1 /* SPDX-License-Identifier: BSD-3-Clause
3 * Copyright (c) 2007-2018 Solarflare Communications Inc.
11 __checkReturn efx_rc_t
15 __out efx_family_t *efp,
16 __out unsigned int *membarp)
18 if (venid == EFX_PCI_VENID_SFC) {
21 case EFX_PCI_DEVID_SIENA_F1_UNINIT:
23 * Hardware default for PF0 of uninitialised Siena.
24 * manftest must be able to cope with this device id.
26 case EFX_PCI_DEVID_BETHPAGE:
27 case EFX_PCI_DEVID_SIENA:
28 *efp = EFX_FAMILY_SIENA;
29 *membarp = EFX_MEM_BAR_SIENA;
31 #endif /* EFSYS_OPT_SIENA */
33 #if EFSYS_OPT_HUNTINGTON
34 case EFX_PCI_DEVID_HUNTINGTON_PF_UNINIT:
36 * Hardware default for PF0 of uninitialised Huntington.
37 * manftest must be able to cope with this device id.
39 case EFX_PCI_DEVID_FARMINGDALE:
40 case EFX_PCI_DEVID_GREENPORT:
41 *efp = EFX_FAMILY_HUNTINGTON;
42 *membarp = EFX_MEM_BAR_HUNTINGTON_PF;
45 case EFX_PCI_DEVID_FARMINGDALE_VF:
46 case EFX_PCI_DEVID_GREENPORT_VF:
47 *efp = EFX_FAMILY_HUNTINGTON;
48 *membarp = EFX_MEM_BAR_HUNTINGTON_VF;
50 #endif /* EFSYS_OPT_HUNTINGTON */
53 case EFX_PCI_DEVID_MEDFORD_PF_UNINIT:
55 * Hardware default for PF0 of uninitialised Medford.
56 * manftest must be able to cope with this device id.
58 case EFX_PCI_DEVID_MEDFORD:
59 *efp = EFX_FAMILY_MEDFORD;
60 *membarp = EFX_MEM_BAR_MEDFORD_PF;
63 case EFX_PCI_DEVID_MEDFORD_VF:
64 *efp = EFX_FAMILY_MEDFORD;
65 *membarp = EFX_MEM_BAR_MEDFORD_VF;
67 #endif /* EFSYS_OPT_MEDFORD */
69 #if EFSYS_OPT_MEDFORD2
70 case EFX_PCI_DEVID_MEDFORD2_PF_UNINIT:
72 * Hardware default for PF0 of uninitialised Medford2.
73 * manftest must be able to cope with this device id.
75 case EFX_PCI_DEVID_MEDFORD2:
76 case EFX_PCI_DEVID_MEDFORD2_VF:
77 *efp = EFX_FAMILY_MEDFORD2;
78 *membarp = EFX_MEM_BAR_MEDFORD2;
80 #endif /* EFSYS_OPT_MEDFORD2 */
82 case EFX_PCI_DEVID_FALCON: /* Obsolete, not supported */
88 *efp = EFX_FAMILY_INVALID;
95 static const efx_nic_ops_t __efx_nic_siena_ops = {
96 siena_nic_probe, /* eno_probe */
97 NULL, /* eno_board_cfg */
98 NULL, /* eno_set_drv_limits */
99 siena_nic_reset, /* eno_reset */
100 siena_nic_init, /* eno_init */
101 NULL, /* eno_get_vi_pool */
102 NULL, /* eno_get_bar_region */
103 NULL, /* eno_hw_unavailable */
104 NULL, /* eno_set_hw_unavailable */
106 siena_nic_register_test, /* eno_register_test */
107 #endif /* EFSYS_OPT_DIAG */
108 siena_nic_fini, /* eno_fini */
109 siena_nic_unprobe, /* eno_unprobe */
112 #endif /* EFSYS_OPT_SIENA */
114 #if EFSYS_OPT_HUNTINGTON
116 static const efx_nic_ops_t __efx_nic_hunt_ops = {
117 ef10_nic_probe, /* eno_probe */
118 hunt_board_cfg, /* eno_board_cfg */
119 ef10_nic_set_drv_limits, /* eno_set_drv_limits */
120 ef10_nic_reset, /* eno_reset */
121 ef10_nic_init, /* eno_init */
122 ef10_nic_get_vi_pool, /* eno_get_vi_pool */
123 ef10_nic_get_bar_region, /* eno_get_bar_region */
124 ef10_nic_hw_unavailable, /* eno_hw_unavailable */
125 ef10_nic_set_hw_unavailable, /* eno_set_hw_unavailable */
127 ef10_nic_register_test, /* eno_register_test */
128 #endif /* EFSYS_OPT_DIAG */
129 ef10_nic_fini, /* eno_fini */
130 ef10_nic_unprobe, /* eno_unprobe */
133 #endif /* EFSYS_OPT_HUNTINGTON */
135 #if EFSYS_OPT_MEDFORD
137 static const efx_nic_ops_t __efx_nic_medford_ops = {
138 ef10_nic_probe, /* eno_probe */
139 medford_board_cfg, /* eno_board_cfg */
140 ef10_nic_set_drv_limits, /* eno_set_drv_limits */
141 ef10_nic_reset, /* eno_reset */
142 ef10_nic_init, /* eno_init */
143 ef10_nic_get_vi_pool, /* eno_get_vi_pool */
144 ef10_nic_get_bar_region, /* eno_get_bar_region */
145 ef10_nic_hw_unavailable, /* eno_hw_unavailable */
146 ef10_nic_set_hw_unavailable, /* eno_set_hw_unavailable */
148 ef10_nic_register_test, /* eno_register_test */
149 #endif /* EFSYS_OPT_DIAG */
150 ef10_nic_fini, /* eno_fini */
151 ef10_nic_unprobe, /* eno_unprobe */
154 #endif /* EFSYS_OPT_MEDFORD */
156 #if EFSYS_OPT_MEDFORD2
158 static const efx_nic_ops_t __efx_nic_medford2_ops = {
159 ef10_nic_probe, /* eno_probe */
160 medford2_board_cfg, /* eno_board_cfg */
161 ef10_nic_set_drv_limits, /* eno_set_drv_limits */
162 ef10_nic_reset, /* eno_reset */
163 ef10_nic_init, /* eno_init */
164 ef10_nic_get_vi_pool, /* eno_get_vi_pool */
165 ef10_nic_get_bar_region, /* eno_get_bar_region */
166 ef10_nic_hw_unavailable, /* eno_hw_unavailable */
167 ef10_nic_set_hw_unavailable, /* eno_set_hw_unavailable */
169 ef10_nic_register_test, /* eno_register_test */
170 #endif /* EFSYS_OPT_DIAG */
171 ef10_nic_fini, /* eno_fini */
172 ef10_nic_unprobe, /* eno_unprobe */
175 #endif /* EFSYS_OPT_MEDFORD2 */
178 __checkReturn efx_rc_t
180 __in efx_family_t family,
181 __in efsys_identifier_t *esip,
182 __in efsys_bar_t *esbp,
183 __in efsys_lock_t *eslp,
184 __deref_out efx_nic_t **enpp)
189 EFSYS_ASSERT3U(family, >, EFX_FAMILY_INVALID);
190 EFSYS_ASSERT3U(family, <, EFX_FAMILY_NTYPES);
192 /* Allocate a NIC object */
193 EFSYS_KMEM_ALLOC(esip, sizeof (efx_nic_t), enp);
200 enp->en_magic = EFX_NIC_MAGIC;
204 case EFX_FAMILY_SIENA:
205 enp->en_enop = &__efx_nic_siena_ops;
208 EFX_FEATURE_LFSR_HASH_INSERT |
209 EFX_FEATURE_LINK_EVENTS |
210 EFX_FEATURE_PERIODIC_MAC_STATS |
212 EFX_FEATURE_LOOKAHEAD_SPLIT |
213 EFX_FEATURE_MAC_HEADER_FILTERS |
214 EFX_FEATURE_TX_SRC_FILTERS;
216 #endif /* EFSYS_OPT_SIENA */
218 #if EFSYS_OPT_HUNTINGTON
219 case EFX_FAMILY_HUNTINGTON:
220 enp->en_enop = &__efx_nic_hunt_ops;
223 EFX_FEATURE_LINK_EVENTS |
224 EFX_FEATURE_PERIODIC_MAC_STATS |
226 EFX_FEATURE_MAC_HEADER_FILTERS |
227 EFX_FEATURE_MCDI_DMA |
228 EFX_FEATURE_PIO_BUFFERS |
229 EFX_FEATURE_FW_ASSISTED_TSO |
230 EFX_FEATURE_FW_ASSISTED_TSO_V2 |
231 EFX_FEATURE_PACKED_STREAM |
232 EFX_FEATURE_TXQ_CKSUM_OP_DESC;
234 #endif /* EFSYS_OPT_HUNTINGTON */
236 #if EFSYS_OPT_MEDFORD
237 case EFX_FAMILY_MEDFORD:
238 enp->en_enop = &__efx_nic_medford_ops;
240 * FW_ASSISTED_TSO omitted as Medford only supports firmware
241 * assisted TSO version 2, not the v1 scheme used on Huntington.
245 EFX_FEATURE_LINK_EVENTS |
246 EFX_FEATURE_PERIODIC_MAC_STATS |
248 EFX_FEATURE_MAC_HEADER_FILTERS |
249 EFX_FEATURE_MCDI_DMA |
250 EFX_FEATURE_PIO_BUFFERS |
251 EFX_FEATURE_FW_ASSISTED_TSO_V2 |
252 EFX_FEATURE_PACKED_STREAM |
253 EFX_FEATURE_TXQ_CKSUM_OP_DESC;
255 #endif /* EFSYS_OPT_MEDFORD */
257 #if EFSYS_OPT_MEDFORD2
258 case EFX_FAMILY_MEDFORD2:
259 enp->en_enop = &__efx_nic_medford2_ops;
262 EFX_FEATURE_LINK_EVENTS |
263 EFX_FEATURE_PERIODIC_MAC_STATS |
265 EFX_FEATURE_MAC_HEADER_FILTERS |
266 EFX_FEATURE_MCDI_DMA |
267 EFX_FEATURE_PIO_BUFFERS |
268 EFX_FEATURE_FW_ASSISTED_TSO_V2 |
269 EFX_FEATURE_PACKED_STREAM |
270 EFX_FEATURE_TXQ_CKSUM_OP_DESC;
272 #endif /* EFSYS_OPT_MEDFORD2 */
279 enp->en_family = family;
293 /* Free the NIC object */
294 EFSYS_KMEM_FREE(esip, sizeof (efx_nic_t), enp);
297 EFSYS_PROBE1(fail1, efx_rc_t, rc);
302 __checkReturn efx_rc_t
305 __in efx_fw_variant_t efv)
307 const efx_nic_ops_t *enop;
310 EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
312 EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_MCDI);
313 #endif /* EFSYS_OPT_MCDI */
314 EFSYS_ASSERT(!(enp->en_mod_flags & EFX_MOD_PROBE));
316 /* Ensure FW variant codes match with MC_CMD_FW codes */
317 EFX_STATIC_ASSERT(EFX_FW_VARIANT_FULL_FEATURED ==
318 MC_CMD_FW_FULL_FEATURED);
319 EFX_STATIC_ASSERT(EFX_FW_VARIANT_LOW_LATENCY ==
320 MC_CMD_FW_LOW_LATENCY);
321 EFX_STATIC_ASSERT(EFX_FW_VARIANT_PACKED_STREAM ==
322 MC_CMD_FW_PACKED_STREAM);
323 EFX_STATIC_ASSERT(EFX_FW_VARIANT_HIGH_TX_RATE ==
324 MC_CMD_FW_HIGH_TX_RATE);
325 EFX_STATIC_ASSERT(EFX_FW_VARIANT_PACKED_STREAM_HASH_MODE_1 ==
326 MC_CMD_FW_PACKED_STREAM_HASH_MODE_1);
327 EFX_STATIC_ASSERT(EFX_FW_VARIANT_RULES_ENGINE ==
328 MC_CMD_FW_RULES_ENGINE);
329 EFX_STATIC_ASSERT(EFX_FW_VARIANT_DPDK ==
331 EFX_STATIC_ASSERT(EFX_FW_VARIANT_DONT_CARE ==
332 (int)MC_CMD_FW_DONT_CARE);
337 if ((rc = enop->eno_probe(enp)) != 0)
340 if ((rc = efx_phy_probe(enp)) != 0)
343 enp->en_mod_flags |= EFX_MOD_PROBE;
350 enop->eno_unprobe(enp);
353 EFSYS_PROBE1(fail1, efx_rc_t, rc);
358 __checkReturn efx_rc_t
359 efx_nic_set_drv_limits(
360 __inout efx_nic_t *enp,
361 __in efx_drv_limits_t *edlp)
363 const efx_nic_ops_t *enop = enp->en_enop;
366 EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
367 EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PROBE);
369 if (enop->eno_set_drv_limits != NULL) {
370 if ((rc = enop->eno_set_drv_limits(enp, edlp)) != 0)
377 EFSYS_PROBE1(fail1, efx_rc_t, rc);
382 __checkReturn efx_rc_t
383 efx_nic_set_drv_version(
384 __inout efx_nic_t *enp,
385 __in_ecount(length) char const *verp,
390 EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
391 EFSYS_ASSERT(!(enp->en_mod_flags & EFX_MOD_PROBE));
394 * length is the string content length in bytes.
395 * Accept any content which fits into the version
396 * buffer, excluding the last byte. This is reserved
397 * for an appended NUL terminator.
399 if (length >= sizeof (enp->en_drv_version)) {
404 (void) memset(enp->en_drv_version, 0,
405 sizeof (enp->en_drv_version));
406 memcpy(enp->en_drv_version, verp, length);
411 EFSYS_PROBE1(fail1, efx_rc_t, rc);
417 __checkReturn efx_rc_t
418 efx_nic_get_bar_region(
420 __in efx_nic_region_t region,
421 __out uint32_t *offsetp,
424 const efx_nic_ops_t *enop = enp->en_enop;
427 EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
428 EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PROBE);
429 EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_NIC);
431 if (enop->eno_get_bar_region == NULL) {
435 if ((rc = (enop->eno_get_bar_region)(enp,
436 region, offsetp, sizep)) != 0) {
446 EFSYS_PROBE1(fail1, efx_rc_t, rc);
452 __checkReturn efx_rc_t
455 __out uint32_t *evq_countp,
456 __out uint32_t *rxq_countp,
457 __out uint32_t *txq_countp)
459 const efx_nic_ops_t *enop = enp->en_enop;
460 efx_nic_cfg_t *encp = &enp->en_nic_cfg;
463 EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
464 EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PROBE);
465 EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_NIC);
467 if (enop->eno_get_vi_pool != NULL) {
468 uint32_t vi_count = 0;
470 if ((rc = (enop->eno_get_vi_pool)(enp, &vi_count)) != 0)
473 *evq_countp = vi_count;
474 *rxq_countp = vi_count;
475 *txq_countp = vi_count;
477 /* Use NIC limits as default value */
478 *evq_countp = encp->enc_evq_limit;
479 *rxq_countp = encp->enc_rxq_limit;
480 *txq_countp = encp->enc_txq_limit;
486 EFSYS_PROBE1(fail1, efx_rc_t, rc);
492 __checkReturn efx_rc_t
496 const efx_nic_ops_t *enop = enp->en_enop;
499 EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
500 EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PROBE);
502 if (enp->en_mod_flags & EFX_MOD_NIC) {
507 if ((rc = enop->eno_init(enp)) != 0)
510 enp->en_mod_flags |= EFX_MOD_NIC;
517 EFSYS_PROBE1(fail1, efx_rc_t, rc);
526 const efx_nic_ops_t *enop = enp->en_enop;
528 EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
529 EFSYS_ASSERT(enp->en_mod_flags & EFX_MOD_PROBE);
530 EFSYS_ASSERT(enp->en_mod_flags & EFX_MOD_NIC);
531 EFSYS_ASSERT(!(enp->en_mod_flags & EFX_MOD_INTR));
532 EFSYS_ASSERT(!(enp->en_mod_flags & EFX_MOD_EV));
533 EFSYS_ASSERT(!(enp->en_mod_flags & EFX_MOD_RX));
534 EFSYS_ASSERT(!(enp->en_mod_flags & EFX_MOD_TX));
538 enp->en_mod_flags &= ~EFX_MOD_NIC;
545 const efx_nic_ops_t *enop = enp->en_enop;
547 EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
549 EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_MCDI);
550 #endif /* EFSYS_OPT_MCDI */
551 EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PROBE);
552 EFSYS_ASSERT(!(enp->en_mod_flags & EFX_MOD_NIC));
553 EFSYS_ASSERT(!(enp->en_mod_flags & EFX_MOD_INTR));
554 EFSYS_ASSERT(!(enp->en_mod_flags & EFX_MOD_EV));
555 EFSYS_ASSERT(!(enp->en_mod_flags & EFX_MOD_RX));
556 EFSYS_ASSERT(!(enp->en_mod_flags & EFX_MOD_TX));
558 efx_phy_unprobe(enp);
560 enop->eno_unprobe(enp);
562 enp->en_mod_flags &= ~EFX_MOD_PROBE;
569 efsys_identifier_t *esip = enp->en_esip;
571 EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
572 EFSYS_ASSERT3U(enp->en_mod_flags, ==, 0);
574 enp->en_family = EFX_FAMILY_INVALID;
583 /* Free the NIC object */
584 EFSYS_KMEM_FREE(esip, sizeof (efx_nic_t), enp);
587 __checkReturn efx_rc_t
591 const efx_nic_ops_t *enop = enp->en_enop;
592 unsigned int mod_flags;
595 EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
596 EFSYS_ASSERT(enp->en_mod_flags & EFX_MOD_PROBE);
598 * All modules except the MCDI, PROBE, NVRAM, VPD, MON, TUNNEL
599 * (which we do not reset here) must have been shut down or never
602 * A rule of thumb here is: If the controller or MC reboots, is *any*
603 * state lost. If it's lost and needs reapplying, then the module
604 * *must* not be initialised during the reset.
606 mod_flags = enp->en_mod_flags;
607 mod_flags &= ~(EFX_MOD_MCDI | EFX_MOD_PROBE | EFX_MOD_NVRAM |
608 EFX_MOD_VPD | EFX_MOD_MON);
610 mod_flags &= ~EFX_MOD_TUNNEL;
611 #endif /* EFSYS_OPT_TUNNEL */
612 EFSYS_ASSERT3U(mod_flags, ==, 0);
613 if (mod_flags != 0) {
618 if ((rc = enop->eno_reset(enp)) != 0)
626 EFSYS_PROBE1(fail1, efx_rc_t, rc);
631 const efx_nic_cfg_t *
633 __in const efx_nic_t *enp)
635 EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
636 EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PROBE);
638 return (&(enp->en_nic_cfg));
641 __checkReturn efx_rc_t
642 efx_nic_get_fw_version(
644 __out efx_nic_fw_info_t *enfip)
646 uint16_t mc_fw_version[4];
654 EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_MCDI);
655 EFSYS_ASSERT3U(enp->en_features, &, EFX_FEATURE_MCDI);
657 /* Ensure RXDP_FW_ID codes match with MC_CMD_GET_CAPABILITIES codes */
658 EFX_STATIC_ASSERT(EFX_RXDP_FULL_FEATURED_FW_ID ==
659 MC_CMD_GET_CAPABILITIES_OUT_RXDP);
660 EFX_STATIC_ASSERT(EFX_RXDP_LOW_LATENCY_FW_ID ==
661 MC_CMD_GET_CAPABILITIES_OUT_RXDP_LOW_LATENCY);
662 EFX_STATIC_ASSERT(EFX_RXDP_PACKED_STREAM_FW_ID ==
663 MC_CMD_GET_CAPABILITIES_OUT_RXDP_PACKED_STREAM);
664 EFX_STATIC_ASSERT(EFX_RXDP_RULES_ENGINE_FW_ID ==
665 MC_CMD_GET_CAPABILITIES_OUT_RXDP_RULES_ENGINE);
666 EFX_STATIC_ASSERT(EFX_RXDP_DPDK_FW_ID ==
667 MC_CMD_GET_CAPABILITIES_OUT_RXDP_DPDK);
669 rc = efx_mcdi_version(enp, mc_fw_version, NULL, NULL);
673 rc = efx_mcdi_get_capabilities(enp, NULL,
674 &enfip->enfi_rx_dpcpu_fw_id,
675 &enfip->enfi_tx_dpcpu_fw_id,
678 enfip->enfi_dpcpu_fw_ids_valid = B_TRUE;
679 } else if (rc == ENOTSUP) {
680 enfip->enfi_dpcpu_fw_ids_valid = B_FALSE;
681 enfip->enfi_rx_dpcpu_fw_id = 0;
682 enfip->enfi_tx_dpcpu_fw_id = 0;
687 memcpy(enfip->enfi_mc_fw_version, mc_fw_version,
688 sizeof (mc_fw_version));
697 EFSYS_PROBE1(fail1, efx_rc_t, rc);
702 __checkReturn boolean_t
703 efx_nic_hw_unavailable(
706 const efx_nic_ops_t *enop = enp->en_enop;
708 EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
709 /* NOTE: can be used by MCDI before NIC probe */
711 if (enop->eno_hw_unavailable != NULL) {
712 if ((enop->eno_hw_unavailable)(enp) != B_FALSE)
723 efx_nic_set_hw_unavailable(
726 const efx_nic_ops_t *enop = enp->en_enop;
728 EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
730 if (enop->eno_set_hw_unavailable != NULL)
731 enop->eno_set_hw_unavailable(enp);
737 __checkReturn efx_rc_t
738 efx_nic_register_test(
741 const efx_nic_ops_t *enop = enp->en_enop;
744 EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
745 EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PROBE);
746 EFSYS_ASSERT(!(enp->en_mod_flags & EFX_MOD_NIC));
748 if ((rc = enop->eno_register_test(enp)) != 0)
754 EFSYS_PROBE1(fail1, efx_rc_t, rc);
759 #endif /* EFSYS_OPT_DIAG */
761 #if EFSYS_OPT_LOOPBACK
765 __in efx_loopback_kind_t loopback_kind,
766 __out efx_qword_t *maskp)
770 EFSYS_ASSERT3U(loopback_kind, <, EFX_LOOPBACK_NKINDS);
771 EFSYS_ASSERT(maskp != NULL);
773 /* Assert the MC_CMD_LOOPBACK and EFX_LOOPBACK namespaces agree */
774 #define LOOPBACK_CHECK(_mcdi, _efx) \
775 EFX_STATIC_ASSERT(MC_CMD_LOOPBACK_##_mcdi == EFX_LOOPBACK_##_efx)
777 LOOPBACK_CHECK(NONE, OFF);
778 LOOPBACK_CHECK(DATA, DATA);
779 LOOPBACK_CHECK(GMAC, GMAC);
780 LOOPBACK_CHECK(XGMII, XGMII);
781 LOOPBACK_CHECK(XGXS, XGXS);
782 LOOPBACK_CHECK(XAUI, XAUI);
783 LOOPBACK_CHECK(GMII, GMII);
784 LOOPBACK_CHECK(SGMII, SGMII);
785 LOOPBACK_CHECK(XGBR, XGBR);
786 LOOPBACK_CHECK(XFI, XFI);
787 LOOPBACK_CHECK(XAUI_FAR, XAUI_FAR);
788 LOOPBACK_CHECK(GMII_FAR, GMII_FAR);
789 LOOPBACK_CHECK(SGMII_FAR, SGMII_FAR);
790 LOOPBACK_CHECK(XFI_FAR, XFI_FAR);
791 LOOPBACK_CHECK(GPHY, GPHY);
792 LOOPBACK_CHECK(PHYXS, PHY_XS);
793 LOOPBACK_CHECK(PCS, PCS);
794 LOOPBACK_CHECK(PMAPMD, PMA_PMD);
795 LOOPBACK_CHECK(XPORT, XPORT);
796 LOOPBACK_CHECK(XGMII_WS, XGMII_WS);
797 LOOPBACK_CHECK(XAUI_WS, XAUI_WS);
798 LOOPBACK_CHECK(XAUI_WS_FAR, XAUI_WS_FAR);
799 LOOPBACK_CHECK(XAUI_WS_NEAR, XAUI_WS_NEAR);
800 LOOPBACK_CHECK(GMII_WS, GMII_WS);
801 LOOPBACK_CHECK(XFI_WS, XFI_WS);
802 LOOPBACK_CHECK(XFI_WS_FAR, XFI_WS_FAR);
803 LOOPBACK_CHECK(PHYXS_WS, PHYXS_WS);
804 LOOPBACK_CHECK(PMA_INT, PMA_INT);
805 LOOPBACK_CHECK(SD_NEAR, SD_NEAR);
806 LOOPBACK_CHECK(SD_FAR, SD_FAR);
807 LOOPBACK_CHECK(PMA_INT_WS, PMA_INT_WS);
808 LOOPBACK_CHECK(SD_FEP2_WS, SD_FEP2_WS);
809 LOOPBACK_CHECK(SD_FEP1_5_WS, SD_FEP1_5_WS);
810 LOOPBACK_CHECK(SD_FEP_WS, SD_FEP_WS);
811 LOOPBACK_CHECK(SD_FES_WS, SD_FES_WS);
812 LOOPBACK_CHECK(AOE_INT_NEAR, AOE_INT_NEAR);
813 LOOPBACK_CHECK(DATA_WS, DATA_WS);
814 LOOPBACK_CHECK(FORCE_EXT_LINK, FORCE_EXT_LINK);
815 #undef LOOPBACK_CHECK
817 /* Build bitmask of possible loopback types */
818 EFX_ZERO_QWORD(mask);
820 if ((loopback_kind == EFX_LOOPBACK_KIND_OFF) ||
821 (loopback_kind == EFX_LOOPBACK_KIND_ALL)) {
822 EFX_SET_QWORD_BIT(mask, EFX_LOOPBACK_OFF);
825 if ((loopback_kind == EFX_LOOPBACK_KIND_MAC) ||
826 (loopback_kind == EFX_LOOPBACK_KIND_ALL)) {
828 * The "MAC" grouping has historically been used by drivers to
829 * mean loopbacks supported by on-chip hardware. Keep that
830 * meaning here, and include on-chip PHY layer loopbacks.
832 EFX_SET_QWORD_BIT(mask, EFX_LOOPBACK_DATA);
833 EFX_SET_QWORD_BIT(mask, EFX_LOOPBACK_GMAC);
834 EFX_SET_QWORD_BIT(mask, EFX_LOOPBACK_XGMII);
835 EFX_SET_QWORD_BIT(mask, EFX_LOOPBACK_XGXS);
836 EFX_SET_QWORD_BIT(mask, EFX_LOOPBACK_XAUI);
837 EFX_SET_QWORD_BIT(mask, EFX_LOOPBACK_GMII);
838 EFX_SET_QWORD_BIT(mask, EFX_LOOPBACK_SGMII);
839 EFX_SET_QWORD_BIT(mask, EFX_LOOPBACK_XGBR);
840 EFX_SET_QWORD_BIT(mask, EFX_LOOPBACK_XFI);
841 EFX_SET_QWORD_BIT(mask, EFX_LOOPBACK_XAUI_FAR);
842 EFX_SET_QWORD_BIT(mask, EFX_LOOPBACK_GMII_FAR);
843 EFX_SET_QWORD_BIT(mask, EFX_LOOPBACK_SGMII_FAR);
844 EFX_SET_QWORD_BIT(mask, EFX_LOOPBACK_XFI_FAR);
845 EFX_SET_QWORD_BIT(mask, EFX_LOOPBACK_PMA_INT);
846 EFX_SET_QWORD_BIT(mask, EFX_LOOPBACK_SD_NEAR);
847 EFX_SET_QWORD_BIT(mask, EFX_LOOPBACK_SD_FAR);
850 if ((loopback_kind == EFX_LOOPBACK_KIND_PHY) ||
851 (loopback_kind == EFX_LOOPBACK_KIND_ALL)) {
853 * The "PHY" grouping has historically been used by drivers to
854 * mean loopbacks supported by off-chip hardware. Keep that
857 EFX_SET_QWORD_BIT(mask, EFX_LOOPBACK_GPHY);
858 EFX_SET_QWORD_BIT(mask, EFX_LOOPBACK_PHY_XS);
859 EFX_SET_QWORD_BIT(mask, EFX_LOOPBACK_PCS);
860 EFX_SET_QWORD_BIT(mask, EFX_LOOPBACK_PMA_PMD);
866 __checkReturn efx_rc_t
867 efx_mcdi_get_loopback_modes(
870 efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
872 EFX_MCDI_DECLARE_BUF(payload, MC_CMD_GET_LOOPBACK_MODES_IN_LEN,
873 MC_CMD_GET_LOOPBACK_MODES_OUT_V2_LEN);
878 req.emr_cmd = MC_CMD_GET_LOOPBACK_MODES;
879 req.emr_in_buf = payload;
880 req.emr_in_length = MC_CMD_GET_LOOPBACK_MODES_IN_LEN;
881 req.emr_out_buf = payload;
882 req.emr_out_length = MC_CMD_GET_LOOPBACK_MODES_OUT_V2_LEN;
884 efx_mcdi_execute(enp, &req);
886 if (req.emr_rc != 0) {
891 if (req.emr_out_length_used <
892 MC_CMD_GET_LOOPBACK_MODES_OUT_SUGGESTED_OFST +
893 MC_CMD_GET_LOOPBACK_MODES_OUT_SUGGESTED_LEN) {
899 * We assert the MC_CMD_LOOPBACK and EFX_LOOPBACK namespaces agree
900 * in efx_loopback_mask() and in siena_phy.c:siena_phy_get_link().
902 efx_loopback_mask(EFX_LOOPBACK_KIND_ALL, &mask);
905 *MCDI_OUT2(req, efx_qword_t, GET_LOOPBACK_MODES_OUT_SUGGESTED));
907 modes = *MCDI_OUT2(req, efx_qword_t, GET_LOOPBACK_MODES_OUT_100M);
908 EFX_AND_QWORD(modes, mask);
909 encp->enc_loopback_types[EFX_LINK_100FDX] = modes;
911 modes = *MCDI_OUT2(req, efx_qword_t, GET_LOOPBACK_MODES_OUT_1G);
912 EFX_AND_QWORD(modes, mask);
913 encp->enc_loopback_types[EFX_LINK_1000FDX] = modes;
915 modes = *MCDI_OUT2(req, efx_qword_t, GET_LOOPBACK_MODES_OUT_10G);
916 EFX_AND_QWORD(modes, mask);
917 encp->enc_loopback_types[EFX_LINK_10000FDX] = modes;
919 if (req.emr_out_length_used >=
920 MC_CMD_GET_LOOPBACK_MODES_OUT_40G_OFST +
921 MC_CMD_GET_LOOPBACK_MODES_OUT_40G_LEN) {
922 /* Response includes 40G loopback modes */
923 modes = *MCDI_OUT2(req, efx_qword_t,
924 GET_LOOPBACK_MODES_OUT_40G);
925 EFX_AND_QWORD(modes, mask);
926 encp->enc_loopback_types[EFX_LINK_40000FDX] = modes;
929 if (req.emr_out_length_used >=
930 MC_CMD_GET_LOOPBACK_MODES_OUT_V2_25G_OFST +
931 MC_CMD_GET_LOOPBACK_MODES_OUT_V2_25G_LEN) {
932 /* Response includes 25G loopback modes */
933 modes = *MCDI_OUT2(req, efx_qword_t,
934 GET_LOOPBACK_MODES_OUT_V2_25G);
935 EFX_AND_QWORD(modes, mask);
936 encp->enc_loopback_types[EFX_LINK_25000FDX] = modes;
939 if (req.emr_out_length_used >=
940 MC_CMD_GET_LOOPBACK_MODES_OUT_V2_50G_OFST +
941 MC_CMD_GET_LOOPBACK_MODES_OUT_V2_50G_LEN) {
942 /* Response includes 50G loopback modes */
943 modes = *MCDI_OUT2(req, efx_qword_t,
944 GET_LOOPBACK_MODES_OUT_V2_50G);
945 EFX_AND_QWORD(modes, mask);
946 encp->enc_loopback_types[EFX_LINK_50000FDX] = modes;
949 if (req.emr_out_length_used >=
950 MC_CMD_GET_LOOPBACK_MODES_OUT_V2_100G_OFST +
951 MC_CMD_GET_LOOPBACK_MODES_OUT_V2_100G_LEN) {
952 /* Response includes 100G loopback modes */
953 modes = *MCDI_OUT2(req, efx_qword_t,
954 GET_LOOPBACK_MODES_OUT_V2_100G);
955 EFX_AND_QWORD(modes, mask);
956 encp->enc_loopback_types[EFX_LINK_100000FDX] = modes;
959 EFX_ZERO_QWORD(modes);
960 EFX_SET_QWORD_BIT(modes, EFX_LOOPBACK_OFF);
961 EFX_OR_QWORD(modes, encp->enc_loopback_types[EFX_LINK_100FDX]);
962 EFX_OR_QWORD(modes, encp->enc_loopback_types[EFX_LINK_1000FDX]);
963 EFX_OR_QWORD(modes, encp->enc_loopback_types[EFX_LINK_10000FDX]);
964 EFX_OR_QWORD(modes, encp->enc_loopback_types[EFX_LINK_40000FDX]);
965 EFX_OR_QWORD(modes, encp->enc_loopback_types[EFX_LINK_25000FDX]);
966 EFX_OR_QWORD(modes, encp->enc_loopback_types[EFX_LINK_50000FDX]);
967 EFX_OR_QWORD(modes, encp->enc_loopback_types[EFX_LINK_100000FDX]);
968 encp->enc_loopback_types[EFX_LINK_UNKNOWN] = modes;
975 EFSYS_PROBE1(fail1, efx_rc_t, rc);
980 #endif /* EFSYS_OPT_LOOPBACK */
982 __checkReturn efx_rc_t
983 efx_nic_calculate_pcie_link_bandwidth(
984 __in uint32_t pcie_link_width,
985 __in uint32_t pcie_link_gen,
986 __out uint32_t *bandwidth_mbpsp)
988 uint32_t lane_bandwidth;
989 uint32_t total_bandwidth;
992 if ((pcie_link_width == 0) || (pcie_link_width > 16) ||
993 !ISP2(pcie_link_width)) {
998 switch (pcie_link_gen) {
999 case EFX_PCIE_LINK_SPEED_GEN1:
1000 /* 2.5 Gb/s raw bandwidth with 8b/10b encoding */
1001 lane_bandwidth = 2000;
1003 case EFX_PCIE_LINK_SPEED_GEN2:
1004 /* 5.0 Gb/s raw bandwidth with 8b/10b encoding */
1005 lane_bandwidth = 4000;
1007 case EFX_PCIE_LINK_SPEED_GEN3:
1008 /* 8.0 Gb/s raw bandwidth with 128b/130b encoding */
1009 lane_bandwidth = 7877;
1016 total_bandwidth = lane_bandwidth * pcie_link_width;
1017 *bandwidth_mbpsp = total_bandwidth;
1024 EFSYS_PROBE1(fail1, efx_rc_t, rc);
1029 #if EFSYS_OPT_FW_SUBVARIANT_AWARE
1031 __checkReturn efx_rc_t
1032 efx_nic_get_fw_subvariant(
1033 __in efx_nic_t *enp,
1034 __out efx_nic_fw_subvariant_t *subvariantp)
1039 rc = efx_mcdi_get_nic_global(enp,
1040 MC_CMD_SET_NIC_GLOBAL_IN_FIRMWARE_SUBVARIANT, &value);
1044 /* Mapping is not required since values match MCDI */
1045 EFX_STATIC_ASSERT(EFX_NIC_FW_SUBVARIANT_DEFAULT ==
1046 MC_CMD_SET_NIC_GLOBAL_IN_FW_SUBVARIANT_DEFAULT);
1047 EFX_STATIC_ASSERT(EFX_NIC_FW_SUBVARIANT_NO_TX_CSUM ==
1048 MC_CMD_SET_NIC_GLOBAL_IN_FW_SUBVARIANT_NO_TX_CSUM);
1051 case MC_CMD_SET_NIC_GLOBAL_IN_FW_SUBVARIANT_DEFAULT:
1052 case MC_CMD_SET_NIC_GLOBAL_IN_FW_SUBVARIANT_NO_TX_CSUM:
1053 *subvariantp = value;
1066 EFSYS_PROBE1(fail1, efx_rc_t, rc);
1071 __checkReturn efx_rc_t
1072 efx_nic_set_fw_subvariant(
1073 __in efx_nic_t *enp,
1074 __in efx_nic_fw_subvariant_t subvariant)
1078 switch (subvariant) {
1079 case EFX_NIC_FW_SUBVARIANT_DEFAULT:
1080 case EFX_NIC_FW_SUBVARIANT_NO_TX_CSUM:
1081 /* Mapping is not required since values match MCDI */
1088 rc = efx_mcdi_set_nic_global(enp,
1089 MC_CMD_SET_NIC_GLOBAL_IN_FIRMWARE_SUBVARIANT, subvariant);
1099 EFSYS_PROBE1(fail1, efx_rc_t, rc);
1104 #endif /* EFSYS_OPT_FW_SUBVARIANT_AWARE */
1106 __checkReturn efx_rc_t
1107 efx_nic_check_pcie_link_speed(
1108 __in efx_nic_t *enp,
1109 __in uint32_t pcie_link_width,
1110 __in uint32_t pcie_link_gen,
1111 __out efx_pcie_link_performance_t *resultp)
1113 efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
1115 efx_pcie_link_performance_t result;
1118 if ((encp->enc_required_pcie_bandwidth_mbps == 0) ||
1119 (pcie_link_width == 0) || (pcie_link_width == 32) ||
1120 (pcie_link_gen == 0)) {
1122 * No usable info on what is required and/or in use. In virtual
1123 * machines, sometimes the PCIe link width is reported as 0 or
1124 * 32, or the speed as 0.
1126 result = EFX_PCIE_LINK_PERFORMANCE_UNKNOWN_BANDWIDTH;
1130 /* Calculate the available bandwidth in megabits per second */
1131 rc = efx_nic_calculate_pcie_link_bandwidth(pcie_link_width,
1132 pcie_link_gen, &bandwidth);
1136 if (bandwidth < encp->enc_required_pcie_bandwidth_mbps) {
1137 result = EFX_PCIE_LINK_PERFORMANCE_SUBOPTIMAL_BANDWIDTH;
1138 } else if (pcie_link_gen < encp->enc_max_pcie_link_gen) {
1139 /* The link provides enough bandwidth but not optimal latency */
1140 result = EFX_PCIE_LINK_PERFORMANCE_SUBOPTIMAL_LATENCY;
1142 result = EFX_PCIE_LINK_PERFORMANCE_OPTIMAL;
1151 EFSYS_PROBE1(fail1, efx_rc_t, rc);