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