sys/dev/ixl/if_ixl.c

   1 /******************************************************************************
   2
   3   Copyright (c) 2013-2018, Intel Corporation
   4   All rights reserved.
   5
   6   Redistribution and use in source and binary forms, with or without
   7   modification, are permitted provided that the following conditions are met:
   8
   9    1. Redistributions of source code must retain the above copyright notice,
  10       this list of conditions and the following disclaimer.
  11
  12    2. Redistributions in binary form must reproduce the above copyright
  13       notice, this list of conditions and the following disclaimer in the
  14       documentation and/or other materials provided with the distribution.
  15
  16    3. Neither the name of the Intel Corporation nor the names of its
  17       contributors may be used to endorse or promote products derived from
  18       this software without specific prior written permission.
  19
  20   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  21   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23   ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  24   LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  30   POSSIBILITY OF SUCH DAMAGE.
  31
  32 ******************************************************************************/
  33
  34 #include "ixl.h"
  35 #include "ixl_pf.h"
  36
  37 #ifdef IXL_IW
  38 #include "ixl_iw.h"
  39 #include "ixl_iw_int.h"
  40 #endif
  41
  42 #ifdef PCI_IOV
  43 #include "ixl_pf_iov.h"
  44 #endif
  45
  46 /*********************************************************************
  47  *  Driver version
  48  *********************************************************************/
  49 #define IXL_DRIVER_VERSION_MAJOR        2
  50 #define IXL_DRIVER_VERSION_MINOR        3
  51 #define IXL_DRIVER_VERSION_BUILD        3
  52
  53 #define IXL_DRIVER_VERSION_STRING                       \
  54     __XSTRING(IXL_DRIVER_VERSION_MAJOR) "."             \
  55     __XSTRING(IXL_DRIVER_VERSION_MINOR) "."             \
  56     __XSTRING(IXL_DRIVER_VERSION_BUILD) "-k"
  57
  58 /*********************************************************************
  59  *  PCI Device ID Table
  60  *
  61  *  Used by probe to select devices to load on
  62  *
  63  *  ( Vendor ID, Device ID, Branding String )
  64  *********************************************************************/
  65
  66 static const pci_vendor_info_t ixl_vendor_info_array[] =
  67 {
  68         PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_SFP_XL710, "Intel(R) Ethernet Controller X710 for 10GbE SFP+"),
  69         PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_KX_B, "Intel(R) Ethernet Controller XL710 for 40GbE backplane"),
  70         PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_KX_C, "Intel(R) Ethernet Controller X710 for 10GbE backplane"),
  71         PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_QSFP_A, "Intel(R) Ethernet Controller XL710 for 40GbE QSFP+"),
  72         PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_QSFP_B, "Intel(R) Ethernet Controller XL710 for 40GbE QSFP+"),
  73         PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_QSFP_C, "Intel(R) Ethernet Controller X710 for 10GbE QSFP+"),
  74         PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_10G_BASE_T, "Intel(R) Ethernet Controller X710 for 10GBASE-T"),
  75         PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_10G_BASE_T4, "Intel(R) Ethernet Controller X710/X557-AT 10GBASE-T"),
  76         PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_KX_X722, "Intel(R) Ethernet Connection X722 for 10GbE backplane"),
  77         PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_QSFP_X722, "Intel(R) Ethernet Connection X722 for 10GbE QSFP+"),
  78         PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_SFP_X722, "Intel(R) Ethernet Connection X722 for 10GbE SFP+"),
  79         PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_1G_BASE_T_X722, "Intel(R) Ethernet Connection X722 for 1GbE"),
  80         PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_10G_BASE_T_X722, "Intel(R) Ethernet Connection X722 for 10GBASE-T"),
  81         PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_SFP_I_X722, "Intel(R) Ethernet Connection X722 for 10GbE SFP+"),
  82         PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_25G_B, "Intel(R) Ethernet Controller XXV710 for 25GbE backplane"),
  83         PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_25G_SFP28, "Intel(R) Ethernet Controller XXV710 for 25GbE SFP28"),
  84         PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_10G_BASE_T_BC, "Intel(R) Ethernet Controller X710 for 10GBASE-T"),
  85         PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_10G_SFP, "Intel(R) Ethernet Controller X710 for 10GbE SFP+"),
  86         PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_10G_B, "Intel(R) Ethernet Controller X710 for 10GbE backplane"),
  87         PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_5G_BASE_T_BC, "Intel(R) Ethernet Controller V710 for 5GBASE-T"),
  88         PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_1G_BASE_T_BC, "Intel(R) Ethernet Controller I710 for 1GBASE-T"),
  89         /* required last entry */
  90         PVID_END
  91 };
  92
  93 /*********************************************************************
  94  *  Function prototypes
  95  *********************************************************************/
  96 /*** IFLIB interface ***/
  97 static void     *ixl_register(device_t dev);
  98 static int       ixl_if_attach_pre(if_ctx_t ctx);
  99 static int       ixl_if_attach_post(if_ctx_t ctx);
 100 static int       ixl_if_detach(if_ctx_t ctx);
 101 static int       ixl_if_shutdown(if_ctx_t ctx);
 102 static int       ixl_if_suspend(if_ctx_t ctx);
 103 static int       ixl_if_resume(if_ctx_t ctx);
 104 static int       ixl_if_msix_intr_assign(if_ctx_t ctx, int msix);
 105 static void      ixl_if_enable_intr(if_ctx_t ctx);
 106 static void      ixl_if_disable_intr(if_ctx_t ctx);
 107 static int       ixl_if_rx_queue_intr_enable(if_ctx_t ctx, uint16_t rxqid);
 108 static int       ixl_if_tx_queue_intr_enable(if_ctx_t ctx, uint16_t txqid);
 109 static int       ixl_if_tx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs, uint64_t *paddrs, int ntxqs, int ntxqsets);
 110 static int       ixl_if_rx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs, uint64_t *paddrs, int nqs, int nqsets);
 111 static void      ixl_if_queues_free(if_ctx_t ctx);
 112 static void      ixl_if_update_admin_status(if_ctx_t ctx);
 113 static void      ixl_if_multi_set(if_ctx_t ctx);
 114 static int       ixl_if_mtu_set(if_ctx_t ctx, uint32_t mtu);
 115 static void      ixl_if_media_status(if_ctx_t ctx, struct ifmediareq *ifmr);
 116 static int       ixl_if_media_change(if_ctx_t ctx);
 117 static int       ixl_if_promisc_set(if_ctx_t ctx, int flags);
 118 static void      ixl_if_timer(if_ctx_t ctx, uint16_t qid);
 119 static void      ixl_if_vlan_register(if_ctx_t ctx, u16 vtag);
 120 static void      ixl_if_vlan_unregister(if_ctx_t ctx, u16 vtag);
 121 static uint64_t  ixl_if_get_counter(if_ctx_t ctx, ift_counter cnt);
 122 static int       ixl_if_i2c_req(if_ctx_t ctx, struct ifi2creq *req);
 123 static int       ixl_if_priv_ioctl(if_ctx_t ctx, u_long command, caddr_t data);
 124 static bool      ixl_if_needs_restart(if_ctx_t ctx, enum iflib_restart_event event);
 125 #ifdef PCI_IOV
 126 static void      ixl_if_vflr_handle(if_ctx_t ctx);
 127 #endif
 128
 129 /*** Other ***/
 130 static void      ixl_save_pf_tunables(struct ixl_pf *);
 131 static int       ixl_allocate_pci_resources(struct ixl_pf *);
 132 static void      ixl_setup_ssctx(struct ixl_pf *pf);
 133 static void      ixl_admin_timer(void *arg);
 134
 135 /*********************************************************************
 136  *  FreeBSD Device Interface Entry Points
 137  *********************************************************************/
 138
 139 static device_method_t ixl_methods[] = {
 140         /* Device interface */
 141         DEVMETHOD(device_register, ixl_register),
 142         DEVMETHOD(device_probe, iflib_device_probe),
 143         DEVMETHOD(device_attach, iflib_device_attach),
 144         DEVMETHOD(device_detach, iflib_device_detach),
 145         DEVMETHOD(device_shutdown, iflib_device_shutdown),
 146 #ifdef PCI_IOV
 147         DEVMETHOD(pci_iov_init, iflib_device_iov_init),
 148         DEVMETHOD(pci_iov_uninit, iflib_device_iov_uninit),
 149         DEVMETHOD(pci_iov_add_vf, iflib_device_iov_add_vf),
 150 #endif
 151         DEVMETHOD_END
 152 };
 153
 154 static driver_t ixl_driver = {
 155         "ixl", ixl_methods, sizeof(struct ixl_pf),
 156 };
 157
 158 DRIVER_MODULE(ixl, pci, ixl_driver, 0, 0);
 159 IFLIB_PNP_INFO(pci, ixl, ixl_vendor_info_array);
 160 MODULE_VERSION(ixl, 3);
 161
 162 MODULE_DEPEND(ixl, pci, 1, 1, 1);
 163 MODULE_DEPEND(ixl, ether, 1, 1, 1);
 164 MODULE_DEPEND(ixl, iflib, 1, 1, 1);
 165
 166 static device_method_t ixl_if_methods[] = {
 167         DEVMETHOD(ifdi_attach_pre, ixl_if_attach_pre),
 168         DEVMETHOD(ifdi_attach_post, ixl_if_attach_post),
 169         DEVMETHOD(ifdi_detach, ixl_if_detach),
 170         DEVMETHOD(ifdi_shutdown, ixl_if_shutdown),
 171         DEVMETHOD(ifdi_suspend, ixl_if_suspend),
 172         DEVMETHOD(ifdi_resume, ixl_if_resume),
 173         DEVMETHOD(ifdi_init, ixl_if_init),
 174         DEVMETHOD(ifdi_stop, ixl_if_stop),
 175         DEVMETHOD(ifdi_msix_intr_assign, ixl_if_msix_intr_assign),
 176         DEVMETHOD(ifdi_intr_enable, ixl_if_enable_intr),
 177         DEVMETHOD(ifdi_intr_disable, ixl_if_disable_intr),
 178         DEVMETHOD(ifdi_rx_queue_intr_enable, ixl_if_rx_queue_intr_enable),
 179         DEVMETHOD(ifdi_tx_queue_intr_enable, ixl_if_tx_queue_intr_enable),
 180         DEVMETHOD(ifdi_tx_queues_alloc, ixl_if_tx_queues_alloc),
 181         DEVMETHOD(ifdi_rx_queues_alloc, ixl_if_rx_queues_alloc),
 182         DEVMETHOD(ifdi_queues_free, ixl_if_queues_free),
 183         DEVMETHOD(ifdi_update_admin_status, ixl_if_update_admin_status),
 184         DEVMETHOD(ifdi_multi_set, ixl_if_multi_set),
 185         DEVMETHOD(ifdi_mtu_set, ixl_if_mtu_set),
 186         DEVMETHOD(ifdi_media_status, ixl_if_media_status),
 187         DEVMETHOD(ifdi_media_change, ixl_if_media_change),
 188         DEVMETHOD(ifdi_promisc_set, ixl_if_promisc_set),
 189         DEVMETHOD(ifdi_timer, ixl_if_timer),
 190         DEVMETHOD(ifdi_vlan_register, ixl_if_vlan_register),
 191         DEVMETHOD(ifdi_vlan_unregister, ixl_if_vlan_unregister),
 192         DEVMETHOD(ifdi_get_counter, ixl_if_get_counter),
 193         DEVMETHOD(ifdi_i2c_req, ixl_if_i2c_req),
 194         DEVMETHOD(ifdi_priv_ioctl, ixl_if_priv_ioctl),
 195         DEVMETHOD(ifdi_needs_restart, ixl_if_needs_restart),
 196 #ifdef PCI_IOV
 197         DEVMETHOD(ifdi_iov_init, ixl_if_iov_init),
 198         DEVMETHOD(ifdi_iov_uninit, ixl_if_iov_uninit),
 199         DEVMETHOD(ifdi_iov_vf_add, ixl_if_iov_vf_add),
 200         DEVMETHOD(ifdi_vflr_handle, ixl_if_vflr_handle),
 201 #endif
 202         // ifdi_led_func
 203         // ifdi_debug
 204         DEVMETHOD_END
 205 };
 206
 207 static driver_t ixl_if_driver = {
 208         "ixl_if", ixl_if_methods, sizeof(struct ixl_pf)
 209 };
 210
 211 /*
 212 ** TUNEABLE PARAMETERS:
 213 */
 214
 215 static SYSCTL_NODE(_hw, OID_AUTO, ixl, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
 216     "ixl driver parameters");
 217
 218 #ifdef IXL_DEBUG_FC
 219 /*
 220  * Leave this on unless you need to send flow control
 221  * frames (or other control frames) from software
 222  */
 223 static int ixl_enable_tx_fc_filter = 1;
 224 TUNABLE_INT("hw.ixl.enable_tx_fc_filter",
 225     &ixl_enable_tx_fc_filter);
 226 SYSCTL_INT(_hw_ixl, OID_AUTO, enable_tx_fc_filter, CTLFLAG_RDTUN,
 227     &ixl_enable_tx_fc_filter, 0,
 228     "Filter out packets with Ethertype 0x8808 from being sent out by non-HW sources");
 229 #endif
 230
 231 #ifdef IXL_DEBUG
 232 static int ixl_debug_recovery_mode = 0;
 233 TUNABLE_INT("hw.ixl.debug_recovery_mode",
 234     &ixl_debug_recovery_mode);
 235 SYSCTL_INT(_hw_ixl, OID_AUTO, debug_recovery_mode, CTLFLAG_RDTUN,
 236     &ixl_debug_recovery_mode, 0,
 237     "Act like when FW entered recovery mode (for debugging)");
 238 #endif
 239
 240 static int ixl_i2c_access_method = 0;
 241 TUNABLE_INT("hw.ixl.i2c_access_method",
 242     &ixl_i2c_access_method);
 243 SYSCTL_INT(_hw_ixl, OID_AUTO, i2c_access_method, CTLFLAG_RDTUN,
 244     &ixl_i2c_access_method, 0,
 245     IXL_SYSCTL_HELP_I2C_METHOD);
 246
 247 static int ixl_enable_vf_loopback = 1;
 248 TUNABLE_INT("hw.ixl.enable_vf_loopback",
 249     &ixl_enable_vf_loopback);
 250 SYSCTL_INT(_hw_ixl, OID_AUTO, enable_vf_loopback, CTLFLAG_RDTUN,
 251     &ixl_enable_vf_loopback, 0,
 252     IXL_SYSCTL_HELP_VF_LOOPBACK);
 253
 254 /*
 255  * Different method for processing TX descriptor
 256  * completion.
 257  */
 258 static int ixl_enable_head_writeback = 1;
 259 TUNABLE_INT("hw.ixl.enable_head_writeback",
 260     &ixl_enable_head_writeback);
 261 SYSCTL_INT(_hw_ixl, OID_AUTO, enable_head_writeback, CTLFLAG_RDTUN,
 262     &ixl_enable_head_writeback, 0,
 263     "For detecting last completed TX descriptor by hardware, use value written by HW instead of checking descriptors");
 264
 265 static int ixl_core_debug_mask = 0;
 266 TUNABLE_INT("hw.ixl.core_debug_mask",
 267     &ixl_core_debug_mask);
 268 SYSCTL_INT(_hw_ixl, OID_AUTO, core_debug_mask, CTLFLAG_RDTUN,
 269     &ixl_core_debug_mask, 0,
 270     "Display debug statements that are printed in non-shared code");
 271
 272 static int ixl_shared_debug_mask = 0;
 273 TUNABLE_INT("hw.ixl.shared_debug_mask",
 274     &ixl_shared_debug_mask);
 275 SYSCTL_INT(_hw_ixl, OID_AUTO, shared_debug_mask, CTLFLAG_RDTUN,
 276     &ixl_shared_debug_mask, 0,
 277     "Display debug statements that are printed in shared code");
 278
 279 #if 0
 280 /*
 281 ** Controls for Interrupt Throttling
 282 **      - true/false for dynamic adjustment
 283 **      - default values for static ITR
 284 */
 285 static int ixl_dynamic_rx_itr = 0;
 286 TUNABLE_INT("hw.ixl.dynamic_rx_itr", &ixl_dynamic_rx_itr);
 287 SYSCTL_INT(_hw_ixl, OID_AUTO, dynamic_rx_itr, CTLFLAG_RDTUN,
 288     &ixl_dynamic_rx_itr, 0, "Dynamic RX Interrupt Rate");
 289
 290 static int ixl_dynamic_tx_itr = 0;
 291 TUNABLE_INT("hw.ixl.dynamic_tx_itr", &ixl_dynamic_tx_itr);
 292 SYSCTL_INT(_hw_ixl, OID_AUTO, dynamic_tx_itr, CTLFLAG_RDTUN,
 293     &ixl_dynamic_tx_itr, 0, "Dynamic TX Interrupt Rate");
 294 #endif
 295
 296 static int ixl_rx_itr = IXL_ITR_8K;
 297 TUNABLE_INT("hw.ixl.rx_itr", &ixl_rx_itr);
 298 SYSCTL_INT(_hw_ixl, OID_AUTO, rx_itr, CTLFLAG_RDTUN,
 299     &ixl_rx_itr, 0, "RX Interrupt Rate");
 300
 301 static int ixl_tx_itr = IXL_ITR_4K;
 302 TUNABLE_INT("hw.ixl.tx_itr", &ixl_tx_itr);
 303 SYSCTL_INT(_hw_ixl, OID_AUTO, tx_itr, CTLFLAG_RDTUN,
 304     &ixl_tx_itr, 0, "TX Interrupt Rate");
 305
 306 static int ixl_flow_control = -1;
 307 SYSCTL_INT(_hw_ixl, OID_AUTO, flow_control, CTLFLAG_RDTUN,
 308     &ixl_flow_control, 0, "Initial Flow Control setting");
 309
 310 #ifdef IXL_IW
 311 int ixl_enable_iwarp = 0;
 312 TUNABLE_INT("hw.ixl.enable_iwarp", &ixl_enable_iwarp);
 313 SYSCTL_INT(_hw_ixl, OID_AUTO, enable_iwarp, CTLFLAG_RDTUN,
 314     &ixl_enable_iwarp, 0, "iWARP enabled");
 315
 316 int ixl_limit_iwarp_msix = IXL_IW_MAX_MSIX;
 317 TUNABLE_INT("hw.ixl.limit_iwarp_msix", &ixl_limit_iwarp_msix);
 318 SYSCTL_INT(_hw_ixl, OID_AUTO, limit_iwarp_msix, CTLFLAG_RDTUN,
 319     &ixl_limit_iwarp_msix, 0, "Limit MSI-X vectors assigned to iWARP");
 320 #endif
 321
 322 extern struct if_txrx ixl_txrx_hwb;
 323 extern struct if_txrx ixl_txrx_dwb;
 324
 325 static struct if_shared_ctx ixl_sctx_init = {
 326         .isc_magic = IFLIB_MAGIC,
 327         .isc_q_align = PAGE_SIZE,
 328         .isc_tx_maxsize = IXL_TSO_SIZE + sizeof(struct ether_vlan_header),
 329         .isc_tx_maxsegsize = IXL_MAX_DMA_SEG_SIZE,
 330         .isc_tso_maxsize = IXL_TSO_SIZE + sizeof(struct ether_vlan_header),
 331         .isc_tso_maxsegsize = IXL_MAX_DMA_SEG_SIZE,
 332         .isc_rx_maxsize = 16384,
 333         .isc_rx_nsegments = IXL_MAX_RX_SEGS,
 334         .isc_rx_maxsegsize = IXL_MAX_DMA_SEG_SIZE,
 335         .isc_nfl = 1,
 336         .isc_ntxqs = 1,
 337         .isc_nrxqs = 1,
 338
 339         .isc_admin_intrcnt = 1,
 340         .isc_vendor_info = ixl_vendor_info_array,
 341         .isc_driver_version = IXL_DRIVER_VERSION_STRING,
 342         .isc_driver = &ixl_if_driver,
 343         .isc_flags = IFLIB_NEED_SCRATCH | IFLIB_NEED_ZERO_CSUM | IFLIB_TSO_INIT_IP | IFLIB_ADMIN_ALWAYS_RUN,
 344
 345         .isc_nrxd_min = {IXL_MIN_RING},
 346         .isc_ntxd_min = {IXL_MIN_RING},
 347         .isc_nrxd_max = {IXL_MAX_RING},
 348         .isc_ntxd_max = {IXL_MAX_RING},
 349         .isc_nrxd_default = {IXL_DEFAULT_RING},
 350         .isc_ntxd_default = {IXL_DEFAULT_RING},
 351 };
 352
 353 /*** Functions ***/
 354 static void *
 355 ixl_register(device_t dev)
 356 {
 357         return (&ixl_sctx_init);
 358 }
 359
 360 static int
 361 ixl_allocate_pci_resources(struct ixl_pf *pf)
 362 {
 363         device_t dev = iflib_get_dev(pf->vsi.ctx);
 364         struct i40e_hw *hw = &pf->hw;
 365         int             rid;
 366
 367         /* Map BAR0 */
 368         rid = PCIR_BAR(0);
 369         pf->pci_mem = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
 370             &rid, RF_ACTIVE);
 371
 372         if (!(pf->pci_mem)) {
 373                 device_printf(dev, "Unable to allocate bus resource: PCI memory\n");
 374                 return (ENXIO);
 375         }
 376
 377         /* Save off the PCI information */
 378         hw->vendor_id = pci_get_vendor(dev);
 379         hw->device_id = pci_get_device(dev);
 380         hw->revision_id = pci_read_config(dev, PCIR_REVID, 1);
 381         hw->subsystem_vendor_id =
 382             pci_read_config(dev, PCIR_SUBVEND_0, 2);
 383         hw->subsystem_device_id =
 384             pci_read_config(dev, PCIR_SUBDEV_0, 2);
 385
 386         hw->bus.device = pci_get_slot(dev);
 387         hw->bus.func = pci_get_function(dev);
 388
 389         /* Save off register access information */
 390         pf->osdep.mem_bus_space_tag =
 391                 rman_get_bustag(pf->pci_mem);
 392         pf->osdep.mem_bus_space_handle =
 393                 rman_get_bushandle(pf->pci_mem);
 394         pf->osdep.mem_bus_space_size = rman_get_size(pf->pci_mem);
 395         pf->osdep.flush_reg = I40E_GLGEN_STAT;
 396         pf->osdep.dev = dev;
 397
 398         pf->hw.hw_addr = (u8 *) &pf->osdep.mem_bus_space_handle;
 399         pf->hw.back = &pf->osdep;
 400
 401         return (0);
 402 }
 403
 404 static void
 405 ixl_setup_ssctx(struct ixl_pf *pf)
 406 {
 407         if_softc_ctx_t scctx = pf->vsi.shared;
 408         struct i40e_hw *hw = &pf->hw;
 409
 410         if (IXL_PF_IN_RECOVERY_MODE(pf)) {
 411                 scctx->isc_ntxqsets_max = scctx->isc_nrxqsets_max = 1;
 412                 scctx->isc_ntxqsets = scctx->isc_nrxqsets = 1;
 413         } else if (hw->mac.type == I40E_MAC_X722)
 414                 scctx->isc_ntxqsets_max = scctx->isc_nrxqsets_max = 128;
 415         else
 416                 scctx->isc_ntxqsets_max = scctx->isc_nrxqsets_max = 64;
 417
 418         if (pf->vsi.enable_head_writeback) {
 419                 scctx->isc_txqsizes[0] = roundup2(scctx->isc_ntxd[0]
 420                     * sizeof(struct i40e_tx_desc) + sizeof(u32), DBA_ALIGN);
 421                 scctx->isc_txrx = &ixl_txrx_hwb;
 422         } else {
 423                 scctx->isc_txqsizes[0] = roundup2(scctx->isc_ntxd[0]
 424                     * sizeof(struct i40e_tx_desc), DBA_ALIGN);
 425                 scctx->isc_txrx = &ixl_txrx_dwb;
 426         }
 427
 428         scctx->isc_txrx->ift_legacy_intr = ixl_intr;
 429         scctx->isc_rxqsizes[0] = roundup2(scctx->isc_nrxd[0]
 430             * sizeof(union i40e_32byte_rx_desc), DBA_ALIGN);
 431         scctx->isc_msix_bar = PCIR_BAR(IXL_MSIX_BAR);
 432         scctx->isc_tx_nsegments = IXL_MAX_TX_SEGS;
 433         scctx->isc_tx_tso_segments_max = IXL_MAX_TSO_SEGS;
 434         scctx->isc_tx_tso_size_max = IXL_TSO_SIZE;
 435         scctx->isc_tx_tso_segsize_max = IXL_MAX_DMA_SEG_SIZE;
 436         scctx->isc_rss_table_size = pf->hw.func_caps.rss_table_size;
 437         scctx->isc_tx_csum_flags = CSUM_OFFLOAD;
 438         scctx->isc_capabilities = scctx->isc_capenable = IXL_CAPS;
 439 }
 440
 441 static void
 442 ixl_admin_timer(void *arg)
 443 {
 444         struct ixl_pf *pf = (struct ixl_pf *)arg;
 445
 446         if (ixl_test_state(&pf->state, IXL_STATE_LINK_POLLING)) {
 447                 struct i40e_hw *hw = &pf->hw;
 448                 sbintime_t stime;
 449                 enum i40e_status_code status;
 450
 451                 hw->phy.get_link_info = TRUE;
 452                 status = i40e_get_link_status(hw, &pf->link_up);
 453                 if (status == I40E_SUCCESS) {
 454                         ixl_clear_state(&pf->state, IXL_STATE_LINK_POLLING);
 455                         /* OS link info is updated in the admin task */
 456                 } else {
 457                         device_printf(pf->dev,
 458                             "%s: i40e_get_link_status status %s, aq error %s\n",
 459                             __func__, i40e_stat_str(hw, status),
 460                             i40e_aq_str(hw, hw->aq.asq_last_status));
 461                         stime = getsbinuptime();
 462                         if (stime - pf->link_poll_start > IXL_PF_MAX_LINK_POLL) {
 463                                 device_printf(pf->dev, "Polling link status failed\n");
 464                                 ixl_clear_state(&pf->state, IXL_STATE_LINK_POLLING);
 465                         }
 466                 }
 467         }
 468
 469         /* Fire off the admin task */
 470         iflib_admin_intr_deferred(pf->vsi.ctx);
 471
 472         /* Reschedule the admin timer */
 473         callout_schedule(&pf->admin_timer, hz/2);
 474 }
 475
 476 static int
 477 ixl_attach_pre_recovery_mode(struct ixl_pf *pf)
 478 {
 479         struct ixl_vsi *vsi = &pf->vsi;
 480         struct i40e_hw *hw = &pf->hw;
 481         device_t dev = pf->dev;
 482
 483         device_printf(dev, "Firmware recovery mode detected. Limiting functionality. Refer to Intel(R) Ethernet Adapters and Devices User Guide for details on firmware recovery mode.\n");
 484
 485         i40e_get_mac_addr(hw, hw->mac.addr);
 486
 487         if (vsi->shared->isc_intr == IFLIB_INTR_MSIX) {
 488                 ixl_configure_intr0_msix(pf);
 489                 ixl_enable_intr0(hw);
 490         }
 491
 492         ixl_setup_ssctx(pf);
 493
 494         return (0);
 495 }
 496
 497 static int
 498 ixl_if_attach_pre(if_ctx_t ctx)
 499 {
 500         device_t dev;
 501         struct ixl_pf *pf;
 502         struct i40e_hw *hw;
 503         struct ixl_vsi *vsi;
 504         enum i40e_get_fw_lldp_status_resp lldp_status;
 505         struct i40e_filter_control_settings filter;
 506         enum i40e_status_code status;
 507         int error = 0;
 508
 509         dev = iflib_get_dev(ctx);
 510         pf = iflib_get_softc(ctx);
 511
 512         INIT_DBG_DEV(dev, "begin");
 513
 514         vsi = &pf->vsi;
 515         vsi->back = pf;
 516         pf->dev = dev;
 517         hw = &pf->hw;
 518
 519         vsi->dev = dev;
 520         vsi->hw = &pf->hw;
 521         vsi->id = 0;
 522         vsi->num_vlans = 0;
 523         vsi->ctx = ctx;
 524         vsi->media = iflib_get_media(ctx);
 525         vsi->shared = iflib_get_softc_ctx(ctx);
 526
 527         snprintf(pf->admin_mtx_name, sizeof(pf->admin_mtx_name),
 528             "%s:admin", device_get_nameunit(dev));
 529         mtx_init(&pf->admin_mtx, pf->admin_mtx_name, NULL, MTX_DEF);
 530         callout_init_mtx(&pf->admin_timer, &pf->admin_mtx, 0);
 531
 532         /* Save tunable values */
 533         ixl_save_pf_tunables(pf);
 534
 535         /* Do PCI setup - map BAR0, etc */
 536         if (ixl_allocate_pci_resources(pf)) {
 537                 device_printf(dev, "Allocation of PCI resources failed\n");
 538                 error = ENXIO;
 539                 goto err_pci_res;
 540         }
 541
 542         /* Establish a clean starting point */
 543         i40e_clear_hw(hw);
 544         i40e_set_mac_type(hw);
 545
 546         error = ixl_pf_reset(pf);
 547         if (error)
 548                 goto err_out;
 549
 550         /* Initialize the shared code */
 551         status = i40e_init_shared_code(hw);
 552         if (status) {
 553                 device_printf(dev, "Unable to initialize shared code, error %s\n",
 554                     i40e_stat_str(hw, status));
 555                 error = EIO;
 556                 goto err_out;
 557         }
 558
 559         /* Set up the admin queue */
 560         hw->aq.num_arq_entries = IXL_AQ_LEN;
 561         hw->aq.num_asq_entries = IXL_AQ_LEN;
 562         hw->aq.arq_buf_size = IXL_AQ_BUF_SZ;
 563         hw->aq.asq_buf_size = IXL_AQ_BUF_SZ;
 564
 565         status = i40e_init_adminq(hw);
 566         if (status != 0 && status != I40E_ERR_FIRMWARE_API_VERSION) {
 567                 device_printf(dev, "Unable to initialize Admin Queue, error %s\n",
 568                     i40e_stat_str(hw, status));
 569                 error = EIO;
 570                 goto err_out;
 571         }
 572         ixl_print_nvm_version(pf);
 573
 574         if (status == I40E_ERR_FIRMWARE_API_VERSION) {
 575                 device_printf(dev, "The driver for the device stopped "
 576                     "because the NVM image is newer than expected.\n");
 577                 device_printf(dev, "You must install the most recent version of "
 578                     "the network driver.\n");
 579                 error = EIO;
 580                 goto err_out;
 581         }
 582
 583         if (hw->aq.api_maj_ver == I40E_FW_API_VERSION_MAJOR &&
 584             hw->aq.api_min_ver > I40E_FW_MINOR_VERSION(hw)) {
 585                 device_printf(dev, "The driver for the device detected "
 586                     "a newer version of the NVM image than expected.\n");
 587                 device_printf(dev, "Please install the most recent version "
 588                     "of the network driver.\n");
 589         } else if (hw->aq.api_maj_ver == 1 && hw->aq.api_min_ver < 4) {
 590                 device_printf(dev, "The driver for the device detected "
 591                     "an older version of the NVM image than expected.\n");
 592                 device_printf(dev, "Please update the NVM image.\n");
 593         }
 594
 595         if (IXL_PF_IN_RECOVERY_MODE(pf)) {
 596                 error = ixl_attach_pre_recovery_mode(pf);
 597                 if (error)
 598                         goto err_out;
 599                 return (error);
 600         }
 601
 602         /* Clear PXE mode */
 603         i40e_clear_pxe_mode(hw);
 604
 605         /* Get capabilities from the device */
 606         error = ixl_get_hw_capabilities(pf);
 607         if (error) {
 608                 device_printf(dev, "get_hw_capabilities failed: %d\n",
 609                     error);
 610                 goto err_get_cap;
 611         }
 612
 613         /* Set up host memory cache */
 614         error = ixl_setup_hmc(pf);
 615         if (error)
 616                 goto err_mac_hmc;
 617
 618         /* Disable LLDP from the firmware for certain NVM versions */
 619         if (((pf->hw.aq.fw_maj_ver == 4) && (pf->hw.aq.fw_min_ver < 3)) ||
 620             (pf->hw.aq.fw_maj_ver < 4)) {
 621                 i40e_aq_stop_lldp(hw, true, false, NULL);
 622                 ixl_set_state(&pf->state, IXL_STATE_FW_LLDP_DISABLED);
 623         }
 624
 625         /* Try enabling Energy Efficient Ethernet (EEE) mode */
 626         if (i40e_enable_eee(hw, true) == I40E_SUCCESS)
 627                 ixl_set_state(&pf->state, IXL_STATE_EEE_ENABLED);
 628         else
 629                 ixl_clear_state(&pf->state, IXL_STATE_EEE_ENABLED);
 630
 631         /* Get MAC addresses from hardware */
 632         i40e_get_mac_addr(hw, hw->mac.addr);
 633         error = i40e_validate_mac_addr(hw->mac.addr);
 634         if (error) {
 635                 device_printf(dev, "validate_mac_addr failed: %d\n", error);
 636                 goto err_mac_hmc;
 637         }
 638         bcopy(hw->mac.addr, hw->mac.perm_addr, ETHER_ADDR_LEN);
 639         iflib_set_mac(ctx, hw->mac.addr);
 640         i40e_get_port_mac_addr(hw, hw->mac.port_addr);
 641
 642         /* Set up the device filtering */
 643         bzero(&filter, sizeof(filter));
 644         filter.enable_ethtype = TRUE;
 645         filter.enable_macvlan = TRUE;
 646         filter.enable_fdir = FALSE;
 647         filter.hash_lut_size = I40E_HASH_LUT_SIZE_512;
 648         if (i40e_set_filter_control(hw, &filter))
 649                 device_printf(dev, "i40e_set_filter_control() failed\n");
 650
 651         /* Query device FW LLDP status */
 652         if (i40e_get_fw_lldp_status(hw, &lldp_status) == I40E_SUCCESS) {
 653                 if (lldp_status == I40E_GET_FW_LLDP_STATUS_DISABLED) {
 654                         ixl_set_state(&pf->state,
 655                             IXL_STATE_FW_LLDP_DISABLED);
 656                 } else {
 657                         ixl_clear_state(&pf->state,
 658                             IXL_STATE_FW_LLDP_DISABLED);
 659                 }
 660         }
 661
 662         /* Tell FW to apply DCB config on link up */
 663         i40e_aq_set_dcb_parameters(hw, true, NULL);
 664
 665         /* Fill out iflib parameters */
 666         ixl_setup_ssctx(pf);
 667
 668         INIT_DBG_DEV(dev, "end");
 669         return (0);
 670
 671 err_mac_hmc:
 672         ixl_shutdown_hmc(pf);
 673 err_get_cap:
 674         i40e_shutdown_adminq(hw);
 675 err_out:
 676         ixl_free_pci_resources(pf);
 677 err_pci_res:
 678         mtx_lock(&pf->admin_mtx);
 679         callout_stop(&pf->admin_timer);
 680         mtx_unlock(&pf->admin_mtx);
 681         mtx_destroy(&pf->admin_mtx);
 682         return (error);
 683 }
 684
 685 static int
 686 ixl_if_attach_post(if_ctx_t ctx)
 687 {
 688         device_t dev;
 689         struct ixl_pf *pf;
 690         struct i40e_hw *hw;
 691         struct ixl_vsi *vsi;
 692         int error = 0;
 693         enum i40e_status_code status;
 694
 695         dev = iflib_get_dev(ctx);
 696         pf = iflib_get_softc(ctx);
 697
 698         INIT_DBG_DEV(dev, "begin");
 699
 700         vsi = &pf->vsi;
 701         vsi->ifp = iflib_get_ifp(ctx);
 702         hw = &pf->hw;
 703
 704         /* Save off determined number of queues for interface */
 705         vsi->num_rx_queues = vsi->shared->isc_nrxqsets;
 706         vsi->num_tx_queues = vsi->shared->isc_ntxqsets;
 707
 708         /* Setup OS network interface / ifnet */
 709         if (ixl_setup_interface(dev, pf)) {
 710                 device_printf(dev, "interface setup failed!\n");
 711                 error = EIO;
 712                 goto err;
 713         }
 714
 715         if (IXL_PF_IN_RECOVERY_MODE(pf)) {
 716                 /* Keep admin queue interrupts active while driver is loaded */
 717                 if (vsi->shared->isc_intr == IFLIB_INTR_MSIX) {
 718                         ixl_configure_intr0_msix(pf);
 719                         ixl_enable_intr0(hw);
 720                 }
 721
 722                 ixl_add_sysctls_recovery_mode(pf);
 723
 724                 /* Start the admin timer */
 725                 mtx_lock(&pf->admin_mtx);
 726                 callout_reset(&pf->admin_timer, hz/2, ixl_admin_timer, pf);
 727                 mtx_unlock(&pf->admin_mtx);
 728                 return (0);
 729         }
 730
 731         error = ixl_switch_config(pf);
 732         if (error) {
 733                 device_printf(dev, "Initial ixl_switch_config() failed: %d\n",
 734                      error);
 735                 goto err;
 736         }
 737
 738         /* Add protocol filters to list */
 739         ixl_init_filters(vsi);
 740
 741         /* Init queue allocation manager */
 742         error = ixl_pf_qmgr_init(&pf->qmgr, hw->func_caps.num_tx_qp);
 743         if (error) {
 744                 device_printf(dev, "Failed to init queue manager for PF queues, error %d\n",
 745                     error);
 746                 goto err;
 747         }
 748         /* reserve a contiguous allocation for the PF's VSI */
 749         error = ixl_pf_qmgr_alloc_contiguous(&pf->qmgr,
 750             max(vsi->num_rx_queues, vsi->num_tx_queues), &pf->qtag);
 751         if (error) {
 752                 device_printf(dev, "Failed to reserve queues for PF LAN VSI, error %d\n",
 753                     error);
 754                 goto err;
 755         }
 756         device_printf(dev, "Allocating %d queues for PF LAN VSI; %d queues active\n",
 757             pf->qtag.num_allocated, pf->qtag.num_active);
 758
 759         /* Determine link state */
 760         error = ixl_attach_get_link_status(pf);
 761         if (error == EINVAL)
 762                 goto err;
 763
 764         /* Limit PHY interrupts to link, autoneg, and modules failure */
 765         status = i40e_aq_set_phy_int_mask(hw, IXL_DEFAULT_PHY_INT_MASK,
 766             NULL);
 767         if (status) {
 768                 device_printf(dev, "i40e_aq_set_phy_mask() failed: err %s,"
 769                     " aq_err %s\n", i40e_stat_str(hw, status),
 770                     i40e_aq_str(hw, hw->aq.asq_last_status));
 771                 goto err;
 772         }
 773
 774         /* Get the bus configuration and set the shared code */
 775         ixl_get_bus_info(pf);
 776
 777         /* Keep admin queue interrupts active while driver is loaded */
 778         if (vsi->shared->isc_intr == IFLIB_INTR_MSIX) {
 779                 ixl_configure_intr0_msix(pf);
 780                 ixl_enable_intr0(hw);
 781         }
 782
 783         /* Set initial advertised speed sysctl value */
 784         ixl_set_initial_advertised_speeds(pf);
 785
 786         /* Initialize statistics & add sysctls */
 787         ixl_add_device_sysctls(pf);
 788         ixl_pf_reset_stats(pf);
 789         ixl_update_stats_counters(pf);
 790         ixl_add_hw_stats(pf);
 791
 792         /*
 793          * Driver may have been reloaded. Ensure that the link state
 794          * is consistent with current settings.
 795          */
 796         ixl_set_link(pf, ixl_test_state(&pf->state, IXL_STATE_LINK_ACTIVE_ON_DOWN));
 797
 798         hw->phy.get_link_info = true;
 799         status = i40e_get_link_status(hw, &pf->link_up);
 800         if (status != I40E_SUCCESS) {
 801                 device_printf(dev,
 802                     "%s get link status, status: %s aq_err=%s\n",
 803                     __func__, i40e_stat_str(hw, status),
 804                     i40e_aq_str(hw, hw->aq.asq_last_status));
 805                 /*
 806                  * Most probably FW has not finished configuring PHY.
 807                  * Retry periodically in a timer callback.
 808                  */
 809                 ixl_set_state(&pf->state, IXL_STATE_LINK_POLLING);
 810                 pf->link_poll_start = getsbinuptime();
 811         } else
 812                 ixl_update_link_status(pf);
 813
 814 #ifdef PCI_IOV
 815         ixl_initialize_sriov(pf);
 816 #endif
 817
 818 #ifdef IXL_IW
 819         if (hw->func_caps.iwarp && ixl_enable_iwarp) {
 820                 pf->iw_enabled = (pf->iw_msix > 0) ? true : false;
 821                 if (pf->iw_enabled) {
 822                         error = ixl_iw_pf_attach(pf);
 823                         if (error) {
 824                                 device_printf(dev,
 825                                     "interfacing to iWARP driver failed: %d\n",
 826                                     error);
 827                                 goto err;
 828                         } else
 829                                 device_printf(dev, "iWARP ready\n");
 830                 } else
 831                         device_printf(dev, "iWARP disabled on this device "
 832                             "(no MSI-X vectors)\n");
 833         } else {
 834                 pf->iw_enabled = false;
 835                 device_printf(dev, "The device is not iWARP enabled\n");
 836         }
 837 #endif
 838         /* Start the admin timer */
 839         mtx_lock(&pf->admin_mtx);
 840         callout_reset(&pf->admin_timer, hz/2, ixl_admin_timer, pf);
 841         mtx_unlock(&pf->admin_mtx);
 842
 843         INIT_DBG_DEV(dev, "end");
 844         return (0);
 845
 846 err:
 847         INIT_DEBUGOUT("end: error %d", error);
 848         /* ixl_if_detach() is called on error from this */
 849         return (error);
 850 }
 851
 852 /**
 853  * XXX: iflib always ignores the return value of detach()
 854  * -> This means that this isn't allowed to fail
 855  */
 856 static int
 857 ixl_if_detach(if_ctx_t ctx)
 858 {
 859         struct ixl_pf *pf = iflib_get_softc(ctx);
 860         struct ixl_vsi *vsi = &pf->vsi;
 861         struct i40e_hw *hw = &pf->hw;
 862         device_t dev = pf->dev;
 863         enum i40e_status_code   status;
 864 #ifdef IXL_IW
 865         int                     error;
 866 #endif
 867
 868         INIT_DBG_DEV(dev, "begin");
 869
 870         /* Stop the admin timer */
 871         mtx_lock(&pf->admin_mtx);
 872         callout_stop(&pf->admin_timer);
 873         mtx_unlock(&pf->admin_mtx);
 874         mtx_destroy(&pf->admin_mtx);
 875
 876 #ifdef IXL_IW
 877         if (ixl_enable_iwarp && pf->iw_enabled) {
 878                 error = ixl_iw_pf_detach(pf);
 879                 if (error == EBUSY) {
 880                         device_printf(dev, "iwarp in use; stop it first.\n");
 881                         //return (error);
 882                 }
 883         }
 884 #endif
 885         /* Remove all previously allocated media types */
 886         ifmedia_removeall(vsi->media);
 887
 888         /* Shutdown LAN HMC */
 889         ixl_shutdown_hmc(pf);
 890
 891         /* Shutdown admin queue */
 892         ixl_disable_intr0(hw);
 893         status = i40e_shutdown_adminq(hw);
 894         if (status)
 895                 device_printf(dev,
 896                     "i40e_shutdown_adminq() failed with status %s\n",
 897                     i40e_stat_str(hw, status));
 898
 899         ixl_pf_qmgr_destroy(&pf->qmgr);
 900         ixl_free_pci_resources(pf);
 901         ixl_free_filters(&vsi->ftl);
 902         INIT_DBG_DEV(dev, "end");
 903         return (0);
 904 }
 905
 906 static int
 907 ixl_if_shutdown(if_ctx_t ctx)
 908 {
 909         int error = 0;
 910
 911         INIT_DEBUGOUT("ixl_if_shutdown: begin");
 912
 913         /* TODO: Call ixl_if_stop()? */
 914
 915         /* TODO: Then setup low power mode */
 916
 917         return (error);
 918 }
 919
 920 static int
 921 ixl_if_suspend(if_ctx_t ctx)
 922 {
 923         int error = 0;
 924
 925         INIT_DEBUGOUT("ixl_if_suspend: begin");
 926
 927         /* TODO: Call ixl_if_stop()? */
 928
 929         /* TODO: Then setup low power mode */
 930
 931         return (error);
 932 }
 933
 934 static int
 935 ixl_if_resume(if_ctx_t ctx)
 936 {
 937         if_t ifp = iflib_get_ifp(ctx);
 938
 939         INIT_DEBUGOUT("ixl_if_resume: begin");
 940
 941         /* Read & clear wake-up registers */
 942
 943         /* Required after D3->D0 transition */
 944         if (if_getflags(ifp) & IFF_UP)
 945                 ixl_if_init(ctx);
 946
 947         return (0);
 948 }
 949
 950 void
 951 ixl_if_init(if_ctx_t ctx)
 952 {
 953         struct ixl_pf *pf = iflib_get_softc(ctx);
 954         struct ixl_vsi *vsi = &pf->vsi;
 955         struct i40e_hw  *hw = &pf->hw;
 956         if_t ifp = iflib_get_ifp(ctx);
 957         device_t        dev = iflib_get_dev(ctx);
 958         u8              tmpaddr[ETHER_ADDR_LEN];
 959         int             ret;
 960
 961         if (IXL_PF_IN_RECOVERY_MODE(pf))
 962                 return;
 963         /*
 964          * If the aq is dead here, it probably means something outside of the driver
 965          * did something to the adapter, like a PF reset.
 966          * So, rebuild the driver's state here if that occurs.
 967          */
 968         if (!i40e_check_asq_alive(&pf->hw)) {
 969                 device_printf(dev, "Admin Queue is down; resetting...\n");
 970                 ixl_teardown_hw_structs(pf);
 971                 ixl_rebuild_hw_structs_after_reset(pf, false);
 972         }
 973
 974         /* Get the latest mac address... User might use a LAA */
 975         bcopy(if_getlladdr(vsi->ifp), tmpaddr, ETH_ALEN);
 976         if (!ixl_ether_is_equal(hw->mac.addr, tmpaddr) &&
 977             (i40e_validate_mac_addr(tmpaddr) == I40E_SUCCESS)) {
 978                 ixl_del_all_vlan_filters(vsi, hw->mac.addr);
 979                 bcopy(tmpaddr, hw->mac.addr, ETH_ALEN);
 980                 ret = i40e_aq_mac_address_write(hw,
 981                     I40E_AQC_WRITE_TYPE_LAA_ONLY,
 982                     hw->mac.addr, NULL);
 983                 if (ret) {
 984                         device_printf(dev, "LLA address change failed!!\n");
 985                         return;
 986                 }
 987                 /*
 988                  * New filters are configured by ixl_reconfigure_filters
 989                  * at the end of ixl_init_locked.
 990                  */
 991         }
 992
 993         iflib_set_mac(ctx, hw->mac.addr);
 994
 995         /* Prepare the VSI: rings, hmc contexts, etc... */
 996         if (ixl_initialize_vsi(vsi)) {
 997                 device_printf(dev, "initialize vsi failed!!\n");
 998                 return;
 999         }
1000
1001         ixl_set_link(pf, true);
1002
1003         /* Reconfigure multicast filters in HW */
1004         ixl_if_multi_set(ctx);
1005
1006         /* Set up RSS */
1007         ixl_config_rss(pf);
1008
1009         /* Set up MSI-X routing and the ITR settings */
1010         if (vsi->shared->isc_intr == IFLIB_INTR_MSIX) {
1011                 ixl_configure_queue_intr_msix(pf);
1012                 ixl_configure_itr(pf);
1013         } else
1014                 ixl_configure_legacy(pf);
1015
1016         if (vsi->enable_head_writeback)
1017                 ixl_init_tx_cidx(vsi);
1018         else
1019                 ixl_init_tx_rsqs(vsi);
1020
1021         ixl_enable_rings(vsi);
1022
1023         i40e_aq_set_default_vsi(hw, vsi->seid, NULL);
1024
1025         /* Re-add configure filters to HW */
1026         ixl_reconfigure_filters(vsi);
1027
1028         /* Configure promiscuous mode */
1029         ixl_if_promisc_set(ctx, if_getflags(ifp));
1030
1031 #ifdef IXL_IW
1032         if (ixl_enable_iwarp && pf->iw_enabled) {
1033                 ret = ixl_iw_pf_init(pf);
1034                 if (ret)
1035                         device_printf(dev,
1036                             "initialize iwarp failed, code %d\n", ret);
1037         }
1038 #endif
1039 }
1040
1041 void
1042 ixl_if_stop(if_ctx_t ctx)
1043 {
1044         struct ixl_pf *pf = iflib_get_softc(ctx);
1045         if_t ifp = iflib_get_ifp(ctx);
1046         struct ixl_vsi *vsi = &pf->vsi;
1047
1048         INIT_DEBUGOUT("ixl_if_stop: begin\n");
1049
1050         if (IXL_PF_IN_RECOVERY_MODE(pf))
1051                 return;
1052
1053         // TODO: This may need to be reworked
1054 #ifdef IXL_IW
1055         /* Stop iWARP device */
1056         if (ixl_enable_iwarp && pf->iw_enabled)
1057                 ixl_iw_pf_stop(pf);
1058 #endif
1059
1060         ixl_disable_rings_intr(vsi);
1061         ixl_disable_rings(pf, vsi, &pf->qtag);
1062
1063         /*
1064          * Don't set link state if only reconfiguring
1065          * e.g. on MTU change.
1066          */
1067         if ((if_getflags(ifp) & IFF_UP) == 0 &&
1068             !ixl_test_state(&pf->state, IXL_STATE_LINK_ACTIVE_ON_DOWN))
1069                 ixl_set_link(pf, false);
1070 }
1071
1072 static int
1073 ixl_if_msix_intr_assign(if_ctx_t ctx, int msix)
1074 {
1075         struct ixl_pf *pf = iflib_get_softc(ctx);
1076         struct ixl_vsi *vsi = &pf->vsi;
1077         struct ixl_rx_queue *rx_que = vsi->rx_queues;
1078         struct ixl_tx_queue *tx_que = vsi->tx_queues;
1079         int err, i, rid, vector = 0;
1080         char buf[16];
1081
1082         MPASS(vsi->shared->isc_nrxqsets > 0);
1083         MPASS(vsi->shared->isc_ntxqsets > 0);
1084
1085         /* Admin Que must use vector 0*/
1086         rid = vector + 1;
1087         err = iflib_irq_alloc_generic(ctx, &vsi->irq, rid, IFLIB_INTR_ADMIN,
1088             ixl_msix_adminq, pf, 0, "aq");
1089         if (err) {
1090                 iflib_irq_free(ctx, &vsi->irq);
1091                 device_printf(iflib_get_dev(ctx),
1092                     "Failed to register Admin Que handler");
1093                 return (err);
1094         }
1095
1096 #ifdef PCI_IOV
1097         /* Create soft IRQ for handling VFLRs */
1098         iflib_softirq_alloc_generic(ctx, NULL, IFLIB_INTR_IOV, pf, 0, "iov");
1099 #endif
1100
1101         /* Now set up the stations */
1102         for (i = 0, vector = 1; i < vsi->shared->isc_nrxqsets; i++, vector++, rx_que++) {
1103                 rid = vector + 1;
1104
1105                 snprintf(buf, sizeof(buf), "rxq%d", i);
1106                 err = iflib_irq_alloc_generic(ctx, &rx_que->que_irq, rid,
1107                     IFLIB_INTR_RXTX, ixl_msix_que, rx_que, rx_que->rxr.me, buf);
1108                 /* XXX: Does the driver work as expected if there are fewer num_rx_queues than
1109                  * what's expected in the iflib context? */
1110                 if (err) {
1111                         device_printf(iflib_get_dev(ctx),
1112                             "Failed to allocate queue RX int vector %d, err: %d\n", i, err);
1113                         vsi->num_rx_queues = i + 1;
1114                         goto fail;
1115                 }
1116                 rx_que->msix = vector;
1117         }
1118
1119         bzero(buf, sizeof(buf));
1120
1121         for (i = 0; i < vsi->shared->isc_ntxqsets; i++, tx_que++) {
1122                 snprintf(buf, sizeof(buf), "txq%d", i);
1123                 iflib_softirq_alloc_generic(ctx,
1124                     &vsi->rx_queues[i % vsi->shared->isc_nrxqsets].que_irq,
1125                     IFLIB_INTR_TX, tx_que, tx_que->txr.me, buf);
1126
1127                 /* TODO: Maybe call a strategy function for this to figure out which
1128                 * interrupts to map Tx queues to. I don't know if there's an immediately
1129                 * better way than this other than a user-supplied map, though. */
1130                 tx_que->msix = (i % vsi->shared->isc_nrxqsets) + 1;
1131         }
1132
1133         return (0);
1134 fail:
1135         iflib_irq_free(ctx, &vsi->irq);
1136         rx_que = vsi->rx_queues;
1137         for (int i = 0; i < vsi->num_rx_queues; i++, rx_que++)
1138                 iflib_irq_free(ctx, &rx_que->que_irq);
1139         return (err);
1140 }
1141
1142 /*
1143  * Enable all interrupts
1144  *
1145  * Called in:
1146  * iflib_init_locked, after ixl_if_init()
1147  */
1148 static void
1149 ixl_if_enable_intr(if_ctx_t ctx)
1150 {
1151         struct ixl_pf *pf = iflib_get_softc(ctx);
1152         struct ixl_vsi *vsi = &pf->vsi;
1153         struct i40e_hw          *hw = vsi->hw;
1154         struct ixl_rx_queue     *que = vsi->rx_queues;
1155
1156         ixl_enable_intr0(hw);
1157         /* Enable queue interrupts */
1158         for (int i = 0; i < vsi->num_rx_queues; i++, que++)
1159                 /* TODO: Queue index parameter is probably wrong */
1160                 ixl_enable_queue(hw, que->rxr.me);
1161 }
1162
1163 /*
1164  * Disable queue interrupts
1165  *
1166  * Other interrupt causes need to remain active.
1167  */
1168 static void
1169 ixl_if_disable_intr(if_ctx_t ctx)
1170 {
1171         struct ixl_pf *pf = iflib_get_softc(ctx);
1172         struct ixl_vsi *vsi = &pf->vsi;
1173         struct i40e_hw          *hw = vsi->hw;
1174         struct ixl_rx_queue     *rx_que = vsi->rx_queues;
1175
1176         if (vsi->shared->isc_intr == IFLIB_INTR_MSIX) {
1177                 for (int i = 0; i < vsi->num_rx_queues; i++, rx_que++)
1178                         ixl_disable_queue(hw, rx_que->msix - 1);
1179         } else {
1180                 // Set PFINT_LNKLST0 FIRSTQ_INDX to 0x7FF
1181                 // stops queues from triggering interrupts
1182                 wr32(hw, I40E_PFINT_LNKLST0, 0x7FF);
1183         }
1184 }
1185
1186 static int
1187 ixl_if_rx_queue_intr_enable(if_ctx_t ctx, uint16_t rxqid)
1188 {
1189         struct ixl_pf *pf = iflib_get_softc(ctx);
1190         struct ixl_vsi *vsi = &pf->vsi;
1191         struct i40e_hw          *hw = vsi->hw;
1192         struct ixl_rx_queue     *rx_que = &vsi->rx_queues[rxqid];
1193
1194         ixl_enable_queue(hw, rx_que->msix - 1);
1195         return (0);
1196 }
1197
1198 static int
1199 ixl_if_tx_queue_intr_enable(if_ctx_t ctx, uint16_t txqid)
1200 {
1201         struct ixl_pf *pf = iflib_get_softc(ctx);
1202         struct ixl_vsi *vsi = &pf->vsi;
1203         struct i40e_hw *hw = vsi->hw;
1204         struct ixl_tx_queue *tx_que = &vsi->tx_queues[txqid];
1205
1206         ixl_enable_queue(hw, tx_que->msix - 1);
1207         return (0);
1208 }
1209
1210 static int
1211 ixl_if_tx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs, uint64_t *paddrs, int ntxqs, int ntxqsets)
1212 {
1213         struct ixl_pf *pf = iflib_get_softc(ctx);
1214         struct ixl_vsi *vsi = &pf->vsi;
1215         if_softc_ctx_t scctx = vsi->shared;
1216         struct ixl_tx_queue *que;
1217         int i, j, error = 0;
1218
1219         MPASS(scctx->isc_ntxqsets > 0);
1220         MPASS(ntxqs == 1);
1221         MPASS(scctx->isc_ntxqsets == ntxqsets);
1222
1223         /* Allocate queue structure memory */
1224         if (!(vsi->tx_queues =
1225             (struct ixl_tx_queue *) malloc(sizeof(struct ixl_tx_queue) *ntxqsets, M_IXL, M_NOWAIT | M_ZERO))) {
1226                 device_printf(iflib_get_dev(ctx), "Unable to allocate TX ring memory\n");
1227                 return (ENOMEM);
1228         }
1229
1230         for (i = 0, que = vsi->tx_queues; i < ntxqsets; i++, que++) {
1231                 struct tx_ring *txr = &que->txr;
1232
1233                 txr->me = i;
1234                 que->vsi = vsi;
1235
1236                 if (!vsi->enable_head_writeback) {
1237                         /* Allocate report status array */
1238                         if (!(txr->tx_rsq = malloc(sizeof(qidx_t) * scctx->isc_ntxd[0], M_IXL, M_NOWAIT))) {
1239                                 device_printf(iflib_get_dev(ctx), "failed to allocate tx_rsq memory\n");
1240                                 error = ENOMEM;
1241                                 goto fail;
1242                         }
1243                         /* Init report status array */
1244                         for (j = 0; j < scctx->isc_ntxd[0]; j++)
1245                                 txr->tx_rsq[j] = QIDX_INVALID;
1246                 }
1247                 /* get the virtual and physical address of the hardware queues */
1248                 txr->tail = I40E_QTX_TAIL(txr->me);
1249                 txr->tx_base = (struct i40e_tx_desc *)vaddrs[i * ntxqs];
1250                 txr->tx_paddr = paddrs[i * ntxqs];
1251                 txr->que = que;
1252         }
1253
1254         return (0);
1255 fail:
1256         ixl_if_queues_free(ctx);
1257         return (error);
1258 }
1259
1260 static int
1261 ixl_if_rx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs, uint64_t *paddrs, int nrxqs, int nrxqsets)
1262 {
1263         struct ixl_pf *pf = iflib_get_softc(ctx);
1264         struct ixl_vsi *vsi = &pf->vsi;
1265         struct ixl_rx_queue *que;
1266         int i, error = 0;
1267
1268 #ifdef INVARIANTS
1269         if_softc_ctx_t scctx = vsi->shared;
1270         MPASS(scctx->isc_nrxqsets > 0);
1271         MPASS(nrxqs == 1);
1272         MPASS(scctx->isc_nrxqsets == nrxqsets);
1273 #endif
1274
1275         /* Allocate queue structure memory */
1276         if (!(vsi->rx_queues =
1277             (struct ixl_rx_queue *) malloc(sizeof(struct ixl_rx_queue) *
1278             nrxqsets, M_IXL, M_NOWAIT | M_ZERO))) {
1279                 device_printf(iflib_get_dev(ctx), "Unable to allocate RX ring memory\n");
1280                 error = ENOMEM;
1281                 goto fail;
1282         }
1283
1284         for (i = 0, que = vsi->rx_queues; i < nrxqsets; i++, que++) {
1285                 struct rx_ring *rxr = &que->rxr;
1286
1287                 rxr->me = i;
1288                 que->vsi = vsi;
1289
1290                 /* get the virtual and physical address of the hardware queues */
1291                 rxr->tail = I40E_QRX_TAIL(rxr->me);
1292                 rxr->rx_base = (union i40e_rx_desc *)vaddrs[i * nrxqs];
1293                 rxr->rx_paddr = paddrs[i * nrxqs];
1294                 rxr->que = que;
1295         }
1296
1297         return (0);
1298 fail:
1299         ixl_if_queues_free(ctx);
1300         return (error);
1301 }
1302
1303 static void
1304 ixl_if_queues_free(if_ctx_t ctx)
1305 {
1306         struct ixl_pf *pf = iflib_get_softc(ctx);
1307         struct ixl_vsi *vsi = &pf->vsi;
1308
1309         if (vsi->tx_queues != NULL && !vsi->enable_head_writeback) {
1310                 struct ixl_tx_queue *que;
1311                 int i = 0;
1312
1313                 for (i = 0, que = vsi->tx_queues; i < vsi->num_tx_queues; i++, que++) {
1314                         struct tx_ring *txr = &que->txr;
1315                         if (txr->tx_rsq != NULL) {
1316                                 free(txr->tx_rsq, M_IXL);
1317                                 txr->tx_rsq = NULL;
1318                         }
1319                 }
1320         }
1321
1322         if (vsi->tx_queues != NULL) {
1323                 free(vsi->tx_queues, M_IXL);
1324                 vsi->tx_queues = NULL;
1325         }
1326         if (vsi->rx_queues != NULL) {
1327                 free(vsi->rx_queues, M_IXL);
1328                 vsi->rx_queues = NULL;
1329         }
1330
1331         if (!IXL_PF_IN_RECOVERY_MODE(pf))
1332                 sysctl_ctx_free(&vsi->sysctl_ctx);
1333 }
1334
1335 void
1336 ixl_update_link_status(struct ixl_pf *pf)
1337 {
1338         struct ixl_vsi *vsi = &pf->vsi;
1339         struct i40e_hw *hw = &pf->hw;
1340         u64 baudrate;
1341
1342         if (pf->link_up) {
1343                 if (vsi->link_active == FALSE) {
1344                         vsi->link_active = TRUE;
1345                         baudrate = ixl_max_aq_speed_to_value(hw->phy.link_info.link_speed);
1346                         iflib_link_state_change(vsi->ctx, LINK_STATE_UP, baudrate);
1347                         ixl_link_up_msg(pf);
1348 #ifdef PCI_IOV
1349                         ixl_broadcast_link_state(pf);
1350 #endif
1351                 }
1352         } else { /* Link down */
1353                 if (vsi->link_active == TRUE) {
1354                         vsi->link_active = FALSE;
1355                         iflib_link_state_change(vsi->ctx, LINK_STATE_DOWN, 0);
1356 #ifdef PCI_IOV
1357                         ixl_broadcast_link_state(pf);
1358 #endif
1359                 }
1360         }
1361 }
1362
1363 static void
1364 ixl_handle_lan_overflow_event(struct ixl_pf *pf, struct i40e_arq_event_info *e)
1365 {
1366         device_t dev = pf->dev;
1367         u32 rxq_idx, qtx_ctl;
1368
1369         rxq_idx = (e->desc.params.external.param0 & I40E_PRTDCB_RUPTQ_RXQNUM_MASK) >>
1370             I40E_PRTDCB_RUPTQ_RXQNUM_SHIFT;
1371         qtx_ctl = e->desc.params.external.param1;
1372
1373         device_printf(dev, "LAN overflow event: global rxq_idx %d\n", rxq_idx);
1374         device_printf(dev, "LAN overflow event: QTX_CTL 0x%08x\n", qtx_ctl);
1375 }
1376
1377 static int
1378 ixl_process_adminq(struct ixl_pf *pf, u16 *pending)
1379 {
1380         enum i40e_status_code status = I40E_SUCCESS;
1381         struct i40e_arq_event_info event;
1382         struct i40e_hw *hw = &pf->hw;
1383         device_t dev = pf->dev;
1384         u16 opcode;
1385         u32 loop = 0, reg;
1386
1387         event.buf_len = IXL_AQ_BUF_SZ;
1388         event.msg_buf = malloc(event.buf_len, M_IXL, M_NOWAIT | M_ZERO);
1389         if (!event.msg_buf) {
1390                 device_printf(dev, "%s: Unable to allocate memory for Admin"
1391                     " Queue event!\n", __func__);
1392                 return (ENOMEM);
1393         }
1394
1395         /* clean and process any events */
1396         do {
1397                 status = i40e_clean_arq_element(hw, &event, pending);
1398                 if (status)
1399                         break;
1400                 opcode = LE16_TO_CPU(event.desc.opcode);
1401                 ixl_dbg(pf, IXL_DBG_AQ,
1402                     "Admin Queue event: %#06x\n", opcode);
1403                 switch (opcode) {
1404                 case i40e_aqc_opc_get_link_status:
1405                         ixl_link_event(pf, &event);
1406                         break;
1407                 case i40e_aqc_opc_send_msg_to_pf:
1408 #ifdef PCI_IOV
1409                         ixl_handle_vf_msg(pf, &event);
1410 #endif
1411                         break;
1412                 /*
1413                  * This should only occur on no-drop queues, which
1414                  * aren't currently configured.
1415                  */
1416                 case i40e_aqc_opc_event_lan_overflow:
1417                         ixl_handle_lan_overflow_event(pf, &event);
1418                         break;
1419                 default:
1420                         break;
1421                 }
1422         } while (*pending && (loop++ < IXL_ADM_LIMIT));
1423
1424         free(event.msg_buf, M_IXL);
1425
1426         /* Re-enable admin queue interrupt cause */
1427         reg = rd32(hw, I40E_PFINT_ICR0_ENA);
1428         reg |= I40E_PFINT_ICR0_ENA_ADMINQ_MASK;
1429         wr32(hw, I40E_PFINT_ICR0_ENA, reg);
1430
1431         return (status);
1432 }
1433
1434 static void
1435 ixl_if_update_admin_status(if_ctx_t ctx)
1436 {
1437         struct ixl_pf   *pf = iflib_get_softc(ctx);
1438         struct i40e_hw  *hw = &pf->hw;
1439         u16             pending;
1440
1441         if (IXL_PF_IS_RESETTING(pf))
1442                 ixl_handle_empr_reset(pf);
1443
1444         /*
1445          * Admin Queue is shut down while handling reset.
1446          * Don't proceed if it hasn't been re-initialized
1447          * e.g due to an issue with new FW.
1448          */
1449         if (!i40e_check_asq_alive(&pf->hw))
1450                 return;
1451
1452         if (ixl_test_state(&pf->state, IXL_STATE_MDD_PENDING))
1453                 ixl_handle_mdd_event(pf);
1454
1455         ixl_process_adminq(pf, &pending);
1456         ixl_update_link_status(pf);
1457
1458         /*
1459          * If there are still messages to process, reschedule ourselves.
1460          * Otherwise, re-enable our interrupt and go to sleep.
1461          */
1462         if (pending > 0)
1463                 iflib_admin_intr_deferred(ctx);
1464         else
1465                 ixl_enable_intr0(hw);
1466 }
1467
1468 static void
1469 ixl_if_multi_set(if_ctx_t ctx)
1470 {
1471         struct ixl_pf *pf = iflib_get_softc(ctx);
1472         struct ixl_vsi *vsi = &pf->vsi;
1473         struct i40e_hw *hw = vsi->hw;
1474         int mcnt;
1475
1476         IOCTL_DEBUGOUT("ixl_if_multi_set: begin");
1477
1478         /* Delete filters for removed multicast addresses */
1479         ixl_del_multi(vsi, false);
1480
1481         mcnt = min(if_llmaddr_count(iflib_get_ifp(ctx)), MAX_MULTICAST_ADDR);
1482         if (__predict_false(mcnt == MAX_MULTICAST_ADDR)) {
1483                 i40e_aq_set_vsi_multicast_promiscuous(hw,
1484                     vsi->seid, TRUE, NULL);
1485                 ixl_del_multi(vsi, true);
1486                 return;
1487         }
1488
1489         ixl_add_multi(vsi);
1490         IOCTL_DEBUGOUT("ixl_if_multi_set: end");
1491 }
1492
1493 static int
1494 ixl_if_mtu_set(if_ctx_t ctx, uint32_t mtu)
1495 {
1496         struct ixl_pf *pf = iflib_get_softc(ctx);
1497         struct ixl_vsi *vsi = &pf->vsi;
1498
1499         IOCTL_DEBUGOUT("ioctl: SIOCSIFMTU (Set Interface MTU)");
1500         if (mtu > IXL_MAX_FRAME - ETHER_HDR_LEN - ETHER_CRC_LEN -
1501                 ETHER_VLAN_ENCAP_LEN)
1502                 return (EINVAL);
1503
1504         vsi->shared->isc_max_frame_size = mtu + ETHER_HDR_LEN + ETHER_CRC_LEN +
1505                 ETHER_VLAN_ENCAP_LEN;
1506
1507         return (0);
1508 }
1509
1510 static void
1511 ixl_if_media_status(if_ctx_t ctx, struct ifmediareq *ifmr)
1512 {
1513         struct ixl_pf *pf = iflib_get_softc(ctx);
1514         struct i40e_hw  *hw = &pf->hw;
1515
1516         INIT_DEBUGOUT("ixl_media_status: begin");
1517
1518         ifmr->ifm_status = IFM_AVALID;
1519         ifmr->ifm_active = IFM_ETHER;
1520
1521         if (!pf->link_up) {
1522                 return;
1523         }
1524
1525         ifmr->ifm_status |= IFM_ACTIVE;
1526         /* Hardware is always full-duplex */
1527         ifmr->ifm_active |= IFM_FDX;
1528
1529         switch (hw->phy.link_info.phy_type) {
1530                 /* 100 M */
1531                 case I40E_PHY_TYPE_100BASE_TX:
1532                         ifmr->ifm_active |= IFM_100_TX;
1533                         break;
1534                 /* 1 G */
1535                 case I40E_PHY_TYPE_1000BASE_T:
1536                         ifmr->ifm_active |= IFM_1000_T;
1537                         break;
1538                 case I40E_PHY_TYPE_1000BASE_SX:
1539                         ifmr->ifm_active |= IFM_1000_SX;
1540                         break;
1541                 case I40E_PHY_TYPE_1000BASE_LX:
1542                         ifmr->ifm_active |= IFM_1000_LX;
1543                         break;
1544                 case I40E_PHY_TYPE_1000BASE_T_OPTICAL:
1545                         ifmr->ifm_active |= IFM_1000_T;
1546                         break;
1547                 /* 2.5 G */
1548                 case I40E_PHY_TYPE_2_5GBASE_T_LINK_STATUS:
1549                         ifmr->ifm_active |= IFM_2500_T;
1550                         break;
1551                 /* 5 G */
1552                 case I40E_PHY_TYPE_5GBASE_T_LINK_STATUS:
1553                         ifmr->ifm_active |= IFM_5000_T;
1554                         break;
1555                 /* 10 G */
1556                 case I40E_PHY_TYPE_10GBASE_SFPP_CU:
1557                         ifmr->ifm_active |= IFM_10G_TWINAX;
1558                         break;
1559                 case I40E_PHY_TYPE_10GBASE_SR:
1560                         ifmr->ifm_active |= IFM_10G_SR;
1561                         break;
1562                 case I40E_PHY_TYPE_10GBASE_LR:
1563                         ifmr->ifm_active |= IFM_10G_LR;
1564                         break;
1565                 case I40E_PHY_TYPE_10GBASE_T:
1566                         ifmr->ifm_active |= IFM_10G_T;
1567                         break;
1568                 case I40E_PHY_TYPE_XAUI:
1569                 case I40E_PHY_TYPE_XFI:
1570                         ifmr->ifm_active |= IFM_10G_TWINAX;
1571                         break;
1572                 case I40E_PHY_TYPE_10GBASE_AOC:
1573                         ifmr->ifm_active |= IFM_10G_AOC;
1574                         break;
1575                 /* 25 G */
1576                 case I40E_PHY_TYPE_25GBASE_KR:
1577                         ifmr->ifm_active |= IFM_25G_KR;
1578                         break;
1579                 case I40E_PHY_TYPE_25GBASE_CR:
1580                         ifmr->ifm_active |= IFM_25G_CR;
1581                         break;
1582                 case I40E_PHY_TYPE_25GBASE_SR:
1583                         ifmr->ifm_active |= IFM_25G_SR;
1584                         break;
1585                 case I40E_PHY_TYPE_25GBASE_LR:
1586                         ifmr->ifm_active |= IFM_25G_LR;
1587                         break;
1588                 case I40E_PHY_TYPE_25GBASE_AOC:
1589                         ifmr->ifm_active |= IFM_25G_AOC;
1590                         break;
1591                 case I40E_PHY_TYPE_25GBASE_ACC:
1592                         ifmr->ifm_active |= IFM_25G_ACC;
1593                         break;
1594                 /* 40 G */
1595                 case I40E_PHY_TYPE_40GBASE_CR4:
1596                 case I40E_PHY_TYPE_40GBASE_CR4_CU:
1597                         ifmr->ifm_active |= IFM_40G_CR4;
1598                         break;
1599                 case I40E_PHY_TYPE_40GBASE_SR4:
1600                         ifmr->ifm_active |= IFM_40G_SR4;
1601                         break;
1602                 case I40E_PHY_TYPE_40GBASE_LR4:
1603                         ifmr->ifm_active |= IFM_40G_LR4;
1604                         break;
1605                 case I40E_PHY_TYPE_XLAUI:
1606                         ifmr->ifm_active |= IFM_OTHER;
1607                         break;
1608                 case I40E_PHY_TYPE_1000BASE_KX:
1609                         ifmr->ifm_active |= IFM_1000_KX;
1610                         break;
1611                 case I40E_PHY_TYPE_SGMII:
1612                         ifmr->ifm_active |= IFM_1000_SGMII;
1613                         break;
1614                 /* ERJ: What's the difference between these? */
1615                 case I40E_PHY_TYPE_10GBASE_CR1_CU:
1616                 case I40E_PHY_TYPE_10GBASE_CR1:
1617                         ifmr->ifm_active |= IFM_10G_CR1;
1618                         break;
1619                 case I40E_PHY_TYPE_10GBASE_KX4:
1620                         ifmr->ifm_active |= IFM_10G_KX4;
1621                         break;
1622                 case I40E_PHY_TYPE_10GBASE_KR:
1623                         ifmr->ifm_active |= IFM_10G_KR;
1624                         break;
1625                 case I40E_PHY_TYPE_SFI:
1626                         ifmr->ifm_active |= IFM_10G_SFI;
1627                         break;
1628                 /* Our single 20G media type */
1629                 case I40E_PHY_TYPE_20GBASE_KR2:
1630                         ifmr->ifm_active |= IFM_20G_KR2;
1631                         break;
1632                 case I40E_PHY_TYPE_40GBASE_KR4:
1633                         ifmr->ifm_active |= IFM_40G_KR4;
1634                         break;
1635                 case I40E_PHY_TYPE_XLPPI:
1636                 case I40E_PHY_TYPE_40GBASE_AOC:
1637                         ifmr->ifm_active |= IFM_40G_XLPPI;
1638                         break;
1639                 /* Unknown to driver */
1640                 default:
1641                         ifmr->ifm_active |= IFM_UNKNOWN;
1642                         break;
1643         }
1644         /* Report flow control status as well */
1645         if (hw->phy.link_info.an_info & I40E_AQ_LINK_PAUSE_TX)
1646                 ifmr->ifm_active |= IFM_ETH_TXPAUSE;
1647         if (hw->phy.link_info.an_info & I40E_AQ_LINK_PAUSE_RX)
1648                 ifmr->ifm_active |= IFM_ETH_RXPAUSE;
1649 }
1650
1651 static int
1652 ixl_if_media_change(if_ctx_t ctx)
1653 {
1654         struct ifmedia *ifm = iflib_get_media(ctx);
1655
1656         INIT_DEBUGOUT("ixl_media_change: begin");
1657
1658         if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)
1659                 return (EINVAL);
1660
1661         if_printf(iflib_get_ifp(ctx), "Media change is not supported.\n");
1662         return (ENODEV);
1663 }
1664
1665 static int
1666 ixl_if_promisc_set(if_ctx_t ctx, int flags)
1667 {
1668         struct ixl_pf *pf = iflib_get_softc(ctx);
1669         struct ixl_vsi *vsi = &pf->vsi;
1670         if_t ifp = iflib_get_ifp(ctx);
1671         struct i40e_hw  *hw = vsi->hw;
1672         int             err;
1673         bool            uni = FALSE, multi = FALSE;
1674
1675         if (flags & IFF_PROMISC)
1676                 uni = multi = TRUE;
1677         else if (flags & IFF_ALLMULTI || if_llmaddr_count(ifp) >=
1678             MAX_MULTICAST_ADDR)
1679                 multi = TRUE;
1680
1681         err = i40e_aq_set_vsi_unicast_promiscuous(hw,
1682             vsi->seid, uni, NULL, true);
1683         if (err)
1684                 return (err);
1685         err = i40e_aq_set_vsi_multicast_promiscuous(hw,
1686             vsi->seid, multi, NULL);
1687         return (err);
1688 }
1689
1690 static void
1691 ixl_if_timer(if_ctx_t ctx, uint16_t qid)
1692 {
1693         struct ixl_pf *pf = iflib_get_softc(ctx);
1694
1695         if (qid != 0)
1696                 return;
1697
1698         ixl_update_stats_counters(pf);
1699 }
1700
1701 static void
1702 ixl_if_vlan_register(if_ctx_t ctx, u16 vtag)
1703 {
1704         struct ixl_pf *pf = iflib_get_softc(ctx);
1705         struct ixl_vsi *vsi = &pf->vsi;
1706         struct i40e_hw  *hw = vsi->hw;
1707         if_t ifp = iflib_get_ifp(ctx);
1708
1709         if ((vtag == 0) || (vtag > 4095))       /* Invalid */
1710                 return;
1711
1712         /*
1713          * Keep track of registered VLANS to know what
1714          * filters have to be configured when VLAN_HWFILTER
1715          * capability is enabled.
1716          */
1717         ++vsi->num_vlans;
1718         bit_set(vsi->vlans_map, vtag);
1719
1720         if ((if_getcapenable(ifp) & IFCAP_VLAN_HWFILTER) == 0)
1721                 return;
1722
1723         if (vsi->num_vlans < IXL_MAX_VLAN_FILTERS)
1724                 ixl_add_filter(vsi, hw->mac.addr, vtag);
1725         else if (vsi->num_vlans == IXL_MAX_VLAN_FILTERS) {
1726                 /*
1727                  * There is not enough HW resources to add filters
1728                  * for all registered VLANs. Re-configure filtering
1729                  * to allow reception of all expected traffic.
1730                  */
1731                 device_printf(vsi->dev,
1732                     "Not enough HW filters for all VLANs. VLAN HW filtering disabled");
1733                 ixl_del_all_vlan_filters(vsi, hw->mac.addr);
1734                 ixl_add_filter(vsi, hw->mac.addr, IXL_VLAN_ANY);
1735         }
1736 }
1737
1738 static void
1739 ixl_if_vlan_unregister(if_ctx_t ctx, u16 vtag)
1740 {
1741         struct ixl_pf *pf = iflib_get_softc(ctx);
1742         struct ixl_vsi *vsi = &pf->vsi;
1743         struct i40e_hw  *hw = vsi->hw;
1744         if_t ifp = iflib_get_ifp(ctx);
1745
1746         if ((vtag == 0) || (vtag > 4095))       /* Invalid */
1747                 return;
1748
1749         --vsi->num_vlans;
1750         bit_clear(vsi->vlans_map, vtag);
1751
1752         if ((if_getcapenable(ifp) & IFCAP_VLAN_HWFILTER) == 0)
1753                 return;
1754
1755         /* One filter is used for untagged frames */
1756         if (vsi->num_vlans < IXL_MAX_VLAN_FILTERS - 1)
1757                 ixl_del_filter(vsi, hw->mac.addr, vtag);
1758         else if (vsi->num_vlans == IXL_MAX_VLAN_FILTERS - 1) {
1759                 ixl_del_filter(vsi, hw->mac.addr, IXL_VLAN_ANY);
1760                 ixl_add_vlan_filters(vsi, hw->mac.addr);
1761         }
1762 }
1763
1764 static uint64_t
1765 ixl_if_get_counter(if_ctx_t ctx, ift_counter cnt)
1766 {
1767         struct ixl_pf *pf = iflib_get_softc(ctx);
1768         struct ixl_vsi *vsi = &pf->vsi;
1769         if_t ifp = iflib_get_ifp(ctx);
1770
1771         switch (cnt) {
1772         case IFCOUNTER_IPACKETS:
1773                 return (vsi->ipackets);
1774         case IFCOUNTER_IERRORS:
1775                 return (vsi->ierrors);
1776         case IFCOUNTER_OPACKETS:
1777                 return (vsi->opackets);
1778         case IFCOUNTER_OERRORS:
1779                 return (vsi->oerrors);
1780         case IFCOUNTER_COLLISIONS:
1781                 /* Collisions are by standard impossible in 40G/10G Ethernet */
1782                 return (0);
1783         case IFCOUNTER_IBYTES:
1784                 return (vsi->ibytes);
1785         case IFCOUNTER_OBYTES:
1786                 return (vsi->obytes);
1787         case IFCOUNTER_IMCASTS:
1788                 return (vsi->imcasts);
1789         case IFCOUNTER_OMCASTS:
1790                 return (vsi->omcasts);
1791         case IFCOUNTER_IQDROPS:
1792                 return (vsi->iqdrops);
1793         case IFCOUNTER_OQDROPS:
1794                 return (vsi->oqdrops);
1795         case IFCOUNTER_NOPROTO:
1796                 return (vsi->noproto);
1797         default:
1798                 return (if_get_counter_default(ifp, cnt));
1799         }
1800 }
1801
1802 #ifdef PCI_IOV
1803 static void
1804 ixl_if_vflr_handle(if_ctx_t ctx)
1805 {
1806         struct ixl_pf *pf = iflib_get_softc(ctx);
1807
1808         ixl_handle_vflr(pf);
1809 }
1810 #endif
1811
1812 static int
1813 ixl_if_i2c_req(if_ctx_t ctx, struct ifi2creq *req)
1814 {
1815         struct ixl_pf           *pf = iflib_get_softc(ctx);
1816
1817         if (pf->read_i2c_byte == NULL)
1818                 return (EINVAL);
1819
1820         for (int i = 0; i < req->len; i++)
1821                 if (pf->read_i2c_byte(pf, req->offset + i,
1822                     req->dev_addr, &req->data[i]))
1823                         return (EIO);
1824         return (0);
1825 }
1826
1827 static int
1828 ixl_if_priv_ioctl(if_ctx_t ctx, u_long command, caddr_t data)
1829 {
1830         struct ixl_pf *pf = iflib_get_softc(ctx);
1831         struct ifdrv *ifd = (struct ifdrv *)data;
1832         int error = 0;
1833
1834         /*
1835          * The iflib_if_ioctl forwards SIOCxDRVSPEC and SIOGPRIVATE_0 without
1836          * performing privilege checks. It is important that this function
1837          * perform the necessary checks for commands which should only be
1838          * executed by privileged threads.
1839          */
1840
1841         switch(command) {
1842         case SIOCGDRVSPEC:
1843         case SIOCSDRVSPEC:
1844                 /* NVM update command */
1845                 if (ifd->ifd_cmd == I40E_NVM_ACCESS) {
1846                         error = priv_check(curthread, PRIV_DRIVER);
1847                         if (error)
1848                                 break;
1849                         error = ixl_handle_nvmupd_cmd(pf, ifd);
1850                 } else {
1851                         error = EINVAL;
1852                 }
1853                 break;
1854         default:
1855                 error = EOPNOTSUPP;
1856         }
1857
1858         return (error);
1859 }
1860
1861 /* ixl_if_needs_restart - Tell iflib when the driver needs to be reinitialized
1862  * @ctx: iflib context
1863  * @event: event code to check
1864  *
1865  * Defaults to returning false for every event.
1866  *
1867  * @returns true if iflib needs to reinit the interface, false otherwise
1868  */
1869 static bool
1870 ixl_if_needs_restart(if_ctx_t ctx __unused, enum iflib_restart_event event)
1871 {
1872         switch (event) {
1873         case IFLIB_RESTART_VLAN_CONFIG:
1874         default:
1875                 return (false);
1876         }
1877 }
1878
1879 /*
1880  * Sanity check and save off tunable values.
1881  */
1882 static void
1883 ixl_save_pf_tunables(struct ixl_pf *pf)
1884 {
1885         device_t dev = pf->dev;
1886
1887         /* Save tunable information */
1888 #ifdef IXL_DEBUG_FC
1889         pf->enable_tx_fc_filter = ixl_enable_tx_fc_filter;
1890 #endif
1891 #ifdef IXL_DEBUG
1892         pf->recovery_mode = ixl_debug_recovery_mode;
1893 #endif
1894         pf->dbg_mask = ixl_core_debug_mask;
1895         pf->hw.debug_mask = ixl_shared_debug_mask;
1896         pf->vsi.enable_head_writeback = !!(ixl_enable_head_writeback);
1897         pf->enable_vf_loopback = !!(ixl_enable_vf_loopback);
1898 #if 0
1899         pf->dynamic_rx_itr = ixl_dynamic_rx_itr;
1900         pf->dynamic_tx_itr = ixl_dynamic_tx_itr;
1901 #endif
1902
1903         if (ixl_i2c_access_method > 3 || ixl_i2c_access_method < 0)
1904                 pf->i2c_access_method = 0;
1905         else
1906                 pf->i2c_access_method = ixl_i2c_access_method;
1907
1908         if (ixl_tx_itr < 0 || ixl_tx_itr > IXL_MAX_ITR) {
1909                 device_printf(dev, "Invalid tx_itr value of %d set!\n",
1910                     ixl_tx_itr);
1911                 device_printf(dev, "tx_itr must be between %d and %d, "
1912                     "inclusive\n",
1913                     0, IXL_MAX_ITR);
1914                 device_printf(dev, "Using default value of %d instead\n",
1915                     IXL_ITR_4K);
1916                 pf->tx_itr = IXL_ITR_4K;
1917         } else
1918                 pf->tx_itr = ixl_tx_itr;
1919
1920         if (ixl_rx_itr < 0 || ixl_rx_itr > IXL_MAX_ITR) {
1921                 device_printf(dev, "Invalid rx_itr value of %d set!\n",
1922                     ixl_rx_itr);
1923                 device_printf(dev, "rx_itr must be between %d and %d, "
1924                     "inclusive\n",
1925                     0, IXL_MAX_ITR);
1926                 device_printf(dev, "Using default value of %d instead\n",
1927                     IXL_ITR_8K);
1928                 pf->rx_itr = IXL_ITR_8K;
1929         } else
1930                 pf->rx_itr = ixl_rx_itr;
1931
1932         pf->fc = -1;
1933         if (ixl_flow_control != -1) {
1934                 if (ixl_flow_control < 0 || ixl_flow_control > 3) {
1935                         device_printf(dev,
1936                             "Invalid flow_control value of %d set!\n",
1937                             ixl_flow_control);
1938                         device_printf(dev,
1939                             "flow_control must be between %d and %d, "
1940                             "inclusive\n", 0, 3);
1941                         device_printf(dev,
1942                             "Using default configuration instead\n");
1943                 } else
1944                         pf->fc = ixl_flow_control;
1945         }
1946 }
1947