net/sfc/base: provide information about supported tunnels
[dpdk.git] / drivers / net / sfc / base / efx.h
index c7108a9..c227546 100644 (file)
@@ -326,6 +326,98 @@ efx_intr_fini(
 
 /* MAC */
 
+#if EFSYS_OPT_MAC_STATS
+
+/* START MKCONFIG GENERATED EfxHeaderMacBlock e323546097fd7c65 */
+typedef enum efx_mac_stat_e {
+       EFX_MAC_RX_OCTETS,
+       EFX_MAC_RX_PKTS,
+       EFX_MAC_RX_UNICST_PKTS,
+       EFX_MAC_RX_MULTICST_PKTS,
+       EFX_MAC_RX_BRDCST_PKTS,
+       EFX_MAC_RX_PAUSE_PKTS,
+       EFX_MAC_RX_LE_64_PKTS,
+       EFX_MAC_RX_65_TO_127_PKTS,
+       EFX_MAC_RX_128_TO_255_PKTS,
+       EFX_MAC_RX_256_TO_511_PKTS,
+       EFX_MAC_RX_512_TO_1023_PKTS,
+       EFX_MAC_RX_1024_TO_15XX_PKTS,
+       EFX_MAC_RX_GE_15XX_PKTS,
+       EFX_MAC_RX_ERRORS,
+       EFX_MAC_RX_FCS_ERRORS,
+       EFX_MAC_RX_DROP_EVENTS,
+       EFX_MAC_RX_FALSE_CARRIER_ERRORS,
+       EFX_MAC_RX_SYMBOL_ERRORS,
+       EFX_MAC_RX_ALIGN_ERRORS,
+       EFX_MAC_RX_INTERNAL_ERRORS,
+       EFX_MAC_RX_JABBER_PKTS,
+       EFX_MAC_RX_LANE0_CHAR_ERR,
+       EFX_MAC_RX_LANE1_CHAR_ERR,
+       EFX_MAC_RX_LANE2_CHAR_ERR,
+       EFX_MAC_RX_LANE3_CHAR_ERR,
+       EFX_MAC_RX_LANE0_DISP_ERR,
+       EFX_MAC_RX_LANE1_DISP_ERR,
+       EFX_MAC_RX_LANE2_DISP_ERR,
+       EFX_MAC_RX_LANE3_DISP_ERR,
+       EFX_MAC_RX_MATCH_FAULT,
+       EFX_MAC_RX_NODESC_DROP_CNT,
+       EFX_MAC_TX_OCTETS,
+       EFX_MAC_TX_PKTS,
+       EFX_MAC_TX_UNICST_PKTS,
+       EFX_MAC_TX_MULTICST_PKTS,
+       EFX_MAC_TX_BRDCST_PKTS,
+       EFX_MAC_TX_PAUSE_PKTS,
+       EFX_MAC_TX_LE_64_PKTS,
+       EFX_MAC_TX_65_TO_127_PKTS,
+       EFX_MAC_TX_128_TO_255_PKTS,
+       EFX_MAC_TX_256_TO_511_PKTS,
+       EFX_MAC_TX_512_TO_1023_PKTS,
+       EFX_MAC_TX_1024_TO_15XX_PKTS,
+       EFX_MAC_TX_GE_15XX_PKTS,
+       EFX_MAC_TX_ERRORS,
+       EFX_MAC_TX_SGL_COL_PKTS,
+       EFX_MAC_TX_MULT_COL_PKTS,
+       EFX_MAC_TX_EX_COL_PKTS,
+       EFX_MAC_TX_LATE_COL_PKTS,
+       EFX_MAC_TX_DEF_PKTS,
+       EFX_MAC_TX_EX_DEF_PKTS,
+       EFX_MAC_PM_TRUNC_BB_OVERFLOW,
+       EFX_MAC_PM_DISCARD_BB_OVERFLOW,
+       EFX_MAC_PM_TRUNC_VFIFO_FULL,
+       EFX_MAC_PM_DISCARD_VFIFO_FULL,
+       EFX_MAC_PM_TRUNC_QBB,
+       EFX_MAC_PM_DISCARD_QBB,
+       EFX_MAC_PM_DISCARD_MAPPING,
+       EFX_MAC_RXDP_Q_DISABLED_PKTS,
+       EFX_MAC_RXDP_DI_DROPPED_PKTS,
+       EFX_MAC_RXDP_STREAMING_PKTS,
+       EFX_MAC_RXDP_HLB_FETCH,
+       EFX_MAC_RXDP_HLB_WAIT,
+       EFX_MAC_VADAPTER_RX_UNICAST_PACKETS,
+       EFX_MAC_VADAPTER_RX_UNICAST_BYTES,
+       EFX_MAC_VADAPTER_RX_MULTICAST_PACKETS,
+       EFX_MAC_VADAPTER_RX_MULTICAST_BYTES,
+       EFX_MAC_VADAPTER_RX_BROADCAST_PACKETS,
+       EFX_MAC_VADAPTER_RX_BROADCAST_BYTES,
+       EFX_MAC_VADAPTER_RX_BAD_PACKETS,
+       EFX_MAC_VADAPTER_RX_BAD_BYTES,
+       EFX_MAC_VADAPTER_RX_OVERFLOW,
+       EFX_MAC_VADAPTER_TX_UNICAST_PACKETS,
+       EFX_MAC_VADAPTER_TX_UNICAST_BYTES,
+       EFX_MAC_VADAPTER_TX_MULTICAST_PACKETS,
+       EFX_MAC_VADAPTER_TX_MULTICAST_BYTES,
+       EFX_MAC_VADAPTER_TX_BROADCAST_PACKETS,
+       EFX_MAC_VADAPTER_TX_BROADCAST_BYTES,
+       EFX_MAC_VADAPTER_TX_BAD_PACKETS,
+       EFX_MAC_VADAPTER_TX_BAD_BYTES,
+       EFX_MAC_VADAPTER_TX_OVERFLOW,
+       EFX_MAC_NSTATS
+} efx_mac_stat_t;
+
+/* END MKCONFIG GENERATED EfxHeaderMacBlock */
+
+#endif /* EFSYS_OPT_MAC_STATS */
+
 typedef enum efx_link_mode_e {
        EFX_LINK_UNKNOWN = 0,
        EFX_LINK_DOWN,
@@ -431,6 +523,80 @@ efx_mac_fcntl_get(
        __out           unsigned int *fcntl_linkp);
 
 
+#if EFSYS_OPT_MAC_STATS
+
+#if EFSYS_OPT_NAMES
+
+extern __checkReturn                   const char *
+efx_mac_stat_name(
+       __in                            efx_nic_t *enp,
+       __in                            unsigned int id);
+
+#endif /* EFSYS_OPT_NAMES */
+
+#define        EFX_MAC_STATS_MASK_BITS_PER_PAGE        (8 * sizeof (uint32_t))
+
+#define        EFX_MAC_STATS_MASK_NPAGES       \
+       (P2ROUNDUP(EFX_MAC_NSTATS, EFX_MAC_STATS_MASK_BITS_PER_PAGE) / \
+           EFX_MAC_STATS_MASK_BITS_PER_PAGE)
+
+/*
+ * Get mask of MAC statistics supported by the hardware.
+ *
+ * If mask_size is insufficient to return the mask, EINVAL error is
+ * returned. EFX_MAC_STATS_MASK_NPAGES multiplied by size of the page
+ * (which is sizeof (uint32_t)) is sufficient.
+ */
+extern __checkReturn                   efx_rc_t
+efx_mac_stats_get_mask(
+       __in                            efx_nic_t *enp,
+       __out_bcount(mask_size)         uint32_t *maskp,
+       __in                            size_t mask_size);
+
+#define        EFX_MAC_STAT_SUPPORTED(_mask, _stat)    \
+       ((_mask)[(_stat) / EFX_MAC_STATS_MASK_BITS_PER_PAGE] &  \
+        (1ULL << ((_stat) & (EFX_MAC_STATS_MASK_BITS_PER_PAGE - 1))))
+
+#define        EFX_MAC_STATS_SIZE 0x400
+
+extern __checkReturn                   efx_rc_t
+efx_mac_stats_clear(
+       __in                            efx_nic_t *enp);
+
+/*
+ * Upload mac statistics supported by the hardware into the given buffer.
+ *
+ * The reference buffer must be at least %EFX_MAC_STATS_SIZE bytes,
+ * and page aligned.
+ *
+ * The hardware will only DMA statistics that it understands (of course).
+ * Drivers should not make any assumptions about which statistics are
+ * supported, especially when the statistics are generated by firmware.
+ *
+ * Thus, drivers should zero this buffer before use, so that not-understood
+ * statistics read back as zero.
+ */
+extern __checkReturn                   efx_rc_t
+efx_mac_stats_upload(
+       __in                            efx_nic_t *enp,
+       __in                            efsys_mem_t *esmp);
+
+extern __checkReturn                   efx_rc_t
+efx_mac_stats_periodic(
+       __in                            efx_nic_t *enp,
+       __in                            efsys_mem_t *esmp,
+       __in                            uint16_t period_ms,
+       __in                            boolean_t events);
+
+extern __checkReturn                   efx_rc_t
+efx_mac_stats_update(
+       __in                            efx_nic_t *enp,
+       __in                            efsys_mem_t *esmp,
+       __inout_ecount(EFX_MAC_NSTATS)  efsys_stat_t *stat,
+       __inout_opt                     uint32_t *generationp);
+
+#endif /* EFSYS_OPT_MAC_STATS */
+
 /* MON */
 
 typedef enum efx_mon_type_e {
@@ -453,6 +619,125 @@ extern    __checkReturn   efx_rc_t
 efx_mon_init(
        __in            efx_nic_t *enp);
 
+#if EFSYS_OPT_MON_STATS
+
+#define        EFX_MON_STATS_PAGE_SIZE 0x100
+#define        EFX_MON_MASK_ELEMENT_SIZE 32
+
+/* START MKCONFIG GENERATED MonitorHeaderStatsBlock 5d4ee5185e419abe */
+typedef enum efx_mon_stat_e {
+       EFX_MON_STAT_2_5V,
+       EFX_MON_STAT_VCCP1,
+       EFX_MON_STAT_VCC,
+       EFX_MON_STAT_5V,
+       EFX_MON_STAT_12V,
+       EFX_MON_STAT_VCCP2,
+       EFX_MON_STAT_EXT_TEMP,
+       EFX_MON_STAT_INT_TEMP,
+       EFX_MON_STAT_AIN1,
+       EFX_MON_STAT_AIN2,
+       EFX_MON_STAT_INT_COOLING,
+       EFX_MON_STAT_EXT_COOLING,
+       EFX_MON_STAT_1V,
+       EFX_MON_STAT_1_2V,
+       EFX_MON_STAT_1_8V,
+       EFX_MON_STAT_3_3V,
+       EFX_MON_STAT_1_2VA,
+       EFX_MON_STAT_VREF,
+       EFX_MON_STAT_VAOE,
+       EFX_MON_STAT_AOE_TEMP,
+       EFX_MON_STAT_PSU_AOE_TEMP,
+       EFX_MON_STAT_PSU_TEMP,
+       EFX_MON_STAT_FAN0,
+       EFX_MON_STAT_FAN1,
+       EFX_MON_STAT_FAN2,
+       EFX_MON_STAT_FAN3,
+       EFX_MON_STAT_FAN4,
+       EFX_MON_STAT_VAOE_IN,
+       EFX_MON_STAT_IAOE,
+       EFX_MON_STAT_IAOE_IN,
+       EFX_MON_STAT_NIC_POWER,
+       EFX_MON_STAT_0_9V,
+       EFX_MON_STAT_I0_9V,
+       EFX_MON_STAT_I1_2V,
+       EFX_MON_STAT_0_9V_ADC,
+       EFX_MON_STAT_INT_TEMP2,
+       EFX_MON_STAT_VREG_TEMP,
+       EFX_MON_STAT_VREG_0_9V_TEMP,
+       EFX_MON_STAT_VREG_1_2V_TEMP,
+       EFX_MON_STAT_INT_VPTAT,
+       EFX_MON_STAT_INT_ADC_TEMP,
+       EFX_MON_STAT_EXT_VPTAT,
+       EFX_MON_STAT_EXT_ADC_TEMP,
+       EFX_MON_STAT_AMBIENT_TEMP,
+       EFX_MON_STAT_AIRFLOW,
+       EFX_MON_STAT_VDD08D_VSS08D_CSR,
+       EFX_MON_STAT_VDD08D_VSS08D_CSR_EXTADC,
+       EFX_MON_STAT_HOTPOINT_TEMP,
+       EFX_MON_STAT_PHY_POWER_SWITCH_PORT0,
+       EFX_MON_STAT_PHY_POWER_SWITCH_PORT1,
+       EFX_MON_STAT_MUM_VCC,
+       EFX_MON_STAT_0V9_A,
+       EFX_MON_STAT_I0V9_A,
+       EFX_MON_STAT_0V9_A_TEMP,
+       EFX_MON_STAT_0V9_B,
+       EFX_MON_STAT_I0V9_B,
+       EFX_MON_STAT_0V9_B_TEMP,
+       EFX_MON_STAT_CCOM_AVREG_1V2_SUPPLY,
+       EFX_MON_STAT_CCOM_AVREG_1V2_SUPPLY_EXT_ADC,
+       EFX_MON_STAT_CCOM_AVREG_1V8_SUPPLY,
+       EFX_MON_STAT_CCOM_AVREG_1V8_SUPPLY_EXT_ADC,
+       EFX_MON_STAT_CONTROLLER_MASTER_VPTAT,
+       EFX_MON_STAT_CONTROLLER_MASTER_INTERNAL_TEMP,
+       EFX_MON_STAT_CONTROLLER_MASTER_VPTAT_EXT_ADC,
+       EFX_MON_STAT_CONTROLLER_MASTER_INTERNAL_TEMP_EXT_ADC,
+       EFX_MON_STAT_CONTROLLER_SLAVE_VPTAT,
+       EFX_MON_STAT_CONTROLLER_SLAVE_INTERNAL_TEMP,
+       EFX_MON_STAT_CONTROLLER_SLAVE_VPTAT_EXT_ADC,
+       EFX_MON_STAT_CONTROLLER_SLAVE_INTERNAL_TEMP_EXT_ADC,
+       EFX_MON_STAT_SODIMM_VOUT,
+       EFX_MON_STAT_SODIMM_0_TEMP,
+       EFX_MON_STAT_SODIMM_1_TEMP,
+       EFX_MON_STAT_PHY0_VCC,
+       EFX_MON_STAT_PHY1_VCC,
+       EFX_MON_STAT_CONTROLLER_TDIODE_TEMP,
+       EFX_MON_STAT_BOARD_FRONT_TEMP,
+       EFX_MON_STAT_BOARD_BACK_TEMP,
+       EFX_MON_NSTATS
+} efx_mon_stat_t;
+
+/* END MKCONFIG GENERATED MonitorHeaderStatsBlock */
+
+typedef enum efx_mon_stat_state_e {
+       EFX_MON_STAT_STATE_OK = 0,
+       EFX_MON_STAT_STATE_WARNING = 1,
+       EFX_MON_STAT_STATE_FATAL = 2,
+       EFX_MON_STAT_STATE_BROKEN = 3,
+       EFX_MON_STAT_STATE_NO_READING = 4,
+} efx_mon_stat_state_t;
+
+typedef struct efx_mon_stat_value_s {
+       uint16_t        emsv_value;
+       uint16_t        emsv_state;
+} efx_mon_stat_value_t;
+
+#if EFSYS_OPT_NAMES
+
+extern                                 const char *
+efx_mon_stat_name(
+       __in                            efx_nic_t *enp,
+       __in                            efx_mon_stat_t id);
+
+#endif /* EFSYS_OPT_NAMES */
+
+extern __checkReturn                   efx_rc_t
+efx_mon_stats_update(
+       __in                            efx_nic_t *enp,
+       __in                            efsys_mem_t *esmp,
+       __inout_ecount(EFX_MON_NSTATS)  efx_mon_stat_value_t *values);
+
+#endif /* EFSYS_OPT_MON_STATS */
+
 extern         void
 efx_mon_fini(
        __in    efx_nic_t *enp);
@@ -463,10 +748,98 @@ extern    __checkReturn   efx_rc_t
 efx_phy_verify(
        __in            efx_nic_t *enp);
 
+#if EFSYS_OPT_PHY_LED_CONTROL
+
+typedef enum efx_phy_led_mode_e {
+       EFX_PHY_LED_DEFAULT = 0,
+       EFX_PHY_LED_OFF,
+       EFX_PHY_LED_ON,
+       EFX_PHY_LED_FLASH,
+       EFX_PHY_LED_NMODES
+} efx_phy_led_mode_t;
+
+extern __checkReturn   efx_rc_t
+efx_phy_led_set(
+       __in    efx_nic_t *enp,
+       __in    efx_phy_led_mode_t mode);
+
+#endif /* EFSYS_OPT_PHY_LED_CONTROL */
+
 extern __checkReturn   efx_rc_t
 efx_port_init(
        __in            efx_nic_t *enp);
 
+#if EFSYS_OPT_LOOPBACK
+
+typedef enum efx_loopback_type_e {
+       EFX_LOOPBACK_OFF = 0,
+       EFX_LOOPBACK_DATA = 1,
+       EFX_LOOPBACK_GMAC = 2,
+       EFX_LOOPBACK_XGMII = 3,
+       EFX_LOOPBACK_XGXS = 4,
+       EFX_LOOPBACK_XAUI = 5,
+       EFX_LOOPBACK_GMII = 6,
+       EFX_LOOPBACK_SGMII = 7,
+       EFX_LOOPBACK_XGBR = 8,
+       EFX_LOOPBACK_XFI = 9,
+       EFX_LOOPBACK_XAUI_FAR = 10,
+       EFX_LOOPBACK_GMII_FAR = 11,
+       EFX_LOOPBACK_SGMII_FAR = 12,
+       EFX_LOOPBACK_XFI_FAR = 13,
+       EFX_LOOPBACK_GPHY = 14,
+       EFX_LOOPBACK_PHY_XS = 15,
+       EFX_LOOPBACK_PCS = 16,
+       EFX_LOOPBACK_PMA_PMD = 17,
+       EFX_LOOPBACK_XPORT = 18,
+       EFX_LOOPBACK_XGMII_WS = 19,
+       EFX_LOOPBACK_XAUI_WS = 20,
+       EFX_LOOPBACK_XAUI_WS_FAR = 21,
+       EFX_LOOPBACK_XAUI_WS_NEAR = 22,
+       EFX_LOOPBACK_GMII_WS = 23,
+       EFX_LOOPBACK_XFI_WS = 24,
+       EFX_LOOPBACK_XFI_WS_FAR = 25,
+       EFX_LOOPBACK_PHYXS_WS = 26,
+       EFX_LOOPBACK_PMA_INT = 27,
+       EFX_LOOPBACK_SD_NEAR = 28,
+       EFX_LOOPBACK_SD_FAR = 29,
+       EFX_LOOPBACK_PMA_INT_WS = 30,
+       EFX_LOOPBACK_SD_FEP2_WS = 31,
+       EFX_LOOPBACK_SD_FEP1_5_WS = 32,
+       EFX_LOOPBACK_SD_FEP_WS = 33,
+       EFX_LOOPBACK_SD_FES_WS = 34,
+       EFX_LOOPBACK_NTYPES
+} efx_loopback_type_t;
+
+typedef enum efx_loopback_kind_e {
+       EFX_LOOPBACK_KIND_OFF = 0,
+       EFX_LOOPBACK_KIND_ALL,
+       EFX_LOOPBACK_KIND_MAC,
+       EFX_LOOPBACK_KIND_PHY,
+       EFX_LOOPBACK_NKINDS
+} efx_loopback_kind_t;
+
+extern                 void
+efx_loopback_mask(
+       __in    efx_loopback_kind_t loopback_kind,
+       __out   efx_qword_t *maskp);
+
+extern __checkReturn   efx_rc_t
+efx_port_loopback_set(
+       __in    efx_nic_t *enp,
+       __in    efx_link_mode_t link_mode,
+       __in    efx_loopback_type_t type);
+
+#if EFSYS_OPT_NAMES
+
+extern __checkReturn   const char *
+efx_loopback_type_name(
+       __in            efx_nic_t *enp,
+       __in            efx_loopback_type_t type);
+
+#endif /* EFSYS_OPT_NAMES */
+
+#endif /* EFSYS_OPT_LOOPBACK */
+
 extern __checkReturn   efx_rc_t
 efx_port_poll(
        __in            efx_nic_t *enp,
@@ -548,6 +921,157 @@ efx_phy_module_get_info(
        __in                            uint8_t len,
        __out_bcount(len)               uint8_t *data);
 
+#if EFSYS_OPT_PHY_STATS
+
+/* START MKCONFIG GENERATED PhyHeaderStatsBlock 30ed56ad501f8e36 */
+typedef enum efx_phy_stat_e {
+       EFX_PHY_STAT_OUI,
+       EFX_PHY_STAT_PMA_PMD_LINK_UP,
+       EFX_PHY_STAT_PMA_PMD_RX_FAULT,
+       EFX_PHY_STAT_PMA_PMD_TX_FAULT,
+       EFX_PHY_STAT_PMA_PMD_REV_A,
+       EFX_PHY_STAT_PMA_PMD_REV_B,
+       EFX_PHY_STAT_PMA_PMD_REV_C,
+       EFX_PHY_STAT_PMA_PMD_REV_D,
+       EFX_PHY_STAT_PCS_LINK_UP,
+       EFX_PHY_STAT_PCS_RX_FAULT,
+       EFX_PHY_STAT_PCS_TX_FAULT,
+       EFX_PHY_STAT_PCS_BER,
+       EFX_PHY_STAT_PCS_BLOCK_ERRORS,
+       EFX_PHY_STAT_PHY_XS_LINK_UP,
+       EFX_PHY_STAT_PHY_XS_RX_FAULT,
+       EFX_PHY_STAT_PHY_XS_TX_FAULT,
+       EFX_PHY_STAT_PHY_XS_ALIGN,
+       EFX_PHY_STAT_PHY_XS_SYNC_A,
+       EFX_PHY_STAT_PHY_XS_SYNC_B,
+       EFX_PHY_STAT_PHY_XS_SYNC_C,
+       EFX_PHY_STAT_PHY_XS_SYNC_D,
+       EFX_PHY_STAT_AN_LINK_UP,
+       EFX_PHY_STAT_AN_MASTER,
+       EFX_PHY_STAT_AN_LOCAL_RX_OK,
+       EFX_PHY_STAT_AN_REMOTE_RX_OK,
+       EFX_PHY_STAT_CL22EXT_LINK_UP,
+       EFX_PHY_STAT_SNR_A,
+       EFX_PHY_STAT_SNR_B,
+       EFX_PHY_STAT_SNR_C,
+       EFX_PHY_STAT_SNR_D,
+       EFX_PHY_STAT_PMA_PMD_SIGNAL_A,
+       EFX_PHY_STAT_PMA_PMD_SIGNAL_B,
+       EFX_PHY_STAT_PMA_PMD_SIGNAL_C,
+       EFX_PHY_STAT_PMA_PMD_SIGNAL_D,
+       EFX_PHY_STAT_AN_COMPLETE,
+       EFX_PHY_STAT_PMA_PMD_REV_MAJOR,
+       EFX_PHY_STAT_PMA_PMD_REV_MINOR,
+       EFX_PHY_STAT_PMA_PMD_REV_MICRO,
+       EFX_PHY_STAT_PCS_FW_VERSION_0,
+       EFX_PHY_STAT_PCS_FW_VERSION_1,
+       EFX_PHY_STAT_PCS_FW_VERSION_2,
+       EFX_PHY_STAT_PCS_FW_VERSION_3,
+       EFX_PHY_STAT_PCS_FW_BUILD_YY,
+       EFX_PHY_STAT_PCS_FW_BUILD_MM,
+       EFX_PHY_STAT_PCS_FW_BUILD_DD,
+       EFX_PHY_STAT_PCS_OP_MODE,
+       EFX_PHY_NSTATS
+} efx_phy_stat_t;
+
+/* END MKCONFIG GENERATED PhyHeaderStatsBlock */
+
+#if EFSYS_OPT_NAMES
+
+extern                                 const char *
+efx_phy_stat_name(
+       __in                            efx_nic_t *enp,
+       __in                            efx_phy_stat_t stat);
+
+#endif /* EFSYS_OPT_NAMES */
+
+#define        EFX_PHY_STATS_SIZE 0x100
+
+extern __checkReturn                   efx_rc_t
+efx_phy_stats_update(
+       __in                            efx_nic_t *enp,
+       __in                            efsys_mem_t *esmp,
+       __inout_ecount(EFX_PHY_NSTATS)  uint32_t *stat);
+
+#endif /* EFSYS_OPT_PHY_STATS */
+
+
+#if EFSYS_OPT_BIST
+
+typedef enum efx_bist_type_e {
+       EFX_BIST_TYPE_UNKNOWN,
+       EFX_BIST_TYPE_PHY_NORMAL,
+       EFX_BIST_TYPE_PHY_CABLE_SHORT,
+       EFX_BIST_TYPE_PHY_CABLE_LONG,
+       EFX_BIST_TYPE_MC_MEM,   /* Test the MC DMEM and IMEM */
+       EFX_BIST_TYPE_SAT_MEM,  /* Test the DMEM and IMEM of satellite cpus*/
+       EFX_BIST_TYPE_REG,      /* Test the register memories */
+       EFX_BIST_TYPE_NTYPES,
+} efx_bist_type_t;
+
+typedef enum efx_bist_result_e {
+       EFX_BIST_RESULT_UNKNOWN,
+       EFX_BIST_RESULT_RUNNING,
+       EFX_BIST_RESULT_PASSED,
+       EFX_BIST_RESULT_FAILED,
+} efx_bist_result_t;
+
+typedef enum efx_phy_cable_status_e {
+       EFX_PHY_CABLE_STATUS_OK,
+       EFX_PHY_CABLE_STATUS_INVALID,
+       EFX_PHY_CABLE_STATUS_OPEN,
+       EFX_PHY_CABLE_STATUS_INTRAPAIRSHORT,
+       EFX_PHY_CABLE_STATUS_INTERPAIRSHORT,
+       EFX_PHY_CABLE_STATUS_BUSY,
+} efx_phy_cable_status_t;
+
+typedef enum efx_bist_value_e {
+       EFX_BIST_PHY_CABLE_LENGTH_A,
+       EFX_BIST_PHY_CABLE_LENGTH_B,
+       EFX_BIST_PHY_CABLE_LENGTH_C,
+       EFX_BIST_PHY_CABLE_LENGTH_D,
+       EFX_BIST_PHY_CABLE_STATUS_A,
+       EFX_BIST_PHY_CABLE_STATUS_B,
+       EFX_BIST_PHY_CABLE_STATUS_C,
+       EFX_BIST_PHY_CABLE_STATUS_D,
+       EFX_BIST_FAULT_CODE,
+       /* Memory BIST specific values. These match to the MC_CMD_BIST_POLL
+        * response. */
+       EFX_BIST_MEM_TEST,
+       EFX_BIST_MEM_ADDR,
+       EFX_BIST_MEM_BUS,
+       EFX_BIST_MEM_EXPECT,
+       EFX_BIST_MEM_ACTUAL,
+       EFX_BIST_MEM_ECC,
+       EFX_BIST_MEM_ECC_PARITY,
+       EFX_BIST_MEM_ECC_FATAL,
+       EFX_BIST_NVALUES,
+} efx_bist_value_t;
+
+extern __checkReturn           efx_rc_t
+efx_bist_enable_offline(
+       __in                    efx_nic_t *enp);
+
+extern __checkReturn           efx_rc_t
+efx_bist_start(
+       __in                    efx_nic_t *enp,
+       __in                    efx_bist_type_t type);
+
+extern __checkReturn           efx_rc_t
+efx_bist_poll(
+       __in                    efx_nic_t *enp,
+       __in                    efx_bist_type_t type,
+       __out                   efx_bist_result_t *resultp,
+       __out_opt               uint32_t *value_maskp,
+       __out_ecount_opt(count) unsigned long *valuesp,
+       __in                    size_t count);
+
+extern                         void
+efx_bist_stop(
+       __in                    efx_nic_t *enp,
+       __in                    efx_bist_type_t type);
+
+#endif /* EFSYS_OPT_BIST */
 
 #define        EFX_FEATURE_IPV6                0x00000001
 #define        EFX_FEATURE_LFSR_HASH_INSERT    0x00000002
@@ -564,6 +1088,14 @@ efx_phy_module_get_info(
 #define        EFX_FEATURE_FW_ASSISTED_TSO_V2  0x00002000
 #define        EFX_FEATURE_PACKED_STREAM       0x00004000
 
+typedef enum efx_tunnel_protocol_e {
+       EFX_TUNNEL_PROTOCOL_NONE = 0,
+       EFX_TUNNEL_PROTOCOL_VXLAN,
+       EFX_TUNNEL_PROTOCOL_GENEVE,
+       EFX_TUNNEL_PROTOCOL_NVGRE,
+       EFX_TUNNEL_NPROTOS
+} efx_tunnel_protocol_t;
+
 typedef struct efx_nic_cfg_s {
        uint32_t                enc_board_type;
        uint32_t                enc_phy_type;
@@ -572,6 +1104,10 @@ typedef struct efx_nic_cfg_s {
 #endif
        char                    enc_phy_revision[21];
        efx_mon_type_t          enc_mon_type;
+#if EFSYS_OPT_MON_STATS
+       uint32_t                enc_mon_stat_dma_buf_size;
+       uint32_t                enc_mon_stat_mask[(EFX_MON_NSTATS + 31) / 32];
+#endif
        unsigned int            enc_features;
        uint8_t                 enc_mac_addr[6];
        uint8_t                 enc_port;       /* PHY port number */
@@ -591,9 +1127,31 @@ typedef struct efx_nic_cfg_s {
        uint32_t                enc_rx_prefix_size;
        uint32_t                enc_rx_buf_align_start;
        uint32_t                enc_rx_buf_align_end;
+#if EFSYS_OPT_LOOPBACK
+       efx_qword_t             enc_loopback_types[EFX_LINK_NMODES];
+#endif /* EFSYS_OPT_LOOPBACK */
+#if EFSYS_OPT_PHY_FLAGS
+       uint32_t                enc_phy_flags_mask;
+#endif /* EFSYS_OPT_PHY_FLAGS */
+#if EFSYS_OPT_PHY_LED_CONTROL
+       uint32_t                enc_led_mask;
+#endif /* EFSYS_OPT_PHY_LED_CONTROL */
+#if EFSYS_OPT_PHY_STATS
+       uint64_t                enc_phy_stat_mask;
+#endif /* EFSYS_OPT_PHY_STATS */
 #if EFSYS_OPT_MCDI
        uint8_t                 enc_mcdi_mdio_channel;
+#if EFSYS_OPT_PHY_STATS
+       uint32_t                enc_mcdi_phy_stat_mask;
+#endif /* EFSYS_OPT_PHY_STATS */
+#if EFSYS_OPT_MON_STATS
+       uint32_t                *enc_mcdi_sensor_maskp;
+       uint32_t                enc_mcdi_sensor_mask_size;
+#endif /* EFSYS_OPT_MON_STATS */
 #endif /* EFSYS_OPT_MCDI */
+#if EFSYS_OPT_BIST
+       uint32_t                enc_bist_mask;
+#endif /* EFSYS_OPT_BIST */
 #if EFSYS_OPT_HUNTINGTON || EFSYS_OPT_MEDFORD
        uint32_t                enc_pf;
        uint32_t                enc_vf;
@@ -608,6 +1166,13 @@ typedef struct efx_nic_cfg_s {
        uint32_t                enc_rx_batch_max;
        /* Number of rx descriptors the hardware requires for a push. */
        uint32_t                enc_rx_push_align;
+       /* Maximum amount of data in DMA descriptor */
+       uint32_t                enc_tx_dma_desc_size_max;
+       /*
+        * Boundary which DMA descriptor data must not cross or 0 if no
+        * limitation.
+        */
+       uint32_t                enc_tx_dma_desc_boundary;
        /*
         * Maximum number of bytes into the packet the TCP header can start for
         * the hardware to apply TSO packet edits.
@@ -630,6 +1195,7 @@ typedef struct efx_nic_cfg_s {
        boolean_t               enc_rx_var_packed_stream_supported;
        boolean_t               enc_pm_and_rxdp_counters;
        boolean_t               enc_mac_stats_40g_tx_size_bins;
+       uint32_t                enc_tunnel_encapsulations_supported;
        /* External port identifier */
        uint8_t                 enc_external_port;
        uint32_t                enc_mcdi_max_payload_length;
@@ -654,6 +1220,24 @@ extern                    const efx_nic_cfg_t *
 efx_nic_cfg_get(
        __in            efx_nic_t *enp);
 
+typedef struct efx_nic_fw_info_s {
+       /* Basic FW version information */
+       uint16_t        enfi_mc_fw_version[4];
+       /*
+        * If datapath capabilities can be detected,
+        * additional FW information is to be shown
+        */
+       boolean_t       enfi_dpcpu_fw_ids_valid;
+       /* Rx and Tx datapath CPU FW IDs */
+       uint16_t        enfi_rx_dpcpu_fw_id;
+       uint16_t        enfi_tx_dpcpu_fw_id;
+} efx_nic_fw_info_t;
+
+extern __checkReturn           efx_rc_t
+efx_nic_get_fw_version(
+       __in                    efx_nic_t *enp,
+       __out                   efx_nic_fw_info_t *enfip);
+
 /* Driver resource limits (minimum required/maximum usable). */
 typedef struct efx_drv_limits_s {
        uint32_t        edl_min_evq_count;
@@ -695,8 +1279,225 @@ efx_nic_get_vi_pool(
        __out           uint32_t *txq_countp);
 
 
+#if EFSYS_OPT_VPD
+
+typedef enum efx_vpd_tag_e {
+       EFX_VPD_ID = 0x02,
+       EFX_VPD_END = 0x0f,
+       EFX_VPD_RO = 0x10,
+       EFX_VPD_RW = 0x11,
+} efx_vpd_tag_t;
+
+typedef uint16_t efx_vpd_keyword_t;
+
+typedef struct efx_vpd_value_s {
+       efx_vpd_tag_t           evv_tag;
+       efx_vpd_keyword_t       evv_keyword;
+       uint8_t                 evv_length;
+       uint8_t                 evv_value[0x100];
+} efx_vpd_value_t;
+
+
+#define        EFX_VPD_KEYWORD(x, y) ((x) | ((y) << 8))
+
+extern __checkReturn           efx_rc_t
+efx_vpd_init(
+       __in                    efx_nic_t *enp);
+
+extern __checkReturn           efx_rc_t
+efx_vpd_size(
+       __in                    efx_nic_t *enp,
+       __out                   size_t *sizep);
+
+extern __checkReturn           efx_rc_t
+efx_vpd_read(
+       __in                    efx_nic_t *enp,
+       __out_bcount(size)      caddr_t data,
+       __in                    size_t size);
+
+extern __checkReturn           efx_rc_t
+efx_vpd_verify(
+       __in                    efx_nic_t *enp,
+       __in_bcount(size)       caddr_t data,
+       __in                    size_t size);
+
+extern __checkReturn           efx_rc_t
+efx_vpd_reinit(
+       __in                    efx_nic_t *enp,
+       __in_bcount(size)       caddr_t data,
+       __in                    size_t size);
+
+extern __checkReturn           efx_rc_t
+efx_vpd_get(
+       __in                    efx_nic_t *enp,
+       __in_bcount(size)       caddr_t data,
+       __in                    size_t size,
+       __inout                 efx_vpd_value_t *evvp);
+
+extern __checkReturn           efx_rc_t
+efx_vpd_set(
+       __in                    efx_nic_t *enp,
+       __inout_bcount(size)    caddr_t data,
+       __in                    size_t size,
+       __in                    efx_vpd_value_t *evvp);
+
+extern __checkReturn           efx_rc_t
+efx_vpd_next(
+       __in                    efx_nic_t *enp,
+       __inout_bcount(size)    caddr_t data,
+       __in                    size_t size,
+       __out                   efx_vpd_value_t *evvp,
+       __inout                 unsigned int *contp);
+
+extern __checkReturn           efx_rc_t
+efx_vpd_write(
+       __in                    efx_nic_t *enp,
+       __in_bcount(size)       caddr_t data,
+       __in                    size_t size);
+
+extern                         void
+efx_vpd_fini(
+       __in                    efx_nic_t *enp);
+
+#endif /* EFSYS_OPT_VPD */
+
 /* NVRAM */
 
+#if EFSYS_OPT_NVRAM
+
+typedef enum efx_nvram_type_e {
+       EFX_NVRAM_INVALID = 0,
+       EFX_NVRAM_BOOTROM,
+       EFX_NVRAM_BOOTROM_CFG,
+       EFX_NVRAM_MC_FIRMWARE,
+       EFX_NVRAM_MC_GOLDEN,
+       EFX_NVRAM_PHY,
+       EFX_NVRAM_NULLPHY,
+       EFX_NVRAM_FPGA,
+       EFX_NVRAM_FCFW,
+       EFX_NVRAM_CPLD,
+       EFX_NVRAM_FPGA_BACKUP,
+       EFX_NVRAM_DYNAMIC_CFG,
+       EFX_NVRAM_LICENSE,
+       EFX_NVRAM_UEFIROM,
+       EFX_NVRAM_NTYPES,
+} efx_nvram_type_t;
+
+extern __checkReturn           efx_rc_t
+efx_nvram_init(
+       __in                    efx_nic_t *enp);
+
+#if EFSYS_OPT_DIAG
+
+extern __checkReturn           efx_rc_t
+efx_nvram_test(
+       __in                    efx_nic_t *enp);
+
+#endif /* EFSYS_OPT_DIAG */
+
+extern __checkReturn           efx_rc_t
+efx_nvram_size(
+       __in                    efx_nic_t *enp,
+       __in                    efx_nvram_type_t type,
+       __out                   size_t *sizep);
+
+extern __checkReturn           efx_rc_t
+efx_nvram_rw_start(
+       __in                    efx_nic_t *enp,
+       __in                    efx_nvram_type_t type,
+       __out_opt               size_t *pref_chunkp);
+
+extern __checkReturn           efx_rc_t
+efx_nvram_rw_finish(
+       __in                    efx_nic_t *enp,
+       __in                    efx_nvram_type_t type);
+
+extern __checkReturn           efx_rc_t
+efx_nvram_get_version(
+       __in                    efx_nic_t *enp,
+       __in                    efx_nvram_type_t type,
+       __out                   uint32_t *subtypep,
+       __out_ecount(4)         uint16_t version[4]);
+
+extern __checkReturn           efx_rc_t
+efx_nvram_read_chunk(
+       __in                    efx_nic_t *enp,
+       __in                    efx_nvram_type_t type,
+       __in                    unsigned int offset,
+       __out_bcount(size)      caddr_t data,
+       __in                    size_t size);
+
+extern __checkReturn           efx_rc_t
+efx_nvram_set_version(
+       __in                    efx_nic_t *enp,
+       __in                    efx_nvram_type_t type,
+       __in_ecount(4)          uint16_t version[4]);
+
+extern __checkReturn           efx_rc_t
+efx_nvram_validate(
+       __in                    efx_nic_t *enp,
+       __in                    efx_nvram_type_t type,
+       __in_bcount(partn_size) caddr_t partn_data,
+       __in                    size_t partn_size);
+
+extern  __checkReturn          efx_rc_t
+efx_nvram_erase(
+       __in                    efx_nic_t *enp,
+       __in                    efx_nvram_type_t type);
+
+extern __checkReturn           efx_rc_t
+efx_nvram_write_chunk(
+       __in                    efx_nic_t *enp,
+       __in                    efx_nvram_type_t type,
+       __in                    unsigned int offset,
+       __in_bcount(size)       caddr_t data,
+       __in                    size_t size);
+
+extern                         void
+efx_nvram_fini(
+       __in                    efx_nic_t *enp);
+
+#endif /* EFSYS_OPT_NVRAM */
+
+#if EFSYS_OPT_BOOTCFG
+
+/* Report size and offset of bootcfg sector in NVRAM partition. */
+extern __checkReturn           efx_rc_t
+efx_bootcfg_sector_info(
+       __in                    efx_nic_t *enp,
+       __in                    uint32_t pf,
+       __out_opt               uint32_t *sector_countp,
+       __out                   size_t *offsetp,
+       __out                   size_t *max_sizep);
+
+/*
+ * Copy bootcfg sector data to a target buffer which may differ in size.
+ * Optionally corrects format errors in source buffer.
+ */
+extern                         efx_rc_t
+efx_bootcfg_copy_sector(
+       __in                    efx_nic_t *enp,
+       __inout_bcount(sector_length)
+                               uint8_t *sector,
+       __in                    size_t sector_length,
+       __out_bcount(data_size) uint8_t *data,
+       __in                    size_t data_size,
+       __in                    boolean_t handle_format_errors);
+
+extern                         efx_rc_t
+efx_bootcfg_read(
+       __in                    efx_nic_t *enp,
+       __out_bcount(size)      caddr_t data,
+       __in                    size_t size);
+
+extern                         efx_rc_t
+efx_bootcfg_write(
+       __in                    efx_nic_t *enp,
+       __in_bcount(size)       caddr_t data,
+       __in                    size_t size);
+
+#endif /* EFSYS_OPT_BOOTCFG */
+
 #if EFSYS_OPT_DIAG
 
 typedef enum efx_pattern_type_t {
@@ -743,6 +1544,54 @@ efx_sram_buf_tbl_clear(
 
 typedef struct efx_evq_s       efx_evq_t;
 
+#if EFSYS_OPT_QSTATS
+
+/* START MKCONFIG GENERATED EfxHeaderEventQueueBlock 6f3843f5fe7cc843 */
+typedef enum efx_ev_qstat_e {
+       EV_ALL,
+       EV_RX,
+       EV_RX_OK,
+       EV_RX_FRM_TRUNC,
+       EV_RX_TOBE_DISC,
+       EV_RX_PAUSE_FRM_ERR,
+       EV_RX_BUF_OWNER_ID_ERR,
+       EV_RX_IPV4_HDR_CHKSUM_ERR,
+       EV_RX_TCP_UDP_CHKSUM_ERR,
+       EV_RX_ETH_CRC_ERR,
+       EV_RX_IP_FRAG_ERR,
+       EV_RX_MCAST_PKT,
+       EV_RX_MCAST_HASH_MATCH,
+       EV_RX_TCP_IPV4,
+       EV_RX_TCP_IPV6,
+       EV_RX_UDP_IPV4,
+       EV_RX_UDP_IPV6,
+       EV_RX_OTHER_IPV4,
+       EV_RX_OTHER_IPV6,
+       EV_RX_NON_IP,
+       EV_RX_BATCH,
+       EV_TX,
+       EV_TX_WQ_FF_FULL,
+       EV_TX_PKT_ERR,
+       EV_TX_PKT_TOO_BIG,
+       EV_TX_UNEXPECTED,
+       EV_GLOBAL,
+       EV_GLOBAL_MNT,
+       EV_DRIVER,
+       EV_DRIVER_SRM_UPD_DONE,
+       EV_DRIVER_TX_DESCQ_FLS_DONE,
+       EV_DRIVER_RX_DESCQ_FLS_DONE,
+       EV_DRIVER_RX_DESCQ_FLS_FAILED,
+       EV_DRIVER_RX_DSC_ERROR,
+       EV_DRIVER_TX_DSC_ERROR,
+       EV_DRV_GEN,
+       EV_MCDI_RESPONSE,
+       EV_NQSTATS
+} efx_ev_qstat_t;
+
+/* END MKCONFIG GENERATED EfxHeaderEventQueueBlock */
+
+#endif /* EFSYS_OPT_QSTATS */
+
 extern __checkReturn   efx_rc_t
 efx_ev_init(
        __in            efx_nic_t *enp);
@@ -825,6 +1674,28 @@ typedef   __checkReturn   boolean_t
        __in            uint32_t size,
        __in            uint16_t flags);
 
+#if EFSYS_OPT_RX_PACKED_STREAM
+
+/*
+ * Packed stream mode is documented in SF-112241-TC.
+ * The general idea is that, instead of putting each incoming
+ * packet into a separate buffer which is specified in a RX
+ * descriptor, a large buffer is provided to the hardware and
+ * packets are put there in a continuous stream.
+ * The main advantage of such an approach is that RX queue refilling
+ * happens much less frequently.
+ */
+
+typedef        __checkReturn   boolean_t
+(*efx_rx_ps_ev_t)(
+       __in_opt        void *arg,
+       __in            uint32_t label,
+       __in            uint32_t id,
+       __in            uint32_t pkt_count,
+       __in            uint16_t flags);
+
+#endif
+
 typedef        __checkReturn   boolean_t
 (*efx_tx_ev_t)(
        __in_opt        void *arg,
@@ -891,9 +1762,32 @@ typedef __checkReturn     boolean_t
        __in_opt        void *arg,
        __in            efx_link_mode_t link_mode);
 
+#if EFSYS_OPT_MON_STATS
+
+typedef __checkReturn  boolean_t
+(*efx_monitor_ev_t)(
+       __in_opt        void *arg,
+       __in            efx_mon_stat_t id,
+       __in            efx_mon_stat_value_t value);
+
+#endif /* EFSYS_OPT_MON_STATS */
+
+#if EFSYS_OPT_MAC_STATS
+
+typedef __checkReturn  boolean_t
+(*efx_mac_stats_ev_t)(
+       __in_opt        void *arg,
+       __in            uint32_t generation
+       );
+
+#endif /* EFSYS_OPT_MAC_STATS */
+
 typedef struct efx_ev_callbacks_s {
        efx_initialized_ev_t            eec_initialized;
        efx_rx_ev_t                     eec_rx;
+#if EFSYS_OPT_RX_PACKED_STREAM
+       efx_rx_ps_ev_t                  eec_rx_ps;
+#endif
        efx_tx_ev_t                     eec_tx;
        efx_exception_ev_t              eec_exception;
        efx_rxq_flush_done_ev_t         eec_rxq_flush_done;
@@ -904,6 +1798,12 @@ typedef struct efx_ev_callbacks_s {
        efx_wake_up_ev_t                eec_wake_up;
        efx_timer_ev_t                  eec_timer;
        efx_link_change_ev_t            eec_link_change;
+#if EFSYS_OPT_MON_STATS
+       efx_monitor_ev_t                eec_monitor;
+#endif /* EFSYS_OPT_MON_STATS */
+#if EFSYS_OPT_MAC_STATS
+       efx_mac_stats_ev_t              eec_mac_stats;
+#endif /* EFSYS_OPT_MAC_STATS */
 } efx_ev_callbacks_t;
 
 extern __checkReturn   boolean_t
@@ -911,6 +1811,15 @@ efx_ev_qpending(
        __in            efx_evq_t *eep,
        __in            unsigned int count);
 
+#if EFSYS_OPT_EV_PREFETCH
+
+extern                 void
+efx_ev_qprefetch(
+       __in            efx_evq_t *eep,
+       __in            unsigned int count);
+
+#endif /* EFSYS_OPT_EV_PREFETCH */
+
 extern                 void
 efx_ev_qpoll(
        __in            efx_evq_t *eep,
@@ -934,6 +1843,24 @@ efx_ev_qprime(
        __in            efx_evq_t *eep,
        __in            unsigned int count);
 
+#if EFSYS_OPT_QSTATS
+
+#if EFSYS_OPT_NAMES
+
+extern         const char *
+efx_ev_qstat_name(
+       __in    efx_nic_t *enp,
+       __in    unsigned int id);
+
+#endif /* EFSYS_OPT_NAMES */
+
+extern                                 void
+efx_ev_qstats_update(
+       __in                            efx_evq_t *eep,
+       __inout_ecount(EV_NQSTATS)      efsys_stat_t *stat);
+
+#endif /* EFSYS_OPT_QSTATS */
+
 extern         void
 efx_ev_qdestroy(
        __in    efx_evq_t *eep);
@@ -948,6 +1875,80 @@ extern            void
 efx_rx_fini(
        __in            efx_nic_t *enp);
 
+#if EFSYS_OPT_RX_SCATTER
+       __checkReturn   efx_rc_t
+efx_rx_scatter_enable(
+       __in            efx_nic_t *enp,
+       __in            unsigned int buf_size);
+#endif /* EFSYS_OPT_RX_SCATTER */
+
+#if EFSYS_OPT_RX_SCALE
+
+typedef enum efx_rx_hash_alg_e {
+       EFX_RX_HASHALG_LFSR = 0,
+       EFX_RX_HASHALG_TOEPLITZ
+} efx_rx_hash_alg_t;
+
+#define        EFX_RX_HASH_IPV4        (1U << 0)
+#define        EFX_RX_HASH_TCPIPV4     (1U << 1)
+#define        EFX_RX_HASH_IPV6        (1U << 2)
+#define        EFX_RX_HASH_TCPIPV6     (1U << 3)
+
+typedef unsigned int efx_rx_hash_type_t;
+
+typedef enum efx_rx_hash_support_e {
+       EFX_RX_HASH_UNAVAILABLE = 0,    /* Hardware hash not inserted */
+       EFX_RX_HASH_AVAILABLE           /* Insert hash with/without RSS */
+} efx_rx_hash_support_t;
+
+#define        EFX_RSS_TBL_SIZE        128     /* Rows in RX indirection table */
+#define        EFX_MAXRSS              64      /* RX indirection entry range */
+#define        EFX_MAXRSS_LEGACY       16      /* See bug16611 and bug17213 */
+
+typedef enum efx_rx_scale_support_e {
+       EFX_RX_SCALE_UNAVAILABLE = 0,   /* Not supported */
+       EFX_RX_SCALE_EXCLUSIVE,         /* Writable key/indirection table */
+       EFX_RX_SCALE_SHARED             /* Read-only key/indirection table */
+} efx_rx_scale_support_t;
+
+extern __checkReturn   efx_rc_t
+efx_rx_hash_support_get(
+       __in            efx_nic_t *enp,
+       __out           efx_rx_hash_support_t *supportp);
+
+
+extern __checkReturn   efx_rc_t
+efx_rx_scale_support_get(
+       __in            efx_nic_t *enp,
+       __out           efx_rx_scale_support_t *supportp);
+
+extern __checkReturn   efx_rc_t
+efx_rx_scale_mode_set(
+       __in    efx_nic_t *enp,
+       __in    efx_rx_hash_alg_t alg,
+       __in    efx_rx_hash_type_t type,
+       __in    boolean_t insert);
+
+extern __checkReturn   efx_rc_t
+efx_rx_scale_tbl_set(
+       __in            efx_nic_t *enp,
+       __in_ecount(n)  unsigned int *table,
+       __in            size_t n);
+
+extern __checkReturn   efx_rc_t
+efx_rx_scale_key_set(
+       __in            efx_nic_t *enp,
+       __in_ecount(n)  uint8_t *key,
+       __in            size_t n);
+
+extern __checkReturn   uint32_t
+efx_pseudo_hdr_hash_get(
+       __in            efx_rxq_t *erp,
+       __in            efx_rx_hash_alg_t func,
+       __in            uint8_t *buffer);
+
+#endif /* EFSYS_OPT_RX_SCALE */
+
 extern __checkReturn   efx_rc_t
 efx_pseudo_hdr_pkt_length_get(
        __in            efx_rxq_t *erp,
@@ -1010,6 +2011,29 @@ efx_rx_qpush(
        __in    unsigned int added,
        __inout unsigned int *pushedp);
 
+#if EFSYS_OPT_RX_PACKED_STREAM
+
+/*
+ * Fake length for RXQ descriptors in packed stream mode
+ * to make hardware happy
+ */
+#define        EFX_RXQ_PACKED_STREAM_FAKE_BUF_SIZE 32
+
+extern                 void
+efx_rx_qps_update_credits(
+       __in            efx_rxq_t *erp);
+
+extern __checkReturn   uint8_t *
+efx_rx_qps_packet_info(
+       __in            efx_rxq_t *erp,
+       __in            uint8_t *buffer,
+       __in            uint32_t buffer_length,
+       __in            uint32_t current_offset,
+       __out           uint16_t *lengthp,
+       __out           uint32_t *next_offsetp,
+       __out           uint32_t *timestamp);
+#endif
+
 extern __checkReturn   efx_rc_t
 efx_rx_qflush(
        __in    efx_rxq_t *erp);
@@ -1026,6 +2050,19 @@ efx_rx_qdestroy(
 
 typedef struct efx_txq_s       efx_txq_t;
 
+#if EFSYS_OPT_QSTATS
+
+/* START MKCONFIG GENERATED EfxHeaderTransmitQueueBlock 12dff8778598b2db */
+typedef enum efx_tx_qstat_e {
+       TX_POST,
+       TX_POST_PIO,
+       TX_NQSTATS
+} efx_tx_qstat_t;
+
+/* END MKCONFIG GENERATED EfxHeaderTransmitQueueBlock */
+
+#endif /* EFSYS_OPT_QSTATS */
+
 extern __checkReturn   efx_rc_t
 efx_tx_init(
        __in            efx_nic_t *enp);
@@ -1154,6 +2191,24 @@ efx_tx_qdesc_vlantci_create(
        __in    uint16_t tci,
        __out   efx_desc_t *edp);
 
+#if EFSYS_OPT_QSTATS
+
+#if EFSYS_OPT_NAMES
+
+extern         const char *
+efx_tx_qstat_name(
+       __in    efx_nic_t *etp,
+       __in    unsigned int id);
+
+#endif /* EFSYS_OPT_NAMES */
+
+extern                                 void
+efx_tx_qstats_update(
+       __in                            efx_txq_t *etp,
+       __inout_ecount(TX_NQSTATS)      efsys_stat_t *stat);
+
+#endif /* EFSYS_OPT_QSTATS */
+
 extern         void
 efx_tx_qdestroy(
        __in    efx_txq_t *etp);
@@ -1200,10 +2255,10 @@ typedef enum efx_filter_match_flags_e {
        EFX_FILTER_MATCH_OUTER_VID = 0x0100,    /* Match by outer VLAN ID */
        EFX_FILTER_MATCH_IP_PROTO = 0x0200,     /* Match by IP transport
                                                 * protocol */
-       EFX_FILTER_MATCH_LOC_MAC_IG = 0x0400,   /* Match by local MAC address
-                                                * I/G bit. Used for RX default
-                                                * unicast and multicast/
-                                                * broadcast filters. */
+       /* Match otherwise-unmatched multicast and broadcast packets */
+       EFX_FILTER_MATCH_UNKNOWN_MCAST_DST = 0x40000000,
+       /* Match otherwise-unmatched unicast packets */
+       EFX_FILTER_MATCH_UNKNOWN_UCAST_DST = 0x80000000,
 } efx_filter_match_flags_t;
 
 typedef enum efx_filter_priority_s {
@@ -1225,7 +2280,7 @@ typedef enum efx_filter_priority_s {
  */
 
 typedef struct efx_filter_spec_s {
-       uint32_t        efs_match_flags:12;
+       uint32_t        efs_match_flags;
        uint32_t        efs_priority:2;
        uint32_t        efs_flags:6;
        uint32_t        efs_dmaq_id:12;
@@ -1272,9 +2327,10 @@ efx_filter_restore(
 
 extern __checkReturn   efx_rc_t
 efx_filter_supported_filters(
-       __in            efx_nic_t *enp,
-       __out           uint32_t *list,
-       __out           size_t *length);
+       __in                            efx_nic_t *enp,
+       __out_ecount(buffer_length)     uint32_t *buffer,
+       __in                            size_t buffer_length,
+       __out                           size_t *list_lengthp);
 
 extern                 void
 efx_filter_spec_init_rx(
@@ -1334,6 +2390,151 @@ efx_hash_bytes(
        __in                    size_t length,
        __in                    uint32_t init);
 
+#if EFSYS_OPT_LICENSING
+
+/* LICENSING */
+
+typedef struct efx_key_stats_s {
+       uint32_t        eks_valid;
+       uint32_t        eks_invalid;
+       uint32_t        eks_blacklisted;
+       uint32_t        eks_unverifiable;
+       uint32_t        eks_wrong_node;
+       uint32_t        eks_licensed_apps_lo;
+       uint32_t        eks_licensed_apps_hi;
+       uint32_t        eks_licensed_features_lo;
+       uint32_t        eks_licensed_features_hi;
+} efx_key_stats_t;
+
+extern __checkReturn           efx_rc_t
+efx_lic_init(
+       __in                    efx_nic_t *enp);
+
+extern                         void
+efx_lic_fini(
+       __in                    efx_nic_t *enp);
+
+extern __checkReturn   boolean_t
+efx_lic_check_support(
+       __in                    efx_nic_t *enp);
+
+extern __checkReturn   efx_rc_t
+efx_lic_update_licenses(
+       __in            efx_nic_t *enp);
+
+extern __checkReturn   efx_rc_t
+efx_lic_get_key_stats(
+       __in            efx_nic_t *enp,
+       __out           efx_key_stats_t *ksp);
+
+extern __checkReturn   efx_rc_t
+efx_lic_app_state(
+       __in            efx_nic_t *enp,
+       __in            uint64_t app_id,
+       __out           boolean_t *licensedp);
+
+extern __checkReturn   efx_rc_t
+efx_lic_get_id(
+       __in            efx_nic_t *enp,
+       __in            size_t buffer_size,
+       __out           uint32_t *typep,
+       __out           size_t *lengthp,
+       __out_opt       uint8_t *bufferp);
+
+
+extern __checkReturn           efx_rc_t
+efx_lic_find_start(
+       __in                    efx_nic_t *enp,
+       __in_bcount(buffer_size)
+                               caddr_t bufferp,
+       __in                    size_t buffer_size,
+       __out                   uint32_t *startp
+       );
+
+extern __checkReturn           efx_rc_t
+efx_lic_find_end(
+       __in                    efx_nic_t *enp,
+       __in_bcount(buffer_size)
+                               caddr_t bufferp,
+       __in                    size_t buffer_size,
+       __in                    uint32_t offset,
+       __out                   uint32_t *endp
+       );
+
+extern __checkReturn   __success(return != B_FALSE)    boolean_t
+efx_lic_find_key(
+       __in                    efx_nic_t *enp,
+       __in_bcount(buffer_size)
+                               caddr_t bufferp,
+       __in                    size_t buffer_size,
+       __in                    uint32_t offset,
+       __out                   uint32_t *startp,
+       __out                   uint32_t *lengthp
+       );
+
+extern __checkReturn   __success(return != B_FALSE)    boolean_t
+efx_lic_validate_key(
+       __in                    efx_nic_t *enp,
+       __in_bcount(length)     caddr_t keyp,
+       __in                    uint32_t length
+       );
+
+extern __checkReturn           efx_rc_t
+efx_lic_read_key(
+       __in                    efx_nic_t *enp,
+       __in_bcount(buffer_size)
+                               caddr_t bufferp,
+       __in                    size_t buffer_size,
+       __in                    uint32_t offset,
+       __in                    uint32_t length,
+       __out_bcount_part(key_max_size, *lengthp)
+                               caddr_t keyp,
+       __in                    size_t key_max_size,
+       __out                   uint32_t *lengthp
+       );
+
+extern __checkReturn           efx_rc_t
+efx_lic_write_key(
+       __in                    efx_nic_t *enp,
+       __in_bcount(buffer_size)
+                               caddr_t bufferp,
+       __in                    size_t buffer_size,
+       __in                    uint32_t offset,
+       __in_bcount(length)     caddr_t keyp,
+       __in                    uint32_t length,
+       __out                   uint32_t *lengthp
+       );
+
+       __checkReturn           efx_rc_t
+efx_lic_delete_key(
+       __in                    efx_nic_t *enp,
+       __in_bcount(buffer_size)
+                               caddr_t bufferp,
+       __in                    size_t buffer_size,
+       __in                    uint32_t offset,
+       __in                    uint32_t length,
+       __in                    uint32_t end,
+       __out                   uint32_t *deltap
+       );
+
+extern __checkReturn           efx_rc_t
+efx_lic_create_partition(
+       __in                    efx_nic_t *enp,
+       __in_bcount(buffer_size)
+                               caddr_t bufferp,
+       __in                    size_t buffer_size
+       );
+
+extern __checkReturn           efx_rc_t
+efx_lic_finish_partition(
+       __in                    efx_nic_t *enp,
+       __in_bcount(buffer_size)
+                               caddr_t bufferp,
+       __in                    size_t buffer_size
+       );
+
+#endif /* EFSYS_OPT_LICENSING */
+
 
 
 #ifdef __cplusplus