Page MenuHomeFreeBSD
Files F156669618

D15577.id43030.diff
No OneTemporary
Actions

D15577.id43030.diff
View Options

This file is larger than 256 KB, so syntax highlighting was skipped.
Index: sys/amd64/conf/GENERIC
===================================================================
--- sys/amd64/conf/GENERIC
+++ sys/amd64/conf/GENERIC
@@ -240,8 +240,8 @@
device ix # Intel PRO/10GbE PCIE PF Ethernet
device ixv # Intel PRO/10GbE PCIE VF Ethernet
device ixl # Intel XL710 40Gbe PCIE Ethernet
-options IXL_IW # Enable iWARP Client Interface in ixl(4)
-device ixlv # Intel XL710 40Gbe VF PCIE Ethernet
+#options IXL_IW # Enable iWARP Client Interface in ixl(4)
+#device ixlv # Intel XL710 40Gbe VF PCIE Ethernet
device le # AMD Am7900 LANCE and Am79C9xx PCnet
device ti # Alteon Networks Tigon I/II gigabit Ethernet
device txp # 3Com 3cR990 (``Typhoon'')
Index: sys/conf/files.amd64
===================================================================
--- sys/conf/files.amd64
+++ sys/conf/files.amd64
@@ -270,10 +270,10 @@
compile-with "${NORMAL_C} -I$S/dev/ixl"
dev/ixl/ixl_pf_i2c.c optional ixl pci \
compile-with "${NORMAL_C} -I$S/dev/ixl"
-dev/ixl/ixl_iw.c optional ixl pci \
- compile-with "${NORMAL_C} -I$S/dev/ixl"
-dev/ixl/if_ixlv.c optional ixlv pci \
- compile-with "${NORMAL_C} -I$S/dev/ixl"
+#dev/ixl/ixl_iw.c optional ixl pci \
+# compile-with "${NORMAL_C} -I$S/dev/ixl"
+#dev/ixl/if_ixlv.c optional ixlv pci \
+# compile-with "${NORMAL_C} -I$S/dev/ixl"
dev/ixl/ixlvc.c optional ixlv pci \
compile-with "${NORMAL_C} -I$S/dev/ixl"
dev/ixl/ixl_txrx.c optional ixl pci | ixlv pci \
Index: sys/dev/ixl/i40e_osdep.c
===================================================================
--- sys/dev/ixl/i40e_osdep.c
+++ sys/dev/ixl/i40e_osdep.c
@@ -132,7 +132,7 @@
bus_dmamap_unload(mem->tag, mem->map);
bus_dmamem_free(mem->tag, mem->va, mem->map);
bus_dma_tag_destroy(mem->tag);
- return (0);
+ return (I40E_SUCCESS);
}
void
Index: sys/dev/ixl/if_ixl.c
===================================================================
--- sys/dev/ixl/if_ixl.c
+++ sys/dev/ixl/if_ixl.c
@@ -51,60 +51,79 @@
#define IXL_DRIVER_VERSION_MINOR 9
#define IXL_DRIVER_VERSION_BUILD 9
-char ixl_driver_version[] = __XSTRING(IXL_DRIVER_VERSION_MAJOR) "."
- __XSTRING(IXL_DRIVER_VERSION_MINOR) "."
- __XSTRING(IXL_DRIVER_VERSION_BUILD) "-k";
+#define IXL_DRIVER_VERSION_STRING \
+ __XSTRING(IXL_DRIVER_VERSION_MAJOR) "." \
+ __XSTRING(IXL_DRIVER_VERSION_MINOR) "." \
+ __XSTRING(IXL_DRIVER_VERSION_BUILD) "-iflib-k"
/*********************************************************************
* PCI Device ID Table
*
* Used by probe to select devices to load on
- * Last field stores an index into ixl_strings
- * Last entry must be all 0s
*
- * { Vendor ID, Device ID, SubVendor ID, SubDevice ID, String Index }
+ * ( Vendor ID, Device ID, Branding String )
*********************************************************************/
-static ixl_vendor_info_t ixl_vendor_info_array[] =
-{
- {I40E_INTEL_VENDOR_ID, I40E_DEV_ID_SFP_XL710, 0, 0, 0},
- {I40E_INTEL_VENDOR_ID, I40E_DEV_ID_KX_B, 0, 0, 0},
- {I40E_INTEL_VENDOR_ID, I40E_DEV_ID_KX_C, 0, 0, 0},
- {I40E_INTEL_VENDOR_ID, I40E_DEV_ID_QSFP_A, 0, 0, 0},
- {I40E_INTEL_VENDOR_ID, I40E_DEV_ID_QSFP_B, 0, 0, 0},
- {I40E_INTEL_VENDOR_ID, I40E_DEV_ID_QSFP_C, 0, 0, 0},
- {I40E_INTEL_VENDOR_ID, I40E_DEV_ID_10G_BASE_T, 0, 0, 0},
- {I40E_INTEL_VENDOR_ID, I40E_DEV_ID_10G_BASE_T4, 0, 0, 0},
- {I40E_INTEL_VENDOR_ID, I40E_DEV_ID_KX_X722, 0, 0, 0},
- {I40E_INTEL_VENDOR_ID, I40E_DEV_ID_QSFP_X722, 0, 0, 0},
- {I40E_INTEL_VENDOR_ID, I40E_DEV_ID_SFP_X722, 0, 0, 0},
- {I40E_INTEL_VENDOR_ID, I40E_DEV_ID_1G_BASE_T_X722, 0, 0, 0},
- {I40E_INTEL_VENDOR_ID, I40E_DEV_ID_10G_BASE_T_X722, 0, 0, 0},
- {I40E_INTEL_VENDOR_ID, I40E_DEV_ID_SFP_I_X722, 0, 0, 0},
- {I40E_INTEL_VENDOR_ID, I40E_DEV_ID_25G_B, 0, 0, 0},
- {I40E_INTEL_VENDOR_ID, I40E_DEV_ID_25G_SFP28, 0, 0, 0},
+static pci_vendor_info_t ixl_vendor_info_array[] =
+{
+ PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_SFP_XL710, "Intel(R) Ethernet Controller X710 for 10GbE SFP+"),
+ PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_KX_B, "Intel(R) Ethernet Controller XL710 for 40GbE backplane"),
+ PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_KX_C, "Intel(R) Ethernet Controller X710 for 10GbE backplane"),
+ PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_QSFP_A, "Intel(R) Ethernet Controller XL710 for 40GbE QSFP+"),
+ PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_QSFP_B, "Intel(R) Ethernet Controller XL710 for 40GbE QSFP+"),
+ PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_QSFP_C, "Intel(R) Ethernet Controller X710 for 10GbE QSFP+"),
+ PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_10G_BASE_T, "Intel(R) Ethernet Controller X710 for 10GBASE-T"),
+ PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_10G_BASE_T4, "Intel(R) Ethernet Controller X710/X557-AT 10GBASE-T"),
+ PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_KX_X722, "Intel(R) Ethernet Connection X722 for 10GbE backplane"),
+ PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_QSFP_X722, "Intel(R) Ethernet Connection X722 for 10GbE QSFP+"),
+ PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_SFP_X722, "Intel(R) Ethernet Connection X722 for 10GbE SFP+"),
+ PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_1G_BASE_T_X722, "Intel(R) Ethernet Connection X722 for 1GbE"),
+ PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_10G_BASE_T_X722, "Intel(R) Ethernet Connection X722 for 10GBASE-T"),
+ PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_SFP_I_X722, "Intel(R) Ethernet Connection X722 for 10GbE SFP+"),
+ PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_25G_B, "Intel(R) Ethernet Controller XXV710 for 25GbE backplane"),
+ PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_25G_SFP28, "Intel(R) Ethernet Controller XXV710 for 25GbE SFP28"),
/* required last entry */
- {0, 0, 0, 0, 0}
-};
-
-/*********************************************************************
- * Table of branding strings
- *********************************************************************/
-
-static char *ixl_strings[] = {
- "Intel(R) Ethernet Connection 700 Series PF Driver"
+ PVID_END
};
-
/*********************************************************************
* Function prototypes
*********************************************************************/
-static int ixl_probe(device_t);
-static int ixl_attach(device_t);
-static int ixl_detach(device_t);
-static int ixl_shutdown(device_t);
-
-static int ixl_save_pf_tunables(struct ixl_pf *);
+/*** IFLIB interface ***/
+static void *ixl_register(device_t dev);
+static int ixl_if_attach_pre(if_ctx_t ctx);
+static int ixl_if_attach_post(if_ctx_t ctx);
+static int ixl_if_detach(if_ctx_t ctx);
+static int ixl_if_shutdown(if_ctx_t ctx);
+static int ixl_if_suspend(if_ctx_t ctx);
+static int ixl_if_resume(if_ctx_t ctx);
+static int ixl_if_msix_intr_assign(if_ctx_t ctx, int msix);
+static void ixl_if_enable_intr(if_ctx_t ctx);
+static void ixl_if_disable_intr(if_ctx_t ctx);
+static int ixl_if_rx_queue_intr_enable(if_ctx_t ctx, uint16_t rxqid);
+static int ixl_if_tx_queue_intr_enable(if_ctx_t ctx, uint16_t txqid);
+static int ixl_if_tx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs, uint64_t *paddrs, int ntxqs, int ntxqsets);
+static int ixl_if_rx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs, uint64_t *paddrs, int nqs, int nqsets);
+static void ixl_if_queues_free(if_ctx_t ctx);
+static void ixl_if_update_admin_status(if_ctx_t ctx);
+static void ixl_if_multi_set(if_ctx_t ctx);
+static int ixl_if_mtu_set(if_ctx_t ctx, uint32_t mtu);
+static void ixl_if_media_status(if_ctx_t ctx, struct ifmediareq *ifmr);
+static int ixl_if_media_change(if_ctx_t ctx);
+static int ixl_if_promisc_set(if_ctx_t ctx, int flags);
+static void ixl_if_timer(if_ctx_t ctx, uint16_t qid);
+static void ixl_if_vlan_register(if_ctx_t ctx, u16 vtag);
+static void ixl_if_vlan_unregister(if_ctx_t ctx, u16 vtag);
+static uint64_t ixl_if_get_counter(if_ctx_t ctx, ift_counter cnt);
+static void ixl_if_vflr_handle(if_ctx_t ctx);
+// static void ixl_if_link_intr_enable(if_ctx_t ctx);
+static int ixl_if_i2c_req(if_ctx_t ctx, struct ifi2creq *req);
+static int ixl_if_priv_ioctl(if_ctx_t ctx, u_long command, caddr_t data);
+
+/*** Other ***/
+static int ixl_mc_filter_apply(void *arg, struct ifmultiaddr *ifma, int);
+static void ixl_save_pf_tunables(struct ixl_pf *);
+static int ixl_allocate_pci_resources(struct ixl_pf *);
/*********************************************************************
* FreeBSD Device Interface Entry Points
@@ -112,16 +131,17 @@
static device_method_t ixl_methods[] = {
/* Device interface */
- DEVMETHOD(device_probe, ixl_probe),
- DEVMETHOD(device_attach, ixl_attach),
- DEVMETHOD(device_detach, ixl_detach),
- DEVMETHOD(device_shutdown, ixl_shutdown),
+ DEVMETHOD(device_register, ixl_register),
+ DEVMETHOD(device_probe, iflib_device_probe),
+ DEVMETHOD(device_attach, iflib_device_attach),
+ DEVMETHOD(device_detach, iflib_device_detach),
+ DEVMETHOD(device_shutdown, iflib_device_shutdown),
#ifdef PCI_IOV
DEVMETHOD(pci_iov_init, ixl_iov_init),
DEVMETHOD(pci_iov_uninit, ixl_iov_uninit),
DEVMETHOD(pci_iov_add_vf, ixl_add_vf),
#endif
- {0, 0}
+ DEVMETHOD_END
};
static driver_t ixl_driver = {
@@ -130,14 +150,51 @@
devclass_t ixl_devclass;
DRIVER_MODULE(ixl, pci, ixl_driver, ixl_devclass, 0, 0);
-
-MODULE_VERSION(ixl, 1);
+MODULE_VERSION(ixl, 3);
MODULE_DEPEND(ixl, pci, 1, 1, 1);
MODULE_DEPEND(ixl, ether, 1, 1, 1);
-#if defined(DEV_NETMAP) && __FreeBSD_version >= 1100000
-MODULE_DEPEND(ixl, netmap, 1, 1, 1);
-#endif /* DEV_NETMAP */
+MODULE_DEPEND(ixl, iflib, 1, 1, 1);
+
+static device_method_t ixl_if_methods[] = {
+ DEVMETHOD(ifdi_attach_pre, ixl_if_attach_pre),
+ DEVMETHOD(ifdi_attach_post, ixl_if_attach_post),
+ DEVMETHOD(ifdi_detach, ixl_if_detach),
+ DEVMETHOD(ifdi_shutdown, ixl_if_shutdown),
+ DEVMETHOD(ifdi_suspend, ixl_if_suspend),
+ DEVMETHOD(ifdi_resume, ixl_if_resume),
+ DEVMETHOD(ifdi_init, ixl_if_init),
+ DEVMETHOD(ifdi_stop, ixl_if_stop),
+ DEVMETHOD(ifdi_msix_intr_assign, ixl_if_msix_intr_assign),
+ DEVMETHOD(ifdi_intr_enable, ixl_if_enable_intr),
+ DEVMETHOD(ifdi_intr_disable, ixl_if_disable_intr),
+ //DEVMETHOD(ifdi_link_intr_enable, ixl_if_link_intr_enable),
+ DEVMETHOD(ifdi_rx_queue_intr_enable, ixl_if_rx_queue_intr_enable),
+ DEVMETHOD(ifdi_tx_queue_intr_enable, ixl_if_tx_queue_intr_enable),
+ DEVMETHOD(ifdi_tx_queues_alloc, ixl_if_tx_queues_alloc),
+ DEVMETHOD(ifdi_rx_queues_alloc, ixl_if_rx_queues_alloc),
+ DEVMETHOD(ifdi_queues_free, ixl_if_queues_free),
+ DEVMETHOD(ifdi_update_admin_status, ixl_if_update_admin_status),
+ DEVMETHOD(ifdi_multi_set, ixl_if_multi_set),
+ DEVMETHOD(ifdi_mtu_set, ixl_if_mtu_set),
+ DEVMETHOD(ifdi_media_status, ixl_if_media_status),
+ DEVMETHOD(ifdi_media_change, ixl_if_media_change),
+ DEVMETHOD(ifdi_promisc_set, ixl_if_promisc_set),
+ DEVMETHOD(ifdi_timer, ixl_if_timer),
+ DEVMETHOD(ifdi_vlan_register, ixl_if_vlan_register),
+ DEVMETHOD(ifdi_vlan_unregister, ixl_if_vlan_unregister),
+ DEVMETHOD(ifdi_get_counter, ixl_if_get_counter),
+ DEVMETHOD(ifdi_vflr_handle, ixl_if_vflr_handle),
+ DEVMETHOD(ifdi_i2c_req, ixl_if_i2c_req),
+ DEVMETHOD(ifdi_priv_ioctl, ixl_if_priv_ioctl),
+ // ifdi_led_func
+ // ifdi_debug
+ DEVMETHOD_END
+};
+
+static driver_t ixl_if_driver = {
+ "ixl_if", ixl_if_methods, sizeof(struct ixl_pf)
+};
/*
** TUNEABLE PARAMETERS:
@@ -146,39 +203,6 @@
static SYSCTL_NODE(_hw, OID_AUTO, ixl, CTLFLAG_RD, 0,
"IXL driver parameters");
-/*
- * MSIX should be the default for best performance,
- * but this allows it to be forced off for testing.
- */
-static int ixl_enable_msix = 1;
-TUNABLE_INT("hw.ixl.enable_msix", &ixl_enable_msix);
-SYSCTL_INT(_hw_ixl, OID_AUTO, enable_msix, CTLFLAG_RDTUN, &ixl_enable_msix, 0,
- "Enable MSI-X interrupts");
-
-/*
-** Number of descriptors per ring
-** - TX and RX sizes are independently configurable
-*/
-static int ixl_tx_ring_size = IXL_DEFAULT_RING;
-TUNABLE_INT("hw.ixl.tx_ring_size", &ixl_tx_ring_size);
-SYSCTL_INT(_hw_ixl, OID_AUTO, tx_ring_size, CTLFLAG_RDTUN,
- &ixl_tx_ring_size, 0, "TX Descriptor Ring Size");
-
-static int ixl_rx_ring_size = IXL_DEFAULT_RING;
-TUNABLE_INT("hw.ixl.rx_ring_size", &ixl_rx_ring_size);
-SYSCTL_INT(_hw_ixl, OID_AUTO, rx_ring_size, CTLFLAG_RDTUN,
- &ixl_rx_ring_size, 0, "RX Descriptor Ring Size");
-
-/*
-** This can be set manually, if left as 0 the
-** number of queues will be calculated based
-** on cpus and msix vectors available.
-*/
-static int ixl_max_queues = 0;
-TUNABLE_INT("hw.ixl.max_queues", &ixl_max_queues);
-SYSCTL_INT(_hw_ixl, OID_AUTO, max_queues, CTLFLAG_RDTUN,
- &ixl_max_queues, 0, "Number of Queues");
-
/*
* Leave this on unless you need to send flow control
* frames (or other control frames) from software
@@ -190,6 +214,13 @@
&ixl_enable_tx_fc_filter, 0,
"Filter out packets with Ethertype 0x8808 from being sent out by non-HW sources");
+static int ixl_i2c_access_method = 0;
+TUNABLE_INT("hw.ixl.i2c_access_method",
+ &ixl_i2c_access_method);
+SYSCTL_INT(_hw_ixl, OID_AUTO, i2c_access_method, CTLFLAG_RDTUN,
+ &ixl_i2c_access_method, 0,
+ IXL_SYSCTL_HELP_I2C_METHOD);
+
/*
* Different method for processing TX descriptor
* completion.
@@ -215,20 +246,22 @@
&ixl_shared_debug_mask, 0,
"Display debug statements that are printed in shared code");
+#if 0
/*
** Controls for Interrupt Throttling
** - true/false for dynamic adjustment
** - default values for static ITR
*/
-static int ixl_dynamic_rx_itr = 1;
+static int ixl_dynamic_rx_itr = 0;
TUNABLE_INT("hw.ixl.dynamic_rx_itr", &ixl_dynamic_rx_itr);
SYSCTL_INT(_hw_ixl, OID_AUTO, dynamic_rx_itr, CTLFLAG_RDTUN,
&ixl_dynamic_rx_itr, 0, "Dynamic RX Interrupt Rate");
-static int ixl_dynamic_tx_itr = 1;
+static int ixl_dynamic_tx_itr = 0;
TUNABLE_INT("hw.ixl.dynamic_tx_itr", &ixl_dynamic_tx_itr);
SYSCTL_INT(_hw_ixl, OID_AUTO, dynamic_tx_itr, CTLFLAG_RDTUN,
&ixl_dynamic_tx_itr, 0, "Dynamic TX Interrupt Rate");
+#endif
static int ixl_rx_itr = IXL_ITR_8K;
TUNABLE_INT("hw.ixl.rx_itr", &ixl_rx_itr);
@@ -256,165 +289,131 @@
&ixl_limit_iwarp_msix, 0, "Limit MSIX vectors assigned to iWARP");
#endif
-#ifdef DEV_NETMAP
-#define NETMAP_IXL_MAIN /* only bring in one part of the netmap code */
-#include <dev/netmap/if_ixl_netmap.h>
-#endif /* DEV_NETMAP */
+extern struct if_txrx ixl_txrx_hwb;
+extern struct if_txrx ixl_txrx_dwb;
+
+static struct if_shared_ctx ixl_sctx_init = {
+ .isc_magic = IFLIB_MAGIC,
+ .isc_q_align = PAGE_SIZE,
+ .isc_tx_maxsize = IXL_TSO_SIZE,
+ .isc_tx_maxsegsize = IXL_MAX_DMA_SEG_SIZE,
+
+ .isc_rx_maxsize = 16384,
+ .isc_rx_nsegments = IXL_MAX_RX_SEGS,
+ .isc_rx_maxsegsize = IXL_MAX_DMA_SEG_SIZE,
+ .isc_nfl = 1,
+ .isc_ntxqs = 1,
+ .isc_nrxqs = 1,
+
+ .isc_admin_intrcnt = 1,
+ .isc_vendor_info = ixl_vendor_info_array,
+ .isc_driver_version = IXL_DRIVER_VERSION_STRING,
+ .isc_driver = &ixl_if_driver,
+ .isc_flags = IFLIB_NEED_SCRATCH | IFLIB_NEED_ZERO_CSUM | IFLIB_ADMIN_ALWAYS_RUN,
+
+ .isc_nrxd_min = {IXL_MIN_RING},
+ .isc_ntxd_min = {IXL_MIN_RING},
+ .isc_nrxd_max = {IXL_MAX_RING},
+ .isc_ntxd_max = {IXL_MAX_RING},
+ .isc_nrxd_default = {IXL_DEFAULT_RING},
+ .isc_ntxd_default = {IXL_DEFAULT_RING},
+};
-/*********************************************************************
- * Device identification routine
- *
- * ixl_probe determines if the driver should be loaded on
- * the hardware based on PCI vendor/device id of the device.
- *
- * return BUS_PROBE_DEFAULT on success, positive on failure
- *********************************************************************/
+if_shared_ctx_t ixl_sctx = &ixl_sctx_init;
-static int
-ixl_probe(device_t dev)
+/*** Functions ***/
+static void *
+ixl_register(device_t dev)
{
- ixl_vendor_info_t *ent;
-
- u16 pci_vendor_id, pci_device_id;
- u16 pci_subvendor_id, pci_subdevice_id;
- char device_name[256];
-
-#if 0
- INIT_DEBUGOUT("ixl_probe: begin");
-#endif
- pci_vendor_id = pci_get_vendor(dev);
- if (pci_vendor_id != I40E_INTEL_VENDOR_ID)
- return (ENXIO);
-
- pci_device_id = pci_get_device(dev);
- pci_subvendor_id = pci_get_subvendor(dev);
- pci_subdevice_id = pci_get_subdevice(dev);
-
- ent = ixl_vendor_info_array;
- while (ent->vendor_id != 0) {
- if ((pci_vendor_id == ent->vendor_id) &&
- (pci_device_id == ent->device_id) &&
-
- ((pci_subvendor_id == ent->subvendor_id) ||
- (ent->subvendor_id == 0)) &&
-
- ((pci_subdevice_id == ent->subdevice_id) ||
- (ent->subdevice_id == 0))) {
- sprintf(device_name, "%s, Version - %s",
- ixl_strings[ent->index],
- ixl_driver_version);
- device_set_desc_copy(dev, device_name);
- return (BUS_PROBE_DEFAULT);
- }
- ent++;
- }
- return (ENXIO);
+ return (ixl_sctx);
}
-/*
- * Sanity check and save off tunable values.
- */
static int
-ixl_save_pf_tunables(struct ixl_pf *pf)
+ixl_allocate_pci_resources(struct ixl_pf *pf)
{
- device_t dev = pf->dev;
-
- /* Save tunable information */
- pf->enable_msix = ixl_enable_msix;
- pf->max_queues = ixl_max_queues;
- pf->enable_tx_fc_filter = ixl_enable_tx_fc_filter;
- pf->dynamic_rx_itr = ixl_dynamic_rx_itr;
- pf->dynamic_tx_itr = ixl_dynamic_tx_itr;
- pf->dbg_mask = ixl_core_debug_mask;
- pf->hw.debug_mask = ixl_shared_debug_mask;
-#ifdef DEV_NETMAP
- if (ixl_enable_head_writeback == 0)
- device_printf(dev, "Head writeback mode cannot be disabled "
- "when netmap is enabled\n");
- pf->vsi.enable_head_writeback = 1;
-#else
- pf->vsi.enable_head_writeback = !!(ixl_enable_head_writeback);
-#endif
-
- ixl_vsi_setup_rings_size(&pf->vsi, ixl_tx_ring_size, ixl_rx_ring_size);
-
- if (ixl_tx_itr < 0 || ixl_tx_itr > IXL_MAX_ITR) {
- device_printf(dev, "Invalid tx_itr value of %d set!\n",
- ixl_tx_itr);
- device_printf(dev, "tx_itr must be between %d and %d, "
- "inclusive\n",
- 0, IXL_MAX_ITR);
- device_printf(dev, "Using default value of %d instead\n",
- IXL_ITR_4K);
- pf->tx_itr = IXL_ITR_4K;
- } else
- pf->tx_itr = ixl_tx_itr;
-
- if (ixl_rx_itr < 0 || ixl_rx_itr > IXL_MAX_ITR) {
- device_printf(dev, "Invalid rx_itr value of %d set!\n",
- ixl_rx_itr);
- device_printf(dev, "rx_itr must be between %d and %d, "
- "inclusive\n",
- 0, IXL_MAX_ITR);
- device_printf(dev, "Using default value of %d instead\n",
- IXL_ITR_8K);
- pf->rx_itr = IXL_ITR_8K;
- } else
- pf->rx_itr = ixl_rx_itr;
-
- return (0);
-}
+ int rid;
+ struct i40e_hw *hw = &pf->hw;
+ device_t dev = iflib_get_dev(pf->vsi.ctx);
+
+ /* Map BAR0 */
+ rid = PCIR_BAR(0);
+ pf->pci_mem = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
+ &rid, RF_ACTIVE);
+
+ if (!(pf->pci_mem)) {
+ device_printf(dev, "Unable to allocate bus resource: PCI memory\n");
+ return (ENXIO);
+ }
-/*********************************************************************
- * Device initialization routine
- *
- * The attach entry point is called when the driver is being loaded.
- * This routine identifies the type of hardware, allocates all resources
- * and initializes the hardware.
- *
- * return 0 on success, positive on failure
- *********************************************************************/
+ /* Save off the PCI information */
+ hw->vendor_id = pci_get_vendor(dev);
+ hw->device_id = pci_get_device(dev);
+ hw->revision_id = pci_read_config(dev, PCIR_REVID, 1);
+ hw->subsystem_vendor_id =
+ pci_read_config(dev, PCIR_SUBVEND_0, 2);
+ hw->subsystem_device_id =
+ pci_read_config(dev, PCIR_SUBDEV_0, 2);
+
+ hw->bus.device = pci_get_slot(dev);
+ hw->bus.func = pci_get_function(dev);
+
+ /* Save off register access information */
+ pf->osdep.mem_bus_space_tag =
+ rman_get_bustag(pf->pci_mem);
+ pf->osdep.mem_bus_space_handle =
+ rman_get_bushandle(pf->pci_mem);
+ pf->osdep.mem_bus_space_size = rman_get_size(pf->pci_mem);
+ pf->osdep.flush_reg = I40E_GLGEN_STAT;
+ pf->osdep.dev = dev;
+
+ pf->hw.hw_addr = (u8 *) &pf->osdep.mem_bus_space_handle;
+ pf->hw.back = &pf->osdep;
+
+ return (0);
+ }
static int
-ixl_attach(device_t dev)
+ixl_if_attach_pre(if_ctx_t ctx)
{
- struct ixl_pf *pf;
- struct i40e_hw *hw;
- struct ixl_vsi *vsi;
+ device_t dev;
+ struct ixl_pf *pf;
+ struct i40e_hw *hw;
+ struct ixl_vsi *vsi;
+ if_softc_ctx_t scctx;
+ struct i40e_filter_control_settings filter;
enum i40e_status_code status;
- int error = 0;
+ int error = 0;
- INIT_DEBUGOUT("ixl_attach: begin");
+ INIT_DEBUGOUT("ixl_if_attach_pre: begin");
/* Allocate, clear, and link in our primary soft structure */
- pf = device_get_softc(dev);
- pf->dev = pf->osdep.dev = dev;
+ dev = iflib_get_dev(ctx);
+ pf = iflib_get_softc(ctx);
+ vsi = &pf->vsi;
+ vsi->back = pf;
+ pf->dev = dev;
hw = &pf->hw;
/*
** Note this assumes we have a single embedded VSI,
** this could be enhanced later to allocate multiple
*/
- vsi = &pf->vsi;
- vsi->dev = pf->dev;
- vsi->back = pf;
+ //vsi->dev = pf->dev;
+ vsi->hw = &pf->hw;
+ vsi->id = 0;
+ vsi->num_vlans = 0;
+ vsi->ctx = ctx;
+ vsi->media = iflib_get_media(ctx);
+ vsi->shared = scctx = iflib_get_softc_ctx(ctx);
/* Save tunable values */
- error = ixl_save_pf_tunables(pf);
- if (error)
- return (error);
-
- /* Core Lock Init*/
- IXL_PF_LOCK_INIT(pf, device_get_nameunit(dev));
-
- /* Set up the timer callout */
- callout_init_mtx(&pf->timer, &pf->pf_mtx, 0);
+ ixl_save_pf_tunables(pf);
/* Do PCI setup - map BAR0, etc */
if (ixl_allocate_pci_resources(pf)) {
device_printf(dev, "Allocation of PCI resources failed\n");
error = ENXIO;
- goto err_out;
+ goto err_pci_res;
}
/* Establish a clean starting point */
@@ -478,16 +477,11 @@
/* Get capabilities from the device */
error = ixl_get_hw_capabilities(pf);
if (error) {
- device_printf(dev, "HW capabilities failure!\n");
+ device_printf(dev, "get_hw_capabilities failed: %d\n",
+ error);
goto err_get_cap;
}
- /*
- * Allocate interrupts and figure out number of queues to use
- * for PF interface
- */
- pf->msix = ixl_init_msix(pf);
-
/* Set up host memory cache */
status = i40e_init_lan_hmc(hw, hw->func_caps.num_tx_qp,
hw->func_caps.num_rx_qp, 0, 0);
@@ -496,7 +490,6 @@
i40e_stat_str(hw, status));
goto err_get_cap;
}
-
status = i40e_configure_lan_hmc(hw, I40E_HMC_MODEL_DIRECT_ONLY);
if (status) {
device_printf(dev, "configure_lan_hmc failed: %s\n",
@@ -504,23 +497,6 @@
goto err_mac_hmc;
}
- /* Init queue allocation manager */
- error = ixl_pf_qmgr_init(&pf->qmgr, hw->func_caps.num_tx_qp);
- if (error) {
- device_printf(dev, "Failed to init queue manager for PF queues, error %d\n",
- error);
- goto err_mac_hmc;
- }
- /* reserve a contiguous allocation for the PF's VSI */
- error = ixl_pf_qmgr_alloc_contiguous(&pf->qmgr, vsi->num_queues, &pf->qtag);
- if (error) {
- device_printf(dev, "Failed to reserve queues for PF LAN VSI, error %d\n",
- error);
- goto err_mac_hmc;
- }
- device_printf(dev, "Allocating %d queues for PF LAN VSI; %d queues active\n",
- pf->qtag.num_allocated, pf->qtag.num_active);
-
/* Disable LLDP from the firmware for certain NVM versions */
if (((pf->hw.aq.fw_maj_ver == 4) && (pf->hw.aq.fw_min_ver < 3)) ||
(pf->hw.aq.fw_maj_ver < 4)) {
@@ -536,45 +512,119 @@
goto err_mac_hmc;
}
bcopy(hw->mac.addr, hw->mac.perm_addr, ETHER_ADDR_LEN);
+ iflib_set_mac(ctx, hw->mac.addr);
i40e_get_port_mac_addr(hw, hw->mac.port_addr);
+ /* Set up the device filtering */
+ bzero(&filter, sizeof(filter));
+ filter.enable_ethtype = TRUE;
+ filter.enable_macvlan = TRUE;
+ filter.enable_fdir = FALSE;
+ filter.hash_lut_size = I40E_HASH_LUT_SIZE_512;
+ if (i40e_set_filter_control(hw, &filter))
+ device_printf(dev, "i40e_set_filter_control() failed\n");
+
/* Query device FW LLDP status */
ixl_get_fw_lldp_status(pf);
/* Tell FW to apply DCB config on link up */
- if ((hw->mac.type != I40E_MAC_X722)
- && ((pf->hw.aq.api_maj_ver > 1)
- || (pf->hw.aq.api_maj_ver == 1 && pf->hw.aq.api_min_ver >= 7)))
- i40e_aq_set_dcb_parameters(hw, true, NULL);
+ i40e_aq_set_dcb_parameters(hw, true, NULL);
/* Initialize mac filter list for VSI */
SLIST_INIT(&vsi->ftl);
- /* Set up SW VSI and allocate queue memory and rings */
- if (ixl_setup_stations(pf)) {
- device_printf(dev, "setup stations failed!\n");
- error = ENOMEM;
- goto err_mac_hmc;
+ /* Fill out iflib parameters */
+ if (hw->mac.type == I40E_MAC_X722)
+ scctx->isc_ntxqsets_max = scctx->isc_nrxqsets_max = 128;
+ else
+ scctx->isc_ntxqsets_max = scctx->isc_nrxqsets_max = 64;
+ if (vsi->enable_head_writeback) {
+ scctx->isc_txqsizes[0] = roundup2(scctx->isc_ntxd[0]
+ * sizeof(struct i40e_tx_desc) + sizeof(u32), DBA_ALIGN);
+ scctx->isc_txrx = &ixl_txrx_hwb;
+ } else {
+ scctx->isc_txqsizes[0] = roundup2(scctx->isc_ntxd[0]
+ * sizeof(struct i40e_tx_desc), DBA_ALIGN);
+ scctx->isc_txrx = &ixl_txrx_dwb;
}
+ scctx->isc_rxqsizes[0] = roundup2(scctx->isc_nrxd[0]
+ * sizeof(union i40e_32byte_rx_desc), DBA_ALIGN);
+ scctx->isc_msix_bar = PCIR_BAR(IXL_MSIX_BAR);
+ scctx->isc_tx_nsegments = IXL_MAX_TX_SEGS;
+ scctx->isc_tx_tso_segments_max = IXL_MAX_TSO_SEGS;
+ scctx->isc_tx_tso_size_max = IXL_TSO_SIZE;
+ scctx->isc_tx_tso_segsize_max = IXL_MAX_DMA_SEG_SIZE;
+ scctx->isc_rss_table_size = pf->hw.func_caps.rss_table_size;
+ scctx->isc_tx_csum_flags = CSUM_OFFLOAD;
+ scctx->isc_capenable = IXL_CAPS;
+
+ INIT_DEBUGOUT("ixl_if_attach_pre: end");
+ return (0);
+
+err_mac_hmc:
+ i40e_shutdown_lan_hmc(hw);
+err_get_cap:
+ i40e_shutdown_adminq(hw);
+err_out:
+ ixl_free_pci_resources(pf);
+err_pci_res:
+ return (error);
+}
+
+static int
+ixl_if_attach_post(if_ctx_t ctx)
+{
+ device_t dev;
+ struct ixl_pf *pf;
+ struct i40e_hw *hw;
+ struct ixl_vsi *vsi;
+ int error = 0;
+ enum i40e_status_code status;
+
+ INIT_DEBUGOUT("ixl_if_attach_post: begin");
+
+ dev = iflib_get_dev(ctx);
+ pf = iflib_get_softc(ctx);
+ vsi = &pf->vsi;
+ vsi->ifp = iflib_get_ifp(ctx);
+ hw = &pf->hw;
/* Setup OS network interface / ifnet */
- if (ixl_setup_interface(dev, vsi)) {
+ if (ixl_setup_interface(dev, pf)) {
device_printf(dev, "interface setup failed!\n");
error = EIO;
- goto err_late;
+ goto err;
}
/* Determine link state */
if (ixl_attach_get_link_status(pf)) {
error = EINVAL;
- goto err_late;
+ goto err;
}
error = ixl_switch_config(pf);
if (error) {
device_printf(dev, "Initial ixl_switch_config() failed: %d\n",
error);
- goto err_late;
+ goto err;
+ }
+
+ /* Init queue allocation manager */
+ error = ixl_pf_qmgr_init(&pf->qmgr, hw->func_caps.num_tx_qp);
+ if (error) {
+ device_printf(dev, "Failed to init queue manager for PF queues, error %d\n",
+ error);
+ goto err;
+ }
+ /* reserve a contiguous allocation for the PF's VSI */
+ error = ixl_pf_qmgr_alloc_contiguous(&pf->qmgr,
+ max(vsi->num_rx_queues, vsi->num_tx_queues), &pf->qtag);
+ if (error) {
+ device_printf(dev, "Failed to reserve queues for PF LAN VSI, error %d\n",
+ error);
+ goto err;
}
+ device_printf(dev, "Allocating %d queues for PF LAN VSI; %d queues active\n",
+ pf->qtag.num_allocated, pf->qtag.num_active);
/* Limit PHY interrupts to link, autoneg, and modules failure */
status = i40e_aq_set_phy_int_mask(hw, IXL_DEFAULT_PHY_INT_MASK,
@@ -583,59 +633,16 @@
device_printf(dev, "i40e_aq_set_phy_mask() failed: err %s,"
" aq_err %s\n", i40e_stat_str(hw, status),
i40e_aq_str(hw, hw->aq.asq_last_status));
- goto err_late;
+ goto err;
}
- /* Get the bus configuration and set the shared code's config */
+ /* Get the bus configuration and set the shared code */
ixl_get_bus_info(pf);
- /*
- * In MSI-X mode, initialize the Admin Queue interrupt,
- * so userland tools can communicate with the adapter regardless of
- * the ifnet interface's status.
- */
- if (pf->msix > 1) {
- error = ixl_setup_adminq_msix(pf);
- if (error) {
- device_printf(dev, "ixl_setup_adminq_msix() error: %d\n",
- error);
- goto err_late;
- }
- error = ixl_setup_adminq_tq(pf);
- if (error) {
- device_printf(dev, "ixl_setup_adminq_tq() error: %d\n",
- error);
- goto err_late;
- }
- ixl_configure_intr0_msix(pf);
- ixl_enable_intr0(hw);
-
- error = ixl_setup_queue_msix(vsi);
- if (error)
- device_printf(dev, "ixl_setup_queue_msix() error: %d\n",
- error);
- error = ixl_setup_queue_tqs(vsi);
- if (error)
- device_printf(dev, "ixl_setup_queue_tqs() error: %d\n",
- error);
- } else {
- error = ixl_setup_legacy(pf);
-
- error = ixl_setup_adminq_tq(pf);
- if (error) {
- device_printf(dev, "ixl_setup_adminq_tq() error: %d\n",
- error);
- goto err_late;
- }
-
- error = ixl_setup_queue_tqs(vsi);
- if (error)
- device_printf(dev, "ixl_setup_queue_tqs() error: %d\n",
- error);
- }
-
- if (error) {
- device_printf(dev, "interrupt setup error: %d\n", error);
+ /* Keep admin queue interrupts active while driver is loaded */
+ if (vsi->shared->isc_intr == IFLIB_INTR_MSIX) {
+ ixl_configure_intr0_msix(pf);
+ ixl_enable_intr0(hw);
}
/* Set initial advertised speed sysctl value */
@@ -643,31 +650,18 @@
/* Initialize statistics & add sysctls */
ixl_add_device_sysctls(pf);
-
ixl_pf_reset_stats(pf);
ixl_update_stats_counters(pf);
ixl_add_hw_stats(pf);
- /* Register for VLAN events */
- vsi->vlan_attach = EVENTHANDLER_REGISTER(vlan_config,
- ixl_register_vlan, vsi, EVENTHANDLER_PRI_FIRST);
- vsi->vlan_detach = EVENTHANDLER_REGISTER(vlan_unconfig,
- ixl_unregister_vlan, vsi, EVENTHANDLER_PRI_FIRST);
+ hw->phy.get_link_info = true;
+ i40e_get_link_status(hw, &pf->link_up);
+ ixl_update_link_status(pf);
#ifdef PCI_IOV
ixl_initialize_sriov(pf);
#endif
-#ifdef DEV_NETMAP
- if (vsi->num_rx_desc == vsi->num_tx_desc) {
- vsi->queues[0].num_desc = vsi->num_rx_desc;
- ixl_netmap_attach(vsi);
- } else
- device_printf(dev,
- "Netmap is not supported when RX and TX descriptor ring sizes differ\n");
-
-#endif /* DEV_NETMAP */
-
#ifdef IXL_IW
if (hw->func_caps.iwarp && ixl_enable_iwarp) {
pf->iw_enabled = (pf->iw_msix > 0) ? true : false;
@@ -677,7 +671,7 @@
device_printf(dev,
"interfacing to iwarp driver failed: %d\n",
error);
- goto err_late;
+ goto err;
} else
device_printf(dev, "iWARP ready\n");
} else
@@ -689,54 +683,38 @@
}
#endif
- INIT_DEBUGOUT("ixl_attach: end");
+ INIT_DBG_DEV(dev, "end");
return (0);
-err_late:
- if (vsi->ifp != NULL) {
- ether_ifdetach(vsi->ifp);
- if_free(vsi->ifp);
- }
-err_mac_hmc:
- i40e_shutdown_lan_hmc(hw);
-err_get_cap:
- i40e_shutdown_adminq(hw);
-err_out:
- ixl_free_pci_resources(pf);
- ixl_free_vsi(vsi);
- IXL_PF_LOCK_DESTROY(pf);
+err:
+ INIT_DEBUGOUT("end: error %d", error);
+ /* ixl_if_detach() is called on error from this */
return (error);
}
-/*********************************************************************
- * Device removal routine
- *
- * The detach entry point is called when the driver is being removed.
- * This routine stops the adapter and deallocates all the resources
- * that were allocated for driver operation.
- *
- * return 0 on success, positive on failure
- *********************************************************************/
-
static int
-ixl_detach(device_t dev)
+ixl_if_detach(if_ctx_t ctx)
{
- struct ixl_pf *pf = device_get_softc(dev);
- struct i40e_hw *hw = &pf->hw;
- struct ixl_vsi *vsi = &pf->vsi;
+ struct ixl_pf *pf = iflib_get_softc(ctx);
+ struct ixl_vsi *vsi = &pf->vsi;
+ struct i40e_hw *hw = &pf->hw;
+ device_t dev = pf->dev;
enum i40e_status_code status;
#if defined(PCI_IOV) || defined(IXL_IW)
int error;
#endif
- INIT_DEBUGOUT("ixl_detach: begin");
+ INIT_DBG_DEV(dev, "begin");
- /* Make sure VLANS are not using driver */
- if (vsi->ifp->if_vlantrunk != NULL) {
- device_printf(dev, "Vlan in use, detach first\n");
- return (EBUSY);
+#ifdef IXL_IW
+ if (ixl_enable_iwarp && pf->iw_enabled) {
+ error = ixl_iw_pf_detach(pf);
+ if (error == EBUSY) {
+ device_printf(dev, "iwarp in use; stop it first.\n");
+ return (error);
+ }
}
-
+#endif
#ifdef PCI_IOV
error = pci_iov_detach(dev);
if (error != 0) {
@@ -744,73 +722,998 @@
return (error);
}
#endif
-
/* Remove all previously allocated media types */
- ifmedia_removeall(&vsi->media);
-
- ether_ifdetach(vsi->ifp);
- if (vsi->ifp->if_drv_flags & IFF_DRV_RUNNING)
- ixl_stop(pf);
+ ifmedia_removeall(vsi->media);
/* Shutdown LAN HMC */
- status = i40e_shutdown_lan_hmc(hw);
- if (status)
- device_printf(dev,
- "Shutdown LAN HMC failed with code %d\n", status);
+ if (hw->hmc.hmc_obj) {
+ status = i40e_shutdown_lan_hmc(hw);
+ if (status)
+ device_printf(dev,
+ "i40e_shutdown_lan_hmc() failed with status %s\n",
+ i40e_stat_str(hw, status));
+ }
- /* Teardown LAN queue resources */
- ixl_teardown_queue_msix(vsi);
- ixl_free_queue_tqs(vsi);
/* Shutdown admin queue */
ixl_disable_intr0(hw);
- ixl_teardown_adminq_msix(pf);
- ixl_free_adminq_tq(pf);
status = i40e_shutdown_adminq(hw);
if (status)
device_printf(dev,
- "Shutdown Admin queue failed with code %d\n", status);
+ "i40e_shutdown_adminq() failed with status %s\n",
+ i40e_stat_str(hw, status));
+
+ ixl_pf_qmgr_destroy(&pf->qmgr);
+ ixl_free_pci_resources(pf);
+ ixl_free_mac_filters(vsi);
+ INIT_DBG_DEV(dev, "end");
+ return (0);
+}
+
+/* TODO: Do shutdown-specific stuff here */
+static int
+ixl_if_shutdown(if_ctx_t ctx)
+{
+ int error = 0;
+
+ INIT_DEBUGOUT("ixl_if_shutdown: begin");
+
+ /* TODO: Call ixl_if_stop()? */
+
+ /* TODO: Then setup low power mode */
+
+ return (error);
+}
+
+static int
+ixl_if_suspend(if_ctx_t ctx)
+{
+ int error = 0;
+
+ INIT_DEBUGOUT("ixl_if_suspend: begin");
+
+ /* TODO: Call ixl_if_stop()? */
+
+ /* TODO: Then setup low power mode */
+
+ return (error);
+}
+
+static int
+ixl_if_resume(if_ctx_t ctx)
+{
+ struct ifnet *ifp = iflib_get_ifp(ctx);
+
+ INIT_DEBUGOUT("ixl_if_resume: begin");
+
+ /* Read & clear wake-up registers */
+
+ /* Required after D3->D0 transition */
+ if (ifp->if_flags & IFF_UP)
+ ixl_if_init(ctx);
+
+ return (0);
+}
+
+/* Set Report Status queue fields to 0 */
+static void
+ixl_init_tx_rsqs(struct ixl_vsi *vsi)
+{
+ if_softc_ctx_t scctx = vsi->shared;
+ struct ixl_tx_queue *tx_que;
+ int i, j;
+
+ for (i = 0, tx_que = vsi->tx_queues; i < vsi->num_tx_queues; i++, tx_que++) {
+ struct tx_ring *txr = &tx_que->txr;
+
+ txr->tx_rs_cidx = txr->tx_rs_pidx = txr->tx_cidx_processed = 0;
+
+ for (j = 0; j < scctx->isc_ntxd[0]; j++)
+ txr->tx_rsq[j] = QIDX_INVALID;
+ }
+}
+
+static void
+ixl_init_tx_cidx(struct ixl_vsi *vsi)
+{
+ struct ixl_tx_queue *tx_que;
+ int i;
+
+ for (i = 0, tx_que = vsi->tx_queues; i < vsi->num_tx_queues; i++, tx_que++) {
+ struct tx_ring *txr = &tx_que->txr;
+
+ txr->tx_cidx_processed = 0;
+ }
+}
+
+void
+ixl_if_init(if_ctx_t ctx)
+{
+ struct ixl_pf *pf = iflib_get_softc(ctx);
+ struct ixl_vsi *vsi = &pf->vsi;
+ struct i40e_hw *hw = &pf->hw;
+ device_t dev = iflib_get_dev(ctx);
+ u8 tmpaddr[ETHER_ADDR_LEN];
+ int ret;
+
+ /*
+ * If the aq is dead here, it probably means something outside of the driver
+ * did something to the adapter, like a PF reset.
+ * So rebuild the driver's state here if that occurs.
+ */
+ if (!i40e_check_asq_alive(&pf->hw)) {
+ device_printf(dev, "Admin Queue is down; resetting...\n");
+ ixl_teardown_hw_structs(pf);
+ ixl_reset(pf);
+ }
+
+ /* Get the latest mac address... User might use a LAA */
+ bcopy(IF_LLADDR(vsi->ifp), tmpaddr,
+ ETH_ALEN);
+ if (!cmp_etheraddr(hw->mac.addr, tmpaddr) &&
+ (i40e_validate_mac_addr(tmpaddr) == I40E_SUCCESS)) {
+ ixl_del_filter(vsi, hw->mac.addr, IXL_VLAN_ANY);
+ bcopy(tmpaddr, hw->mac.addr,
+ ETH_ALEN);
+ ret = i40e_aq_mac_address_write(hw,
+ I40E_AQC_WRITE_TYPE_LAA_ONLY,
+ hw->mac.addr, NULL);
+ if (ret) {
+ device_printf(dev, "LLA address"
+ "change failed!!\n");
+ return;
+ }
+ }
- /* Unregister VLAN events */
- if (vsi->vlan_attach != NULL)
- EVENTHANDLER_DEREGISTER(vlan_config, vsi->vlan_attach);
- if (vsi->vlan_detach != NULL)
- EVENTHANDLER_DEREGISTER(vlan_unconfig, vsi->vlan_detach);
+ iflib_set_mac(ctx, hw->mac.addr);
+ ixl_add_filter(vsi, hw->mac.addr, IXL_VLAN_ANY);
- callout_drain(&pf->timer);
+ /* Prepare the VSI: rings, hmc contexts, etc... */
+ if (ixl_initialize_vsi(vsi)) {
+ device_printf(dev, "initialize vsi failed!!\n");
+ return;
+ }
+
+ // TODO: Call iflib setup multicast filters here?
+ // It's called in ixgbe in D5213
+ ixl_if_multi_set(ctx);
+
+ /* Set up RSS */
+ ixl_config_rss(pf);
+
+ /* Add protocol filters to list */
+ ixl_init_filters(vsi);
+
+ /* Setup vlan's if needed */
+ ixl_setup_vlan_filters(vsi);
+
+ /* Set up MSI/X routing and the ITR settings */
+ if (vsi->shared->isc_intr == IFLIB_INTR_MSIX) {
+ ixl_configure_queue_intr_msix(pf);
+ ixl_configure_itr(pf);
+ } else
+ ixl_configure_legacy(pf);
+
+ if (vsi->enable_head_writeback)
+ ixl_init_tx_cidx(vsi);
+ else
+ ixl_init_tx_rsqs(vsi);
+
+ ixl_enable_rings(vsi);
+
+ i40e_aq_set_default_vsi(hw, vsi->seid, NULL);
+
+ ixl_reconfigure_filters(vsi);
#ifdef IXL_IW
if (ixl_enable_iwarp && pf->iw_enabled) {
- error = ixl_iw_pf_detach(pf);
- if (error == EBUSY) {
- device_printf(dev, "iwarp in use; stop it first.\n");
- return (error);
- }
+ ret = ixl_iw_pf_init(pf);
+ if (ret)
+ device_printf(dev,
+ "initialize iwarp failed, code %d\n", ret);
}
#endif
+}
+
+void
+ixl_if_stop(if_ctx_t ctx)
+{
+ struct ixl_pf *pf = iflib_get_softc(ctx);
+ struct ixl_vsi *vsi = &pf->vsi;
+
+ INIT_DEBUGOUT("ixl_if_stop: begin\n");
+
+ // TODO: This may need to be reworked
+#ifdef IXL_IW
+ /* Stop iWARP device */
+ if (ixl_enable_iwarp && pf->iw_enabled)
+ ixl_iw_pf_stop(pf);
+#endif
+
+ ixl_disable_rings_intr(vsi);
+ ixl_disable_rings(vsi);
+}
+
+static int
+ixl_if_msix_intr_assign(if_ctx_t ctx, int msix)
+{
+ struct ixl_pf *pf = iflib_get_softc(ctx);
+ struct ixl_vsi *vsi = &pf->vsi;
+ struct ixl_rx_queue *rx_que = vsi->rx_queues;
+ struct ixl_tx_queue *tx_que = vsi->tx_queues;
+ int err, i, rid, vector = 0;
+ char buf[16];
+
+ /* Admin Que must use vector 0*/
+ rid = vector + 1;
+ err = iflib_irq_alloc_generic(ctx, &vsi->irq, rid, IFLIB_INTR_ADMIN,
+ ixl_msix_adminq, pf, 0, "aq");
+ if (err) {
+ iflib_irq_free(ctx, &vsi->irq);
+ device_printf(iflib_get_dev(ctx),
+ "Failed to register Admin que handler");
+ return (err);
+ }
+ // TODO: Re-enable this at some point
+ // iflib_softirq_alloc_generic(ctx, rid, IFLIB_INTR_IOV, pf, 0, "ixl_iov");
+
+ /* Now set up the stations */
+ for (i = 0, vector = 1; i < vsi->num_rx_queues; i++, vector++, rx_que++) {
+ rid = vector + 1;
+
+ snprintf(buf, sizeof(buf), "rxq%d", i);
+ err = iflib_irq_alloc_generic(ctx, &rx_que->que_irq, rid,
+ IFLIB_INTR_RX, ixl_msix_que, rx_que, rx_que->rxr.me, buf);
+ /* XXX: Does the driver work as expected if there are fewer num_rx_queues than
+ * what's expected in the iflib context? */
+ if (err) {
+ device_printf(iflib_get_dev(ctx),
+ "Failed to allocate q int %d err: %d", i, err);
+ vsi->num_rx_queues = i + 1;
+ goto fail;
+ }
+ rx_que->msix = vector;
+ }
+
+ bzero(buf, sizeof(buf));
+
+ for (i = 0; i < vsi->num_tx_queues; i++, tx_que++) {
+ snprintf(buf, sizeof(buf), "txq%d", i);
+ iflib_softirq_alloc_generic(ctx,
+ &vsi->rx_queues[i % vsi->num_rx_queues].que_irq,
+ IFLIB_INTR_TX, tx_que, tx_que->txr.me, buf);
+
+ /* TODO: Maybe call a strategy function for this to figure out which
+ * interrupts to map Tx queues to. I don't know if there's an immediately
+ * better way than this other than a user-supplied map, though. */
+ tx_que->msix = (i % vsi->num_rx_queues) + 1;
+ }
-#ifdef DEV_NETMAP
- netmap_detach(vsi->ifp);
-#endif /* DEV_NETMAP */
- ixl_pf_qmgr_destroy(&pf->qmgr);
- ixl_free_pci_resources(pf);
- bus_generic_detach(dev);
- if_free(vsi->ifp);
- ixl_free_vsi(vsi);
- IXL_PF_LOCK_DESTROY(pf);
return (0);
+fail:
+ iflib_irq_free(ctx, &vsi->irq);
+ rx_que = vsi->rx_queues;
+ for (int i = 0; i < vsi->num_rx_queues; i++, rx_que++)
+ iflib_irq_free(ctx, &rx_que->que_irq);
+ return (err);
}
-/*********************************************************************
+/*
+ * Enable all interrupts
*
- * Shutdown entry point
+ * Called in:
+ * iflib_init_locked, after ixl_if_init()
+ */
+static void
+ixl_if_enable_intr(if_ctx_t ctx)
+{
+ struct ixl_pf *pf = iflib_get_softc(ctx);
+ struct ixl_vsi *vsi = &pf->vsi;
+ struct i40e_hw *hw = vsi->hw;
+ struct ixl_rx_queue *que = vsi->rx_queues;
+
+ ixl_enable_intr0(hw);
+ /* Enable queue interrupts */
+ for (int i = 0; i < vsi->num_rx_queues; i++, que++)
+ /* TODO: Queue index parameter is probably wrong */
+ ixl_enable_queue(hw, que->rxr.me);
+}
+
+/*
+ * Disable queue interrupts
*
- **********************************************************************/
+ * Other interrupt causes need to remain active.
+ */
+static void
+ixl_if_disable_intr(if_ctx_t ctx)
+{
+ struct ixl_pf *pf = iflib_get_softc(ctx);
+ struct ixl_vsi *vsi = &pf->vsi;
+ struct i40e_hw *hw = vsi->hw;
+ struct ixl_rx_queue *rx_que = vsi->rx_queues;
+
+ if (vsi->shared->isc_intr == IFLIB_INTR_MSIX) {
+ for (int i = 0; i < vsi->num_rx_queues; i++, rx_que++)
+ ixl_disable_queue(hw, rx_que->msix - 1);
+ } else {
+ // Set PFINT_LNKLST0 FIRSTQ_INDX to 0x7FF
+ // stops queues from triggering interrupts
+ wr32(hw, I40E_PFINT_LNKLST0, 0x7FF);
+ }
+}
+
+static int
+ixl_if_rx_queue_intr_enable(if_ctx_t ctx, uint16_t rxqid)
+{
+ struct ixl_pf *pf = iflib_get_softc(ctx);
+ struct ixl_vsi *vsi = &pf->vsi;
+ struct i40e_hw *hw = vsi->hw;
+ struct ixl_rx_queue *rx_que = &vsi->rx_queues[rxqid];
+
+ ixl_enable_queue(hw, rx_que->msix - 1);
+ return (0);
+}
+
+static int
+ixl_if_tx_queue_intr_enable(if_ctx_t ctx, uint16_t txqid)
+{
+ struct ixl_pf *pf = iflib_get_softc(ctx);
+ struct ixl_vsi *vsi = &pf->vsi;
+ struct i40e_hw *hw = vsi->hw;
+ struct ixl_tx_queue *tx_que = &vsi->tx_queues[txqid];
+
+ ixl_enable_queue(hw, tx_que->msix - 1);
+
+ return (0);
+}
+
+static int
+ixl_if_tx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs, uint64_t *paddrs, int ntxqs, int ntxqsets)
+{
+ struct ixl_pf *pf = iflib_get_softc(ctx);
+ struct ixl_vsi *vsi = &pf->vsi;
+ if_softc_ctx_t scctx = vsi->shared;
+ struct ixl_tx_queue *que;
+ // int i;
+ int i, j, error = 0;
+
+ MPASS(vsi->num_tx_queues > 0);
+ MPASS(ntxqs == 1);
+ MPASS(vsi->num_tx_queues == ntxqsets);
+
+ /* Allocate queue structure memory */
+ if (!(vsi->tx_queues =
+ (struct ixl_tx_queue *) malloc(sizeof(struct ixl_tx_queue) *ntxqsets, M_IXL, M_NOWAIT | M_ZERO))) {
+ device_printf(iflib_get_dev(ctx), "Unable to allocate TX ring memory\n");
+ return (ENOMEM);
+ }
+
+ for (i = 0, que = vsi->tx_queues; i < ntxqsets; i++, que++) {
+ struct tx_ring *txr = &que->txr;
+
+ txr->me = i;
+ que->vsi = vsi;
+
+ if (!vsi->enable_head_writeback) {
+ /* Allocate report status array */
+ if (!(txr->tx_rsq = malloc(sizeof(qidx_t) * scctx->isc_ntxd[0], M_IXL, M_NOWAIT))) {
+ device_printf(iflib_get_dev(ctx), "failed to allocate tx_rsq memory\n");
+ error = ENOMEM;
+ goto fail;
+ }
+ /* Init report status array */
+ for (j = 0; j < scctx->isc_ntxd[0]; j++)
+ txr->tx_rsq[j] = QIDX_INVALID;
+ }
+ /* get the virtual and physical address of the hardware queues */
+ txr->tail = I40E_QTX_TAIL(txr->me);
+ txr->tx_base = (struct i40e_tx_desc *)vaddrs[i * ntxqs];
+ txr->tx_paddr = paddrs[i * ntxqs];
+ txr->que = que;
+ }
+
+ return (0);
+fail:
+ ixl_if_queues_free(ctx);
+ return (error);
+}
+
+static int
+ixl_if_rx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs, uint64_t *paddrs, int nrxqs, int nrxqsets)
+{
+ struct ixl_pf *pf = iflib_get_softc(ctx);
+ struct ixl_vsi *vsi = &pf->vsi;
+ struct ixl_rx_queue *que;
+ int i, error = 0;
+
+ MPASS(vsi->num_rx_queues > 0);
+ MPASS(nrxqs == 1);
+ MPASS(vsi->num_rx_queues == nrxqsets);
+
+ /* Allocate queue structure memory */
+ if (!(vsi->rx_queues =
+ (struct ixl_rx_queue *) malloc(sizeof(struct ixl_rx_queue) *
+ nrxqsets, M_IXL, M_NOWAIT | M_ZERO))) {
+ device_printf(iflib_get_dev(ctx), "Unable to allocate RX ring memory\n");
+ error = ENOMEM;
+ goto fail;
+ }
+
+ for (i = 0, que = vsi->rx_queues; i < nrxqsets; i++, que++) {
+ struct rx_ring *rxr = &que->rxr;
+
+ rxr->me = i;
+ que->vsi = vsi;
+
+ /* get the virtual and physical address of the hardware queues */
+ rxr->tail = I40E_QRX_TAIL(rxr->me);
+ rxr->rx_base = (union i40e_rx_desc *)vaddrs[i * nrxqs];
+ rxr->rx_paddr = paddrs[i * nrxqs];
+ rxr->que = que;
+ }
+
+ return (0);
+fail:
+ ixl_if_queues_free(ctx);
+ return (error);
+}
+
+static void
+ixl_if_queues_free(if_ctx_t ctx)
+{
+ struct ixl_pf *pf = iflib_get_softc(ctx);
+ struct ixl_vsi *vsi = &pf->vsi;
+
+ if (vsi->enable_head_writeback) {
+ struct ixl_tx_queue *que;
+ int i = 0;
+
+ for (i = 0, que = vsi->tx_queues; i < vsi->num_tx_queues; i++, que++) {
+ struct tx_ring *txr = &que->txr;
+ if (txr->tx_rsq != NULL) {
+ free(txr->tx_rsq, M_IXL);
+ txr->tx_rsq = NULL;
+ }
+ }
+ }
+
+ if (vsi->tx_queues != NULL) {
+ free(vsi->tx_queues, M_IXL);
+ vsi->tx_queues = NULL;
+ }
+ if (vsi->rx_queues != NULL) {
+ free(vsi->rx_queues, M_IXL);
+ vsi->rx_queues = NULL;
+ }
+}
+
+void
+ixl_update_link_status(struct ixl_pf *pf)
+{
+ struct ixl_vsi *vsi = &pf->vsi;
+ u64 baudrate;
+
+ if (pf->link_up) {
+ if (vsi->link_active == FALSE) {
+ vsi->link_active = TRUE;
+ baudrate = ixl_max_aq_speed_to_value(pf->link_speed);
+ iflib_link_state_change(vsi->ctx, LINK_STATE_UP, baudrate);
+ ixl_link_up_msg(pf);
+#ifdef PCI_IOV
+ ixl_broadcast_link_state(pf);
+#endif
+
+ }
+ } else { /* Link down */
+ if (vsi->link_active == TRUE) {
+ vsi->link_active = FALSE;
+ iflib_link_state_change(vsi->ctx, LINK_STATE_DOWN, 0);
+#ifdef PCI_IOV
+ ixl_broadcast_link_state(pf);
+#endif
+ }
+ }
+}
+
+static int
+ixl_process_adminq(struct ixl_pf *pf, u16 *pending)
+{
+ enum i40e_status_code status = I40E_SUCCESS;
+ struct i40e_arq_event_info event;
+ struct i40e_hw *hw = &pf->hw;
+ device_t dev = pf->dev;
+ u16 opcode;
+ u32 loop = 0, reg;
+
+ event.buf_len = IXL_AQ_BUF_SZ;
+ event.msg_buf = malloc(event.buf_len, M_IXL, M_NOWAIT | M_ZERO);
+ if (!event.msg_buf) {
+ device_printf(dev, "%s: Unable to allocate memory for Admin"
+ " Queue event!\n", __func__);
+ return (ENOMEM);
+ }
+
+ /* clean and process any events */
+ do {
+ status = i40e_clean_arq_element(hw, &event, pending);
+ if (status)
+ break;
+ opcode = LE16_TO_CPU(event.desc.opcode);
+ ixl_dbg(pf, IXL_DBG_AQ,
+ "Admin Queue event: %#06x\n", opcode);
+ switch (opcode) {
+ case i40e_aqc_opc_get_link_status:
+ ixl_link_event(pf, &event);
+ break;
+ case i40e_aqc_opc_send_msg_to_pf:
+#ifdef PCI_IOV
+ ixl_handle_vf_msg(pf, &event);
+#endif
+ break;
+ /*
+ * This should only occur on no-drop queues, which
+ * aren't currently configured.
+ */
+ case i40e_aqc_opc_event_lan_overflow:
+ device_printf(dev, "LAN overflow event\n");
+ break;
+ default:
+ break;
+ }
+ } while (*pending && (loop++ < IXL_ADM_LIMIT));
+
+ free(event.msg_buf, M_IXL);
+
+ /* Re-enable admin queue interrupt cause */
+ reg = rd32(hw, I40E_PFINT_ICR0_ENA);
+ reg |= I40E_PFINT_ICR0_ENA_ADMINQ_MASK;
+ wr32(hw, I40E_PFINT_ICR0_ENA, reg);
+
+ return (status);
+}
+
+static void
+ixl_if_update_admin_status(if_ctx_t ctx)
+{
+ struct ixl_pf *pf = iflib_get_softc(ctx);
+ struct i40e_hw *hw = &pf->hw;
+ u16 pending;
+
+ if (pf->state & IXL_PF_STATE_ADAPTER_RESETTING)
+ ixl_handle_empr_reset(pf);
+
+ if (pf->state & IXL_PF_STATE_MDD_PENDING)
+ ixl_handle_mdd_event(pf);
+
+#ifdef PCI_IOV
+ if (pf->state & IXL_PF_STATE_VF_RESET_REQ)
+ iflib_iov_intr_deferred(ctx);
+#endif
+
+ ixl_process_adminq(pf, &pending);
+ ixl_update_link_status(pf);
+
+ /*
+ * If there are still messages to process, reschedule ourselves.
+ * Otherwise, re-enable our interrupt and go to sleep.
+ */
+ if (pending > 0)
+ iflib_admin_intr_deferred(ctx);
+ else
+ ixl_enable_intr0(hw);
+}
+
+static void
+ixl_if_multi_set(if_ctx_t ctx)
+{
+ struct ixl_pf *pf = iflib_get_softc(ctx);
+ struct ixl_vsi *vsi = &pf->vsi;
+ struct i40e_hw *hw = vsi->hw;
+ int mcnt = 0, flags;
+
+ IOCTL_DEBUGOUT("ixl_if_multi_set: begin");
+
+ mcnt = if_multiaddr_count(iflib_get_ifp(ctx), MAX_MULTICAST_ADDR);
+ /* delete existing MC filters */
+ ixl_del_multi(vsi);
+
+ if (__predict_false(mcnt == MAX_MULTICAST_ADDR)) {
+ i40e_aq_set_vsi_multicast_promiscuous(hw,
+ vsi->seid, TRUE, NULL);
+ return;
+ }
+ /* (re-)install filters for all mcast addresses */
+ mcnt = if_multi_apply(iflib_get_ifp(ctx), ixl_mc_filter_apply, vsi);
+
+ if (mcnt > 0) {
+ flags = (IXL_FILTER_ADD | IXL_FILTER_USED | IXL_FILTER_MC);
+ ixl_add_hw_filters(vsi, flags, mcnt);
+ }
+
+ IOCTL_DEBUGOUT("ixl_if_multi_set: end");
+}
static int
-ixl_shutdown(device_t dev)
+ixl_if_mtu_set(if_ctx_t ctx, uint32_t mtu)
{
- struct ixl_pf *pf = device_get_softc(dev);
- ixl_stop(pf);
+ struct ixl_pf *pf = iflib_get_softc(ctx);
+ struct ixl_vsi *vsi = &pf->vsi;
+
+ IOCTL_DEBUGOUT("ioctl: SIOCSIFMTU (Set Interface MTU)");
+ if (mtu > IXL_MAX_FRAME - ETHER_HDR_LEN - ETHER_CRC_LEN -
+ ETHER_VLAN_ENCAP_LEN)
+ return (EINVAL);
+
+ vsi->shared->isc_max_frame_size = mtu + ETHER_HDR_LEN + ETHER_CRC_LEN +
+ ETHER_VLAN_ENCAP_LEN;
+
return (0);
}
+static void
+ixl_if_media_status(if_ctx_t ctx, struct ifmediareq *ifmr)
+{
+ struct ixl_pf *pf = iflib_get_softc(ctx);
+ struct i40e_hw *hw = &pf->hw;
+
+ INIT_DEBUGOUT("ixl_media_status: begin");
+
+ ifmr->ifm_status = IFM_AVALID;
+ ifmr->ifm_active = IFM_ETHER;
+
+ if (!pf->link_up) {
+ return;
+ }
+
+ ifmr->ifm_status |= IFM_ACTIVE;
+ /* Hardware is always full-duplex */
+ ifmr->ifm_active |= IFM_FDX;
+
+ switch (hw->phy.link_info.phy_type) {
+ /* 100 M */
+ case I40E_PHY_TYPE_100BASE_TX:
+ ifmr->ifm_active |= IFM_100_TX;
+ break;
+ /* 1 G */
+ case I40E_PHY_TYPE_1000BASE_T:
+ ifmr->ifm_active |= IFM_1000_T;
+ break;
+ case I40E_PHY_TYPE_1000BASE_SX:
+ ifmr->ifm_active |= IFM_1000_SX;
+ break;
+ case I40E_PHY_TYPE_1000BASE_LX:
+ ifmr->ifm_active |= IFM_1000_LX;
+ break;
+ case I40E_PHY_TYPE_1000BASE_T_OPTICAL:
+ ifmr->ifm_active |= IFM_1000_T;
+ break;
+ /* 10 G */
+ case I40E_PHY_TYPE_10GBASE_SFPP_CU:
+ ifmr->ifm_active |= IFM_10G_TWINAX;
+ break;
+ case I40E_PHY_TYPE_10GBASE_SR:
+ ifmr->ifm_active |= IFM_10G_SR;
+ break;
+ case I40E_PHY_TYPE_10GBASE_LR:
+ ifmr->ifm_active |= IFM_10G_LR;
+ break;
+ case I40E_PHY_TYPE_10GBASE_T:
+ ifmr->ifm_active |= IFM_10G_T;
+ break;
+ case I40E_PHY_TYPE_XAUI:
+ case I40E_PHY_TYPE_XFI:
+ ifmr->ifm_active |= IFM_10G_TWINAX;
+ break;
+ case I40E_PHY_TYPE_10GBASE_AOC:
+ ifmr->ifm_active |= IFM_10G_AOC;
+ break;
+ /* 25 G */
+ case I40E_PHY_TYPE_25GBASE_KR:
+ ifmr->ifm_active |= IFM_25G_KR;
+ break;
+ case I40E_PHY_TYPE_25GBASE_CR:
+ ifmr->ifm_active |= IFM_25G_CR;
+ break;
+ case I40E_PHY_TYPE_25GBASE_SR:
+ ifmr->ifm_active |= IFM_25G_SR;
+ break;
+ case I40E_PHY_TYPE_25GBASE_LR:
+ ifmr->ifm_active |= IFM_25G_LR;
+ break;
+ case I40E_PHY_TYPE_25GBASE_AOC:
+ ifmr->ifm_active |= IFM_25G_AOC;
+ break;
+ case I40E_PHY_TYPE_25GBASE_ACC:
+ ifmr->ifm_active |= IFM_25G_ACC;
+ break;
+ /* 40 G */
+ case I40E_PHY_TYPE_40GBASE_CR4:
+ case I40E_PHY_TYPE_40GBASE_CR4_CU:
+ ifmr->ifm_active |= IFM_40G_CR4;
+ break;
+ case I40E_PHY_TYPE_40GBASE_SR4:
+ ifmr->ifm_active |= IFM_40G_SR4;
+ break;
+ case I40E_PHY_TYPE_40GBASE_LR4:
+ ifmr->ifm_active |= IFM_40G_LR4;
+ break;
+ case I40E_PHY_TYPE_XLAUI:
+ ifmr->ifm_active |= IFM_OTHER;
+ break;
+ case I40E_PHY_TYPE_1000BASE_KX:
+ ifmr->ifm_active |= IFM_1000_KX;
+ break;
+ case I40E_PHY_TYPE_SGMII:
+ ifmr->ifm_active |= IFM_1000_SGMII;
+ break;
+ /* ERJ: What's the difference between these? */
+ case I40E_PHY_TYPE_10GBASE_CR1_CU:
+ case I40E_PHY_TYPE_10GBASE_CR1:
+ ifmr->ifm_active |= IFM_10G_CR1;
+ break;
+ case I40E_PHY_TYPE_10GBASE_KX4:
+ ifmr->ifm_active |= IFM_10G_KX4;
+ break;
+ case I40E_PHY_TYPE_10GBASE_KR:
+ ifmr->ifm_active |= IFM_10G_KR;
+ break;
+ case I40E_PHY_TYPE_SFI:
+ ifmr->ifm_active |= IFM_10G_SFI;
+ break;
+ /* Our single 20G media type */
+ case I40E_PHY_TYPE_20GBASE_KR2:
+ ifmr->ifm_active |= IFM_20G_KR2;
+ break;
+ case I40E_PHY_TYPE_40GBASE_KR4:
+ ifmr->ifm_active |= IFM_40G_KR4;
+ break;
+ case I40E_PHY_TYPE_XLPPI:
+ case I40E_PHY_TYPE_40GBASE_AOC:
+ ifmr->ifm_active |= IFM_40G_XLPPI;
+ break;
+ /* Unknown to driver */
+ default:
+ ifmr->ifm_active |= IFM_UNKNOWN;
+ break;
+ }
+ /* Report flow control status as well */
+ if (hw->phy.link_info.an_info & I40E_AQ_LINK_PAUSE_TX)
+ ifmr->ifm_active |= IFM_ETH_TXPAUSE;
+ if (hw->phy.link_info.an_info & I40E_AQ_LINK_PAUSE_RX)
+ ifmr->ifm_active |= IFM_ETH_RXPAUSE;
+}
+
+static int
+ixl_if_media_change(if_ctx_t ctx)
+{
+ struct ifmedia *ifm = iflib_get_media(ctx);
+
+ INIT_DEBUGOUT("ixl_media_change: begin");
+
+ if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)
+ return (EINVAL);
+
+ if_printf(iflib_get_ifp(ctx), "Media change is not supported.\n");
+ return (ENODEV);
+}
+
+static int
+ixl_if_promisc_set(if_ctx_t ctx, int flags)
+{
+ struct ixl_pf *pf = iflib_get_softc(ctx);
+ struct ixl_vsi *vsi = &pf->vsi;
+ struct ifnet *ifp = iflib_get_ifp(ctx);
+ struct i40e_hw *hw = vsi->hw;
+ int err;
+ bool uni = FALSE, multi = FALSE;
+
+ if (flags & IFF_PROMISC)
+ uni = multi = TRUE;
+ else if (flags & IFF_ALLMULTI ||
+ if_multiaddr_count(ifp, MAX_MULTICAST_ADDR) == MAX_MULTICAST_ADDR)
+ multi = TRUE;
+
+ err = i40e_aq_set_vsi_unicast_promiscuous(hw,
+ vsi->seid, uni, NULL, true);
+ if (err)
+ return (err);
+ err = i40e_aq_set_vsi_multicast_promiscuous(hw,
+ vsi->seid, multi, NULL);
+ return (err);
+}
+
+static void
+ixl_if_timer(if_ctx_t ctx, uint16_t qid)
+{
+ struct ixl_pf *pf = iflib_get_softc(ctx);
+ //struct i40e_hw *hw = &pf->hw;
+ //struct ixl_tx_queue *que = &vsi->tx_queues[qid];
+ #if 0
+ u32 mask;
+
+ /*
+ ** Check status of the queues
+ */
+ mask = (I40E_PFINT_DYN_CTLN_INTENA_MASK |
+ I40E_PFINT_DYN_CTLN_SWINT_TRIG_MASK);
+
+ /* If queue param has outstanding work, trigger sw irq */
+ // TODO: TX queues in iflib don't use HW interrupts; does this do anything?
+ if (que->busy)
+ wr32(hw, I40E_PFINT_DYN_CTLN(que->txr.me), mask);
+#endif
+
+ if (qid != 0)
+ return;
+
+ /* Fire off the adminq task */
+ iflib_admin_intr_deferred(ctx);
+
+ /* Update stats */
+ ixl_update_stats_counters(pf);
+}
+
+static void
+ixl_if_vlan_register(if_ctx_t ctx, u16 vtag)
+{
+ struct ixl_pf *pf = iflib_get_softc(ctx);
+ struct ixl_vsi *vsi = &pf->vsi;
+ struct i40e_hw *hw = vsi->hw;
+
+ if ((vtag == 0) || (vtag > 4095)) /* Invalid */
+ return;
+
+ ++vsi->num_vlans;
+ ixl_add_filter(vsi, hw->mac.addr, vtag);
+}
+
+static void
+ixl_if_vlan_unregister(if_ctx_t ctx, u16 vtag)
+{
+ struct ixl_pf *pf = iflib_get_softc(ctx);
+ struct ixl_vsi *vsi = &pf->vsi;
+ struct i40e_hw *hw = vsi->hw;
+
+ if ((vtag == 0) || (vtag > 4095)) /* Invalid */
+ return;
+
+ --vsi->num_vlans;
+ ixl_del_filter(vsi, hw->mac.addr, vtag);
+}
+
+static uint64_t
+ixl_if_get_counter(if_ctx_t ctx, ift_counter cnt)
+{
+ struct ixl_pf *pf = iflib_get_softc(ctx);
+ struct ixl_vsi *vsi = &pf->vsi;
+ if_t ifp = iflib_get_ifp(ctx);
+
+ switch (cnt) {
+ case IFCOUNTER_IPACKETS:
+ return (vsi->ipackets);
+ case IFCOUNTER_IERRORS:
+ return (vsi->ierrors);
+ case IFCOUNTER_OPACKETS:
+ return (vsi->opackets);
+ case IFCOUNTER_OERRORS:
+ return (vsi->oerrors);
+ case IFCOUNTER_COLLISIONS:
+ /* Collisions are by standard impossible in 40G/10G Ethernet */
+ return (0);
+ case IFCOUNTER_IBYTES:
+ return (vsi->ibytes);
+ case IFCOUNTER_OBYTES:
+ return (vsi->obytes);
+ case IFCOUNTER_IMCASTS:
+ return (vsi->imcasts);
+ case IFCOUNTER_OMCASTS:
+ return (vsi->omcasts);
+ case IFCOUNTER_IQDROPS:
+ return (vsi->iqdrops);
+ case IFCOUNTER_OQDROPS:
+ return (vsi->oqdrops);
+ case IFCOUNTER_NOPROTO:
+ return (vsi->noproto);
+ default:
+ return (if_get_counter_default(ifp, cnt));
+ }
+}
+
+static void
+ixl_if_vflr_handle(if_ctx_t ctx)
+{
+ IXL_DEV_ERR(iflib_get_dev(ctx), "");
+
+ // TODO: call ixl_handle_vflr()
+}
+
+static int
+ixl_if_i2c_req(if_ctx_t ctx, struct ifi2creq *req)
+{
+ struct ixl_pf *pf = iflib_get_softc(ctx);
+
+ if (pf->read_i2c_byte == NULL)
+ return (EINVAL);
+
+ for (int i = 0; i < req->len; i++)
+ if (pf->read_i2c_byte(pf, req->offset + i,
+ req->dev_addr, &req->data[i]))
+ return (EIO);
+ return (0);
+}
+
+static int
+ixl_if_priv_ioctl(if_ctx_t ctx, u_long command, caddr_t data)
+{
+ struct ixl_pf *pf = iflib_get_softc(ctx);
+ struct ifdrv *ifd = (struct ifdrv *)data;
+ int error = 0;
+
+ /* NVM update command */
+ if (ifd->ifd_cmd == I40E_NVM_ACCESS)
+ error = ixl_handle_nvmupd_cmd(pf, ifd);
+ else
+ error = EINVAL;
+
+ return (error);
+}
+
+static int
+ixl_mc_filter_apply(void *arg, struct ifmultiaddr *ifma, int count __unused)
+{
+ struct ixl_vsi *vsi = arg;
+
+ if (ifma->ifma_addr->sa_family != AF_LINK)
+ return (0);
+ ixl_add_mc_filter(vsi,
+ (u8*)LLADDR((struct sockaddr_dl *) ifma->ifma_addr));
+ return (1);
+}
+
+/*
+ * Sanity check and save off tunable values.
+ */
+static void
+ixl_save_pf_tunables(struct ixl_pf *pf)
+{
+ device_t dev = pf->dev;
+
+ /* Save tunable information */
+ pf->enable_tx_fc_filter = ixl_enable_tx_fc_filter;
+ pf->dbg_mask = ixl_core_debug_mask;
+ pf->hw.debug_mask = ixl_shared_debug_mask;
+ pf->vsi.enable_head_writeback = !!(ixl_enable_head_writeback);
+#if 0
+ pf->dynamic_rx_itr = ixl_dynamic_rx_itr;
+ pf->dynamic_tx_itr = ixl_dynamic_tx_itr;
+#endif
+
+ if (ixl_i2c_access_method > 3 || ixl_i2c_access_method < 0)
+ pf->i2c_access_method = 0;
+ else
+ pf->i2c_access_method = ixl_i2c_access_method;
+
+ if (ixl_tx_itr < 0 || ixl_tx_itr > IXL_MAX_ITR) {
+ device_printf(dev, "Invalid tx_itr value of %d set!\n",
+ ixl_tx_itr);
+ device_printf(dev, "tx_itr must be between %d and %d, "
+ "inclusive\n",
+ 0, IXL_MAX_ITR);
+ device_printf(dev, "Using default value of %d instead\n",
+ IXL_ITR_4K);
+ pf->tx_itr = IXL_ITR_4K;
+ } else
+ pf->tx_itr = ixl_tx_itr;
+
+ if (ixl_rx_itr < 0 || ixl_rx_itr > IXL_MAX_ITR) {
+ device_printf(dev, "Invalid rx_itr value of %d set!\n",
+ ixl_rx_itr);
+ device_printf(dev, "rx_itr must be between %d and %d, "
+ "inclusive\n",
+ 0, IXL_MAX_ITR);
+ device_printf(dev, "Using default value of %d instead\n",
+ IXL_ITR_8K);
+ pf->rx_itr = IXL_ITR_8K;
+ } else
+ pf->rx_itr = ixl_rx_itr;
+}
+
Index: sys/dev/ixl/if_ixlv.c
===================================================================
--- sys/dev/ixl/if_ixlv.c
+++ sys/dev/ixl/if_ixlv.c
@@ -44,102 +44,86 @@
char ixlv_driver_version[] = __XSTRING(IXLV_DRIVER_VERSION_MAJOR) "."
__XSTRING(IXLV_DRIVER_VERSION_MINOR) "."
- __XSTRING(IXLV_DRIVER_VERSION_BUILD) "-k";
+ __XSTRING(IXLV_DRIVER_VERSION_BUILD) "-iflib-k";
/*********************************************************************
* PCI Device ID Table
*
* Used by probe to select devices to load on
- * Last field stores an index into ixlv_strings
- * Last entry must be all 0s
*
- * { Vendor ID, Device ID, SubVendor ID, SubDevice ID, String Index }
+ * ( Vendor ID, Device ID, Branding String )
*********************************************************************/
-static ixl_vendor_info_t ixlv_vendor_info_array[] =
+static pci_vendor_info_t ixlv_vendor_info_array[] =
{
{I40E_INTEL_VENDOR_ID, I40E_DEV_ID_VF, 0, 0, 0},
{I40E_INTEL_VENDOR_ID, I40E_DEV_ID_X722_VF, 0, 0, 0},
{I40E_INTEL_VENDOR_ID, I40E_DEV_ID_ADAPTIVE_VF, 0, 0, 0},
/* required last entry */
- {0, 0, 0, 0, 0}
+ PVID_END
};
-/*********************************************************************
- * Table of branding strings
- *********************************************************************/
-
-static char *ixlv_strings[] = {
- "Intel(R) Ethernet Connection 700 Series VF Driver"
-};
-
-
/*********************************************************************
* Function prototypes
*********************************************************************/
-static int ixlv_probe(device_t);
-static int ixlv_attach(device_t);
-static int ixlv_detach(device_t);
-static int ixlv_shutdown(device_t);
-static void ixlv_init_locked(struct ixlv_sc *);
+static void *ixlv_register(device_t dev);
+static int ixlv_if_attach_pre(if_ctx_t ctx);
+static int ixlv_if_attach_post(if_ctx_t ctx);
+static int ixlv_if_detach(if_ctx_t ctx);
+static int ixlv_if_shutdown(if_ctx_t ctx);
+static int ixlv_if_suspend(if_ctx_t ctx);
+static int ixlv_if_resume(if_ctx_t ctx);
+static int ixlv_if_msix_intr_assign(if_ctx_t ctx, int msix);
+static void ixlv_if_enable_intr(if_ctx_t ctx);
+static void ixlv_if_disable_intr(if_ctx_t ctx);
+static int ixlv_if_queue_intr_enable(if_ctx_t ctx, uint16_t rxqid);
+static int ixlv_if_tx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs, uint64_t *paddrs, int ntxqs, int ntxqsets);
+static int ixlv_if_rx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs, uint64_t *paddrs, int nqs, int nqsets);
+static void ixlv_if_queues_free(if_ctx_t ctx);
+static void ixlv_if_update_admin_status(if_ctx_t ctx);
+static void ixlv_if_multi_set(if_ctx_t ctx);
+static int ixlv_if_mtu_set(if_ctx_t ctx, uint32_t mtu);
+static void ixlv_if_media_status(if_ctx_t ctx, struct ifmediareq *ifmr);
+static int ixlv_if_media_change(if_ctx_t ctx);
+static int ixlv_if_promisc_set(if_ctx_t ctx, int flags);
+static void ixlv_if_timer(if_ctx_t ctx, uint16_t qid);
+static void ixlv_if_vlan_register(if_ctx_t ctx, u16 vtag);
+static void ixlv_if_vlan_unregister(if_ctx_t ctx, u16 vtag);
+static uint64_t ixlv_if_get_counter(if_ctx_t ctx, ift_counter cnt);
+static void ixlv_if_stop(if_ctx_t ctx);
+
static int ixlv_allocate_pci_resources(struct ixlv_sc *);
+static int ixlv_reset_complete(struct i40e_hw *);
+static int ixlv_setup_vc(struct ixlv_sc *);
+static int ixlv_reset(struct ixlv_sc *);
+static int ixlv_vf_config(struct ixlv_sc *);
+static void ixlv_init_filters(struct ixlv_sc *);
static void ixlv_free_pci_resources(struct ixlv_sc *);
-static int ixlv_assign_msix(struct ixlv_sc *);
-static int ixlv_init_msix(struct ixlv_sc *);
-static int ixlv_init_taskqueue(struct ixlv_sc *);
-static int ixlv_setup_queues(struct ixlv_sc *);
+static void ixlv_free_filters(struct ixlv_sc *);
+static void ixlv_setup_interface(device_t, struct ixl_vsi *);
+static void ixlv_add_sysctls(struct ixlv_sc *);
+static void ixlv_enable_adminq_irq(struct i40e_hw *);
+static void ixlv_disable_adminq_irq(struct i40e_hw *);
+static void ixlv_enable_queue_irq(struct i40e_hw *, int);
+static void ixlv_disable_queue_irq(struct i40e_hw *, int);
static void ixlv_config_rss(struct ixlv_sc *);
static void ixlv_stop(struct ixlv_sc *);
-static void ixlv_add_multi(struct ixl_vsi *);
-static void ixlv_del_multi(struct ixl_vsi *);
-static void ixlv_free_queue(struct ixlv_sc *sc, struct ixl_queue *que);
-static void ixlv_free_queues(struct ixl_vsi *);
-static int ixlv_setup_interface(device_t, struct ixlv_sc *);
-static int ixlv_teardown_adminq_msix(struct ixlv_sc *);
-
-static int ixlv_media_change(struct ifnet *);
-static void ixlv_media_status(struct ifnet *, struct ifmediareq *);
-
-static void ixlv_local_timer(void *);
static int ixlv_add_mac_filter(struct ixlv_sc *, u8 *, u16);
static int ixlv_del_mac_filter(struct ixlv_sc *sc, u8 *macaddr);
-static void ixlv_init_filters(struct ixlv_sc *);
-static void ixlv_free_filters(struct ixlv_sc *);
-
-static void ixlv_msix_que(void *);
-static void ixlv_msix_adminq(void *);
-static void ixlv_do_adminq(void *, int);
+static int ixlv_msix_que(void *);
+static int ixlv_msix_adminq(void *);
static void ixlv_do_adminq_locked(struct ixlv_sc *sc);
-static void ixlv_handle_que(void *, int);
-static int ixlv_reset(struct ixlv_sc *);
-static int ixlv_reset_complete(struct i40e_hw *);
-static void ixlv_set_queue_rx_itr(struct ixl_queue *);
-static void ixlv_set_queue_tx_itr(struct ixl_queue *);
static void ixl_init_cmd_complete(struct ixl_vc_cmd *, void *,
enum i40e_status_code);
static void ixlv_configure_itr(struct ixlv_sc *);
-static void ixlv_enable_adminq_irq(struct i40e_hw *);
-static void ixlv_disable_adminq_irq(struct i40e_hw *);
-static void ixlv_enable_queue_irq(struct i40e_hw *, int);
-static void ixlv_disable_queue_irq(struct i40e_hw *, int);
-
static void ixlv_setup_vlan_filters(struct ixlv_sc *);
-static void ixlv_register_vlan(void *, struct ifnet *, u16);
-static void ixlv_unregister_vlan(void *, struct ifnet *, u16);
-
-static void ixlv_init_hw(struct ixlv_sc *);
-static int ixlv_setup_vc(struct ixlv_sc *);
-static int ixlv_vf_config(struct ixlv_sc *);
-
-static void ixlv_cap_txcsum_tso(struct ixl_vsi *,
- struct ifnet *, int);
static char *ixlv_vc_speed_to_string(enum virtchnl_link_speed link_speed);
static int ixlv_sysctl_current_speed(SYSCTL_HANDLER_ARGS);
-static void ixlv_add_sysctls(struct ixlv_sc *);
+// static void ixlv_add_sysctls(struct ixlv_sc *);
#ifdef IXL_DEBUG
static int ixlv_sysctl_qtx_tail_handler(SYSCTL_HANDLER_ARGS);
static int ixlv_sysctl_qrx_tail_handler(SYSCTL_HANDLER_ARGS);
@@ -151,11 +135,12 @@
static device_method_t ixlv_methods[] = {
/* Device interface */
- DEVMETHOD(device_probe, ixlv_probe),
- DEVMETHOD(device_attach, ixlv_attach),
- DEVMETHOD(device_detach, ixlv_detach),
- DEVMETHOD(device_shutdown, ixlv_shutdown),
- {0, 0}
+ DEVMETHOD(device_register, ixlv_register),
+ DEVMETHOD(device_probe, iflib_device_probe),
+ DEVMETHOD(device_attach, iflib_device_attach),
+ DEVMETHOD(device_detach, iflib_device_detach),
+ DEVMETHOD(device_shutdown, iflib_device_shutdown),
+ DEVMETHOD_END
};
static driver_t ixlv_driver = {
@@ -167,6 +152,41 @@
MODULE_DEPEND(ixlv, pci, 1, 1, 1);
MODULE_DEPEND(ixlv, ether, 1, 1, 1);
+MODULE_DEPEND(ixlv, iflib, 1, 1, 1);
+
+static device_method_t ixlv_if_methods[] = {
+ DEVMETHOD(ifdi_attach_pre, ixlv_if_attach_pre),
+ DEVMETHOD(ifdi_attach_post, ixlv_if_attach_post),
+ DEVMETHOD(ifdi_detach, ixlv_if_detach),
+ DEVMETHOD(ifdi_shutdown, ixlv_if_shutdown),
+ DEVMETHOD(ifdi_suspend, ixlv_if_suspend),
+ DEVMETHOD(ifdi_resume, ixlv_if_resume),
+ DEVMETHOD(ifdi_init, ixlv_if_init),
+ DEVMETHOD(ifdi_stop, ixlv_if_stop),
+ DEVMETHOD(ifdi_msix_intr_assign, ixlv_if_msix_intr_assign),
+ DEVMETHOD(ifdi_intr_enable, ixlv_if_enable_intr),
+ DEVMETHOD(ifdi_intr_disable, ixlv_if_disable_intr),
+ DEVMETHOD(ifdi_queue_intr_enable, ixlv_if_queue_intr_enable),
+ DEVMETHOD(ifdi_tx_queues_alloc, ixlv_if_tx_queues_alloc),
+ DEVMETHOD(ifdi_rx_queues_alloc, ixlv_if_rx_queues_alloc),
+ DEVMETHOD(ifdi_queues_free, ixlv_if_queues_free),
+ DEVMETHOD(ifdi_update_admin_status, ixlv_if_update_admin_status),
+ DEVMETHOD(ifdi_multi_set, ixlv_if_multi_set),
+ DEVMETHOD(ifdi_mtu_set, ixlv_if_mtu_set),
+ // DEVMETHOD(ifdi_crcstrip_set, ixlv_if_crcstrip_set),
+ DEVMETHOD(ifdi_media_status, ixlv_if_media_status),
+ DEVMETHOD(ifdi_media_change, ixlv_if_media_change),
+ DEVMETHOD(ifdi_promisc_set, ixlv_if_promisc_set),
+ DEVMETHOD(ifdi_timer, ixlv_if_timer),
+ DEVMETHOD(ifdi_vlan_register, ixlv_if_vlan_register),
+ DEVMETHOD(ifdi_vlan_unregister, ixlv_if_vlan_unregister),
+ DEVMETHOD(ifdi_get_counter, ixlv_if_get_counter),
+ DEVMETHOD_END
+};
+
+static driver_t ixlv_if_driver = {
+ "ixlv_if", ixlv_if_methods, sizeof(struct ixlv_sc)
+};
/*
** TUNEABLE PARAMETERS:
@@ -195,17 +215,6 @@
SYSCTL_INT(_hw_ixlv, OID_AUTO, max_queues, CTLFLAG_RDTUN,
&ixlv_max_queues, 0, "Number of Queues");
-/*
-** Number of entries in Tx queue buf_ring.
-** Increasing this will reduce the number of
-** errors when transmitting fragmented UDP
-** packets.
-*/
-static int ixlv_txbrsz = DEFAULT_TXBRSZ;
-TUNABLE_INT("hw.ixlv.txbrsz", &ixlv_txbrsz);
-SYSCTL_INT(_hw_ixlv, OID_AUTO, txbr_size, CTLFLAG_RDTUN,
- &ixlv_txbrsz, 0, "TX Buf Ring Size");
-
/*
* Different method for processing TX descriptor
* completion.
@@ -242,99 +251,99 @@
SYSCTL_INT(_hw_ixlv, OID_AUTO, tx_itr, CTLFLAG_RDTUN,
&ixlv_tx_itr, 0, "TX Interrupt Rate");
-/*********************************************************************
- * Device identification routine
- *
- * ixlv_probe determines if the driver should be loaded on
- * the hardware based on PCI vendor/device id of the device.
- *
- * return BUS_PROBE_DEFAULT on success, positive on failure
- *********************************************************************/
-
-static int
-ixlv_probe(device_t dev)
-{
- ixl_vendor_info_t *ent;
-
- u16 pci_vendor_id, pci_device_id;
- u16 pci_subvendor_id, pci_subdevice_id;
- char device_name[256];
+extern struct if_txrx ixl_txrx;
+
+static struct if_shared_ctx ixlv_sctx_init = {
+ .isc_magic = IFLIB_MAGIC,
+ .isc_q_align = PAGE_SIZE,/* max(DBA_ALIGN, PAGE_SIZE) */
+ .isc_tx_maxsize = IXL_TSO_SIZE,
+
+ .isc_tx_maxsegsize = PAGE_SIZE,
+
+ // TODO: Review the rx_maxsize and rx_maxsegsize params
+ // Where are they used in iflib?
+ .isc_rx_maxsize = 16384,
+ .isc_rx_nsegments = 1,
+ .isc_rx_maxsegsize = 16384,
+ // TODO: What is isc_nfl for?
+ .isc_nfl = 1,
+ .isc_ntxqs = 1,
+ .isc_nrxqs = 1,
+
+ .isc_admin_intrcnt = 1,
+ .isc_vendor_info = ixlv_vendor_info_array,
+ .isc_driver_version = ixlv_driver_version,
+ .isc_driver = &ixlv_if_driver,
+
+ .isc_nrxd_min = {IXL_MIN_RING},
+ .isc_ntxd_min = {IXL_MIN_RING},
+ .isc_nrxd_max = {IXL_MAX_RING},
+ .isc_ntxd_max = {IXL_MAX_RING},
+ .isc_nrxd_default = {IXL_DEFAULT_RING},
+ .isc_ntxd_default = {IXL_DEFAULT_RING},
+};
-#if 0
- INIT_DEBUGOUT("ixlv_probe: begin");
-#endif
+if_shared_ctx_t ixlv_sctx = &ixlv_sctx_init;
- pci_vendor_id = pci_get_vendor(dev);
- if (pci_vendor_id != I40E_INTEL_VENDOR_ID)
- return (ENXIO);
+/*** Functions ***/
- pci_device_id = pci_get_device(dev);
- pci_subvendor_id = pci_get_subvendor(dev);
- pci_subdevice_id = pci_get_subdevice(dev);
-
- ent = ixlv_vendor_info_array;
- while (ent->vendor_id != 0) {
- if ((pci_vendor_id == ent->vendor_id) &&
- (pci_device_id == ent->device_id) &&
-
- ((pci_subvendor_id == ent->subvendor_id) ||
- (ent->subvendor_id == 0)) &&
-
- ((pci_subdevice_id == ent->subdevice_id) ||
- (ent->subdevice_id == 0))) {
- sprintf(device_name, "%s, Version - %s",
- ixlv_strings[ent->index],
- ixlv_driver_version);
- device_set_desc_copy(dev, device_name);
- return (BUS_PROBE_DEFAULT);
- }
- ent++;
- }
- return (ENXIO);
-}
-
-/*********************************************************************
- * Device initialization routine
- *
- * The attach entry point is called when the driver is being loaded.
- * This routine identifies the type of hardware, allocates all resources
- * and initializes the hardware.
- *
- * return 0 on success, positive on failure
- *********************************************************************/
+static void *
+ixlv_register(device_t dev)
+{
+ return (ixlv_sctx);
+ }
static int
-ixlv_attach(device_t dev)
+ixlv_if_attach_pre(if_ctx_t ctx)
{
+ device_t dev;
struct ixlv_sc *sc;
struct i40e_hw *hw;
struct ixl_vsi *vsi;
- int error = 0;
+ if_softc_ctx_t scctx;
+ int error = 0;
INIT_DBG_DEV(dev, "begin");
- /* Allocate, clear, and link in our primary soft structure */
- sc = device_get_softc(dev);
- sc->dev = sc->osdep.dev = dev;
+ dev = iflib_get_dev(ctx);
+ sc = iflib_get_softc(ctx);
hw = &sc->hw;
+ /*
+ ** Note this assumes we have a single embedded VSI,
+ ** this could be enhanced later to allocate multiple
+ */
vsi = &sc->vsi;
vsi->dev = dev;
+ vsi->back = sc;
+ vsi->hw = &sc->hw;
+ // vsi->id = 0;
+ vsi->num_vlans = 0;
+ vsi->ctx = ctx;
+ vsi->media = iflib_get_media(ctx);
+ vsi->shared = scctx = iflib_get_softc_ctx(ctx);
+ sc->dev = dev;
/* Initialize hw struct */
ixlv_init_hw(sc);
-
- /* Allocate filter lists */
- ixlv_init_filters(sc);
+ /*
+ * These are the same across all current ixl models
+ */
+ vsi->shared->isc_tx_nsegments = IXL_MAX_TX_SEGS;
+ vsi->shared->isc_msix_bar = PCIR_BAR(IXL_MSIX_BAR);
+ vsi->shared->isc_tx_tso_segments_max = IXL_MAX_TSO_SEGS;
+ vsi->shared->isc_tx_tso_size_max = IXL_TSO_SIZE;
+ vsi->shared->isc_tx_tso_segsize_max = PAGE_SIZE;
/* Save this tunable */
vsi->enable_head_writeback = ixlv_enable_head_writeback;
- /* Core Lock Init */
- mtx_init(&sc->mtx, device_get_nameunit(dev),
- "IXL SC Lock", MTX_DEF);
-
- /* Set up the timer callout */
- callout_init_mtx(&sc->timer, &sc->mtx, 0);
+ scctx->isc_txqsizes[0] = roundup2(scctx->isc_ntxd[0]
+ * sizeof(struct i40e_tx_desc) + sizeof(u32), DBA_ALIGN);
+ scctx->isc_rxqsizes[0] = roundup2(scctx->isc_nrxd[0]
+ * sizeof(union i40e_32byte_rx_desc), DBA_ALIGN);
+ /* XXX: No idea what this does */
+ /* TODO: This value may depend on resources received */
+ scctx->isc_max_txqsets = scctx->isc_max_rxqsets = 16;
/* Do PCI setup - map BAR0, etc */
if (ixlv_allocate_pci_resources(sc)) {
@@ -346,6 +355,7 @@
INIT_DBG_DEV(dev, "Allocated PCI resources and MSIX vectors");
+ /* XXX: This is called by init_shared_code in the PF driver */
error = i40e_set_mac_type(hw);
if (error) {
device_printf(dev, "%s: set_mac_type failed: %d\n",
@@ -362,6 +372,7 @@
INIT_DBG_DEV(dev, "VF Device is ready for configuration");
+ /* Sets up Admin Queue */
error = ixlv_setup_vc(sc);
if (error) {
device_printf(dev, "%s: Error setting up PF comms, %d\n",
@@ -409,6 +420,7 @@
error = EIO;
goto err_res_buf;
}
+ vsi->id = sc->vsi_res->vsi_id;
INIT_DBG_DEV(dev, "Resource Acquisition complete");
@@ -420,38 +432,52 @@
addr[0] |= 0x02;
bcopy(addr, hw->mac.addr, sizeof(addr));
}
+ bcopy(hw->mac.addr, hw->mac.perm_addr, ETHER_ADDR_LEN);
+ iflib_set_mac(ctx, hw->mac.addr);
- /* Now that the number of queues for this VF is known, set up interrupts */
- sc->msix = ixlv_init_msix(sc);
- /* We fail without MSIX support */
- if (sc->msix == 0) {
- error = ENXIO;
- goto err_res_buf;
- }
+ // TODO: Is this still safe to call?
+ // ixl_vsi_setup_rings_size(vsi, ixlv_tx_ring_size, ixlv_rx_ring_size);
- vsi->id = sc->vsi_res->vsi_id;
- vsi->back = (void *)sc;
- vsi->flags |= IXL_FLAGS_IS_VF | IXL_FLAGS_USES_MSIX;
+ /* Allocate filter lists */
+ ixlv_init_filters(sc);
- ixl_vsi_setup_rings_size(vsi, ixlv_tx_ring_size, ixlv_rx_ring_size);
+ /* Fill out more iflib parameters */
+ scctx->isc_txrx = &ixl_txrx;
+ // TODO: Probably needs changing
+ vsi->shared->isc_rss_table_size = sc->hw.func_caps.rss_table_size;
+ scctx->isc_tx_csum_flags = CSUM_OFFLOAD;
+ scctx->isc_capenable = IXL_CAPS;
- /* This allocates the memory and early settings */
- if (ixlv_setup_queues(sc) != 0) {
- device_printf(dev, "%s: setup queues failed!\n",
- __func__);
- error = EIO;
- goto out;
- }
+ INIT_DBG_DEV(dev, "end");
+ return (0);
+err_res_buf:
+ free(sc->vf_res, M_DEVBUF);
+err_aq:
+ i40e_shutdown_adminq(hw);
+err_pci_res:
+ ixlv_free_pci_resources(sc);
+err_early:
+ ixlv_free_filters(sc);
+ INIT_DBG_DEV(dev, "end: error %d", error);
+ return (error);
+}
- /* Do queue interrupt setup */
- if (ixlv_assign_msix(sc) != 0) {
- device_printf(dev, "%s: allocating queue interrupts failed!\n",
- __func__);
- error = ENXIO;
- goto out;
- }
+static int
+ixlv_if_attach_post(if_ctx_t ctx)
+{
+ device_t dev;
+ struct ixlv_sc *sc;
+ struct i40e_hw *hw;
+ struct ixl_vsi *vsi;
+ int error = 0;
+
+ INIT_DBG_DEV(dev, "begin");
- INIT_DBG_DEV(dev, "Queue memory and interrupts setup");
+ dev = iflib_get_dev(ctx);
+ vsi = iflib_get_softc(ctx);
+ vsi->ifp = iflib_get_ifp(ctx);
+ sc = (struct ixlv_sc *)vsi->back;
+ hw = &sc->hw;
/* Setup the stack interface */
if (ixlv_setup_interface(dev, sc) != 0) {
@@ -463,99 +489,44 @@
INIT_DBG_DEV(dev, "Interface setup complete");
- /* Start AdminQ taskqueue */
- ixlv_init_taskqueue(sc);
-
- /* We expect a link state message, so schedule the AdminQ task now */
- taskqueue_enqueue(sc->tq, &sc->aq_irq);
-
- /* Initialize stats */
+ /* Initialize statistics & add sysctls */
bzero(&sc->vsi.eth_stats, sizeof(struct i40e_eth_stats));
ixlv_add_sysctls(sc);
- /* Register for VLAN events */
- vsi->vlan_attach = EVENTHANDLER_REGISTER(vlan_config,
- ixlv_register_vlan, vsi, EVENTHANDLER_PRI_FIRST);
- vsi->vlan_detach = EVENTHANDLER_REGISTER(vlan_unconfig,
- ixlv_unregister_vlan, vsi, EVENTHANDLER_PRI_FIRST);
-
/* We want AQ enabled early */
ixlv_enable_adminq_irq(hw);
-
- /* Set things up to run init */
- sc->init_state = IXLV_INIT_READY;
-
- ixl_vc_init_mgr(sc, &sc->vc_mgr);
-
INIT_DBG_DEV(dev, "end");
return (error);
-
+// TODO: Check if any failures can happen above
+#if 0
out:
- ixlv_free_queues(vsi);
- ixlv_teardown_adminq_msix(sc);
-err_res_buf:
free(sc->vf_res, M_DEVBUF);
-err_aq:
i40e_shutdown_adminq(hw);
-err_pci_res:
ixlv_free_pci_resources(sc);
-err_early:
- mtx_destroy(&sc->mtx);
ixlv_free_filters(sc);
INIT_DBG_DEV(dev, "end: error %d", error);
return (error);
+#endif
}
-/*********************************************************************
- * Device removal routine
- *
- * The detach entry point is called when the driver is being removed.
- * This routine stops the adapter and deallocates all the resources
- * that were allocated for driver operation.
- *
- * return 0 on success, positive on failure
- *********************************************************************/
-
static int
-ixlv_detach(device_t dev)
+ixlv_if_detach(if_ctx_t ctx)
{
- struct ixlv_sc *sc = device_get_softc(dev);
- struct ixl_vsi *vsi = &sc->vsi;
- struct i40e_hw *hw = &sc->hw;
- enum i40e_status_code status;
+ struct ixl_vsi *vsi = iflib_get_softc(ctx);
+ struct ixlv_sc *sc = vsi->back;
+ struct i40e_hw *hw = &sc->hw;
+ device_t dev = sc->dev;
+ enum i40e_status_code status;
INIT_DBG_DEV(dev, "begin");
- /* Make sure VLANS are not using driver */
- if (vsi->ifp->if_vlantrunk != NULL) {
- if_printf(vsi->ifp, "Vlan in use, detach first\n");
- return (EBUSY);
- }
-
/* Remove all the media and link information */
ifmedia_removeall(&sc->media);
- /* Stop driver */
- ether_ifdetach(vsi->ifp);
- if (vsi->ifp->if_drv_flags & IFF_DRV_RUNNING) {
- mtx_lock(&sc->mtx);
- ixlv_stop(sc);
- mtx_unlock(&sc->mtx);
- }
-
- /* Unregister VLAN events */
- if (vsi->vlan_attach != NULL)
- EVENTHANDLER_DEREGISTER(vlan_config, vsi->vlan_attach);
- if (vsi->vlan_detach != NULL)
- EVENTHANDLER_DEREGISTER(vlan_unconfig, vsi->vlan_detach);
-
/* Drain VC mgr */
callout_drain(&sc->vc_mgr.callout);
ixlv_disable_adminq_irq(hw);
- ixlv_teardown_adminq_msix(sc);
- /* Drain admin queue taskqueue */
- taskqueue_free(sc->tq);
status = i40e_shutdown_adminq(&sc->hw);
if (status != I40E_SUCCESS) {
device_printf(dev,
@@ -563,123 +534,57 @@
i40e_stat_str(hw, status));
}
- if_free(vsi->ifp);
free(sc->vf_res, M_DEVBUF);
- ixlv_free_queues(vsi);
ixlv_free_pci_resources(sc);
ixlv_free_filters(sc);
- bus_generic_detach(dev);
- mtx_destroy(&sc->mtx);
INIT_DBG_DEV(dev, "end");
return (0);
}
-/*********************************************************************
- *
- * Shutdown entry point
- *
- **********************************************************************/
-
+/* TODO: Do shutdown-specific stuff here */
static int
-ixlv_shutdown(device_t dev)
+ixlv_if_shutdown(if_ctx_t ctx)
{
- struct ixlv_sc *sc = device_get_softc(dev);
+ int error = 0;
INIT_DBG_DEV(dev, "begin");
- mtx_lock(&sc->mtx);
- ixlv_stop(sc);
- mtx_unlock(&sc->mtx);
+ /* TODO: Call ixl_if_stop()? */
- INIT_DBG_DEV(dev, "end");
- return (0);
+ return (error);
}
-/*
- * Configure TXCSUM(IPV6) and TSO(4/6)
- * - the hardware handles these together so we
- * need to tweak them
- */
-static void
-ixlv_cap_txcsum_tso(struct ixl_vsi *vsi, struct ifnet *ifp, int mask)
-{
- /* Enable/disable TXCSUM/TSO4 */
- if (!(ifp->if_capenable & IFCAP_TXCSUM)
- && !(ifp->if_capenable & IFCAP_TSO4)) {
- if (mask & IFCAP_TXCSUM) {
- ifp->if_capenable |= IFCAP_TXCSUM;
- /* enable TXCSUM, restore TSO if previously enabled */
- if (vsi->flags & IXL_FLAGS_KEEP_TSO4) {
- vsi->flags &= ~IXL_FLAGS_KEEP_TSO4;
- ifp->if_capenable |= IFCAP_TSO4;
- }
- }
- else if (mask & IFCAP_TSO4) {
- ifp->if_capenable |= (IFCAP_TXCSUM | IFCAP_TSO4);
- vsi->flags &= ~IXL_FLAGS_KEEP_TSO4;
- if_printf(ifp,
- "TSO4 requires txcsum, enabling both...\n");
- }
- } else if((ifp->if_capenable & IFCAP_TXCSUM)
- && !(ifp->if_capenable & IFCAP_TSO4)) {
- if (mask & IFCAP_TXCSUM)
- ifp->if_capenable &= ~IFCAP_TXCSUM;
- else if (mask & IFCAP_TSO4)
- ifp->if_capenable |= IFCAP_TSO4;
- } else if((ifp->if_capenable & IFCAP_TXCSUM)
- && (ifp->if_capenable & IFCAP_TSO4)) {
- if (mask & IFCAP_TXCSUM) {
- vsi->flags |= IXL_FLAGS_KEEP_TSO4;
- ifp->if_capenable &= ~(IFCAP_TXCSUM | IFCAP_TSO4);
- if_printf(ifp,
- "TSO4 requires txcsum, disabling both...\n");
- } else if (mask & IFCAP_TSO4)
- ifp->if_capenable &= ~IFCAP_TSO4;
- }
-
- /* Enable/disable TXCSUM_IPV6/TSO6 */
- if (!(ifp->if_capenable & IFCAP_TXCSUM_IPV6)
- && !(ifp->if_capenable & IFCAP_TSO6)) {
- if (mask & IFCAP_TXCSUM_IPV6) {
- ifp->if_capenable |= IFCAP_TXCSUM_IPV6;
- if (vsi->flags & IXL_FLAGS_KEEP_TSO6) {
- vsi->flags &= ~IXL_FLAGS_KEEP_TSO6;
- ifp->if_capenable |= IFCAP_TSO6;
- }
- } else if (mask & IFCAP_TSO6) {
- ifp->if_capenable |= (IFCAP_TXCSUM_IPV6 | IFCAP_TSO6);
- vsi->flags &= ~IXL_FLAGS_KEEP_TSO6;
- if_printf(ifp,
- "TSO6 requires txcsum6, enabling both...\n");
- }
- } else if((ifp->if_capenable & IFCAP_TXCSUM_IPV6)
- && !(ifp->if_capenable & IFCAP_TSO6)) {
- if (mask & IFCAP_TXCSUM_IPV6)
- ifp->if_capenable &= ~IFCAP_TXCSUM_IPV6;
- else if (mask & IFCAP_TSO6)
- ifp->if_capenable |= IFCAP_TSO6;
- } else if ((ifp->if_capenable & IFCAP_TXCSUM_IPV6)
- && (ifp->if_capenable & IFCAP_TSO6)) {
- if (mask & IFCAP_TXCSUM_IPV6) {
- vsi->flags |= IXL_FLAGS_KEEP_TSO6;
- ifp->if_capenable &= ~(IFCAP_TXCSUM_IPV6 | IFCAP_TSO6);
- if_printf(ifp,
- "TSO6 requires txcsum6, disabling both...\n");
- } else if (mask & IFCAP_TSO6)
- ifp->if_capenable &= ~IFCAP_TSO6;
- }
+/* TODO: What is a VF supposed to do in suspend/resume? */
+static int
+ixlv_if_suspend(if_ctx_t ctx)
+{
+ int error = 0;
+
+ INIT_DBG_DEV(dev, "begin");
+
+ /* TODO: Call ixl_if_stop()? */
+
+ return (error);
}
-/*********************************************************************
- * Ioctl entry point
- *
- * ixlv_ioctl is called when the user wants to configure the
- * interface.
- *
- * return 0 on success, positive on failure
- **********************************************************************/
+static int
+ixlv_if_resume(if_ctx_t ctx)
+{
+ struct ifnet *ifp = iflib_get_ifp(ctx);
+ INIT_DBG_DEV(dev, "begin");
+
+ /* Read & clear wake-up registers */
+
+ /* Required after D3->D0 transition */
+ if (ifp->if_flags & IFF_UP)
+ ixlv_if_init(ctx);
+
+ return (0);
+}
+
+#if 0
static int
ixlv_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
{
@@ -812,6 +717,7 @@
return (error);
}
+#endif
/*
** To do a reinit on the VF is unfortunately more complicated
@@ -893,14 +799,18 @@
}
}
-static void
-ixlv_init_locked(struct ixlv_sc *sc)
+void
+ixlv_if_init(if_ctx_t ctx)
{
- struct i40e_hw *hw = &sc->hw;
- struct ixl_vsi *vsi = &sc->vsi;
- struct ixl_queue *que = vsi->queues;
- struct ifnet *ifp = vsi->ifp;
- int error = 0;
+ struct ixl_vsi *vsi = iflib_get_softc(ctx);
+ if_softc_ctx_t scctx = vsi->shared;
+ struct ixlv_sc *sc = vsi->back;
+ struct i40e_hw *hw = &sc->hw;
+ struct ifnet *ifp = iflib_get_ifp(ctx);
+ struct ixl_tx_queue *tx_que = vsi->tx_queues;
+ struct ixl_rx_queue *rx_que = vsi->rx_queues;
+
+ int error = 0;
INIT_DBG_IF(ifp, "begin");
@@ -927,14 +837,6 @@
/* Check for an LAA mac address... */
bcopy(IF_LLADDR(ifp), hw->mac.addr, ETHER_ADDR_LEN);
- ifp->if_hwassist = 0;
- if (ifp->if_capenable & IFCAP_TSO)
- ifp->if_hwassist |= CSUM_TSO;
- if (ifp->if_capenable & IFCAP_TXCSUM)
- ifp->if_hwassist |= (CSUM_OFFLOAD_IPV4 & ~CSUM_IP);
- if (ifp->if_capenable & IFCAP_TXCSUM_IPV6)
- ifp->if_hwassist |= CSUM_OFFLOAD_IPV6;
-
/* Add mac filter for this VF to PF */
if (i40e_validate_mac_addr(hw->mac.addr) == I40E_SUCCESS) {
error = ixlv_add_mac_filter(sc, hw->mac.addr, 0);
@@ -947,17 +849,19 @@
/* Setup vlan's if needed */
ixlv_setup_vlan_filters(sc);
+ // TODO: Functionize
/* Prepare the queues for operation */
- for (int i = 0; i < vsi->num_queues; i++, que++) {
- struct rx_ring *rxr = &que->rxr;
-
- ixl_init_tx_ring(que);
+ for (int i = 0; i < vsi->num_tx_queues; i++, tx_que++) {
+ // TODO: Necessary? Correct?
+ ixl_init_tx_ring(vsi, tx_que);
+ }
+ for (int i = 0; i < vsi->num_rx_queues; i++, rx_que++) {
+ struct rx_ring *rxr = &rx_que->rxr;
- if (vsi->max_frame_size <= MCLBYTES)
+ if (scctx->isc_max_frame_size <= MCLBYTES)
rxr->mbuf_sz = MCLBYTES;
else
rxr->mbuf_sz = MJUMPAGESIZE;
- ixl_init_rx_ring(que);
}
/* Set initial ITR values */
@@ -978,9 +882,6 @@
ixl_vc_enqueue(&sc->vc_mgr, &sc->enable_queues_cmd,
IXLV_FLAG_AQ_ENABLE_QUEUES, ixl_init_cmd_complete, sc);
- /* Start the local timer */
- callout_reset(&sc->timer, hz, ixlv_local_timer, sc);
-
sc->init_state = IXLV_RUNNING;
init_done:
@@ -988,9 +889,7 @@
return;
}
-/*
-** Init entry point for the stack
-*/
+#if 0
void
ixlv_init(void *arg)
{
@@ -1047,6 +946,7 @@
hw->bus.device = pci_get_slot(dev);
hw->bus.func = pci_get_function(dev);
}
+#endif
/*
* ixlv_attach() helper function; initalizes the admin queue
@@ -1210,287 +1110,665 @@
}
goto done;
-fail:
- free(sc->vf_res, M_DEVBUF);
-done:
- return (ret_error);
+fail:
+ free(sc->vf_res, M_DEVBUF);
+done:
+ return (ret_error);
+}
+
+static int
+ixlv_if_msix_intr_assign(if_ctx_t ctx, int msix)
+{
+ struct ixl_vsi *vsi = iflib_get_softc(ctx);
+ struct ixlv_sc *sc = vsi->back;
+ struct ixl_rx_queue *que = vsi->rx_queues;
+ struct ixl_tx_queue *tx_que = vsi->tx_queues;
+ int err, i, rid, vector = 0;
+ char buf[16];
+
+ /* Admin Que is vector 0*/
+ rid = vector + 1;
+
+ err = iflib_irq_alloc_generic(ctx, &vsi->irq, rid, IFLIB_INTR_ADMIN,
+ ixlv_msix_adminq, sc, 0, "aq");
+ if (err) {
+ iflib_irq_free(ctx, &vsi->irq);
+ device_printf(iflib_get_dev(ctx), "Failed to register Admin que handler");
+ return (err);
+ }
+ sc->admvec = vector;
+ ++vector;
+
+ /* Now set up the stations */
+ for (i = 0; i < vsi->num_rx_queues; i++, vector++, que++) {
+ rid = vector + 1;
+
+ snprintf(buf, sizeof(buf), "rxq%d", i);
+ err = iflib_irq_alloc_generic(ctx, &que->que_irq, rid, IFLIB_INTR_RX,
+ ixlv_msix_que, que, que->rxr.me, buf);
+ if (err) {
+ device_printf(iflib_get_dev(ctx), "Failed to allocate q int %d err: %d", i, err);
+ vsi->num_rx_queues = i + 1;
+ goto fail;
+ }
+ que->msix = vector;
+ }
+
+ for (i = 0, tx_que = vsi->tx_queues; i < vsi->num_tx_queues; i++, tx_que++) {
+ snprintf(buf, sizeof(buf), "txq%d", i);
+ rid = que->msix + 1;
+ iflib_softirq_alloc_generic(ctx, rid, IFLIB_INTR_TX, tx_que, tx_que->txr.me, buf);
+ }
+
+ return (0);
+fail:
+ iflib_irq_free(ctx, &vsi->irq);
+ que = vsi->rx_queues;
+ for (int i = 0; i < vsi->num_rx_queues; i++, que++)
+ iflib_irq_free(ctx, &que->que_irq);
+ return (err);
+}
+
+/* Enable all interrupts */
+static void
+ixlv_if_enable_intr(if_ctx_t ctx)
+{
+ struct ixl_vsi *vsi = iflib_get_softc(ctx);
+
+ ixlv_enable_intr(vsi);
+}
+
+/* Disable all interrupts */
+static void
+ixlv_if_disable_intr(if_ctx_t ctx)
+{
+ struct ixl_vsi *vsi = iflib_get_softc(ctx);
+
+ ixlv_disable_intr(vsi);
+}
+
+/* Enable queue interrupt */
+static int
+ixlv_if_queue_intr_enable(if_ctx_t ctx, uint16_t rxqid)
+{
+ struct ixl_vsi *vsi = iflib_get_softc(ctx);
+ struct i40e_hw *hw = vsi->hw;
+ struct ixl_rx_queue *que = &vsi->rx_queues[rxqid];
+
+ ixlv_enable_queue_irq(hw, que->rxr.me);
+
+ return (0);
+}
+
+static int
+ixlv_if_tx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs, uint64_t *paddrs, int ntxqs, int ntxqsets)
+{
+ struct ixl_vsi *vsi = iflib_get_softc(ctx);
+ struct ixl_tx_queue *que;
+ int i;
+
+ MPASS(vsi->num_tx_queues > 0);
+ MPASS(ntxqs == 1);
+ MPASS(vsi->num_tx_queues == ntxqsets);
+
+ /* Allocate queue structure memory */
+ if (!(vsi->tx_queues =
+ (struct ixl_tx_queue *) malloc(sizeof(struct ixl_tx_queue) *ntxqsets, M_IXLV, M_NOWAIT | M_ZERO))) {
+ device_printf(iflib_get_dev(ctx), "Unable to allocate TX ring memory\n");
+ return (ENOMEM);
+ }
+
+ for (i = 0, que = vsi->tx_queues; i < ntxqsets; i++, que++) {
+ struct tx_ring *txr = &que->txr;
+ txr->me = i;
+ que->vsi = vsi;
+
+ /* get the virtual and physical address of the hardware queues */
+ txr->tail = I40E_QTX_TAIL1(txr->me);
+ txr->tx_base = (struct i40e_tx_desc *)vaddrs[i];
+ txr->tx_paddr = paddrs[i];
+ txr->que = que;
+ }
+
+ // TODO: Do a config_gtask_init for admin queue here?
+ // iflib_config_gtask_init(ctx, &adapter->mod_task, ixgbe_handle_mod, "mod_task");
+
+ device_printf(iflib_get_dev(ctx), "%s: allocated for %d txqs\n", __func__, vsi->num_tx_queues);
+ return (0);
+}
+
+static int
+ixlv_if_rx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs, uint64_t *paddrs, int nrxqs, int nrxqsets)
+{
+ struct ixl_vsi *vsi = iflib_get_softc(ctx);
+ struct ixl_rx_queue *que;
+ int i;
+
+ MPASS(vsi->num_rx_queues > 0);
+ MPASS(nrxqs == 1);
+ MPASS(vsi->num_rx_queues == nrxqsets);
+
+ /* Allocate queue structure memory */
+ if (!(vsi->rx_queues =
+ (struct ixl_rx_queue *) malloc(sizeof(struct ixl_rx_queue) *
+ nrxqsets, M_IXLV, M_NOWAIT | M_ZERO))) {
+ device_printf(iflib_get_dev(ctx), "Unable to allocate RX ring memory\n");
+ return (ENOMEM);
+ }
+
+ for (i = 0, que = vsi->rx_queues; i < nrxqsets; i++, que++) {
+ struct rx_ring *rxr = &que->rxr;
+
+ rxr->me = i;
+ que->vsi = vsi;
+
+ /* get the virtual and physical address of the hardware queues */
+ rxr->tail = I40E_QRX_TAIL1(rxr->me);
+ rxr->rx_base = (union i40e_rx_desc *)vaddrs[i];
+ rxr->rx_paddr = paddrs[i];
+ rxr->que = que;
+ }
+
+ device_printf(iflib_get_dev(ctx), "%s: allocated for %d rxqs\n", __func__, vsi->num_rx_queues);
+ return (0);
+}
+
+static void
+ixlv_if_queues_free(if_ctx_t ctx)
+{
+ struct ixl_vsi *vsi = iflib_get_softc(ctx);
+
+ if (vsi->tx_queues != NULL) {
+ free(vsi->tx_queues, M_IXLV);
+ vsi->tx_queues = NULL;
+ }
+ if (vsi->rx_queues != NULL) {
+ free(vsi->rx_queues, M_IXLV);
+ vsi->rx_queues = NULL;
+ }
+}
+
+// TODO: Implement
+static void
+ixlv_if_update_admin_status(if_ctx_t ctx)
+{
+ struct ixl_vsi *vsi = iflib_get_softc(ctx);
+ //struct ixlv_sc *sc = vsi->back;
+ //struct i40e_hw *hw = &sc->hw;
+ //struct i40e_arq_event_info event;
+ //i40e_status ret;
+ //u32 loop = 0;
+ //u16 opcode
+ u16 result = 0;
+ //u64 baudrate;
+
+ /* TODO: Split up
+ * - Update admin queue stuff
+ * - Update link status
+ * - Enqueue aq task
+ * - Re-enable admin intr
+ */
+
+/* TODO: Does VF reset need to be handled here? */
+#if 0
+ if (pf->state & IXL_PF_STATE_EMPR_RESETTING) {
+ /* Flag cleared at end of this function */
+ ixl_handle_empr_reset(pf);
+ return;
+ }
+#endif
+
+#if 0
+ event.buf_len = IXL_AQ_BUF_SZ;
+ event.msg_buf = malloc(event.buf_len,
+ M_IXLV, M_NOWAIT | M_ZERO);
+ if (!event.msg_buf) {
+ device_printf(pf->dev, "%s: Unable to allocate memory for Admin"
+ " Queue event!\n", __func__);
+ return;
+ }
+
+ /* clean and process any events */
+ do {
+ ret = i40e_clean_arq_element(hw, &event, &result);
+ if (ret)
+ break;
+ opcode = LE16_TO_CPU(event.desc.opcode);
+ ixl_dbg(pf, IXL_DBG_AQ,
+ "Admin Queue event: %#06x\n", opcode);
+ switch (opcode) {
+ case i40e_aqc_opc_get_link_status:
+ ixl_link_event(pf, &event);
+ break;
+ case i40e_aqc_opc_send_msg_to_pf:
+#ifdef PCI_IOV
+ ixl_handle_vf_msg(pf, &event);
+#endif
+ break;
+ case i40e_aqc_opc_event_lan_overflow:
+ break;
+ default:
+#ifdef IXL_DEBUG
+ printf("AdminQ unknown event %x\n", opcode);
+#endif
+ break;
+ }
+
+ } while (result && (loop++ < IXL_ADM_LIMIT));
+
+ free(event.msg_buf, M_IXLV);
+#endif
+
+#if 0
+ /* XXX: This updates the link status */
+ if (pf->link_up) {
+ if (vsi->link_active == FALSE) {
+ vsi->link_active = TRUE;
+ baudrate = ixl_max_aq_speed_to_value(pf->link_speed);
+ iflib_link_state_change(ctx, LINK_STATE_UP, baudrate);
+ ixl_link_up_msg(pf);
+ // ixl_ping_all_vfs(adapter);
+ }
+ } else { /* Link down */
+ if (vsi->link_active == TRUE) {
+ vsi->link_active = FALSE;
+ iflib_link_state_change(ctx, LINK_STATE_DOWN, 0);
+ // ixl_ping_all_vfs(adapter);
+ }
+ }
+#endif
+
+ /*
+ * If there are still messages to process, reschedule ourselves.
+ * Otherwise, re-enable our interrupt and go to sleep.
+ */
+ if (result > 0)
+ iflib_admin_intr_deferred(ctx);
+ else
+ /* TODO: Link/adminq interrupt should be re-enabled in IFDI_LINK_INTR_ENABLE */
+ ixlv_enable_intr(vsi);
+}
+
+static void
+ixlv_if_multi_set(if_ctx_t ctx)
+{
+ // struct ixl_vsi *vsi = iflib_get_softc(ctx);
+ // struct i40e_hw *hw = vsi->hw;
+ // struct ixlv_sc *sc = vsi->back;
+ // int mcnt = 0, flags;
+
+ IOCTL_DEBUGOUT("ixl_if_multi_set: begin");
+
+ // TODO: Implement
+#if 0
+ mcnt = if_multiaddr_count(iflib_get_ifp(ctx), MAX_MULTICAST_ADDR);
+ /* delete existing MC filters */
+ ixlv_del_multi(vsi);
+
+ if (__predict_false(mcnt == MAX_MULTICAST_ADDR)) {
+ // Set promiscuous mode (multicast)
+ // TODO: This needs to get handled somehow
+#if 0
+ ixl_vc_enqueue(&sc->vc_mgr, &sc->add_vlan_cmd,
+ IXLV_FLAG_AQ_CONFIGURE_PROMISC, ixl_init_cmd_complete, sc);
+#endif
+ return;
+ }
+ /* (re-)install filters for all mcast addresses */
+ mcnt = if_multi_apply(iflib_get_ifp(ctx), ixl_mc_filter_apply, vsi);
+
+ if (mcnt > 0) {
+ flags = (IXL_FILTER_ADD | IXL_FILTER_USED | IXL_FILTER_MC);
+ ixlv_add_hw_filters(vsi, flags, mcnt);
+ }
+#endif
+
+ IOCTL_DEBUGOUT("ixl_if_multi_set: end");
+}
+
+static void
+ixlv_if_media_status(if_ctx_t ctx, struct ifmediareq *ifmr)
+{
+ struct ixl_vsi *vsi = iflib_get_softc(ctx);
+ struct ixlv_sc *sc = (struct ixlv_sc *)vsi->back;
+ struct i40e_hw *hw = &sc->hw;
+
+ INIT_DEBUGOUT("ixl_media_status: begin");
+
+ hw->phy.get_link_info = TRUE;
+ i40e_get_link_status(hw, &sc->link_up);
+
+ ifmr->ifm_status = IFM_AVALID;
+ ifmr->ifm_active = IFM_ETHER;
+
+ if (!sc->link_up) {
+ return;
+ }
+
+ ifmr->ifm_status |= IFM_ACTIVE;
+ /* Hardware is always full-duplex */
+ ifmr->ifm_active |= IFM_FDX;
+
+ // TODO: Check another variable to get link speed
+#if 0
+ switch (hw->phy.link_info.phy_type) {
+ /* 100 M */
+ case I40E_PHY_TYPE_100BASE_TX:
+ ifmr->ifm_active |= IFM_100_TX;
+ break;
+ /* 1 G */
+ case I40E_PHY_TYPE_1000BASE_T:
+ ifmr->ifm_active |= IFM_1000_T;
+ break;
+ case I40E_PHY_TYPE_1000BASE_SX:
+ ifmr->ifm_active |= IFM_1000_SX;
+ break;
+ case I40E_PHY_TYPE_1000BASE_LX:
+ ifmr->ifm_active |= IFM_1000_LX;
+ break;
+ case I40E_PHY_TYPE_1000BASE_T_OPTICAL:
+ ifmr->ifm_active |= IFM_OTHER;
+ break;
+ /* 10 G */
+ case I40E_PHY_TYPE_10GBASE_SFPP_CU:
+ ifmr->ifm_active |= IFM_10G_TWINAX;
+ break;
+ case I40E_PHY_TYPE_10GBASE_SR:
+ ifmr->ifm_active |= IFM_10G_SR;
+ break;
+ case I40E_PHY_TYPE_10GBASE_LR:
+ ifmr->ifm_active |= IFM_10G_LR;
+ break;
+ case I40E_PHY_TYPE_10GBASE_T:
+ ifmr->ifm_active |= IFM_10G_T;
+ break;
+ case I40E_PHY_TYPE_XAUI:
+ case I40E_PHY_TYPE_XFI:
+ case I40E_PHY_TYPE_10GBASE_AOC:
+ ifmr->ifm_active |= IFM_OTHER;
+ break;
+ /* 25 G */
+ case I40E_PHY_TYPE_25GBASE_KR:
+ ifmr->ifm_active |= IFM_25G_KR;
+ break;
+ case I40E_PHY_TYPE_25GBASE_CR:
+ ifmr->ifm_active |= IFM_25G_CR;
+ break;
+ case I40E_PHY_TYPE_25GBASE_SR:
+ ifmr->ifm_active |= IFM_25G_SR;
+ break;
+ case I40E_PHY_TYPE_25GBASE_LR:
+ ifmr->ifm_active |= IFM_UNKNOWN;
+ break;
+ /* 40 G */
+ case I40E_PHY_TYPE_40GBASE_CR4:
+ case I40E_PHY_TYPE_40GBASE_CR4_CU:
+ ifmr->ifm_active |= IFM_40G_CR4;
+ break;
+ case I40E_PHY_TYPE_40GBASE_SR4:
+ ifmr->ifm_active |= IFM_40G_SR4;
+ break;
+ case I40E_PHY_TYPE_40GBASE_LR4:
+ ifmr->ifm_active |= IFM_40G_LR4;
+ break;
+ case I40E_PHY_TYPE_XLAUI:
+ ifmr->ifm_active |= IFM_OTHER;
+ break;
+ case I40E_PHY_TYPE_1000BASE_KX:
+ ifmr->ifm_active |= IFM_1000_KX;
+ break;
+ case I40E_PHY_TYPE_SGMII:
+ ifmr->ifm_active |= IFM_1000_SGMII;
+ break;
+ /* ERJ: What's the difference between these? */
+ case I40E_PHY_TYPE_10GBASE_CR1_CU:
+ case I40E_PHY_TYPE_10GBASE_CR1:
+ ifmr->ifm_active |= IFM_10G_CR1;
+ break;
+ case I40E_PHY_TYPE_10GBASE_KX4:
+ ifmr->ifm_active |= IFM_10G_KX4;
+ break;
+ case I40E_PHY_TYPE_10GBASE_KR:
+ ifmr->ifm_active |= IFM_10G_KR;
+ break;
+ case I40E_PHY_TYPE_SFI:
+ ifmr->ifm_active |= IFM_10G_SFI;
+ break;
+ /* Our single 20G media type */
+ case I40E_PHY_TYPE_20GBASE_KR2:
+ ifmr->ifm_active |= IFM_20G_KR2;
+ break;
+ case I40E_PHY_TYPE_40GBASE_KR4:
+ ifmr->ifm_active |= IFM_40G_KR4;
+ break;
+ case I40E_PHY_TYPE_XLPPI:
+ case I40E_PHY_TYPE_40GBASE_AOC:
+ ifmr->ifm_active |= IFM_40G_XLPPI;
+ break;
+ /* Unknown to driver */
+ default:
+ ifmr->ifm_active |= IFM_UNKNOWN;
+ break;
+ }
+ /* Report flow control status as well */
+ if (hw->phy.link_info.an_info & I40E_AQ_LINK_PAUSE_TX)
+ ifmr->ifm_active |= IFM_ETH_TXPAUSE;
+ if (hw->phy.link_info.an_info & I40E_AQ_LINK_PAUSE_RX)
+ ifmr->ifm_active |= IFM_ETH_RXPAUSE;
+ #endif
+}
+
+static int
+ixlv_if_media_change(if_ctx_t ctx)
+{
+ struct ifmedia *ifm = iflib_get_media(ctx);
+
+ INIT_DEBUGOUT("ixl_media_change: begin");
+
+ if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)
+ return (EINVAL);
+
+ if_printf(iflib_get_ifp(ctx), "Media change is not supported.\n");
+ return (ENODEV);
}
-/*
- * Allocate MSI/X vectors, setup the AQ vector early
- */
+// TODO: Rework
static int
-ixlv_init_msix(struct ixlv_sc *sc)
+ixlv_if_promisc_set(if_ctx_t ctx, int flags)
{
- device_t dev = sc->dev;
- int rid, want, vectors, queues, available;
- int auto_max_queues;
+ struct ixl_vsi *vsi = iflib_get_softc(ctx);
+ struct ifnet *ifp = iflib_get_ifp(ctx);
+ struct i40e_hw *hw = vsi->hw;
+ int err;
+ bool uni = FALSE, multi = FALSE;
- rid = PCIR_BAR(IXL_MSIX_BAR);
- sc->msix_mem = bus_alloc_resource_any(dev,
- SYS_RES_MEMORY, &rid, RF_ACTIVE);
- if (!sc->msix_mem) {
- /* May not be enabled */
- device_printf(sc->dev,
- "Unable to map MSIX table\n");
- goto fail;
- }
+ if (flags & IFF_ALLMULTI ||
+ if_multiaddr_count(ifp, MAX_MULTICAST_ADDR) == MAX_MULTICAST_ADDR)
+ multi = TRUE;
+ if (flags & IFF_PROMISC)
+ uni = TRUE;
- available = pci_msix_count(dev);
- if (available == 0) { /* system has msix disabled */
- bus_release_resource(dev, SYS_RES_MEMORY,
- rid, sc->msix_mem);
- sc->msix_mem = NULL;
- goto fail;
- }
-
- /* Clamp queues to number of CPUs and # of MSI-X vectors available */
- auto_max_queues = min(mp_ncpus, available - 1);
- /* Clamp queues to # assigned to VF by PF */
- auto_max_queues = min(auto_max_queues, sc->vf_res->num_queue_pairs);
-
- /* Override with tunable value if tunable is less than autoconfig count */
- if ((ixlv_max_queues != 0) && (ixlv_max_queues <= auto_max_queues))
- queues = ixlv_max_queues;
- /* Use autoconfig amount if that's lower */
- else if ((ixlv_max_queues != 0) && (ixlv_max_queues > auto_max_queues)) {
- device_printf(dev, "ixlv_max_queues (%d) is too large, using "
- "autoconfig amount (%d)...\n",
- ixlv_max_queues, auto_max_queues);
- queues = auto_max_queues;
- }
- /* Limit maximum auto-configured queues to 8 if no user value is set */
- else
- queues = min(auto_max_queues, 8);
+ err = i40e_aq_set_vsi_unicast_promiscuous(hw,
+ vsi->seid, uni, NULL, false);
+ if (err)
+ return (err);
+ err = i40e_aq_set_vsi_multicast_promiscuous(hw,
+ vsi->seid, multi, NULL);
+ return (err);
+}
-#ifdef RSS
- /* If we're doing RSS, clamp at the number of RSS buckets */
- if (queues > rss_getnumbuckets())
- queues = rss_getnumbuckets();
-#endif
+static void
+ixlv_if_timer(if_ctx_t ctx, uint16_t qid)
+{
+ struct ixl_vsi *vsi = iflib_get_softc(ctx);
+ struct ixlv_sc *sc = vsi->back;
+ //struct i40e_hw *hw = &sc->hw;
+ //struct ixl_tx_queue *que = &vsi->tx_queues[qid];
+ //u32 mask;
+#if 0
/*
- ** Want one vector (RX/TX pair) per queue
- ** plus an additional for the admin queue.
+ ** Check status of the queues
*/
- want = queues + 1;
- if (want <= available) /* Have enough */
- vectors = want;
- else {
- device_printf(sc->dev,
- "MSIX Configuration Problem, "
- "%d vectors available but %d wanted!\n",
- available, want);
- goto fail;
- }
+ mask = (I40E_PFINT_DYN_CTLN_INTENA_MASK |
+ I40E_PFINT_DYN_CTLN_SWINT_TRIG_MASK);
+
+ /* If queue param has outstanding work, trigger sw irq */
+ // TODO: TX queues in iflib don't use HW interrupts; does this do anything?
+ if (que->busy)
+ wr32(hw, I40E_PFINT_DYN_CTLN(que->txr.me), mask);
+ #endif
+
+ // XXX: Is this timer per-queue?
+ if (qid != 0)
+ return;
-#ifdef RSS
- /*
- * If we're doing RSS, the number of queues needs to
- * match the number of RSS buckets that are configured.
- *
- * + If there's more queues than RSS buckets, we'll end
- * up with queues that get no traffic.
- *
- * + If there's more RSS buckets than queues, we'll end
- * up having multiple RSS buckets map to the same queue,
- * so there'll be some contention.
- */
- if (queues != rss_getnumbuckets()) {
- device_printf(dev,
- "%s: queues (%d) != RSS buckets (%d)"
- "; performance will be impacted.\n",
- __func__, queues, rss_getnumbuckets());
- }
-#endif
+ /* Fire off the adminq task */
+ iflib_admin_intr_deferred(ctx);
- if (pci_alloc_msix(dev, &vectors) == 0) {
- device_printf(sc->dev,
- "Using MSIX interrupts with %d vectors\n", vectors);
- sc->msix = vectors;
- sc->vsi.num_queues = queues;
- }
+ /* Update stats */
+ ixlv_request_stats(sc);
+}
- /* Next we need to setup the vector for the Admin Queue */
- rid = 1; /* zero vector + 1 */
- sc->res = bus_alloc_resource_any(dev, SYS_RES_IRQ,
- &rid, RF_SHAREABLE | RF_ACTIVE);
- if (sc->res == NULL) {
- device_printf(dev, "Unable to allocate"
- " bus resource: AQ interrupt \n");
- goto fail;
- }
- if (bus_setup_intr(dev, sc->res,
- INTR_TYPE_NET | INTR_MPSAFE, NULL,
- ixlv_msix_adminq, sc, &sc->tag)) {
- sc->res = NULL;
- device_printf(dev, "Failed to register AQ handler");
- goto fail;
- }
- bus_describe_intr(dev, sc->res, sc->tag, "adminq");
+static void
+ixlv_if_vlan_register(if_ctx_t ctx, u16 vtag)
+{
+ struct ixl_vsi *vsi = iflib_get_softc(ctx);
+ //struct i40e_hw *hw = vsi->hw;
+
+ if ((vtag == 0) || (vtag > 4095)) /* Invalid */
+ return;
- return (vectors);
+ ++vsi->num_vlans;
+ // TODO: Redo
+ // ixlv_add_filter(vsi, hw->mac.addr, vtag);
+}
-fail:
- /* The VF driver MUST use MSIX */
- return (0);
+static void
+ixlv_if_vlan_unregister(if_ctx_t ctx, u16 vtag)
+{
+ struct ixl_vsi *vsi = iflib_get_softc(ctx);
+ //struct i40e_hw *hw = vsi->hw;
+
+ if ((vtag == 0) || (vtag > 4095)) /* Invalid */
+ return;
+
+ --vsi->num_vlans;
+ // TODO: Redo
+ // ixlv_del_filter(vsi, hw->mac.addr, vtag);
+}
+
+static uint64_t
+ixlv_if_get_counter(if_ctx_t ctx, ift_counter cnt)
+{
+ struct ixl_vsi *vsi = iflib_get_softc(ctx);
+ if_t ifp = iflib_get_ifp(ctx);
+
+ switch (cnt) {
+ case IFCOUNTER_IPACKETS:
+ return (vsi->ipackets);
+ case IFCOUNTER_IERRORS:
+ return (vsi->ierrors);
+ case IFCOUNTER_OPACKETS:
+ return (vsi->opackets);
+ case IFCOUNTER_OERRORS:
+ return (vsi->oerrors);
+ case IFCOUNTER_COLLISIONS:
+ /* Collisions are by standard impossible in 40G/10G Ethernet */
+ return (0);
+ case IFCOUNTER_IBYTES:
+ return (vsi->ibytes);
+ case IFCOUNTER_OBYTES:
+ return (vsi->obytes);
+ case IFCOUNTER_IMCASTS:
+ return (vsi->imcasts);
+ case IFCOUNTER_OMCASTS:
+ return (vsi->omcasts);
+ case IFCOUNTER_IQDROPS:
+ return (vsi->iqdrops);
+ case IFCOUNTER_OQDROPS:
+ return (vsi->oqdrops);
+ case IFCOUNTER_NOPROTO:
+ return (vsi->noproto);
+ default:
+ return (if_get_counter_default(ifp, cnt));
+ }
}
static int
ixlv_allocate_pci_resources(struct ixlv_sc *sc)
{
+ struct i40e_hw *hw = &sc->hw;
+ device_t dev = iflib_get_dev(sc->vsi.ctx);
int rid;
- device_t dev = sc->dev;
+ /* Map BAR0 */
rid = PCIR_BAR(0);
sc->pci_mem = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
&rid, RF_ACTIVE);
if (!(sc->pci_mem)) {
- device_printf(dev, "Unable to allocate bus resource: memory\n");
+ device_printf(dev, "Unable to allocate bus resource: PCI memory\n");
return (ENXIO);
- }
+ }
+
+ /* Save off the PCI information */
+ hw->vendor_id = pci_get_vendor(dev);
+ hw->device_id = pci_get_device(dev);
+ hw->revision_id = pci_read_config(dev, PCIR_REVID, 1);
+ hw->subsystem_vendor_id =
+ pci_read_config(dev, PCIR_SUBVEND_0, 2);
+ hw->subsystem_device_id =
+ pci_read_config(dev, PCIR_SUBDEV_0, 2);
+
+ hw->bus.device = pci_get_slot(dev);
+ hw->bus.func = pci_get_function(dev);
+ /* Save off register access information */
sc->osdep.mem_bus_space_tag =
rman_get_bustag(sc->pci_mem);
sc->osdep.mem_bus_space_handle =
rman_get_bushandle(sc->pci_mem);
sc->osdep.mem_bus_space_size = rman_get_size(sc->pci_mem);
sc->osdep.flush_reg = I40E_VFGEN_RSTAT;
+ sc->osdep.dev = dev;
+
sc->hw.hw_addr = (u8 *) &sc->osdep.mem_bus_space_handle;
sc->hw.back = &sc->osdep;
- ixl_set_busmaster(dev);
- ixl_set_msix_enable(dev);
-
/* Disable adminq interrupts (just in case) */
- ixlv_disable_adminq_irq(&sc->hw);
+ /* TODO: Probably not necessary */
+ // ixlv_disable_adminq_irq(&sc->hw);
- return (0);
-}
-
-/*
- * Free MSI-X related resources for a single queue
- */
+ return (0);
+ }
+
static void
-ixlv_free_msix_resources(struct ixlv_sc *sc, struct ixl_queue *que)
+ixlv_free_pci_resources(struct ixlv_sc *sc)
{
+ struct ixl_vsi *vsi = &sc->vsi;
+ struct ixl_rx_queue *rx_que = vsi->rx_queues;
device_t dev = sc->dev;
+ /* We may get here before stations are setup */
+ // TODO: Check if we can still check against sc->msix
+ if ((sc->msix > 0) || (rx_que == NULL))
+ goto early;
+
/*
- ** Release all msix queue resources:
+ ** Release all msix VSI resources:
*/
- if (que->tag != NULL) {
- bus_teardown_intr(dev, que->res, que->tag);
- que->tag = NULL;
- }
- if (que->res != NULL) {
- int rid = que->msix + 1;
- bus_release_resource(dev, SYS_RES_IRQ, rid, que->res);
- que->res = NULL;
- }
- if (que->tq != NULL) {
- taskqueue_free(que->tq);
- que->tq = NULL;
- }
-}
+ iflib_irq_free(vsi->ctx, &vsi->irq);
-static void
-ixlv_free_pci_resources(struct ixlv_sc *sc)
-{
- device_t dev = sc->dev;
-
- pci_release_msi(dev);
-
- if (sc->msix_mem != NULL)
- bus_release_resource(dev, SYS_RES_MEMORY,
- PCIR_BAR(IXL_MSIX_BAR), sc->msix_mem);
+ for (int i = 0; i < vsi->num_rx_queues; i++, rx_que++)
+ iflib_irq_free(vsi->ctx, &rx_que->que_irq);
+early:
if (sc->pci_mem != NULL)
bus_release_resource(dev, SYS_RES_MEMORY,
PCIR_BAR(0), sc->pci_mem);
}
-/*
- * Create taskqueue and tasklet for Admin Queue interrupts.
- */
-static int
-ixlv_init_taskqueue(struct ixlv_sc *sc)
-{
- int error = 0;
-
- TASK_INIT(&sc->aq_irq, 0, ixlv_do_adminq, sc);
-
- sc->tq = taskqueue_create_fast("ixl_adm", M_NOWAIT,
- taskqueue_thread_enqueue, &sc->tq);
- taskqueue_start_threads(&sc->tq, 1, PI_NET, "%s sc->tq",
- device_get_nameunit(sc->dev));
-
- return (error);
-}
-
-/*********************************************************************
- *
- * Setup MSIX Interrupt resources and handlers for the VSI queues
- *
- **********************************************************************/
-static int
-ixlv_assign_msix(struct ixlv_sc *sc)
-{
- device_t dev = sc->dev;
- struct ixl_vsi *vsi = &sc->vsi;
- struct ixl_queue *que = vsi->queues;
- struct tx_ring *txr;
- int error, rid, vector = 1;
-#ifdef RSS
- cpuset_t cpu_mask;
-#endif
-
- for (int i = 0; i < vsi->num_queues; i++, vector++, que++) {
- int cpu_id = i;
- rid = vector + 1;
- txr = &que->txr;
- que->res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
- RF_SHAREABLE | RF_ACTIVE);
- if (que->res == NULL) {
- device_printf(dev,"Unable to allocate"
- " bus resource: que interrupt [%d]\n", vector);
- return (ENXIO);
- }
- /* Set the handler function */
- error = bus_setup_intr(dev, que->res,
- INTR_TYPE_NET | INTR_MPSAFE, NULL,
- ixlv_msix_que, que, &que->tag);
- if (error) {
- que->tag = NULL;
- device_printf(dev, "Failed to register que handler");
- return (error);
- }
- bus_describe_intr(dev, que->res, que->tag, "que %d", i);
- /* Bind the vector to a CPU */
-#ifdef RSS
- cpu_id = rss_getcpu(i % rss_getnumbuckets());
-#endif
- bus_bind_intr(dev, que->res, cpu_id);
- que->msix = vector;
- TASK_INIT(&que->tx_task, 0, ixl_deferred_mq_start, que);
- TASK_INIT(&que->task, 0, ixlv_handle_que, que);
- que->tq = taskqueue_create_fast("ixlv_que", M_NOWAIT,
- taskqueue_thread_enqueue, &que->tq);
-#ifdef RSS
- CPU_SETOF(cpu_id, &cpu_mask);
- taskqueue_start_threads_cpuset(&que->tq, 1, PI_NET,
- &cpu_mask, "%s (bucket %d)",
- device_get_nameunit(dev), cpu_id);
-#else
- taskqueue_start_threads(&que->tq, 1, PI_NET,
- "%s que", device_get_nameunit(dev));
-#endif
-
- }
-
- return (0);
-}
/*
** Requests a VF reset from the PF.
@@ -1552,76 +1830,31 @@
return (EBUSY);
}
-
-/*********************************************************************
- *
- * Setup networking device structure and register an interface.
- *
- **********************************************************************/
-static int
-ixlv_setup_interface(device_t dev, struct ixlv_sc *sc)
+static void
+ixlv_setup_interface(device_t dev, struct ixl_vsi *vsi)
{
- struct ifnet *ifp;
- struct ixl_vsi *vsi = &sc->vsi;
- struct ixl_queue *que = vsi->queues;
+ if_ctx_t ctx = vsi->ctx;
+ struct ixlv_sc *sc = vsi->back;
+ struct ifnet *ifp = iflib_get_ifp(ctx);
+ uint64_t cap;
+ //struct ixl_queue *que = vsi->queues;
INIT_DBG_DEV(dev, "begin");
- ifp = vsi->ifp = if_alloc(IFT_ETHER);
- if (ifp == NULL) {
- device_printf(dev, "%s: could not allocate ifnet"
- " structure!\n", __func__);
- return (-1);
- }
-
- if_initname(ifp, device_get_name(dev), device_get_unit(dev));
-
- ifp->if_mtu = ETHERMTU;
+ /* initialize fast path functions */
+ cap = IXL_CAPS;
+ if_setifheaderlen(ifp, sizeof(struct ether_vlan_header));
+ if_setcapabilitiesbit(ifp, cap, 0);
+ if_setcapenable(ifp, if_getcapabilities(ifp));
+ /* TODO: Remove VLAN_ENCAP_LEN? */
+ vsi->shared->isc_max_frame_size =
+ ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN
+ + ETHER_VLAN_ENCAP_LEN;
#if __FreeBSD_version >= 1100000
- ifp->if_baudrate = IF_Gbps(40);
+ if_setbaudrate(ifp, IF_Gbps(40));
#else
if_initbaudrate(ifp, IF_Gbps(40));
#endif
- ifp->if_init = ixlv_init;
- ifp->if_softc = vsi;
- ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
- ifp->if_ioctl = ixlv_ioctl;
-
-#if __FreeBSD_version >= 1100000
- if_setgetcounterfn(ifp, ixl_get_counter);
-#endif
-
- ifp->if_transmit = ixl_mq_start;
-
- ifp->if_qflush = ixl_qflush;
- ifp->if_snd.ifq_maxlen = que->num_tx_desc - 2;
-
- ether_ifattach(ifp, sc->hw.mac.addr);
-
- vsi->max_frame_size =
- ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN
- + ETHER_VLAN_ENCAP_LEN;
-
- ifp->if_hw_tsomax = IP_MAXPACKET - (ETHER_HDR_LEN + ETHER_CRC_LEN);
- ifp->if_hw_tsomaxsegcount = IXL_MAX_TSO_SEGS;
- ifp->if_hw_tsomaxsegsize = IXL_MAX_DMA_SEG_SIZE;
-
- /*
- * Tell the upper layer(s) we support long frames.
- */
- ifp->if_hdrlen = sizeof(struct ether_vlan_header);
-
- ifp->if_capabilities |= IFCAP_HWCSUM;
- ifp->if_capabilities |= IFCAP_HWCSUM_IPV6;
- ifp->if_capabilities |= IFCAP_TSO;
- ifp->if_capabilities |= IFCAP_JUMBO_MTU;
-
- ifp->if_capabilities |= IFCAP_VLAN_HWTAGGING
- | IFCAP_VLAN_HWTSO
- | IFCAP_VLAN_MTU
- | IFCAP_VLAN_HWCSUM
- | IFCAP_LRO;
- ifp->if_capenable = ifp->if_capabilities;
/*
** Don't turn this on by default, if vlans are
@@ -1631,14 +1864,7 @@
** using vlans directly on the ixl driver you can
** enable this and get full hardware tag filtering.
*/
- ifp->if_capabilities |= IFCAP_VLAN_HWFILTER;
-
- /*
- * Specify the media types supported by this adapter and register
- * callbacks to update media and link information
- */
- ifmedia_init(&sc->media, IFM_IMASK, ixlv_media_change,
- ixlv_media_status);
+ if_setcapabilitiesbit(ifp, IFCAP_VLAN_HWFILTER, 0);
/* Media types based on reported link speed over AdminQ */
ifmedia_add(&sc->media, IFM_ETHER | IFM_100_TX, 0, NULL);
@@ -1653,6 +1879,7 @@
INIT_DBG_DEV(dev, "end");
return (0);
}
+#if 0
/*
** Allocate and setup a single queue
@@ -1763,6 +1990,7 @@
return (error);
}
+#endif
/*
** Allocate and setup the interface queues
@@ -1813,6 +2041,7 @@
return (error);
}
+#if 0
/*
** This routine is run via an vlan config EVENT,
** it enables us to use the HW Filter table since
@@ -1885,6 +2114,7 @@
mtx_unlock(&sc->mtx);
return;
}
+#endif
/*
** Get a new filter and add it to the mac filter list.
@@ -1923,44 +2153,19 @@
return (f);
}
-static int
-ixlv_teardown_adminq_msix(struct ixlv_sc *sc)
-{
- device_t dev = sc->dev;
- int error = 0;
-
- if (sc->tag != NULL) {
- bus_teardown_intr(dev, sc->res, sc->tag);
- if (error) {
- device_printf(dev, "bus_teardown_intr() for"
- " interrupt 0 failed\n");
- // return (ENXIO);
- }
- sc->tag = NULL;
- }
- if (sc->res != NULL) {
- bus_release_resource(dev, SYS_RES_IRQ, 1, sc->res);
- if (error) {
- device_printf(dev, "bus_release_resource() for"
- " interrupt 0 failed\n");
- // return (ENXIO);
- }
- sc->res = NULL;
- }
-
- return (0);
-
-}
-
/*
** Admin Queue interrupt handler
*/
-static void
+static int
ixlv_msix_adminq(void *arg)
{
struct ixlv_sc *sc = arg;
struct i40e_hw *hw = &sc->hw;
- u32 reg, mask;
+ // device_t dev = sc->dev;
+ u32 reg;
+ bool do_task = FALSE;
+
+ ++sc->admin_irq;
reg = rd32(hw, I40E_VFINT_ICR01);
mask = rd32(hw, I40E_VFINT_ICR0_ENA1);
@@ -1969,34 +2174,40 @@
reg |= I40E_VFINT_DYN_CTL01_CLEARPBA_MASK;
wr32(hw, I40E_VFINT_DYN_CTL01, reg);
- /* schedule task */
- taskqueue_enqueue(sc->tq, &sc->aq_irq);
- return;
+ /* Check on the cause */
+ if (reg & I40E_VFINT_ICR0_ADMINQ_MASK)
+ do_task = TRUE;
+
+ if (do_task)
+ iflib_admin_intr_deferred(sc->vsi.ctx);
+ else
+ ixlv_enable_adminq_irq(hw);
+
+ return (FILTER_HANDLED);
}
void
ixlv_enable_intr(struct ixl_vsi *vsi)
{
struct i40e_hw *hw = vsi->hw;
- struct ixl_queue *que = vsi->queues;
+ struct ixl_rx_queue *que = vsi->rx_queues;
ixlv_enable_adminq_irq(hw);
- for (int i = 0; i < vsi->num_queues; i++, que++)
- ixlv_enable_queue_irq(hw, que->me);
+ for (int i = 0; i < vsi->num_rx_queues; i++, que++)
+ ixlv_enable_queue_irq(hw, que->rxr.me);
}
void
ixlv_disable_intr(struct ixl_vsi *vsi)
{
struct i40e_hw *hw = vsi->hw;
- struct ixl_queue *que = vsi->queues;
+ struct ixl_rx_queue *que = vsi->rx_queues;
ixlv_disable_adminq_irq(hw);
- for (int i = 0; i < vsi->num_queues; i++, que++)
- ixlv_disable_queue_irq(hw, que->me);
+ for (int i = 0; i < vsi->num_rx_queues; i++, que++)
+ ixlv_disable_queue_irq(hw, que->rxr.me);
}
-
static void
ixlv_disable_adminq_irq(struct i40e_hw *hw)
{
@@ -2004,7 +2215,6 @@
wr32(hw, I40E_VFINT_ICR0_ENA1, 0);
/* flush */
rd32(hw, I40E_VFGEN_RSTAT);
- return;
}
static void
@@ -2016,7 +2226,6 @@
wr32(hw, I40E_VFINT_ICR0_ENA1, I40E_VFINT_ICR0_ENA1_ADMINQ_MASK);
/* flush */
rd32(hw, I40E_VFGEN_RSTAT);
- return;
}
static void
@@ -2047,24 +2256,26 @@
{
struct i40e_hw *hw = &sc->hw;
struct ixl_vsi *vsi = &sc->vsi;
- struct ixl_queue *que = vsi->queues;
+ struct ixl_rx_queue *rx_que = vsi->rx_queues;
vsi->rx_itr_setting = ixlv_rx_itr;
- vsi->tx_itr_setting = ixlv_tx_itr;
+ //vsi->tx_itr_setting = ixlv_tx_itr;
- for (int i = 0; i < vsi->num_queues; i++, que++) {
- struct tx_ring *txr = &que->txr;
- struct rx_ring *rxr = &que->rxr;
+ for (int i = 0; i < vsi->num_rx_queues; i++, rx_que++) {
+ struct rx_ring *rxr = &rx_que->rxr;
wr32(hw, I40E_VFINT_ITRN1(IXL_RX_ITR, i),
vsi->rx_itr_setting);
rxr->itr = vsi->rx_itr_setting;
rxr->latency = IXL_AVE_LATENCY;
+#if 0
+ struct tx_ring *txr = &que->txr;
wr32(hw, I40E_VFINT_ITRN1(IXL_TX_ITR, i),
vsi->tx_itr_setting);
txr->itr = vsi->tx_itr_setting;
txr->latency = IXL_AVE_LATENCY;
+#endif
}
}
@@ -2073,7 +2284,7 @@
** interrupt moderation value.
*/
static void
-ixlv_set_queue_rx_itr(struct ixl_queue *que)
+ixlv_set_queue_rx_itr(struct ixl_rx_queue *que)
{
struct ixl_vsi *vsi = que->vsi;
struct i40e_hw *hw = vsi->hw;
@@ -2124,7 +2335,7 @@
((9 * rx_itr) + rxr->itr);
rxr->itr = min(rx_itr, IXL_MAX_ITR);
wr32(hw, I40E_VFINT_ITRN1(IXL_RX_ITR,
- que->me), rxr->itr);
+ que->rxr.me), rxr->itr);
}
} else { /* We may have have toggled to non-dynamic */
if (vsi->rx_itr_setting & IXL_ITR_DYNAMIC)
@@ -2133,7 +2344,7 @@
if (rxr->itr != vsi->rx_itr_setting) {
rxr->itr = vsi->rx_itr_setting;
wr32(hw, I40E_VFINT_ITRN1(IXL_RX_ITR,
- que->me), rxr->itr);
+ que->rxr.me), rxr->itr);
}
}
rxr->bytes = 0;
@@ -2147,7 +2358,7 @@
** interrupt moderation value.
*/
static void
-ixlv_set_queue_tx_itr(struct ixl_queue *que)
+ixlv_set_queue_tx_itr(struct ixl_tx_queue *que)
{
struct ixl_vsi *vsi = que->vsi;
struct i40e_hw *hw = vsi->hw;
@@ -2197,7 +2408,7 @@
((9 * tx_itr) + txr->itr);
txr->itr = min(tx_itr, IXL_MAX_ITR);
wr32(hw, I40E_VFINT_ITRN1(IXL_TX_ITR,
- que->me), txr->itr);
+ que->txr.me), txr->itr);
}
} else { /* We may have have toggled to non-dynamic */
@@ -2207,7 +2418,7 @@
if (txr->itr != vsi->tx_itr_setting) {
txr->itr = vsi->tx_itr_setting;
wr32(hw, I40E_VFINT_ITRN1(IXL_TX_ITR,
- que->me), txr->itr);
+ que->txr.me), txr->itr);
}
}
txr->bytes = 0;
@@ -2215,7 +2426,7 @@
return;
}
-
+#if 0
/*
**
** MSIX Interrupt Handlers and Tasklets
@@ -2248,50 +2459,20 @@
ixlv_enable_queue_irq(hw, que->me);
return;
}
+#endif
-/*********************************************************************
- *
- * MSIX Queue Interrupt Service routine
- *
- **********************************************************************/
-static void
+static int
ixlv_msix_que(void *arg)
{
- struct ixl_queue *que = arg;
- struct ixl_vsi *vsi = que->vsi;
- struct i40e_hw *hw = vsi->hw;
- struct tx_ring *txr = &que->txr;
- bool more_tx, more_rx;
-
- /* Spurious interrupts are ignored */
- if (!(vsi->ifp->if_drv_flags & IFF_DRV_RUNNING))
- return;
+ struct ixl_rx_queue *que = arg;
++que->irqs;
- more_rx = ixl_rxeof(que, IXL_RX_LIMIT);
-
- mtx_lock(&txr->mtx);
- more_tx = ixl_txeof(que);
- /*
- ** Make certain that if the stack
- ** has anything queued the task gets
- ** scheduled to handle it.
- */
- if (!drbr_empty(vsi->ifp, txr->br))
- more_tx = 1;
- mtx_unlock(&txr->mtx);
-
ixlv_set_queue_rx_itr(que);
ixlv_set_queue_tx_itr(que);
- if (more_tx || more_rx)
- taskqueue_enqueue(que->tq, &que->task);
- else
- ixlv_enable_queue_irq(hw, que->me);
-
- return;
+ return (FILTER_SCHEDULE_THREAD);
}
@@ -2386,6 +2567,7 @@
}
+#if 0
/*********************************************************************
* Multicast Initialization
*
@@ -2526,14 +2708,6 @@
IOCTL_DBG_IF(ifp, "end");
}
-/*********************************************************************
- * Timer routine
- *
- * This routine checks for link status,updates statistics,
- * and runs the watchdog check.
- *
- **********************************************************************/
-
static void
ixlv_local_timer(void *arg)
{
@@ -2600,6 +2774,7 @@
return;
}
+#endif
/*********************************************************************
*
@@ -2617,8 +2792,6 @@
ifp = sc->vsi.ifp;
INIT_DBG_IF(ifp, "begin");
- IXLV_CORE_LOCK_ASSERT(sc);
-
ixl_vc_flush(&sc->vc_mgr);
ixlv_disable_queues(sc);
@@ -2633,53 +2806,12 @@
INIT_DBG_IF(ifp, "end");
}
-/* Free a single queue struct */
-static void
-ixlv_free_queue(struct ixlv_sc *sc, struct ixl_queue *que)
-{
- struct tx_ring *txr = &que->txr;
- struct rx_ring *rxr = &que->rxr;
-
- if (!mtx_initialized(&txr->mtx)) /* uninitialized */
- return;
- IXL_TX_LOCK(txr);
- if (txr->br)
- buf_ring_free(txr->br, M_DEVBUF);
- ixl_free_que_tx(que);
- if (txr->base)
- i40e_free_dma_mem(&sc->hw, &txr->dma);
- IXL_TX_UNLOCK(txr);
- IXL_TX_LOCK_DESTROY(txr);
-
- if (!mtx_initialized(&rxr->mtx)) /* uninitialized */
- return;
- IXL_RX_LOCK(rxr);
- ixl_free_que_rx(que);
- if (rxr->base)
- i40e_free_dma_mem(&sc->hw, &rxr->dma);
- IXL_RX_UNLOCK(rxr);
- IXL_RX_LOCK_DESTROY(rxr);
-}
-
-/*********************************************************************
- *
- * Free all station queue structs.
- *
- **********************************************************************/
static void
-ixlv_free_queues(struct ixl_vsi *vsi)
+ixlv_if_stop(if_ctx_t ctx)
{
- struct ixlv_sc *sc = (struct ixlv_sc *)vsi->back;
- struct ixl_queue *que = vsi->queues;
-
- for (int i = 0; i < vsi->num_queues; i++, que++) {
- /* First, free the MSI-X resources */
- ixlv_free_msix_resources(sc, que);
- /* Then free other queue data */
- ixlv_free_queue(sc, que);
- }
+ struct ixl_vsi *vsi = iflib_get_softc(ctx);
- free(vsi->queues, M_DEVBUF);
+ ixlv_stop(sc);
}
static void
@@ -2696,7 +2828,7 @@
#endif
/* Don't set up RSS if using a single queue */
- if (vsi->num_queues == 1) {
+ if (vsi->num_rx_queues == 1) {
wr32(hw, I40E_VFQF_HENA(0), 0);
wr32(hw, I40E_VFQF_HENA(1), 0);
ixl_flush(hw);
@@ -2742,7 +2874,7 @@
/* Populate the LUT with max no. of queues in round robin fashion */
for (i = 0, j = 0; i < IXL_RSS_VSI_LUT_SIZE; i++, j++) {
- if (j == vsi->num_queues)
+ if (j == vsi->num_rx_queues)
j = 0;
#ifdef RSS
/*
@@ -2874,21 +3006,6 @@
return (0);
}
-/*
-** Tasklet handler for MSIX Adminq interrupts
-** - done outside interrupt context since it might sleep
-*/
-static void
-ixlv_do_adminq(void *context, int pending)
-{
- struct ixlv_sc *sc = context;
-
- mtx_lock(&sc->mtx);
- ixlv_do_adminq_locked(sc);
- mtx_unlock(&sc->mtx);
- return;
-}
-
static void
ixlv_do_adminq_locked(struct ixlv_sc *sc)
{
@@ -2901,8 +3018,6 @@
i40e_status ret;
bool aq_error = false;
- IXLV_CORE_LOCK_ASSERT(sc);
-
event.buf_len = IXL_AQ_BUF_SZ;
event.msg_buf = sc->aq_buffer;
v_msg = (struct virtchnl_msg *)&event.desc;
@@ -2961,7 +3076,8 @@
device_printf(dev, "WARNING: Resetting!\n");
sc->init_state = IXLV_RESET_REQUIRED;
ixlv_stop(sc);
- ixlv_init_locked(sc);
+ // TODO: Make stop/init calls match
+ ixlv_if_init(sc->vsi.ctx);
}
ixlv_enable_adminq_irq(hw);
}
@@ -2977,15 +3093,17 @@
struct sysctl_oid *tree = device_get_sysctl_tree(dev);
struct sysctl_oid_list *child = SYSCTL_CHILDREN(tree);
- struct sysctl_oid *vsi_node, *queue_node;
- struct sysctl_oid_list *vsi_list, *queue_list;
+ struct sysctl_oid *vsi_node; // *queue_node;
+ struct sysctl_oid_list *vsi_list; // *queue_list;
#define QUEUE_NAME_LEN 32
- char queue_namebuf[QUEUE_NAME_LEN];
+ //char queue_namebuf[QUEUE_NAME_LEN];
+#if 0
struct ixl_queue *queues = vsi->queues;
- struct tx_ring *txr;
+ struct tX_ring *txr;
struct rx_ring *rxr;
+#endif
/* Driver statistics sysctls */
SYSCTL_ADD_UQUAD(ctx, child, OID_AUTO, "watchdog_events",
@@ -3042,6 +3160,7 @@
entry++;
}
+#if 0
/* Queue sysctls */
for (int q = 0; q < vsi->num_queues; q++) {
snprintf(queue_namebuf, QUEUE_NAME_LEN, "que%d", q);
@@ -3106,6 +3225,7 @@
"Ticks before watchdog event is triggered");
#endif
}
+#endif
}
static void
@@ -3117,7 +3237,6 @@
sc->vlan_filters = malloc(sizeof(struct ixlv_vlan_filter),
M_DEVBUF, M_NOWAIT | M_ZERO);
SLIST_INIT(sc->vlan_filters);
- return;
}
static void
@@ -3138,7 +3257,6 @@
free(v, M_DEVBUF);
}
free(sc->vlan_filters, M_DEVBUF);
- return;
}
static char *
Index: sys/dev/ixl/ixl.h
===================================================================
--- sys/dev/ixl/ixl.h
+++ sys/dev/ixl/ixl.h
@@ -61,6 +61,7 @@
#include <net/ethernet.h>
#include <net/if_dl.h>
#include <net/if_media.h>
+#include <net/iflib.h>
#include <net/bpf.h>
#include <net/if_types.h>
@@ -102,80 +103,13 @@
#include <netinet/in_rss.h>
#endif
+#include "ifdi_if.h"
#include "i40e_type.h"
#include "i40e_prototype.h"
+#include "ixl_debug.h"
-#define MAC_FORMAT "%02x:%02x:%02x:%02x:%02x:%02x"
-#define MAC_FORMAT_ARGS(mac_addr) \
- (mac_addr)[0], (mac_addr)[1], (mac_addr)[2], (mac_addr)[3], \
- (mac_addr)[4], (mac_addr)[5]
-#define ON_OFF_STR(is_set) ((is_set) ? "On" : "Off")
-
-#ifdef IXL_DEBUG
-
-#define _DBG_PRINTF(S, ...) printf("%s: " S "\n", __func__, ##__VA_ARGS__)
-#define _DEV_DBG_PRINTF(dev, S, ...) device_printf(dev, "%s: " S "\n", __func__, ##__VA_ARGS__)
-#define _IF_DBG_PRINTF(ifp, S, ...) if_printf(ifp, "%s: " S "\n", __func__, ##__VA_ARGS__)
-
-/* Defines for printing generic debug information */
-#define DPRINTF(...) _DBG_PRINTF(__VA_ARGS__)
-#define DDPRINTF(...) _DEV_DBG_PRINTF(__VA_ARGS__)
-#define IDPRINTF(...) _IF_DBG_PRINTF(__VA_ARGS__)
-
-/* Defines for printing specific debug information */
-#define DEBUG_INIT 1
-#define DEBUG_IOCTL 1
-#define DEBUG_HW 1
-
-#define INIT_DEBUGOUT(...) if (DEBUG_INIT) _DBG_PRINTF(__VA_ARGS__)
-#define INIT_DBG_DEV(...) if (DEBUG_INIT) _DEV_DBG_PRINTF(__VA_ARGS__)
-#define INIT_DBG_IF(...) if (DEBUG_INIT) _IF_DBG_PRINTF(__VA_ARGS__)
-
-#define IOCTL_DEBUGOUT(...) if (DEBUG_IOCTL) _DBG_PRINTF(__VA_ARGS__)
-#define IOCTL_DBG_IF2(ifp, S, ...) if (DEBUG_IOCTL) \
- if_printf(ifp, S "\n", ##__VA_ARGS__)
-#define IOCTL_DBG_IF(...) if (DEBUG_IOCTL) _IF_DBG_PRINTF(__VA_ARGS__)
-
-#define HW_DEBUGOUT(...) if (DEBUG_HW) _DBG_PRINTF(__VA_ARGS__)
-
-#else /* no IXL_DEBUG */
-#define DEBUG_INIT 0
-#define DEBUG_IOCTL 0
-#define DEBUG_HW 0
-
-#define DPRINTF(...)
-#define DDPRINTF(...)
-#define IDPRINTF(...)
-
-#define INIT_DEBUGOUT(...)
-#define INIT_DBG_DEV(...)
-#define INIT_DBG_IF(...)
-#define IOCTL_DEBUGOUT(...)
-#define IOCTL_DBG_IF2(...)
-#define IOCTL_DBG_IF(...)
-#define HW_DEBUGOUT(...)
-#endif /* IXL_DEBUG */
-
-enum ixl_dbg_mask {
- IXL_DBG_INFO = 0x00000001,
- IXL_DBG_EN_DIS = 0x00000002,
- IXL_DBG_AQ = 0x00000004,
- IXL_DBG_NVMUPD = 0x00000008,
-
- IXL_DBG_IOCTL_KNOWN = 0x00000010,
- IXL_DBG_IOCTL_UNKNOWN = 0x00000020,
- IXL_DBG_IOCTL_ALL = 0x00000030,
-
- I40E_DEBUG_RSS = 0x00000100,
-
- IXL_DBG_IOV = 0x00001000,
- IXL_DBG_IOV_VC = 0x00002000,
-
- IXL_DBG_SWITCH_INFO = 0x00010000,
- IXL_DBG_I2C = 0x00020000,
-
- IXL_DBG_ALL = 0xFFFFFFFF
-};
+#define PVIDV(vendor, devid, name) \
+ PVID(vendor, devid, name " - " IXL_DRIVER_VERSION_STRING)
/* Tunables */
@@ -195,48 +129,27 @@
#define IXL_AQ_LEN 256
#define IXL_AQ_LEN_MAX 1024
-/*
-** Default number of entries in Tx queue buf_ring.
-*/
-#define DEFAULT_TXBRSZ 4096
-
/* Alignment for rings */
#define DBA_ALIGN 128
-/*
- * This is the max watchdog interval, ie. the time that can
- * pass between any two TX clean operations, such only happening
- * when the TX hardware is functioning.
- *
- * XXX: Watchdog currently counts down in units of (hz)
- * Set this to just (hz) if you want queues to hang under a little bit of stress
- */
-#define IXL_WATCHDOG (10 * hz)
-
-/*
- * This parameters control when the driver calls the routine to reclaim
- * transmit descriptors.
- */
-#define IXL_TX_CLEANUP_THRESHOLD (que->num_tx_desc / 8)
-#define IXL_TX_OP_THRESHOLD (que->num_tx_desc / 32)
-
#define MAX_MULTICAST_ADDR 128
#define IXL_MSIX_BAR 3
#define IXL_ADM_LIMIT 2
-#define IXL_TSO_SIZE 65535
+// TODO: Find out which TSO_SIZE to use
+//#define IXL_TSO_SIZE 65535
+#define IXL_TSO_SIZE ((255*1024)-1)
+#define IXL_TX_BUF_SZ ((u32) 1514)
#define IXL_AQ_BUF_SZ ((u32) 4096)
-#define IXL_RX_HDR 128
-#define IXL_RX_LIMIT 512
#define IXL_RX_ITR 0
#define IXL_TX_ITR 1
#define IXL_ITR_NONE 3
#define IXL_QUEUE_EOL 0x7FF
#define IXL_MAX_FRAME 9728
#define IXL_MAX_TX_SEGS 8
+#define IXL_MAX_RX_SEGS 5
#define IXL_MAX_TSO_SEGS 128
#define IXL_SPARSE_CHAIN 7
-#define IXL_QUEUE_HUNG 0x80000000
#define IXL_MIN_TSO_MSS 64
#define IXL_MAX_DMA_SEG_SIZE ((16 * 1024) - 1)
@@ -252,7 +165,6 @@
/* ERJ: hardware can support ~2k (SW5+) filters between all functions */
#define IXL_MAX_FILTERS 256
-#define IXL_MAX_TX_BUSY 10
#define IXL_NVM_VERSION_LO_SHIFT 0
#define IXL_NVM_VERSION_LO_MASK (0xff << IXL_NVM_VERSION_LO_SHIFT)
@@ -288,12 +200,6 @@
#define CSUM_OFFLOAD_IPV6 (CSUM_TCP_IPV6|CSUM_UDP_IPV6|CSUM_SCTP_IPV6)
#define CSUM_OFFLOAD (CSUM_OFFLOAD_IPV4|CSUM_OFFLOAD_IPV6|CSUM_TSO)
-/* Misc flags for ixl_vsi.flags */
-#define IXL_FLAGS_KEEP_TSO4 (1 << 0)
-#define IXL_FLAGS_KEEP_TSO6 (1 << 1)
-#define IXL_FLAGS_USES_MSIX (1 << 2)
-#define IXL_FLAGS_IS_VF (1 << 3)
-
#define IXL_VF_RESET_TIMEOUT 100
#define IXL_VSI_DATA_PORT 0x01
@@ -304,6 +210,7 @@
#define IXL_RX_CTX_BASE_UNITS 128
#define IXL_TX_CTX_BASE_UNITS 128
+#if 0
#define IXL_VPINT_LNKLSTN_REG(hw, vector, vf_num) \
I40E_VPINT_LNKLSTN(((vector) - 1) + \
(((hw)->func_caps.num_msix_vectors_vf - 1) * (vf_num)))
@@ -311,6 +218,7 @@
#define IXL_VFINT_DYN_CTLN_REG(hw, vector, vf_num) \
I40E_VFINT_DYN_CTLN(((vector) - 1) + \
(((hw)->func_caps.num_msix_vectors_vf - 1) * (vf_num)))
+#endif
#define IXL_PF_PCI_CIAA_VF_DEVICE_STATUS 0xAA
@@ -347,15 +255,20 @@
BIT_ULL(I40E_FILTER_PCTYPE_NONF_IPV4_TCP_SYN_NO_ACK) | \
BIT_ULL(I40E_FILTER_PCTYPE_NONF_IPV6_TCP_SYN_NO_ACK))
-#define IXL_TX_LOCK(_sc) mtx_lock(&(_sc)->mtx)
-#define IXL_TX_UNLOCK(_sc) mtx_unlock(&(_sc)->mtx)
-#define IXL_TX_LOCK_DESTROY(_sc) mtx_destroy(&(_sc)->mtx)
-#define IXL_TX_TRYLOCK(_sc) mtx_trylock(&(_sc)->mtx)
-#define IXL_TX_LOCK_ASSERT(_sc) mtx_assert(&(_sc)->mtx, MA_OWNED)
-
-#define IXL_RX_LOCK(_sc) mtx_lock(&(_sc)->mtx)
-#define IXL_RX_UNLOCK(_sc) mtx_unlock(&(_sc)->mtx)
-#define IXL_RX_LOCK_DESTROY(_sc) mtx_destroy(&(_sc)->mtx)
+#define IXL_CAPS \
+ (IFCAP_TSO4 | IFCAP_TSO6 | \
+ IFCAP_TXCSUM | IFCAP_TXCSUM_IPV6 | \
+ IFCAP_RXCSUM | IFCAP_RXCSUM_IPV6 | \
+ IFCAP_VLAN_HWFILTER | IFCAP_VLAN_HWTSO | \
+ IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_HWCSUM | IFCAP_VLAN_HWTSO | \
+ IFCAP_VLAN_MTU | IFCAP_JUMBO_MTU | IFCAP_LRO)
+
+#define IXL_CSUM_TCP \
+ (CSUM_IP_TCP|CSUM_IP_TSO|CSUM_IP6_TSO|CSUM_IP6_TCP)
+#define IXL_CSUM_UDP \
+ (CSUM_IP_UDP|CSUM_IP6_UDP)
+#define IXL_CSUM_SCTP \
+ (CSUM_IP_SCTP|CSUM_IP6_SCTP)
/* Pre-11 counter(9) compatibility */
#if __FreeBSD_version >= 1100036
@@ -386,6 +299,9 @@
#define IXL_SET_NOPROTO(vsi, count) (vsi)->noproto = (count)
#endif
+#define IXL_DEV_ERR(_dev, _format, ...) \
+ device_printf(_dev, "%s: " _format " (%s:%d)\n", __func__, ##__VA_ARGS__, __FILE__, __LINE__)
+
/*
*****************************************************************************
* vendor_info_array
@@ -403,22 +319,6 @@
unsigned int index;
} ixl_vendor_info_t;
-
-struct ixl_tx_buf {
- u32 eop_index;
- struct mbuf *m_head;
- bus_dmamap_t map;
- bus_dma_tag_t tag;
-};
-
-struct ixl_rx_buf {
- struct mbuf *m_head;
- struct mbuf *m_pack;
- struct mbuf *fmp;
- bus_dmamap_t hmap;
- bus_dmamap_t pmap;
-};
-
/*
** This struct has multiple uses, multicast
** addresses, vlans, and mac filters all use it.
@@ -434,34 +334,30 @@
* The Transmit ring control struct
*/
struct tx_ring {
- struct ixl_queue *que;
- struct mtx mtx;
+ struct ixl_tx_queue *que;
u32 tail;
- struct i40e_tx_desc *base;
- struct i40e_dma_mem dma;
- u16 next_avail;
- u16 next_to_clean;
- u16 atr_rate;
- u16 atr_count;
- u32 itr;
+ struct i40e_tx_desc *tx_base;
+ u64 tx_paddr;
u32 latency;
- struct ixl_tx_buf *buffers;
- volatile u16 avail;
- u32 cmd;
- bus_dma_tag_t tx_tag;
- bus_dma_tag_t tso_tag;
- char mtx_name[16];
- struct buf_ring *br;
- s32 watchdog_timer;
+ u32 packets;
+ u32 me;
+ /*
+ * For reporting completed packet status
+ * in descriptor writeback mode
+ */
+ qidx_t *tx_rsq;
+ qidx_t tx_rs_cidx;
+ qidx_t tx_rs_pidx;
+ qidx_t tx_cidx_processed;
/* Used for Dynamic ITR calculation */
- u32 packets;
+ u32 itr;
u32 bytes;
/* Soft Stats */
u64 tx_bytes;
- u64 no_desc;
- u64 total_packets;
+ u64 tx_packets;
+ u64 mss_too_small;
};
@@ -469,68 +365,46 @@
* The Receive ring control struct
*/
struct rx_ring {
- struct ixl_queue *que;
- struct mtx mtx;
- union i40e_rx_desc *base;
- struct i40e_dma_mem dma;
- struct lro_ctrl lro;
- bool lro_enabled;
- bool hdr_split;
+ struct ixl_rx_queue *que;
+ union i40e_rx_desc *rx_base;
+ uint64_t rx_paddr;
bool discard;
- u32 next_refresh;
- u32 next_check;
u32 itr;
u32 latency;
- char mtx_name[16];
- struct ixl_rx_buf *buffers;
u32 mbuf_sz;
u32 tail;
- bus_dma_tag_t htag;
- bus_dma_tag_t ptag;
+ u32 me;
/* Used for Dynamic ITR calculation */
u32 packets;
u32 bytes;
/* Soft stats */
- u64 split;
u64 rx_packets;
u64 rx_bytes;
u64 desc_errs;
- u64 not_done;
};
/*
-** Driver queue struct: this is the interrupt container
-** for the associated tx and rx ring pair.
+** Driver queue structs
*/
-struct ixl_queue {
+struct ixl_tx_queue {
struct ixl_vsi *vsi;
- u32 me;
- u32 msix; /* This queue's MSIX vector */
- u32 eims; /* This queue's EIMS bit */
- struct resource *res;
- void *tag;
- int num_tx_desc; /* both tx and rx */
- int num_rx_desc; /* both tx and rx */
-#ifdef DEV_NETMAP
- int num_desc; /* for compatibility with current netmap code in kernel */
-#endif
struct tx_ring txr;
- struct rx_ring rxr;
- struct task task;
- struct task tx_task;
- struct taskqueue *tq;
-
- /* Queue stats */
+ struct if_irq que_irq;
+ u32 msix;
+ /* Stats */
u64 irqs;
u64 tso;
- u64 mbuf_defrag_failed;
- u64 mbuf_hdr_failed;
- u64 mbuf_pkt_failed;
- u64 tx_dmamap_failed;
- u64 dropped_pkts;
- u64 mss_too_small;
+};
+
+struct ixl_rx_queue {
+ struct ixl_vsi *vsi;
+ struct rx_ring rxr;
+ struct if_irq que_irq;
+ u32 msix; /* This queue's MSIX vector */
+ /* Stats */
+ u64 irqs;
};
/*
@@ -538,29 +412,35 @@
*/
SLIST_HEAD(ixl_ftl_head, ixl_mac_filter);
struct ixl_vsi {
- void *back;
+ if_ctx_t ctx;
+ if_softc_ctx_t shared;
struct ifnet *ifp;
- device_t dev;
+ //device_t dev;
struct i40e_hw *hw;
- struct ifmedia media;
+ struct ifmedia *media;
+#define num_rx_queues shared->isc_nrxqsets
+#define num_tx_queues shared->isc_ntxqsets
+
+ void *back;
enum i40e_vsi_type type;
+ // TODO: Remove?
+ u64 que_mask;
int id;
- u16 num_queues;
- int num_tx_desc;
- int num_rx_desc;
u32 rx_itr_setting;
u32 tx_itr_setting;
- u16 max_frame_size;
bool enable_head_writeback;
- struct ixl_queue *queues; /* head of queues */
-
u16 vsi_num;
bool link_active;
u16 seid;
u16 uplink_seid;
u16 downlink_seid;
+ struct ixl_tx_queue *tx_queues; /* TX queue array */
+ struct ixl_rx_queue *rx_queues; /* RX queue array */
+ struct if_irq irq;
+ u32 link_speed;
+
/* MAC/VLAN Filter list */
struct ixl_ftl_head ftl;
u16 num_macs;
@@ -568,8 +448,6 @@
/* Contains readylist & stat counter id */
struct i40e_aqc_vsi_properties_data info;
- eventhandler_tag vlan_attach;
- eventhandler_tag vlan_detach;
u16 num_vlans;
/* Per-VSI stats from hardware */
@@ -595,37 +473,27 @@
/* Misc. */
u64 flags;
+ /* Stats sysctls for this VSI */
struct sysctl_oid *vsi_node;
};
/*
-** Find the number of unrefreshed RX descriptors
-*/
-static inline u16
-ixl_rx_unrefreshed(struct ixl_queue *que)
-{
- struct rx_ring *rxr = &que->rxr;
-
- if (rxr->next_check > rxr->next_refresh)
- return (rxr->next_check - rxr->next_refresh - 1);
- else
- return ((que->num_rx_desc + rxr->next_check) -
- rxr->next_refresh - 1);
-}
-
-/*
-** Find the next available unused filter
+** Creates new filter with given MAC address and VLAN ID
*/
static inline struct ixl_mac_filter *
-ixl_get_filter(struct ixl_vsi *vsi)
+ixl_new_filter(struct ixl_vsi *vsi, const u8 *macaddr, s16 vlan)
{
struct ixl_mac_filter *f;
/* create a new empty filter */
f = malloc(sizeof(struct ixl_mac_filter),
M_DEVBUF, M_NOWAIT | M_ZERO);
- if (f)
+ if (f) {
SLIST_INSERT_HEAD(&vsi->ftl, f, next);
+ bcopy(macaddr, f->macaddr, ETHER_ADDR_LEN);
+ f->vlan = vlan;
+ f->flags |= (IXL_FILTER_ADD | IXL_FILTER_USED);
+ }
return (f);
}
@@ -636,14 +504,7 @@
static inline bool
cmp_etheraddr(const u8 *ea1, const u8 *ea2)
{
- bool cmp = FALSE;
-
- if ((ea1[0] == ea2[0]) && (ea1[1] == ea2[1]) &&
- (ea1[2] == ea2[2]) && (ea1[3] == ea2[3]) &&
- (ea1[4] == ea2[4]) && (ea1[5] == ea2[5]))
- cmp = TRUE;
-
- return (cmp);
+ return (bcmp(ea1, ea2, 6) == 0);
}
/*
@@ -679,34 +540,11 @@
extern const uint8_t ixl_bcast_addr[ETHER_ADDR_LEN];
-/*********************************************************************
- * TXRX Function prototypes
- *********************************************************************/
-int ixl_allocate_tx_data(struct ixl_queue *);
-int ixl_allocate_rx_data(struct ixl_queue *);
-void ixl_init_tx_ring(struct ixl_queue *);
-int ixl_init_rx_ring(struct ixl_queue *);
-bool ixl_rxeof(struct ixl_queue *, int);
-bool ixl_txeof(struct ixl_queue *);
-void ixl_free_que_tx(struct ixl_queue *);
-void ixl_free_que_rx(struct ixl_queue *);
-
-int ixl_mq_start(struct ifnet *, struct mbuf *);
-int ixl_mq_start_locked(struct ifnet *, struct tx_ring *);
-void ixl_deferred_mq_start(void *, int);
-
-void ixl_vsi_setup_rings_size(struct ixl_vsi *, int, int);
-int ixl_queue_hang_check(struct ixl_vsi *);
-void ixl_free_vsi(struct ixl_vsi *);
-void ixl_qflush(struct ifnet *);
-
/* Common function prototypes between PF/VF driver */
-#if __FreeBSD_version >= 1100000
-uint64_t ixl_get_counter(if_t ifp, ift_counter cnt);
-#endif
-void ixl_get_default_rss_key(u32 *);
+void ixl_init_tx_ring(struct ixl_vsi *vsi, struct ixl_tx_queue *que);
+void ixl_set_queue_rx_itr(struct ixl_rx_queue *que);
+void ixl_get_default_rss_key(u32 *);
const char * i40e_vc_stat_str(struct i40e_hw *hw,
enum virtchnl_status_code stat_err);
-void ixl_set_busmaster(device_t);
-void ixl_set_msix_enable(device_t);
+u64 ixl_max_aq_speed_to_value(u8);
#endif /* _IXL_H_ */
Index: sys/dev/ixl/ixl_debug.h
===================================================================
--- /dev/null
+++ sys/dev/ixl/ixl_debug.h
@@ -0,0 +1,110 @@
+/******************************************************************************
+
+ Copyright (c) 2013-2016, Intel Corporation
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ 3. Neither the name of the Intel Corporation nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.
+
+******************************************************************************/
+/*$FreeBSD$*/
+
+#ifndef _IXL_DEBUG_H_
+#define _IXL_DEBUG_H_
+
+#define MAC_FORMAT "%02x:%02x:%02x:%02x:%02x:%02x"
+#define MAC_FORMAT_ARGS(mac_addr) \
+ (mac_addr)[0], (mac_addr)[1], (mac_addr)[2], (mac_addr)[3], \
+ (mac_addr)[4], (mac_addr)[5]
+#define ON_OFF_STR(is_set) ((is_set) ? "On" : "Off")
+
+#ifdef IXL_DEBUG
+
+#define _DBG_PRINTF(S, ...) printf("%s: " S "\n", __func__, ##__VA_ARGS__)
+#define _DEV_DBG_PRINTF(dev, S, ...) device_printf(dev, "%s: " S "\n", __func__, ##__VA_ARGS__)
+#define _IF_DBG_PRINTF(ifp, S, ...) if_printf(ifp, "%s: " S "\n", __func__, ##__VA_ARGS__)
+
+/* Defines for printing generic debug information */
+#define DPRINTF(...) _DBG_PRINTF(__VA_ARGS__)
+#define DDPRINTF(...) _DEV_DBG_PRINTF(__VA_ARGS__)
+#define IDPRINTF(...) _IF_DBG_PRINTF(__VA_ARGS__)
+
+/* Defines for printing specific debug information */
+#define DEBUG_INIT 1
+#define DEBUG_IOCTL 1
+#define DEBUG_HW 1
+
+#define INIT_DEBUGOUT(...) if (DEBUG_INIT) _DBG_PRINTF(__VA_ARGS__)
+#define INIT_DBG_DEV(...) if (DEBUG_INIT) _DEV_DBG_PRINTF(__VA_ARGS__)
+#define INIT_DBG_IF(...) if (DEBUG_INIT) _IF_DBG_PRINTF(__VA_ARGS__)
+
+#define IOCTL_DEBUGOUT(...) if (DEBUG_IOCTL) _DBG_PRINTF(__VA_ARGS__)
+#define IOCTL_DBG_IF2(ifp, S, ...) if (DEBUG_IOCTL) \
+ if_printf(ifp, S "\n", ##__VA_ARGS__)
+#define IOCTL_DBG_IF(...) if (DEBUG_IOCTL) _IF_DBG_PRINTF(__VA_ARGS__)
+
+#define HW_DEBUGOUT(...) if (DEBUG_HW) _DBG_PRINTF(__VA_ARGS__)
+
+#else /* no IXL_DEBUG */
+#define DEBUG_INIT 0
+#define DEBUG_IOCTL 0
+#define DEBUG_HW 0
+
+#define DPRINTF(...)
+#define DDPRINTF(...)
+#define IDPRINTF(...)
+
+#define INIT_DEBUGOUT(...)
+#define INIT_DBG_DEV(...)
+#define INIT_DBG_IF(...)
+#define IOCTL_DEBUGOUT(...)
+#define IOCTL_DBG_IF2(...)
+#define IOCTL_DBG_IF(...)
+#define HW_DEBUGOUT(...)
+#endif /* IXL_DEBUG */
+
+enum ixl_dbg_mask {
+ IXL_DBG_INFO = 0x00000001,
+ IXL_DBG_EN_DIS = 0x00000002,
+ IXL_DBG_AQ = 0x00000004,
+ IXL_DBG_NVMUPD = 0x00000008,
+
+ IXL_DBG_IOCTL_KNOWN = 0x00000010,
+ IXL_DBG_IOCTL_UNKNOWN = 0x00000020,
+ IXL_DBG_IOCTL_ALL = 0x00000030,
+
+ I40E_DEBUG_RSS = 0x00000100,
+
+ IXL_DBG_IOV = 0x00001000,
+ IXL_DBG_IOV_VC = 0x00002000,
+
+ IXL_DBG_SWITCH_INFO = 0x00010000,
+ IXL_DBG_I2C = 0x00020000,
+
+ IXL_DBG_ALL = 0xFFFFFFFF
+};
+
+#endif /* _IXL_DEBUG_H_ */
Index: sys/dev/ixl/ixl_pf.h
===================================================================
--- sys/dev/ixl/ixl_pf.h
+++ sys/dev/ixl/ixl_pf.h
@@ -45,16 +45,41 @@
#define VF_FLAG_PROMISC_CAP 0x08
#define VF_FLAG_MAC_ANTI_SPOOF 0x10
-#define IXL_PF_STATE_EMPR_RESETTING (1 << 0)
-#define IXL_PF_STATE_FW_LLDP_DISABLED (1 << 1)
+#define IXL_ICR0_CRIT_ERR_MASK \
+ (I40E_PFINT_ICR0_PCI_EXCEPTION_MASK | \
+ I40E_PFINT_ICR0_ECC_ERR_MASK | \
+ I40E_PFINT_ICR0_PE_CRITERR_MASK)
+
+/* VF Interrupts */
+#define IXL_VPINT_LNKLSTN_REG(hw, vector, vf_num) \
+ I40E_VPINT_LNKLSTN(((vector) - 1) + \
+ (((hw)->func_caps.num_msix_vectors_vf - 1) * (vf_num)))
+
+#define IXL_VFINT_DYN_CTLN_REG(hw, vector, vf_num) \
+ I40E_VFINT_DYN_CTLN(((vector) - 1) + \
+ (((hw)->func_caps.num_msix_vectors_vf - 1) * (vf_num)))
+
+/* Used in struct ixl_pf's state field */
+enum ixl_pf_state {
+ IXL_PF_STATE_ADAPTER_RESETTING = (1 << 0),
+ IXL_PF_STATE_MDD_PENDING = (1 << 1),
+ IXL_PF_STATE_PF_RESET_REQ = (1 << 2),
+ IXL_PF_STATE_VF_RESET_REQ = (1 << 3),
+ IXL_PF_STATE_PF_CRIT_ERR = (1 << 4),
+ IXL_PF_STATE_CORE_RESET_REQ = (1 << 5),
+ IXL_PF_STATE_GLOB_RESET_REQ = (1 << 6),
+ IXL_PF_STATE_EMP_RESET_REQ = (1 << 7),
+ IXL_PF_STATE_FW_LLDP_DISABLED = (1 << 8),
+};
struct ixl_vf {
struct ixl_vsi vsi;
- uint32_t vf_flags;
+ u32 vf_flags;
+ u32 num_mdd_events;
- uint8_t mac[ETHER_ADDR_LEN];
- uint16_t vf_num;
- uint32_t version;
+ u8 mac[ETHER_ADDR_LEN];
+ u16 vf_num;
+ u32 version;
struct ixl_pf_qtag qtag;
struct sysctl_ctx_list ctx;
@@ -62,31 +87,24 @@
/* Physical controller structure */
struct ixl_pf {
+ /*
+ * This is first so that iflib_get_softc can return
+ * either the VSI or the PF structures.
+ */
+ struct ixl_vsi vsi;
+
struct i40e_hw hw;
struct i40e_osdep osdep;
device_t dev;
- struct ixl_vsi vsi;
struct resource *pci_mem;
- struct resource *msix_mem;
- /*
- * Interrupt resources: this set is
- * either used for legacy, or for Link
- * when doing MSIX
- */
- void *tag;
- struct resource *res;
-
- struct callout timer;
- int msix;
#ifdef IXL_IW
int iw_msix;
bool iw_enabled;
#endif
int if_flags;
- int state;
- bool init_in_progress;
+ u32 state;
u8 supported_speeds;
struct ixl_pf_qmgr qmgr;
@@ -101,13 +119,6 @@
int tx_itr;
int rx_itr;
- struct mtx pf_mtx;
-
- u32 qbase;
- u32 admvec;
- struct task adminq;
- struct taskqueue *tq;
-
bool link_up;
u32 link_speed;
int advertised_speed;
@@ -124,6 +135,13 @@
struct i40e_hw_port_stats stats_offsets;
bool stat_offsets_loaded;
+ /* I2C access methods */
+ u8 i2c_access_method;
+ s32 (*read_i2c_byte)(struct ixl_pf *pf, u8 byte_offset,
+ u8 dev_addr, u8 *data);
+ s32 (*write_i2c_byte)(struct ixl_pf *pf, u8 byte_offset,
+ u8 dev_addr, u8 data);
+
/* SR-IOV */
struct ixl_vf *vfs;
int num_vfs;
@@ -177,13 +195,38 @@
#define IXL_SYSCTL_HELP_LINK_STATUS \
"\nExecutes a \"Get Link Status\" command on the Admin Queue, and displays" \
-" the response." \
+" the response."
#define IXL_SYSCTL_HELP_FW_LLDP \
"\nFW LLDP engine:\n" \
"\t0 - disable\n" \
"\t1 - enable\n"
+#define IXL_SYSCTL_HELP_READ_I2C \
+"\nRead a byte from I2C bus\n" \
+"Input: 32-bit value\n" \
+"\tbits 0-7: device address (0xA0 or 0xA2)\n" \
+"\tbits 8-15: offset (0-255)\n" \
+"\tbits 16-31: unused\n" \
+"Output: 8-bit value read"
+
+#define IXL_SYSCTL_HELP_WRITE_I2C \
+"\nWrite a byte to the I2C bus\n" \
+"Input: 32-bit value\n" \
+"\tbits 0-7: device address (0xA0 or 0xA2)\n" \
+"\tbits 8-15: offset (0-255)\n" \
+"\tbits 16-23: value to write\n" \
+"\tbits 24-31: unused\n" \
+"Output: 8-bit value written"
+
+#define IXL_SYSCTL_HELP_I2C_METHOD \
+"\nI2C access method that driver will use:\n" \
+"\t0 - best available method\n" \
+"\t1 - bit bang via I2CPARAMS register\n" \
+"\t2 - register read/write via I2CCMD register\n" \
+"\t3 - Use Admin Queue command (best)\n" \
+"Using the Admin Queue is only supported on 710 devices with FW version 1.7 or higher"
+
extern const char * const ixl_fc_string[6];
MALLOC_DECLARE(M_IXL);
@@ -199,13 +242,6 @@
#define i40e_send_vf_nack(pf, vf, op, st) \
ixl_send_vf_nack_msg((pf), (vf), (op), (st), __FILE__, __LINE__)
-#define IXL_PF_LOCK_INIT(_sc, _name) \
- mtx_init(&(_sc)->pf_mtx, _name, "IXL PF Lock", MTX_DEF)
-#define IXL_PF_LOCK(_sc) mtx_lock(&(_sc)->pf_mtx)
-#define IXL_PF_UNLOCK(_sc) mtx_unlock(&(_sc)->pf_mtx)
-#define IXL_PF_LOCK_DESTROY(_sc) mtx_destroy(&(_sc)->pf_mtx)
-#define IXL_PF_LOCK_ASSERT(_sc) mtx_assert(&(_sc)->pf_mtx, MA_OWNED)
-
/* Debug printing */
#define ixl_dbg(p, m, s, ...) ixl_debug_core(p, m, s, ##__VA_ARGS__)
void ixl_debug_core(struct ixl_pf *, enum ixl_dbg_mask, char *, ...);
@@ -216,11 +252,8 @@
/* For netmap(4) compatibility */
#define ixl_disable_intr(vsi) ixl_disable_rings_intr(vsi)
-/*
- * PF-only function declarations
- */
-
-int ixl_setup_interface(device_t, struct ixl_vsi *);
+/* PF-only function declarations */
+int ixl_setup_interface(device_t, struct ixl_pf *);
void ixl_print_nvm_cmd(device_t, struct i40e_nvm_access *);
char * ixl_aq_speed_to_str(enum i40e_aq_link_speed);
@@ -230,9 +263,9 @@
void ixl_local_timer(void *);
void ixl_register_vlan(void *, struct ifnet *, u16);
void ixl_unregister_vlan(void *, struct ifnet *, u16);
-void ixl_intr(void *);
-void ixl_msix_que(void *);
-void ixl_msix_adminq(void *);
+int ixl_intr(void *);
+int ixl_msix_que(void *);
+int ixl_msix_adminq(void *);
void ixl_do_adminq(void *, int);
int ixl_res_alloc_cmp(const void *, const void *);
@@ -264,7 +297,6 @@
int ixl_get_hw_capabilities(struct ixl_pf *);
void ixl_link_up_msg(struct ixl_pf *);
void ixl_update_link_status(struct ixl_pf *);
-int ixl_allocate_pci_resources(struct ixl_pf *);
int ixl_setup_stations(struct ixl_pf *);
int ixl_switch_config(struct ixl_pf *);
void ixl_stop_locked(struct ixl_pf *);
@@ -304,8 +336,8 @@
int ixl_prepare_for_reset(struct ixl_pf *pf, bool is_up);
int ixl_rebuild_hw_structs_after_reset(struct ixl_pf *, bool is_up);
-void ixl_set_queue_rx_itr(struct ixl_queue *);
-void ixl_set_queue_tx_itr(struct ixl_queue *);
+void ixl_set_queue_rx_itr(struct ixl_rx_queue *);
+void ixl_set_queue_tx_itr(struct ixl_tx_queue *);
void ixl_add_filter(struct ixl_vsi *, const u8 *, s16 vlan);
void ixl_del_filter(struct ixl_vsi *, const u8 *, s16 vlan);
@@ -345,19 +377,31 @@
void ixl_update_vsi_stats(struct ixl_vsi *);
void ixl_vsi_reset_stats(struct ixl_vsi *);
-int ixl_vsi_setup_queues(struct ixl_vsi *vsi);
void ixl_vsi_free_queues(struct ixl_vsi *vsi);
+void ixl_if_init(if_ctx_t ctx);
+void ixl_if_stop(if_ctx_t ctx);
+
/*
* I2C Function prototypes
*/
int ixl_find_i2c_interface(struct ixl_pf *);
-s32 ixl_read_i2c_byte(struct ixl_pf *pf, u8 byte_offset,
+s32 ixl_read_i2c_byte_bb(struct ixl_pf *pf, u8 byte_offset,
+ u8 dev_addr, u8 *data);
+s32 ixl_write_i2c_byte_bb(struct ixl_pf *pf, u8 byte_offset,
+ u8 dev_addr, u8 data);
+s32 ixl_read_i2c_byte_reg(struct ixl_pf *pf, u8 byte_offset,
+ u8 dev_addr, u8 *data);
+s32 ixl_write_i2c_byte_reg(struct ixl_pf *pf, u8 byte_offset,
+ u8 dev_addr, u8 data);
+s32 ixl_read_i2c_byte_aq(struct ixl_pf *pf, u8 byte_offset,
u8 dev_addr, u8 *data);
-s32 ixl_write_i2c_byte(struct ixl_pf *pf, u8 byte_offset,
+s32 ixl_write_i2c_byte_aq(struct ixl_pf *pf, u8 byte_offset,
u8 dev_addr, u8 data);
int ixl_get_fw_lldp_status(struct ixl_pf *pf);
int ixl_attach_get_link_status(struct ixl_pf *);
+u64 ixl_max_aq_speed_to_value(u8);
+void ixl_handle_vflr(void *, int);
#endif /* _IXL_PF_H_ */
Index: sys/dev/ixl/ixl_pf_i2c.c
===================================================================
--- sys/dev/ixl/ixl_pf_i2c.c
+++ sys/dev/ixl/ixl_pf_i2c.c
@@ -46,9 +46,9 @@
#define IXL_I2C_CLOCK_STRETCHING_TIMEOUT 500
#define IXL_I2C_REG(_hw) \
- I40E_GLGEN_I2CPARAMS(((struct i40e_osdep *)(_hw)->back)->i2c_intfc_num)
-
+ I40E_GLGEN_I2CPARAMS(_hw->func_caps.mdio_port_num)
+/* I2C bit-banging functions */
static s32 ixl_set_i2c_data(struct ixl_pf *pf, u32 *i2cctl, bool data);
static bool ixl_get_i2c_data(struct ixl_pf *pf, u32 *i2cctl);
static void ixl_raise_i2c_clk(struct ixl_pf *pf, u32 *i2cctl);
@@ -62,6 +62,8 @@
static void ixl_i2c_start(struct ixl_pf *pf);
static void ixl_i2c_stop(struct ixl_pf *pf);
+static s32 ixl_wait_for_i2c_completion(struct i40e_hw *hw, u8 portnum);
+
/**
* ixl_i2c_bus_clear - Clears the I2C bus
* @hw: pointer to hardware structure
@@ -449,10 +451,10 @@
}
/**
- * ixl_read_i2c_byte - Reads 8 bit word over I2C
+ * ixl_read_i2c_byte_bb - Reads 8 bit word over I2C
**/
s32
-ixl_read_i2c_byte(struct ixl_pf *pf, u8 byte_offset,
+ixl_read_i2c_byte_bb(struct ixl_pf *pf, u8 byte_offset,
u8 dev_addr, u8 *data)
{
struct i40e_hw *hw = &pf->hw;
@@ -523,9 +525,9 @@
i40e_msec_delay(100);
retry++;
if (retry < max_retry)
- ixl_dbg(pf, IXL_DBG_I2C, "I2C byte read error - Retrying.\n");
+ ixl_dbg(pf, IXL_DBG_I2C, "I2C byte read error - Retrying\n");
else
- ixl_dbg(pf, IXL_DBG_I2C, "I2C byte read error.\n");
+ ixl_dbg(pf, IXL_DBG_I2C, "I2C byte read error\n");
} while (retry < max_retry);
done:
@@ -538,10 +540,10 @@
}
/**
- * ixl_write_i2c_byte - Writes 8 bit word over I2C
+ * ixl_write_i2c_byte_bb - Writes 8 bit word over I2C
**/
s32
-ixl_write_i2c_byte(struct ixl_pf *pf, u8 byte_offset,
+ixl_write_i2c_byte_bb(struct ixl_pf *pf, u8 byte_offset,
u8 dev_addr, u8 data)
{
struct i40e_hw *hw = &pf->hw;
@@ -589,9 +591,9 @@
i40e_msec_delay(100);
retry++;
if (retry < max_retry)
- ixl_dbg(pf, IXL_DBG_I2C, "I2C byte write error - Retrying.\n");
+ ixl_dbg(pf, IXL_DBG_I2C, "I2C byte write error - Retrying\n");
else
- ixl_dbg(pf, IXL_DBG_I2C, "I2C byte write error.\n");
+ ixl_dbg(pf, IXL_DBG_I2C, "I2C byte write error\n");
} while (retry < max_retry);
write_byte_out:
@@ -603,3 +605,139 @@
return status;
}
+/**
+ * ixl_read_i2c_byte - Reads 8 bit word over I2C using a hardware register
+ **/
+s32
+ixl_read_i2c_byte_reg(struct ixl_pf *pf, u8 byte_offset,
+ u8 dev_addr, u8 *data)
+{
+ struct i40e_hw *hw = &pf->hw;
+ u32 reg = 0;
+ s32 status;
+ *data = 0;
+
+ reg |= (byte_offset << I40E_GLGEN_I2CCMD_REGADD_SHIFT);
+ reg |= (((dev_addr >> 1) & 0x7) << I40E_GLGEN_I2CCMD_PHYADD_SHIFT);
+ reg |= I40E_GLGEN_I2CCMD_OP_MASK;
+ wr32(hw, I40E_GLGEN_I2CCMD(hw->func_caps.mdio_port_num), reg);
+
+ status = ixl_wait_for_i2c_completion(hw, hw->func_caps.mdio_port_num);
+
+ /* Get data from I2C register */
+ reg = rd32(hw, I40E_GLGEN_I2CCMD(hw->func_caps.mdio_port_num));
+
+ /* Retrieve data readed from EEPROM */
+ *data = (u8)(reg & 0xff);
+
+ if (status)
+ ixl_dbg(pf, IXL_DBG_I2C, "I2C byte read error\n");
+ return status;
+}
+
+/**
+ * ixl_write_i2c_byte - Writes 8 bit word over I2C using a hardware register
+ **/
+s32
+ixl_write_i2c_byte_reg(struct ixl_pf *pf, u8 byte_offset,
+ u8 dev_addr, u8 data)
+{
+ struct i40e_hw *hw = &pf->hw;
+ s32 status = I40E_SUCCESS;
+ u32 reg = 0;
+ u8 upperbyte = 0;
+ u16 datai2c = 0;
+
+ status = ixl_read_i2c_byte_reg(pf, byte_offset + 1, dev_addr, &upperbyte);
+ datai2c = ((u16)upperbyte << 8) | (u16)data;
+ reg = rd32(hw, I40E_GLGEN_I2CCMD(hw->func_caps.mdio_port_num));
+
+ /* Form write command */
+ reg &= ~I40E_GLGEN_I2CCMD_PHYADD_MASK;
+ reg |= (((dev_addr >> 1) & 0x7) << I40E_GLGEN_I2CCMD_PHYADD_SHIFT);
+ reg &= ~I40E_GLGEN_I2CCMD_REGADD_MASK;
+ reg |= (byte_offset << I40E_GLGEN_I2CCMD_REGADD_SHIFT);
+ reg &= ~I40E_GLGEN_I2CCMD_DATA_MASK;
+ reg |= (datai2c << I40E_GLGEN_I2CCMD_DATA_SHIFT);
+ reg &= ~I40E_GLGEN_I2CCMD_OP_MASK;
+
+ /* Write command to registers controling I2C - data and address. */
+ wr32(hw, I40E_GLGEN_I2CCMD(hw->func_caps.mdio_port_num), reg);
+
+ status = ixl_wait_for_i2c_completion(hw, hw->func_caps.mdio_port_num);
+
+ if (status)
+ ixl_dbg(pf, IXL_DBG_I2C, "I2C byte write error\n");
+ return status;
+}
+
+/**
+ * ixl_wait_for_i2c_completion
+ **/
+static s32
+ixl_wait_for_i2c_completion(struct i40e_hw *hw, u8 portnum)
+{
+ s32 status = 0;
+ u32 timeout = 100;
+ u32 reg;
+ do {
+ reg = rd32(hw, I40E_GLGEN_I2CCMD(portnum));
+ if ((reg & I40E_GLGEN_I2CCMD_R_MASK) != 0)
+ break;
+ i40e_usec_delay(10);
+ } while (timeout-- > 0);
+
+ if (timeout == 0)
+ return I40E_ERR_TIMEOUT;
+ else
+ return status;
+}
+
+/**
+ * ixl_read_i2c_byte - Reads 8 bit word over I2C using a hardware register
+ **/
+s32
+ixl_read_i2c_byte_aq(struct ixl_pf *pf, u8 byte_offset,
+ u8 dev_addr, u8 *data)
+{
+ struct i40e_hw *hw = &pf->hw;
+ s32 status = I40E_SUCCESS;
+ u32 reg;
+
+ status = i40e_aq_get_phy_register(hw,
+ I40E_AQ_PHY_REG_ACCESS_EXTERNAL_MODULE,
+ dev_addr,
+ byte_offset,
+ &reg, NULL);
+
+ if (status)
+ ixl_dbg(pf, IXL_DBG_I2C, "I2C byte read status %s, error %s\n",
+ i40e_stat_str(hw, status), i40e_aq_str(hw, hw->aq.asq_last_status));
+ else
+ *data = (u8)reg;
+
+ return status;
+}
+
+/**
+ * ixl_write_i2c_byte - Writes 8 bit word over I2C using a hardware register
+ **/
+s32
+ixl_write_i2c_byte_aq(struct ixl_pf *pf, u8 byte_offset,
+ u8 dev_addr, u8 data)
+{
+ struct i40e_hw *hw = &pf->hw;
+ s32 status = I40E_SUCCESS;
+
+ status = i40e_aq_set_phy_register(hw,
+ I40E_AQ_PHY_REG_ACCESS_EXTERNAL_MODULE,
+ dev_addr,
+ byte_offset,
+ data, NULL);
+
+ if (status)
+ ixl_dbg(pf, IXL_DBG_I2C, "I2C byte write status %s, error %s\n",
+ i40e_stat_str(hw, status), i40e_aq_str(hw, hw->aq.asq_last_status));
+
+ return status;
+}
Index: sys/dev/ixl/ixl_pf_iov.c
===================================================================
--- sys/dev/ixl/ixl_pf_iov.c
+++ sys/dev/ixl/ixl_pf_iov.c
@@ -83,15 +83,13 @@
void
ixl_initialize_sriov(struct ixl_pf *pf)
{
+ return;
+#if 0
device_t dev = pf->dev;
struct i40e_hw *hw = &pf->hw;
nvlist_t *pf_schema, *vf_schema;
int iov_error;
- /* SR-IOV is only supported when MSI-X is in use. */
- if (pf->msix <= 1)
- return;
-
pf_schema = pci_iov_schema_alloc_node();
vf_schema = pci_iov_schema_alloc_node();
pci_iov_schema_add_unicast_mac(vf_schema, "mac-addr", 0, NULL);
@@ -114,8 +112,10 @@
device_printf(dev, "SR-IOV ready\n");
pf->vc_debug_lvl = 1;
+#endif
}
+
/*
* Allocate the VSI for a VF.
*/
@@ -165,15 +165,17 @@
vsi_ctx.info.tc_mapping[0] = htole16(
(0 << I40E_AQ_VSI_TC_QUE_OFFSET_SHIFT) |
- (bsrl(vf->qtag.num_allocated) << I40E_AQ_VSI_TC_QUE_NUMBER_SHIFT));
+ ((fls(vf->qtag.num_allocated) - 1) << I40E_AQ_VSI_TC_QUE_NUMBER_SHIFT));
code = i40e_aq_add_vsi(hw, &vsi_ctx, NULL);
if (code != I40E_SUCCESS)
return (ixl_adminq_err_to_errno(hw->aq.asq_last_status));
vf->vsi.seid = vsi_ctx.seid;
vf->vsi.vsi_num = vsi_ctx.vsi_number;
- // vf->vsi.first_queue = vf->qtag.qidx[0];
- vf->vsi.num_queues = vf->qtag.num_active;
+ // TODO: How to deal with num tx queues / num rx queues split?
+ // I don't think just assigning this variable is going to work
+ vf->vsi.num_rx_queues = vf->qtag.num_active;
+ vf->vsi.num_tx_queues = vf->qtag.num_active;
code = i40e_aq_get_vsi_params(hw, &vsi_ctx, NULL);
if (code != I40E_SUCCESS)
@@ -204,7 +206,7 @@
vf->vsi.hw_filters_add = 0;
vf->vsi.hw_filters_del = 0;
- ixl_add_filter(&vf->vsi, ixl_bcast_addr, IXL_VLAN_ANY);
+ // ixl_add_filter(&vf->vsi, ixl_bcast_addr, IXL_VLAN_ANY);
ixl_reconfigure_filters(&vf->vsi);
return (0);
@@ -253,7 +255,7 @@
/* Program index of each VF queue into PF queue space
* (This is only needed if QTABLE is enabled) */
- for (i = 0; i < vf->vsi.num_queues; i++) {
+ for (i = 0; i < vf->vsi.num_tx_queues; i++) {
qtable = ixl_pf_qidx_from_vsi_qidx(&vf->qtag, i) <<
I40E_VPLAN_QTABLE_QINDEX_SHIFT;
@@ -266,7 +268,7 @@
/* Map queues allocated to VF to its VSI;
* This mapping matches the VF-wide mapping since the VF
* is only given a single VSI */
- for (i = 0; i < vf->vsi.num_queues; i++)
+ for (i = 0; i < vf->vsi.num_tx_queues; i++)
ixl_vf_map_vsi_queue(hw, vf, i,
ixl_pf_qidx_from_vsi_qidx(&vf->qtag, i));
@@ -335,7 +337,8 @@
ixl_vf_unregister_intr(hw, vpint_reg);
}
- vf->vsi.num_queues = 0;
+ vf->vsi.num_tx_queues = 0;
+ vf->vsi.num_rx_queues = 0;
}
static int
@@ -533,13 +536,13 @@
VIRTCHNL_VF_OFFLOAD_VLAN);
reply.num_vsis = 1;
- reply.num_queue_pairs = vf->vsi.num_queues;
+ reply.num_queue_pairs = vf->vsi.num_tx_queues;
reply.max_vectors = pf->hw.func_caps.num_msix_vectors_vf;
reply.rss_key_size = 52;
reply.rss_lut_size = 64;
reply.vsi_res[0].vsi_id = vf->vsi.vsi_num;
reply.vsi_res[0].vsi_type = VIRTCHNL_VSI_SRIOV;
- reply.vsi_res[0].num_queue_pairs = vf->vsi.num_queues;
+ reply.vsi_res[0].num_queue_pairs = vf->vsi.num_tx_queues;
memcpy(reply.vsi_res[0].default_mac_addr, vf->mac, ETHER_ADDR_LEN);
ixl_send_vf_msg(pf, vf, VIRTCHNL_OP_GET_VF_RESOURCES,
@@ -674,9 +677,9 @@
}
info = msg;
- if (info->num_queue_pairs == 0 || info->num_queue_pairs > vf->vsi.num_queues) {
+ if (info->num_queue_pairs == 0 || info->num_queue_pairs > vf->vsi.num_tx_queues) {
device_printf(pf->dev, "VF %d: invalid # of qpairs (msg has %d, VSI has %d)\n",
- vf->vf_num, info->num_queue_pairs, vf->vsi.num_queues);
+ vf->vf_num, info->num_queue_pairs, vf->vsi.num_tx_queues);
i40e_send_vf_nack(pf, vf, VIRTCHNL_OP_CONFIG_VSI_QUEUES,
I40E_ERR_PARAM);
return;
@@ -705,7 +708,7 @@
if (pair->txq.vsi_id != vf->vsi.vsi_num ||
pair->rxq.vsi_id != vf->vsi.vsi_num ||
pair->txq.queue_id != pair->rxq.queue_id ||
- pair->txq.queue_id >= vf->vsi.num_queues) {
+ pair->txq.queue_id >= vf->vsi.num_tx_queues) {
i40e_send_vf_nack(pf, vf,
VIRTCHNL_OP_CONFIG_VSI_QUEUES, I40E_ERR_PARAM);
@@ -854,7 +857,7 @@
if (vector->rxq_map != 0) {
largest_rxq = fls(vector->rxq_map) - 1;
- if (largest_rxq >= vf->vsi.num_queues) {
+ if (largest_rxq >= vf->vsi.num_rx_queues) {
i40e_send_vf_nack(pf, vf,
VIRTCHNL_OP_CONFIG_IRQ_MAP,
I40E_ERR_PARAM);
@@ -864,7 +867,7 @@
if (vector->txq_map != 0) {
largest_txq = fls(vector->txq_map) - 1;
- if (largest_txq >= vf->vsi.num_queues) {
+ if (largest_txq >= vf->vsi.num_tx_queues) {
i40e_send_vf_nack(pf, vf,
VIRTCHNL_OP_CONFIG_IRQ_MAP,
I40E_ERR_PARAM);
@@ -911,7 +914,7 @@
for (int i = 0; i < 32; i++) {
if ((1 << i) & select->tx_queues) {
/* Warn if queue is out of VF allocation range */
- if (i >= vf->vsi.num_queues) {
+ if (i >= vf->vsi.num_tx_queues) {
device_printf(pf->dev, "VF %d: TX ring %d is outside of VF VSI allocation!\n",
vf->vf_num, i);
break;
@@ -936,7 +939,7 @@
for (int i = 0; i < 32; i++) {
if ((1 << i) & select->rx_queues) {
/* Warn if queue is out of VF allocation range */
- if (i >= vf->vsi.num_queues) {
+ if (i >= vf->vsi.num_rx_queues) {
device_printf(pf->dev, "VF %d: RX ring %d is outside of VF VSI allocation!\n",
vf->vf_num, i);
break;
@@ -990,7 +993,7 @@
for (int i = 0; i < 32; i++) {
if ((1 << i) & select->tx_queues) {
/* Warn if queue is out of VF allocation range */
- if (i >= vf->vsi.num_queues) {
+ if (i >= vf->vsi.num_tx_queues) {
device_printf(pf->dev, "VF %d: TX ring %d is outside of VF VSI allocation!\n",
vf->vf_num, i);
break;
@@ -1016,7 +1019,7 @@
for (int i = 0; i < 32; i++) {
if ((1 << i) & select->rx_queues) {
/* Warn if queue is out of VF allocation range */
- if (i >= vf->vsi.num_queues) {
+ if (i >= vf->vsi.num_rx_queues) {
device_printf(pf->dev, "VF %d: RX ring %d is outside of VF VSI allocation!\n",
vf->vf_num, i);
break;
@@ -1058,6 +1061,8 @@
static bool
ixl_bcast_mac(const uint8_t *addr)
{
+ static uint8_t ixl_bcast_addr[ETHER_ADDR_LEN] =
+ {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
return (cmp_etheraddr(addr, ixl_bcast_addr));
}
@@ -1634,7 +1639,7 @@
pf = arg;
hw = &pf->hw;
- IXL_PF_LOCK(pf);
+ /* TODO: May need to lock this */
for (i = 0; i < pf->num_vfs; i++) {
global_vf_num = hw->func_caps.vf_base_id + i;
@@ -1653,12 +1658,13 @@
}
}
+ atomic_clear_32(&pf->state, IXL_PF_STATE_VF_RESET_REQ);
icr0 = rd32(hw, I40E_PFINT_ICR0_ENA);
icr0 |= I40E_PFINT_ICR0_ENA_VFLR_MASK;
wr32(hw, I40E_PFINT_ICR0_ENA, icr0);
ixl_flush(hw);
- IXL_PF_UNLOCK(pf);
+ // IXL_PF_UNLOCK()
}
static int
@@ -1728,7 +1734,7 @@
hw = &pf->hw;
pf_vsi = &pf->vsi;
- IXL_PF_LOCK(pf);
+ //IXL_PF_LOCK(pf);
pf->vfs = malloc(sizeof(struct ixl_vf) * num_vfs, M_IXL, M_NOWAIT |
M_ZERO);
@@ -1750,13 +1756,13 @@
}
pf->num_vfs = num_vfs;
- IXL_PF_UNLOCK(pf);
+ //IXL_PF_UNLOCK(pf);
return (0);
fail:
free(pf->vfs, M_IXL);
pf->vfs = NULL;
- IXL_PF_UNLOCK(pf);
+ //IXL_PF_UNLOCK(pf);
return (error);
}
@@ -1775,7 +1781,7 @@
vsi = &pf->vsi;
ifp = vsi->ifp;
- IXL_PF_LOCK(pf);
+ //IXL_PF_LOCK(pf);
for (i = 0; i < pf->num_vfs; i++) {
if (pf->vfs[i].vsi.seid != 0)
i40e_aq_delete_element(hw, pf->vfs[i].vsi.seid, NULL);
@@ -1796,7 +1802,7 @@
pf->vfs = NULL;
pf->num_vfs = 0;
- IXL_PF_UNLOCK(pf);
+ //IXL_PF_UNLOCK(pf);
/* Do this after the unlock as sysctl_ctx_free might sleep. */
for (i = 0; i < num_vfs; i++)
@@ -1849,7 +1855,7 @@
pf = device_get_softc(dev);
vf = &pf->vfs[vfnum];
- IXL_PF_LOCK(pf);
+ //IXL_PF_LOCK(pf);
vf->vf_num = vfnum;
vf->vsi.back = pf;
@@ -1889,7 +1895,7 @@
ixl_reset_vf(pf, vf);
out:
- IXL_PF_UNLOCK(pf);
+ //IXL_PF_UNLOCK(pf);
if (error == 0) {
snprintf(sysctl_name, sizeof(sysctl_name), "vf%d", vfnum);
ixl_add_vsi_sysctls(pf, &vf->vsi, &vf->ctx, sysctl_name);
Index: sys/dev/ixl/ixl_pf_main.c
===================================================================
--- sys/dev/ixl/ixl_pf_main.c
+++ sys/dev/ixl/ixl_pf_main.c
@@ -44,14 +44,6 @@
#include "ixl_iw_int.h"
#endif
-#ifdef DEV_NETMAP
-#include <net/netmap.h>
-#include <sys/selinfo.h>
-#include <dev/netmap/netmap_kern.h>
-#endif /* DEV_NETMAP */
-
-static int ixl_vsi_setup_queue(struct ixl_vsi *, struct ixl_queue *, int);
-static u64 ixl_max_aq_speed_to_value(u8);
static u8 ixl_convert_sysctl_aq_link_speed(u8, bool);
static void ixl_sbuf_print_bytes(struct sbuf *, u8 *, int, int, bool);
@@ -84,6 +76,12 @@
static int ixl_sysctl_fec_auto_enable(SYSCTL_HANDLER_ARGS);
static int ixl_sysctl_dump_debug_data(SYSCTL_HANDLER_ARGS);
static int ixl_sysctl_fw_lldp(SYSCTL_HANDLER_ARGS);
+static int ixl_sysctl_do_pf_reset(SYSCTL_HANDLER_ARGS);
+static int ixl_sysctl_do_core_reset(SYSCTL_HANDLER_ARGS);
+static int ixl_sysctl_do_global_reset(SYSCTL_HANDLER_ARGS);
+static int ixl_sysctl_do_emp_reset(SYSCTL_HANDLER_ARGS);
+static int ixl_sysctl_queue_interrupt_table(SYSCTL_HANDLER_ARGS);
+static int ixl_sysctl_read_i2c_diag_data(SYSCTL_HANDLER_ARGS);
#ifdef IXL_DEBUG
static int ixl_sysctl_qtx_tail_handler(SYSCTL_HANDLER_ARGS);
static int ixl_sysctl_qrx_tail_handler(SYSCTL_HANDLER_ARGS);
@@ -170,11 +168,11 @@
{
struct i40e_hw *hw = &pf->hw;
struct ixl_vsi *vsi = &pf->vsi;
- struct ixl_queue *que = vsi->queues;
+ struct ixl_tx_queue *que = vsi->tx_queues;
vsi->tx_itr_setting = pf->tx_itr;
- for (int i = 0; i < vsi->num_queues; i++, que++) {
+ for (int i = 0; i < vsi->num_tx_queues; i++, que++) {
struct tx_ring *txr = &que->txr;
wr32(hw, I40E_PFINT_ITRN(IXL_TX_ITR, i),
@@ -189,11 +187,11 @@
{
struct i40e_hw *hw = &pf->hw;
struct ixl_vsi *vsi = &pf->vsi;
- struct ixl_queue *que = vsi->queues;
+ struct ixl_rx_queue *que = vsi->rx_queues;
vsi->rx_itr_setting = pf->rx_itr;
- for (int i = 0; i < vsi->num_queues; i++, que++) {
+ for (int i = 0; i < vsi->num_rx_queues; i++, que++) {
struct rx_ring *rxr = &que->rxr;
wr32(hw, I40E_PFINT_ITRN(IXL_RX_ITR, i),
@@ -213,136 +211,6 @@
ixl_configure_rx_itr(pf);
}
-
-/*********************************************************************
- * Init entry point
- *
- * This routine is used in two ways. It is used by the stack as
- * init entry point in network interface structure. It is also used
- * by the driver as a hw/sw initialization routine to get to a
- * consistent state.
- *
- * return 0 on success, positive on failure
- **********************************************************************/
-void
-ixl_init_locked(struct ixl_pf *pf)
-{
- struct i40e_hw *hw = &pf->hw;
- struct ixl_vsi *vsi = &pf->vsi;
- struct ifnet *ifp = vsi->ifp;
- device_t dev = pf->dev;
- struct i40e_filter_control_settings filter;
- u8 tmpaddr[ETHER_ADDR_LEN];
- int ret;
-
- INIT_DEBUGOUT("ixl_init_locked: begin");
- IXL_PF_LOCK_ASSERT(pf);
-
- ixl_stop_locked(pf);
-
- /*
- * If the aq is dead here, it probably means something outside of the driver
- * did something to the adapter, like a PF reset.
- * So rebuild the driver's state here if that occurs.
- */
- if (!i40e_check_asq_alive(&pf->hw)) {
- device_printf(dev, "Admin Queue is down; resetting...\n");
- ixl_teardown_hw_structs(pf);
- ixl_reset(pf);
- }
-
- /* Get the latest mac address... User might use a LAA */
- bcopy(IF_LLADDR(vsi->ifp), tmpaddr,
- ETH_ALEN);
- if (!cmp_etheraddr(hw->mac.addr, tmpaddr) &&
- (i40e_validate_mac_addr(tmpaddr) == I40E_SUCCESS)) {
- device_printf(dev, "ixl_init_locked: reconfigure MAC addr\n");
- ixl_del_filter(vsi, hw->mac.addr, IXL_VLAN_ANY);
- bcopy(tmpaddr, hw->mac.addr,
- ETH_ALEN);
- ret = i40e_aq_mac_address_write(hw,
- I40E_AQC_WRITE_TYPE_LAA_ONLY,
- hw->mac.addr, NULL);
- if (ret) {
- device_printf(dev, "LLA address"
- "change failed!!\n");
- return;
- }
- }
-
- ixl_add_filter(vsi, hw->mac.addr, IXL_VLAN_ANY);
-
- /* Set the various hardware offload abilities */
- ifp->if_hwassist = 0;
- if (ifp->if_capenable & IFCAP_TSO)
- ifp->if_hwassist |= CSUM_TSO;
- if (ifp->if_capenable & IFCAP_TXCSUM)
- ifp->if_hwassist |= (CSUM_TCP | CSUM_UDP);
- if (ifp->if_capenable & IFCAP_TXCSUM_IPV6)
- ifp->if_hwassist |= (CSUM_TCP_IPV6 | CSUM_UDP_IPV6);
-
- /* Set up the device filtering */
- bzero(&filter, sizeof(filter));
- filter.enable_ethtype = TRUE;
- filter.enable_macvlan = TRUE;
- filter.enable_fdir = FALSE;
- filter.hash_lut_size = I40E_HASH_LUT_SIZE_512;
- if (i40e_set_filter_control(hw, &filter))
- device_printf(dev, "i40e_set_filter_control() failed\n");
-
- /* Prepare the VSI: rings, hmc contexts, etc... */
- if (ixl_initialize_vsi(vsi)) {
- device_printf(dev, "initialize vsi failed!!\n");
- return;
- }
-
- /* Set up RSS */
- ixl_config_rss(pf);
-
- /* Add protocol filters to list */
- ixl_init_filters(vsi);
-
- /* Setup vlan's if needed */
- ixl_setup_vlan_filters(vsi);
-
- /* Set up MSI/X routing and the ITR settings */
- if (pf->msix > 1) {
- ixl_configure_queue_intr_msix(pf);
- ixl_configure_itr(pf);
- } else
- ixl_configure_legacy(pf);
-
- ixl_enable_rings(vsi);
-
- i40e_aq_set_default_vsi(hw, vsi->seid, NULL);
-
- ixl_reconfigure_filters(vsi);
-
- /* And now turn on interrupts */
- ixl_enable_intr(vsi);
-
- /* Get link info */
- hw->phy.get_link_info = TRUE;
- i40e_get_link_status(hw, &pf->link_up);
- ixl_update_link_status(pf);
-
- /* Start the local timer */
- callout_reset(&pf->timer, hz, ixl_local_timer, pf);
-
- /* Now inform the stack we're ready */
- ifp->if_drv_flags |= IFF_DRV_RUNNING;
-
-#ifdef IXL_IW
- if (ixl_enable_iwarp && pf->iw_enabled) {
- ret = ixl_iw_pf_init(pf);
- if (ret)
- device_printf(dev,
- "initialize iwarp failed, code %d\n", ret);
- }
-#endif
-}
-
-
/*********************************************************************
*
* Get the hardware capabilities
@@ -355,9 +223,10 @@
struct i40e_aqc_list_capabilities_element_resp *buf;
struct i40e_hw *hw = &pf->hw;
device_t dev = pf->dev;
- int error, len;
- u16 needed;
- bool again = TRUE;
+ enum i40e_status_code status;
+ int len, i2c_intfc_num;
+ bool again = TRUE;
+ u16 needed;
len = 40 * sizeof(struct i40e_aqc_list_capabilities_element_resp);
retry:
@@ -368,7 +237,7 @@
}
/* This populates the hw struct */
- error = i40e_aq_discover_capabilities(hw, buf, len,
+ status = i40e_aq_discover_capabilities(hw, buf, len,
&needed, i40e_aqc_opc_list_func_capabilities, NULL);
free(buf, M_DEVBUF);
if ((pf->hw.aq.asq_last_status == I40E_AQ_RC_ENOMEM) &&
@@ -377,32 +246,52 @@
again = FALSE;
len = needed;
goto retry;
- } else if (pf->hw.aq.asq_last_status != I40E_AQ_RC_OK) {
- device_printf(dev, "capability discovery failed: %d\n",
- pf->hw.aq.asq_last_status);
+ } else if (status != I40E_SUCCESS) {
+ device_printf(dev, "capability discovery failed; status %s, error %s\n",
+ i40e_stat_str(hw, status), i40e_aq_str(hw, hw->aq.asq_last_status));
return (ENODEV);
}
- /* Capture this PF's starting queue pair */
- pf->qbase = hw->func_caps.base_queue;
-
-#ifdef IXL_DEBUG
- device_printf(dev, "pf_id=%d, num_vfs=%d, msix_pf=%d, "
- "msix_vf=%d, fd_g=%d, fd_b=%d, tx_qp=%d rx_qp=%d qbase=%d\n",
- hw->pf_id, hw->func_caps.num_vfs,
- hw->func_caps.num_msix_vectors,
- hw->func_caps.num_msix_vectors_vf,
- hw->func_caps.fd_filters_guaranteed,
- hw->func_caps.fd_filters_best_effort,
- hw->func_caps.num_tx_qp,
- hw->func_caps.num_rx_qp,
- hw->func_caps.base_queue);
-#endif
- struct i40e_osdep *osdep = (struct i40e_osdep *)hw->back;
- osdep->i2c_intfc_num = ixl_find_i2c_interface(pf);
- if (osdep->i2c_intfc_num != -1)
+ /*
+ * Some devices have both MDIO and I2C; since this isn't reported
+ * by the FW, check registers to see if an I2C interface exists.
+ */
+ i2c_intfc_num = ixl_find_i2c_interface(pf);
+ if (i2c_intfc_num != -1)
pf->has_i2c = true;
+ /* Determine functions to use for driver I2C accesses */
+ switch (pf->i2c_access_method) {
+ case 0: {
+ if (hw->mac.type == I40E_MAC_XL710 &&
+ hw->aq.api_maj_ver == 1 &&
+ hw->aq.api_min_ver >= 7) {
+ pf->read_i2c_byte = ixl_read_i2c_byte_aq;
+ pf->write_i2c_byte = ixl_write_i2c_byte_aq;
+ } else {
+ pf->read_i2c_byte = ixl_read_i2c_byte_reg;
+ pf->write_i2c_byte = ixl_write_i2c_byte_reg;
+ }
+ break;
+ }
+ case 3:
+ pf->read_i2c_byte = ixl_read_i2c_byte_aq;
+ pf->write_i2c_byte = ixl_write_i2c_byte_aq;
+ break;
+ case 2:
+ pf->read_i2c_byte = ixl_read_i2c_byte_reg;
+ pf->write_i2c_byte = ixl_write_i2c_byte_reg;
+ break;
+ case 1:
+ pf->read_i2c_byte = ixl_read_i2c_byte_bb;
+ pf->write_i2c_byte = ixl_write_i2c_byte_bb;
+ break;
+ default:
+ /* Should not happen */
+ device_printf(dev, "Error setting I2C access functions\n");
+ break;
+ }
+
/* Print a subset of the capability information. */
device_printf(dev, "PF-ID[%d]: VFs %d, MSIX %d, VF MSIX %d, QPs %d, %s\n",
hw->pf_id, hw->func_caps.num_vfs, hw->func_caps.num_msix_vectors,
@@ -412,79 +301,7 @@
(hw->func_caps.mdio_port_mode == 1) ? "MDIO dedicated" :
"MDIO shared");
- return (error);
-}
-
-void
-ixl_cap_txcsum_tso(struct ixl_vsi *vsi, struct ifnet *ifp, int mask)
-{
- device_t dev = vsi->dev;
-
- /* Enable/disable TXCSUM/TSO4 */
- if (!(ifp->if_capenable & IFCAP_TXCSUM)
- && !(ifp->if_capenable & IFCAP_TSO4)) {
- if (mask & IFCAP_TXCSUM) {
- ifp->if_capenable |= IFCAP_TXCSUM;
- /* enable TXCSUM, restore TSO if previously enabled */
- if (vsi->flags & IXL_FLAGS_KEEP_TSO4) {
- vsi->flags &= ~IXL_FLAGS_KEEP_TSO4;
- ifp->if_capenable |= IFCAP_TSO4;
- }
- }
- else if (mask & IFCAP_TSO4) {
- ifp->if_capenable |= (IFCAP_TXCSUM | IFCAP_TSO4);
- vsi->flags &= ~IXL_FLAGS_KEEP_TSO4;
- device_printf(dev,
- "TSO4 requires txcsum, enabling both...\n");
- }
- } else if((ifp->if_capenable & IFCAP_TXCSUM)
- && !(ifp->if_capenable & IFCAP_TSO4)) {
- if (mask & IFCAP_TXCSUM)
- ifp->if_capenable &= ~IFCAP_TXCSUM;
- else if (mask & IFCAP_TSO4)
- ifp->if_capenable |= IFCAP_TSO4;
- } else if((ifp->if_capenable & IFCAP_TXCSUM)
- && (ifp->if_capenable & IFCAP_TSO4)) {
- if (mask & IFCAP_TXCSUM) {
- vsi->flags |= IXL_FLAGS_KEEP_TSO4;
- ifp->if_capenable &= ~(IFCAP_TXCSUM | IFCAP_TSO4);
- device_printf(dev,
- "TSO4 requires txcsum, disabling both...\n");
- } else if (mask & IFCAP_TSO4)
- ifp->if_capenable &= ~IFCAP_TSO4;
- }
-
- /* Enable/disable TXCSUM_IPV6/TSO6 */
- if (!(ifp->if_capenable & IFCAP_TXCSUM_IPV6)
- && !(ifp->if_capenable & IFCAP_TSO6)) {
- if (mask & IFCAP_TXCSUM_IPV6) {
- ifp->if_capenable |= IFCAP_TXCSUM_IPV6;
- if (vsi->flags & IXL_FLAGS_KEEP_TSO6) {
- vsi->flags &= ~IXL_FLAGS_KEEP_TSO6;
- ifp->if_capenable |= IFCAP_TSO6;
- }
- } else if (mask & IFCAP_TSO6) {
- ifp->if_capenable |= (IFCAP_TXCSUM_IPV6 | IFCAP_TSO6);
- vsi->flags &= ~IXL_FLAGS_KEEP_TSO6;
- device_printf(dev,
- "TSO6 requires txcsum6, enabling both...\n");
- }
- } else if((ifp->if_capenable & IFCAP_TXCSUM_IPV6)
- && !(ifp->if_capenable & IFCAP_TSO6)) {
- if (mask & IFCAP_TXCSUM_IPV6)
- ifp->if_capenable &= ~IFCAP_TXCSUM_IPV6;
- else if (mask & IFCAP_TSO6)
- ifp->if_capenable |= IFCAP_TSO6;
- } else if ((ifp->if_capenable & IFCAP_TXCSUM_IPV6)
- && (ifp->if_capenable & IFCAP_TSO6)) {
- if (mask & IFCAP_TXCSUM_IPV6) {
- vsi->flags |= IXL_FLAGS_KEEP_TSO6;
- ifp->if_capenable &= ~(IFCAP_TXCSUM_IPV6 | IFCAP_TSO6);
- device_printf(dev,
- "TSO6 requires txcsum6, disabling both...\n");
- } else if (mask & IFCAP_TSO6)
- ifp->if_capenable &= ~IFCAP_TSO6;
- }
+ return (0);
}
/* For the set_advertise sysctl */
@@ -522,7 +339,8 @@
status = i40e_shutdown_lan_hmc(hw);
if (status) {
device_printf(dev,
- "init: LAN HMC shutdown failure; status %d\n", status);
+ "init: LAN HMC shutdown failure; status %s\n",
+ i40e_stat_str(hw, status));
goto err_out;
}
}
@@ -532,7 +350,8 @@
status = i40e_shutdown_adminq(hw);
if (status)
device_printf(dev,
- "init: Admin Queue shutdown failure; status %d\n", status);
+ "init: Admin Queue shutdown failure; status %s\n",
+ i40e_stat_str(hw, status));
err_out:
return (status);
@@ -543,7 +362,7 @@
{
struct i40e_hw *hw = &pf->hw;
device_t dev = pf->dev;
- u8 set_fc_err_mask;
+ u32 reg;
int error = 0;
// XXX: clear_hw() actually writes to hw registers -- maybe this isn't necessary
@@ -565,6 +384,7 @@
i40e_clear_pxe_mode(hw);
+#if 0
error = ixl_get_hw_capabilities(pf);
if (error) {
device_printf(dev, "init: Error retrieving HW capabilities;"
@@ -636,95 +456,65 @@
err_out:
return (error);
-}
+#endif
+ // TODO: Fix second parameter
+ ixl_rebuild_hw_structs_after_reset(pf, false);
-/*
-** MSIX Interrupt Handlers and Tasklets
-*/
-void
-ixl_handle_que(void *context, int pending)
-{
- struct ixl_queue *que = context;
- struct ixl_vsi *vsi = que->vsi;
- struct ixl_pf *pf = (struct ixl_pf *)vsi->back;
- struct i40e_hw *hw = vsi->hw;
- struct tx_ring *txr = &que->txr;
- struct ifnet *ifp = vsi->ifp;
- bool more;
-
- if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
- more = ixl_rxeof(que, IXL_RX_LIMIT);
- IXL_TX_LOCK(txr);
- ixl_txeof(que);
- if (!drbr_empty(ifp, txr->br))
- ixl_mq_start_locked(ifp, txr);
- IXL_TX_UNLOCK(txr);
- if (more) {
- taskqueue_enqueue(que->tq, &que->task);
- return;
- }
- }
+ /* The PF reset should have cleared any critical errors */
+ atomic_clear_32(&pf->state, IXL_PF_STATE_PF_CRIT_ERR);
+ atomic_clear_32(&pf->state, IXL_PF_STATE_PF_RESET_REQ);
+
+ reg = rd32(hw, I40E_PFINT_ICR0_ENA);
+ reg |= IXL_ICR0_CRIT_ERR_MASK;
+ wr32(hw, I40E_PFINT_ICR0_ENA, reg);
- /* Re-enable queue interrupt */
- if (pf->msix > 1)
- ixl_enable_queue(hw, que->me);
- else
- ixl_enable_intr0(hw);
+ err_out:
+ return (error);
}
-
-/*********************************************************************
- *
- * Legacy Interrupt Service routine
- *
- **********************************************************************/
-void
+/*
+ * TODO: Make sure this properly handles admin queue / single rx queue intr
+ */
+int
ixl_intr(void *arg)
{
struct ixl_pf *pf = arg;
struct i40e_hw *hw = &pf->hw;
struct ixl_vsi *vsi = &pf->vsi;
- struct ixl_queue *que = vsi->queues;
- struct ifnet *ifp = vsi->ifp;
- struct tx_ring *txr = &que->txr;
+ struct ixl_rx_queue *que = vsi->rx_queues;
u32 icr0;
- bool more;
- pf->admin_irq++;
+ // pf->admin_irq++
+ ++que->irqs;
+// TODO: Check against proper field
+#if 0
/* Clear PBA at start of ISR if using legacy interrupts */
if (pf->msix == 0)
wr32(hw, I40E_PFINT_DYN_CTL0,
I40E_PFINT_DYN_CTLN_CLEARPBA_MASK |
(IXL_ITR_NONE << I40E_PFINT_DYN_CTLN_ITR_INDX_SHIFT));
+#endif
icr0 = rd32(hw, I40E_PFINT_ICR0);
#ifdef PCI_IOV
if (icr0 & I40E_PFINT_ICR0_VFLR_MASK)
- taskqueue_enqueue(pf->tq, &pf->vflr_task);
+ iflib_iov_intr_deferred(vsi->ctx);
#endif
+ // TODO!: Do the stuff that's done in ixl_msix_adminq here, too!
if (icr0 & I40E_PFINT_ICR0_ADMINQ_MASK)
- taskqueue_enqueue(pf->tq, &pf->adminq);
-
- if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
- ++que->irqs;
-
- more = ixl_rxeof(que, IXL_RX_LIMIT);
-
- IXL_TX_LOCK(txr);
- ixl_txeof(que);
- if (!drbr_empty(vsi->ifp, txr->br))
- ixl_mq_start_locked(ifp, txr);
- IXL_TX_UNLOCK(txr);
-
- if (more)
- taskqueue_enqueue(que->tq, &que->task);
- }
-
+ iflib_admin_intr_deferred(vsi->ctx);
+
+ // TODO: Is intr0 enabled somewhere else?
ixl_enable_intr0(hw);
+
+ if (icr0 & I40E_PFINT_ICR0_QUEUE_0_MASK)
+ return (FILTER_SCHEDULE_THREAD);
+ else
+ return (FILTER_HANDLED);
}
@@ -733,43 +523,17 @@
* MSIX VSI Interrupt Service routine
*
**********************************************************************/
-void
+int
ixl_msix_que(void *arg)
{
- struct ixl_queue *que = arg;
- struct ixl_vsi *vsi = que->vsi;
- struct i40e_hw *hw = vsi->hw;
- struct tx_ring *txr = &que->txr;
- bool more_tx, more_rx;
-
- /* Protect against spurious interrupts */
- if (!(vsi->ifp->if_drv_flags & IFF_DRV_RUNNING))
- return;
+ struct ixl_rx_queue *que = arg;
++que->irqs;
- more_rx = ixl_rxeof(que, IXL_RX_LIMIT);
-
- IXL_TX_LOCK(txr);
- more_tx = ixl_txeof(que);
- /*
- ** Make certain that if the stack
- ** has anything queued the task gets
- ** scheduled to handle it.
- */
- if (!drbr_empty(vsi->ifp, txr->br))
- more_tx = 1;
- IXL_TX_UNLOCK(txr);
-
ixl_set_queue_rx_itr(que);
- ixl_set_queue_tx_itr(que);
-
- if (more_tx || more_rx)
- taskqueue_enqueue(que->tq, &que->task);
- else
- ixl_enable_queue(hw, que->me);
+ // ixl_set_queue_tx_itr(que);
- return;
+ return (FILTER_SCHEDULE_THREAD);
}
@@ -778,7 +542,7 @@
* MSIX Admin Queue Interrupt Service routine
*
**********************************************************************/
-void
+int
ixl_msix_adminq(void *arg)
{
struct ixl_pf *pf = arg;
@@ -787,23 +551,29 @@
u32 reg, mask, rstat_reg;
bool do_task = FALSE;
+ DDPRINTF(dev, "begin");
+
++pf->admin_irq;
reg = rd32(hw, I40E_PFINT_ICR0);
+ // For masking off interrupt causes that need to be handled before
+ // they can be re-enabled
mask = rd32(hw, I40E_PFINT_ICR0_ENA);
/* Check on the cause */
if (reg & I40E_PFINT_ICR0_ADMINQ_MASK) {
- mask &= ~I40E_PFINT_ICR0_ADMINQ_MASK;
+ mask &= ~I40E_PFINT_ICR0_ENA_ADMINQ_MASK;
do_task = TRUE;
}
if (reg & I40E_PFINT_ICR0_MAL_DETECT_MASK) {
- ixl_handle_mdd_event(pf);
- mask &= ~I40E_PFINT_ICR0_MAL_DETECT_MASK;
+ mask &= ~I40E_PFINT_ICR0_ENA_MAL_DETECT_MASK;
+ atomic_set_32(&pf->state, IXL_PF_STATE_MDD_PENDING);
+ do_task = TRUE;
}
if (reg & I40E_PFINT_ICR0_GRST_MASK) {
+ mask &= ~I40E_PFINT_ICR0_ENA_GRST_MASK;
device_printf(dev, "Reset Requested!\n");
rstat_reg = rd32(hw, I40E_GLGEN_RSTAT);
rstat_reg = (rstat_reg & I40E_GLGEN_RSTAT_RESET_TYPE_MASK)
@@ -819,20 +589,39 @@
break;
case I40E_RESET_EMPR:
printf("EMPR\n");
- atomic_set_int(&pf->state, IXL_PF_STATE_EMPR_RESETTING);
break;
default:
printf("POR\n");
break;
}
/* overload admin queue task to check reset progress */
+ atomic_set_int(&pf->state, IXL_PF_STATE_ADAPTER_RESETTING);
do_task = TRUE;
}
- if (reg & I40E_PFINT_ICR0_ECC_ERR_MASK) {
- device_printf(dev, "ECC Error detected!\n");
+ /*
+ * PE / PCI / ECC exceptions are all handled in the same way:
+ * mask out these three causes, then request a PF reset
+ *
+ * TODO: I think at least ECC error requires a GLOBR, not PFR
+ */
+ if (reg & I40E_PFINT_ICR0_ECC_ERR_MASK)
+ device_printf(dev, "ECC Error detected!\n");
+ if (reg & I40E_PFINT_ICR0_PCI_EXCEPTION_MASK)
+ device_printf(dev, "PCI Exception detected!\n");
+ if (reg & I40E_PFINT_ICR0_PE_CRITERR_MASK)
+ device_printf(dev, "Critical Protocol Engine Error detected!\n");
+ /* Checks against the conditions above */
+ if (reg & IXL_ICR0_CRIT_ERR_MASK) {
+ mask &= ~IXL_ICR0_CRIT_ERR_MASK;
+ atomic_set_32(&pf->state,
+ IXL_PF_STATE_PF_RESET_REQ | IXL_PF_STATE_PF_CRIT_ERR);
+ do_task = TRUE;
}
+ // TODO: Linux driver never re-enables this interrupt once it has been detected
+ // Then what is supposed to happen? A PF reset? Should it never happen?
+ // TODO: Parse out this error into something human readable
if (reg & I40E_PFINT_ICR0_HMC_ERR_MASK) {
reg = rd32(hw, I40E_PFHMC_ERRORINFO);
if (reg & I40E_PFHMC_ERRORINFO_ERROR_DETECTED_MASK) {
@@ -844,55 +633,19 @@
}
}
- if (reg & I40E_PFINT_ICR0_PCI_EXCEPTION_MASK) {
- device_printf(dev, "PCI Exception detected!\n");
- }
-
#ifdef PCI_IOV
if (reg & I40E_PFINT_ICR0_VFLR_MASK) {
mask &= ~I40E_PFINT_ICR0_ENA_VFLR_MASK;
- taskqueue_enqueue(pf->tq, &pf->vflr_task);
+ atomic_set_32(&pf->state, IXL_PF_STATE_VF_RESET_REQ);
+ do_task = TRUE;
}
#endif
+ wr32(hw, I40E_PFINT_ICR0_ENA, mask);
if (do_task)
- taskqueue_enqueue(pf->tq, &pf->adminq);
+ return (FILTER_SCHEDULE_THREAD);
else
- ixl_enable_intr0(hw);
-}
-
-void
-ixl_set_promisc(struct ixl_vsi *vsi)
-{
- struct ifnet *ifp = vsi->ifp;
- struct i40e_hw *hw = vsi->hw;
- int err, mcnt = 0;
- bool uni = FALSE, multi = FALSE;
-
- if (ifp->if_flags & IFF_PROMISC)
- uni = multi = TRUE;
- else if (ifp->if_flags & IFF_ALLMULTI)
- multi = TRUE;
- else { /* Need to count the multicast addresses */
- struct ifmultiaddr *ifma;
- if_maddr_rlock(ifp);
- CK_STAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
- if (ifma->ifma_addr->sa_family != AF_LINK)
- continue;
- if (mcnt == MAX_MULTICAST_ADDR) {
- multi = TRUE;
- break;
- }
- mcnt++;
- }
- if_maddr_runlock(ifp);
- }
-
- err = i40e_aq_set_vsi_unicast_promiscuous(hw,
- vsi->seid, uni, NULL, TRUE);
- err = i40e_aq_set_vsi_multicast_promiscuous(hw,
- vsi->seid, multi, NULL);
- return;
+ return (FILTER_HANDLED);
}
/*********************************************************************
@@ -947,7 +700,6 @@
}
IOCTL_DEBUGOUT("ixl_add_multi: end");
- return;
}
void
@@ -987,36 +739,6 @@
ixl_del_hw_filters(vsi, mcnt);
}
-/*********************************************************************
- * Timer routine
- *
- * This routine checks for link status, updates statistics,
- * and runs the watchdog check.
- *
- * Only runs when the driver is configured UP and RUNNING.
- *
- **********************************************************************/
-
-void
-ixl_local_timer(void *arg)
-{
- struct ixl_pf *pf = arg;
-
- IXL_PF_LOCK_ASSERT(pf);
-
- /* Fire off the adminq task */
- taskqueue_enqueue(pf->tq, &pf->adminq);
-
- /* Update stats */
- ixl_update_stats_counters(pf);
-
- /* Increment stat when a queue shows hung */
- if (ixl_queue_hang_check(&pf->vsi))
- pf->watchdog_events++;
-
- callout_reset(&pf->timer, hz, ixl_local_timer, pf);
-}
-
void
ixl_link_up_msg(struct ixl_pf *pf)
{
@@ -1053,473 +775,6 @@
ixl_fc_string[1] : ixl_fc_string[0]);
}
-/*
-** Note: this routine updates the OS on the link state
-** the real check of the hardware only happens with
-** a link interrupt.
-*/
-void
-ixl_update_link_status(struct ixl_pf *pf)
-{
- struct ixl_vsi *vsi = &pf->vsi;
- struct ifnet *ifp = vsi->ifp;
- device_t dev = pf->dev;
-
- if (pf->link_up) {
- if (vsi->link_active == FALSE) {
- vsi->link_active = TRUE;
-#if __FreeBSD_version >= 1100000
- ifp->if_baudrate = ixl_max_aq_speed_to_value(pf->link_speed);
-#else
- if_initbaudrate(ifp, ixl_max_aq_speed_to_value(pf->link_speed));
-#endif
- if_link_state_change(ifp, LINK_STATE_UP);
- ixl_link_up_msg(pf);
-#ifdef PCI_IOV
- ixl_broadcast_link_state(pf);
-#endif
- }
- } else { /* Link down */
- if (vsi->link_active == TRUE) {
- if (bootverbose)
- device_printf(dev, "Link is Down\n");
- if_link_state_change(ifp, LINK_STATE_DOWN);
- vsi->link_active = FALSE;
-#ifdef PCI_IOV
- ixl_broadcast_link_state(pf);
-#endif
- }
- }
-}
-
-/*********************************************************************
- *
- * This routine disables all traffic on the adapter by issuing a
- * global reset on the MAC and deallocates TX/RX buffers.
- *
- **********************************************************************/
-
-void
-ixl_stop_locked(struct ixl_pf *pf)
-{
- struct ixl_vsi *vsi = &pf->vsi;
- struct ifnet *ifp = vsi->ifp;
-
- INIT_DEBUGOUT("ixl_stop: begin\n");
-
- IXL_PF_LOCK_ASSERT(pf);
-
-#ifdef IXL_IW
- /* Stop iWARP device */
- if (ixl_enable_iwarp && pf->iw_enabled)
- ixl_iw_pf_stop(pf);
-#endif
-
- /* Stop the local timer */
- callout_stop(&pf->timer);
-
- ixl_disable_rings_intr(vsi);
- ixl_disable_rings(vsi);
-
- /* Tell the stack that the interface is no longer active */
- ifp->if_drv_flags &= ~(IFF_DRV_RUNNING);
-}
-
-void
-ixl_stop(struct ixl_pf *pf)
-{
- IXL_PF_LOCK(pf);
- ixl_stop_locked(pf);
- IXL_PF_UNLOCK(pf);
-}
-
-/*********************************************************************
- *
- * Setup MSIX Interrupt resources and handlers for the VSI
- *
- **********************************************************************/
-int
-ixl_setup_legacy(struct ixl_pf *pf)
-{
- device_t dev = pf->dev;
- int error, rid = 0;
-
- if (pf->msix == 1)
- rid = 1;
- pf->res = bus_alloc_resource_any(dev, SYS_RES_IRQ,
- &rid, RF_SHAREABLE | RF_ACTIVE);
- if (pf->res == NULL) {
- device_printf(dev, "bus_alloc_resource_any() for"
- " legacy/msi interrupt\n");
- return (ENXIO);
- }
-
- /* Set the handler function */
- error = bus_setup_intr(dev, pf->res,
- INTR_TYPE_NET | INTR_MPSAFE, NULL,
- ixl_intr, pf, &pf->tag);
- if (error) {
- pf->res = NULL;
- device_printf(dev, "bus_setup_intr() for legacy/msi"
- " interrupt handler failed, error %d\n", error);
- return (ENXIO);
- }
- error = bus_describe_intr(dev, pf->res, pf->tag, "irq");
- if (error) {
- /* non-fatal */
- device_printf(dev, "bus_describe_intr() for Admin Queue"
- " interrupt name failed, error %d\n", error);
- }
-
- return (0);
-}
-
-int
-ixl_setup_adminq_tq(struct ixl_pf *pf)
-{
- device_t dev = pf->dev;
- int error = 0;
-
- /* Tasklet for Admin Queue interrupts */
- TASK_INIT(&pf->adminq, 0, ixl_do_adminq, pf);
-#ifdef PCI_IOV
- /* VFLR Tasklet */
- TASK_INIT(&pf->vflr_task, 0, ixl_handle_vflr, pf);
-#endif
- /* Create and start Admin Queue taskqueue */
- pf->tq = taskqueue_create_fast("ixl_aq", M_NOWAIT,
- taskqueue_thread_enqueue, &pf->tq);
- if (!pf->tq) {
- device_printf(dev, "taskqueue_create_fast (for AQ) returned NULL!\n");
- return (ENOMEM);
- }
- error = taskqueue_start_threads(&pf->tq, 1, PI_NET, "%s aq",
- device_get_nameunit(dev));
- if (error) {
- device_printf(dev, "taskqueue_start_threads (for AQ) error: %d\n",
- error);
- taskqueue_free(pf->tq);
- return (error);
- }
- return (0);
-}
-
-int
-ixl_setup_queue_tqs(struct ixl_vsi *vsi)
-{
- struct ixl_queue *que = vsi->queues;
- device_t dev = vsi->dev;
-#ifdef RSS
- int cpu_id = 0;
- cpuset_t cpu_mask;
-#endif
-
- /* Create queue tasks and start queue taskqueues */
- for (int i = 0; i < vsi->num_queues; i++, que++) {
- TASK_INIT(&que->tx_task, 0, ixl_deferred_mq_start, que);
- TASK_INIT(&que->task, 0, ixl_handle_que, que);
- que->tq = taskqueue_create_fast("ixl_que", M_NOWAIT,
- taskqueue_thread_enqueue, &que->tq);
-#ifdef RSS
- CPU_SETOF(cpu_id, &cpu_mask);
- taskqueue_start_threads_cpuset(&que->tq, 1, PI_NET,
- &cpu_mask, "%s (bucket %d)",
- device_get_nameunit(dev), cpu_id);
-#else
- taskqueue_start_threads(&que->tq, 1, PI_NET,
- "%s (que %d)", device_get_nameunit(dev), que->me);
-#endif
- }
-
- return (0);
-}
-
-void
-ixl_free_adminq_tq(struct ixl_pf *pf)
-{
- if (pf->tq) {
- taskqueue_free(pf->tq);
- pf->tq = NULL;
- }
-}
-
-void
-ixl_free_queue_tqs(struct ixl_vsi *vsi)
-{
- struct ixl_queue *que = vsi->queues;
-
- for (int i = 0; i < vsi->num_queues; i++, que++) {
- if (que->tq) {
- taskqueue_free(que->tq);
- que->tq = NULL;
- }
- }
-}
-
-int
-ixl_setup_adminq_msix(struct ixl_pf *pf)
-{
- device_t dev = pf->dev;
- int rid, error = 0;
-
- /* Admin IRQ rid is 1, vector is 0 */
- rid = 1;
- /* Get interrupt resource from bus */
- pf->res = bus_alloc_resource_any(dev,
- SYS_RES_IRQ, &rid, RF_SHAREABLE | RF_ACTIVE);
- if (!pf->res) {
- device_printf(dev, "bus_alloc_resource_any() for Admin Queue"
- " interrupt failed [rid=%d]\n", rid);
- return (ENXIO);
- }
- /* Then associate interrupt with handler */
- error = bus_setup_intr(dev, pf->res,
- INTR_TYPE_NET | INTR_MPSAFE, NULL,
- ixl_msix_adminq, pf, &pf->tag);
- if (error) {
- pf->res = NULL;
- device_printf(dev, "bus_setup_intr() for Admin Queue"
- " interrupt handler failed, error %d\n", error);
- return (ENXIO);
- }
- error = bus_describe_intr(dev, pf->res, pf->tag, "aq");
- if (error) {
- /* non-fatal */
- device_printf(dev, "bus_describe_intr() for Admin Queue"
- " interrupt name failed, error %d\n", error);
- }
- pf->admvec = 0;
-
- return (0);
-}
-
-/*
- * Allocate interrupt resources from bus and associate an interrupt handler
- * to those for the VSI's queues.
- */
-int
-ixl_setup_queue_msix(struct ixl_vsi *vsi)
-{
- device_t dev = vsi->dev;
- struct ixl_queue *que = vsi->queues;
- struct tx_ring *txr;
- int error, rid, vector = 1;
-
- /* Queue interrupt vector numbers start at 1 (adminq intr is 0) */
- for (int i = 0; i < vsi->num_queues; i++, vector++, que++) {
- int cpu_id = i;
- rid = vector + 1;
- txr = &que->txr;
- que->res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
- RF_SHAREABLE | RF_ACTIVE);
- if (!que->res) {
- device_printf(dev, "bus_alloc_resource_any() for"
- " Queue %d interrupt failed [rid=%d]\n",
- que->me, rid);
- return (ENXIO);
- }
- /* Set the handler function */
- error = bus_setup_intr(dev, que->res,
- INTR_TYPE_NET | INTR_MPSAFE, NULL,
- ixl_msix_que, que, &que->tag);
- if (error) {
- device_printf(dev, "bus_setup_intr() for Queue %d"
- " interrupt handler failed, error %d\n",
- que->me, error);
- bus_release_resource(dev, SYS_RES_IRQ, rid, que->res);
- return (error);
- }
- error = bus_describe_intr(dev, que->res, que->tag, "q%d", i);
- if (error) {
- device_printf(dev, "bus_describe_intr() for Queue %d"
- " interrupt name failed, error %d\n",
- que->me, error);
- }
- /* Bind the vector to a CPU */
-#ifdef RSS
- cpu_id = rss_getcpu(i % rss_getnumbuckets());
-#endif
- error = bus_bind_intr(dev, que->res, cpu_id);
- if (error) {
- device_printf(dev, "bus_bind_intr() for Queue %d"
- " to CPU %d failed, error %d\n",
- que->me, cpu_id, error);
- }
- que->msix = vector;
- }
-
- return (0);
-}
-
-/*
- * Allocate MSI/X vectors from the OS.
- * Returns 0 for legacy, 1 for MSI, >1 for MSIX.
- */
-int
-ixl_init_msix(struct ixl_pf *pf)
-{
- device_t dev = pf->dev;
- struct i40e_hw *hw = &pf->hw;
-#ifdef IXL_IW
-#if __FreeBSD_version >= 1100000
- cpuset_t cpu_set;
-#endif
-#endif
- int auto_max_queues;
- int rid, want, vectors, queues, available;
-#ifdef IXL_IW
- int iw_want=0, iw_vectors;
-
- pf->iw_msix = 0;
-#endif
-
- /* Override by tuneable */
- if (!pf->enable_msix)
- goto no_msix;
-
- /* First try MSI/X */
- rid = PCIR_BAR(IXL_MSIX_BAR);
- pf->msix_mem = bus_alloc_resource_any(dev,
- SYS_RES_MEMORY, &rid, RF_ACTIVE);
- if (!pf->msix_mem) {
- /* May not be enabled */
- device_printf(pf->dev,
- "Unable to map MSIX table\n");
- goto no_msix;
- }
-
- available = pci_msix_count(dev);
- if (available < 2) {
- /* system has msix disabled (0), or only one vector (1) */
- device_printf(pf->dev, "Less than two MSI-X vectors available\n");
- bus_release_resource(dev, SYS_RES_MEMORY,
- rid, pf->msix_mem);
- pf->msix_mem = NULL;
- goto no_msix;
- }
-
- /* Clamp max number of queues based on:
- * - # of MSI-X vectors available
- * - # of cpus available
- * - # of queues that can be assigned to the LAN VSI
- */
- auto_max_queues = min(mp_ncpus, available - 1);
- if (hw->mac.type == I40E_MAC_X722)
- auto_max_queues = min(auto_max_queues, 128);
- else
- auto_max_queues = min(auto_max_queues, 64);
-
- /* Override with tunable value if tunable is less than autoconfig count */
- if ((pf->max_queues != 0) && (pf->max_queues <= auto_max_queues))
- queues = pf->max_queues;
- /* Use autoconfig amount if that's lower */
- else if ((pf->max_queues != 0) && (pf->max_queues > auto_max_queues)) {
- device_printf(dev, "ixl_max_queues (%d) is too large, using "
- "autoconfig amount (%d)...\n",
- pf->max_queues, auto_max_queues);
- queues = auto_max_queues;
- }
- /* Limit maximum auto-configured queues to 8 if no user value is set */
- else
- queues = min(auto_max_queues, 8);
-
-#ifdef RSS
- /* If we're doing RSS, clamp at the number of RSS buckets */
- if (queues > rss_getnumbuckets())
- queues = rss_getnumbuckets();
-#endif
-
- /*
- ** Want one vector (RX/TX pair) per queue
- ** plus an additional for the admin queue.
- */
- want = queues + 1;
- if (want <= available) /* Have enough */
- vectors = want;
- else {
- device_printf(pf->dev,
- "MSIX Configuration Problem, "
- "%d vectors available but %d wanted!\n",
- available, want);
- pf->msix_mem = NULL;
- goto no_msix; /* Will go to Legacy setup */
- }
-
-#ifdef IXL_IW
- if (ixl_enable_iwarp && hw->func_caps.iwarp) {
-#if __FreeBSD_version >= 1100000
- if(bus_get_cpus(dev, INTR_CPUS, sizeof(cpu_set), &cpu_set) == 0)
- {
- iw_want = min(CPU_COUNT(&cpu_set), IXL_IW_MAX_MSIX);
- }
-#endif
- if(!iw_want)
- iw_want = min(mp_ncpus, IXL_IW_MAX_MSIX);
- if(ixl_limit_iwarp_msix > 0)
- iw_want = min(iw_want, ixl_limit_iwarp_msix);
- else
- iw_want = min(iw_want, 1);
-
- available -= vectors;
- if (available > 0) {
- iw_vectors = (available >= iw_want) ?
- iw_want : available;
- vectors += iw_vectors;
- } else
- iw_vectors = 0;
- }
-#endif
-
- ixl_set_msix_enable(dev);
- if (pci_alloc_msix(dev, &vectors) == 0) {
- device_printf(pf->dev,
- "Using MSIX interrupts with %d vectors\n", vectors);
- pf->msix = vectors;
-#ifdef IXL_IW
- if (ixl_enable_iwarp && hw->func_caps.iwarp)
- {
- pf->iw_msix = iw_vectors;
- device_printf(pf->dev,
- "Reserving %d MSIX interrupts for iWARP CEQ and AEQ\n",
- iw_vectors);
- }
-#endif
-
- pf->vsi.num_queues = queues;
-#ifdef RSS
- /*
- * If we're doing RSS, the number of queues needs to
- * match the number of RSS buckets that are configured.
- *
- * + If there's more queues than RSS buckets, we'll end
- * up with queues that get no traffic.
- *
- * + If there's more RSS buckets than queues, we'll end
- * up having multiple RSS buckets map to the same queue,
- * so there'll be some contention.
- */
- if (queues != rss_getnumbuckets()) {
- device_printf(dev,
- "%s: queues (%d) != RSS buckets (%d)"
- "; performance will be impacted.\n",
- __func__, queues, rss_getnumbuckets());
- }
-#endif
- return (vectors);
- }
-no_msix:
- vectors = pci_msi_count(dev);
- pf->vsi.num_queues = 1;
- pf->max_queues = 1;
- if (vectors == 1 && pci_alloc_msi(dev, &vectors) == 0)
- device_printf(pf->dev, "Using an MSI interrupt\n");
- else {
- vectors = 0;
- device_printf(pf->dev, "Using a Legacy interrupt\n");
- }
- return (vectors);
-}
-
/*
* Configure admin queue/misc interrupt cause registers in hardware.
*/
@@ -1561,19 +816,28 @@
/*
* Configure queue interrupt cause registers in hardware.
+ *
+ * Linked list for each vector LNKLSTN(i) -> RQCTL(i) -> TQCTL(i) -> EOL
*/
void
ixl_configure_queue_intr_msix(struct ixl_pf *pf)
{
- struct i40e_hw *hw = &pf->hw;
+ struct i40e_hw *hw = &pf->hw;
struct ixl_vsi *vsi = &pf->vsi;
u32 reg;
u16 vector = 1;
- for (int i = 0; i < vsi->num_queues; i++, vector++) {
+ // TODO: See if max is really necessary
+ for (int i = 0; i < max(vsi->num_rx_queues, vsi->num_tx_queues); i++, vector++) {
+ /* Make sure interrupt is disabled */
wr32(hw, I40E_PFINT_DYN_CTLN(i), 0);
- /* First queue type is RX / 0 */
- wr32(hw, I40E_PFINT_LNKLSTN(i), i);
+ /* Set linked list head to point to corresponding RX queue
+ * e.g. vector 1 (LNKLSTN register 0) points to queue pair 0's RX queue */
+ reg = ((i << I40E_PFINT_LNKLSTN_FIRSTQ_INDX_SHIFT)
+ & I40E_PFINT_LNKLSTN_FIRSTQ_INDX_MASK) |
+ ((I40E_QUEUE_TYPE_RX << I40E_PFINT_LNKLSTN_FIRSTQ_TYPE_SHIFT)
+ & I40E_PFINT_LNKLSTN_FIRSTQ_TYPE_MASK);
+ wr32(hw, I40E_PFINT_LNKLSTN(i), reg);
reg = I40E_QINT_RQCTL_CAUSE_ENA_MASK |
(IXL_RX_ITR << I40E_QINT_RQCTL_ITR_INDX_SHIFT) |
@@ -1592,18 +856,17 @@
}
/*
- * Configure for MSI single vector operation
+ * Configure for single interrupt vector operation
*/
void
ixl_configure_legacy(struct ixl_pf *pf)
{
struct i40e_hw *hw = &pf->hw;
struct ixl_vsi *vsi = &pf->vsi;
- struct ixl_queue *que = vsi->queues;
- struct rx_ring *rxr = &que->rxr;
- struct tx_ring *txr = &que->txr;
u32 reg;
+// TODO: Fix
+#if 0
/* Configure ITR */
vsi->tx_itr_setting = pf->tx_itr;
wr32(hw, I40E_PFINT_ITR0(IXL_TX_ITR),
@@ -1614,6 +877,9 @@
wr32(hw, I40E_PFINT_ITR0(IXL_RX_ITR),
vsi->rx_itr_setting);
rxr->itr = vsi->rx_itr_setting;
+ /* XXX: Assuming only 1 queue in single interrupt mode */
+#endif
+ vsi->rx_queues[0].rxr.itr = vsi->rx_itr_setting;
/* Setup "other" causes */
reg = I40E_PFINT_ICR0_ENA_ECC_ERR_MASK
@@ -1646,151 +912,28 @@
wr32(hw, I40E_QINT_TQCTL(0), reg);
}
-int
-ixl_allocate_pci_resources(struct ixl_pf *pf)
-{
- int rid;
- struct i40e_hw *hw = &pf->hw;
- device_t dev = pf->dev;
-
- /* Map BAR0 */
- rid = PCIR_BAR(0);
- pf->pci_mem = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
- &rid, RF_ACTIVE);
-
- if (!(pf->pci_mem)) {
- device_printf(dev, "Unable to allocate bus resource: PCI memory\n");
- return (ENXIO);
- }
- /* Ensure proper PCI device operation */
- ixl_set_busmaster(dev);
-
- /* Save off the PCI information */
- hw->vendor_id = pci_get_vendor(dev);
- hw->device_id = pci_get_device(dev);
- hw->revision_id = pci_read_config(dev, PCIR_REVID, 1);
- hw->subsystem_vendor_id =
- pci_read_config(dev, PCIR_SUBVEND_0, 2);
- hw->subsystem_device_id =
- pci_read_config(dev, PCIR_SUBDEV_0, 2);
-
- hw->bus.device = pci_get_slot(dev);
- hw->bus.func = pci_get_function(dev);
-
- /* Save off register access information */
- pf->osdep.mem_bus_space_tag =
- rman_get_bustag(pf->pci_mem);
- pf->osdep.mem_bus_space_handle =
- rman_get_bushandle(pf->pci_mem);
- pf->osdep.mem_bus_space_size = rman_get_size(pf->pci_mem);
- pf->osdep.flush_reg = I40E_GLGEN_STAT;
- pf->hw.hw_addr = (u8 *) &pf->osdep.mem_bus_space_handle;
-
- pf->hw.back = &pf->osdep;
-
- return (0);
-}
-
-/*
- * Teardown and release the admin queue/misc vector
- * interrupt.
- */
-int
-ixl_teardown_adminq_msix(struct ixl_pf *pf)
-{
- device_t dev = pf->dev;
- int rid, error = 0;
-
- if (pf->admvec) /* we are doing MSIX */
- rid = pf->admvec + 1;
- else
- (pf->msix != 0) ? (rid = 1):(rid = 0);
-
- if (pf->tag != NULL) {
- bus_teardown_intr(dev, pf->res, pf->tag);
- if (error) {
- device_printf(dev, "bus_teardown_intr() for"
- " interrupt 0 failed\n");
- // return (ENXIO);
- }
- pf->tag = NULL;
- }
- if (pf->res != NULL) {
- bus_release_resource(dev, SYS_RES_IRQ, rid, pf->res);
- if (error) {
- device_printf(dev, "bus_release_resource() for"
- " interrupt 0 failed [rid=%d]\n", rid);
- // return (ENXIO);
- }
- pf->res = NULL;
- }
-
- return (0);
-}
-
-int
-ixl_teardown_queue_msix(struct ixl_vsi *vsi)
-{
- struct ixl_pf *pf = (struct ixl_pf *)vsi->back;
- struct ixl_queue *que = vsi->queues;
- device_t dev = vsi->dev;
- int rid, error = 0;
-
- /* We may get here before stations are setup */
- if ((pf->msix < 2) || (que == NULL))
- return (0);
-
- /* Release all MSIX queue resources */
- for (int i = 0; i < vsi->num_queues; i++, que++) {
- rid = que->msix + 1;
- if (que->tag != NULL) {
- error = bus_teardown_intr(dev, que->res, que->tag);
- if (error) {
- device_printf(dev, "bus_teardown_intr() for"
- " Queue %d interrupt failed\n",
- que->me);
- // return (ENXIO);
- }
- que->tag = NULL;
- }
- if (que->res != NULL) {
- error = bus_release_resource(dev, SYS_RES_IRQ, rid, que->res);
- if (error) {
- device_printf(dev, "bus_release_resource() for"
- " Queue %d interrupt failed [rid=%d]\n",
- que->me, rid);
- // return (ENXIO);
- }
- que->res = NULL;
- }
- }
-
- return (0);
-}
-
void
ixl_free_pci_resources(struct ixl_pf *pf)
{
- device_t dev = pf->dev;
- int memrid;
-
- ixl_teardown_queue_msix(&pf->vsi);
- ixl_teardown_adminq_msix(pf);
+ struct ixl_vsi *vsi = &pf->vsi;
+ device_t dev = iflib_get_dev(vsi->ctx);
+ struct ixl_rx_queue *rx_que = vsi->rx_queues;
- if (pf->msix > 0)
- pci_release_msi(dev);
-
- memrid = PCIR_BAR(IXL_MSIX_BAR);
+ /* We may get here before stations are setup */
+ if (rx_que == NULL)
+ goto early;
- if (pf->msix_mem != NULL)
- bus_release_resource(dev, SYS_RES_MEMORY,
- memrid, pf->msix_mem);
+ /*
+ ** Release all msix VSI resources:
+ */
+ iflib_irq_free(vsi->ctx, &vsi->irq);
+ for (int i = 0; i < vsi->num_rx_queues; i++, rx_que++)
+ iflib_irq_free(vsi->ctx, &rx_que->que_irq);
+early:
if (pf->pci_mem != NULL)
bus_release_resource(dev, SYS_RES_MEMORY,
PCIR_BAR(0), pf->pci_mem);
-
- return;
}
void
@@ -1798,73 +941,73 @@
{
/* Display supported media types */
if (phy_types & (I40E_CAP_PHY_TYPE_100BASE_TX))
- ifmedia_add(&vsi->media, IFM_ETHER | IFM_100_TX, 0, NULL);
+ ifmedia_add(vsi->media, IFM_ETHER | IFM_100_TX, 0, NULL);
if (phy_types & (I40E_CAP_PHY_TYPE_1000BASE_T))
- ifmedia_add(&vsi->media, IFM_ETHER | IFM_1000_T, 0, NULL);
+ ifmedia_add(vsi->media, IFM_ETHER | IFM_1000_T, 0, NULL);
if (phy_types & (I40E_CAP_PHY_TYPE_1000BASE_SX))
- ifmedia_add(&vsi->media, IFM_ETHER | IFM_1000_SX, 0, NULL);
+ ifmedia_add(vsi->media, IFM_ETHER | IFM_1000_SX, 0, NULL);
if (phy_types & (I40E_CAP_PHY_TYPE_1000BASE_LX))
- ifmedia_add(&vsi->media, IFM_ETHER | IFM_1000_LX, 0, NULL);
+ ifmedia_add(vsi->media, IFM_ETHER | IFM_1000_LX, 0, NULL);
if (phy_types & (I40E_CAP_PHY_TYPE_XAUI) ||
phy_types & (I40E_CAP_PHY_TYPE_XFI) ||
phy_types & (I40E_CAP_PHY_TYPE_10GBASE_SFPP_CU))
- ifmedia_add(&vsi->media, IFM_ETHER | IFM_10G_TWINAX, 0, NULL);
+ ifmedia_add(vsi->media, IFM_ETHER | IFM_10G_TWINAX, 0, NULL);
if (phy_types & (I40E_CAP_PHY_TYPE_10GBASE_SR))
- ifmedia_add(&vsi->media, IFM_ETHER | IFM_10G_SR, 0, NULL);
+ ifmedia_add(vsi->media, IFM_ETHER | IFM_10G_SR, 0, NULL);
if (phy_types & (I40E_CAP_PHY_TYPE_10GBASE_LR))
- ifmedia_add(&vsi->media, IFM_ETHER | IFM_10G_LR, 0, NULL);
+ ifmedia_add(vsi->media, IFM_ETHER | IFM_10G_LR, 0, NULL);
if (phy_types & (I40E_CAP_PHY_TYPE_10GBASE_T))
- ifmedia_add(&vsi->media, IFM_ETHER | IFM_10G_T, 0, NULL);
+ ifmedia_add(vsi->media, IFM_ETHER | IFM_10G_T, 0, NULL);
if (phy_types & (I40E_CAP_PHY_TYPE_40GBASE_CR4) ||
phy_types & (I40E_CAP_PHY_TYPE_40GBASE_CR4_CU) ||
phy_types & (I40E_CAP_PHY_TYPE_40GBASE_AOC) ||
phy_types & (I40E_CAP_PHY_TYPE_XLAUI) ||
phy_types & (I40E_CAP_PHY_TYPE_40GBASE_KR4))
- ifmedia_add(&vsi->media, IFM_ETHER | IFM_40G_CR4, 0, NULL);
+ ifmedia_add(vsi->media, IFM_ETHER | IFM_40G_CR4, 0, NULL);
if (phy_types & (I40E_CAP_PHY_TYPE_40GBASE_SR4))
- ifmedia_add(&vsi->media, IFM_ETHER | IFM_40G_SR4, 0, NULL);
+ ifmedia_add(vsi->media, IFM_ETHER | IFM_40G_SR4, 0, NULL);
if (phy_types & (I40E_CAP_PHY_TYPE_40GBASE_LR4))
- ifmedia_add(&vsi->media, IFM_ETHER | IFM_40G_LR4, 0, NULL);
+ ifmedia_add(vsi->media, IFM_ETHER | IFM_40G_LR4, 0, NULL);
if (phy_types & (I40E_CAP_PHY_TYPE_1000BASE_KX))
- ifmedia_add(&vsi->media, IFM_ETHER | IFM_1000_KX, 0, NULL);
+ ifmedia_add(vsi->media, IFM_ETHER | IFM_1000_KX, 0, NULL);
if (phy_types & (I40E_CAP_PHY_TYPE_10GBASE_CR1_CU)
|| phy_types & (I40E_CAP_PHY_TYPE_10GBASE_CR1))
- ifmedia_add(&vsi->media, IFM_ETHER | IFM_10G_CR1, 0, NULL);
+ ifmedia_add(vsi->media, IFM_ETHER | IFM_10G_CR1, 0, NULL);
if (phy_types & (I40E_CAP_PHY_TYPE_10GBASE_AOC))
- ifmedia_add(&vsi->media, IFM_ETHER | IFM_10G_AOC, 0, NULL);
+ ifmedia_add(vsi->media, IFM_ETHER | IFM_10G_AOC, 0, NULL);
if (phy_types & (I40E_CAP_PHY_TYPE_SFI))
- ifmedia_add(&vsi->media, IFM_ETHER | IFM_10G_SFI, 0, NULL);
+ ifmedia_add(vsi->media, IFM_ETHER | IFM_10G_SFI, 0, NULL);
if (phy_types & (I40E_CAP_PHY_TYPE_10GBASE_KX4))
- ifmedia_add(&vsi->media, IFM_ETHER | IFM_10G_KX4, 0, NULL);
+ ifmedia_add(vsi->media, IFM_ETHER | IFM_10G_KX4, 0, NULL);
if (phy_types & (I40E_CAP_PHY_TYPE_10GBASE_KR))
- ifmedia_add(&vsi->media, IFM_ETHER | IFM_10G_KR, 0, NULL);
+ ifmedia_add(vsi->media, IFM_ETHER | IFM_10G_KR, 0, NULL);
if (phy_types & (I40E_CAP_PHY_TYPE_20GBASE_KR2))
- ifmedia_add(&vsi->media, IFM_ETHER | IFM_20G_KR2, 0, NULL);
+ ifmedia_add(vsi->media, IFM_ETHER | IFM_20G_KR2, 0, NULL);
if (phy_types & (I40E_CAP_PHY_TYPE_40GBASE_KR4))
- ifmedia_add(&vsi->media, IFM_ETHER | IFM_40G_KR4, 0, NULL);
+ ifmedia_add(vsi->media, IFM_ETHER | IFM_40G_KR4, 0, NULL);
if (phy_types & (I40E_CAP_PHY_TYPE_XLPPI))
- ifmedia_add(&vsi->media, IFM_ETHER | IFM_40G_XLPPI, 0, NULL);
+ ifmedia_add(vsi->media, IFM_ETHER | IFM_40G_XLPPI, 0, NULL);
if (phy_types & (I40E_CAP_PHY_TYPE_25GBASE_KR))
- ifmedia_add(&vsi->media, IFM_ETHER | IFM_25G_KR, 0, NULL);
+ ifmedia_add(vsi->media, IFM_ETHER | IFM_25G_KR, 0, NULL);
if (phy_types & (I40E_CAP_PHY_TYPE_25GBASE_CR))
- ifmedia_add(&vsi->media, IFM_ETHER | IFM_25G_CR, 0, NULL);
+ ifmedia_add(vsi->media, IFM_ETHER | IFM_25G_CR, 0, NULL);
if (phy_types & (I40E_CAP_PHY_TYPE_25GBASE_SR))
- ifmedia_add(&vsi->media, IFM_ETHER | IFM_25G_SR, 0, NULL);
+ ifmedia_add(vsi->media, IFM_ETHER | IFM_25G_SR, 0, NULL);
if (phy_types & (I40E_CAP_PHY_TYPE_25GBASE_LR))
- ifmedia_add(&vsi->media, IFM_ETHER | IFM_25G_LR, 0, NULL);
+ ifmedia_add(vsi->media, IFM_ETHER | IFM_25G_LR, 0, NULL);
if (phy_types & (I40E_CAP_PHY_TYPE_25GBASE_AOC))
- ifmedia_add(&vsi->media, IFM_ETHER | IFM_25G_AOC, 0, NULL);
+ ifmedia_add(vsi->media, IFM_ETHER | IFM_25G_AOC, 0, NULL);
if (phy_types & (I40E_CAP_PHY_TYPE_25GBASE_ACC))
- ifmedia_add(&vsi->media, IFM_ETHER | IFM_25G_ACC, 0, NULL);
+ ifmedia_add(vsi->media, IFM_ETHER | IFM_25G_ACC, 0, NULL);
}
/*********************************************************************
@@ -1873,66 +1016,29 @@
*
**********************************************************************/
int
-ixl_setup_interface(device_t dev, struct ixl_vsi *vsi)
+ixl_setup_interface(device_t dev, struct ixl_pf *pf)
{
- struct ixl_pf *pf = (struct ixl_pf *)vsi->back;
- struct ifnet *ifp;
- struct i40e_hw *hw = vsi->hw;
- struct ixl_queue *que = vsi->queues;
+ struct ixl_vsi *vsi = &pf->vsi;
+ if_ctx_t ctx = vsi->ctx;
+ struct i40e_hw *hw = &pf->hw;
+ struct ifnet *ifp = iflib_get_ifp(ctx);
struct i40e_aq_get_phy_abilities_resp abilities;
enum i40e_status_code aq_error = 0;
- INIT_DEBUGOUT("ixl_setup_interface: begin");
-
- ifp = vsi->ifp = if_alloc(IFT_ETHER);
- if (ifp == NULL) {
- device_printf(dev, "can not allocate ifnet structure\n");
- return (-1);
- }
- if_initname(ifp, device_get_name(dev), device_get_unit(dev));
- ifp->if_mtu = ETHERMTU;
- ifp->if_init = ixl_init;
- ifp->if_softc = vsi;
- ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
- ifp->if_ioctl = ixl_ioctl;
-
-#if __FreeBSD_version >= 1100036
- if_setgetcounterfn(ifp, ixl_get_counter);
-#endif
+ uint64_t cap;
- ifp->if_transmit = ixl_mq_start;
+ INIT_DBG_DEV(dev, "begin");
- ifp->if_qflush = ixl_qflush;
-
- ifp->if_snd.ifq_maxlen = que->num_tx_desc - 2;
-
- vsi->max_frame_size =
+ /* initialize fast path functions */
+ cap = IXL_CAPS;
+ if_setifheaderlen(ifp, sizeof(struct ether_vlan_header));
+ if_setcapabilitiesbit(ifp, cap, 0);
+ if_setcapenable(ifp, if_getcapabilities(ifp));
+ /* TODO: Remove VLAN_ENCAP_LEN? */
+ vsi->shared->isc_max_frame_size =
ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN
+ ETHER_VLAN_ENCAP_LEN;
- /* Set TSO limits */
- ifp->if_hw_tsomax = IP_MAXPACKET - (ETHER_HDR_LEN + ETHER_CRC_LEN);
- ifp->if_hw_tsomaxsegcount = IXL_MAX_TSO_SEGS;
- ifp->if_hw_tsomaxsegsize = IXL_MAX_DMA_SEG_SIZE;
-
- /*
- * Tell the upper layer(s) we support long frames.
- */
- ifp->if_hdrlen = sizeof(struct ether_vlan_header);
-
- ifp->if_capabilities |= IFCAP_HWCSUM;
- ifp->if_capabilities |= IFCAP_HWCSUM_IPV6;
- ifp->if_capabilities |= IFCAP_TSO;
- ifp->if_capabilities |= IFCAP_JUMBO_MTU;
- ifp->if_capabilities |= IFCAP_LRO;
-
- /* VLAN capabilties */
- ifp->if_capabilities |= IFCAP_VLAN_HWTAGGING
- | IFCAP_VLAN_HWTSO
- | IFCAP_VLAN_MTU
- | IFCAP_VLAN_HWCSUM;
- ifp->if_capenable = ifp->if_capabilities;
-
/*
** Don't turn this on by default, if vlans are
** created on another pseudo device (eg. lagg)
@@ -1941,19 +1047,13 @@
** using vlans directly on the ixl driver you can
** enable this and get full hardware tag filtering.
*/
- ifp->if_capabilities |= IFCAP_VLAN_HWFILTER;
-
- /*
- * Specify the media types supported by this adapter and register
- * callbacks to update media and link information
- */
- ifmedia_init(&vsi->media, IFM_IMASK, ixl_media_change,
- ixl_media_status);
+ if_setcapabilitiesbit(ifp, IFCAP_VLAN_HWFILTER, 0);
aq_error = i40e_aq_get_phy_capabilities(hw,
FALSE, TRUE, &abilities, NULL);
/* May need delay to detect fiber correctly */
if (aq_error == I40E_ERR_UNKNOWN_PHY) {
+ /* TODO: Maybe just retry this in a task... */
i40e_msec_delay(200);
aq_error = i40e_aq_get_phy_capabilities(hw, FALSE,
TRUE, &abilities, NULL);
@@ -1968,7 +1068,7 @@
} else {
pf->supported_speeds = abilities.link_speed;
#if __FreeBSD_version >= 1100000
- ifp->if_baudrate = ixl_max_aq_speed_to_value(pf->supported_speeds);
+ if_setbaudrate(ifp, ixl_max_aq_speed_to_value(pf->supported_speeds));
#else
if_initbaudrate(ifp, ixl_max_aq_speed_to_value(pf->supported_speeds));
#endif
@@ -1977,10 +1077,8 @@
}
/* Use autoselect media by default */
- ifmedia_add(&vsi->media, IFM_ETHER | IFM_AUTO, 0, NULL);
- ifmedia_set(&vsi->media, IFM_ETHER | IFM_AUTO);
-
- ether_ifattach(ifp, hw->mac.addr);
+ ifmedia_add(vsi->media, IFM_ETHER | IFM_AUTO, 0, NULL);
+ ifmedia_set(vsi->media, IFM_ETHER | IFM_AUTO);
return (0);
}
@@ -1991,8 +1089,8 @@
void
ixl_link_event(struct ixl_pf *pf, struct i40e_arq_event_info *e)
{
- struct i40e_hw *hw = &pf->hw;
- device_t dev = pf->dev;
+ struct i40e_hw *hw = &pf->hw;
+ device_t dev = iflib_get_dev(pf->vsi.ctx);
struct i40e_aqc_get_link_status *status =
(struct i40e_aqc_get_link_status *)&e->desc.params.raw;
@@ -2008,8 +1106,7 @@
device_printf(dev, "Link failed because "
"an unqualified module was detected!\n");
- /* Update OS link info */
- ixl_update_link_status(pf);
+ /* OS link info is updated elsewhere */
}
/*********************************************************************
@@ -2024,7 +1121,7 @@
{
struct i40e_hw *hw = &pf->hw;
struct ixl_vsi *vsi = &pf->vsi;
- device_t dev = vsi->dev;
+ device_t dev = iflib_get_dev(vsi->ctx);
struct i40e_aqc_get_switch_config_resp *sw_config;
u8 aq_buf[I40E_AQ_LARGE_BUF];
int ret;
@@ -2069,9 +1166,11 @@
int
ixl_initialize_vsi(struct ixl_vsi *vsi)
{
- struct ixl_pf *pf = vsi->back;
- struct ixl_queue *que = vsi->queues;
- device_t dev = vsi->dev;
+ struct ixl_pf *pf = vsi->back;
+ if_softc_ctx_t scctx = iflib_get_softc_ctx(vsi->ctx);
+ struct ixl_tx_queue *tx_que = vsi->tx_queues;
+ struct ixl_rx_queue *rx_que = vsi->rx_queues;
+ device_t dev = iflib_get_dev(vsi->ctx);
struct i40e_hw *hw = vsi->hw;
struct i40e_vsi_context ctxt;
int tc_queues;
@@ -2110,7 +1209,7 @@
* queue allocation at queue 0, and assign it 2^tc_queues queues (though
* the driver may not use all of them).
*/
- tc_queues = bsrl(pf->qtag.num_allocated);
+ tc_queues = fls(pf->qtag.num_allocated) - 1;
ctxt.info.tc_mapping[0] = ((0 << I40E_AQ_VSI_TC_QUE_OFFSET_SHIFT)
& I40E_AQ_VSI_TC_QUE_OFFSET_MASK) |
((tc_queues << I40E_AQ_VSI_TC_QUE_NUMBER_SHIFT)
@@ -2119,6 +1218,7 @@
/* Set VLAN receive stripping mode */
ctxt.info.valid_sections |= I40E_AQ_VSI_PROP_VLAN_VALID;
ctxt.info.port_vlan_flags = I40E_AQ_VSI_PVLAN_MODE_ALL;
+ // TODO: Call function to get this cap bit, instead
if (vsi->ifp->if_capenable & IFCAP_VLAN_HWTAGGING)
ctxt.info.port_vlan_flags |= I40E_AQ_VSI_PVLAN_EMOD_STR_BOTH;
else
@@ -2150,20 +1250,16 @@
return (err);
}
- for (int i = 0; i < vsi->num_queues; i++, que++) {
- struct tx_ring *txr = &que->txr;
- struct rx_ring *rxr = &que->rxr;
+ for (int i = 0; i < vsi->num_tx_queues; i++, tx_que++) {
+ struct tx_ring *txr = &tx_que->txr;
struct i40e_hmc_obj_txq tctx;
- struct i40e_hmc_obj_rxq rctx;
u32 txctl;
- u16 size;
/* Setup the HMC TX Context */
- size = que->num_tx_desc * sizeof(struct i40e_tx_desc);
bzero(&tctx, sizeof(tctx));
tctx.new_context = 1;
- tctx.base = (txr->dma.pa/IXL_TX_CTX_BASE_UNITS);
- tctx.qlen = que->num_tx_desc;
+ tctx.base = (txr->tx_paddr/IXL_TX_CTX_BASE_UNITS);
+ tctx.qlen = scctx->isc_ntxd[0];
tctx.fc_ena = 0; /* Disable FCoE */
/*
* This value needs to pulled from the VSI that this queue
@@ -2177,8 +1273,11 @@
*/
if (vsi->enable_head_writeback) {
tctx.head_wb_ena = 1;
- tctx.head_wb_addr = txr->dma.pa +
- (que->num_tx_desc * sizeof(struct i40e_tx_desc));
+ tctx.head_wb_addr = txr->tx_paddr +
+ (scctx->isc_ntxd[0] * sizeof(struct i40e_tx_desc));
+ } else {
+ tctx.head_wb_ena = 0;
+ tctx.head_wb_addr = 0;
}
tctx.rdylist_act = 0;
err = i40e_clear_lan_tx_queue_context(hw, i);
@@ -2199,10 +1298,14 @@
ixl_flush(hw);
/* Do ring (re)init */
- ixl_init_tx_ring(que);
+ ixl_init_tx_ring(vsi, tx_que);
+ }
+ for (int i = 0; i < vsi->num_rx_queues; i++, rx_que++) {
+ struct rx_ring *rxr = &rx_que->rxr;
+ struct i40e_hmc_obj_rxq rctx;
/* Next setup the HMC RX Context */
- if (vsi->max_frame_size <= MCLBYTES)
+ if (scctx->isc_max_frame_size <= MCLBYTES)
rxr->mbuf_sz = MCLBYTES;
else
rxr->mbuf_sz = MJUMPAGESIZE;
@@ -2214,18 +1317,18 @@
rctx.dbuff = rxr->mbuf_sz >> I40E_RXQ_CTX_DBUFF_SHIFT;
/* ignore header split for now */
rctx.hbuff = 0 >> I40E_RXQ_CTX_HBUFF_SHIFT;
- rctx.rxmax = (vsi->max_frame_size < max_rxmax) ?
- vsi->max_frame_size : max_rxmax;
+ rctx.rxmax = (scctx->isc_max_frame_size < max_rxmax) ?
+ scctx->isc_max_frame_size : max_rxmax;
rctx.dtype = 0;
rctx.dsize = 1; /* do 32byte descriptors */
rctx.hsplit_0 = 0; /* no header split */
- rctx.base = (rxr->dma.pa/IXL_RX_CTX_BASE_UNITS);
- rctx.qlen = que->num_rx_desc;
+ rctx.base = (rxr->rx_paddr/IXL_RX_CTX_BASE_UNITS);
+ rctx.qlen = scctx->isc_nrxd[0];
rctx.tphrdesc_ena = 1;
rctx.tphwdesc_ena = 1;
rctx.tphdata_ena = 0; /* Header Split related */
rctx.tphhead_ena = 0; /* Header Split related */
- rctx.lrxqthresh = 2; /* Interrupt at <128 desc avail */
+ rctx.lrxqthresh = 1; /* Interrupt at <64 desc avail */
rctx.crcstrip = 1;
rctx.l2tsel = 1;
rctx.showiv = 1; /* Strip inner VLAN header */
@@ -2243,82 +1346,11 @@
device_printf(dev, "Unable to set RX context %d\n", i);
break;
}
- err = ixl_init_rx_ring(que);
- if (err) {
- device_printf(dev, "Fail in init_rx_ring %d\n", i);
- break;
- }
-#ifdef DEV_NETMAP
- /* preserve queue */
- if (vsi->ifp->if_capenable & IFCAP_NETMAP) {
- struct netmap_adapter *na = NA(vsi->ifp);
- struct netmap_kring *kring = na->rx_rings[i];
- int t = na->num_rx_desc - 1 - nm_kr_rxspace(kring);
- wr32(vsi->hw, I40E_QRX_TAIL(que->me), t);
- } else
-#endif /* DEV_NETMAP */
- wr32(vsi->hw, I40E_QRX_TAIL(que->me), que->num_rx_desc - 1);
+ wr32(vsi->hw, I40E_QRX_TAIL(i), 0);
}
return (err);
}
-
-
-
-void
-ixl_vsi_free_queues(struct ixl_vsi *vsi)
-{
- struct ixl_pf *pf = (struct ixl_pf *)vsi->back;
- struct ixl_queue *que = vsi->queues;
-
- if (NULL == vsi->queues)
- return;
-
- for (int i = 0; i < vsi->num_queues; i++, que++) {
- struct tx_ring *txr = &que->txr;
- struct rx_ring *rxr = &que->rxr;
-
- if (!mtx_initialized(&txr->mtx)) /* uninitialized */
- continue;
- IXL_TX_LOCK(txr);
- if (txr->br)
- buf_ring_free(txr->br, M_DEVBUF);
- ixl_free_que_tx(que);
- if (txr->base)
- i40e_free_dma_mem(&pf->hw, &txr->dma);
- IXL_TX_UNLOCK(txr);
- IXL_TX_LOCK_DESTROY(txr);
-
- if (!mtx_initialized(&rxr->mtx)) /* uninitialized */
- continue;
- IXL_RX_LOCK(rxr);
- ixl_free_que_rx(que);
- if (rxr->base)
- i40e_free_dma_mem(&pf->hw, &rxr->dma);
- IXL_RX_UNLOCK(rxr);
- IXL_RX_LOCK_DESTROY(rxr);
- }
-}
-
-
-/*********************************************************************
- *
- * Free all VSI structs.
- *
- **********************************************************************/
-void
-ixl_free_vsi(struct ixl_vsi *vsi)
-{
-
- /* Free station queues */
- ixl_vsi_free_queues(vsi);
- if (vsi->queues)
- free(vsi->queues, M_DEVBUF);
-
- /* Free VSI filter list */
- ixl_free_mac_filters(vsi);
-}
-
void
ixl_free_mac_filters(struct ixl_vsi *vsi)
{
@@ -2331,179 +1363,12 @@
}
}
-/*
- * Fill out fields in queue struct and setup tx/rx memory and structs
- */
-static int
-ixl_vsi_setup_queue(struct ixl_vsi *vsi, struct ixl_queue *que, int index)
-{
- struct ixl_pf *pf = (struct ixl_pf *)vsi->back;
- device_t dev = pf->dev;
- struct i40e_hw *hw = &pf->hw;
- struct tx_ring *txr = &que->txr;
- struct rx_ring *rxr = &que->rxr;
- int error = 0;
- int rsize, tsize;
-
- que->num_tx_desc = vsi->num_tx_desc;
- que->num_rx_desc = vsi->num_rx_desc;
- que->me = index;
- que->vsi = vsi;
-
- txr->que = que;
- txr->tail = I40E_QTX_TAIL(que->me);
-
- /* Initialize the TX lock */
- snprintf(txr->mtx_name, sizeof(txr->mtx_name), "%s:tx(%d)",
- device_get_nameunit(dev), que->me);
- mtx_init(&txr->mtx, txr->mtx_name, NULL, MTX_DEF);
- /*
- * Create the TX descriptor ring
- *
- * In Head Writeback mode, the descriptor ring is one bigger
- * than the number of descriptors for space for the HW to
- * write back index of last completed descriptor.
- */
- if (vsi->enable_head_writeback) {
- tsize = roundup2((que->num_tx_desc *
- sizeof(struct i40e_tx_desc)) +
- sizeof(u32), DBA_ALIGN);
- } else {
- tsize = roundup2((que->num_tx_desc *
- sizeof(struct i40e_tx_desc)), DBA_ALIGN);
- }
- if (i40e_allocate_dma_mem(hw,
- &txr->dma, i40e_mem_reserved, tsize, DBA_ALIGN)) {
- device_printf(dev,
- "Unable to allocate TX Descriptor memory\n");
- error = ENOMEM;
- goto err_destroy_tx_mtx;
- }
- txr->base = (struct i40e_tx_desc *)txr->dma.va;
- bzero((void *)txr->base, tsize);
- /* Now allocate transmit soft structs for the ring */
- if (ixl_allocate_tx_data(que)) {
- device_printf(dev,
- "Critical Failure setting up TX structures\n");
- error = ENOMEM;
- goto err_free_tx_dma;
- }
- /* Allocate a buf ring */
- txr->br = buf_ring_alloc(DEFAULT_TXBRSZ, M_DEVBUF,
- M_NOWAIT, &txr->mtx);
- if (txr->br == NULL) {
- device_printf(dev,
- "Critical Failure setting up TX buf ring\n");
- error = ENOMEM;
- goto err_free_tx_data;
- }
-
- rsize = roundup2(que->num_rx_desc *
- sizeof(union i40e_rx_desc), DBA_ALIGN);
- rxr->que = que;
- rxr->tail = I40E_QRX_TAIL(que->me);
-
- /* Initialize the RX side lock */
- snprintf(rxr->mtx_name, sizeof(rxr->mtx_name), "%s:rx(%d)",
- device_get_nameunit(dev), que->me);
- mtx_init(&rxr->mtx, rxr->mtx_name, NULL, MTX_DEF);
-
- if (i40e_allocate_dma_mem(hw,
- &rxr->dma, i40e_mem_reserved, rsize, 4096)) {
- device_printf(dev,
- "Unable to allocate RX Descriptor memory\n");
- error = ENOMEM;
- goto err_destroy_rx_mtx;
- }
- rxr->base = (union i40e_rx_desc *)rxr->dma.va;
- bzero((void *)rxr->base, rsize);
- /* Allocate receive soft structs for the ring*/
- if (ixl_allocate_rx_data(que)) {
- device_printf(dev,
- "Critical Failure setting up receive structs\n");
- error = ENOMEM;
- goto err_free_rx_dma;
- }
-
- return (0);
-
-err_free_rx_dma:
- i40e_free_dma_mem(&pf->hw, &rxr->dma);
-err_destroy_rx_mtx:
- mtx_destroy(&rxr->mtx);
- /* err_free_tx_buf_ring */
- buf_ring_free(txr->br, M_DEVBUF);
-err_free_tx_data:
- ixl_free_que_tx(que);
-err_free_tx_dma:
- i40e_free_dma_mem(&pf->hw, &txr->dma);
-err_destroy_tx_mtx:
- mtx_destroy(&txr->mtx);
-
- return (error);
-}
-
-int
-ixl_vsi_setup_queues(struct ixl_vsi *vsi)
-{
- struct ixl_queue *que;
- int error = 0;
-
- for (int i = 0; i < vsi->num_queues; i++) {
- que = &vsi->queues[i];
- error = ixl_vsi_setup_queue(vsi, que, i);
- if (error)
- break;
- }
- return (error);
-}
-
-
-/*********************************************************************
- *
- * Allocate memory for the VSI (virtual station interface) and their
- * associated queues, rings and the descriptors associated with each,
- * called only once at attach.
- *
- **********************************************************************/
-int
-ixl_setup_stations(struct ixl_pf *pf)
-{
- device_t dev = pf->dev;
- struct ixl_vsi *vsi;
- int error = 0;
-
- vsi = &pf->vsi;
- vsi->back = (void *)pf;
- vsi->hw = &pf->hw;
- vsi->id = 0;
- vsi->num_vlans = 0;
- vsi->back = pf;
-
- if (pf->msix > 1)
- vsi->flags |= IXL_FLAGS_USES_MSIX;
-
- /* Get memory for the station queues */
- if (!(vsi->queues =
- (struct ixl_queue *) malloc(sizeof(struct ixl_queue) *
- vsi->num_queues, M_DEVBUF, M_NOWAIT | M_ZERO))) {
- device_printf(dev, "Unable to allocate queue memory\n");
- error = ENOMEM;
- goto ixl_setup_stations_err;
- }
-
- /* Then setup each queue */
- error = ixl_vsi_setup_queues(vsi);
-ixl_setup_stations_err:
- return (error);
-}
-
/*
** Provide a update to the queue RX
** interrupt moderation value.
*/
void
-ixl_set_queue_rx_itr(struct ixl_queue *que)
+ixl_set_queue_rx_itr(struct ixl_rx_queue *que)
{
struct ixl_vsi *vsi = que->vsi;
struct ixl_pf *pf = (struct ixl_pf *)vsi->back;
@@ -2554,7 +1419,7 @@
((9 * rx_itr) + rxr->itr);
rxr->itr = min(rx_itr, IXL_MAX_ITR);
wr32(hw, I40E_PFINT_ITRN(IXL_RX_ITR,
- que->me), rxr->itr);
+ rxr->me), rxr->itr);
}
} else { /* We may have have toggled to non-dynamic */
if (vsi->rx_itr_setting & IXL_ITR_DYNAMIC)
@@ -2563,12 +1428,11 @@
if (rxr->itr != vsi->rx_itr_setting) {
rxr->itr = vsi->rx_itr_setting;
wr32(hw, I40E_PFINT_ITRN(IXL_RX_ITR,
- que->me), rxr->itr);
+ rxr->me), rxr->itr);
}
}
rxr->bytes = 0;
rxr->packets = 0;
- return;
}
@@ -2577,7 +1441,7 @@
** interrupt moderation value.
*/
void
-ixl_set_queue_tx_itr(struct ixl_queue *que)
+ixl_set_queue_tx_itr(struct ixl_tx_queue *que)
{
struct ixl_vsi *vsi = que->vsi;
struct ixl_pf *pf = (struct ixl_pf *)vsi->back;
@@ -2628,7 +1492,7 @@
((9 * tx_itr) + txr->itr);
txr->itr = min(tx_itr, IXL_MAX_ITR);
wr32(hw, I40E_PFINT_ITRN(IXL_TX_ITR,
- que->me), txr->itr);
+ txr->me), txr->itr);
}
} else { /* We may have have toggled to non-dynamic */
@@ -2638,7 +1502,7 @@
if (txr->itr != vsi->tx_itr_setting) {
txr->itr = vsi->tx_itr_setting;
wr32(hw, I40E_PFINT_ITRN(IXL_TX_ITR,
- que->me), txr->itr);
+ txr->me), txr->itr);
}
}
txr->bytes = 0;
@@ -2669,17 +1533,17 @@
* Retrieves I40E_QTX_TAIL value from hardware
* for a sysctl.
*/
-static int
+int
ixl_sysctl_qtx_tail_handler(SYSCTL_HANDLER_ARGS)
{
- struct ixl_queue *que;
+ struct ixl_tx_queue *tx_que;
int error;
u32 val;
- que = ((struct ixl_queue *)oidp->oid_arg1);
- if (!que) return 0;
+ tx_que = ((struct ixl_tx_queue *)oidp->oid_arg1);
+ if (!tx_que) return 0;
- val = rd32(que->vsi->hw, que->txr.tail);
+ val = rd32(tx_que->vsi->hw, tx_que->txr.tail);
error = sysctl_handle_int(oidp, &val, 0, req);
if (error || !req->newptr)
return error;
@@ -2691,17 +1555,17 @@
* Retrieves I40E_QRX_TAIL value from hardware
* for a sysctl.
*/
-static int
+int
ixl_sysctl_qrx_tail_handler(SYSCTL_HANDLER_ARGS)
{
- struct ixl_queue *que;
+ struct ixl_rx_queue *rx_que;
int error;
u32 val;
- que = ((struct ixl_queue *)oidp->oid_arg1);
- if (!que) return 0;
+ rx_que = ((struct ixl_rx_queue *)oidp->oid_arg1);
+ if (!rx_que) return 0;
- val = rd32(que->vsi->hw, que->rxr.tail);
+ val = rd32(rx_que->vsi->hw, rx_que->rxr.tail);
error = sysctl_handle_int(oidp, &val, 0, req);
if (error || !req->newptr)
return error;
@@ -2780,22 +1644,21 @@
void
ixl_add_hw_stats(struct ixl_pf *pf)
{
- device_t dev = pf->dev;
struct ixl_vsi *vsi = &pf->vsi;
- struct ixl_queue *queues = vsi->queues;
+ device_t dev = iflib_get_dev(vsi->ctx);
struct i40e_hw_port_stats *pf_stats = &pf->stats;
struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(dev);
struct sysctl_oid *tree = device_get_sysctl_tree(dev);
struct sysctl_oid_list *child = SYSCTL_CHILDREN(tree);
- struct sysctl_oid_list *vsi_list;
-
+ struct sysctl_oid_list *vsi_list, *queue_list;
struct sysctl_oid *queue_node;
- struct sysctl_oid_list *queue_list;
+ char queue_namebuf[32];
+ struct ixl_rx_queue *rx_que;
+ struct ixl_tx_queue *tx_que;
struct tx_ring *txr;
struct rx_ring *rxr;
- char queue_namebuf[QUEUE_NAME_LEN];
/* Driver statistics */
SYSCTL_ADD_UQUAD(ctx, child, OID_AUTO, "watchdog_events",
@@ -2809,81 +1672,68 @@
vsi_list = SYSCTL_CHILDREN(pf->vsi.vsi_node);
/* Queue statistics */
- for (int q = 0; q < vsi->num_queues; q++) {
- snprintf(queue_namebuf, QUEUE_NAME_LEN, "que%d", q);
+ for (int q = 0; q < vsi->num_rx_queues; q++) {
+ snprintf(queue_namebuf, QUEUE_NAME_LEN, "rxq%02d", q);
queue_node = SYSCTL_ADD_NODE(ctx, vsi_list,
- OID_AUTO, queue_namebuf, CTLFLAG_RD, NULL, "Queue #");
+ OID_AUTO, queue_namebuf, CTLFLAG_RD, NULL, "RX Queue #");
queue_list = SYSCTL_CHILDREN(queue_node);
- txr = &(queues[q].txr);
- rxr = &(queues[q].rxr);
+ rx_que = &(vsi->rx_queues[q]);
+ rxr = &(rx_que->rxr);
+
- SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "mbuf_defrag_failed",
- CTLFLAG_RD, &(queues[q].mbuf_defrag_failed),
- "m_defrag() failed");
SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "irqs",
- CTLFLAG_RD, &(queues[q].irqs),
- "irqs on this queue");
- SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "tso_tx",
- CTLFLAG_RD, &(queues[q].tso),
- "TSO");
- SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "tx_dmamap_failed",
- CTLFLAG_RD, &(queues[q].tx_dmamap_failed),
- "Driver tx dma failure in xmit");
- SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "mss_too_small",
- CTLFLAG_RD, &(queues[q].mss_too_small),
- "TSO sends with an MSS less than 64");
- SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "no_desc_avail",
- CTLFLAG_RD, &(txr->no_desc),
- "Queue No Descriptor Available");
- SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "tx_packets",
- CTLFLAG_RD, &(txr->total_packets),
- "Queue Packets Transmitted");
- SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "tx_bytes",
- CTLFLAG_RD, &(txr->tx_bytes),
- "Queue Bytes Transmitted");
- SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "rx_packets",
+ CTLFLAG_RD, &(rx_que->irqs),
+ "irqs on this queue (both Tx and Rx)");
+
+ SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "packets",
CTLFLAG_RD, &(rxr->rx_packets),
"Queue Packets Received");
- SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "rx_bytes",
+ SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "bytes",
CTLFLAG_RD, &(rxr->rx_bytes),
"Queue Bytes Received");
- SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "rx_desc_err",
+ SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "desc_err",
CTLFLAG_RD, &(rxr->desc_errs),
"Queue Rx Descriptor Errors");
- SYSCTL_ADD_UINT(ctx, queue_list, OID_AUTO, "rx_itr",
+ SYSCTL_ADD_UINT(ctx, queue_list, OID_AUTO, "itr",
CTLFLAG_RD, &(rxr->itr), 0,
"Queue Rx ITR Interval");
- SYSCTL_ADD_UINT(ctx, queue_list, OID_AUTO, "tx_itr",
- CTLFLAG_RD, &(txr->itr), 0,
- "Queue Tx ITR Interval");
#ifdef IXL_DEBUG
- SYSCTL_ADD_INT(ctx, queue_list, OID_AUTO, "txr_watchdog",
- CTLFLAG_RD, &(txr->watchdog_timer), 0,
- "Ticks before watchdog timer causes interface reinit");
- SYSCTL_ADD_U16(ctx, queue_list, OID_AUTO, "tx_next_avail",
- CTLFLAG_RD, &(txr->next_avail), 0,
- "Next TX descriptor to be used");
- SYSCTL_ADD_U16(ctx, queue_list, OID_AUTO, "tx_next_to_clean",
- CTLFLAG_RD, &(txr->next_to_clean), 0,
- "Next TX descriptor to be cleaned");
- SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "rx_not_done",
- CTLFLAG_RD, &(rxr->not_done),
- "Queue Rx Descriptors not Done");
- SYSCTL_ADD_UINT(ctx, queue_list, OID_AUTO, "rx_next_refresh",
- CTLFLAG_RD, &(rxr->next_refresh), 0,
- "Queue Rx Descriptors not Done");
- SYSCTL_ADD_UINT(ctx, queue_list, OID_AUTO, "rx_next_check",
- CTLFLAG_RD, &(rxr->next_check), 0,
- "Queue Rx Descriptors not Done");
SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "qrx_tail",
- CTLTYPE_UINT | CTLFLAG_RD, &queues[q],
- sizeof(struct ixl_queue),
+ CTLTYPE_UINT | CTLFLAG_RD, rx_que,
+ sizeof(struct ixl_rx_queue),
ixl_sysctl_qrx_tail_handler, "IU",
"Queue Receive Descriptor Tail");
+#endif
+ }
+ for (int q = 0; q < vsi->num_tx_queues; q++) {
+ snprintf(queue_namebuf, QUEUE_NAME_LEN, "txq%02d", q);
+ queue_node = SYSCTL_ADD_NODE(ctx, vsi_list,
+ OID_AUTO, queue_namebuf, CTLFLAG_RD, NULL, "TX Queue #");
+ queue_list = SYSCTL_CHILDREN(queue_node);
+
+ tx_que = &(vsi->tx_queues[q]);
+ txr = &(tx_que->txr);
+
+ SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "tso",
+ CTLFLAG_RD, &(tx_que->tso),
+ "TSO");
+ SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "mss_too_small",
+ CTLFLAG_RD, &(txr->mss_too_small),
+ "TSO sends with an MSS less than 64");
+ SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "packets",
+ CTLFLAG_RD, &(txr->tx_packets),
+ "Queue Packets Transmitted");
+ SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "bytes",
+ CTLFLAG_RD, &(txr->tx_bytes),
+ "Queue Bytes Transmitted");
+ SYSCTL_ADD_UINT(ctx, queue_list, OID_AUTO, "itr",
+ CTLFLAG_RD, &(txr->itr), 0,
+ "Queue Tx ITR Interval");
+#ifdef IXL_DEBUG
SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "qtx_tail",
- CTLTYPE_UINT | CTLFLAG_RD, &queues[q],
- sizeof(struct ixl_queue),
+ CTLTYPE_UINT | CTLFLAG_RD, tx_que,
+ sizeof(struct ixl_tx_queue),
ixl_sysctl_qtx_tail_handler, "IU",
"Queue Transmit Descriptor Tail");
#endif
@@ -3063,8 +1913,8 @@
ixl_set_rss_hlut(struct ixl_pf *pf)
{
struct i40e_hw *hw = &pf->hw;
- device_t dev = pf->dev;
struct ixl_vsi *vsi = &pf->vsi;
+ device_t dev = iflib_get_dev(vsi->ctx);
int i, que_id;
int lut_entry_width;
u32 lut = 0;
@@ -3082,9 +1932,9 @@
* num_queues.)
*/
que_id = rss_get_indirection_to_bucket(i);
- que_id = que_id % vsi->num_queues;
+ que_id = que_id % vsi->num_rx_queues;
#else
- que_id = i % vsi->num_queues;
+ que_id = i % vsi->num_rx_queues;
#endif
lut = (que_id & ((0x1 << lut_entry_width) - 1));
hlut_buf[i] = lut;
@@ -3113,56 +1963,6 @@
ixl_set_rss_hlut(pf);
}
-/*
-** This routine is run via an vlan config EVENT,
-** it enables us to use the HW Filter table since
-** we can get the vlan id. This just creates the
-** entry in the soft version of the VFTA, init will
-** repopulate the real table.
-*/
-void
-ixl_register_vlan(void *arg, struct ifnet *ifp, u16 vtag)
-{
- struct ixl_vsi *vsi = ifp->if_softc;
- struct i40e_hw *hw = vsi->hw;
- struct ixl_pf *pf = (struct ixl_pf *)vsi->back;
-
- if (ifp->if_softc != arg) /* Not our event */
- return;
-
- if ((vtag == 0) || (vtag > 4095)) /* Invalid */
- return;
-
- IXL_PF_LOCK(pf);
- ++vsi->num_vlans;
- ixl_add_filter(vsi, hw->mac.addr, vtag);
- IXL_PF_UNLOCK(pf);
-}
-
-/*
-** This routine is run via an vlan
-** unconfig EVENT, remove our entry
-** in the soft vfta.
-*/
-void
-ixl_unregister_vlan(void *arg, struct ifnet *ifp, u16 vtag)
-{
- struct ixl_vsi *vsi = ifp->if_softc;
- struct i40e_hw *hw = vsi->hw;
- struct ixl_pf *pf = (struct ixl_pf *)vsi->back;
-
- if (ifp->if_softc != arg)
- return;
-
- if ((vtag == 0) || (vtag > 4095)) /* Invalid */
- return;
-
- IXL_PF_LOCK(pf);
- --vsi->num_vlans;
- ixl_del_filter(vsi, hw->mac.addr, vtag);
- IXL_PF_UNLOCK(pf);
-}
-
/*
** This routine updates vlan filters, called by init
** it scans the filter table and then updates the hw
@@ -3196,7 +1996,6 @@
flags = IXL_FILTER_VLAN;
flags |= (IXL_FILTER_ADD | IXL_FILTER_USED);
ixl_add_hw_filters(vsi, flags, cnt);
- return;
}
/*
@@ -3210,8 +2009,8 @@
{
struct ixl_pf *pf = (struct ixl_pf *)vsi->back;
- /* Add broadcast address */
- ixl_add_filter(vsi, ixl_bcast_addr, IXL_VLAN_ANY);
+ /* Receive broadcast Ethernet frames */
+ i40e_aq_set_vsi_broadcast(&pf->hw, vsi->seid, TRUE, NULL);
/*
* Prevent Tx flow control frames from being sent out by
@@ -3235,15 +2034,11 @@
if (f != NULL)
return;
- f = ixl_get_filter(vsi);
- if (f == NULL) {
+ f = ixl_new_filter(vsi, macaddr, IXL_VLAN_ANY);
+ if (f != NULL)
+ f->flags |= IXL_FILTER_MC;
+ else
printf("WARNING: no filter available!!\n");
- return;
- }
- bcopy(macaddr, f->macaddr, ETHER_ADDR_LEN);
- f->vlan = IXL_VLAN_ANY;
- f->flags |= (IXL_FILTER_ADD | IXL_FILTER_USED
- | IXL_FILTER_MC);
return;
}
@@ -3286,14 +2081,11 @@
}
}
- f = ixl_get_filter(vsi);
+ f = ixl_new_filter(vsi, macaddr, vlan);
if (f == NULL) {
device_printf(dev, "WARNING: no filter available!!\n");
return;
}
- bcopy(macaddr, f->macaddr, ETHER_ADDR_LEN);
- f->vlan = vlan;
- f->flags |= (IXL_FILTER_ADD | IXL_FILTER_USED);
if (f->vlan != IXL_VLAN_ANY)
f->flags |= IXL_FILTER_VLAN;
else
@@ -3332,20 +2124,15 @@
ixl_find_filter(struct ixl_vsi *vsi, const u8 *macaddr, s16 vlan)
{
struct ixl_mac_filter *f;
- bool match = FALSE;
SLIST_FOREACH(f, &vsi->ftl, next) {
- if (!cmp_etheraddr(f->macaddr, macaddr))
- continue;
- if (f->vlan == vlan) {
- match = TRUE;
- break;
+ if ((cmp_etheraddr(f->macaddr, macaddr) != 0)
+ && (f->vlan == vlan)) {
+ return (f);
}
}
- if (!match)
- f = NULL;
- return (f);
+ return (NULL);
}
/*
@@ -3361,12 +2148,12 @@
struct ixl_pf *pf;
struct i40e_hw *hw;
device_t dev;
- int err, j = 0;
+ enum i40e_status_code status;
+ int j = 0;
pf = vsi->back;
- dev = pf->dev;
+ dev = iflib_get_dev(vsi->ctx);
hw = &pf->hw;
- IXL_PF_LOCK_ASSERT(pf);
a = malloc(sizeof(struct i40e_aqc_add_macvlan_element_data) * cnt,
M_DEVBUF, M_NOWAIT | M_ZERO);
@@ -3399,10 +2186,11 @@
break;
}
if (j > 0) {
- err = i40e_aq_add_macvlan(hw, vsi->seid, a, j, NULL);
- if (err)
- device_printf(dev, "aq_add_macvlan err %d, "
- "aq_error %d\n", err, hw->aq.asq_last_status);
+ status = i40e_aq_add_macvlan(hw, vsi->seid, a, j, NULL);
+ if (status)
+ device_printf(dev, "i40e_aq_add_macvlan status %s, "
+ "error %s\n", i40e_stat_str(hw, status),
+ i40e_aq_str(hw, hw->aq.asq_last_status));
else
vsi->hw_filters_add += j;
}
@@ -3423,18 +2211,17 @@
struct i40e_hw *hw;
device_t dev;
struct ixl_mac_filter *f, *f_temp;
- int err, j = 0;
-
- DEBUGOUT("ixl_del_hw_filters: begin\n");
+ enum i40e_status_code status;
+ int j = 0;
pf = vsi->back;
hw = &pf->hw;
- dev = pf->dev;
+ dev = iflib_get_dev(vsi->ctx);
d = malloc(sizeof(struct i40e_aqc_remove_macvlan_element_data) * cnt,
M_DEVBUF, M_NOWAIT | M_ZERO);
if (d == NULL) {
- printf("del hw filter failed to get memory\n");
+ device_printf(dev, "%s: failed to get memory\n", __func__);
return;
}
@@ -3458,21 +2245,19 @@
break;
}
if (j > 0) {
- err = i40e_aq_remove_macvlan(hw, vsi->seid, d, j, NULL);
- if (err && hw->aq.asq_last_status != I40E_AQ_RC_ENOENT) {
+ status = i40e_aq_remove_macvlan(hw, vsi->seid, d, j, NULL);
+ if (status) {
int sc = 0;
for (int i = 0; i < j; i++)
sc += (!d[i].error_code);
vsi->hw_filters_del += sc;
device_printf(dev,
- "Failed to remove %d/%d filters, aq error %d\n",
- j - sc, j, hw->aq.asq_last_status);
+ "Failed to remove %d/%d filters, error %s\n",
+ j - sc, j, i40e_aq_str(hw, hw->aq.asq_last_status));
} else
vsi->hw_filters_del += j;
}
free(d, M_DEVBUF);
-
- DEBUGOUT("ixl_del_hw_filters: end\n");
return;
}
@@ -3566,11 +2351,11 @@
struct ixl_pf *pf = vsi->back;
int error = 0;
- for (int i = 0; i < vsi->num_queues; i++) {
- error = ixl_enable_ring(pf, &pf->qtag, i);
- if (error)
- return (error);
- }
+ for (int i = 0; i < vsi->num_tx_queues; i++)
+ error = ixl_enable_tx_ring(pf, &pf->qtag, i);
+
+ for (int i = 0; i < vsi->num_rx_queues; i++)
+ error = ixl_enable_rx_ring(pf, &pf->qtag, i);
return (error);
}
@@ -3662,11 +2447,11 @@
struct ixl_pf *pf = vsi->back;
int error = 0;
- for (int i = 0; i < vsi->num_queues; i++) {
- error = ixl_disable_ring(pf, &pf->qtag, i);
- if (error)
- return (error);
- }
+ for (int i = 0; i < vsi->num_tx_queues; i++)
+ error = ixl_disable_tx_ring(pf, &pf->qtag, i);
+
+ for (int i = 0; i < vsi->num_rx_queues; i++)
+ error = ixl_disable_rx_ring(pf, &pf->qtag, i);
return (error);
}
@@ -3682,8 +2467,10 @@
{
struct i40e_hw *hw = &pf->hw;
device_t dev = pf->dev;
+ struct ixl_vf *vf;
bool mdd_detected = false;
bool pf_mdd_detected = false;
+ bool vf_mdd_detected = false;
u32 reg;
/* find what triggered the MDD event */
@@ -3735,6 +2522,39 @@
}
}
+ if (pf_mdd_detected) {
+ atomic_set_32(&pf->state, IXL_PF_STATE_PF_RESET_REQ);
+ goto end;
+ }
+
+ // Handle VF detection
+ for (int i = 0; i < pf->num_vfs && mdd_detected; i++) {
+ vf = &(pf->vfs[i]);
+ reg = rd32(hw, I40E_VP_MDET_TX(i));
+ if (reg & I40E_VP_MDET_TX_VALID_MASK) {
+ wr32(hw, I40E_VP_MDET_TX(i), 0xFFFF);
+ vf->num_mdd_events++;
+ device_printf(dev, "MDD TX event is for VF %d\n", i);
+ vf_mdd_detected = true;
+ }
+
+ reg = rd32(hw, I40E_VP_MDET_RX(i));
+ if (reg & I40E_VP_MDET_RX_VALID_MASK) {
+ wr32(hw, I40E_VP_MDET_RX(i), 0xFFFF);
+ vf->num_mdd_events++;
+ device_printf(dev, "MDD RX event is for VF %d\n", i);
+ vf_mdd_detected = true;
+ }
+
+ // TODO: Disable VF if there are too many MDD events from it
+ }
+
+ if (vf_mdd_detected)
+ atomic_set_32(&pf->state, IXL_PF_STATE_VF_RESET_REQ);
+
+end:
+ atomic_clear_32(&pf->state, IXL_PF_STATE_MDD_PENDING);
+
/* re-enable mdd interrupt cause */
reg = rd32(hw, I40E_PFINT_ICR0_ENA);
reg |= I40E_PFINT_ICR0_ENA_MAL_DETECT_MASK;
@@ -3742,16 +2562,17 @@
ixl_flush(hw);
}
+/* This only enables HW interrupts for the RX queues */
void
ixl_enable_intr(struct ixl_vsi *vsi)
{
- struct ixl_pf *pf = (struct ixl_pf *)vsi->back;
struct i40e_hw *hw = vsi->hw;
- struct ixl_queue *que = vsi->queues;
+ struct ixl_rx_queue *que = vsi->rx_queues;
- if (pf->msix > 1) {
- for (int i = 0; i < vsi->num_queues; i++, que++)
- ixl_enable_queue(hw, que->me);
+ // TODO: Check iflib interrupt mode instead?
+ if (vsi->shared->isc_intr == IFLIB_INTR_MSIX) {
+ for (int i = 0; i < vsi->num_rx_queues; i++, que++)
+ ixl_enable_queue(hw, que->rxr.me);
} else
ixl_enable_intr0(hw);
}
@@ -3760,10 +2581,10 @@
ixl_disable_rings_intr(struct ixl_vsi *vsi)
{
struct i40e_hw *hw = vsi->hw;
- struct ixl_queue *que = vsi->queues;
+ struct ixl_rx_queue *que = vsi->rx_queues;
- for (int i = 0; i < vsi->num_queues; i++, que++)
- ixl_disable_queue(hw, que->me);
+ for (int i = 0; i < vsi->num_rx_queues; i++, que++)
+ ixl_disable_queue(hw, que->rxr.me);
}
void
@@ -3988,39 +2809,22 @@
ixl_prepare_for_reset(struct ixl_pf *pf, bool is_up)
{
struct i40e_hw *hw = &pf->hw;
- struct ixl_vsi *vsi = &pf->vsi;
device_t dev = pf->dev;
int error = 0;
- /* Teardown */
- if (is_up)
- ixl_stop(pf);
-
- ixl_teardown_queue_msix(vsi);
-
error = i40e_shutdown_lan_hmc(hw);
if (error)
device_printf(dev,
"Shutdown LAN HMC failed with code %d\n", error);
ixl_disable_intr0(hw);
- ixl_teardown_adminq_msix(pf);
error = i40e_shutdown_adminq(hw);
if (error)
device_printf(dev,
"Shutdown Admin queue failed with code %d\n", error);
- callout_drain(&pf->timer);
-
- /* Free ring buffers, locks and filters */
- ixl_vsi_free_queues(vsi);
-
- /* Free VSI filter list */
- ixl_free_mac_filters(vsi);
-
ixl_pf_qmgr_release(&pf->qmgr, &pf->qtag);
-
return (error);
}
@@ -4071,16 +2875,13 @@
}
/* reserve a contiguous allocation for the PF's VSI */
- error = ixl_pf_qmgr_alloc_contiguous(&pf->qmgr, vsi->num_queues, &pf->qtag);
+ error = ixl_pf_qmgr_alloc_contiguous(&pf->qmgr, vsi->num_tx_queues, &pf->qtag);
if (error) {
device_printf(dev, "Failed to reserve queues for PF LAN VSI, error %d\n",
error);
/* TODO: error handling */
}
- device_printf(dev, "Allocating %d queues for PF LAN VSI; %d queues active\n",
- pf->qtag.num_allocated, pf->qtag.num_active);
-
error = ixl_switch_config(pf);
if (error) {
device_printf(dev, "ixl_rebuild_hw_structs_after_reset: ixl_switch_config() failed: %d\n",
@@ -4088,38 +2889,6 @@
goto ixl_rebuild_hw_structs_after_reset_err;
}
- if (ixl_vsi_setup_queues(vsi)) {
- device_printf(dev, "setup queues failed!\n");
- error = ENOMEM;
- goto ixl_rebuild_hw_structs_after_reset_err;
- }
-
- if (pf->msix > 1) {
- error = ixl_setup_adminq_msix(pf);
- if (error) {
- device_printf(dev, "ixl_setup_adminq_msix() error: %d\n",
- error);
- goto ixl_rebuild_hw_structs_after_reset_err;
- }
-
- ixl_configure_intr0_msix(pf);
- ixl_enable_intr0(hw);
-
- error = ixl_setup_queue_msix(vsi);
- if (error) {
- device_printf(dev, "ixl_setup_queue_msix() error: %d\n",
- error);
- goto ixl_rebuild_hw_structs_after_reset_err;
- }
- } else {
- error = ixl_setup_legacy(pf);
- if (error) {
- device_printf(dev, "ixl_setup_legacy() error: %d\n",
- error);
- goto ixl_rebuild_hw_structs_after_reset_err;
- }
- }
-
/* Determine link state */
if (ixl_attach_get_link_status(pf)) {
error = EINVAL;
@@ -4129,8 +2898,11 @@
i40e_aq_set_dcb_parameters(hw, TRUE, NULL);
ixl_get_fw_lldp_status(pf);
- if (is_up)
- ixl_init(pf);
+ /* Keep admin queue interrupts active while driver is loaded */
+ if (vsi->shared->isc_intr == IFLIB_INTR_MSIX) {
+ ixl_configure_intr0_msix(pf);
+ ixl_enable_intr0(hw);
+ }
device_printf(dev, "Rebuilding driver state done.\n");
return (0);
@@ -4161,81 +2933,11 @@
break;
}
ixl_dbg(pf, IXL_DBG_INFO,
- "EMPR reset wait count: %d\n", count);
+ "Reset wait count: %d\n", count);
ixl_rebuild_hw_structs_after_reset(pf, is_up);
- atomic_clear_int(&pf->state, IXL_PF_STATE_EMPR_RESETTING);
-}
-
-/*
-** Tasklet handler for MSIX Adminq interrupts
-** - do outside interrupt since it might sleep
-*/
-void
-ixl_do_adminq(void *context, int pending)
-{
- struct ixl_pf *pf = context;
- struct i40e_hw *hw = &pf->hw;
- struct i40e_arq_event_info event;
- i40e_status ret;
- device_t dev = pf->dev;
- u32 loop = 0;
- u16 opcode, result;
-
- if (pf->state & IXL_PF_STATE_EMPR_RESETTING) {
- /* Flag cleared at end of this function */
- ixl_handle_empr_reset(pf);
- return;
- }
-
- /* Admin Queue handling */
- event.buf_len = IXL_AQ_BUF_SZ;
- event.msg_buf = malloc(event.buf_len,
- M_DEVBUF, M_NOWAIT | M_ZERO);
- if (!event.msg_buf) {
- device_printf(dev, "%s: Unable to allocate memory for Admin"
- " Queue event!\n", __func__);
- return;
- }
-
- IXL_PF_LOCK(pf);
- /* clean and process any events */
- do {
- ret = i40e_clean_arq_element(hw, &event, &result);
- if (ret)
- break;
- opcode = LE16_TO_CPU(event.desc.opcode);
- ixl_dbg(pf, IXL_DBG_AQ,
- "Admin Queue event: %#06x\n", opcode);
- switch (opcode) {
- case i40e_aqc_opc_get_link_status:
- ixl_link_event(pf, &event);
- break;
- case i40e_aqc_opc_send_msg_to_pf:
-#ifdef PCI_IOV
- ixl_handle_vf_msg(pf, &event);
-#endif
- break;
- case i40e_aqc_opc_event_lan_overflow:
- default:
- break;
- }
-
- } while (result && (loop++ < IXL_ADM_LIMIT));
-
- free(event.msg_buf, M_DEVBUF);
-
- /*
- * If there are still messages to process, reschedule ourselves.
- * Otherwise, re-enable our interrupt.
- */
- if (result > 0)
- taskqueue_enqueue(pf->tq, &pf->adminq);
- else
- ixl_enable_intr0(hw);
-
- IXL_PF_UNLOCK(pf);
+ atomic_clear_int(&pf->state, IXL_PF_STATE_ADAPTER_RESETTING);
}
/**
@@ -4317,8 +3019,6 @@
ixl_update_eth_stats(vsi);
tx_discards = es->tx_discards + nsd->tx_dropped_link_down;
- for (int i = 0; i < vsi->num_queues; i++)
- tx_discards += vsi->queues[i].txr.br->br_drops;
/* Update ifnet stats */
IXL_SET_IPACKETS(vsi, es->rx_unicast +
@@ -4476,14 +3176,6 @@
OID_AUTO, "dynamic_tx_itr", CTLFLAG_RW,
&pf->dynamic_tx_itr, 0, "Enable dynamic TX ITR");
- SYSCTL_ADD_INT(ctx, ctx_list,
- OID_AUTO, "tx_ring_size", CTLFLAG_RD,
- &pf->vsi.num_tx_desc, 0, "TX ring size");
-
- SYSCTL_ADD_INT(ctx, ctx_list,
- OID_AUTO, "rx_ring_size", CTLFLAG_RD,
- &pf->vsi.num_rx_desc, 0, "RX ring size");
-
/* Add FEC sysctls for 25G adapters */
if (i40e_is_25G_device(hw->device_id)) {
fec_node = SYSCTL_ADD_NODE(ctx, ctx_list,
@@ -4527,7 +3219,7 @@
SYSCTL_ADD_UINT(ctx, debug_list,
OID_AUTO, "core_debug_mask", CTLFLAG_RW,
- &pf->dbg_mask, 0, "Non-hared code debug message level");
+ &pf->dbg_mask, 0, "Non-shared code debug message level");
SYSCTL_ADD_PROC(ctx, debug_list,
OID_AUTO, "link_status", CTLTYPE_STRING | CTLFLAG_RD,
@@ -4569,14 +3261,39 @@
OID_AUTO, "dump_debug_data", CTLTYPE_STRING | CTLFLAG_RD,
pf, 0, ixl_sysctl_dump_debug_data, "A", "Dump Debug Data from FW");
+ SYSCTL_ADD_PROC(ctx, debug_list,
+ OID_AUTO, "do_pf_reset", CTLTYPE_INT | CTLFLAG_WR,
+ pf, 0, ixl_sysctl_do_pf_reset, "I", "Tell HW to initiate a PF reset");
+
+ SYSCTL_ADD_PROC(ctx, debug_list,
+ OID_AUTO, "do_core_reset", CTLTYPE_INT | CTLFLAG_WR,
+ pf, 0, ixl_sysctl_do_core_reset, "I", "Tell HW to initiate a CORE reset");
+
+ SYSCTL_ADD_PROC(ctx, debug_list,
+ OID_AUTO, "do_global_reset", CTLTYPE_INT | CTLFLAG_WR,
+ pf, 0, ixl_sysctl_do_global_reset, "I", "Tell HW to initiate a GLOBAL reset");
+
+ SYSCTL_ADD_PROC(ctx, debug_list,
+ OID_AUTO, "do_emp_reset", CTLTYPE_INT | CTLFLAG_WR,
+ pf, 0, ixl_sysctl_do_emp_reset, "I",
+ "(This doesn't work) Tell HW to initiate a EMP (entire firmware) reset");
+
+ SYSCTL_ADD_PROC(ctx, debug_list,
+ OID_AUTO, "queue_interrupt_table", CTLTYPE_STRING | CTLFLAG_RD,
+ pf, 0, ixl_sysctl_queue_interrupt_table, "A", "View MSI-X indices for TX/RX queues");
+
if (pf->has_i2c) {
SYSCTL_ADD_PROC(ctx, debug_list,
OID_AUTO, "read_i2c_byte", CTLTYPE_INT | CTLFLAG_RW,
- pf, 0, ixl_sysctl_read_i2c_byte, "I", "Read byte from I2C bus");
+ pf, 0, ixl_sysctl_read_i2c_byte, "I", IXL_SYSCTL_HELP_READ_I2C);
SYSCTL_ADD_PROC(ctx, debug_list,
OID_AUTO, "write_i2c_byte", CTLTYPE_INT | CTLFLAG_RW,
- pf, 0, ixl_sysctl_write_i2c_byte, "I", "Write byte to I2C bus");
+ pf, 0, ixl_sysctl_write_i2c_byte, "I", IXL_SYSCTL_HELP_WRITE_I2C);
+
+ SYSCTL_ADD_PROC(ctx, debug_list,
+ OID_AUTO, "read_i2c_diag_data", CTLTYPE_STRING | CTLFLAG_RD,
+ pf, 0, ixl_sysctl_read_i2c_diag_data, "A", "Dump selected diagnostic data from FW");
}
#ifdef PCI_IOV
@@ -4596,9 +3313,9 @@
struct ixl_pf *pf = (struct ixl_pf *)arg1;
int queues;
- IXL_PF_LOCK(pf);
+ //IXL_PF_LOCK(pf);
queues = (int)ixl_pf_qmgr_get_num_free(&pf->qmgr);
- IXL_PF_UNLOCK(pf);
+ //IXL_PF_UNLOCK(pf);
return sysctl_handle_int(oidp, NULL, queues, req);
}
@@ -4642,11 +3359,6 @@
}
pf->fc = requested_fc;
- /* Get new link state */
- i40e_msec_delay(250);
- hw->phy.get_link_info = TRUE;
- i40e_get_link_status(hw, &pf->link_up);
-
return (0);
}
@@ -4848,34 +3560,11 @@
error = ixl_set_advertised_speeds(pf, requested_ls, false);
if (error)
- return (error);
-
- pf->advertised_speed = requested_ls;
- ixl_update_link_status(pf);
- return (0);
-}
-
-/*
- * Input: bitmap of enum i40e_aq_link_speed
- */
-static u64
-ixl_max_aq_speed_to_value(u8 link_speeds)
-{
- if (link_speeds & I40E_LINK_SPEED_40GB)
- return IF_Gbps(40);
- if (link_speeds & I40E_LINK_SPEED_25GB)
- return IF_Gbps(25);
- if (link_speeds & I40E_LINK_SPEED_20GB)
- return IF_Gbps(20);
- if (link_speeds & I40E_LINK_SPEED_10GB)
- return IF_Gbps(10);
- if (link_speeds & I40E_LINK_SPEED_1GB)
- return IF_Gbps(1);
- if (link_speeds & I40E_LINK_SPEED_100MB)
- return IF_Mbps(100);
- else
- /* Minimum supported link speed */
- return IF_Mbps(100);
+ return (error);
+
+ pf->advertised_speed = requested_ls;
+ ixl_update_link_status(pf);
+ return (0);
}
/*
@@ -4960,7 +3649,7 @@
// device_printf(dev, "- Get Driver Status Command\n");
}
else if (nvma->command == I40E_NVM_READ) {
-
+
}
else {
switch (nvma->command) {
@@ -5010,19 +3699,20 @@
if (pf->dbg_mask & IXL_DBG_NVMUPD)
ixl_print_nvm_cmd(dev, nvma);
- if (pf->state & IXL_PF_STATE_EMPR_RESETTING) {
+ if (pf->state & IXL_PF_STATE_ADAPTER_RESETTING) {
int count = 0;
while (count++ < 100) {
i40e_msec_delay(100);
- if (!(pf->state & IXL_PF_STATE_EMPR_RESETTING))
+ if (!(pf->state & IXL_PF_STATE_ADAPTER_RESETTING))
break;
}
}
- if (!(pf->state & IXL_PF_STATE_EMPR_RESETTING)) {
- IXL_PF_LOCK(pf);
+ if (!(pf->state & IXL_PF_STATE_ADAPTER_RESETTING)) {
+ // TODO: Might need a different lock here
+ // IXL_PF_LOCK(pf);
status = i40e_nvmupd_command(hw, nvma, nvma->data, &perrno);
- IXL_PF_UNLOCK(pf);
+ // IXL_PF_UNLOCK(pf);
} else {
perrno = -EBUSY;
}
@@ -5042,389 +3732,6 @@
return (perrno);
}
-/*********************************************************************
- *
- * Media Ioctl callback
- *
- * This routine is called whenever the user queries the status of
- * the interface using ifconfig.
- *
- * When adding new media types here, make sure to add them to
- * ixl_add_ifmedia(), too.
- *
- **********************************************************************/
-void
-ixl_media_status(struct ifnet * ifp, struct ifmediareq * ifmr)
-{
- struct ixl_vsi *vsi = ifp->if_softc;
- struct ixl_pf *pf = vsi->back;
- struct i40e_hw *hw = &pf->hw;
-
- INIT_DEBUGOUT("ixl_media_status: begin");
-
- /* Don't touch PF during reset */
- if (atomic_load_acq_int(&pf->state) & IXL_PF_STATE_EMPR_RESETTING)
- return;
-
- IXL_PF_LOCK(pf);
-
- i40e_get_link_status(hw, &pf->link_up);
- ixl_update_link_status(pf);
-
- ifmr->ifm_status = IFM_AVALID;
- ifmr->ifm_active = IFM_ETHER;
-
- if (!pf->link_up) {
- IXL_PF_UNLOCK(pf);
- return;
- }
-
- ifmr->ifm_status |= IFM_ACTIVE;
-
- /* Hardware always does full-duplex */
- ifmr->ifm_active |= IFM_FDX;
-
- switch (hw->phy.link_info.phy_type) {
- /* 100 M */
- case I40E_PHY_TYPE_100BASE_TX:
- ifmr->ifm_active |= IFM_100_TX;
- break;
- /* 1 G */
- case I40E_PHY_TYPE_1000BASE_T:
- ifmr->ifm_active |= IFM_1000_T;
- break;
- case I40E_PHY_TYPE_1000BASE_SX:
- ifmr->ifm_active |= IFM_1000_SX;
- break;
- case I40E_PHY_TYPE_1000BASE_LX:
- ifmr->ifm_active |= IFM_1000_LX;
- break;
- case I40E_PHY_TYPE_1000BASE_T_OPTICAL:
- ifmr->ifm_active |= IFM_1000_T;
- break;
- /* 10 G */
- case I40E_PHY_TYPE_10GBASE_SFPP_CU:
- ifmr->ifm_active |= IFM_10G_TWINAX;
- break;
- case I40E_PHY_TYPE_10GBASE_SR:
- ifmr->ifm_active |= IFM_10G_SR;
- break;
- case I40E_PHY_TYPE_10GBASE_LR:
- ifmr->ifm_active |= IFM_10G_LR;
- break;
- case I40E_PHY_TYPE_10GBASE_T:
- ifmr->ifm_active |= IFM_10G_T;
- break;
- case I40E_PHY_TYPE_XAUI:
- case I40E_PHY_TYPE_XFI:
- ifmr->ifm_active |= IFM_10G_TWINAX;
- break;
- case I40E_PHY_TYPE_10GBASE_AOC:
- ifmr->ifm_active |= IFM_10G_AOC;
- break;
- /* 25 G */
- case I40E_PHY_TYPE_25GBASE_KR:
- ifmr->ifm_active |= IFM_25G_KR;
- break;
- case I40E_PHY_TYPE_25GBASE_CR:
- ifmr->ifm_active |= IFM_25G_CR;
- break;
- case I40E_PHY_TYPE_25GBASE_SR:
- ifmr->ifm_active |= IFM_25G_SR;
- break;
- case I40E_PHY_TYPE_25GBASE_LR:
- ifmr->ifm_active |= IFM_25G_LR;
- break;
- case I40E_PHY_TYPE_25GBASE_AOC:
- ifmr->ifm_active |= IFM_25G_AOC;
- break;
- case I40E_PHY_TYPE_25GBASE_ACC:
- ifmr->ifm_active |= IFM_25G_ACC;
- break;
- /* 40 G */
- case I40E_PHY_TYPE_40GBASE_CR4:
- case I40E_PHY_TYPE_40GBASE_CR4_CU:
- ifmr->ifm_active |= IFM_40G_CR4;
- break;
- case I40E_PHY_TYPE_40GBASE_SR4:
- ifmr->ifm_active |= IFM_40G_SR4;
- break;
- case I40E_PHY_TYPE_40GBASE_LR4:
- ifmr->ifm_active |= IFM_40G_LR4;
- break;
- case I40E_PHY_TYPE_XLAUI:
- ifmr->ifm_active |= IFM_OTHER;
- break;
- case I40E_PHY_TYPE_1000BASE_KX:
- ifmr->ifm_active |= IFM_1000_KX;
- break;
- case I40E_PHY_TYPE_SGMII:
- ifmr->ifm_active |= IFM_1000_SGMII;
- break;
- /* ERJ: What's the difference between these? */
- case I40E_PHY_TYPE_10GBASE_CR1_CU:
- case I40E_PHY_TYPE_10GBASE_CR1:
- ifmr->ifm_active |= IFM_10G_CR1;
- break;
- case I40E_PHY_TYPE_10GBASE_KX4:
- ifmr->ifm_active |= IFM_10G_KX4;
- break;
- case I40E_PHY_TYPE_10GBASE_KR:
- ifmr->ifm_active |= IFM_10G_KR;
- break;
- case I40E_PHY_TYPE_SFI:
- ifmr->ifm_active |= IFM_10G_SFI;
- break;
- /* Our single 20G media type */
- case I40E_PHY_TYPE_20GBASE_KR2:
- ifmr->ifm_active |= IFM_20G_KR2;
- break;
- case I40E_PHY_TYPE_40GBASE_KR4:
- ifmr->ifm_active |= IFM_40G_KR4;
- break;
- case I40E_PHY_TYPE_XLPPI:
- case I40E_PHY_TYPE_40GBASE_AOC:
- ifmr->ifm_active |= IFM_40G_XLPPI;
- break;
- /* Unknown to driver */
- default:
- ifmr->ifm_active |= IFM_UNKNOWN;
- break;
- }
- /* Report flow control status as well */
- if (hw->phy.link_info.an_info & I40E_AQ_LINK_PAUSE_TX)
- ifmr->ifm_active |= IFM_ETH_TXPAUSE;
- if (hw->phy.link_info.an_info & I40E_AQ_LINK_PAUSE_RX)
- ifmr->ifm_active |= IFM_ETH_RXPAUSE;
-
- IXL_PF_UNLOCK(pf);
-}
-
-void
-ixl_init(void *arg)
-{
- struct ixl_pf *pf = arg;
-
- IXL_PF_LOCK(pf);
- ixl_init_locked(pf);
- IXL_PF_UNLOCK(pf);
-}
-
-/*
- * NOTE: Fortville does not support forcing media speeds. Instead,
- * use the set_advertise sysctl to set the speeds Fortville
- * will advertise or be allowed to operate at.
- */
-int
-ixl_media_change(struct ifnet * ifp)
-{
- struct ixl_vsi *vsi = ifp->if_softc;
- struct ifmedia *ifm = &vsi->media;
-
- INIT_DEBUGOUT("ixl_media_change: begin");
-
- if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)
- return (EINVAL);
-
- if_printf(ifp, "Use 'advertise_speed' sysctl to change advertised speeds\n");
-
- return (ENODEV);
-}
-
-/*********************************************************************
- * Ioctl entry point
- *
- * ixl_ioctl is called when the user wants to configure the
- * interface.
- *
- * return 0 on success, positive on failure
- **********************************************************************/
-
-int
-ixl_ioctl(struct ifnet * ifp, u_long command, caddr_t data)
-{
- struct ixl_vsi *vsi = ifp->if_softc;
- struct ixl_pf *pf = vsi->back;
- struct ifreq *ifr = (struct ifreq *)data;
- struct ifdrv *ifd = (struct ifdrv *)data;
-#if defined(INET) || defined(INET6)
- struct ifaddr *ifa = (struct ifaddr *)data;
- bool avoid_reset = FALSE;
-#endif
- int error = 0;
-
- switch (command) {
-
- case SIOCSIFADDR:
- IOCTL_DEBUGOUT("ioctl: SIOCSIFADDR (Set Interface Address)");
-#ifdef INET
- if (ifa->ifa_addr->sa_family == AF_INET)
- avoid_reset = TRUE;
-#endif
-#ifdef INET6
- if (ifa->ifa_addr->sa_family == AF_INET6)
- avoid_reset = TRUE;
-#endif
-#if defined(INET) || defined(INET6)
- /*
- ** Calling init results in link renegotiation,
- ** so we avoid doing it when possible.
- */
- if (avoid_reset) {
- ifp->if_flags |= IFF_UP;
- if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
- ixl_init(pf);
-#ifdef INET
- if (!(ifp->if_flags & IFF_NOARP))
- arp_ifinit(ifp, ifa);
-#endif
- } else
- error = ether_ioctl(ifp, command, data);
- break;
-#endif
- case SIOCSIFMTU:
- IOCTL_DEBUGOUT("ioctl: SIOCSIFMTU (Set Interface MTU)");
- if (ifr->ifr_mtu > IXL_MAX_FRAME -
- ETHER_HDR_LEN - ETHER_CRC_LEN - ETHER_VLAN_ENCAP_LEN) {
- error = EINVAL;
- } else {
- IXL_PF_LOCK(pf);
- ifp->if_mtu = ifr->ifr_mtu;
- vsi->max_frame_size =
- ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN
- + ETHER_VLAN_ENCAP_LEN;
- if (ifp->if_drv_flags & IFF_DRV_RUNNING)
- ixl_init_locked(pf);
- IXL_PF_UNLOCK(pf);
- }
- break;
- case SIOCSIFFLAGS:
- IOCTL_DEBUGOUT("ioctl: SIOCSIFFLAGS (Set Interface Flags)");
- IXL_PF_LOCK(pf);
- if (ifp->if_flags & IFF_UP) {
- if ((ifp->if_drv_flags & IFF_DRV_RUNNING)) {
- if ((ifp->if_flags ^ pf->if_flags) &
- (IFF_PROMISC | IFF_ALLMULTI)) {
- ixl_set_promisc(vsi);
- }
- } else {
- IXL_PF_UNLOCK(pf);
- ixl_init(pf);
- IXL_PF_LOCK(pf);
- }
- } else {
- if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
- ixl_stop_locked(pf);
- }
- }
- pf->if_flags = ifp->if_flags;
- IXL_PF_UNLOCK(pf);
- break;
- case SIOCSDRVSPEC:
- case SIOCGDRVSPEC:
- IOCTL_DEBUGOUT("ioctl: SIOCxDRVSPEC (Get/Set Driver-specific "
- "Info)\n");
-
- /* NVM update command */
- if (ifd->ifd_cmd == I40E_NVM_ACCESS)
- error = ixl_handle_nvmupd_cmd(pf, ifd);
- else
- error = EINVAL;
- break;
- case SIOCADDMULTI:
- IOCTL_DEBUGOUT("ioctl: SIOCADDMULTI");
- if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
- IXL_PF_LOCK(pf);
- ixl_disable_rings_intr(vsi);
- ixl_add_multi(vsi);
- ixl_enable_intr(vsi);
- IXL_PF_UNLOCK(pf);
- }
- break;
- case SIOCDELMULTI:
- IOCTL_DEBUGOUT("ioctl: SIOCDELMULTI");
- if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
- IXL_PF_LOCK(pf);
- ixl_disable_rings_intr(vsi);
- ixl_del_multi(vsi);
- ixl_enable_intr(vsi);
- IXL_PF_UNLOCK(pf);
- }
- break;
- case SIOCSIFMEDIA:
- case SIOCGIFMEDIA:
- case SIOCGIFXMEDIA:
- IOCTL_DEBUGOUT("ioctl: SIOCxIFMEDIA (Get/Set Interface Media)");
- error = ifmedia_ioctl(ifp, ifr, &vsi->media, command);
- break;
- case SIOCSIFCAP:
- {
- int mask = ifr->ifr_reqcap ^ ifp->if_capenable;
- IOCTL_DEBUGOUT("ioctl: SIOCSIFCAP (Set Capabilities)");
-
- ixl_cap_txcsum_tso(vsi, ifp, mask);
-
- if (mask & IFCAP_RXCSUM)
- ifp->if_capenable ^= IFCAP_RXCSUM;
- if (mask & IFCAP_RXCSUM_IPV6)
- ifp->if_capenable ^= IFCAP_RXCSUM_IPV6;
- if (mask & IFCAP_LRO)
- ifp->if_capenable ^= IFCAP_LRO;
- if (mask & IFCAP_VLAN_HWTAGGING)
- ifp->if_capenable ^= IFCAP_VLAN_HWTAGGING;
- if (mask & IFCAP_VLAN_HWFILTER)
- ifp->if_capenable ^= IFCAP_VLAN_HWFILTER;
- if (mask & IFCAP_VLAN_HWTSO)
- ifp->if_capenable ^= IFCAP_VLAN_HWTSO;
- if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
- IXL_PF_LOCK(pf);
- ixl_init_locked(pf);
- IXL_PF_UNLOCK(pf);
- }
- VLAN_CAPABILITIES(ifp);
-
- break;
- }
-#if __FreeBSD_version >= 1003000
- case SIOCGI2C:
- {
- struct ifi2creq i2c;
- int i;
-
- IOCTL_DEBUGOUT("ioctl: SIOCGI2C (Get I2C Data)");
- if (!pf->has_i2c)
- return (ENOTTY);
-
- error = copyin(ifr_data_get_ptr(ifr), &i2c, sizeof(i2c));
- if (error != 0)
- break;
- if (i2c.dev_addr != 0xA0 && i2c.dev_addr != 0xA2) {
- error = EINVAL;
- break;
- }
- if (i2c.len > sizeof(i2c.data)) {
- error = EINVAL;
- break;
- }
-
- for (i = 0; i < i2c.len; i++)
- if (ixl_read_i2c_byte(pf, i2c.offset + i,
- i2c.dev_addr, &i2c.data[i]))
- return (EIO);
-
- error = copyout(&i2c, ifr_data_get_ptr(ifr), sizeof(i2c));
- break;
- }
-#endif
- default:
- IOCTL_DEBUGOUT("ioctl: UNKNOWN (0x%X)\n", (int)command);
- error = ether_ioctl(ifp, command, data);
- break;
- }
-
- return (error);
-}
-
int
ixl_find_i2c_interface(struct ixl_pf *pf)
{
@@ -5499,6 +3806,7 @@
return (ext) ? ext_phy_types_str[bit_pos] : phy_types_str[bit_pos];
}
+/* TODO: ERJ: I don't this is necessary anymore. */
int
ixl_aq_get_link_status(struct ixl_pf *pf, struct i40e_aqc_get_link_status *link_status)
{
@@ -5567,7 +3875,7 @@
"Power : 0x%02x",
link_status.phy_type,
ixl_phy_type_string_ls(link_status.phy_type),
- link_status.link_speed,
+ link_status.link_speed,
link_status.link_info,
link_status.an_info,
link_status.ext_info,
@@ -5647,7 +3955,7 @@
"ModType E: %01x\n"
"FEC Cfg : %02x\n"
"Ext CC : %02x",
- abilities.link_speed,
+ abilities.link_speed,
abilities.abilities, abilities.eee_capability,
abilities.eeer_val, abilities.d3_lpan,
abilities.phy_id[0], abilities.phy_id[1],
@@ -5689,7 +3997,7 @@
}
buf_len = sizeof(char) * (entry_len + 1) * ftl_len + 2;
- buf = buf_i = malloc(buf_len, M_DEVBUF, M_NOWAIT);
+ buf = buf_i = malloc(buf_len, M_DEVBUF, M_WAITOK);
sprintf(buf_i++, "\n");
SLIST_FOREACH(f, &vsi->ftl, next) {
@@ -5723,12 +4031,13 @@
}
/*
- * Longest string length: 25
+ * Longest string length: 25
*/
char *
ixl_switch_res_type_string(u8 type)
{
- static char * ixl_switch_res_type_strings[0x14] = {
+ // TODO: This should be changed to static const
+ char * ixl_switch_res_type_strings[0x14] = {
"VEB",
"VSI",
"Perfect Match MAC address",
@@ -5823,9 +4132,6 @@
/*
** Caller must init and delete sbuf; this function will clear and
** finish it for caller.
-**
-** XXX: Cannot use the SEID for this, since there is no longer a
-** fixed mapping between SEID and element type.
*/
char *
ixl_switch_element_string(struct sbuf *s,
@@ -6134,6 +4440,52 @@
return (0);
}
+/*
+ * Read some diagnostic data from an SFP module
+ * Bytes 96-99, 102-105 from device address 0xA2
+ */
+static int
+ixl_sysctl_read_i2c_diag_data(SYSCTL_HANDLER_ARGS)
+{
+ struct ixl_pf *pf = (struct ixl_pf *)arg1;
+ device_t dev = pf->dev;
+ struct sbuf *sbuf;
+ int error = 0;
+ u8 output;
+
+ error = pf->read_i2c_byte(pf, 0, 0xA0, &output);
+ if (error) {
+ device_printf(dev, "Error reading from i2c\n");
+ return (error);
+ }
+ if (output != 0x3) {
+ device_printf(dev, "Module is not SFP/SFP+/SFP28 (%02X)\n", output);
+ return (EIO);
+ }
+
+ pf->read_i2c_byte(pf, 92, 0xA0, &output);
+ if (!(output & 0x60)) {
+ device_printf(dev, "Module doesn't support diagnostics: %02X\n", output);
+ return (EIO);
+ }
+
+ sbuf = sbuf_new_for_sysctl(NULL, NULL, 128, req);
+
+ for (u8 offset = 96; offset < 100; offset++) {
+ pf->read_i2c_byte(pf, offset, 0xA2, &output);
+ sbuf_printf(sbuf, "%02X ", output);
+ }
+ for (u8 offset = 102; offset < 106; offset++) {
+ pf->read_i2c_byte(pf, offset, 0xA2, &output);
+ sbuf_printf(sbuf, "%02X ", output);
+ }
+
+ sbuf_finish(sbuf);
+ sbuf_delete(sbuf);
+
+ return (0);
+}
+
/*
* Sysctl to read a byte from I2C bus.
*
@@ -6149,9 +4501,6 @@
struct ixl_pf *pf = (struct ixl_pf *)arg1;
device_t dev = pf->dev;
int input = -1, error = 0;
-
- device_printf(dev, "%s: start\n", __func__);
-
u8 dev_addr, offset, output;
/* Read in I2C read parameters */
@@ -6165,7 +4514,7 @@
}
offset = (input >> 8) & 0xFF;
- error = ixl_read_i2c_byte(pf, offset, dev_addr, &output);
+ error = pf->read_i2c_byte(pf, offset, dev_addr, &output);
if (error)
return (error);
@@ -6189,7 +4538,6 @@
struct ixl_pf *pf = (struct ixl_pf *)arg1;
device_t dev = pf->dev;
int input = -1, error = 0;
-
u8 dev_addr, offset, value;
/* Read in I2C write parameters */
@@ -6204,7 +4552,7 @@
offset = (input >> 8) & 0xFF;
value = (input >> 16) & 0xFF;
- error = ixl_write_i2c_byte(pf, offset, dev_addr, value);
+ error = pf->write_i2c_byte(pf, offset, dev_addr, value);
if (error)
return (error);
@@ -6549,3 +4897,116 @@
i40e_get_link_status(hw, &pf->link_up);
return (0);
}
+
+static int
+ixl_sysctl_do_pf_reset(SYSCTL_HANDLER_ARGS)
+{
+ struct ixl_pf *pf = (struct ixl_pf *)arg1;
+ int requested = 0, error = 0;
+
+ /* Read in new mode */
+ error = sysctl_handle_int(oidp, &requested, 0, req);
+ if ((error) || (req->newptr == NULL))
+ return (error);
+
+ /* Initiate the PF reset later in the admin task */
+ atomic_set_32(&pf->state, IXL_PF_STATE_PF_RESET_REQ);
+
+ return (error);
+}
+
+static int
+ixl_sysctl_do_core_reset(SYSCTL_HANDLER_ARGS)
+{
+ struct ixl_pf *pf = (struct ixl_pf *)arg1;
+ struct i40e_hw *hw = &pf->hw;
+ int requested = 0, error = 0;
+
+ /* Read in new mode */
+ error = sysctl_handle_int(oidp, &requested, 0, req);
+ if ((error) || (req->newptr == NULL))
+ return (error);
+
+ wr32(hw, I40E_GLGEN_RTRIG, I40E_GLGEN_RTRIG_CORER_MASK);
+
+ return (error);
+}
+
+static int
+ixl_sysctl_do_global_reset(SYSCTL_HANDLER_ARGS)
+{
+ struct ixl_pf *pf = (struct ixl_pf *)arg1;
+ struct i40e_hw *hw = &pf->hw;
+ int requested = 0, error = 0;
+
+ /* Read in new mode */
+ error = sysctl_handle_int(oidp, &requested, 0, req);
+ if ((error) || (req->newptr == NULL))
+ return (error);
+
+ wr32(hw, I40E_GLGEN_RTRIG, I40E_GLGEN_RTRIG_GLOBR_MASK);
+
+ return (error);
+}
+
+static int
+ixl_sysctl_do_emp_reset(SYSCTL_HANDLER_ARGS)
+{
+ struct ixl_pf *pf = (struct ixl_pf *)arg1;
+ struct i40e_hw *hw = &pf->hw;
+ int requested = 0, error = 0;
+
+ /* Read in new mode */
+ error = sysctl_handle_int(oidp, &requested, 0, req);
+ if ((error) || (req->newptr == NULL))
+ return (error);
+
+ /* TODO: Find out how to bypass this */
+ if (!(rd32(hw, 0x000B818C) & 0x1)) {
+ device_printf(pf->dev, "SW not allowed to initiate EMPR\n");
+ error = EINVAL;
+ } else
+ wr32(hw, I40E_GLGEN_RTRIG, I40E_GLGEN_RTRIG_EMPFWR_MASK);
+
+ return (error);
+}
+
+/*
+ * Print out mapping of TX queue indexes and Rx queue indexes
+ * to MSI-X vectors.
+ */
+static int
+ixl_sysctl_queue_interrupt_table(SYSCTL_HANDLER_ARGS)
+{
+ struct ixl_pf *pf = (struct ixl_pf *)arg1;
+ struct ixl_vsi *vsi = &pf->vsi;
+ device_t dev = pf->dev;
+ struct sbuf *buf;
+ int error = 0;
+
+ struct ixl_rx_queue *rx_que = vsi->rx_queues;
+ struct ixl_tx_queue *tx_que = vsi->tx_queues;
+
+ buf = sbuf_new_for_sysctl(NULL, NULL, 128, req);
+ if (!buf) {
+ device_printf(dev, "Could not allocate sbuf for output.\n");
+ return (ENOMEM);
+ }
+
+ sbuf_cat(buf, "\n");
+ for (int i = 0; i < vsi->num_rx_queues; i++) {
+ rx_que = &vsi->rx_queues[i];
+ sbuf_printf(buf, "(rxq %3d): %d\n", i, rx_que->msix);
+ }
+ for (int i = 0; i < vsi->num_tx_queues; i++) {
+ tx_que = &vsi->tx_queues[i];
+ sbuf_printf(buf, "(txq %3d): %d\n", i, tx_que->msix);
+ }
+
+ error = sbuf_finish(buf);
+ if (error)
+ device_printf(dev, "Error finishing sbuf: %d\n", error);
+ sbuf_delete(buf);
+
+ return (error);
+}
Index: sys/dev/ixl/ixl_pf_qmgr.c
===================================================================
--- sys/dev/ixl/ixl_pf_qmgr.c
+++ sys/dev/ixl/ixl_pf_qmgr.c
@@ -83,8 +83,8 @@
qtag->qmgr = qmgr;
qtag->type = IXL_PF_QALLOC_CONTIGUOUS;
qtag->qidx[0] = block_start;
- qtag->num_allocated = num;
- qtag->num_active = alloc_size;
+ qtag->num_allocated = alloc_size;
+ qtag->num_active = num;
return (0);
}
Index: sys/dev/ixl/ixl_txrx.c
===================================================================
--- sys/dev/ixl/ixl_txrx.c
+++ sys/dev/ixl/ixl_txrx.c
@@ -51,27 +51,43 @@
#endif
/* Local Prototypes */
-static void ixl_rx_checksum(struct mbuf *, u32, u32, u8);
-static void ixl_refresh_mbufs(struct ixl_queue *, int);
-static int ixl_xmit(struct ixl_queue *, struct mbuf **);
-static int ixl_tx_setup_offload(struct ixl_queue *,
- struct mbuf *, u32 *, u32 *);
-static bool ixl_tso_setup(struct ixl_queue *, struct mbuf *);
-static void ixl_queue_sw_irq(struct ixl_vsi *, int);
-
-static inline void ixl_rx_discard(struct rx_ring *, int);
-static inline void ixl_rx_input(struct rx_ring *, struct ifnet *,
- struct mbuf *, u8);
-
-static inline bool ixl_tso_detect_sparse(struct mbuf *mp);
-static inline u32 ixl_get_tx_head(struct ixl_queue *que);
-
-#ifdef DEV_NETMAP
-#include <dev/netmap/if_ixl_netmap.h>
-#if __FreeBSD_version >= 1200000
-int ixl_rx_miss, ixl_rx_miss_bufs, ixl_crcstrip = 1;
-#endif
-#endif /* DEV_NETMAP */
+static void ixl_rx_checksum(if_rxd_info_t ri, u32 status, u32 error, u8 ptype);
+
+static int ixl_isc_txd_encap(void *arg, if_pkt_info_t pi);
+static void ixl_isc_txd_flush(void *arg, uint16_t txqid, qidx_t pidx);
+static int ixl_isc_txd_credits_update_hwb(void *arg, uint16_t txqid, bool clear);
+static int ixl_isc_txd_credits_update_dwb(void *arg, uint16_t txqid, bool clear);
+
+static void ixl_isc_rxd_refill(void *arg, if_rxd_update_t iru);
+static void ixl_isc_rxd_flush(void *arg, uint16_t rxqid, uint8_t flid __unused,
+ qidx_t pidx);
+static int ixl_isc_rxd_available(void *arg, uint16_t rxqid, qidx_t idx,
+ qidx_t budget);
+static int ixl_isc_rxd_pkt_get(void *arg, if_rxd_info_t ri);
+
+extern int ixl_intr(void *arg);
+
+struct if_txrx ixl_txrx_hwb = {
+ ixl_isc_txd_encap,
+ ixl_isc_txd_flush,
+ ixl_isc_txd_credits_update_hwb,
+ ixl_isc_rxd_available,
+ ixl_isc_rxd_pkt_get,
+ ixl_isc_rxd_refill,
+ ixl_isc_rxd_flush,
+ ixl_intr
+};
+
+struct if_txrx ixl_txrx_dwb = {
+ ixl_isc_txd_encap,
+ ixl_isc_txd_flush,
+ ixl_isc_txd_credits_update_dwb,
+ ixl_isc_rxd_available,
+ ixl_isc_rxd_pkt_get,
+ ixl_isc_rxd_refill,
+ ixl_isc_rxd_flush,
+ ixl_intr
+};
/*
* @key key is saved into this parameter
@@ -117,155 +133,16 @@
return hw->err_str;
}
-/*
- * PCI BUSMASTER needs to be set for proper operation.
- */
-void
-ixl_set_busmaster(device_t dev)
-{
- u16 pci_cmd_word;
-
- pci_cmd_word = pci_read_config(dev, PCIR_COMMAND, 2);
- pci_cmd_word |= PCIM_CMD_BUSMASTEREN;
- pci_write_config(dev, PCIR_COMMAND, pci_cmd_word, 2);
-}
-
-/*
- * Rewrite the ENABLE bit in the MSIX control register
- */
-void
-ixl_set_msix_enable(device_t dev)
-{
- int msix_ctrl, rid;
-
- pci_find_cap(dev, PCIY_MSIX, &rid);
- rid += PCIR_MSIX_CTRL;
- msix_ctrl = pci_read_config(dev, rid, 2);
- msix_ctrl |= PCIM_MSIXCTRL_MSIX_ENABLE;
- pci_write_config(dev, rid, msix_ctrl, 2);
-}
-
-
-/*
-** Multiqueue Transmit driver
-*/
-int
-ixl_mq_start(struct ifnet *ifp, struct mbuf *m)
-{
- struct ixl_vsi *vsi = ifp->if_softc;
- struct ixl_queue *que;
- struct tx_ring *txr;
- int err, i;
-#ifdef RSS
- u32 bucket_id;
-#endif
-
- /*
- * Which queue to use:
- *
- * When doing RSS, map it to the same outbound
- * queue as the incoming flow would be mapped to.
- * If everything is setup correctly, it should be
- * the same bucket that the current CPU we're on is.
- */
- if (M_HASHTYPE_GET(m) != M_HASHTYPE_NONE) {
-#ifdef RSS
- if (rss_hash2bucket(m->m_pkthdr.flowid,
- M_HASHTYPE_GET(m), &bucket_id) == 0) {
- i = bucket_id % vsi->num_queues;
- } else
-#endif
- i = m->m_pkthdr.flowid % vsi->num_queues;
- } else
- i = curcpu % vsi->num_queues;
-
- que = &vsi->queues[i];
- txr = &que->txr;
-
- err = drbr_enqueue(ifp, txr->br, m);
- if (err)
- return (err);
- if (IXL_TX_TRYLOCK(txr)) {
- ixl_mq_start_locked(ifp, txr);
- IXL_TX_UNLOCK(txr);
- } else
- taskqueue_enqueue(que->tq, &que->tx_task);
-
- return (0);
-}
-
-int
-ixl_mq_start_locked(struct ifnet *ifp, struct tx_ring *txr)
-{
- struct ixl_queue *que = txr->que;
- struct ixl_vsi *vsi = que->vsi;
- struct mbuf *next;
- int err = 0;
-
-
- if (((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) ||
- vsi->link_active == 0)
- return (ENETDOWN);
-
- /* Process the transmit queue */
- while ((next = drbr_peek(ifp, txr->br)) != NULL) {
- if ((err = ixl_xmit(que, &next)) != 0) {
- if (next == NULL)
- drbr_advance(ifp, txr->br);
- else
- drbr_putback(ifp, txr->br, next);
- break;
- }
- drbr_advance(ifp, txr->br);
- /* Send a copy of the frame to the BPF listener */
- ETHER_BPF_MTAP(ifp, next);
- if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
- break;
- }
-
- if (txr->avail < IXL_TX_CLEANUP_THRESHOLD)
- ixl_txeof(que);
-
- return (err);
-}
-
-/*
- * Called from a taskqueue to drain queued transmit packets.
- */
-void
-ixl_deferred_mq_start(void *arg, int pending)
-{
- struct ixl_queue *que = arg;
- struct tx_ring *txr = &que->txr;
- struct ixl_vsi *vsi = que->vsi;
- struct ifnet *ifp = vsi->ifp;
-
- IXL_TX_LOCK(txr);
- if (!drbr_empty(ifp, txr->br))
- ixl_mq_start_locked(ifp, txr);
- IXL_TX_UNLOCK(txr);
-}
-
-/*
-** Flush all queue ring buffers
-*/
-void
-ixl_qflush(struct ifnet *ifp)
+static bool
+ixl_is_tx_desc_done(struct tx_ring *txr, int idx)
{
- struct ixl_vsi *vsi = ifp->if_softc;
-
- for (int i = 0; i < vsi->num_queues; i++) {
- struct ixl_queue *que = &vsi->queues[i];
- struct tx_ring *txr = &que->txr;
- struct mbuf *m;
- IXL_TX_LOCK(txr);
- while ((m = buf_ring_dequeue_sc(txr->br)) != NULL)
- m_freem(m);
- IXL_TX_UNLOCK(txr);
- }
- if_qflush(ifp);
+ return (((txr->tx_base[idx].cmd_type_offset_bsz >> I40E_TXD_QW1_DTYPE_SHIFT)
+ & I40E_TXD_QW1_DTYPE_MASK) == I40E_TX_DESC_DTYPE_DESC_DONE);
}
+// TODO: Might want to still incorporate this
+// TODO: Compare this version of iflib with current version in OOT driver
+#if 0
static inline bool
ixl_tso_detect_sparse(struct mbuf *mp)
{
@@ -292,386 +169,39 @@
return (false);
}
-
-
-/*********************************************************************
- *
- * This routine maps the mbufs to tx descriptors, allowing the
- * TX engine to transmit the packets.
- * - return 0 on success, positive on failure
- *
- **********************************************************************/
-#define IXL_TXD_CMD (I40E_TX_DESC_CMD_EOP | I40E_TX_DESC_CMD_RS)
-
+#endif
static int
-ixl_xmit(struct ixl_queue *que, struct mbuf **m_headp)
+ixl_tso_detect_sparse(bus_dma_segment_t *segs, int nsegs, if_pkt_info_t pi)
{
- struct ixl_vsi *vsi = que->vsi;
- struct i40e_hw *hw = vsi->hw;
- struct tx_ring *txr = &que->txr;
- struct ixl_tx_buf *buf;
- struct i40e_tx_desc *txd = NULL;
- struct mbuf *m_head, *m;
- int i, j, error, nsegs;
- int first, last = 0;
- u16 vtag = 0;
- u32 cmd, off;
- bus_dmamap_t map;
- bus_dma_tag_t tag;
- bus_dma_segment_t segs[IXL_MAX_TSO_SEGS];
-
- cmd = off = 0;
- m_head = *m_headp;
-
- /*
- * Important to capture the first descriptor
- * used because it will contain the index of
- * the one we tell the hardware to report back
- */
- first = txr->next_avail;
- buf = &txr->buffers[first];
- map = buf->map;
- tag = txr->tx_tag;
-
- if (m_head->m_pkthdr.csum_flags & CSUM_TSO) {
- /* Use larger mapping for TSO */
- tag = txr->tso_tag;
- if (ixl_tso_detect_sparse(m_head)) {
- m = m_defrag(m_head, M_NOWAIT);
- if (m == NULL) {
- m_freem(*m_headp);
- *m_headp = NULL;
- return (ENOBUFS);
- }
- *m_headp = m;
- }
- }
-
- /*
- * Map the packet for DMA.
- */
- error = bus_dmamap_load_mbuf_sg(tag, map,
- *m_headp, segs, &nsegs, BUS_DMA_NOWAIT);
-
- if (error == EFBIG) {
- struct mbuf *m;
-
- m = m_defrag(*m_headp, M_NOWAIT);
- if (m == NULL) {
- que->mbuf_defrag_failed++;
- m_freem(*m_headp);
- *m_headp = NULL;
- return (ENOBUFS);
- }
- *m_headp = m;
-
- /* Try it again */
- error = bus_dmamap_load_mbuf_sg(tag, map,
- *m_headp, segs, &nsegs, BUS_DMA_NOWAIT);
-
- if (error != 0) {
- que->tx_dmamap_failed++;
- m_freem(*m_headp);
- *m_headp = NULL;
- return (error);
- }
- } else if (error != 0) {
- que->tx_dmamap_failed++;
- m_freem(*m_headp);
- *m_headp = NULL;
- return (error);
- }
-
- /* Make certain there are enough descriptors */
- if (nsegs > txr->avail - 2) {
- txr->no_desc++;
- error = ENOBUFS;
- goto xmit_fail;
- }
- m_head = *m_headp;
-
- /* Set up the TSO/CSUM offload */
- if (m_head->m_pkthdr.csum_flags & CSUM_OFFLOAD) {
- error = ixl_tx_setup_offload(que, m_head, &cmd, &off);
- if (error)
- goto xmit_fail;
- }
-
- cmd |= I40E_TX_DESC_CMD_ICRC;
- /* Grab the VLAN tag */
- if (m_head->m_flags & M_VLANTAG) {
- cmd |= I40E_TX_DESC_CMD_IL2TAG1;
- vtag = htole16(m_head->m_pkthdr.ether_vtag);
- }
-
- i = txr->next_avail;
- for (j = 0; j < nsegs; j++) {
- bus_size_t seglen;
-
- buf = &txr->buffers[i];
- buf->tag = tag; /* Keep track of the type tag */
- txd = &txr->base[i];
- seglen = segs[j].ds_len;
-
- txd->buffer_addr = htole64(segs[j].ds_addr);
- txd->cmd_type_offset_bsz =
- htole64(I40E_TX_DESC_DTYPE_DATA
- | ((u64)cmd << I40E_TXD_QW1_CMD_SHIFT)
- | ((u64)off << I40E_TXD_QW1_OFFSET_SHIFT)
- | ((u64)seglen << I40E_TXD_QW1_TX_BUF_SZ_SHIFT)
- | ((u64)vtag << I40E_TXD_QW1_L2TAG1_SHIFT));
-
- last = i; /* descriptor that will get completion IRQ */
-
- if (++i == que->num_tx_desc)
- i = 0;
-
- buf->m_head = NULL;
- buf->eop_index = -1;
- }
- /* Set the last descriptor for report */
- txd->cmd_type_offset_bsz |=
- htole64(((u64)IXL_TXD_CMD << I40E_TXD_QW1_CMD_SHIFT));
- txr->avail -= nsegs;
- txr->next_avail = i;
+ int count, curseg, i, hlen, segsz;
- buf->m_head = m_head;
- /* Swap the dma map between the first and last descriptor.
- * The descriptor that gets checked on completion will now
- * have the real map from the first descriptor.
- */
- txr->buffers[first].map = buf->map;
- buf->map = map;
- bus_dmamap_sync(tag, map, BUS_DMASYNC_PREWRITE);
-
- /* Set the index of the descriptor that will be marked done */
- buf = &txr->buffers[first];
- buf->eop_index = last;
-
- bus_dmamap_sync(txr->dma.tag, txr->dma.map,
- BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
- /*
- * Advance the Transmit Descriptor Tail (Tdt), this tells the
- * hardware that this frame is available to transmit.
- */
- ++txr->total_packets;
- wr32(hw, txr->tail, i);
-
- /* Mark outstanding work */
- atomic_store_rel_32(&txr->watchdog_timer, IXL_WATCHDOG);
- return (0);
-
-xmit_fail:
- bus_dmamap_unload(tag, buf->map);
- return (error);
-}
-
-
-/*********************************************************************
- *
- * Allocate memory for tx_buffer structures. The tx_buffer stores all
- * the information needed to transmit a packet on the wire. This is
- * called only once at attach, setup is done every reset.
- *
- **********************************************************************/
-int
-ixl_allocate_tx_data(struct ixl_queue *que)
-{
- struct tx_ring *txr = &que->txr;
- struct ixl_vsi *vsi = que->vsi;
- device_t dev = vsi->dev;
- struct ixl_tx_buf *buf;
- int i, error = 0;
-
- /*
- * Setup DMA descriptor areas.
- */
- if ((error = bus_dma_tag_create(bus_get_dma_tag(dev), /* parent */
- 1, 0, /* alignment, bounds */
- BUS_SPACE_MAXADDR, /* lowaddr */
- BUS_SPACE_MAXADDR, /* highaddr */
- NULL, NULL, /* filter, filterarg */
- IXL_TSO_SIZE, /* maxsize */
- IXL_MAX_TX_SEGS, /* nsegments */
- IXL_MAX_DMA_SEG_SIZE, /* maxsegsize */
- 0, /* flags */
- NULL, /* lockfunc */
- NULL, /* lockfuncarg */
- &txr->tx_tag))) {
- device_printf(dev,"Unable to allocate TX DMA tag\n");
- return (error);
- }
-
- /* Make a special tag for TSO */
- if ((error = bus_dma_tag_create(bus_get_dma_tag(dev), /* parent */
- 1, 0, /* alignment, bounds */
- BUS_SPACE_MAXADDR, /* lowaddr */
- BUS_SPACE_MAXADDR, /* highaddr */
- NULL, NULL, /* filter, filterarg */
- IXL_TSO_SIZE, /* maxsize */
- IXL_MAX_TSO_SEGS, /* nsegments */
- IXL_MAX_DMA_SEG_SIZE, /* maxsegsize */
- 0, /* flags */
- NULL, /* lockfunc */
- NULL, /* lockfuncarg */
- &txr->tso_tag))) {
- device_printf(dev,"Unable to allocate TX TSO DMA tag\n");
- goto free_tx_dma;
- }
-
- if (!(txr->buffers =
- (struct ixl_tx_buf *) malloc(sizeof(struct ixl_tx_buf) *
- que->num_tx_desc, M_DEVBUF, M_NOWAIT | M_ZERO))) {
- device_printf(dev, "Unable to allocate tx_buffer memory\n");
- error = ENOMEM;
- goto free_tx_tso_dma;
- }
-
- /* Create the descriptor buffer default dma maps */
- buf = txr->buffers;
- for (i = 0; i < que->num_tx_desc; i++, buf++) {
- buf->tag = txr->tx_tag;
- error = bus_dmamap_create(buf->tag, 0, &buf->map);
- if (error != 0) {
- device_printf(dev, "Unable to create TX DMA map\n");
- goto free_buffers;
- }
- }
-
- return 0;
-
-free_buffers:
- while (i--) {
- buf--;
- bus_dmamap_destroy(buf->tag, buf->map);
- }
-
- free(txr->buffers, M_DEVBUF);
- txr->buffers = NULL;
-free_tx_tso_dma:
- bus_dma_tag_destroy(txr->tso_tag);
- txr->tso_tag = NULL;
-free_tx_dma:
- bus_dma_tag_destroy(txr->tx_tag);
- txr->tx_tag = NULL;
-
- return (error);
-}
-
-
-/*********************************************************************
- *
- * (Re)Initialize a queue transmit ring.
- * - called by init, it clears the descriptor ring,
- * and frees any stale mbufs
- *
- **********************************************************************/
-void
-ixl_init_tx_ring(struct ixl_queue *que)
-{
-#ifdef DEV_NETMAP
- struct netmap_adapter *na = NA(que->vsi->ifp);
- struct netmap_slot *slot;
-#endif /* DEV_NETMAP */
- struct tx_ring *txr = &que->txr;
- struct ixl_tx_buf *buf;
-
- /* Clear the old ring contents */
- IXL_TX_LOCK(txr);
+ if (nsegs <= IXL_MAX_TX_SEGS-2)
+ return (0);
+ segsz = pi->ipi_tso_segsz;
+ curseg = count = 0;
-#ifdef DEV_NETMAP
/*
- * (under lock): if in netmap mode, do some consistency
- * checks and set slot to entry 0 of the netmap ring.
+ * skip the 1st segment if it is just the header, since the
+ * IXL_MAX_TX_SEGS-2 restriction applies to the payload
*/
- slot = netmap_reset(na, NR_TX, que->me, 0);
-#endif /* DEV_NETMAP */
-
- bzero((void *)txr->base,
- (sizeof(struct i40e_tx_desc)) * que->num_tx_desc);
-
- /* Reset indices */
- txr->next_avail = 0;
- txr->next_to_clean = 0;
-
- /* Reset watchdog status */
- txr->watchdog_timer = 0;
-
- /* Free any existing tx mbufs. */
- buf = txr->buffers;
- for (int i = 0; i < que->num_tx_desc; i++, buf++) {
- if (buf->m_head != NULL) {
- bus_dmamap_sync(buf->tag, buf->map,
- BUS_DMASYNC_POSTWRITE);
- bus_dmamap_unload(buf->tag, buf->map);
- m_freem(buf->m_head);
- buf->m_head = NULL;
- }
-#ifdef DEV_NETMAP
- /*
- * In netmap mode, set the map for the packet buffer.
- * NOTE: Some drivers (not this one) also need to set
- * the physical buffer address in the NIC ring.
- * netmap_idx_n2k() maps a nic index, i, into the corresponding
- * netmap slot index, si
- */
- if (slot) {
- int si = netmap_idx_n2k(na->tx_rings[que->me], i);
- netmap_load_map(na, buf->tag, buf->map, NMB(na, slot + si));
- }
-#endif /* DEV_NETMAP */
- /* Clear the EOP index */
- buf->eop_index = -1;
- }
-
- /* Set number of descriptors available */
- txr->avail = que->num_tx_desc;
-
- bus_dmamap_sync(txr->dma.tag, txr->dma.map,
- BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
- IXL_TX_UNLOCK(txr);
-}
-
-
-/*********************************************************************
- *
- * Free transmit ring related data structures.
- *
- **********************************************************************/
-void
-ixl_free_que_tx(struct ixl_queue *que)
-{
- struct tx_ring *txr = &que->txr;
- struct ixl_tx_buf *buf;
-
- INIT_DBG_IF(que->vsi->ifp, "queue %d: begin", que->me);
-
- for (int i = 0; i < que->num_tx_desc; i++) {
- buf = &txr->buffers[i];
- if (buf->m_head != NULL) {
- bus_dmamap_sync(buf->tag, buf->map,
- BUS_DMASYNC_POSTWRITE);
- m_freem(buf->m_head);
- buf->m_head = NULL;
- }
- bus_dmamap_unload(buf->tag, buf->map);
- bus_dmamap_destroy(buf->tag, buf->map);
- }
- if (txr->buffers != NULL) {
- free(txr->buffers, M_DEVBUF);
- txr->buffers = NULL;
- }
- if (txr->tx_tag != NULL) {
- bus_dma_tag_destroy(txr->tx_tag);
- txr->tx_tag = NULL;
- }
- if (txr->tso_tag != NULL) {
- bus_dma_tag_destroy(txr->tso_tag);
- txr->tso_tag = NULL;
- }
-
- INIT_DBG_IF(que->vsi->ifp, "queue %d: end", que->me);
- return;
+ hlen = pi->ipi_ehdrlen + pi->ipi_ip_hlen + pi->ipi_tcp_hlen;
+ if (hlen == segs[0].ds_len)
+ i = 1;
+ else
+ i = 0;
+ for (; i < nsegs; i++) {
+ curseg += segs[i].ds_len;
+ count++;
+ if (__predict_false(count > IXL_MAX_TX_SEGS-2))
+ return (1);
+ if (curseg > segsz) {
+ curseg -= segsz;
+ count = 1;
+ }
+ if (curseg == segsz)
+ curseg = count = 0;
+ }
+ return (0);
}
/*********************************************************************
@@ -680,55 +210,14 @@
*
**********************************************************************/
-static int
-ixl_tx_setup_offload(struct ixl_queue *que,
- struct mbuf *mp, u32 *cmd, u32 *off)
+static void
+ixl_tx_setup_offload(struct ixl_tx_queue *que,
+ if_pkt_info_t pi, u32 *cmd, u32 *off)
{
- struct ether_vlan_header *eh;
-#ifdef INET
- struct ip *ip = NULL;
-#endif
- struct tcphdr *th = NULL;
-#ifdef INET6
- struct ip6_hdr *ip6;
-#endif
- int elen, ip_hlen = 0, tcp_hlen;
- u16 etype;
- u8 ipproto = 0;
- bool tso = FALSE;
-
- /* Set up the TSO context descriptor if required */
- if (mp->m_pkthdr.csum_flags & CSUM_TSO) {
- tso = ixl_tso_setup(que, mp);
- if (tso)
- ++que->tso;
- else
- return (ENXIO);
- }
-
- /*
- * Determine where frame payload starts.
- * Jump over vlan headers if already present,
- * helpful for QinQ too.
- */
- eh = mtod(mp, struct ether_vlan_header *);
- if (eh->evl_encap_proto == htons(ETHERTYPE_VLAN)) {
- etype = ntohs(eh->evl_proto);
- elen = ETHER_HDR_LEN + ETHER_VLAN_ENCAP_LEN;
- } else {
- etype = ntohs(eh->evl_encap_proto);
- elen = ETHER_HDR_LEN;
- }
-
- switch (etype) {
+ switch (pi->ipi_etype) {
#ifdef INET
case ETHERTYPE_IP:
- ip = (struct ip *)(mp->m_data + elen);
- ip_hlen = ip->ip_hl << 2;
- ipproto = ip->ip_p;
- th = (struct tcphdr *)((caddr_t)ip + ip_hlen);
- /* The IP checksum must be recalculated with TSO */
- if (tso)
+ if (pi->ipi_csum_flags & CSUM_IP)
*cmd |= I40E_TX_DESC_CMD_IIPT_IPV4_CSUM;
else
*cmd |= I40E_TX_DESC_CMD_IIPT_IPV4;
@@ -736,10 +225,6 @@
#endif
#ifdef INET6
case ETHERTYPE_IPV6:
- ip6 = (struct ip6_hdr *)(mp->m_data + elen);
- ip_hlen = sizeof(struct ip6_hdr);
- ipproto = ip6->ip6_nxt;
- th = (struct tcphdr *)((caddr_t)ip6 + ip_hlen);
*cmd |= I40E_TX_DESC_CMD_IIPT_IPV6;
break;
#endif
@@ -747,27 +232,26 @@
break;
}
- *off |= (elen >> 1) << I40E_TX_DESC_LENGTH_MACLEN_SHIFT;
- *off |= (ip_hlen >> 2) << I40E_TX_DESC_LENGTH_IPLEN_SHIFT;
+ *off |= (pi->ipi_ehdrlen >> 1) << I40E_TX_DESC_LENGTH_MACLEN_SHIFT;
+ *off |= (pi->ipi_ip_hlen >> 2) << I40E_TX_DESC_LENGTH_IPLEN_SHIFT;
- switch (ipproto) {
+ switch (pi->ipi_ipproto) {
case IPPROTO_TCP:
- tcp_hlen = th->th_off << 2;
- if (mp->m_pkthdr.csum_flags & (CSUM_TCP|CSUM_TCP_IPV6)) {
+ if (pi->ipi_csum_flags & IXL_CSUM_TCP) {
*cmd |= I40E_TX_DESC_CMD_L4T_EOFT_TCP;
- *off |= (tcp_hlen >> 2) <<
+ *off |= (pi->ipi_tcp_hlen >> 2) <<
I40E_TX_DESC_LENGTH_L4_FC_LEN_SHIFT;
}
break;
case IPPROTO_UDP:
- if (mp->m_pkthdr.csum_flags & (CSUM_UDP|CSUM_UDP_IPV6)) {
+ if (pi->ipi_csum_flags & IXL_CSUM_UDP) {
*cmd |= I40E_TX_DESC_CMD_L4T_EOFT_UDP;
*off |= (sizeof(struct udphdr) >> 2) <<
I40E_TX_DESC_LENGTH_L4_FC_LEN_SHIFT;
}
break;
case IPPROTO_SCTP:
- if (mp->m_pkthdr.csum_flags & (CSUM_SCTP|CSUM_SCTP_IPV6)) {
+ if (pi->ipi_csum_flags & IXL_CSUM_SCTP) {
*cmd |= I40E_TX_DESC_CMD_L4T_EOFT_SCTP;
*off |= (sizeof(struct sctphdr) >> 2) <<
I40E_TX_DESC_LENGTH_L4_FC_LEN_SHIFT;
@@ -776,104 +260,35 @@
default:
break;
}
-
- return (0);
}
-
/**********************************************************************
*
* Setup context for hardware segmentation offload (TSO)
*
**********************************************************************/
-static bool
-ixl_tso_setup(struct ixl_queue *que, struct mbuf *mp)
+static int
+ixl_tso_setup(struct tx_ring *txr, if_pkt_info_t pi)
{
- struct tx_ring *txr = &que->txr;
+ if_softc_ctx_t scctx;
struct i40e_tx_context_desc *TXD;
- struct ixl_tx_buf *buf;
u32 cmd, mss, type, tsolen;
- u16 etype;
- int idx, elen, ip_hlen, tcp_hlen;
- struct ether_vlan_header *eh;
-#ifdef INET
- struct ip *ip;
-#endif
-#ifdef INET6
- struct ip6_hdr *ip6;
-#endif
-#if defined(INET6) || defined(INET)
- struct tcphdr *th;
-#endif
+ int idx;
u64 type_cmd_tso_mss;
- /*
- * Determine where frame payload starts.
- * Jump over vlan headers if already present
- */
- eh = mtod(mp, struct ether_vlan_header *);
- if (eh->evl_encap_proto == htons(ETHERTYPE_VLAN)) {
- elen = ETHER_HDR_LEN + ETHER_VLAN_ENCAP_LEN;
- etype = eh->evl_proto;
- } else {
- elen = ETHER_HDR_LEN;
- etype = eh->evl_encap_proto;
- }
-
- switch (ntohs(etype)) {
-#ifdef INET6
- case ETHERTYPE_IPV6:
- ip6 = (struct ip6_hdr *)(mp->m_data + elen);
- if (ip6->ip6_nxt != IPPROTO_TCP)
- return (ENXIO);
- ip_hlen = sizeof(struct ip6_hdr);
- th = (struct tcphdr *)((caddr_t)ip6 + ip_hlen);
- th->th_sum = in6_cksum_pseudo(ip6, 0, IPPROTO_TCP, 0);
- tcp_hlen = th->th_off << 2;
- /*
- * The corresponding flag is set by the stack in the IPv4
- * TSO case, but not in IPv6 (at least in FreeBSD 10.2).
- * So, set it here because the rest of the flow requires it.
- */
- mp->m_pkthdr.csum_flags |= CSUM_TCP_IPV6;
- break;
-#endif
-#ifdef INET
- case ETHERTYPE_IP:
- ip = (struct ip *)(mp->m_data + elen);
- if (ip->ip_p != IPPROTO_TCP)
- return (ENXIO);
- ip->ip_sum = 0;
- ip_hlen = ip->ip_hl << 2;
- th = (struct tcphdr *)((caddr_t)ip + ip_hlen);
- th->th_sum = in_pseudo(ip->ip_src.s_addr,
- ip->ip_dst.s_addr, htons(IPPROTO_TCP));
- tcp_hlen = th->th_off << 2;
- break;
-#endif
- default:
- printf("%s: CSUM_TSO but no supported IP version (0x%04x)",
- __func__, ntohs(etype));
- return FALSE;
- }
-
- /* Ensure we have at least the IP+TCP header in the first mbuf. */
- if (mp->m_len < elen + ip_hlen + sizeof(struct tcphdr))
- return FALSE;
-
- idx = txr->next_avail;
- buf = &txr->buffers[idx];
- TXD = (struct i40e_tx_context_desc *) &txr->base[idx];
- tsolen = mp->m_pkthdr.len - (elen + ip_hlen + tcp_hlen);
+ idx = pi->ipi_pidx;
+ TXD = (struct i40e_tx_context_desc *) &txr->tx_base[idx];
+ tsolen = pi->ipi_len - (pi->ipi_ehdrlen + pi->ipi_ip_hlen + pi->ipi_tcp_hlen);
+ scctx = txr->que->vsi->shared;
type = I40E_TX_DESC_DTYPE_CONTEXT;
cmd = I40E_TX_CTX_DESC_TSO;
/* TSO MSS must not be less than 64 */
- if (mp->m_pkthdr.tso_segsz < IXL_MIN_TSO_MSS) {
- que->mss_too_small++;
- mp->m_pkthdr.tso_segsz = IXL_MIN_TSO_MSS;
+ if (pi->ipi_tso_segsz < IXL_MIN_TSO_MSS) {
+ txr->mss_too_small++;
+ pi->ipi_tso_segsz = IXL_MIN_TSO_MSS;
}
- mss = mp->m_pkthdr.tso_segsz;
+ mss = pi->ipi_tso_segsz;
type_cmd_tso_mss = ((u64)type << I40E_TXD_CTX_QW1_DTYPE_SHIFT) |
((u64)cmd << I40E_TXD_CTX_QW1_CMD_SHIFT) |
@@ -882,743 +297,285 @@
TXD->type_cmd_tso_mss = htole64(type_cmd_tso_mss);
TXD->tunneling_params = htole32(0);
- buf->m_head = NULL;
- buf->eop_index = -1;
+ txr->que->tso++;
- if (++idx == que->num_tx_desc)
- idx = 0;
-
- txr->avail--;
- txr->next_avail = idx;
-
- return TRUE;
+ return ((idx + 1) & (scctx->isc_ntxd[0]-1));
}
-/*
- * ixl_get_tx_head - Retrieve the value from the
- * location the HW records its HEAD index
- */
-static inline u32
-ixl_get_tx_head(struct ixl_queue *que)
-{
- struct tx_ring *txr = &que->txr;
- void *head = &txr->base[que->num_tx_desc];
- return LE32_TO_CPU(*(volatile __le32 *)head);
-}
-
-/**********************************************************************
- *
- * Get index of last used descriptor/buffer from hardware, and clean
- * the descriptors/buffers up to that index.
- *
- **********************************************************************/
-static bool
-ixl_txeof_hwb(struct ixl_queue *que)
-{
- struct tx_ring *txr = &que->txr;
- u32 first, last, head, done;
- struct ixl_tx_buf *buf;
- struct i40e_tx_desc *tx_desc, *eop_desc;
-
- mtx_assert(&txr->mtx, MA_OWNED);
-
-#ifdef DEV_NETMAP
- // XXX todo: implement moderation
- if (netmap_tx_irq(que->vsi->ifp, que->me))
- return FALSE;
-#endif /* DEF_NETMAP */
-
- /* These are not the descriptors you seek, move along :) */
- if (txr->avail == que->num_tx_desc) {
- atomic_store_rel_32(&txr->watchdog_timer, 0);
- return FALSE;
- }
-
- first = txr->next_to_clean;
- buf = &txr->buffers[first];
- tx_desc = (struct i40e_tx_desc *)&txr->base[first];
- last = buf->eop_index;
- if (last == -1)
- return FALSE;
- eop_desc = (struct i40e_tx_desc *)&txr->base[last];
-
- /* Sync DMA before reading head index from ring */
- bus_dmamap_sync(txr->dma.tag, txr->dma.map,
- BUS_DMASYNC_POSTREAD);
+/*********************************************************************
+ *
+ * This routine maps the mbufs to tx descriptors, allowing the
+ * TX engine to transmit the packets.
+ * - return 0 on success, positive on failure
+ *
+ **********************************************************************/
+#define IXL_TXD_CMD (I40E_TX_DESC_CMD_EOP | I40E_TX_DESC_CMD_RS)
- /* Get the Head WB value */
- head = ixl_get_tx_head(que);
+static int
+ixl_isc_txd_encap(void *arg, if_pkt_info_t pi)
+{
+ struct ixl_vsi *vsi = arg;
+ if_softc_ctx_t scctx = vsi->shared;
+ struct ixl_tx_queue *que = &vsi->tx_queues[pi->ipi_qsidx];
+ struct tx_ring *txr = &que->txr;
+ int nsegs = pi->ipi_nsegs;
+ bus_dma_segment_t *segs = pi->ipi_segs;
+ struct i40e_tx_desc *txd = NULL;
+ int i, j, mask, pidx_last;
+ u32 cmd, off, tx_intr;
- /*
- ** Get the index of the first descriptor
- ** BEYOND the EOP and call that 'done'.
- ** I do this so the comparison in the
- ** inner while loop below can be simple
- */
- if (++last == que->num_tx_desc) last = 0;
- done = last;
+ // device_printf(iflib_get_dev(vsi->ctx), "%s: begin\n", __func__);
- /*
- ** The HEAD index of the ring is written in a
- ** defined location, this rather than a done bit
- ** is what is used to keep track of what must be
- ** 'cleaned'.
- */
- while (first != head) {
- /* We clean the range of the packet */
- while (first != done) {
- ++txr->avail;
-
- if (buf->m_head) {
- txr->bytes += /* for ITR adjustment */
- buf->m_head->m_pkthdr.len;
- txr->tx_bytes += /* for TX stats */
- buf->m_head->m_pkthdr.len;
- bus_dmamap_sync(buf->tag,
- buf->map,
- BUS_DMASYNC_POSTWRITE);
- bus_dmamap_unload(buf->tag,
- buf->map);
- m_freem(buf->m_head);
- buf->m_head = NULL;
- }
- buf->eop_index = -1;
+ cmd = off = 0;
+ i = pi->ipi_pidx;
- if (++first == que->num_tx_desc)
- first = 0;
+ tx_intr = (pi->ipi_flags & IPI_TX_INTR);
+#if 0
+ device_printf(iflib_get_dev(vsi->ctx), "%s: tx_intr %d\n", __func__, tx_intr);
+#endif
- buf = &txr->buffers[first];
- tx_desc = &txr->base[first];
+ /* Set up the TSO/CSUM offload */
+ if (pi->ipi_csum_flags & CSUM_OFFLOAD) {
+ /* Set up the TSO context descriptor if required */
+ if (pi->ipi_csum_flags & CSUM_TSO) {
+ if (ixl_tso_detect_sparse(segs, nsegs, pi))
+ return (EFBIG);
+ i = ixl_tso_setup(txr, pi);
}
- ++txr->packets;
- /* If a packet was successfully cleaned, reset the watchdog timer */
- atomic_store_rel_32(&txr->watchdog_timer, IXL_WATCHDOG);
- /* See if there is more work now */
- last = buf->eop_index;
- if (last != -1) {
- eop_desc = &txr->base[last];
- /* Get next done point */
- if (++last == que->num_tx_desc) last = 0;
- done = last;
- } else
- break;
- }
- bus_dmamap_sync(txr->dma.tag, txr->dma.map,
- BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
-
- txr->next_to_clean = first;
-
- /*
- * If there are no pending descriptors, clear the timeout.
- */
- if (txr->avail == que->num_tx_desc) {
- atomic_store_rel_32(&txr->watchdog_timer, 0);
- return FALSE;
- }
-
- return TRUE;
-}
-
-/**********************************************************************
- *
- * Use index kept by driver and the flag on each descriptor to find used
- * descriptor/buffers and clean them up for re-use.
- *
- * This method of reclaiming descriptors is current incompatible with
- * DEV_NETMAP.
- *
- * Returns TRUE if there are more descriptors to be cleaned after this
- * function exits.
- *
- **********************************************************************/
-static bool
-ixl_txeof_dwb(struct ixl_queue *que)
-{
- struct tx_ring *txr = &que->txr;
- u32 first, last, done;
- u32 limit = 256;
- struct ixl_tx_buf *buf;
- struct i40e_tx_desc *tx_desc, *eop_desc;
-
- mtx_assert(&txr->mtx, MA_OWNED);
-
- /* There are no descriptors to clean */
- if (txr->avail == que->num_tx_desc) {
- atomic_store_rel_32(&txr->watchdog_timer, 0);
- return FALSE;
+ ixl_tx_setup_offload(que, pi, &cmd, &off);
}
+ if (pi->ipi_mflags & M_VLANTAG)
+ cmd |= I40E_TX_DESC_CMD_IL2TAG1;
- /* Set starting index/descriptor/buffer */
- first = txr->next_to_clean;
- buf = &txr->buffers[first];
- tx_desc = &txr->base[first];
-
- /*
- * This function operates per-packet -- identifies the start of the
- * packet and gets the index of the last descriptor of the packet from
- * it, from eop_index.
- *
- * If the last descriptor is marked "done" by the hardware, then all
- * of the descriptors for the packet are cleaned.
- */
- last = buf->eop_index;
- if (last == -1)
- return FALSE;
- eop_desc = &txr->base[last];
-
- /* Sync DMA before reading from ring */
- bus_dmamap_sync(txr->dma.tag, txr->dma.map, BUS_DMASYNC_POSTREAD);
-
- /*
- * Get the index of the first descriptor beyond the EOP and call that
- * 'done'. Simplifies the comparison for the inner loop below.
- */
- if (++last == que->num_tx_desc)
- last = 0;
- done = last;
-
- /*
- * We find the last completed descriptor by examining each
- * descriptor's status bits to see if it's done.
- */
- do {
- /* Break if last descriptor in packet isn't marked done */
- if ((eop_desc->cmd_type_offset_bsz & I40E_TXD_QW1_DTYPE_MASK)
- != I40E_TX_DESC_DTYPE_DESC_DONE)
- break;
-
- /* Clean the descriptors that make up the processed packet */
- while (first != done) {
- /*
- * If there was a buffer attached to this descriptor,
- * prevent the adapter from accessing it, and add its
- * length to the queue's TX stats.
- */
- if (buf->m_head) {
- txr->bytes += buf->m_head->m_pkthdr.len;
- txr->tx_bytes += buf->m_head->m_pkthdr.len;
- bus_dmamap_sync(buf->tag, buf->map,
- BUS_DMASYNC_POSTWRITE);
- bus_dmamap_unload(buf->tag, buf->map);
- m_freem(buf->m_head);
- buf->m_head = NULL;
- }
- buf->eop_index = -1;
- ++txr->avail;
-
- if (++first == que->num_tx_desc)
- first = 0;
- buf = &txr->buffers[first];
- tx_desc = &txr->base[first];
- }
- ++txr->packets;
- /* If a packet was successfully cleaned, reset the watchdog timer */
- atomic_store_rel_32(&txr->watchdog_timer, IXL_WATCHDOG);
-
- /*
- * Since buf is the first buffer after the one that was just
- * cleaned, check if the packet it starts is done, too.
- */
- last = buf->eop_index;
- if (last != -1) {
- eop_desc = &txr->base[last];
- /* Get next done point */
- if (++last == que->num_tx_desc) last = 0;
- done = last;
- } else
- break;
- } while (--limit);
+ cmd |= I40E_TX_DESC_CMD_ICRC;
+ mask = scctx->isc_ntxd[0] - 1;
+ for (j = 0; j < nsegs; j++) {
+ bus_size_t seglen;
- bus_dmamap_sync(txr->dma.tag, txr->dma.map,
- BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
+ txd = &txr->tx_base[i];
+ seglen = segs[j].ds_len;
- txr->next_to_clean = first;
+ txd->buffer_addr = htole64(segs[j].ds_addr);
+ txd->cmd_type_offset_bsz =
+ htole64(I40E_TX_DESC_DTYPE_DATA
+ | ((u64)cmd << I40E_TXD_QW1_CMD_SHIFT)
+ | ((u64)off << I40E_TXD_QW1_OFFSET_SHIFT)
+ | ((u64)seglen << I40E_TXD_QW1_TX_BUF_SZ_SHIFT)
+ | ((u64)htole16(pi->ipi_vtag) << I40E_TXD_QW1_L2TAG1_SHIFT));
- /*
- * If there are no pending descriptors, clear the watchdog timer.
- */
- if (txr->avail == que->num_tx_desc) {
- atomic_store_rel_32(&txr->watchdog_timer, 0);
- return FALSE;
+ txr->tx_bytes += seglen;
+ pidx_last = i;
+ i = (i+1) & mask;
}
-
- return TRUE;
-}
-
-bool
-ixl_txeof(struct ixl_queue *que)
-{
- struct ixl_vsi *vsi = que->vsi;
-
- return (vsi->enable_head_writeback) ? ixl_txeof_hwb(que)
- : ixl_txeof_dwb(que);
+ /* Set the last descriptor for report */
+ txd->cmd_type_offset_bsz |=
+ htole64(((u64)IXL_TXD_CMD << I40E_TXD_QW1_CMD_SHIFT));
+ /* Add to report status array (if using TX interrupts) */
+ if (!vsi->enable_head_writeback && tx_intr) {
+ txr->tx_rsq[txr->tx_rs_pidx] = pidx_last;
+ txr->tx_rs_pidx = (txr->tx_rs_pidx+1) & mask;
+ MPASS(txr->tx_rs_pidx != txr->tx_rs_cidx);
+ }
+ pi->ipi_new_pidx = i;
+
+ ++txr->tx_packets;
+ return (0);
}
-
-/*********************************************************************
- *
- * Refresh mbuf buffers for RX descriptor rings
- * - now keeps its own state so discards due to resource
- * exhaustion are unnecessary, if an mbuf cannot be obtained
- * it just returns, keeping its placeholder, thus it can simply
- * be recalled to try again.
- *
- **********************************************************************/
static void
-ixl_refresh_mbufs(struct ixl_queue *que, int limit)
+ixl_isc_txd_flush(void *arg, uint16_t txqid, qidx_t pidx)
{
- struct ixl_vsi *vsi = que->vsi;
- struct rx_ring *rxr = &que->rxr;
- bus_dma_segment_t hseg[1];
- bus_dma_segment_t pseg[1];
- struct ixl_rx_buf *buf;
- struct mbuf *mh, *mp;
- int i, j, nsegs, error;
- bool refreshed = FALSE;
-
- i = j = rxr->next_refresh;
- /* Control the loop with one beyond */
- if (++j == que->num_rx_desc)
- j = 0;
-
- while (j != limit) {
- buf = &rxr->buffers[i];
- if (rxr->hdr_split == FALSE)
- goto no_split;
-
- if (buf->m_head == NULL) {
- mh = m_gethdr(M_NOWAIT, MT_DATA);
- if (mh == NULL)
- goto update;
- } else
- mh = buf->m_head;
-
- mh->m_pkthdr.len = mh->m_len = MHLEN;
- mh->m_len = MHLEN;
- mh->m_flags |= M_PKTHDR;
- /* Get the memory mapping */
- error = bus_dmamap_load_mbuf_sg(rxr->htag,
- buf->hmap, mh, hseg, &nsegs, BUS_DMA_NOWAIT);
- if (error != 0) {
- printf("Refresh mbufs: hdr dmamap load"
- " failure - %d\n", error);
- m_free(mh);
- buf->m_head = NULL;
- goto update;
- }
- buf->m_head = mh;
- bus_dmamap_sync(rxr->htag, buf->hmap,
- BUS_DMASYNC_PREREAD);
- rxr->base[i].read.hdr_addr =
- htole64(hseg[0].ds_addr);
-
-no_split:
- if (buf->m_pack == NULL) {
- mp = m_getjcl(M_NOWAIT, MT_DATA,
- M_PKTHDR, rxr->mbuf_sz);
- if (mp == NULL)
- goto update;
- } else
- mp = buf->m_pack;
-
- mp->m_pkthdr.len = mp->m_len = rxr->mbuf_sz;
- /* Get the memory mapping */
- error = bus_dmamap_load_mbuf_sg(rxr->ptag,
- buf->pmap, mp, pseg, &nsegs, BUS_DMA_NOWAIT);
- if (error != 0) {
- printf("Refresh mbufs: payload dmamap load"
- " failure - %d\n", error);
- m_free(mp);
- buf->m_pack = NULL;
- goto update;
- }
- buf->m_pack = mp;
- bus_dmamap_sync(rxr->ptag, buf->pmap,
- BUS_DMASYNC_PREREAD);
- rxr->base[i].read.pkt_addr =
- htole64(pseg[0].ds_addr);
- /* Used only when doing header split */
- rxr->base[i].read.hdr_addr = 0;
-
- refreshed = TRUE;
- /* Next is precalculated */
- i = j;
- rxr->next_refresh = i;
- if (++j == que->num_rx_desc)
- j = 0;
- }
-update:
- if (refreshed) /* Update hardware tail index */
- wr32(vsi->hw, rxr->tail, rxr->next_refresh);
- return;
+ struct ixl_vsi *vsi = arg;
+ struct tx_ring *txr = &vsi->tx_queues[txqid].txr;
+
+ /*
+ * Advance the Transmit Descriptor Tail (Tdt), this tells the
+ * hardware that this frame is available to transmit.
+ */
+ wr32(vsi->hw, txr->tail, pidx);
}
/*********************************************************************
*
- * Allocate memory for rx_buffer structures. Since we use one
- * rx_buffer per descriptor, the maximum number of rx_buffer's
- * that we'll need is equal to the number of receive descriptors
- * that we've defined.
+ * (Re)Initialize a queue transmit ring by clearing its memory.
*
**********************************************************************/
-int
-ixl_allocate_rx_data(struct ixl_queue *que)
+void
+ixl_init_tx_ring(struct ixl_vsi *vsi, struct ixl_tx_queue *que)
{
- struct rx_ring *rxr = &que->rxr;
- struct ixl_vsi *vsi = que->vsi;
- device_t dev = vsi->dev;
- struct ixl_rx_buf *buf;
- int i, bsize, error;
-
- if ((error = bus_dma_tag_create(bus_get_dma_tag(dev), /* parent */
- 1, 0, /* alignment, bounds */
- BUS_SPACE_MAXADDR, /* lowaddr */
- BUS_SPACE_MAXADDR, /* highaddr */
- NULL, NULL, /* filter, filterarg */
- MSIZE, /* maxsize */
- 1, /* nsegments */
- MSIZE, /* maxsegsize */
- 0, /* flags */
- NULL, /* lockfunc */
- NULL, /* lockfuncarg */
- &rxr->htag))) {
- device_printf(dev, "Unable to create RX DMA htag\n");
- return (error);
- }
+ struct tx_ring *txr = &que->txr;
- if ((error = bus_dma_tag_create(bus_get_dma_tag(dev), /* parent */
- 1, 0, /* alignment, bounds */
- BUS_SPACE_MAXADDR, /* lowaddr */
- BUS_SPACE_MAXADDR, /* highaddr */
- NULL, NULL, /* filter, filterarg */
- MJUM16BYTES, /* maxsize */
- 1, /* nsegments */
- MJUM16BYTES, /* maxsegsize */
- 0, /* flags */
- NULL, /* lockfunc */
- NULL, /* lockfuncarg */
- &rxr->ptag))) {
- device_printf(dev, "Unable to create RX DMA ptag\n");
- goto free_rx_htag;
- }
+ /* Clear the old ring contents */
+ bzero((void *)txr->tx_base,
+ (sizeof(struct i40e_tx_desc)) * vsi->shared->isc_ntxd[0]);
- bsize = sizeof(struct ixl_rx_buf) * que->num_rx_desc;
- if (!(rxr->buffers =
- (struct ixl_rx_buf *) malloc(bsize,
- M_DEVBUF, M_NOWAIT | M_ZERO))) {
- device_printf(dev, "Unable to allocate rx_buffer memory\n");
- error = ENOMEM;
- goto free_rx_ptag;
- }
+ // TODO: Write max descriptor index instead of 0?
+ wr32(vsi->hw, txr->tail, 0);
+ wr32(vsi->hw, I40E_QTX_HEAD(txr->me), 0);
+}
- for (i = 0; i < que->num_rx_desc; i++) {
- buf = &rxr->buffers[i];
- error = bus_dmamap_create(rxr->htag,
- BUS_DMA_NOWAIT, &buf->hmap);
- if (error) {
- device_printf(dev, "Unable to create RX head map\n");
- goto free_buffers;
- }
- error = bus_dmamap_create(rxr->ptag,
- BUS_DMA_NOWAIT, &buf->pmap);
- if (error) {
- bus_dmamap_destroy(rxr->htag, buf->hmap);
- device_printf(dev, "Unable to create RX pkt map\n");
- goto free_buffers;
- }
- }
+/*
+ * ixl_get_tx_head - Retrieve the value from the
+ * location the HW records its HEAD index
+ */
+static inline u32
+ixl_get_tx_head(struct ixl_tx_queue *que)
+{
+ if_softc_ctx_t scctx = que->vsi->shared;
+ struct tx_ring *txr = &que->txr;
+ void *head = &txr->tx_base[scctx->isc_ntxd[0]];
- return 0;
-free_buffers:
- while (i--) {
- buf = &rxr->buffers[i];
- bus_dmamap_destroy(rxr->ptag, buf->pmap);
- bus_dmamap_destroy(rxr->htag, buf->hmap);
- }
- free(rxr->buffers, M_DEVBUF);
- rxr->buffers = NULL;
-free_rx_ptag:
- bus_dma_tag_destroy(rxr->ptag);
- rxr->ptag = NULL;
-free_rx_htag:
- bus_dma_tag_destroy(rxr->htag);
- rxr->htag = NULL;
- return (error);
+ return LE32_TO_CPU(*(volatile __le32 *)head);
}
-
-/*********************************************************************
- *
- * (Re)Initialize the queue receive ring and its buffers.
- *
- **********************************************************************/
-int
-ixl_init_rx_ring(struct ixl_queue *que)
+static int
+ixl_isc_txd_credits_update_hwb(void *arg, uint16_t qid, bool clear)
{
- struct rx_ring *rxr = &que->rxr;
- struct ixl_vsi *vsi = que->vsi;
-#if defined(INET6) || defined(INET)
- struct ifnet *ifp = vsi->ifp;
- struct lro_ctrl *lro = &rxr->lro;
-#endif
- struct ixl_rx_buf *buf;
- bus_dma_segment_t pseg[1], hseg[1];
- int rsize, nsegs, error = 0;
-#ifdef DEV_NETMAP
- struct netmap_adapter *na = NA(que->vsi->ifp);
- struct netmap_slot *slot;
-#endif /* DEV_NETMAP */
-
- IXL_RX_LOCK(rxr);
-#ifdef DEV_NETMAP
- /* same as in ixl_init_tx_ring() */
- slot = netmap_reset(na, NR_RX, que->me, 0);
-#endif /* DEV_NETMAP */
- /* Clear the ring contents */
- rsize = roundup2(que->num_rx_desc *
- sizeof(union i40e_rx_desc), DBA_ALIGN);
- bzero((void *)rxr->base, rsize);
- /* Cleanup any existing buffers */
- for (int i = 0; i < que->num_rx_desc; i++) {
- buf = &rxr->buffers[i];
- if (buf->m_head != NULL) {
- bus_dmamap_sync(rxr->htag, buf->hmap,
- BUS_DMASYNC_POSTREAD);
- bus_dmamap_unload(rxr->htag, buf->hmap);
- buf->m_head->m_flags |= M_PKTHDR;
- m_freem(buf->m_head);
- }
- if (buf->m_pack != NULL) {
- bus_dmamap_sync(rxr->ptag, buf->pmap,
- BUS_DMASYNC_POSTREAD);
- bus_dmamap_unload(rxr->ptag, buf->pmap);
- buf->m_pack->m_flags |= M_PKTHDR;
- m_freem(buf->m_pack);
- }
- buf->m_head = NULL;
- buf->m_pack = NULL;
- }
+ struct ixl_vsi *vsi = arg;
+ if_softc_ctx_t scctx = vsi->shared;
+ struct ixl_tx_queue *que = &vsi->tx_queues[qid];
+ struct tx_ring *txr = &que->txr;
+ int head, credits;
- /* header split is off */
- rxr->hdr_split = FALSE;
+ /* Get the Head WB value */
+ head = ixl_get_tx_head(que);
- /* Now replenish the mbufs */
- for (int j = 0; j != que->num_rx_desc; ++j) {
- struct mbuf *mh, *mp;
-
- buf = &rxr->buffers[j];
-#ifdef DEV_NETMAP
- /*
- * In netmap mode, fill the map and set the buffer
- * address in the NIC ring, considering the offset
- * between the netmap and NIC rings (see comment in
- * ixgbe_setup_transmit_ring() ). No need to allocate
- * an mbuf, so end the block with a continue;
- */
- if (slot) {
- int sj = netmap_idx_n2k(na->rx_rings[que->me], j);
- uint64_t paddr;
- void *addr;
-
- addr = PNMB(na, slot + sj, &paddr);
- netmap_load_map(na, rxr->dma.tag, buf->pmap, addr);
- /* Update descriptor and the cached value */
- rxr->base[j].read.pkt_addr = htole64(paddr);
- rxr->base[j].read.hdr_addr = 0;
- continue;
- }
-#endif /* DEV_NETMAP */
- /*
- ** Don't allocate mbufs if not
- ** doing header split, its wasteful
- */
- if (rxr->hdr_split == FALSE)
- goto skip_head;
-
- /* First the header */
- buf->m_head = m_gethdr(M_NOWAIT, MT_DATA);
- if (buf->m_head == NULL) {
- error = ENOBUFS;
- goto fail;
- }
- m_adj(buf->m_head, ETHER_ALIGN);
- mh = buf->m_head;
- mh->m_len = mh->m_pkthdr.len = MHLEN;
- mh->m_flags |= M_PKTHDR;
- /* Get the memory mapping */
- error = bus_dmamap_load_mbuf_sg(rxr->htag,
- buf->hmap, buf->m_head, hseg,
- &nsegs, BUS_DMA_NOWAIT);
- if (error != 0) /* Nothing elegant to do here */
- goto fail;
- bus_dmamap_sync(rxr->htag,
- buf->hmap, BUS_DMASYNC_PREREAD);
- /* Update descriptor */
- rxr->base[j].read.hdr_addr = htole64(hseg[0].ds_addr);
-
-skip_head:
- /* Now the payload cluster */
- buf->m_pack = m_getjcl(M_NOWAIT, MT_DATA,
- M_PKTHDR, rxr->mbuf_sz);
- if (buf->m_pack == NULL) {
- error = ENOBUFS;
- goto fail;
- }
- mp = buf->m_pack;
- mp->m_pkthdr.len = mp->m_len = rxr->mbuf_sz;
- /* Get the memory mapping */
- error = bus_dmamap_load_mbuf_sg(rxr->ptag,
- buf->pmap, mp, pseg,
- &nsegs, BUS_DMA_NOWAIT);
- if (error != 0)
- goto fail;
- bus_dmamap_sync(rxr->ptag,
- buf->pmap, BUS_DMASYNC_PREREAD);
- /* Update descriptor */
- rxr->base[j].read.pkt_addr = htole64(pseg[0].ds_addr);
- rxr->base[j].read.hdr_addr = 0;
- }
+ credits = head - txr->tx_cidx_processed;
+ if (credits < 0)
+ credits += scctx->isc_ntxd[0];
+ if (clear)
+ txr->tx_cidx_processed = head;
+ return (credits);
+}
- /* Setup our descriptor indices */
- rxr->next_check = 0;
- rxr->next_refresh = 0;
- rxr->lro_enabled = FALSE;
- rxr->split = 0;
- rxr->bytes = 0;
- rxr->discard = FALSE;
+static int
+ixl_isc_txd_credits_update_dwb(void *arg, uint16_t txqid, bool clear)
+{
+ struct ixl_vsi *vsi = arg;
+ struct ixl_tx_queue *tx_que = &vsi->tx_queues[txqid];
+ if_softc_ctx_t scctx = vsi->shared;
+ struct tx_ring *txr = &tx_que->txr;
+
+ qidx_t processed = 0;
+ qidx_t cur, prev, ntxd, rs_cidx;
+ int32_t delta;
+ bool is_done;
+
+ rs_cidx = txr->tx_rs_cidx;
+#if 0
+ device_printf(iflib_get_dev(vsi->ctx), "%s: (q%d) rs_cidx %d, txr->tx_rs_pidx %d\n", __func__,
+ txr->me, rs_cidx, txr->tx_rs_pidx);
+#endif
+ if (rs_cidx == txr->tx_rs_pidx)
+ return (0);
+ cur = txr->tx_rsq[rs_cidx];
+ MPASS(cur != QIDX_INVALID);
+ is_done = ixl_is_tx_desc_done(txr, cur);
- wr32(vsi->hw, rxr->tail, que->num_rx_desc - 1);
- ixl_flush(vsi->hw);
+ if (clear == false || !is_done)
+ return (0);
-#if defined(INET6) || defined(INET)
- /*
- ** Now set up the LRO interface:
- */
- if (ifp->if_capenable & IFCAP_LRO) {
- int err = tcp_lro_init(lro);
- if (err) {
- if_printf(ifp, "queue %d: LRO Initialization failed!\n", que->me);
- goto fail;
- }
- INIT_DBG_IF(ifp, "queue %d: RX Soft LRO Initialized", que->me);
- rxr->lro_enabled = TRUE;
- lro->ifp = vsi->ifp;
- }
+ prev = txr->tx_cidx_processed;
+ ntxd = scctx->isc_ntxd[0];
+ do {
+ delta = (int32_t)cur - (int32_t)prev;
+ MPASS(prev == 0 || delta != 0);
+ if (delta < 0)
+ delta += ntxd;
+#if 0
+ device_printf(iflib_get_dev(vsi->ctx),
+ "%s: (q%d) cidx_processed=%u cur=%u clear=%d delta=%d\n",
+ __func__, txr->me, prev, cur, clear, delta);
#endif
+ processed += delta;
+ prev = cur;
+ rs_cidx = (rs_cidx + 1) & (ntxd-1);
+ if (rs_cidx == txr->tx_rs_pidx)
+ break;
+ cur = txr->tx_rsq[rs_cidx];
+ MPASS(cur != QIDX_INVALID);
+ is_done = ixl_is_tx_desc_done(txr, cur);
+ } while (is_done);
- bus_dmamap_sync(rxr->dma.tag, rxr->dma.map,
- BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
+ txr->tx_rs_cidx = rs_cidx;
+ txr->tx_cidx_processed = prev;
-fail:
- IXL_RX_UNLOCK(rxr);
- return (error);
+#if 0
+ device_printf(iflib_get_dev(vsi->ctx), "%s: (q%d) processed %d\n", __func__, txr->me, processed);
+#endif
+ return (processed);
}
-
-/*********************************************************************
- *
- * Free station receive ring data structures
- *
- **********************************************************************/
-void
-ixl_free_que_rx(struct ixl_queue *que)
+static void
+ixl_isc_rxd_refill(void *arg, if_rxd_update_t iru)
{
- struct rx_ring *rxr = &que->rxr;
- struct ixl_rx_buf *buf;
+ struct ixl_vsi *vsi = arg;
+ if_softc_ctx_t scctx = vsi->shared;
+ struct rx_ring *rxr = &((vsi->rx_queues[iru->iru_qsidx]).rxr);
+ uint64_t *paddrs;
+ uint32_t next_pidx, pidx;
+ uint16_t count;
+ int i;
- /* Cleanup any existing buffers */
- if (rxr->buffers != NULL) {
- for (int i = 0; i < que->num_rx_desc; i++) {
- buf = &rxr->buffers[i];
+ paddrs = iru->iru_paddrs;
+ pidx = iru->iru_pidx;
+ count = iru->iru_count;
- /* Free buffers and unload dma maps */
- ixl_rx_discard(rxr, i);
-
- bus_dmamap_destroy(rxr->htag, buf->hmap);
- bus_dmamap_destroy(rxr->ptag, buf->pmap);
- }
- free(rxr->buffers, M_DEVBUF);
- rxr->buffers = NULL;
- }
-
- if (rxr->htag != NULL) {
- bus_dma_tag_destroy(rxr->htag);
- rxr->htag = NULL;
- }
- if (rxr->ptag != NULL) {
- bus_dma_tag_destroy(rxr->ptag);
- rxr->ptag = NULL;
- }
+ for (i = 0, next_pidx = pidx; i < count; i++) {
+ rxr->rx_base[next_pidx].read.pkt_addr = htole64(paddrs[i]);
+ if (++next_pidx == scctx->isc_nrxd[0])
+ next_pidx = 0;
+ }
}
-static inline void
-ixl_rx_input(struct rx_ring *rxr, struct ifnet *ifp, struct mbuf *m, u8 ptype)
+static void
+ixl_isc_rxd_flush(void * arg, uint16_t rxqid, uint8_t flid __unused, qidx_t pidx)
{
+ struct ixl_vsi *vsi = arg;
+ struct rx_ring *rxr = &vsi->rx_queues[rxqid].rxr;
-#if defined(INET6) || defined(INET)
- /*
- * ATM LRO is only for IPv4/TCP packets and TCP checksum of the packet
- * should be computed by hardware. Also it should not have VLAN tag in
- * ethernet header.
- */
- if (rxr->lro_enabled &&
- (ifp->if_capenable & IFCAP_VLAN_HWTAGGING) != 0 &&
- (m->m_pkthdr.csum_flags & (CSUM_DATA_VALID | CSUM_PSEUDO_HDR)) ==
- (CSUM_DATA_VALID | CSUM_PSEUDO_HDR)) {
- /*
- * Send to the stack if:
- ** - LRO not enabled, or
- ** - no LRO resources, or
- ** - lro enqueue fails
- */
- if (rxr->lro.lro_cnt != 0)
- if (tcp_lro_rx(&rxr->lro, m, 0) == 0)
- return;
- }
-#endif
- (*ifp->if_input)(ifp, m);
+ wr32(vsi->hw, rxr->tail, pidx);
}
-
-static inline void
-ixl_rx_discard(struct rx_ring *rxr, int i)
+static int
+ixl_isc_rxd_available(void *arg, uint16_t rxqid, qidx_t idx, qidx_t budget)
{
- struct ixl_rx_buf *rbuf;
+ struct ixl_vsi *vsi = arg;
+ struct rx_ring *rxr = &vsi->rx_queues[rxqid].rxr;
+ union i40e_rx_desc *rxd;
+ u64 qword;
+ uint32_t status;
+ int cnt, i, nrxd;
- KASSERT(rxr != NULL, ("Receive ring pointer cannot be null"));
- KASSERT(i < rxr->que->num_rx_desc, ("Descriptor index must be less than que->num_desc"));
+ nrxd = vsi->shared->isc_nrxd[0];
- rbuf = &rxr->buffers[i];
+ if (budget == 1) {
+ rxd = &rxr->rx_base[idx];
+ qword = le64toh(rxd->wb.qword1.status_error_len);
+ status = (qword & I40E_RXD_QW1_STATUS_MASK)
+ >> I40E_RXD_QW1_STATUS_SHIFT;
+ return !!(status & (1 << I40E_RX_DESC_STATUS_DD_SHIFT));
+ }
- /* Free the mbufs in the current chain for the packet */
- if (rbuf->fmp != NULL) {
- bus_dmamap_sync(rxr->ptag, rbuf->pmap, BUS_DMASYNC_POSTREAD);
- m_freem(rbuf->fmp);
- rbuf->fmp = NULL;
- }
+ for (cnt = 0, i = idx; cnt < nrxd - 1 && cnt <= budget;) {
+ rxd = &rxr->rx_base[i];
+ qword = le64toh(rxd->wb.qword1.status_error_len);
+ status = (qword & I40E_RXD_QW1_STATUS_MASK)
+ >> I40E_RXD_QW1_STATUS_SHIFT;
- /*
- * Free the mbufs for the current descriptor; and let ixl_refresh_mbufs()
- * assign new mbufs to these.
- */
- if (rbuf->m_head) {
- bus_dmamap_sync(rxr->htag, rbuf->hmap, BUS_DMASYNC_POSTREAD);
- bus_dmamap_unload(rxr->htag, rbuf->hmap);
- m_free(rbuf->m_head);
- rbuf->m_head = NULL;
- }
-
- if (rbuf->m_pack) {
- bus_dmamap_sync(rxr->ptag, rbuf->pmap, BUS_DMASYNC_POSTREAD);
- bus_dmamap_unload(rxr->ptag, rbuf->pmap);
- m_free(rbuf->m_pack);
- rbuf->m_pack = NULL;
+ if ((status & (1 << I40E_RX_DESC_STATUS_DD_SHIFT)) == 0)
+ break;
+ if (++i == nrxd)
+ i = 0;
+ if (status & (1 << I40E_RX_DESC_STATUS_EOF_SHIFT))
+ cnt++;
}
+
+ return (cnt);
}
-#ifdef RSS
/*
** i40e_ptype_to_hash: parse the packet type
** to determine the appropriate hash.
@@ -1631,13 +588,13 @@
decoded = decode_rx_desc_ptype(ptype);
if (!decoded.known)
- return M_HASHTYPE_OPAQUE_HASH;
+ return M_HASHTYPE_OPAQUE;
- if (decoded.outer_ip == I40E_RX_PTYPE_OUTER_L2)
- return M_HASHTYPE_OPAQUE_HASH;
+ if (decoded.outer_ip == I40E_RX_PTYPE_OUTER_L2)
+ return M_HASHTYPE_OPAQUE;
/* Note: anything that gets to this point is IP */
- if (decoded.outer_ip_ver == I40E_RX_PTYPE_OUTER_IPV6) {
+ if (decoded.outer_ip_ver == I40E_RX_PTYPE_OUTER_IPV6) {
switch (decoded.inner_prot) {
case I40E_RX_PTYPE_INNER_PROT_TCP:
return M_HASHTYPE_RSS_TCP_IPV6;
@@ -1647,7 +604,7 @@
return M_HASHTYPE_RSS_IPV6;
}
}
- if (decoded.outer_ip_ver == I40E_RX_PTYPE_OUTER_IPV4) {
+ if (decoded.outer_ip_ver == I40E_RX_PTYPE_OUTER_IPV4) {
switch (decoded.inner_prot) {
case I40E_RX_PTYPE_INNER_PROT_TCP:
return M_HASHTYPE_RSS_TCP_IPV4;
@@ -1658,56 +615,38 @@
}
}
/* We should never get here!! */
- return M_HASHTYPE_OPAQUE_HASH;
+ return M_HASHTYPE_OPAQUE;
}
-#endif /* RSS */
/*********************************************************************
*
- * This routine executes in interrupt context. It replenishes
- * the mbufs in the descriptor and sends data which has been
+ * This routine executes in ithread context. It sends data which has been
* dma'ed into host memory to upper layer.
*
- * We loop at most count times if count is > 0, or until done if
- * count < 0.
+ * Returns 0 upon success, errno on failure
*
- * Return TRUE for more work, FALSE for all clean.
*********************************************************************/
-bool
-ixl_rxeof(struct ixl_queue *que, int count)
+static int
+ixl_isc_rxd_pkt_get(void *arg, if_rxd_info_t ri)
{
- struct ixl_vsi *vsi = que->vsi;
+ struct ixl_vsi *vsi = arg;
+ struct ixl_rx_queue *que = &vsi->rx_queues[ri->iri_qsidx];
struct rx_ring *rxr = &que->rxr;
- struct ifnet *ifp = vsi->ifp;
-#if defined(INET6) || defined(INET)
- struct lro_ctrl *lro = &rxr->lro;
-#endif
- int i, nextp, processed = 0;
union i40e_rx_desc *cur;
- struct ixl_rx_buf *rbuf, *nbuf;
-
- IXL_RX_LOCK(rxr);
+ u32 status, error;
+ u16 plen, vtag;
+ u64 qword;
+ u8 ptype;
+ bool eop;
+ int i, cidx;
+
+ cidx = ri->iri_cidx;
+ i = 0;
+ do {
+ /* 5 descriptor receive limit */
+ MPASS(i < IXL_MAX_RX_SEGS);
-#ifdef DEV_NETMAP
- if (netmap_rx_irq(ifp, que->me, &count)) {
- IXL_RX_UNLOCK(rxr);
- return (FALSE);
- }
-#endif /* DEV_NETMAP */
-
- for (i = rxr->next_check; count != 0;) {
- struct mbuf *sendmp, *mh, *mp;
- u32 status, error;
- u16 hlen, plen, vtag;
- u64 qword;
- u8 ptype;
- bool eop;
-
- /* Sync the ring. */
- bus_dmamap_sync(rxr->dma.tag, rxr->dma.map,
- BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
-
- cur = &rxr->base[i];
+ cur = &rxr->rx_base[cidx];
qword = le64toh(cur->wb.qword1.status_error_len);
status = (qword & I40E_RXD_QW1_STATUS_MASK)
>> I40E_RXD_QW1_STATUS_SHIFT;
@@ -1715,229 +654,54 @@
>> I40E_RXD_QW1_ERROR_SHIFT;
plen = (qword & I40E_RXD_QW1_LENGTH_PBUF_MASK)
>> I40E_RXD_QW1_LENGTH_PBUF_SHIFT;
- hlen = (qword & I40E_RXD_QW1_LENGTH_HBUF_MASK)
- >> I40E_RXD_QW1_LENGTH_HBUF_SHIFT;
ptype = (qword & I40E_RXD_QW1_PTYPE_MASK)
>> I40E_RXD_QW1_PTYPE_SHIFT;
- if ((status & (1 << I40E_RX_DESC_STATUS_DD_SHIFT)) == 0) {
- ++rxr->not_done;
- break;
- }
- if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
- break;
+ /* we should never be called without a valid descriptor */
+ MPASS((status & (1 << I40E_RX_DESC_STATUS_DD_SHIFT)) != 0);
+
+ ri->iri_len += plen;
+ rxr->bytes += plen;
- count--;
- sendmp = NULL;
- nbuf = NULL;
cur->wb.qword1.status_error_len = 0;
- rbuf = &rxr->buffers[i];
- mh = rbuf->m_head;
- mp = rbuf->m_pack;
eop = (status & (1 << I40E_RX_DESC_STATUS_EOF_SHIFT));
if (status & (1 << I40E_RX_DESC_STATUS_L2TAG1P_SHIFT))
vtag = le16toh(cur->wb.qword0.lo_dword.l2tag1);
else
vtag = 0;
- /* Remove device access to the rx buffers. */
- if (rbuf->m_head != NULL) {
- bus_dmamap_sync(rxr->htag, rbuf->hmap,
- BUS_DMASYNC_POSTREAD);
- bus_dmamap_unload(rxr->htag, rbuf->hmap);
- }
- if (rbuf->m_pack != NULL) {
- bus_dmamap_sync(rxr->ptag, rbuf->pmap,
- BUS_DMASYNC_POSTREAD);
- bus_dmamap_unload(rxr->ptag, rbuf->pmap);
- }
-
/*
** Make sure bad packets are discarded,
** note that only EOP descriptor has valid
** error results.
*/
- if (eop && (error & (1 << I40E_RX_DESC_ERROR_RXE_SHIFT))) {
+ if (eop && (error & (1 << I40E_RX_DESC_ERROR_RXE_SHIFT))) {
rxr->desc_errs++;
- ixl_rx_discard(rxr, i);
- goto next_desc;
- }
-
- /* Prefetch the next buffer */
- if (!eop) {
- nextp = i + 1;
- if (nextp == que->num_rx_desc)
- nextp = 0;
- nbuf = &rxr->buffers[nextp];
- prefetch(nbuf);
- }
-
- /*
- ** The header mbuf is ONLY used when header
- ** split is enabled, otherwise we get normal
- ** behavior, ie, both header and payload
- ** are DMA'd into the payload buffer.
- **
- ** Rather than using the fmp/lmp global pointers
- ** we now keep the head of a packet chain in the
- ** buffer struct and pass this along from one
- ** descriptor to the next, until we get EOP.
- */
- if (rxr->hdr_split && (rbuf->fmp == NULL)) {
- if (hlen > IXL_RX_HDR)
- hlen = IXL_RX_HDR;
- mh->m_len = hlen;
- mh->m_flags |= M_PKTHDR;
- mh->m_next = NULL;
- mh->m_pkthdr.len = mh->m_len;
- /* Null buf pointer so it is refreshed */
- rbuf->m_head = NULL;
- /*
- ** Check the payload length, this
- ** could be zero if its a small
- ** packet.
- */
- if (plen > 0) {
- mp->m_len = plen;
- mp->m_next = NULL;
- mp->m_flags &= ~M_PKTHDR;
- mh->m_next = mp;
- mh->m_pkthdr.len += mp->m_len;
- /* Null buf pointer so it is refreshed */
- rbuf->m_pack = NULL;
- rxr->split++;
- }
- /*
- ** Now create the forward
- ** chain so when complete
- ** we wont have to.
- */
- if (eop == 0) {
- /* stash the chain head */
- nbuf->fmp = mh;
- /* Make forward chain */
- if (plen)
- mp->m_next = nbuf->m_pack;
- else
- mh->m_next = nbuf->m_pack;
- } else {
- /* Singlet, prepare to send */
- sendmp = mh;
- if (vtag) {
- sendmp->m_pkthdr.ether_vtag = vtag;
- sendmp->m_flags |= M_VLANTAG;
- }
- }
- } else {
- /*
- ** Either no header split, or a
- ** secondary piece of a fragmented
- ** split packet.
- */
- mp->m_len = plen;
- /*
- ** See if there is a stored head
- ** that determines what we are
- */
- sendmp = rbuf->fmp;
- rbuf->m_pack = rbuf->fmp = NULL;
-
- if (sendmp != NULL) /* secondary frag */
- sendmp->m_pkthdr.len += mp->m_len;
- else {
- /* first desc of a non-ps chain */
- sendmp = mp;
- sendmp->m_flags |= M_PKTHDR;
- sendmp->m_pkthdr.len = mp->m_len;
- }
- /* Pass the head pointer on */
- if (eop == 0) {
- nbuf->fmp = sendmp;
- sendmp = NULL;
- mp->m_next = nbuf->m_pack;
- }
- }
- ++processed;
- /* Sending this frame? */
- if (eop) {
- sendmp->m_pkthdr.rcvif = ifp;
- /* gather stats */
- rxr->rx_packets++;
- rxr->rx_bytes += sendmp->m_pkthdr.len;
- /* capture data for dynamic ITR adjustment */
- rxr->packets++;
- rxr->bytes += sendmp->m_pkthdr.len;
- /* Set VLAN tag (field only valid in eop desc) */
- if (vtag) {
- sendmp->m_pkthdr.ether_vtag = vtag;
- sendmp->m_flags |= M_VLANTAG;
- }
- if ((ifp->if_capenable & IFCAP_RXCSUM) != 0)
- ixl_rx_checksum(sendmp, status, error, ptype);
-#ifdef RSS
- sendmp->m_pkthdr.flowid =
- le32toh(cur->wb.qword0.hi_dword.rss);
- M_HASHTYPE_SET(sendmp, ixl_ptype_to_hash(ptype));
-#else
- sendmp->m_pkthdr.flowid = que->msix;
- M_HASHTYPE_SET(sendmp, M_HASHTYPE_OPAQUE);
-#endif
- }
-next_desc:
- bus_dmamap_sync(rxr->dma.tag, rxr->dma.map,
- BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
-
- /* Advance our pointers to the next descriptor. */
- if (++i == que->num_rx_desc)
- i = 0;
-
- /* Now send to the stack or do LRO */
- if (sendmp != NULL) {
- rxr->next_check = i;
- IXL_RX_UNLOCK(rxr);
- ixl_rx_input(rxr, ifp, sendmp, ptype);
- IXL_RX_LOCK(rxr);
- /*
- * Update index used in loop in case another
- * ixl_rxeof() call executes when lock is released
- */
- i = rxr->next_check;
- }
-
- /* Every 8 descriptors we go to refresh mbufs */
- if (processed == 8) {
- ixl_refresh_mbufs(que, i);
- processed = 0;
- }
- }
-
- /* Refresh any remaining buf structs */
- if (ixl_rx_unrefreshed(que))
- ixl_refresh_mbufs(que, i);
-
- rxr->next_check = i;
-
- IXL_RX_UNLOCK(rxr);
-
-#if defined(INET6) || defined(INET)
- /*
- * Flush any outstanding LRO work
- */
-#if __FreeBSD_version >= 1100105
- tcp_lro_flush_all(lro);
-#else
- struct lro_entry *queued;
- while ((queued = SLIST_FIRST(&lro->lro_active)) != NULL) {
- SLIST_REMOVE_HEAD(&lro->lro_active, next);
- tcp_lro_flush(lro, queued);
- }
-#endif
-#endif /* defined(INET6) || defined(INET) */
-
- return (FALSE);
+ return (EBADMSG);
+ }
+ ri->iri_frags[i].irf_flid = 0;
+ ri->iri_frags[i].irf_idx = cidx;
+ ri->iri_frags[i].irf_len = plen;
+ if (++cidx == vsi->shared->isc_nrxd[0])
+ cidx = 0;
+ i++;
+ } while (!eop);
+
+ /* capture data for dynamic ITR adjustment */
+ rxr->packets++;
+ rxr->rx_packets++;
+
+ if ((vsi->ifp->if_capenable & IFCAP_RXCSUM) != 0)
+ ixl_rx_checksum(ri, status, error, ptype);
+ ri->iri_flowid = le32toh(cur->wb.qword0.hi_dword.rss);
+ ri->iri_rsstype = ixl_ptype_to_hash(ptype);
+ ri->iri_vtag = vtag;
+ ri->iri_nfrags = i;
+ if (vtag)
+ ri->iri_flags |= M_VLANTAG;
+ return (0);
}
-
/*********************************************************************
*
* Verify that the hardware indicated that the checksum is valid.
@@ -1946,194 +710,64 @@
*
*********************************************************************/
static void
-ixl_rx_checksum(struct mbuf * mp, u32 status, u32 error, u8 ptype)
+ixl_rx_checksum(if_rxd_info_t ri, u32 status, u32 error, u8 ptype)
{
struct i40e_rx_ptype_decoded decoded;
- decoded = decode_rx_desc_ptype(ptype);
+ ri->iri_csum_flags = 0;
- /* Errors? */
- if (error & ((1 << I40E_RX_DESC_ERROR_IPE_SHIFT) |
- (1 << I40E_RX_DESC_ERROR_L4E_SHIFT))) {
- mp->m_pkthdr.csum_flags = 0;
+ /* No L3 or L4 checksum was calculated */
+ if (!(status & (1 << I40E_RX_DESC_STATUS_L3L4P_SHIFT)))
return;
- }
+
+ decoded = decode_rx_desc_ptype(ptype);
/* IPv6 with extension headers likely have bad csum */
if (decoded.outer_ip == I40E_RX_PTYPE_OUTER_IP &&
- decoded.outer_ip_ver == I40E_RX_PTYPE_OUTER_IPV6)
+ decoded.outer_ip_ver == I40E_RX_PTYPE_OUTER_IPV6) {
if (status &
(1 << I40E_RX_DESC_STATUS_IPV6EXADD_SHIFT)) {
- mp->m_pkthdr.csum_flags = 0;
+ ri->iri_csum_flags = 0;
return;
}
-
-
- /* IP Checksum Good */
- mp->m_pkthdr.csum_flags = CSUM_IP_CHECKED;
- mp->m_pkthdr.csum_flags |= CSUM_IP_VALID;
-
- if (status & (1 << I40E_RX_DESC_STATUS_L3L4P_SHIFT)) {
- mp->m_pkthdr.csum_flags |=
- (CSUM_DATA_VALID | CSUM_PSEUDO_HDR);
- mp->m_pkthdr.csum_data |= htons(0xffff);
}
- return;
-}
-#if __FreeBSD_version >= 1100000
-uint64_t
-ixl_get_counter(if_t ifp, ift_counter cnt)
-{
- struct ixl_vsi *vsi;
-
- vsi = if_getsoftc(ifp);
-
- switch (cnt) {
- case IFCOUNTER_IPACKETS:
- return (vsi->ipackets);
- case IFCOUNTER_IERRORS:
- return (vsi->ierrors);
- case IFCOUNTER_OPACKETS:
- return (vsi->opackets);
- case IFCOUNTER_OERRORS:
- return (vsi->oerrors);
- case IFCOUNTER_COLLISIONS:
- /* Collisions are by standard impossible in 40G/10G Ethernet */
- return (0);
- case IFCOUNTER_IBYTES:
- return (vsi->ibytes);
- case IFCOUNTER_OBYTES:
- return (vsi->obytes);
- case IFCOUNTER_IMCASTS:
- return (vsi->imcasts);
- case IFCOUNTER_OMCASTS:
- return (vsi->omcasts);
- case IFCOUNTER_IQDROPS:
- return (vsi->iqdrops);
- case IFCOUNTER_OQDROPS:
- return (vsi->oqdrops);
- case IFCOUNTER_NOPROTO:
- return (vsi->noproto);
- default:
- return (if_get_counter_default(ifp, cnt));
- }
-}
-#endif
+ ri->iri_csum_flags |= CSUM_L3_CALC;
-/*
- * Set TX and RX ring size adjusting value to supported range
- */
-void
-ixl_vsi_setup_rings_size(struct ixl_vsi * vsi, int tx_ring_size, int rx_ring_size)
-{
- struct device * dev = vsi->dev;
-
- if (tx_ring_size < IXL_MIN_RING
- || tx_ring_size > IXL_MAX_RING
- || tx_ring_size % IXL_RING_INCREMENT != 0) {
- device_printf(dev, "Invalid tx_ring_size value of %d set!\n",
- tx_ring_size);
- device_printf(dev, "tx_ring_size must be between %d and %d, "
- "inclusive, and must be a multiple of %d\n",
- IXL_MIN_RING, IXL_MAX_RING, IXL_RING_INCREMENT);
- device_printf(dev, "Using default value of %d instead\n",
- IXL_DEFAULT_RING);
- vsi->num_tx_desc = IXL_DEFAULT_RING;
- } else
- vsi->num_tx_desc = tx_ring_size;
-
- if (rx_ring_size < IXL_MIN_RING
- || rx_ring_size > IXL_MAX_RING
- || rx_ring_size % IXL_RING_INCREMENT != 0) {
- device_printf(dev, "Invalid rx_ring_size value of %d set!\n",
- rx_ring_size);
- device_printf(dev, "rx_ring_size must be between %d and %d, "
- "inclusive, and must be a multiple of %d\n",
- IXL_MIN_RING, IXL_MAX_RING, IXL_RING_INCREMENT);
- device_printf(dev, "Using default value of %d instead\n",
- IXL_DEFAULT_RING);
- vsi->num_rx_desc = IXL_DEFAULT_RING;
- } else
- vsi->num_rx_desc = rx_ring_size;
-
- device_printf(dev, "using %d tx descriptors and %d rx descriptors\n",
- vsi->num_tx_desc, vsi->num_rx_desc);
+ /* IPv4 checksum error */
+ if (error & (1 << I40E_RX_DESC_ERROR_IPE_SHIFT))
+ return;
-}
+ ri->iri_csum_flags |= CSUM_L3_VALID;
+ ri->iri_csum_flags |= CSUM_L4_CALC;
-static void
-ixl_queue_sw_irq(struct ixl_vsi *vsi, int qidx)
-{
- struct i40e_hw *hw = vsi->hw;
- u32 reg, mask;
-
- if ((vsi->flags & IXL_FLAGS_IS_VF) != 0) {
- mask = (I40E_VFINT_DYN_CTLN1_INTENA_MASK |
- I40E_VFINT_DYN_CTLN1_SWINT_TRIG_MASK |
- I40E_VFINT_DYN_CTLN1_ITR_INDX_MASK);
-
- reg = I40E_VFINT_DYN_CTLN1(qidx);
- } else {
- mask = (I40E_PFINT_DYN_CTLN_INTENA_MASK |
- I40E_PFINT_DYN_CTLN_SWINT_TRIG_MASK |
- I40E_PFINT_DYN_CTLN_ITR_INDX_MASK);
-
- reg = ((vsi->flags & IXL_FLAGS_USES_MSIX) != 0) ?
- I40E_PFINT_DYN_CTLN(qidx) : I40E_PFINT_DYN_CTL0;
- }
+ /* L4 checksum error */
+ if (error & (1 << I40E_RX_DESC_ERROR_L4E_SHIFT))
+ return;
- wr32(hw, reg, mask);
+ ri->iri_csum_flags |= CSUM_L4_VALID;
+ ri->iri_csum_data |= htons(0xffff);
}
-int
-ixl_queue_hang_check(struct ixl_vsi *vsi)
-{
- struct ixl_queue *que = vsi->queues;
- device_t dev = vsi->dev;
- struct tx_ring *txr;
- s32 timer, new_timer;
- int hung = 0;
-
- for (int i = 0; i < vsi->num_queues; i++, que++) {
- txr = &que->txr;
- /*
- * If watchdog_timer is equal to defualt value set by ixl_txeof
- * just substract hz and move on - the queue is most probably
- * running. Otherwise check the value.
- */
- if (atomic_cmpset_rel_32(&txr->watchdog_timer,
- IXL_WATCHDOG, (IXL_WATCHDOG) - hz) == 0) {
- timer = atomic_load_acq_32(&txr->watchdog_timer);
- /*
- * Again - if the timer was reset to default value
- * then queue is running. Otherwise check if watchdog
- * expired and act accrdingly.
- */
-
- if (timer > 0 && timer != IXL_WATCHDOG) {
- new_timer = timer - hz;
- if (new_timer <= 0) {
- atomic_store_rel_32(&txr->watchdog_timer, -1);
- device_printf(dev, "WARNING: queue %d "
- "appears to be hung!\n", que->me);
- ++hung;
- /* Try to unblock the queue with SW IRQ */
- ixl_queue_sw_irq(vsi, i);
- } else {
- /*
- * If this fails, that means something in the TX path
- * has updated the watchdog, so it means the TX path
- * is still working and the watchdog doesn't need
- * to countdown.
- */
- atomic_cmpset_rel_32(&txr->watchdog_timer,
- timer, new_timer);
- }
- }
- }
- }
-
- return (hung);
+/*
+ * Input: bitmap of enum i40e_aq_link_speed
+ */
+u64
+ixl_max_aq_speed_to_value(u8 link_speeds)
+{
+ if (link_speeds & I40E_LINK_SPEED_40GB)
+ return IF_Gbps(40);
+ if (link_speeds & I40E_LINK_SPEED_25GB)
+ return IF_Gbps(25);
+ if (link_speeds & I40E_LINK_SPEED_20GB)
+ return IF_Gbps(20);
+ if (link_speeds & I40E_LINK_SPEED_10GB)
+ return IF_Gbps(10);
+ if (link_speeds & I40E_LINK_SPEED_1GB)
+ return IF_Gbps(1);
+ if (link_speeds & I40E_LINK_SPEED_100MB)
+ return IF_Mbps(100);
+ else
+ /* Minimum supported link speed */
+ return IF_Mbps(100);
}
-
Index: sys/dev/ixl/ixlv.h
===================================================================
--- sys/dev/ixl/ixlv.h
+++ sys/dev/ixl/ixlv.h
@@ -38,8 +38,7 @@
#include "ixlv_vc_mgr.h"
-#define IXLV_AQ_MAX_ERR 30
-#define IXLV_MAX_INIT_WAIT 120
+#define IXLV_AQ_MAX_ERR 200
#define IXLV_MAX_FILTERS 128
#define IXLV_MAX_QUEUES 16
#define IXLV_AQ_TIMEOUT (1 * hz)
@@ -79,6 +78,8 @@
"\23I40E_VIRTCHNL_VF_OFFLOAD_RSS_PCTYPE_V2" \
"\24I40E_VIRTCHNL_VF_OFFLOAD_RSS_PF"
+static MALLOC_DEFINE(M_IXLV, "ixlv", "ixlv driver allocations");
+
/* Driver state */
enum ixlv_state_t {
IXLV_START,
@@ -144,9 +145,10 @@
u32 qbase;
u32 admvec;
struct timeout_task timeout;
+#ifdef notyet
struct task aq_irq;
struct task aq_sched;
- struct taskqueue *tq;
+#endif
struct ixl_vsi vsi;
@@ -186,7 +188,6 @@
u8 aq_buffer[IXL_AQ_BUF_SZ];
};
-#define IXLV_CORE_LOCK_ASSERT(sc) mtx_assert(&(sc)->mtx, MA_OWNED)
/*
** This checks for a zero mac addr, something that will be likely
** unless the Admin on the Host has created one.
@@ -205,6 +206,8 @@
/*
** VF Common function prototypes
*/
+void ixlv_if_init(if_ctx_t ctx);
+
int ixlv_send_api_ver(struct ixlv_sc *);
int ixlv_verify_api_ver(struct ixlv_sc *);
int ixlv_send_vf_config_msg(struct ixlv_sc *);
Index: sys/dev/ixl/ixlvc.c
===================================================================
--- sys/dev/ixl/ixlvc.c
+++ sys/dev/ixl/ixlvc.c
@@ -386,7 +386,9 @@
{
device_t dev = sc->dev;
struct ixl_vsi *vsi = &sc->vsi;
- struct ixl_queue *que = vsi->queues;
++ if_softc_ctx_t scctx = iflib_get_softc_ctx(vsi->ctx);
++ struct ixl_tx_queue *tx_que = vsi->tx_queues;
++ struct ixl_rx_queue *rx_que = vsi->rx_queues;
struct tx_ring *txr;
struct rx_ring *rxr;
int len, pairs;
@@ -394,7 +396,9 @@
struct virtchnl_vsi_queue_config_info *vqci;
struct virtchnl_queue_pair_info *vqpi;
- pairs = vsi->num_queues;
++ /* XXX: Linux PF driver wants matching ids in each tx/rx struct, so both TX/RX
++ * queues of a pair need to be configured */
++ pairs = max(vsi->num_tx_queues, vsi->num_rx_queues);
len = sizeof(struct virtchnl_vsi_queue_config_info) +
(sizeof(struct virtchnl_queue_pair_info) * pairs);
vqci = malloc(len, M_DEVBUF, M_NOWAIT | M_ZERO);
@@ -409,25 +413,24 @@
/* Size check is not needed here - HW max is 16 queue pairs, and we
* can fit info for 31 of them into the AQ buffer before it overflows.
*/
- for (int i = 0; i < pairs; i++, que++, vqpi++) {
- txr = &que->txr;
- rxr = &que->rxr;
++ for (int i = 0; i < pairs; i++, tx_que++, rx_que++, vqpi++) {
++ txr = &tx_que->txr;
++ rxr = &rx_que->rxr;
++
vqpi->txq.vsi_id = vqci->vsi_id;
vqpi->txq.queue_id = i;
- vqpi->txq.ring_len = que->num_tx_desc;
- vqpi->txq.dma_ring_addr = txr->dma.pa;
++ vqpi->txq.ring_len = scctx->isc_ntxd[0];
++ vqpi->txq.dma_ring_addr = txr->tx_paddr;
/* Enable Head writeback */
- if (vsi->enable_head_writeback) {
- vqpi->txq.headwb_enabled = 1;
- vqpi->txq.dma_headwb_addr = txr->dma.pa +
- (que->num_tx_desc * sizeof(struct i40e_tx_desc));
- }
+ vqpi->txq.headwb_enabled = 0;
+ vqpi->txq.dma_headwb_addr = 0;
vqpi->rxq.vsi_id = vqci->vsi_id;
vqpi->rxq.queue_id = i;
- vqpi->rxq.ring_len = que->num_rx_desc;
- vqpi->rxq.dma_ring_addr = rxr->dma.pa;
- vqpi->rxq.max_pkt_size = vsi->max_frame_size;
++ vqpi->rxq.ring_len = scctx->isc_nrxd[0];
++ vqpi->rxq.dma_ring_addr = rxr->rx_paddr;
++ vqpi->rxq.max_pkt_size = scctx->isc_max_frame_size;
++ // TODO: Get this value from iflib, somehow
vqpi->rxq.databuffer_size = rxr->mbuf_sz;
vqpi->rxq.splithdr_enabled = 0;
}
@@ -448,6 +451,8 @@
struct virtchnl_queue_select vqs;
vqs.vsi_id = sc->vsi_res->vsi_id;
++ /* XXX: In Linux PF, as long as neither of these is 0,
++ * every queue in VF VSI is enabled. */
vqs.tx_queues = (1 << sc->vsi_res->num_queue_pairs) - 1;
vqs.rx_queues = vqs.tx_queues;
ixlv_send_pf_msg(sc, VIRTCHNL_OP_ENABLE_QUEUES,
@@ -465,6 +470,8 @@
struct virtchnl_queue_select vqs;
vqs.vsi_id = sc->vsi_res->vsi_id;
++ /* XXX: In Linux PF, as long as neither of these is 0,
++ * every queue in VF VSI is disabled. */
vqs.tx_queues = (1 << sc->vsi_res->num_queue_pairs) - 1;
vqs.rx_queues = vqs.tx_queues;
ixlv_send_pf_msg(sc, VIRTCHNL_OP_DISABLE_QUEUES,
@@ -483,27 +490,33 @@
struct virtchnl_irq_map_info *vm;
int i, q, len;
struct ixl_vsi *vsi = &sc->vsi;
- struct ixl_queue *que = vsi->queues;
++ struct ixl_rx_queue *rx_que = vsi->rx_queues;
++ if_softc_ctx_t scctx = vsi->shared;
++ device_t dev = sc->dev;
++
++ // XXX: What happens if we only get 1 MSI-X vector?
++ MPASS(scctx->isc_vectors > 1);
/* How many queue vectors, adminq uses one */
- q = sc->msix - 1;
++ // XXX: How do we know how many interrupt vectors we have?
++ q = scctx->isc_vectors - 1;
len = sizeof(struct virtchnl_irq_map_info) +
- (sc->msix * sizeof(struct virtchnl_vector_map));
++ (scctx->isc_vectors * sizeof(struct i40e_virtchnl_vector_map));
vm = malloc(len, M_DEVBUF, M_NOWAIT);
if (!vm) {
- printf("%s: unable to allocate memory\n", __func__);
++ device_printf(dev, "%s: unable to allocate memory\n", __func__);
ixl_vc_schedule_retry(&sc->vc_mgr);
return;
}
- vm->num_vectors = sc->msix;
++ vm->num_vectors = scctx->isc_vectors;
/* Queue vectors first */
- for (i = 0; i < q; i++, que++) {
++ for (i = 0; i < q; i++, rx_que++) {
vm->vecmap[i].vsi_id = sc->vsi_res->vsi_id;
vm->vecmap[i].vector_id = i + 1; /* first is adminq */
- vm->vecmap[i].txq_map = (1 << que->me);
- vm->vecmap[i].rxq_map = (1 << que->me);
+ // vm->vecmap[i].txq_map = (1 << que->me);
+ vm->vecmap[i].rxq_map = (1 << rx_que->rxr.me);
vm->vecmap[i].rxitr_idx = 0;
vm->vecmap[i].txitr_idx = 1;
}
@@ -811,8 +824,10 @@
uint64_t tx_discards;
tx_discards = es->tx_discards;
+#if 0
for (int i = 0; i < vsi->num_queues; i++)
tx_discards += sc->vsi.queues[i].txr.br->br_drops;
+#endif
/* Update ifnet stats */
IXL_SET_IPACKETS(vsi, es->rx_unicast +
@@ -875,8 +890,12 @@
ixlv_set_rss_hena(struct ixlv_sc *sc)
{
struct virtchnl_rss_hena hena;
++ struct i40e_hw *hw = &sc->hw;
- hena.hena = IXL_DEFAULT_RSS_HENA_X722;
++ if (hw->mac.type == I40E_MAC_X722_VF)
++ hena.hena = IXL_DEFAULT_RSS_HENA_X722;
++ else
++ hena.hena = IXL_DEFAULT_RSS_HENA_XL710;
ixlv_send_pf_msg(sc, VIRTCHNL_OP_SET_RSS_HENA,
(u8 *)&hena, sizeof(hena));
@@ -912,9 +931,9 @@
* num_queues.)
*/
que_id = rss_get_indirection_to_bucket(i);
- que_id = que_id % sc->vsi.num_queues;
++ que_id = que_id % sc->vsi.num_rx_queues;
#else
- que_id = i % sc->vsi.num_queues;
++ que_id = i % sc->vsi.num_rx_queues;
#endif
lut = que_id & IXL_RSS_VSI_LUT_ENTRY_MASK;
rss_lut_msg->lut[i] = lut;
@@ -961,9 +980,9 @@
case VIRTCHNL_EVENT_RESET_IMPENDING:
device_printf(dev, "PF initiated reset!\n");
sc->init_state = IXLV_RESET_PENDING;
- mtx_unlock(&sc->mtx);
- ixlv_init(vsi);
- mtx_lock(&sc->mtx);
++ // mtx_unlock(&sc->mtx);
++ ixlv_if_init(sc->vsi.ctx);
++ // mtx_lock(&sc->mtx);
break;
default:
device_printf(dev, "%s: Unknown event %d from AQ\n",
@@ -1023,7 +1042,7 @@
/* Turn on all interrupts */
ixlv_enable_intr(vsi);
/* And inform the stack we're ready */
- vsi->ifp->if_drv_flags |= IFF_DRV_RUNNING;
+ // vsi->ifp->if_drv_flags |= IFF_DRV_RUNNING;
/* TODO: Clear a state flag, so we know we're ready to run init again */
}
break;
@@ -1161,7 +1180,6 @@
{
struct ixl_vc_mgr *mgr = (struct ixl_vc_mgr *)arg;
- IXLV_CORE_LOCK_ASSERT(mgr->sc);
ixl_vc_process_completion(mgr, I40E_ERR_TIMEOUT);
}
@@ -1170,7 +1188,6 @@
{
struct ixl_vc_mgr *mgr = (struct ixl_vc_mgr *)arg;
- IXLV_CORE_LOCK_ASSERT(mgr->sc);
ixl_vc_send_current(mgr);
}
@@ -1213,8 +1230,6 @@
ixl_vc_enqueue(struct ixl_vc_mgr *mgr, struct ixl_vc_cmd *cmd,
uint32_t req, ixl_vc_callback_t *callback, void *arg)
{
- IXLV_CORE_LOCK_ASSERT(mgr->sc);
-
if (cmd->flags & IXLV_VC_CMD_FLAG_BUSY) {
if (mgr->current == cmd)
mgr->current = NULL;
@@ -1236,7 +1251,6 @@
{
struct ixl_vc_cmd *cmd;
- IXLV_CORE_LOCK_ASSERT(mgr->sc);
KASSERT(TAILQ_EMPTY(&mgr->pending) || mgr->current != NULL,
("ixlv: pending commands waiting but no command in progress"));
Index: sys/modules/Makefile
===================================================================
--- sys/modules/Makefile
+++ sys/modules/Makefile
@@ -206,7 +206,6 @@
${_ix} \
${_ixv} \
${_ixl} \
- ${_ixlv} \
jme \
joy \
kbdmux \
Index: sys/modules/ixl/Makefile
===================================================================
--- sys/modules/ixl/Makefile
+++ sys/modules/ixl/Makefile
@@ -3,11 +3,10 @@
.PATH: ${SRCTOP}/sys/dev/ixl
KMOD = if_ixl
-SRCS = device_if.h bus_if.h pci_if.h
-SRCS += opt_inet.h opt_inet6.h opt_rss.h opt_ixl.h
+SRCS = device_if.h bus_if.h pci_if.h ifdi_if.h
+SRCS += opt_inet.h opt_inet6.h opt_rss.h opt_ixl.h opt_iflib.h
SRCS += if_ixl.c ixl_pf_main.c ixl_pf_qmgr.c ixl_txrx.c ixl_pf_i2c.c i40e_osdep.c
-SRCS += ixl_iw.c
-SRCS.PCI_IOV= pci_iov_if.h ixl_pf_iov.c
+SRCS.PCI_IOV = pci_iov_if.h ixl_pf_iov.c
# Shared source
SRCS += i40e_common.c i40e_nvm.c i40e_adminq.c i40e_lan_hmc.c i40e_hmc.c i40e_dcb.c
@@ -15,4 +14,7 @@
# Debug messages / sysctls
# CFLAGS += -DIXL_DEBUG
+#CFLAGS += -DIXL_IW
+#SRCS += ixl_iw.c
+
.include <bsd.kmod.mk>
Index: sys/modules/ixlv/Makefile
===================================================================
--- sys/modules/ixlv/Makefile
+++ sys/modules/ixlv/Makefile
@@ -3,8 +3,8 @@
.PATH: ${SRCTOP}/sys/dev/ixl
KMOD = if_ixlv
-SRCS = device_if.h bus_if.h pci_if.h
-SRCS += opt_inet.h opt_inet6.h opt_rss.h opt_ixl.h
+SRCS = device_if.h bus_if.h pci_if.h ifdi_if.h
+SRCS += opt_inet.h opt_inet6.h opt_rss.h opt_ixl.h opt_iflib.h
SRCS += if_ixlv.c ixlvc.c ixl_txrx.c i40e_osdep.c
# Shared source
Index: sys/net/iflib.c
===================================================================
--- sys/net/iflib.c
+++ sys/net/iflib.c
@@ -2275,7 +2275,7 @@
}
}
}
- done:
+done:
if_setdrvflagbits(ctx->ifc_ifp, IFF_DRV_RUNNING, IFF_DRV_OACTIVE);
IFDI_INTR_ENABLE(ctx);
txq = ctx->ifc_txqs;
@@ -4025,7 +4025,7 @@
*/
if (avoid_reset) {
if_setflagbits(ifp, IFF_UP,0);
- if (!(if_getdrvflags(ifp)& IFF_DRV_RUNNING))
+ if (!(if_getdrvflags(ifp) & IFF_DRV_RUNNING))
reinit = 1;
#ifdef INET
if (!(if_getflags(ifp) & IFF_NOARP))
@@ -4126,7 +4126,7 @@
#endif
setmask |= (mask & IFCAP_FLAGS);
- if (setmask & (IFCAP_RXCSUM | IFCAP_RXCSUM_IPV6))
+ if (setmask & (IFCAP_RXCSUM | IFCAP_RXCSUM_IPV6))
setmask |= (IFCAP_RXCSUM | IFCAP_RXCSUM_IPV6);
if ((mask & IFCAP_WOL) &&
(if_getcapabilities(ifp) & IFCAP_WOL) != 0)
@@ -4151,7 +4151,7 @@
CTX_UNLOCK(ctx);
}
break;
- }
+ }
case SIOCGPRIVATE_0:
case SIOCSDRVSPEC:
case SIOCGDRVSPEC:
@@ -5106,7 +5106,7 @@
KASSERT(ntxqs > 0, ("number of queues per qset must be at least 1"));
KASSERT(nrxqs > 0, ("number of queues per qset must be at least 1"));
-/* Allocate the TX ring struct memory */
+ /* Allocate the TX ring struct memory */
if (!(ctx->ifc_txqs =
(iflib_txq_t) malloc(sizeof(struct iflib_txq) *
ntxqsets, M_IFLIB, M_NOWAIT | M_ZERO))) {
@@ -5639,7 +5639,7 @@
}
void
-iflib_softirq_alloc_generic(if_ctx_t ctx, if_irq_t irq, iflib_intr_type_t type, void *arg, int qid, char *name)
+iflib_softirq_alloc_generic(if_ctx_t ctx, if_irq_t irq, iflib_intr_type_t type, void *arg, int qid, char *name)
{
struct grouptask *gtask;
struct taskqgroup *tqg;

File Metadata

Mime Type
text/plain
Expires
Sat, May 16, 1:47 PM (11 h, 40 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
33132072
Default Alt Text
D15577.id43030.diff (342 KB)

Event Timeline