171d10453SEric Joyner /* SPDX-License-Identifier: BSD-3-Clause */ 2015f8cc5SEric Joyner /* Copyright (c) 2024, Intel Corporation 371d10453SEric Joyner * All rights reserved. 471d10453SEric Joyner * 571d10453SEric Joyner * Redistribution and use in source and binary forms, with or without 671d10453SEric Joyner * modification, are permitted provided that the following conditions are met: 771d10453SEric Joyner * 871d10453SEric Joyner * 1. Redistributions of source code must retain the above copyright notice, 971d10453SEric Joyner * this list of conditions and the following disclaimer. 1071d10453SEric Joyner * 1171d10453SEric Joyner * 2. Redistributions in binary form must reproduce the above copyright 1271d10453SEric Joyner * notice, this list of conditions and the following disclaimer in the 1371d10453SEric Joyner * documentation and/or other materials provided with the distribution. 1471d10453SEric Joyner * 1571d10453SEric Joyner * 3. Neither the name of the Intel Corporation nor the names of its 1671d10453SEric Joyner * contributors may be used to endorse or promote products derived from 1771d10453SEric Joyner * this software without specific prior written permission. 1871d10453SEric Joyner * 1971d10453SEric Joyner * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 2071d10453SEric Joyner * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 2171d10453SEric Joyner * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 2271d10453SEric Joyner * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 2371d10453SEric Joyner * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 2471d10453SEric Joyner * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 2571d10453SEric Joyner * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 2671d10453SEric Joyner * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 2771d10453SEric Joyner * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 2871d10453SEric Joyner * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 2971d10453SEric Joyner * POSSIBILITY OF SUCH DAMAGE. 3071d10453SEric Joyner */ 3171d10453SEric Joyner 3271d10453SEric Joyner /** 3371d10453SEric Joyner * @file if_ice_iflib.c 3471d10453SEric Joyner * @brief iflib driver implementation 3571d10453SEric Joyner * 3671d10453SEric Joyner * Contains the main entry point for the iflib driver implementation. It 3771d10453SEric Joyner * implements the various ifdi driver methods, and sets up the module and 3871d10453SEric Joyner * driver values to load an iflib driver. 3971d10453SEric Joyner */ 4071d10453SEric Joyner 4171d10453SEric Joyner #include "ice_iflib.h" 4271d10453SEric Joyner #include "ice_drv_info.h" 4371d10453SEric Joyner #include "ice_switch.h" 4471d10453SEric Joyner #include "ice_sched.h" 4571d10453SEric Joyner 4671d10453SEric Joyner #include <sys/module.h> 4771d10453SEric Joyner #include <sys/sockio.h> 4871d10453SEric Joyner #include <sys/smp.h> 4971d10453SEric Joyner #include <dev/pci/pcivar.h> 5071d10453SEric Joyner #include <dev/pci/pcireg.h> 5171d10453SEric Joyner 5271d10453SEric Joyner /* 5371d10453SEric Joyner * Device method prototypes 5471d10453SEric Joyner */ 5571d10453SEric Joyner 5671d10453SEric Joyner static void *ice_register(device_t); 5771d10453SEric Joyner static int ice_if_attach_pre(if_ctx_t); 5871d10453SEric Joyner static int ice_attach_pre_recovery_mode(struct ice_softc *sc); 5971d10453SEric Joyner static int ice_if_attach_post(if_ctx_t); 6071d10453SEric Joyner static void ice_attach_post_recovery_mode(struct ice_softc *sc); 6171d10453SEric Joyner static int ice_if_detach(if_ctx_t); 6271d10453SEric Joyner static int ice_if_tx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs, uint64_t *paddrs, int ntxqs, int ntxqsets); 6371d10453SEric Joyner static int ice_if_rx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs, uint64_t *paddrs, int nqs, int nqsets); 6471d10453SEric Joyner static int ice_if_msix_intr_assign(if_ctx_t ctx, int msix); 6571d10453SEric Joyner static void ice_if_queues_free(if_ctx_t ctx); 6671d10453SEric Joyner static int ice_if_mtu_set(if_ctx_t ctx, uint32_t mtu); 6771d10453SEric Joyner static void ice_if_intr_enable(if_ctx_t ctx); 6871d10453SEric Joyner static void ice_if_intr_disable(if_ctx_t ctx); 6971d10453SEric Joyner static int ice_if_rx_queue_intr_enable(if_ctx_t ctx, uint16_t rxqid); 7071d10453SEric Joyner static int ice_if_tx_queue_intr_enable(if_ctx_t ctx, uint16_t txqid); 7171d10453SEric Joyner static int ice_if_promisc_set(if_ctx_t ctx, int flags); 7271d10453SEric Joyner static void ice_if_media_status(if_ctx_t ctx, struct ifmediareq *ifmr); 7371d10453SEric Joyner static int ice_if_media_change(if_ctx_t ctx); 7471d10453SEric Joyner static void ice_if_init(if_ctx_t ctx); 7571d10453SEric Joyner static void ice_if_timer(if_ctx_t ctx, uint16_t qid); 7671d10453SEric Joyner static void ice_if_update_admin_status(if_ctx_t ctx); 7771d10453SEric Joyner static void ice_if_multi_set(if_ctx_t ctx); 7871d10453SEric Joyner static void ice_if_vlan_register(if_ctx_t ctx, u16 vtag); 7971d10453SEric Joyner static void ice_if_vlan_unregister(if_ctx_t ctx, u16 vtag); 8071d10453SEric Joyner static void ice_if_stop(if_ctx_t ctx); 8171d10453SEric Joyner static uint64_t ice_if_get_counter(if_ctx_t ctx, ift_counter counter); 8271d10453SEric Joyner static int ice_if_priv_ioctl(if_ctx_t ctx, u_long command, caddr_t data); 8371d10453SEric Joyner static int ice_if_i2c_req(if_ctx_t ctx, struct ifi2creq *req); 847d7af7f8SEric Joyner static int ice_if_suspend(if_ctx_t ctx); 857d7af7f8SEric Joyner static int ice_if_resume(if_ctx_t ctx); 869c30461dSEric Joyner static bool ice_if_needs_restart(if_ctx_t ctx, enum iflib_restart_event event); 87f377a0c7SEric Joyner static void ice_init_link(struct ice_softc *sc); 889e54973fSEric Joyner static int ice_setup_mirror_vsi(struct ice_mirr_if *mif); 899e54973fSEric Joyner static int ice_wire_mirror_intrs(struct ice_mirr_if *mif); 909e54973fSEric Joyner static void ice_free_irqvs_subif(struct ice_mirr_if *mif); 919e54973fSEric Joyner static void *ice_subif_register(device_t); 929e54973fSEric Joyner static void ice_subif_setup_scctx(struct ice_mirr_if *mif); 939e54973fSEric Joyner static int ice_subif_rebuild(struct ice_softc *sc); 949e54973fSEric Joyner static int ice_subif_rebuild_vsi_qmap(struct ice_softc *sc); 959e54973fSEric Joyner 969e54973fSEric Joyner /* Iflib API */ 979e54973fSEric Joyner static int ice_subif_if_tx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs, 989e54973fSEric Joyner uint64_t *paddrs, int ntxqs, int ntxqsets); 999e54973fSEric Joyner static int ice_subif_if_rx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs, 1009e54973fSEric Joyner uint64_t *paddrs, int nrxqs, int nrxqsets); 1019e54973fSEric Joyner static int ice_subif_if_rx_queue_intr_enable(if_ctx_t ctx, uint16_t rxqid); 1029e54973fSEric Joyner static int ice_subif_if_tx_queue_intr_enable(if_ctx_t ctx, uint16_t txqid); 1039e54973fSEric Joyner static void ice_subif_if_intr_enable(if_ctx_t ctx); 1049e54973fSEric Joyner static int ice_subif_if_msix_intr_assign(if_ctx_t ctx, int msix); 1059e54973fSEric Joyner static void ice_subif_if_init(if_ctx_t ctx); 1069e54973fSEric Joyner static void ice_subif_if_stop(if_ctx_t ctx); 1079e54973fSEric Joyner static void ice_subif_if_queues_free(if_ctx_t ctx); 1089e54973fSEric Joyner static int ice_subif_if_attach_pre(if_ctx_t); 1099e54973fSEric Joyner static int ice_subif_if_attach_post(if_ctx_t); 1109e54973fSEric Joyner static void ice_subif_if_media_status(if_ctx_t ctx, struct ifmediareq *ifmr); 1119e54973fSEric Joyner static int ice_subif_if_promisc_set(if_ctx_t ctx, int flags); 11271d10453SEric Joyner 11371d10453SEric Joyner static int ice_msix_que(void *arg); 11471d10453SEric Joyner static int ice_msix_admin(void *arg); 11571d10453SEric Joyner 11671d10453SEric Joyner /* 11771d10453SEric Joyner * Helper function prototypes 11871d10453SEric Joyner */ 11971d10453SEric Joyner static int ice_pci_mapping(struct ice_softc *sc); 12071d10453SEric Joyner static void ice_free_pci_mapping(struct ice_softc *sc); 12171d10453SEric Joyner static void ice_update_link_status(struct ice_softc *sc, bool update_media); 12271d10453SEric Joyner static void ice_init_device_features(struct ice_softc *sc); 12371d10453SEric Joyner static void ice_init_tx_tracking(struct ice_vsi *vsi); 12471d10453SEric Joyner static void ice_handle_reset_event(struct ice_softc *sc); 12571d10453SEric Joyner static void ice_handle_pf_reset_request(struct ice_softc *sc); 12671d10453SEric Joyner static void ice_prepare_for_reset(struct ice_softc *sc); 12771d10453SEric Joyner static int ice_rebuild_pf_vsi_qmap(struct ice_softc *sc); 12871d10453SEric Joyner static void ice_rebuild(struct ice_softc *sc); 12971d10453SEric Joyner static void ice_rebuild_recovery_mode(struct ice_softc *sc); 13071d10453SEric Joyner static void ice_free_irqvs(struct ice_softc *sc); 13171d10453SEric Joyner static void ice_update_rx_mbuf_sz(struct ice_softc *sc); 13271d10453SEric Joyner static void ice_poll_for_media_avail(struct ice_softc *sc); 13371d10453SEric Joyner static void ice_setup_scctx(struct ice_softc *sc); 13471d10453SEric Joyner static int ice_allocate_msix(struct ice_softc *sc); 13571d10453SEric Joyner static void ice_admin_timer(void *arg); 13671d10453SEric Joyner static void ice_transition_recovery_mode(struct ice_softc *sc); 13771d10453SEric Joyner static void ice_transition_safe_mode(struct ice_softc *sc); 1389c30461dSEric Joyner static void ice_set_default_promisc_mask(ice_bitmap_t *promisc_mask); 13971d10453SEric Joyner 14071d10453SEric Joyner /* 14171d10453SEric Joyner * Device Interface Declaration 14271d10453SEric Joyner */ 14371d10453SEric Joyner 14471d10453SEric Joyner /** 14571d10453SEric Joyner * @var ice_methods 14671d10453SEric Joyner * @brief ice driver method entry points 14771d10453SEric Joyner * 14871d10453SEric Joyner * List of device methods implementing the generic device interface used by 14971d10453SEric Joyner * the device stack to interact with the ice driver. Since this is an iflib 15071d10453SEric Joyner * driver, most of the methods point to the generic iflib implementation. 15171d10453SEric Joyner */ 15271d10453SEric Joyner static device_method_t ice_methods[] = { 15371d10453SEric Joyner /* Device interface */ 15471d10453SEric Joyner DEVMETHOD(device_register, ice_register), 15571d10453SEric Joyner DEVMETHOD(device_probe, iflib_device_probe_vendor), 15671d10453SEric Joyner DEVMETHOD(device_attach, iflib_device_attach), 15771d10453SEric Joyner DEVMETHOD(device_detach, iflib_device_detach), 15871d10453SEric Joyner DEVMETHOD(device_shutdown, iflib_device_shutdown), 15971d10453SEric Joyner DEVMETHOD(device_suspend, iflib_device_suspend), 16071d10453SEric Joyner DEVMETHOD(device_resume, iflib_device_resume), 16171d10453SEric Joyner DEVMETHOD_END 16271d10453SEric Joyner }; 16371d10453SEric Joyner 16471d10453SEric Joyner /** 16571d10453SEric Joyner * @var ice_iflib_methods 16671d10453SEric Joyner * @brief iflib method entry points 16771d10453SEric Joyner * 16871d10453SEric Joyner * List of device methods used by the iflib stack to interact with this 16971d10453SEric Joyner * driver. These are the real main entry points used to interact with this 17071d10453SEric Joyner * driver. 17171d10453SEric Joyner */ 17271d10453SEric Joyner static device_method_t ice_iflib_methods[] = { 17371d10453SEric Joyner DEVMETHOD(ifdi_attach_pre, ice_if_attach_pre), 17471d10453SEric Joyner DEVMETHOD(ifdi_attach_post, ice_if_attach_post), 17571d10453SEric Joyner DEVMETHOD(ifdi_detach, ice_if_detach), 17671d10453SEric Joyner DEVMETHOD(ifdi_tx_queues_alloc, ice_if_tx_queues_alloc), 17771d10453SEric Joyner DEVMETHOD(ifdi_rx_queues_alloc, ice_if_rx_queues_alloc), 17871d10453SEric Joyner DEVMETHOD(ifdi_msix_intr_assign, ice_if_msix_intr_assign), 17971d10453SEric Joyner DEVMETHOD(ifdi_queues_free, ice_if_queues_free), 18071d10453SEric Joyner DEVMETHOD(ifdi_mtu_set, ice_if_mtu_set), 18171d10453SEric Joyner DEVMETHOD(ifdi_intr_enable, ice_if_intr_enable), 18271d10453SEric Joyner DEVMETHOD(ifdi_intr_disable, ice_if_intr_disable), 18371d10453SEric Joyner DEVMETHOD(ifdi_rx_queue_intr_enable, ice_if_rx_queue_intr_enable), 18471d10453SEric Joyner DEVMETHOD(ifdi_tx_queue_intr_enable, ice_if_tx_queue_intr_enable), 18571d10453SEric Joyner DEVMETHOD(ifdi_promisc_set, ice_if_promisc_set), 18671d10453SEric Joyner DEVMETHOD(ifdi_media_status, ice_if_media_status), 18771d10453SEric Joyner DEVMETHOD(ifdi_media_change, ice_if_media_change), 18871d10453SEric Joyner DEVMETHOD(ifdi_init, ice_if_init), 18971d10453SEric Joyner DEVMETHOD(ifdi_stop, ice_if_stop), 19071d10453SEric Joyner DEVMETHOD(ifdi_timer, ice_if_timer), 19171d10453SEric Joyner DEVMETHOD(ifdi_update_admin_status, ice_if_update_admin_status), 19271d10453SEric Joyner DEVMETHOD(ifdi_multi_set, ice_if_multi_set), 19371d10453SEric Joyner DEVMETHOD(ifdi_vlan_register, ice_if_vlan_register), 19471d10453SEric Joyner DEVMETHOD(ifdi_vlan_unregister, ice_if_vlan_unregister), 19571d10453SEric Joyner DEVMETHOD(ifdi_get_counter, ice_if_get_counter), 19671d10453SEric Joyner DEVMETHOD(ifdi_priv_ioctl, ice_if_priv_ioctl), 19771d10453SEric Joyner DEVMETHOD(ifdi_i2c_req, ice_if_i2c_req), 1987d7af7f8SEric Joyner DEVMETHOD(ifdi_suspend, ice_if_suspend), 1997d7af7f8SEric Joyner DEVMETHOD(ifdi_resume, ice_if_resume), 20014a14e36SKevin Bowling DEVMETHOD(ifdi_needs_restart, ice_if_needs_restart), 20171d10453SEric Joyner DEVMETHOD_END 20271d10453SEric Joyner }; 20371d10453SEric Joyner 20471d10453SEric Joyner /** 20571d10453SEric Joyner * @var ice_driver 20671d10453SEric Joyner * @brief driver structure for the generic device stack 20771d10453SEric Joyner * 20871d10453SEric Joyner * driver_t definition used to setup the generic device methods. 20971d10453SEric Joyner */ 21071d10453SEric Joyner static driver_t ice_driver = { 21171d10453SEric Joyner .name = "ice", 21271d10453SEric Joyner .methods = ice_methods, 21371d10453SEric Joyner .size = sizeof(struct ice_softc), 21471d10453SEric Joyner }; 21571d10453SEric Joyner 21671d10453SEric Joyner /** 21771d10453SEric Joyner * @var ice_iflib_driver 21871d10453SEric Joyner * @brief driver structure for the iflib stack 21971d10453SEric Joyner * 22071d10453SEric Joyner * driver_t definition used to setup the iflib device methods. 22171d10453SEric Joyner */ 22271d10453SEric Joyner static driver_t ice_iflib_driver = { 22371d10453SEric Joyner .name = "ice", 22471d10453SEric Joyner .methods = ice_iflib_methods, 22571d10453SEric Joyner .size = sizeof(struct ice_softc), 22671d10453SEric Joyner }; 22771d10453SEric Joyner 22871d10453SEric Joyner extern struct if_txrx ice_txrx; 22971d10453SEric Joyner extern struct if_txrx ice_recovery_txrx; 23071d10453SEric Joyner 23171d10453SEric Joyner /** 23271d10453SEric Joyner * @var ice_sctx 23371d10453SEric Joyner * @brief ice driver shared context 23471d10453SEric Joyner * 23571d10453SEric Joyner * Structure defining shared values (context) that is used by all instances of 23671d10453SEric Joyner * the device. Primarily used to setup details about how the iflib stack 23771d10453SEric Joyner * should treat this driver. Also defines the default, minimum, and maximum 23871d10453SEric Joyner * number of descriptors in each ring. 23971d10453SEric Joyner */ 24071d10453SEric Joyner static struct if_shared_ctx ice_sctx = { 24171d10453SEric Joyner .isc_magic = IFLIB_MAGIC, 24271d10453SEric Joyner .isc_q_align = PAGE_SIZE, 24371d10453SEric Joyner 24471d10453SEric Joyner .isc_tx_maxsize = ICE_MAX_FRAME_SIZE, 24571d10453SEric Joyner /* We could technically set this as high as ICE_MAX_DMA_SEG_SIZE, but 24671d10453SEric Joyner * that doesn't make sense since that would be larger than the maximum 24771d10453SEric Joyner * size of a single packet. 24871d10453SEric Joyner */ 24971d10453SEric Joyner .isc_tx_maxsegsize = ICE_MAX_FRAME_SIZE, 25071d10453SEric Joyner 25171d10453SEric Joyner /* XXX: This is only used by iflib to ensure that 25271d10453SEric Joyner * scctx->isc_tx_tso_size_max + the VLAN header is a valid size. 25371d10453SEric Joyner */ 25471d10453SEric Joyner .isc_tso_maxsize = ICE_TSO_SIZE + sizeof(struct ether_vlan_header), 25571d10453SEric Joyner /* XXX: This is used by iflib to set the number of segments in the TSO 25671d10453SEric Joyner * DMA tag. However, scctx->isc_tx_tso_segsize_max is used to set the 25771d10453SEric Joyner * related ifnet parameter. 25871d10453SEric Joyner */ 25971d10453SEric Joyner .isc_tso_maxsegsize = ICE_MAX_DMA_SEG_SIZE, 26071d10453SEric Joyner 26171d10453SEric Joyner .isc_rx_maxsize = ICE_MAX_FRAME_SIZE, 26271d10453SEric Joyner .isc_rx_nsegments = ICE_MAX_RX_SEGS, 26371d10453SEric Joyner .isc_rx_maxsegsize = ICE_MAX_FRAME_SIZE, 26471d10453SEric Joyner 26571d10453SEric Joyner .isc_nfl = 1, 26671d10453SEric Joyner .isc_ntxqs = 1, 26771d10453SEric Joyner .isc_nrxqs = 1, 26871d10453SEric Joyner 26971d10453SEric Joyner .isc_admin_intrcnt = 1, 27071d10453SEric Joyner .isc_vendor_info = ice_vendor_info_array, 27171d10453SEric Joyner .isc_driver_version = __DECONST(char *, ice_driver_version), 27271d10453SEric Joyner .isc_driver = &ice_iflib_driver, 27371d10453SEric Joyner 27471d10453SEric Joyner /* 27571d10453SEric Joyner * IFLIB_NEED_SCRATCH ensures that mbufs have scratch space available 27671d10453SEric Joyner * for hardware checksum offload 27771d10453SEric Joyner * 27871d10453SEric Joyner * IFLIB_TSO_INIT_IP ensures that the TSO packets have zeroed out the 27971d10453SEric Joyner * IP sum field, required by our hardware to calculate valid TSO 28071d10453SEric Joyner * checksums. 28171d10453SEric Joyner * 28271d10453SEric Joyner * IFLIB_ADMIN_ALWAYS_RUN ensures that the administrative task runs 28371d10453SEric Joyner * even when the interface is down. 28471d10453SEric Joyner * 28571d10453SEric Joyner * IFLIB_SKIP_MSIX allows the driver to handle allocating MSI-X 28671d10453SEric Joyner * vectors manually instead of relying on iflib code to do this. 28771d10453SEric Joyner */ 28871d10453SEric Joyner .isc_flags = IFLIB_NEED_SCRATCH | IFLIB_TSO_INIT_IP | 28971d10453SEric Joyner IFLIB_ADMIN_ALWAYS_RUN | IFLIB_SKIP_MSIX, 29071d10453SEric Joyner 29171d10453SEric Joyner .isc_nrxd_min = {ICE_MIN_DESC_COUNT}, 29271d10453SEric Joyner .isc_ntxd_min = {ICE_MIN_DESC_COUNT}, 29371d10453SEric Joyner .isc_nrxd_max = {ICE_IFLIB_MAX_DESC_COUNT}, 29471d10453SEric Joyner .isc_ntxd_max = {ICE_IFLIB_MAX_DESC_COUNT}, 29571d10453SEric Joyner .isc_nrxd_default = {ICE_DEFAULT_DESC_COUNT}, 29671d10453SEric Joyner .isc_ntxd_default = {ICE_DEFAULT_DESC_COUNT}, 29771d10453SEric Joyner }; 29871d10453SEric Joyner 29983c0a9e8SJohn Baldwin DRIVER_MODULE(ice, pci, ice_driver, ice_module_event_handler, NULL); 30071d10453SEric Joyner 30171d10453SEric Joyner MODULE_VERSION(ice, 1); 30271d10453SEric Joyner MODULE_DEPEND(ice, pci, 1, 1, 1); 30371d10453SEric Joyner MODULE_DEPEND(ice, ether, 1, 1, 1); 30471d10453SEric Joyner MODULE_DEPEND(ice, iflib, 1, 1, 1); 30571d10453SEric Joyner 30671d10453SEric Joyner IFLIB_PNP_INFO(pci, ice, ice_vendor_info_array); 30771d10453SEric Joyner 30871d10453SEric Joyner /* Static driver-wide sysctls */ 30971d10453SEric Joyner #include "ice_iflib_sysctls.h" 31071d10453SEric Joyner 31171d10453SEric Joyner /** 31271d10453SEric Joyner * ice_pci_mapping - Map PCI BAR memory 31371d10453SEric Joyner * @sc: device private softc 31471d10453SEric Joyner * 31571d10453SEric Joyner * Map PCI BAR 0 for device operation. 31671d10453SEric Joyner */ 31771d10453SEric Joyner static int 31871d10453SEric Joyner ice_pci_mapping(struct ice_softc *sc) 31971d10453SEric Joyner { 32071d10453SEric Joyner int rc; 32171d10453SEric Joyner 32271d10453SEric Joyner /* Map BAR0 */ 32371d10453SEric Joyner rc = ice_map_bar(sc->dev, &sc->bar0, 0); 32471d10453SEric Joyner if (rc) 32571d10453SEric Joyner return rc; 32671d10453SEric Joyner 32771d10453SEric Joyner return 0; 32871d10453SEric Joyner } 32971d10453SEric Joyner 33071d10453SEric Joyner /** 33171d10453SEric Joyner * ice_free_pci_mapping - Release PCI BAR memory 33271d10453SEric Joyner * @sc: device private softc 33371d10453SEric Joyner * 33471d10453SEric Joyner * Release PCI BARs which were previously mapped by ice_pci_mapping(). 33571d10453SEric Joyner */ 33671d10453SEric Joyner static void 33771d10453SEric Joyner ice_free_pci_mapping(struct ice_softc *sc) 33871d10453SEric Joyner { 33971d10453SEric Joyner /* Free BAR0 */ 34071d10453SEric Joyner ice_free_bar(sc->dev, &sc->bar0); 34171d10453SEric Joyner } 34271d10453SEric Joyner 34371d10453SEric Joyner /* 34471d10453SEric Joyner * Device methods 34571d10453SEric Joyner */ 34671d10453SEric Joyner 34771d10453SEric Joyner /** 34871d10453SEric Joyner * ice_register - register device method callback 34971d10453SEric Joyner * @dev: the device being registered 35071d10453SEric Joyner * 35171d10453SEric Joyner * Returns a pointer to the shared context structure, which is used by iflib. 35271d10453SEric Joyner */ 35371d10453SEric Joyner static void * 35471d10453SEric Joyner ice_register(device_t dev __unused) 35571d10453SEric Joyner { 35671d10453SEric Joyner return &ice_sctx; 35771d10453SEric Joyner } /* ice_register */ 35871d10453SEric Joyner 35971d10453SEric Joyner /** 36071d10453SEric Joyner * ice_setup_scctx - Setup the iflib softc context structure 36171d10453SEric Joyner * @sc: the device private structure 36271d10453SEric Joyner * 36371d10453SEric Joyner * Setup the parameters in if_softc_ctx_t structure used by the iflib stack 36471d10453SEric Joyner * when loading. 36571d10453SEric Joyner */ 36671d10453SEric Joyner static void 36771d10453SEric Joyner ice_setup_scctx(struct ice_softc *sc) 36871d10453SEric Joyner { 36971d10453SEric Joyner if_softc_ctx_t scctx = sc->scctx; 37071d10453SEric Joyner struct ice_hw *hw = &sc->hw; 3719c30461dSEric Joyner device_t dev = sc->dev; 37271d10453SEric Joyner bool safe_mode, recovery_mode; 37371d10453SEric Joyner 37471d10453SEric Joyner safe_mode = ice_is_bit_set(sc->feat_en, ICE_FEATURE_SAFE_MODE); 37571d10453SEric Joyner recovery_mode = ice_test_state(&sc->state, ICE_STATE_RECOVERY_MODE); 37671d10453SEric Joyner 37771d10453SEric Joyner /* 37871d10453SEric Joyner * If the driver loads in Safe mode or Recovery mode, limit iflib to 37971d10453SEric Joyner * a single queue pair. 38071d10453SEric Joyner */ 38171d10453SEric Joyner if (safe_mode || recovery_mode) { 38271d10453SEric Joyner scctx->isc_ntxqsets = scctx->isc_nrxqsets = 1; 38371d10453SEric Joyner scctx->isc_ntxqsets_max = 1; 38471d10453SEric Joyner scctx->isc_nrxqsets_max = 1; 38571d10453SEric Joyner } else { 38671d10453SEric Joyner /* 38771d10453SEric Joyner * iflib initially sets the isc_ntxqsets and isc_nrxqsets to 38871d10453SEric Joyner * the values of the override sysctls. Cache these initial 38971d10453SEric Joyner * values so that the driver can be aware of what the iflib 39071d10453SEric Joyner * sysctl value is when setting up MSI-X vectors. 39171d10453SEric Joyner */ 39271d10453SEric Joyner sc->ifc_sysctl_ntxqs = scctx->isc_ntxqsets; 39371d10453SEric Joyner sc->ifc_sysctl_nrxqs = scctx->isc_nrxqsets; 39471d10453SEric Joyner 39571d10453SEric Joyner if (scctx->isc_ntxqsets == 0) 39671d10453SEric Joyner scctx->isc_ntxqsets = hw->func_caps.common_cap.rss_table_size; 39771d10453SEric Joyner if (scctx->isc_nrxqsets == 0) 39871d10453SEric Joyner scctx->isc_nrxqsets = hw->func_caps.common_cap.rss_table_size; 39971d10453SEric Joyner 40071d10453SEric Joyner scctx->isc_ntxqsets_max = hw->func_caps.common_cap.num_txq; 40171d10453SEric Joyner scctx->isc_nrxqsets_max = hw->func_caps.common_cap.num_rxq; 40271d10453SEric Joyner 40371d10453SEric Joyner /* 40471d10453SEric Joyner * Sanity check that the iflib sysctl values are within the 40571d10453SEric Joyner * maximum supported range. 40671d10453SEric Joyner */ 40771d10453SEric Joyner if (sc->ifc_sysctl_ntxqs > scctx->isc_ntxqsets_max) 40871d10453SEric Joyner sc->ifc_sysctl_ntxqs = scctx->isc_ntxqsets_max; 40971d10453SEric Joyner if (sc->ifc_sysctl_nrxqs > scctx->isc_nrxqsets_max) 41071d10453SEric Joyner sc->ifc_sysctl_nrxqs = scctx->isc_nrxqsets_max; 41171d10453SEric Joyner } 41271d10453SEric Joyner 41371d10453SEric Joyner scctx->isc_txqsizes[0] = roundup2(scctx->isc_ntxd[0] 41471d10453SEric Joyner * sizeof(struct ice_tx_desc), DBA_ALIGN); 41571d10453SEric Joyner scctx->isc_rxqsizes[0] = roundup2(scctx->isc_nrxd[0] 41671d10453SEric Joyner * sizeof(union ice_32b_rx_flex_desc), DBA_ALIGN); 41771d10453SEric Joyner 41871d10453SEric Joyner scctx->isc_tx_nsegments = ICE_MAX_TX_SEGS; 41971d10453SEric Joyner scctx->isc_tx_tso_segments_max = ICE_MAX_TSO_SEGS; 42071d10453SEric Joyner scctx->isc_tx_tso_size_max = ICE_TSO_SIZE; 42171d10453SEric Joyner scctx->isc_tx_tso_segsize_max = ICE_MAX_DMA_SEG_SIZE; 42271d10453SEric Joyner 4239c30461dSEric Joyner scctx->isc_msix_bar = pci_msix_table_bar(dev); 42471d10453SEric Joyner scctx->isc_rss_table_size = hw->func_caps.common_cap.rss_table_size; 42571d10453SEric Joyner 42671d10453SEric Joyner /* 42771d10453SEric Joyner * If the driver loads in recovery mode, disable Tx/Rx functionality 42871d10453SEric Joyner */ 42971d10453SEric Joyner if (recovery_mode) 43071d10453SEric Joyner scctx->isc_txrx = &ice_recovery_txrx; 43171d10453SEric Joyner else 43271d10453SEric Joyner scctx->isc_txrx = &ice_txrx; 43371d10453SEric Joyner 43471d10453SEric Joyner /* 43571d10453SEric Joyner * If the driver loads in Safe mode or Recovery mode, disable 43671d10453SEric Joyner * advanced features including hardware offloads. 43771d10453SEric Joyner */ 43871d10453SEric Joyner if (safe_mode || recovery_mode) { 43971d10453SEric Joyner scctx->isc_capenable = ICE_SAFE_CAPS; 44071d10453SEric Joyner scctx->isc_tx_csum_flags = 0; 44171d10453SEric Joyner } else { 44271d10453SEric Joyner scctx->isc_capenable = ICE_FULL_CAPS; 44371d10453SEric Joyner scctx->isc_tx_csum_flags = ICE_CSUM_OFFLOAD; 44471d10453SEric Joyner } 44571d10453SEric Joyner 44671d10453SEric Joyner scctx->isc_capabilities = scctx->isc_capenable; 44771d10453SEric Joyner } /* ice_setup_scctx */ 44871d10453SEric Joyner 44971d10453SEric Joyner /** 45071d10453SEric Joyner * ice_if_attach_pre - Early device attach logic 45171d10453SEric Joyner * @ctx: the iflib context structure 45271d10453SEric Joyner * 45371d10453SEric Joyner * Called by iflib during the attach process. Earliest main driver entry 45471d10453SEric Joyner * point which performs necessary hardware and driver initialization. Called 45571d10453SEric Joyner * before the Tx and Rx queues are allocated. 45671d10453SEric Joyner */ 45771d10453SEric Joyner static int 45871d10453SEric Joyner ice_if_attach_pre(if_ctx_t ctx) 45971d10453SEric Joyner { 46071d10453SEric Joyner struct ice_softc *sc = (struct ice_softc *)iflib_get_softc(ctx); 46171d10453SEric Joyner enum ice_fw_modes fw_mode; 462f2635e84SEric Joyner int status; 46371d10453SEric Joyner if_softc_ctx_t scctx; 46471d10453SEric Joyner struct ice_hw *hw; 46571d10453SEric Joyner device_t dev; 46671d10453SEric Joyner int err; 46771d10453SEric Joyner 46871d10453SEric Joyner device_printf(iflib_get_dev(ctx), "Loading the iflib ice driver\n"); 46971d10453SEric Joyner 47056429daeSEric Joyner ice_set_state(&sc->state, ICE_STATE_ATTACHING); 47156429daeSEric Joyner 47271d10453SEric Joyner sc->ctx = ctx; 47371d10453SEric Joyner sc->media = iflib_get_media(ctx); 47471d10453SEric Joyner sc->sctx = iflib_get_sctx(ctx); 47571d10453SEric Joyner sc->iflib_ctx_lock = iflib_ctx_lock_get(ctx); 476f2635e84SEric Joyner sc->ifp = iflib_get_ifp(ctx); 47771d10453SEric Joyner 47871d10453SEric Joyner dev = sc->dev = iflib_get_dev(ctx); 47971d10453SEric Joyner scctx = sc->scctx = iflib_get_softc_ctx(ctx); 48071d10453SEric Joyner 48171d10453SEric Joyner hw = &sc->hw; 48271d10453SEric Joyner hw->back = sc; 48371d10453SEric Joyner 48471d10453SEric Joyner snprintf(sc->admin_mtx_name, sizeof(sc->admin_mtx_name), 48571d10453SEric Joyner "%s:admin", device_get_nameunit(dev)); 48671d10453SEric Joyner mtx_init(&sc->admin_mtx, sc->admin_mtx_name, NULL, MTX_DEF); 48771d10453SEric Joyner callout_init_mtx(&sc->admin_timer, &sc->admin_mtx, 0); 48871d10453SEric Joyner 48971d10453SEric Joyner ASSERT_CTX_LOCKED(sc); 49071d10453SEric Joyner 49171d10453SEric Joyner if (ice_pci_mapping(sc)) { 49271d10453SEric Joyner err = (ENXIO); 49371d10453SEric Joyner goto destroy_admin_timer; 49471d10453SEric Joyner } 49571d10453SEric Joyner 49671d10453SEric Joyner /* Save off the PCI information */ 49771d10453SEric Joyner ice_save_pci_info(hw, dev); 49871d10453SEric Joyner 49971d10453SEric Joyner /* create tunables as early as possible */ 50071d10453SEric Joyner ice_add_device_tunables(sc); 50171d10453SEric Joyner 50271d10453SEric Joyner /* Setup ControlQ lengths */ 50371d10453SEric Joyner ice_set_ctrlq_len(hw); 50471d10453SEric Joyner 5058923de59SPiotr Kubaj reinit_hw: 5068923de59SPiotr Kubaj 50771d10453SEric Joyner fw_mode = ice_get_fw_mode(hw); 50871d10453SEric Joyner if (fw_mode == ICE_FW_MODE_REC) { 50971d10453SEric Joyner device_printf(dev, "Firmware recovery mode detected. Limiting functionality. Refer to Intel(R) Ethernet Adapters and Devices User Guide for details on firmware recovery mode.\n"); 51071d10453SEric Joyner 51171d10453SEric Joyner err = ice_attach_pre_recovery_mode(sc); 51271d10453SEric Joyner if (err) 51371d10453SEric Joyner goto free_pci_mapping; 51471d10453SEric Joyner 51571d10453SEric Joyner return (0); 51671d10453SEric Joyner } 51771d10453SEric Joyner 51871d10453SEric Joyner /* Initialize the hw data structure */ 51971d10453SEric Joyner status = ice_init_hw(hw); 52071d10453SEric Joyner if (status) { 52171d10453SEric Joyner if (status == ICE_ERR_FW_API_VER) { 52271d10453SEric Joyner /* Enter recovery mode, so that the driver remains 52371d10453SEric Joyner * loaded. This way, if the system administrator 52471d10453SEric Joyner * cannot update the driver, they may still attempt to 52571d10453SEric Joyner * downgrade the NVM. 52671d10453SEric Joyner */ 52771d10453SEric Joyner err = ice_attach_pre_recovery_mode(sc); 52871d10453SEric Joyner if (err) 52971d10453SEric Joyner goto free_pci_mapping; 53071d10453SEric Joyner 53171d10453SEric Joyner return (0); 53271d10453SEric Joyner } else { 53371d10453SEric Joyner err = EIO; 53471d10453SEric Joyner device_printf(dev, "Unable to initialize hw, err %s aq_err %s\n", 53571d10453SEric Joyner ice_status_str(status), 53671d10453SEric Joyner ice_aq_str(hw->adminq.sq_last_status)); 53771d10453SEric Joyner } 53871d10453SEric Joyner goto free_pci_mapping; 53971d10453SEric Joyner } 54071d10453SEric Joyner 5418923de59SPiotr Kubaj ice_init_device_features(sc); 5428923de59SPiotr Kubaj 5439c30461dSEric Joyner /* Keep flag set by default */ 5449c30461dSEric Joyner ice_set_state(&sc->state, ICE_STATE_LINK_ACTIVE_ON_DOWN); 5459c30461dSEric Joyner 54671d10453SEric Joyner /* Notify firmware of the device driver version */ 54771d10453SEric Joyner err = ice_send_version(sc); 54871d10453SEric Joyner if (err) 54971d10453SEric Joyner goto deinit_hw; 55071d10453SEric Joyner 5518923de59SPiotr Kubaj /* 5528923de59SPiotr Kubaj * Success indicates a change was made that requires a reinitialization 5538923de59SPiotr Kubaj * of the hardware 5548923de59SPiotr Kubaj */ 5558923de59SPiotr Kubaj err = ice_load_pkg_file(sc); 556f2635e84SEric Joyner if (!err) { 5578923de59SPiotr Kubaj ice_deinit_hw(hw); 5588923de59SPiotr Kubaj goto reinit_hw; 5598923de59SPiotr Kubaj } 56071d10453SEric Joyner 56171d10453SEric Joyner err = ice_init_link_events(sc); 56271d10453SEric Joyner if (err) { 56371d10453SEric Joyner device_printf(dev, "ice_init_link_events failed: %s\n", 56471d10453SEric Joyner ice_err_str(err)); 56571d10453SEric Joyner goto deinit_hw; 56671d10453SEric Joyner } 56771d10453SEric Joyner 5688923de59SPiotr Kubaj /* Initialize VLAN mode in FW; if dual VLAN mode is supported by the package 5698923de59SPiotr Kubaj * and firmware, this will force them to use single VLAN mode. 5708923de59SPiotr Kubaj */ 5718923de59SPiotr Kubaj status = ice_set_vlan_mode(hw); 5728923de59SPiotr Kubaj if (status) { 5738923de59SPiotr Kubaj err = EIO; 5748923de59SPiotr Kubaj device_printf(dev, "Unable to initialize VLAN mode, err %s aq_err %s\n", 5758923de59SPiotr Kubaj ice_status_str(status), 5768923de59SPiotr Kubaj ice_aq_str(hw->adminq.sq_last_status)); 5778923de59SPiotr Kubaj goto deinit_hw; 5788923de59SPiotr Kubaj } 57971d10453SEric Joyner 5808923de59SPiotr Kubaj ice_print_nvm_version(sc); 58171d10453SEric Joyner 58271d10453SEric Joyner /* Setup the MAC address */ 58371d10453SEric Joyner iflib_set_mac(ctx, hw->port_info->mac.lan_addr); 58471d10453SEric Joyner 58571d10453SEric Joyner /* Setup the iflib softc context structure */ 58671d10453SEric Joyner ice_setup_scctx(sc); 58771d10453SEric Joyner 58871d10453SEric Joyner /* Initialize the Tx queue manager */ 58971d10453SEric Joyner err = ice_resmgr_init(&sc->tx_qmgr, hw->func_caps.common_cap.num_txq); 59071d10453SEric Joyner if (err) { 59171d10453SEric Joyner device_printf(dev, "Unable to initialize Tx queue manager: %s\n", 59271d10453SEric Joyner ice_err_str(err)); 59371d10453SEric Joyner goto deinit_hw; 59471d10453SEric Joyner } 59571d10453SEric Joyner 59671d10453SEric Joyner /* Initialize the Rx queue manager */ 59771d10453SEric Joyner err = ice_resmgr_init(&sc->rx_qmgr, hw->func_caps.common_cap.num_rxq); 59871d10453SEric Joyner if (err) { 59971d10453SEric Joyner device_printf(dev, "Unable to initialize Rx queue manager: %s\n", 60071d10453SEric Joyner ice_err_str(err)); 60171d10453SEric Joyner goto free_tx_qmgr; 60271d10453SEric Joyner } 60371d10453SEric Joyner 6049e54973fSEric Joyner /* Initialize the PF device interrupt resource manager */ 60571d10453SEric Joyner err = ice_alloc_intr_tracking(sc); 60671d10453SEric Joyner if (err) 60771d10453SEric Joyner /* Errors are already printed */ 60871d10453SEric Joyner goto free_rx_qmgr; 60971d10453SEric Joyner 61071d10453SEric Joyner /* Determine maximum number of VSIs we'll prepare for */ 61171d10453SEric Joyner sc->num_available_vsi = min(ICE_MAX_VSI_AVAILABLE, 61271d10453SEric Joyner hw->func_caps.guar_num_vsi); 61371d10453SEric Joyner 61471d10453SEric Joyner if (!sc->num_available_vsi) { 61571d10453SEric Joyner err = EIO; 61671d10453SEric Joyner device_printf(dev, "No VSIs allocated to host\n"); 61771d10453SEric Joyner goto free_intr_tracking; 61871d10453SEric Joyner } 61971d10453SEric Joyner 62071d10453SEric Joyner /* Allocate storage for the VSI pointers */ 62171d10453SEric Joyner sc->all_vsi = (struct ice_vsi **) 62271d10453SEric Joyner malloc(sizeof(struct ice_vsi *) * sc->num_available_vsi, 62371d10453SEric Joyner M_ICE, M_WAITOK | M_ZERO); 62471d10453SEric Joyner if (!sc->all_vsi) { 62571d10453SEric Joyner err = ENOMEM; 62671d10453SEric Joyner device_printf(dev, "Unable to allocate VSI array\n"); 62771d10453SEric Joyner goto free_intr_tracking; 62871d10453SEric Joyner } 62971d10453SEric Joyner 63071d10453SEric Joyner /* 63171d10453SEric Joyner * Prepare the statically allocated primary PF VSI in the softc 63271d10453SEric Joyner * structure. Other VSIs will be dynamically allocated as needed. 63371d10453SEric Joyner */ 63471d10453SEric Joyner ice_setup_pf_vsi(sc); 63571d10453SEric Joyner 6365f97656fSZhenlei Huang ice_alloc_vsi_qmap(&sc->pf_vsi, scctx->isc_ntxqsets_max, 63771d10453SEric Joyner scctx->isc_nrxqsets_max); 63871d10453SEric Joyner 63971d10453SEric Joyner /* Allocate MSI-X vectors (due to isc_flags IFLIB_SKIP_MSIX) */ 64071d10453SEric Joyner err = ice_allocate_msix(sc); 64171d10453SEric Joyner if (err) 64271d10453SEric Joyner goto free_main_vsi; 64371d10453SEric Joyner 64471d10453SEric Joyner return 0; 64571d10453SEric Joyner 64671d10453SEric Joyner free_main_vsi: 64771d10453SEric Joyner /* ice_release_vsi will free the queue maps if they were allocated */ 64871d10453SEric Joyner ice_release_vsi(&sc->pf_vsi); 64971d10453SEric Joyner free(sc->all_vsi, M_ICE); 65071d10453SEric Joyner sc->all_vsi = NULL; 65171d10453SEric Joyner free_intr_tracking: 65271d10453SEric Joyner ice_free_intr_tracking(sc); 65371d10453SEric Joyner free_rx_qmgr: 65471d10453SEric Joyner ice_resmgr_destroy(&sc->rx_qmgr); 65571d10453SEric Joyner free_tx_qmgr: 65671d10453SEric Joyner ice_resmgr_destroy(&sc->tx_qmgr); 65771d10453SEric Joyner deinit_hw: 65871d10453SEric Joyner ice_deinit_hw(hw); 65971d10453SEric Joyner free_pci_mapping: 66071d10453SEric Joyner ice_free_pci_mapping(sc); 66171d10453SEric Joyner destroy_admin_timer: 66271d10453SEric Joyner mtx_lock(&sc->admin_mtx); 66371d10453SEric Joyner callout_stop(&sc->admin_timer); 66471d10453SEric Joyner mtx_unlock(&sc->admin_mtx); 66571d10453SEric Joyner mtx_destroy(&sc->admin_mtx); 66671d10453SEric Joyner return err; 66771d10453SEric Joyner } /* ice_if_attach_pre */ 66871d10453SEric Joyner 66971d10453SEric Joyner /** 67071d10453SEric Joyner * ice_attach_pre_recovery_mode - Limited driver attach_pre for FW recovery 67171d10453SEric Joyner * @sc: the device private softc 67271d10453SEric Joyner * 67371d10453SEric Joyner * Loads the device driver in limited Firmware Recovery mode, intended to 67471d10453SEric Joyner * allow users to update the firmware to attempt to recover the device. 67571d10453SEric Joyner * 67671d10453SEric Joyner * @remark We may enter recovery mode in case either (a) the firmware is 67771d10453SEric Joyner * detected to be in an invalid state and must be re-programmed, or (b) the 67871d10453SEric Joyner * driver detects that the loaded firmware has a non-compatible API version 67971d10453SEric Joyner * that the driver cannot operate with. 68071d10453SEric Joyner */ 68171d10453SEric Joyner static int 68271d10453SEric Joyner ice_attach_pre_recovery_mode(struct ice_softc *sc) 68371d10453SEric Joyner { 68471d10453SEric Joyner ice_set_state(&sc->state, ICE_STATE_RECOVERY_MODE); 68571d10453SEric Joyner 68671d10453SEric Joyner /* Setup the iflib softc context */ 68771d10453SEric Joyner ice_setup_scctx(sc); 68871d10453SEric Joyner 68971d10453SEric Joyner /* Setup the PF VSI back pointer */ 69071d10453SEric Joyner sc->pf_vsi.sc = sc; 69171d10453SEric Joyner 69271d10453SEric Joyner /* 69371d10453SEric Joyner * We still need to allocate MSI-X vectors since we need one vector to 69471d10453SEric Joyner * run the administrative admin interrupt 69571d10453SEric Joyner */ 69671d10453SEric Joyner return ice_allocate_msix(sc); 69771d10453SEric Joyner } 69871d10453SEric Joyner 69971d10453SEric Joyner /** 70071d10453SEric Joyner * ice_update_link_status - notify OS of link state change 70171d10453SEric Joyner * @sc: device private softc structure 70271d10453SEric Joyner * @update_media: true if we should update media even if link didn't change 70371d10453SEric Joyner * 70471d10453SEric Joyner * Called to notify iflib core of link status changes. Should be called once 70571d10453SEric Joyner * during attach_post, and whenever link status changes during runtime. 70671d10453SEric Joyner * 70771d10453SEric Joyner * This call only updates the currently supported media types if the link 70871d10453SEric Joyner * status changed, or if update_media is set to true. 70971d10453SEric Joyner */ 71071d10453SEric Joyner static void 71171d10453SEric Joyner ice_update_link_status(struct ice_softc *sc, bool update_media) 71271d10453SEric Joyner { 71371d10453SEric Joyner struct ice_hw *hw = &sc->hw; 714f2635e84SEric Joyner int status; 71571d10453SEric Joyner 71671d10453SEric Joyner /* Never report link up when in recovery mode */ 71771d10453SEric Joyner if (ice_test_state(&sc->state, ICE_STATE_RECOVERY_MODE)) 71871d10453SEric Joyner return; 71971d10453SEric Joyner 72071d10453SEric Joyner /* Report link status to iflib only once each time it changes */ 72171d10453SEric Joyner if (!ice_testandset_state(&sc->state, ICE_STATE_LINK_STATUS_REPORTED)) { 72271d10453SEric Joyner if (sc->link_up) { /* link is up */ 72371d10453SEric Joyner uint64_t baudrate = ice_aq_speed_to_rate(sc->hw.port_info); 72471d10453SEric Joyner 7259c30461dSEric Joyner if (!(hw->port_info->phy.link_info_old.link_info & ICE_AQ_LINK_UP)) 7267d7af7f8SEric Joyner ice_set_default_local_lldp_mib(sc); 7277d7af7f8SEric Joyner 72871d10453SEric Joyner iflib_link_state_change(sc->ctx, LINK_STATE_UP, baudrate); 7298a13362dSEric Joyner ice_rdma_link_change(sc, LINK_STATE_UP, baudrate); 73071d10453SEric Joyner 73171d10453SEric Joyner ice_link_up_msg(sc); 73271d10453SEric Joyner } else { /* link is down */ 73371d10453SEric Joyner iflib_link_state_change(sc->ctx, LINK_STATE_DOWN, 0); 7348a13362dSEric Joyner ice_rdma_link_change(sc, LINK_STATE_DOWN, 0); 73571d10453SEric Joyner } 7369dc2f6e2SEric Joyner update_media = true; 73771d10453SEric Joyner } 73871d10453SEric Joyner 73971d10453SEric Joyner /* Update the supported media types */ 7409c30461dSEric Joyner if (update_media && !ice_test_state(&sc->state, ICE_STATE_PREPARED_FOR_RESET)) { 7417d7af7f8SEric Joyner status = ice_add_media_types(sc, sc->media); 74271d10453SEric Joyner if (status) 74371d10453SEric Joyner device_printf(sc->dev, "Error adding device media types: %s aq_err %s\n", 74471d10453SEric Joyner ice_status_str(status), 74571d10453SEric Joyner ice_aq_str(hw->adminq.sq_last_status)); 74671d10453SEric Joyner } 74771d10453SEric Joyner } 74871d10453SEric Joyner 74971d10453SEric Joyner /** 75071d10453SEric Joyner * ice_if_attach_post - Late device attach logic 75171d10453SEric Joyner * @ctx: the iflib context structure 75271d10453SEric Joyner * 75371d10453SEric Joyner * Called by iflib to finish up attaching the device. Performs any attach 75471d10453SEric Joyner * logic which must wait until after the Tx and Rx queues have been 75571d10453SEric Joyner * allocated. 75671d10453SEric Joyner */ 75771d10453SEric Joyner static int 75871d10453SEric Joyner ice_if_attach_post(if_ctx_t ctx) 75971d10453SEric Joyner { 76071d10453SEric Joyner struct ice_softc *sc = (struct ice_softc *)iflib_get_softc(ctx); 76171d10453SEric Joyner if_t ifp = iflib_get_ifp(ctx); 762f2635e84SEric Joyner int status; 76371d10453SEric Joyner int err; 76471d10453SEric Joyner 76571d10453SEric Joyner ASSERT_CTX_LOCKED(sc); 76671d10453SEric Joyner 76771d10453SEric Joyner /* We don't yet support loading if MSI-X is not supported */ 76871d10453SEric Joyner if (sc->scctx->isc_intr != IFLIB_INTR_MSIX) { 76971d10453SEric Joyner device_printf(sc->dev, "The ice driver does not support loading without MSI-X\n"); 77071d10453SEric Joyner return (ENOTSUP); 77171d10453SEric Joyner } 77271d10453SEric Joyner 77371d10453SEric Joyner /* The ifnet structure hasn't yet been initialized when the attach_pre 77471d10453SEric Joyner * handler is called, so wait until attach_post to setup the 77571d10453SEric Joyner * isc_max_frame_size. 77671d10453SEric Joyner */ 777402810d3SJustin Hibbits sc->scctx->isc_max_frame_size = if_getmtu(ifp) + 77871d10453SEric Joyner ETHER_HDR_LEN + ETHER_CRC_LEN + ETHER_VLAN_ENCAP_LEN; 77971d10453SEric Joyner 78071d10453SEric Joyner /* 78171d10453SEric Joyner * If we are in recovery mode, only perform a limited subset of 78271d10453SEric Joyner * initialization to support NVM recovery. 78371d10453SEric Joyner */ 78471d10453SEric Joyner if (ice_test_state(&sc->state, ICE_STATE_RECOVERY_MODE)) { 78571d10453SEric Joyner ice_attach_post_recovery_mode(sc); 78671d10453SEric Joyner return (0); 78771d10453SEric Joyner } 78871d10453SEric Joyner 78971d10453SEric Joyner sc->pf_vsi.max_frame_size = sc->scctx->isc_max_frame_size; 79071d10453SEric Joyner 79171d10453SEric Joyner err = ice_initialize_vsi(&sc->pf_vsi); 79271d10453SEric Joyner if (err) { 79371d10453SEric Joyner device_printf(sc->dev, "Unable to initialize Main VSI: %s\n", 79471d10453SEric Joyner ice_err_str(err)); 79571d10453SEric Joyner return err; 79671d10453SEric Joyner } 79771d10453SEric Joyner 7989cf1841cSEric Joyner /* Enable FW health event reporting */ 7999cf1841cSEric Joyner ice_init_health_events(sc); 8009cf1841cSEric Joyner 80171d10453SEric Joyner /* Configure the main PF VSI for RSS */ 80271d10453SEric Joyner err = ice_config_rss(&sc->pf_vsi); 80371d10453SEric Joyner if (err) { 80471d10453SEric Joyner device_printf(sc->dev, 80571d10453SEric Joyner "Unable to configure RSS for the main VSI, err %s\n", 80671d10453SEric Joyner ice_err_str(err)); 80771d10453SEric Joyner return err; 80871d10453SEric Joyner } 80971d10453SEric Joyner 81071d10453SEric Joyner /* Configure switch to drop transmitted LLDP and PAUSE frames */ 81171d10453SEric Joyner err = ice_cfg_pf_ethertype_filters(sc); 81271d10453SEric Joyner if (err) 81371d10453SEric Joyner return err; 81471d10453SEric Joyner 81571d10453SEric Joyner ice_get_and_print_bus_info(sc); 81671d10453SEric Joyner 81771d10453SEric Joyner ice_set_link_management_mode(sc); 81871d10453SEric Joyner 81971d10453SEric Joyner ice_init_saved_phy_cfg(sc); 82071d10453SEric Joyner 82156429daeSEric Joyner ice_cfg_pba_num(sc); 82256429daeSEric Joyner 8239c30461dSEric Joyner /* Set a default value for PFC mode on attach since the FW state is unknown 8249c30461dSEric Joyner * before sysctl tunables are executed and it can't be queried. This fixes an 8259c30461dSEric Joyner * issue when loading the driver with the FW LLDP agent enabled but the FW 8269c30461dSEric Joyner * was previously in DSCP PFC mode. 8279c30461dSEric Joyner */ 8289c30461dSEric Joyner status = ice_aq_set_pfc_mode(&sc->hw, ICE_AQC_PFC_VLAN_BASED_PFC, NULL); 829f2635e84SEric Joyner if (status) 8309c30461dSEric Joyner device_printf(sc->dev, "Setting pfc mode failed, status %s\n", ice_status_str(status)); 8319c30461dSEric Joyner 83271d10453SEric Joyner ice_add_device_sysctls(sc); 83371d10453SEric Joyner 83471d10453SEric Joyner /* Get DCBX/LLDP state and start DCBX agent */ 83571d10453SEric Joyner ice_init_dcb_setup(sc); 83671d10453SEric Joyner 837f377a0c7SEric Joyner /* Setup link, if PHY FW is ready */ 838f377a0c7SEric Joyner ice_init_link(sc); 83971d10453SEric Joyner 84071d10453SEric Joyner /* Configure interrupt causes for the administrative interrupt */ 84171d10453SEric Joyner ice_configure_misc_interrupts(sc); 84271d10453SEric Joyner 84371d10453SEric Joyner /* Enable ITR 0 right away, so that we can handle admin interrupts */ 84471d10453SEric Joyner ice_enable_intr(&sc->hw, sc->irqvs[0].me); 84571d10453SEric Joyner 8468a13362dSEric Joyner err = ice_rdma_pf_attach(sc); 8478a13362dSEric Joyner if (err) 8488a13362dSEric Joyner return (err); 8498a13362dSEric Joyner 85071d10453SEric Joyner /* Start the admin timer */ 85171d10453SEric Joyner mtx_lock(&sc->admin_mtx); 85271d10453SEric Joyner callout_reset(&sc->admin_timer, hz/2, ice_admin_timer, sc); 85371d10453SEric Joyner mtx_unlock(&sc->admin_mtx); 85471d10453SEric Joyner 8559c30461dSEric Joyner if (ice_test_state(&sc->state, ICE_STATE_LINK_ACTIVE_ON_DOWN) && 8569c30461dSEric Joyner !ice_test_state(&sc->state, ICE_STATE_NO_MEDIA)) 8579c30461dSEric Joyner ice_set_state(&sc->state, ICE_STATE_FIRST_INIT_LINK); 8589c30461dSEric Joyner 85956429daeSEric Joyner ice_clear_state(&sc->state, ICE_STATE_ATTACHING); 86056429daeSEric Joyner 86171d10453SEric Joyner return 0; 86271d10453SEric Joyner } /* ice_if_attach_post */ 86371d10453SEric Joyner 86471d10453SEric Joyner /** 86571d10453SEric Joyner * ice_attach_post_recovery_mode - Limited driver attach_post for FW recovery 86671d10453SEric Joyner * @sc: the device private softc 86771d10453SEric Joyner * 86871d10453SEric Joyner * Performs minimal work to prepare the driver to recover an NVM in case the 86971d10453SEric Joyner * firmware is in recovery mode. 87071d10453SEric Joyner */ 87171d10453SEric Joyner static void 87271d10453SEric Joyner ice_attach_post_recovery_mode(struct ice_softc *sc) 87371d10453SEric Joyner { 87471d10453SEric Joyner /* Configure interrupt causes for the administrative interrupt */ 87571d10453SEric Joyner ice_configure_misc_interrupts(sc); 87671d10453SEric Joyner 87771d10453SEric Joyner /* Enable ITR 0 right away, so that we can handle admin interrupts */ 87871d10453SEric Joyner ice_enable_intr(&sc->hw, sc->irqvs[0].me); 87971d10453SEric Joyner 88071d10453SEric Joyner /* Start the admin timer */ 88171d10453SEric Joyner mtx_lock(&sc->admin_mtx); 88271d10453SEric Joyner callout_reset(&sc->admin_timer, hz/2, ice_admin_timer, sc); 88371d10453SEric Joyner mtx_unlock(&sc->admin_mtx); 88456429daeSEric Joyner 88556429daeSEric Joyner ice_clear_state(&sc->state, ICE_STATE_ATTACHING); 88671d10453SEric Joyner } 88771d10453SEric Joyner 88871d10453SEric Joyner /** 88971d10453SEric Joyner * ice_free_irqvs - Free IRQ vector memory 89071d10453SEric Joyner * @sc: the device private softc structure 89171d10453SEric Joyner * 89271d10453SEric Joyner * Free IRQ vector memory allocated during ice_if_msix_intr_assign. 89371d10453SEric Joyner */ 89471d10453SEric Joyner static void 89571d10453SEric Joyner ice_free_irqvs(struct ice_softc *sc) 89671d10453SEric Joyner { 89771d10453SEric Joyner struct ice_vsi *vsi = &sc->pf_vsi; 89871d10453SEric Joyner if_ctx_t ctx = sc->ctx; 89971d10453SEric Joyner int i; 90071d10453SEric Joyner 90171d10453SEric Joyner /* If the irqvs array is NULL, then there are no vectors to free */ 90271d10453SEric Joyner if (sc->irqvs == NULL) 90371d10453SEric Joyner return; 90471d10453SEric Joyner 90571d10453SEric Joyner /* Free the IRQ vectors */ 90671d10453SEric Joyner for (i = 0; i < sc->num_irq_vectors; i++) 90771d10453SEric Joyner iflib_irq_free(ctx, &sc->irqvs[i].irq); 90871d10453SEric Joyner 90971d10453SEric Joyner /* Clear the irqv pointers */ 91071d10453SEric Joyner for (i = 0; i < vsi->num_rx_queues; i++) 91171d10453SEric Joyner vsi->rx_queues[i].irqv = NULL; 91271d10453SEric Joyner 91371d10453SEric Joyner for (i = 0; i < vsi->num_tx_queues; i++) 91471d10453SEric Joyner vsi->tx_queues[i].irqv = NULL; 91571d10453SEric Joyner 91671d10453SEric Joyner /* Release the vector array memory */ 91771d10453SEric Joyner free(sc->irqvs, M_ICE); 91871d10453SEric Joyner sc->irqvs = NULL; 91971d10453SEric Joyner sc->num_irq_vectors = 0; 92071d10453SEric Joyner } 92171d10453SEric Joyner 92271d10453SEric Joyner /** 92371d10453SEric Joyner * ice_if_detach - Device driver detach logic 92471d10453SEric Joyner * @ctx: iflib context structure 92571d10453SEric Joyner * 92671d10453SEric Joyner * Perform device shutdown logic to detach the device driver. 92771d10453SEric Joyner * 92871d10453SEric Joyner * Note that there is no guarantee of the ordering of ice_if_queues_free() and 92971d10453SEric Joyner * ice_if_detach(). It is possible for the functions to be called in either 93071d10453SEric Joyner * order, and they must not assume to have a strict ordering. 93171d10453SEric Joyner */ 93271d10453SEric Joyner static int 93371d10453SEric Joyner ice_if_detach(if_ctx_t ctx) 93471d10453SEric Joyner { 93571d10453SEric Joyner struct ice_softc *sc = (struct ice_softc *)iflib_get_softc(ctx); 93671d10453SEric Joyner struct ice_vsi *vsi = &sc->pf_vsi; 937f2635e84SEric Joyner int status; 93871d10453SEric Joyner int i; 93971d10453SEric Joyner 94071d10453SEric Joyner ASSERT_CTX_LOCKED(sc); 94171d10453SEric Joyner 94271d10453SEric Joyner /* Indicate that we're detaching */ 94371d10453SEric Joyner ice_set_state(&sc->state, ICE_STATE_DETACHING); 94471d10453SEric Joyner 94571d10453SEric Joyner /* Stop the admin timer */ 94671d10453SEric Joyner mtx_lock(&sc->admin_mtx); 94771d10453SEric Joyner callout_stop(&sc->admin_timer); 94871d10453SEric Joyner mtx_unlock(&sc->admin_mtx); 94971d10453SEric Joyner mtx_destroy(&sc->admin_mtx); 95071d10453SEric Joyner 9519e54973fSEric Joyner /* Remove additional interfaces if they exist */ 9529e54973fSEric Joyner if (sc->mirr_if) 9539e54973fSEric Joyner ice_destroy_mirror_interface(sc); 9548a13362dSEric Joyner ice_rdma_pf_detach(sc); 9558a13362dSEric Joyner 95671d10453SEric Joyner /* Free allocated media types */ 95771d10453SEric Joyner ifmedia_removeall(sc->media); 95871d10453SEric Joyner 95971d10453SEric Joyner /* Free the Tx and Rx sysctl contexts, and assign NULL to the node 96071d10453SEric Joyner * pointers. Note, the calls here and those in ice_if_queues_free() 96171d10453SEric Joyner * are *BOTH* necessary, as we cannot guarantee which path will be 96271d10453SEric Joyner * run first 96371d10453SEric Joyner */ 96471d10453SEric Joyner ice_vsi_del_txqs_ctx(vsi); 96571d10453SEric Joyner ice_vsi_del_rxqs_ctx(vsi); 96671d10453SEric Joyner 96771d10453SEric Joyner /* Release MSI-X resources */ 96871d10453SEric Joyner ice_free_irqvs(sc); 96971d10453SEric Joyner 97071d10453SEric Joyner for (i = 0; i < sc->num_available_vsi; i++) { 97171d10453SEric Joyner if (sc->all_vsi[i]) 97271d10453SEric Joyner ice_release_vsi(sc->all_vsi[i]); 97371d10453SEric Joyner } 97471d10453SEric Joyner 97571d10453SEric Joyner if (sc->all_vsi) { 97671d10453SEric Joyner free(sc->all_vsi, M_ICE); 97771d10453SEric Joyner sc->all_vsi = NULL; 97871d10453SEric Joyner } 97971d10453SEric Joyner 98071d10453SEric Joyner /* Release MSI-X memory */ 98171d10453SEric Joyner pci_release_msi(sc->dev); 98271d10453SEric Joyner 98371d10453SEric Joyner if (sc->msix_table != NULL) { 98471d10453SEric Joyner bus_release_resource(sc->dev, SYS_RES_MEMORY, 98571d10453SEric Joyner rman_get_rid(sc->msix_table), 98671d10453SEric Joyner sc->msix_table); 98771d10453SEric Joyner sc->msix_table = NULL; 98871d10453SEric Joyner } 98971d10453SEric Joyner 99071d10453SEric Joyner ice_free_intr_tracking(sc); 99171d10453SEric Joyner 99271d10453SEric Joyner /* Destroy the queue managers */ 99371d10453SEric Joyner ice_resmgr_destroy(&sc->tx_qmgr); 99471d10453SEric Joyner ice_resmgr_destroy(&sc->rx_qmgr); 99571d10453SEric Joyner 99671d10453SEric Joyner if (!ice_test_state(&sc->state, ICE_STATE_RECOVERY_MODE)) 99771d10453SEric Joyner ice_deinit_hw(&sc->hw); 99871d10453SEric Joyner 9999c30461dSEric Joyner IFLIB_CTX_UNLOCK(sc); 10009c30461dSEric Joyner status = ice_reset(&sc->hw, ICE_RESET_PFR); 10019c30461dSEric Joyner IFLIB_CTX_LOCK(sc); 10029c30461dSEric Joyner if (status) { 10039c30461dSEric Joyner device_printf(sc->dev, "device PF reset failed, err %s\n", 10049c30461dSEric Joyner ice_status_str(status)); 10059c30461dSEric Joyner } 10069c30461dSEric Joyner 100771d10453SEric Joyner ice_free_pci_mapping(sc); 100871d10453SEric Joyner 100971d10453SEric Joyner return 0; 101071d10453SEric Joyner } /* ice_if_detach */ 101171d10453SEric Joyner 101271d10453SEric Joyner /** 101371d10453SEric Joyner * ice_if_tx_queues_alloc - Allocate Tx queue memory 101471d10453SEric Joyner * @ctx: iflib context structure 101571d10453SEric Joyner * @vaddrs: virtual addresses for the queue memory 101671d10453SEric Joyner * @paddrs: physical addresses for the queue memory 101771d10453SEric Joyner * @ntxqs: the number of Tx queues per set (should always be 1) 101871d10453SEric Joyner * @ntxqsets: the number of Tx queue sets to allocate 101971d10453SEric Joyner * 102071d10453SEric Joyner * Called by iflib to allocate Tx queues for the device. Allocates driver 102171d10453SEric Joyner * memory to track each queue, the status arrays used for descriptor 102271d10453SEric Joyner * status reporting, and Tx queue sysctls. 102371d10453SEric Joyner */ 102471d10453SEric Joyner static int 102571d10453SEric Joyner ice_if_tx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs, uint64_t *paddrs, 102671d10453SEric Joyner int __invariant_only ntxqs, int ntxqsets) 102771d10453SEric Joyner { 102871d10453SEric Joyner struct ice_softc *sc = (struct ice_softc *)iflib_get_softc(ctx); 102971d10453SEric Joyner struct ice_vsi *vsi = &sc->pf_vsi; 103071d10453SEric Joyner struct ice_tx_queue *txq; 103171d10453SEric Joyner int err, i, j; 103271d10453SEric Joyner 103371d10453SEric Joyner MPASS(ntxqs == 1); 103471d10453SEric Joyner MPASS(sc->scctx->isc_ntxd[0] <= ICE_MAX_DESC_COUNT); 103571d10453SEric Joyner ASSERT_CTX_LOCKED(sc); 103671d10453SEric Joyner 103771d10453SEric Joyner /* Do not bother allocating queues if we're in recovery mode */ 103871d10453SEric Joyner if (ice_test_state(&sc->state, ICE_STATE_RECOVERY_MODE)) 103971d10453SEric Joyner return (0); 104071d10453SEric Joyner 104171d10453SEric Joyner /* Allocate queue structure memory */ 104271d10453SEric Joyner if (!(vsi->tx_queues = 10438923de59SPiotr Kubaj (struct ice_tx_queue *) malloc(sizeof(struct ice_tx_queue) * ntxqsets, M_ICE, M_NOWAIT | M_ZERO))) { 104471d10453SEric Joyner device_printf(sc->dev, "Unable to allocate Tx queue memory\n"); 104571d10453SEric Joyner return (ENOMEM); 104671d10453SEric Joyner } 104771d10453SEric Joyner 104871d10453SEric Joyner /* Allocate report status arrays */ 104971d10453SEric Joyner for (i = 0, txq = vsi->tx_queues; i < ntxqsets; i++, txq++) { 105071d10453SEric Joyner if (!(txq->tx_rsq = 10518923de59SPiotr Kubaj (uint16_t *) malloc(sizeof(uint16_t) * sc->scctx->isc_ntxd[0], M_ICE, M_NOWAIT))) { 105271d10453SEric Joyner device_printf(sc->dev, "Unable to allocate tx_rsq memory\n"); 105371d10453SEric Joyner err = ENOMEM; 105471d10453SEric Joyner goto free_tx_queues; 105571d10453SEric Joyner } 105671d10453SEric Joyner /* Initialize report status array */ 105771d10453SEric Joyner for (j = 0; j < sc->scctx->isc_ntxd[0]; j++) 105871d10453SEric Joyner txq->tx_rsq[j] = QIDX_INVALID; 105971d10453SEric Joyner } 106071d10453SEric Joyner 106171d10453SEric Joyner /* Assign queues from PF space to the main VSI */ 106271d10453SEric Joyner err = ice_resmgr_assign_contiguous(&sc->tx_qmgr, vsi->tx_qmap, ntxqsets); 106371d10453SEric Joyner if (err) { 106471d10453SEric Joyner device_printf(sc->dev, "Unable to assign PF queues: %s\n", 106571d10453SEric Joyner ice_err_str(err)); 106671d10453SEric Joyner goto free_tx_queues; 106771d10453SEric Joyner } 106871d10453SEric Joyner vsi->qmap_type = ICE_RESMGR_ALLOC_CONTIGUOUS; 106971d10453SEric Joyner 107071d10453SEric Joyner /* Add Tx queue sysctls context */ 107171d10453SEric Joyner ice_vsi_add_txqs_ctx(vsi); 107271d10453SEric Joyner 107371d10453SEric Joyner for (i = 0, txq = vsi->tx_queues; i < ntxqsets; i++, txq++) { 107456429daeSEric Joyner /* q_handle == me when only one TC */ 107556429daeSEric Joyner txq->me = txq->q_handle = i; 107671d10453SEric Joyner txq->vsi = vsi; 107771d10453SEric Joyner 107871d10453SEric Joyner /* store the queue size for easier access */ 107971d10453SEric Joyner txq->desc_count = sc->scctx->isc_ntxd[0]; 108071d10453SEric Joyner 108171d10453SEric Joyner /* get the virtual and physical address of the hardware queues */ 108271d10453SEric Joyner txq->tail = QTX_COMM_DBELL(vsi->tx_qmap[i]); 108371d10453SEric Joyner txq->tx_base = (struct ice_tx_desc *)vaddrs[i]; 108471d10453SEric Joyner txq->tx_paddr = paddrs[i]; 108571d10453SEric Joyner 108671d10453SEric Joyner ice_add_txq_sysctls(txq); 108771d10453SEric Joyner } 108871d10453SEric Joyner 108971d10453SEric Joyner vsi->num_tx_queues = ntxqsets; 109071d10453SEric Joyner 109171d10453SEric Joyner return (0); 109271d10453SEric Joyner 109371d10453SEric Joyner free_tx_queues: 109471d10453SEric Joyner for (i = 0, txq = vsi->tx_queues; i < ntxqsets; i++, txq++) { 109571d10453SEric Joyner if (txq->tx_rsq != NULL) { 109671d10453SEric Joyner free(txq->tx_rsq, M_ICE); 109771d10453SEric Joyner txq->tx_rsq = NULL; 109871d10453SEric Joyner } 109971d10453SEric Joyner } 110071d10453SEric Joyner free(vsi->tx_queues, M_ICE); 110171d10453SEric Joyner vsi->tx_queues = NULL; 110271d10453SEric Joyner return err; 110371d10453SEric Joyner } 110471d10453SEric Joyner 110571d10453SEric Joyner /** 110671d10453SEric Joyner * ice_if_rx_queues_alloc - Allocate Rx queue memory 110771d10453SEric Joyner * @ctx: iflib context structure 110871d10453SEric Joyner * @vaddrs: virtual addresses for the queue memory 110971d10453SEric Joyner * @paddrs: physical addresses for the queue memory 111071d10453SEric Joyner * @nrxqs: number of Rx queues per set (should always be 1) 111171d10453SEric Joyner * @nrxqsets: number of Rx queue sets to allocate 111271d10453SEric Joyner * 111371d10453SEric Joyner * Called by iflib to allocate Rx queues for the device. Allocates driver 111471d10453SEric Joyner * memory to track each queue, as well as sets up the Rx queue sysctls. 111571d10453SEric Joyner */ 111671d10453SEric Joyner static int 111771d10453SEric Joyner ice_if_rx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs, uint64_t *paddrs, 111871d10453SEric Joyner int __invariant_only nrxqs, int nrxqsets) 111971d10453SEric Joyner { 112071d10453SEric Joyner struct ice_softc *sc = (struct ice_softc *)iflib_get_softc(ctx); 112171d10453SEric Joyner struct ice_vsi *vsi = &sc->pf_vsi; 112271d10453SEric Joyner struct ice_rx_queue *rxq; 112371d10453SEric Joyner int err, i; 112471d10453SEric Joyner 112571d10453SEric Joyner MPASS(nrxqs == 1); 112671d10453SEric Joyner MPASS(sc->scctx->isc_nrxd[0] <= ICE_MAX_DESC_COUNT); 112771d10453SEric Joyner ASSERT_CTX_LOCKED(sc); 112871d10453SEric Joyner 112971d10453SEric Joyner /* Do not bother allocating queues if we're in recovery mode */ 113071d10453SEric Joyner if (ice_test_state(&sc->state, ICE_STATE_RECOVERY_MODE)) 113171d10453SEric Joyner return (0); 113271d10453SEric Joyner 113371d10453SEric Joyner /* Allocate queue structure memory */ 113471d10453SEric Joyner if (!(vsi->rx_queues = 11358923de59SPiotr Kubaj (struct ice_rx_queue *) malloc(sizeof(struct ice_rx_queue) * nrxqsets, M_ICE, M_NOWAIT | M_ZERO))) { 113671d10453SEric Joyner device_printf(sc->dev, "Unable to allocate Rx queue memory\n"); 113771d10453SEric Joyner return (ENOMEM); 113871d10453SEric Joyner } 113971d10453SEric Joyner 114071d10453SEric Joyner /* Assign queues from PF space to the main VSI */ 114171d10453SEric Joyner err = ice_resmgr_assign_contiguous(&sc->rx_qmgr, vsi->rx_qmap, nrxqsets); 114271d10453SEric Joyner if (err) { 114371d10453SEric Joyner device_printf(sc->dev, "Unable to assign PF queues: %s\n", 114471d10453SEric Joyner ice_err_str(err)); 114571d10453SEric Joyner goto free_rx_queues; 114671d10453SEric Joyner } 114771d10453SEric Joyner vsi->qmap_type = ICE_RESMGR_ALLOC_CONTIGUOUS; 114871d10453SEric Joyner 114971d10453SEric Joyner /* Add Rx queue sysctls context */ 115071d10453SEric Joyner ice_vsi_add_rxqs_ctx(vsi); 115171d10453SEric Joyner 115271d10453SEric Joyner for (i = 0, rxq = vsi->rx_queues; i < nrxqsets; i++, rxq++) { 115371d10453SEric Joyner rxq->me = i; 115471d10453SEric Joyner rxq->vsi = vsi; 115571d10453SEric Joyner 115671d10453SEric Joyner /* store the queue size for easier access */ 115771d10453SEric Joyner rxq->desc_count = sc->scctx->isc_nrxd[0]; 115871d10453SEric Joyner 115971d10453SEric Joyner /* get the virtual and physical address of the hardware queues */ 116071d10453SEric Joyner rxq->tail = QRX_TAIL(vsi->rx_qmap[i]); 116171d10453SEric Joyner rxq->rx_base = (union ice_32b_rx_flex_desc *)vaddrs[i]; 116271d10453SEric Joyner rxq->rx_paddr = paddrs[i]; 116371d10453SEric Joyner 116471d10453SEric Joyner ice_add_rxq_sysctls(rxq); 116571d10453SEric Joyner } 116671d10453SEric Joyner 116771d10453SEric Joyner vsi->num_rx_queues = nrxqsets; 116871d10453SEric Joyner 116971d10453SEric Joyner return (0); 117071d10453SEric Joyner 117171d10453SEric Joyner free_rx_queues: 117271d10453SEric Joyner free(vsi->rx_queues, M_ICE); 117371d10453SEric Joyner vsi->rx_queues = NULL; 117471d10453SEric Joyner return err; 117571d10453SEric Joyner } 117671d10453SEric Joyner 117771d10453SEric Joyner /** 117871d10453SEric Joyner * ice_if_queues_free - Free queue memory 117971d10453SEric Joyner * @ctx: the iflib context structure 118071d10453SEric Joyner * 118171d10453SEric Joyner * Free queue memory allocated by ice_if_tx_queues_alloc() and 118271d10453SEric Joyner * ice_if_rx_queues_alloc(). 118371d10453SEric Joyner * 118471d10453SEric Joyner * There is no guarantee that ice_if_queues_free() and ice_if_detach() will be 118571d10453SEric Joyner * called in the same order. It's possible for ice_if_queues_free() to be 118671d10453SEric Joyner * called prior to ice_if_detach(), and vice versa. 118771d10453SEric Joyner * 118871d10453SEric Joyner * For this reason, the main VSI is a static member of the ice_softc, which is 118971d10453SEric Joyner * not free'd until after iflib finishes calling both of these functions. 119071d10453SEric Joyner * 119171d10453SEric Joyner * Thus, care must be taken in how we manage the memory being freed by this 119271d10453SEric Joyner * function, and in what tasks it can and must perform. 119371d10453SEric Joyner */ 119471d10453SEric Joyner static void 119571d10453SEric Joyner ice_if_queues_free(if_ctx_t ctx) 119671d10453SEric Joyner { 119771d10453SEric Joyner struct ice_softc *sc = (struct ice_softc *)iflib_get_softc(ctx); 119871d10453SEric Joyner struct ice_vsi *vsi = &sc->pf_vsi; 119971d10453SEric Joyner struct ice_tx_queue *txq; 120071d10453SEric Joyner int i; 120171d10453SEric Joyner 120271d10453SEric Joyner /* Free the Tx and Rx sysctl contexts, and assign NULL to the node 120371d10453SEric Joyner * pointers. Note, the calls here and those in ice_if_detach() 120471d10453SEric Joyner * are *BOTH* necessary, as we cannot guarantee which path will be 120571d10453SEric Joyner * run first 120671d10453SEric Joyner */ 120771d10453SEric Joyner ice_vsi_del_txqs_ctx(vsi); 120871d10453SEric Joyner ice_vsi_del_rxqs_ctx(vsi); 120971d10453SEric Joyner 121071d10453SEric Joyner /* Release MSI-X IRQ vectors, if not yet released in ice_if_detach */ 121171d10453SEric Joyner ice_free_irqvs(sc); 121271d10453SEric Joyner 121371d10453SEric Joyner if (vsi->tx_queues != NULL) { 121471d10453SEric Joyner /* free the tx_rsq arrays */ 121571d10453SEric Joyner for (i = 0, txq = vsi->tx_queues; i < vsi->num_tx_queues; i++, txq++) { 121671d10453SEric Joyner if (txq->tx_rsq != NULL) { 121771d10453SEric Joyner free(txq->tx_rsq, M_ICE); 121871d10453SEric Joyner txq->tx_rsq = NULL; 121971d10453SEric Joyner } 122071d10453SEric Joyner } 122171d10453SEric Joyner free(vsi->tx_queues, M_ICE); 122271d10453SEric Joyner vsi->tx_queues = NULL; 122371d10453SEric Joyner vsi->num_tx_queues = 0; 122471d10453SEric Joyner } 122571d10453SEric Joyner if (vsi->rx_queues != NULL) { 122671d10453SEric Joyner free(vsi->rx_queues, M_ICE); 122771d10453SEric Joyner vsi->rx_queues = NULL; 122871d10453SEric Joyner vsi->num_rx_queues = 0; 122971d10453SEric Joyner } 123071d10453SEric Joyner } 123171d10453SEric Joyner 123271d10453SEric Joyner /** 123371d10453SEric Joyner * ice_msix_que - Fast interrupt handler for MSI-X receive queues 123471d10453SEric Joyner * @arg: The Rx queue memory 123571d10453SEric Joyner * 123671d10453SEric Joyner * Interrupt filter function for iflib MSI-X interrupts. Called by iflib when 123771d10453SEric Joyner * an MSI-X interrupt for a given queue is triggered. Currently this just asks 123871d10453SEric Joyner * iflib to schedule the main Rx thread. 123971d10453SEric Joyner */ 124071d10453SEric Joyner static int 124171d10453SEric Joyner ice_msix_que(void *arg) 124271d10453SEric Joyner { 124371d10453SEric Joyner struct ice_rx_queue __unused *rxq = (struct ice_rx_queue *)arg; 124471d10453SEric Joyner 124571d10453SEric Joyner /* TODO: dynamic ITR algorithm?? */ 124671d10453SEric Joyner 124771d10453SEric Joyner return (FILTER_SCHEDULE_THREAD); 124871d10453SEric Joyner } 124971d10453SEric Joyner 125071d10453SEric Joyner /** 125171d10453SEric Joyner * ice_msix_admin - Fast interrupt handler for MSI-X admin interrupt 125271d10453SEric Joyner * @arg: pointer to device softc memory 125371d10453SEric Joyner * 125471d10453SEric Joyner * Called by iflib when an administrative interrupt occurs. Should perform any 125571d10453SEric Joyner * fast logic for handling the interrupt cause, and then indicate whether the 125671d10453SEric Joyner * admin task needs to be queued. 125771d10453SEric Joyner */ 125871d10453SEric Joyner static int 125971d10453SEric Joyner ice_msix_admin(void *arg) 126071d10453SEric Joyner { 126171d10453SEric Joyner struct ice_softc *sc = (struct ice_softc *)arg; 126271d10453SEric Joyner struct ice_hw *hw = &sc->hw; 126371d10453SEric Joyner device_t dev = sc->dev; 126471d10453SEric Joyner u32 oicr; 126571d10453SEric Joyner 126671d10453SEric Joyner /* There is no safe way to modify the enabled miscellaneous causes of 126771d10453SEric Joyner * the OICR vector at runtime, as doing so would be prone to race 126871d10453SEric Joyner * conditions. Reading PFINT_OICR will unmask the associated interrupt 126971d10453SEric Joyner * causes and allow future interrupts to occur. The admin interrupt 127071d10453SEric Joyner * vector will not be re-enabled until after we exit this function, 127171d10453SEric Joyner * but any delayed tasks must be resilient against possible "late 127271d10453SEric Joyner * arrival" interrupts that occur while we're already handling the 127371d10453SEric Joyner * task. This is done by using state bits and serializing these 127471d10453SEric Joyner * delayed tasks via the admin status task function. 127571d10453SEric Joyner */ 127671d10453SEric Joyner oicr = rd32(hw, PFINT_OICR); 127771d10453SEric Joyner 127871d10453SEric Joyner /* Processing multiple controlq interrupts on a single vector does not 127971d10453SEric Joyner * provide an indication of which controlq triggered the interrupt. 128071d10453SEric Joyner * We might try reading the INTEVENT bit of the respective PFINT_*_CTL 128171d10453SEric Joyner * registers. However, the INTEVENT bit is not guaranteed to be set as 128271d10453SEric Joyner * it gets automatically cleared when the hardware acknowledges the 128371d10453SEric Joyner * interrupt. 128471d10453SEric Joyner * 128571d10453SEric Joyner * This means we don't really have a good indication of whether or 128671d10453SEric Joyner * which controlq triggered this interrupt. We'll just notify the 128771d10453SEric Joyner * admin task that it should check all the controlqs. 128871d10453SEric Joyner */ 128971d10453SEric Joyner ice_set_state(&sc->state, ICE_STATE_CONTROLQ_EVENT_PENDING); 129071d10453SEric Joyner 129171d10453SEric Joyner if (oicr & PFINT_OICR_VFLR_M) { 129271d10453SEric Joyner ice_set_state(&sc->state, ICE_STATE_VFLR_PENDING); 129371d10453SEric Joyner } 129471d10453SEric Joyner 129571d10453SEric Joyner if (oicr & PFINT_OICR_MAL_DETECT_M) { 129671d10453SEric Joyner ice_set_state(&sc->state, ICE_STATE_MDD_PENDING); 129771d10453SEric Joyner } 129871d10453SEric Joyner 129971d10453SEric Joyner if (oicr & PFINT_OICR_GRST_M) { 130071d10453SEric Joyner u32 reset; 130171d10453SEric Joyner 130271d10453SEric Joyner reset = (rd32(hw, GLGEN_RSTAT) & GLGEN_RSTAT_RESET_TYPE_M) >> 130371d10453SEric Joyner GLGEN_RSTAT_RESET_TYPE_S; 130471d10453SEric Joyner 130571d10453SEric Joyner if (reset == ICE_RESET_CORER) 130671d10453SEric Joyner sc->soft_stats.corer_count++; 130771d10453SEric Joyner else if (reset == ICE_RESET_GLOBR) 130871d10453SEric Joyner sc->soft_stats.globr_count++; 130971d10453SEric Joyner else 131071d10453SEric Joyner sc->soft_stats.empr_count++; 131171d10453SEric Joyner 131271d10453SEric Joyner /* There are a couple of bits at play for handling resets. 131371d10453SEric Joyner * First, the ICE_STATE_RESET_OICR_RECV bit is used to 131471d10453SEric Joyner * indicate that the driver has received an OICR with a reset 131571d10453SEric Joyner * bit active, indicating that a CORER/GLOBR/EMPR is about to 131671d10453SEric Joyner * happen. Second, we set hw->reset_ongoing to indicate that 131771d10453SEric Joyner * the hardware is in reset. We will set this back to false as 131871d10453SEric Joyner * soon as the driver has determined that the hardware is out 131971d10453SEric Joyner * of reset. 132071d10453SEric Joyner * 1321b6f9c6aaSGordon Bergling * If the driver wishes to trigger a request, it can set one of 132271d10453SEric Joyner * the ICE_STATE_RESET_*_REQ bits, which will trigger the 132371d10453SEric Joyner * correct type of reset. 132471d10453SEric Joyner */ 13259e54973fSEric Joyner if (!ice_testandset_state(&sc->state, ICE_STATE_RESET_OICR_RECV)) { 132671d10453SEric Joyner hw->reset_ongoing = true; 13279e54973fSEric Joyner /* 13289e54973fSEric Joyner * During the NVM update process, there is a driver reset and link 13299e54973fSEric Joyner * goes down and then up. The below if-statement prevents a second 13309e54973fSEric Joyner * link flap from occurring in ice_if_init(). 13319e54973fSEric Joyner */ 13329e54973fSEric Joyner if (if_getflags(sc->ifp) & IFF_UP) 13339e54973fSEric Joyner ice_set_state(&sc->state, ICE_STATE_FIRST_INIT_LINK); 13349e54973fSEric Joyner } 133571d10453SEric Joyner } 133671d10453SEric Joyner 133771d10453SEric Joyner if (oicr & PFINT_OICR_ECC_ERR_M) { 133871d10453SEric Joyner device_printf(dev, "ECC Error detected!\n"); 133971d10453SEric Joyner ice_set_state(&sc->state, ICE_STATE_RESET_PFR_REQ); 134071d10453SEric Joyner } 134171d10453SEric Joyner 134201fbb869SBartosz Sobczak if (oicr & (PFINT_OICR_PE_CRITERR_M | PFINT_OICR_HMC_ERR_M)) { 134301fbb869SBartosz Sobczak if (oicr & PFINT_OICR_HMC_ERR_M) 134401fbb869SBartosz Sobczak /* Log the HMC errors */ 134501fbb869SBartosz Sobczak ice_log_hmc_error(hw, dev); 134601fbb869SBartosz Sobczak ice_rdma_notify_pe_intr(sc, oicr); 134771d10453SEric Joyner } 134871d10453SEric Joyner 134971d10453SEric Joyner if (oicr & PFINT_OICR_PCI_EXCEPTION_M) { 135071d10453SEric Joyner device_printf(dev, "PCI Exception detected!\n"); 135171d10453SEric Joyner ice_set_state(&sc->state, ICE_STATE_RESET_PFR_REQ); 135271d10453SEric Joyner } 135371d10453SEric Joyner 135471d10453SEric Joyner return (FILTER_SCHEDULE_THREAD); 135571d10453SEric Joyner } 135671d10453SEric Joyner 135771d10453SEric Joyner /** 135871d10453SEric Joyner * ice_allocate_msix - Allocate MSI-X vectors for the interface 135971d10453SEric Joyner * @sc: the device private softc 136071d10453SEric Joyner * 136171d10453SEric Joyner * Map the MSI-X bar, and then request MSI-X vectors in a two-stage process. 136271d10453SEric Joyner * 136371d10453SEric Joyner * First, determine a suitable total number of vectors based on the number 136471d10453SEric Joyner * of CPUs, RSS buckets, the administrative vector, and other demands such as 136571d10453SEric Joyner * RDMA. 136671d10453SEric Joyner * 136771d10453SEric Joyner * Request the desired amount of vectors, and see how many we obtain. If we 136871d10453SEric Joyner * don't obtain as many as desired, reduce the demands by lowering the number 136971d10453SEric Joyner * of requested queues or reducing the demand from other features such as 137071d10453SEric Joyner * RDMA. 137171d10453SEric Joyner * 137271d10453SEric Joyner * @remark This function is required because the driver sets the 137371d10453SEric Joyner * IFLIB_SKIP_MSIX flag indicating that the driver will manage MSI-X vectors 137471d10453SEric Joyner * manually. 137571d10453SEric Joyner * 137671d10453SEric Joyner * @remark This driver will only use MSI-X vectors. If this is not possible, 137771d10453SEric Joyner * neither MSI or legacy interrupts will be tried. 137871d10453SEric Joyner * 13799e54973fSEric Joyner * @remark if it exists, os_imgr is initialized here for keeping track of 13809e54973fSEric Joyner * the assignments of extra MSIX vectors. 13819e54973fSEric Joyner * 138271d10453SEric Joyner * @post on success this function must set the following scctx parameters: 138371d10453SEric Joyner * isc_vectors, isc_nrxqsets, isc_ntxqsets, and isc_intr. 138471d10453SEric Joyner * 138571d10453SEric Joyner * @returns zero on success or an error code on failure. 138671d10453SEric Joyner */ 138771d10453SEric Joyner static int 138871d10453SEric Joyner ice_allocate_msix(struct ice_softc *sc) 138971d10453SEric Joyner { 139071d10453SEric Joyner bool iflib_override_queue_count = false; 139171d10453SEric Joyner if_softc_ctx_t scctx = sc->scctx; 139271d10453SEric Joyner device_t dev = sc->dev; 139371d10453SEric Joyner cpuset_t cpus; 139471d10453SEric Joyner int bar, queues, vectors, requested; 139571d10453SEric Joyner int err = 0; 13968a13362dSEric Joyner int rdma; 139771d10453SEric Joyner 139871d10453SEric Joyner /* Allocate the MSI-X bar */ 139971d10453SEric Joyner bar = scctx->isc_msix_bar; 140071d10453SEric Joyner sc->msix_table = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &bar, RF_ACTIVE); 140171d10453SEric Joyner if (!sc->msix_table) { 140271d10453SEric Joyner device_printf(dev, "Unable to map MSI-X table\n"); 140371d10453SEric Joyner return (ENOMEM); 140471d10453SEric Joyner } 140571d10453SEric Joyner 140671d10453SEric Joyner /* Check if the iflib queue count sysctls have been set */ 140771d10453SEric Joyner if (sc->ifc_sysctl_ntxqs || sc->ifc_sysctl_nrxqs) 140871d10453SEric Joyner iflib_override_queue_count = true; 140971d10453SEric Joyner 141071d10453SEric Joyner err = bus_get_cpus(dev, INTR_CPUS, sizeof(cpus), &cpus); 141171d10453SEric Joyner if (err) { 141271d10453SEric Joyner device_printf(dev, "%s: Unable to fetch the CPU list: %s\n", 141371d10453SEric Joyner __func__, ice_err_str(err)); 141471d10453SEric Joyner CPU_COPY(&all_cpus, &cpus); 141571d10453SEric Joyner } 141671d10453SEric Joyner 141771d10453SEric Joyner /* Attempt to mimic behavior of iflib_msix_init */ 141871d10453SEric Joyner if (iflib_override_queue_count) { 141971d10453SEric Joyner /* 142071d10453SEric Joyner * If the override sysctls have been set, limit the queues to 142171d10453SEric Joyner * the number of logical CPUs. 142271d10453SEric Joyner */ 142371d10453SEric Joyner queues = mp_ncpus; 142471d10453SEric Joyner } else { 142571d10453SEric Joyner /* 142671d10453SEric Joyner * Otherwise, limit the queue count to the CPUs associated 142771d10453SEric Joyner * with the NUMA node the device is associated with. 142871d10453SEric Joyner */ 142971d10453SEric Joyner queues = CPU_COUNT(&cpus); 143071d10453SEric Joyner } 143171d10453SEric Joyner 143271d10453SEric Joyner /* Clamp to the number of RSS buckets */ 143371d10453SEric Joyner queues = imin(queues, rss_getnumbuckets()); 143471d10453SEric Joyner 143571d10453SEric Joyner /* 143671d10453SEric Joyner * Clamp the number of queue pairs to the minimum of the requested Tx 143771d10453SEric Joyner * and Rx queues. 143871d10453SEric Joyner */ 143971d10453SEric Joyner queues = imin(queues, sc->ifc_sysctl_ntxqs ?: scctx->isc_ntxqsets); 144071d10453SEric Joyner queues = imin(queues, sc->ifc_sysctl_nrxqs ?: scctx->isc_nrxqsets); 144171d10453SEric Joyner 14428a13362dSEric Joyner if (ice_is_bit_set(sc->feat_cap, ICE_FEATURE_RDMA)) { 14438a13362dSEric Joyner /* 14448a13362dSEric Joyner * Choose a number of RDMA vectors based on the number of CPUs 14458a13362dSEric Joyner * up to a maximum 14468a13362dSEric Joyner */ 14478a13362dSEric Joyner rdma = min(CPU_COUNT(&cpus), ICE_RDMA_MAX_MSIX); 14488a13362dSEric Joyner 14498a13362dSEric Joyner /* Further limit by the user configurable tunable */ 14508a13362dSEric Joyner rdma = min(rdma, ice_rdma_max_msix); 14518a13362dSEric Joyner } else { 14528a13362dSEric Joyner rdma = 0; 14538a13362dSEric Joyner } 14548a13362dSEric Joyner 145571d10453SEric Joyner /* 145671d10453SEric Joyner * Determine the number of vectors to request. Note that we also need 145771d10453SEric Joyner * to allocate one vector for administrative tasks. 145871d10453SEric Joyner */ 14598a13362dSEric Joyner requested = rdma + queues + 1; 14609e54973fSEric Joyner /* Add extra vectors requested by the user for later subinterface 14619e54973fSEric Joyner * creation. 14629e54973fSEric Joyner */ 14639e54973fSEric Joyner if_ctx_t ctx = sc->ctx; 14649e54973fSEric Joyner u32 extra_vectors = iflib_get_extra_msix_vectors_sysctl(ctx); 14659e54973fSEric Joyner requested += extra_vectors; 146671d10453SEric Joyner 146771d10453SEric Joyner vectors = requested; 146871d10453SEric Joyner err = pci_alloc_msix(dev, &vectors); 146971d10453SEric Joyner if (err) { 147071d10453SEric Joyner device_printf(dev, "Failed to allocate %d MSI-X vectors, err %s\n", 147171d10453SEric Joyner vectors, ice_err_str(err)); 147271d10453SEric Joyner goto err_free_msix_table; 147371d10453SEric Joyner } 147471d10453SEric Joyner 147571d10453SEric Joyner /* If we don't receive enough vectors, reduce demands */ 147671d10453SEric Joyner if (vectors < requested) { 147771d10453SEric Joyner int diff = requested - vectors; 147871d10453SEric Joyner 147971d10453SEric Joyner device_printf(dev, "Requested %d MSI-X vectors, but got only %d\n", 148071d10453SEric Joyner requested, vectors); 148171d10453SEric Joyner 14829e54973fSEric Joyner diff += extra_vectors; 14839e54973fSEric Joyner extra_vectors = 0; 148471d10453SEric Joyner /* 14858a13362dSEric Joyner * The OS didn't grant us the requested number of vectors. 14868a13362dSEric Joyner * Check to see if we can reduce demands by limiting the 14878a13362dSEric Joyner * number of vectors allocated to certain features. 14888a13362dSEric Joyner */ 14898a13362dSEric Joyner 14908a13362dSEric Joyner if (rdma >= diff) { 14918a13362dSEric Joyner /* Reduce the number of RDMA vectors we reserve */ 14928a13362dSEric Joyner rdma -= diff; 14938a13362dSEric Joyner diff = 0; 14948a13362dSEric Joyner } else { 14958a13362dSEric Joyner /* Disable RDMA and reduce the difference */ 14968a13362dSEric Joyner ice_clear_bit(ICE_FEATURE_RDMA, sc->feat_cap); 14978a13362dSEric Joyner diff -= rdma; 14988a13362dSEric Joyner rdma = 0; 14998a13362dSEric Joyner } 15008a13362dSEric Joyner 15018a13362dSEric Joyner /* 150271d10453SEric Joyner * If we still have a difference, we need to reduce the number 150371d10453SEric Joyner * of queue pairs. 150471d10453SEric Joyner * 150571d10453SEric Joyner * However, we still need at least one vector for the admin 150671d10453SEric Joyner * interrupt and one queue pair. 150771d10453SEric Joyner */ 150871d10453SEric Joyner if (queues <= diff) { 150971d10453SEric Joyner device_printf(dev, "Unable to allocate sufficient MSI-X vectors\n"); 151071d10453SEric Joyner err = (ERANGE); 151171d10453SEric Joyner goto err_pci_release_msi; 151271d10453SEric Joyner } 151371d10453SEric Joyner 151471d10453SEric Joyner queues -= diff; 151571d10453SEric Joyner } 151671d10453SEric Joyner 151771d10453SEric Joyner device_printf(dev, "Using %d Tx and Rx queues\n", queues); 15188a13362dSEric Joyner if (rdma) 15198a13362dSEric Joyner device_printf(dev, "Reserving %d MSI-X interrupts for iRDMA\n", 15208a13362dSEric Joyner rdma); 152171d10453SEric Joyner device_printf(dev, "Using MSI-X interrupts with %d vectors\n", 152271d10453SEric Joyner vectors); 152371d10453SEric Joyner 15249e54973fSEric Joyner /* Split resulting vectors back into requested splits */ 152571d10453SEric Joyner scctx->isc_vectors = vectors; 152671d10453SEric Joyner scctx->isc_nrxqsets = queues; 152771d10453SEric Joyner scctx->isc_ntxqsets = queues; 152871d10453SEric Joyner scctx->isc_intr = IFLIB_INTR_MSIX; 152971d10453SEric Joyner 15308a13362dSEric Joyner sc->irdma_vectors = rdma; 15318a13362dSEric Joyner 153271d10453SEric Joyner /* Interrupt allocation tracking isn't required in recovery mode, 153371d10453SEric Joyner * since neither RDMA nor VFs are enabled. 153471d10453SEric Joyner */ 153571d10453SEric Joyner if (ice_test_state(&sc->state, ICE_STATE_RECOVERY_MODE)) 153671d10453SEric Joyner return (0); 153771d10453SEric Joyner 153871d10453SEric Joyner /* Keep track of which interrupt indices are being used for what */ 15398a13362dSEric Joyner sc->lan_vectors = vectors - rdma; 15409e54973fSEric Joyner sc->lan_vectors -= extra_vectors; 15419e54973fSEric Joyner err = ice_resmgr_assign_contiguous(&sc->dev_imgr, sc->pf_imap, sc->lan_vectors); 154271d10453SEric Joyner if (err) { 154371d10453SEric Joyner device_printf(dev, "Unable to assign PF interrupt mapping: %s\n", 154471d10453SEric Joyner ice_err_str(err)); 154571d10453SEric Joyner goto err_pci_release_msi; 154671d10453SEric Joyner } 15479e54973fSEric Joyner err = ice_resmgr_assign_contiguous(&sc->dev_imgr, sc->rdma_imap, rdma); 15488a13362dSEric Joyner if (err) { 15498a13362dSEric Joyner device_printf(dev, "Unable to assign PF RDMA interrupt mapping: %s\n", 15508a13362dSEric Joyner ice_err_str(err)); 15519e54973fSEric Joyner goto err_release_pf_imap; 15528a13362dSEric Joyner } 15539e54973fSEric Joyner sc->extra_vectors = extra_vectors; 15549e54973fSEric Joyner /* Setup another resource manager to track the assignments of extra OS 15559e54973fSEric Joyner * vectors. These OS interrupt allocations don't need to be contiguous, 15569e54973fSEric Joyner * unlike the ones that come from the device. 15579e54973fSEric Joyner */ 15589e54973fSEric Joyner err = ice_resmgr_init(&sc->os_imgr, sc->extra_vectors); 15599e54973fSEric Joyner if (err) { 15609e54973fSEric Joyner device_printf(dev, "Unable to initialize OS extra interrupt manager: %s\n", 15619e54973fSEric Joyner ice_err_str(err)); 15629e54973fSEric Joyner ice_resmgr_release_map(&sc->dev_imgr, sc->rdma_imap, 15639e54973fSEric Joyner rdma); 15649e54973fSEric Joyner goto err_release_pf_imap; 15659e54973fSEric Joyner } 156671d10453SEric Joyner return (0); 156771d10453SEric Joyner 15689e54973fSEric Joyner err_release_pf_imap: 15699e54973fSEric Joyner ice_resmgr_release_map(&sc->dev_imgr, sc->pf_imap, 15709e54973fSEric Joyner sc->lan_vectors); 157171d10453SEric Joyner err_pci_release_msi: 157271d10453SEric Joyner pci_release_msi(dev); 157371d10453SEric Joyner err_free_msix_table: 157471d10453SEric Joyner if (sc->msix_table != NULL) { 157571d10453SEric Joyner bus_release_resource(sc->dev, SYS_RES_MEMORY, 157671d10453SEric Joyner rman_get_rid(sc->msix_table), 157771d10453SEric Joyner sc->msix_table); 157871d10453SEric Joyner sc->msix_table = NULL; 157971d10453SEric Joyner } 158071d10453SEric Joyner 158171d10453SEric Joyner return (err); 158271d10453SEric Joyner } 158371d10453SEric Joyner 158471d10453SEric Joyner /** 158571d10453SEric Joyner * ice_if_msix_intr_assign - Assign MSI-X interrupt vectors to queues 158671d10453SEric Joyner * @ctx: the iflib context structure 158771d10453SEric Joyner * @msix: the number of vectors we were assigned 158871d10453SEric Joyner * 158971d10453SEric Joyner * Called by iflib to assign MSI-X vectors to queues. Currently requires that 159071d10453SEric Joyner * we get at least the same number of vectors as we have queues, and that we 159171d10453SEric Joyner * always have the same number of Tx and Rx queues. 159271d10453SEric Joyner * 159371d10453SEric Joyner * Tx queues use a softirq instead of using their own hardware interrupt. 159471d10453SEric Joyner */ 159571d10453SEric Joyner static int 159671d10453SEric Joyner ice_if_msix_intr_assign(if_ctx_t ctx, int msix) 159771d10453SEric Joyner { 159871d10453SEric Joyner struct ice_softc *sc = (struct ice_softc *)iflib_get_softc(ctx); 159971d10453SEric Joyner struct ice_vsi *vsi = &sc->pf_vsi; 160071d10453SEric Joyner int err, i, vector; 160171d10453SEric Joyner 160271d10453SEric Joyner ASSERT_CTX_LOCKED(sc); 160371d10453SEric Joyner 160471d10453SEric Joyner if (vsi->num_rx_queues != vsi->num_tx_queues) { 160571d10453SEric Joyner device_printf(sc->dev, 160671d10453SEric Joyner "iflib requested %d Tx queues, and %d Rx queues, but the driver isn't able to support a differing number of Tx and Rx queues\n", 160771d10453SEric Joyner vsi->num_tx_queues, vsi->num_rx_queues); 160871d10453SEric Joyner return (EOPNOTSUPP); 160971d10453SEric Joyner } 161071d10453SEric Joyner 161171d10453SEric Joyner if (msix < (vsi->num_rx_queues + 1)) { 161271d10453SEric Joyner device_printf(sc->dev, 161371d10453SEric Joyner "Not enough MSI-X vectors to assign one vector to each queue pair\n"); 161471d10453SEric Joyner return (EOPNOTSUPP); 161571d10453SEric Joyner } 161671d10453SEric Joyner 161771d10453SEric Joyner /* Save the number of vectors for future use */ 161871d10453SEric Joyner sc->num_irq_vectors = vsi->num_rx_queues + 1; 161971d10453SEric Joyner 162071d10453SEric Joyner /* Allocate space to store the IRQ vector data */ 162171d10453SEric Joyner if (!(sc->irqvs = 162271d10453SEric Joyner (struct ice_irq_vector *) malloc(sizeof(struct ice_irq_vector) * (sc->num_irq_vectors), 162371d10453SEric Joyner M_ICE, M_NOWAIT))) { 162471d10453SEric Joyner device_printf(sc->dev, 162571d10453SEric Joyner "Unable to allocate irqv memory\n"); 162671d10453SEric Joyner return (ENOMEM); 162771d10453SEric Joyner } 162871d10453SEric Joyner 162971d10453SEric Joyner /* Administrative interrupt events will use vector 0 */ 163071d10453SEric Joyner err = iflib_irq_alloc_generic(ctx, &sc->irqvs[0].irq, 1, IFLIB_INTR_ADMIN, 163171d10453SEric Joyner ice_msix_admin, sc, 0, "admin"); 163271d10453SEric Joyner if (err) { 163371d10453SEric Joyner device_printf(sc->dev, 163471d10453SEric Joyner "Failed to register Admin queue handler: %s\n", 163571d10453SEric Joyner ice_err_str(err)); 163671d10453SEric Joyner goto free_irqvs; 163771d10453SEric Joyner } 163871d10453SEric Joyner sc->irqvs[0].me = 0; 163971d10453SEric Joyner 164071d10453SEric Joyner /* Do not allocate queue interrupts when in recovery mode */ 164171d10453SEric Joyner if (ice_test_state(&sc->state, ICE_STATE_RECOVERY_MODE)) 164271d10453SEric Joyner return (0); 164371d10453SEric Joyner 16449e54973fSEric Joyner int rid; 164571d10453SEric Joyner for (i = 0, vector = 1; i < vsi->num_rx_queues; i++, vector++) { 164671d10453SEric Joyner struct ice_rx_queue *rxq = &vsi->rx_queues[i]; 164771d10453SEric Joyner struct ice_tx_queue *txq = &vsi->tx_queues[i]; 164871d10453SEric Joyner char irq_name[16]; 164971d10453SEric Joyner 16509e54973fSEric Joyner rid = vector + 1; 16519e54973fSEric Joyner 165271d10453SEric Joyner snprintf(irq_name, sizeof(irq_name), "rxq%d", i); 165371d10453SEric Joyner err = iflib_irq_alloc_generic(ctx, &sc->irqvs[vector].irq, rid, 165481be6552SMatt Macy IFLIB_INTR_RXTX, ice_msix_que, 165571d10453SEric Joyner rxq, rxq->me, irq_name); 165671d10453SEric Joyner if (err) { 165771d10453SEric Joyner device_printf(sc->dev, 165871d10453SEric Joyner "Failed to allocate q int %d err: %s\n", 165971d10453SEric Joyner i, ice_err_str(err)); 166071d10453SEric Joyner vector--; 166171d10453SEric Joyner i--; 166271d10453SEric Joyner goto fail; 166371d10453SEric Joyner } 166471d10453SEric Joyner sc->irqvs[vector].me = vector; 166571d10453SEric Joyner rxq->irqv = &sc->irqvs[vector]; 166671d10453SEric Joyner 166771d10453SEric Joyner bzero(irq_name, sizeof(irq_name)); 166871d10453SEric Joyner 166971d10453SEric Joyner snprintf(irq_name, sizeof(irq_name), "txq%d", i); 167071d10453SEric Joyner iflib_softirq_alloc_generic(ctx, &sc->irqvs[vector].irq, 167171d10453SEric Joyner IFLIB_INTR_TX, txq, 167271d10453SEric Joyner txq->me, irq_name); 167371d10453SEric Joyner txq->irqv = &sc->irqvs[vector]; 167471d10453SEric Joyner } 167571d10453SEric Joyner 16769e54973fSEric Joyner /* For future interrupt assignments */ 16779e54973fSEric Joyner sc->last_rid = rid + sc->irdma_vectors; 16789e54973fSEric Joyner 167971d10453SEric Joyner return (0); 168071d10453SEric Joyner fail: 168171d10453SEric Joyner for (; i >= 0; i--, vector--) 168271d10453SEric Joyner iflib_irq_free(ctx, &sc->irqvs[vector].irq); 168371d10453SEric Joyner iflib_irq_free(ctx, &sc->irqvs[0].irq); 168471d10453SEric Joyner free_irqvs: 168571d10453SEric Joyner free(sc->irqvs, M_ICE); 168671d10453SEric Joyner sc->irqvs = NULL; 168771d10453SEric Joyner return err; 168871d10453SEric Joyner } 168971d10453SEric Joyner 169071d10453SEric Joyner /** 169171d10453SEric Joyner * ice_if_mtu_set - Set the device MTU 169271d10453SEric Joyner * @ctx: iflib context structure 169371d10453SEric Joyner * @mtu: the MTU requested 169471d10453SEric Joyner * 169571d10453SEric Joyner * Called by iflib to configure the device's Maximum Transmission Unit (MTU). 169671d10453SEric Joyner * 169771d10453SEric Joyner * @pre assumes the caller holds the iflib CTX lock 169871d10453SEric Joyner */ 169971d10453SEric Joyner static int 170071d10453SEric Joyner ice_if_mtu_set(if_ctx_t ctx, uint32_t mtu) 170171d10453SEric Joyner { 170271d10453SEric Joyner struct ice_softc *sc = (struct ice_softc *)iflib_get_softc(ctx); 170371d10453SEric Joyner 170471d10453SEric Joyner ASSERT_CTX_LOCKED(sc); 170571d10453SEric Joyner 170671d10453SEric Joyner /* Do not support configuration when in recovery mode */ 170771d10453SEric Joyner if (ice_test_state(&sc->state, ICE_STATE_RECOVERY_MODE)) 170871d10453SEric Joyner return (ENOSYS); 170971d10453SEric Joyner 171071d10453SEric Joyner if (mtu < ICE_MIN_MTU || mtu > ICE_MAX_MTU) 171171d10453SEric Joyner return (EINVAL); 171271d10453SEric Joyner 171371d10453SEric Joyner sc->scctx->isc_max_frame_size = mtu + 171471d10453SEric Joyner ETHER_HDR_LEN + ETHER_CRC_LEN + ETHER_VLAN_ENCAP_LEN; 171571d10453SEric Joyner 171671d10453SEric Joyner sc->pf_vsi.max_frame_size = sc->scctx->isc_max_frame_size; 171771d10453SEric Joyner 171871d10453SEric Joyner return (0); 171971d10453SEric Joyner } 172071d10453SEric Joyner 172171d10453SEric Joyner /** 172271d10453SEric Joyner * ice_if_intr_enable - Enable device interrupts 172371d10453SEric Joyner * @ctx: iflib context structure 172471d10453SEric Joyner * 172571d10453SEric Joyner * Called by iflib to request enabling device interrupts. 172671d10453SEric Joyner */ 172771d10453SEric Joyner static void 172871d10453SEric Joyner ice_if_intr_enable(if_ctx_t ctx) 172971d10453SEric Joyner { 173071d10453SEric Joyner struct ice_softc *sc = (struct ice_softc *)iflib_get_softc(ctx); 173171d10453SEric Joyner struct ice_vsi *vsi = &sc->pf_vsi; 173271d10453SEric Joyner struct ice_hw *hw = &sc->hw; 173371d10453SEric Joyner 173471d10453SEric Joyner ASSERT_CTX_LOCKED(sc); 173571d10453SEric Joyner 173671d10453SEric Joyner /* Enable ITR 0 */ 173771d10453SEric Joyner ice_enable_intr(hw, sc->irqvs[0].me); 173871d10453SEric Joyner 173971d10453SEric Joyner /* Do not enable queue interrupts in recovery mode */ 174071d10453SEric Joyner if (ice_test_state(&sc->state, ICE_STATE_RECOVERY_MODE)) 174171d10453SEric Joyner return; 174271d10453SEric Joyner 174371d10453SEric Joyner /* Enable all queue interrupts */ 174471d10453SEric Joyner for (int i = 0; i < vsi->num_rx_queues; i++) 174571d10453SEric Joyner ice_enable_intr(hw, vsi->rx_queues[i].irqv->me); 174671d10453SEric Joyner } 174771d10453SEric Joyner 174871d10453SEric Joyner /** 174971d10453SEric Joyner * ice_if_intr_disable - Disable device interrupts 175071d10453SEric Joyner * @ctx: iflib context structure 175171d10453SEric Joyner * 175271d10453SEric Joyner * Called by iflib to request disabling device interrupts. 175371d10453SEric Joyner */ 175471d10453SEric Joyner static void 175571d10453SEric Joyner ice_if_intr_disable(if_ctx_t ctx) 175671d10453SEric Joyner { 175771d10453SEric Joyner struct ice_softc *sc = (struct ice_softc *)iflib_get_softc(ctx); 175871d10453SEric Joyner struct ice_hw *hw = &sc->hw; 175971d10453SEric Joyner unsigned int i; 176071d10453SEric Joyner 176171d10453SEric Joyner ASSERT_CTX_LOCKED(sc); 176271d10453SEric Joyner 176371d10453SEric Joyner /* IFDI_INTR_DISABLE may be called prior to interrupts actually being 176471d10453SEric Joyner * assigned to queues. Instead of assuming that the interrupt 176571d10453SEric Joyner * assignment in the rx_queues structure is valid, just disable all 176671d10453SEric Joyner * possible interrupts 176771d10453SEric Joyner * 176871d10453SEric Joyner * Note that we choose not to disable ITR 0 because this handles the 176971d10453SEric Joyner * AdminQ interrupts, and we want to keep processing these even when 177071d10453SEric Joyner * the interface is offline. 177171d10453SEric Joyner */ 177271d10453SEric Joyner for (i = 1; i < hw->func_caps.common_cap.num_msix_vectors; i++) 177371d10453SEric Joyner ice_disable_intr(hw, i); 177471d10453SEric Joyner } 177571d10453SEric Joyner 177671d10453SEric Joyner /** 177771d10453SEric Joyner * ice_if_rx_queue_intr_enable - Enable a specific Rx queue interrupt 177871d10453SEric Joyner * @ctx: iflib context structure 177971d10453SEric Joyner * @rxqid: the Rx queue to enable 178071d10453SEric Joyner * 178171d10453SEric Joyner * Enable a specific Rx queue interrupt. 178271d10453SEric Joyner * 178371d10453SEric Joyner * This function is not protected by the iflib CTX lock. 178471d10453SEric Joyner */ 178571d10453SEric Joyner static int 178671d10453SEric Joyner ice_if_rx_queue_intr_enable(if_ctx_t ctx, uint16_t rxqid) 178771d10453SEric Joyner { 178871d10453SEric Joyner struct ice_softc *sc = (struct ice_softc *)iflib_get_softc(ctx); 178971d10453SEric Joyner struct ice_vsi *vsi = &sc->pf_vsi; 179071d10453SEric Joyner struct ice_hw *hw = &sc->hw; 179171d10453SEric Joyner 179271d10453SEric Joyner /* Do not enable queue interrupts in recovery mode */ 179371d10453SEric Joyner if (ice_test_state(&sc->state, ICE_STATE_RECOVERY_MODE)) 179471d10453SEric Joyner return (ENOSYS); 179571d10453SEric Joyner 179671d10453SEric Joyner ice_enable_intr(hw, vsi->rx_queues[rxqid].irqv->me); 179771d10453SEric Joyner return (0); 179871d10453SEric Joyner } 179971d10453SEric Joyner 180071d10453SEric Joyner /** 180171d10453SEric Joyner * ice_if_tx_queue_intr_enable - Enable a specific Tx queue interrupt 180271d10453SEric Joyner * @ctx: iflib context structure 180371d10453SEric Joyner * @txqid: the Tx queue to enable 180471d10453SEric Joyner * 180571d10453SEric Joyner * Enable a specific Tx queue interrupt. 180671d10453SEric Joyner * 180771d10453SEric Joyner * This function is not protected by the iflib CTX lock. 180871d10453SEric Joyner */ 180971d10453SEric Joyner static int 181071d10453SEric Joyner ice_if_tx_queue_intr_enable(if_ctx_t ctx, uint16_t txqid) 181171d10453SEric Joyner { 181271d10453SEric Joyner struct ice_softc *sc = (struct ice_softc *)iflib_get_softc(ctx); 181371d10453SEric Joyner struct ice_vsi *vsi = &sc->pf_vsi; 181471d10453SEric Joyner struct ice_hw *hw = &sc->hw; 181571d10453SEric Joyner 181671d10453SEric Joyner /* Do not enable queue interrupts in recovery mode */ 181771d10453SEric Joyner if (ice_test_state(&sc->state, ICE_STATE_RECOVERY_MODE)) 181871d10453SEric Joyner return (ENOSYS); 181971d10453SEric Joyner 182071d10453SEric Joyner ice_enable_intr(hw, vsi->tx_queues[txqid].irqv->me); 182171d10453SEric Joyner return (0); 182271d10453SEric Joyner } 182371d10453SEric Joyner 182471d10453SEric Joyner /** 18259c30461dSEric Joyner * ice_set_default_promisc_mask - Set default config for promisc settings 18269c30461dSEric Joyner * @promisc_mask: bitmask to setup 18279c30461dSEric Joyner * 18289c30461dSEric Joyner * The ice_(set|clear)_vsi_promisc() function expects a mask of promiscuous 18299c30461dSEric Joyner * modes to operate on. The mask used in here is the default one for the 18309c30461dSEric Joyner * driver, where promiscuous is enabled/disabled for all types of 18319c30461dSEric Joyner * non-VLAN-tagged/VLAN 0 traffic. 18329c30461dSEric Joyner */ 18339c30461dSEric Joyner static void 18349c30461dSEric Joyner ice_set_default_promisc_mask(ice_bitmap_t *promisc_mask) 18359c30461dSEric Joyner { 18369c30461dSEric Joyner ice_zero_bitmap(promisc_mask, ICE_PROMISC_MAX); 18379c30461dSEric Joyner ice_set_bit(ICE_PROMISC_UCAST_TX, promisc_mask); 18389c30461dSEric Joyner ice_set_bit(ICE_PROMISC_UCAST_RX, promisc_mask); 18399c30461dSEric Joyner ice_set_bit(ICE_PROMISC_MCAST_TX, promisc_mask); 18409c30461dSEric Joyner ice_set_bit(ICE_PROMISC_MCAST_RX, promisc_mask); 18419c30461dSEric Joyner } 18429c30461dSEric Joyner 18439c30461dSEric Joyner /** 184471d10453SEric Joyner * ice_if_promisc_set - Set device promiscuous mode 184571d10453SEric Joyner * @ctx: iflib context structure 184671d10453SEric Joyner * @flags: promiscuous flags to configure 184771d10453SEric Joyner * 184871d10453SEric Joyner * Called by iflib to configure device promiscuous mode. 184971d10453SEric Joyner * 185071d10453SEric Joyner * @remark Calls to this function will always overwrite the previous setting 185171d10453SEric Joyner */ 185271d10453SEric Joyner static int 185371d10453SEric Joyner ice_if_promisc_set(if_ctx_t ctx, int flags) 185471d10453SEric Joyner { 185571d10453SEric Joyner struct ice_softc *sc = (struct ice_softc *)iflib_get_softc(ctx); 185671d10453SEric Joyner struct ice_hw *hw = &sc->hw; 185771d10453SEric Joyner device_t dev = sc->dev; 1858f2635e84SEric Joyner int status; 185971d10453SEric Joyner bool promisc_enable = flags & IFF_PROMISC; 186071d10453SEric Joyner bool multi_enable = flags & IFF_ALLMULTI; 18619c30461dSEric Joyner ice_declare_bitmap(promisc_mask, ICE_PROMISC_MAX); 186271d10453SEric Joyner 186371d10453SEric Joyner /* Do not support configuration when in recovery mode */ 186471d10453SEric Joyner if (ice_test_state(&sc->state, ICE_STATE_RECOVERY_MODE)) 186571d10453SEric Joyner return (ENOSYS); 186671d10453SEric Joyner 18679c30461dSEric Joyner ice_set_default_promisc_mask(promisc_mask); 18689c30461dSEric Joyner 186971d10453SEric Joyner if (multi_enable) 187071d10453SEric Joyner return (EOPNOTSUPP); 187171d10453SEric Joyner 187271d10453SEric Joyner if (promisc_enable) { 187371d10453SEric Joyner status = ice_set_vsi_promisc(hw, sc->pf_vsi.idx, 18749c30461dSEric Joyner promisc_mask, 0); 187571d10453SEric Joyner if (status && status != ICE_ERR_ALREADY_EXISTS) { 187671d10453SEric Joyner device_printf(dev, 187771d10453SEric Joyner "Failed to enable promiscuous mode for PF VSI, err %s aq_err %s\n", 187871d10453SEric Joyner ice_status_str(status), 187971d10453SEric Joyner ice_aq_str(hw->adminq.sq_last_status)); 188071d10453SEric Joyner return (EIO); 188171d10453SEric Joyner } 188271d10453SEric Joyner } else { 188371d10453SEric Joyner status = ice_clear_vsi_promisc(hw, sc->pf_vsi.idx, 18849c30461dSEric Joyner promisc_mask, 0); 188571d10453SEric Joyner if (status) { 188671d10453SEric Joyner device_printf(dev, 188771d10453SEric Joyner "Failed to disable promiscuous mode for PF VSI, err %s aq_err %s\n", 188871d10453SEric Joyner ice_status_str(status), 188971d10453SEric Joyner ice_aq_str(hw->adminq.sq_last_status)); 189071d10453SEric Joyner return (EIO); 189171d10453SEric Joyner } 189271d10453SEric Joyner } 189371d10453SEric Joyner 189471d10453SEric Joyner return (0); 189571d10453SEric Joyner } 189671d10453SEric Joyner 189771d10453SEric Joyner /** 189871d10453SEric Joyner * ice_if_media_change - Change device media 189971d10453SEric Joyner * @ctx: device ctx structure 190071d10453SEric Joyner * 190171d10453SEric Joyner * Called by iflib when a media change is requested. This operation is not 190271d10453SEric Joyner * supported by the hardware, so we just return an error code. 190371d10453SEric Joyner */ 190471d10453SEric Joyner static int 190571d10453SEric Joyner ice_if_media_change(if_ctx_t ctx) 190671d10453SEric Joyner { 190771d10453SEric Joyner struct ice_softc *sc = (struct ice_softc *)iflib_get_softc(ctx); 190871d10453SEric Joyner 190971d10453SEric Joyner device_printf(sc->dev, "Media change is not supported.\n"); 191071d10453SEric Joyner return (ENODEV); 191171d10453SEric Joyner } 191271d10453SEric Joyner 191371d10453SEric Joyner /** 191471d10453SEric Joyner * ice_if_media_status - Report current device media 191571d10453SEric Joyner * @ctx: iflib context structure 191671d10453SEric Joyner * @ifmr: ifmedia request structure to update 191771d10453SEric Joyner * 191871d10453SEric Joyner * Updates the provided ifmr with current device media status, including link 191971d10453SEric Joyner * status and media type. 192071d10453SEric Joyner */ 192171d10453SEric Joyner static void 192271d10453SEric Joyner ice_if_media_status(if_ctx_t ctx, struct ifmediareq *ifmr) 192371d10453SEric Joyner { 192471d10453SEric Joyner struct ice_softc *sc = (struct ice_softc *)iflib_get_softc(ctx); 192571d10453SEric Joyner struct ice_link_status *li = &sc->hw.port_info->phy.link_info; 192671d10453SEric Joyner 192771d10453SEric Joyner ifmr->ifm_status = IFM_AVALID; 192871d10453SEric Joyner ifmr->ifm_active = IFM_ETHER; 192971d10453SEric Joyner 193071d10453SEric Joyner /* Never report link up or media types when in recovery mode */ 193171d10453SEric Joyner if (ice_test_state(&sc->state, ICE_STATE_RECOVERY_MODE)) 193271d10453SEric Joyner return; 193371d10453SEric Joyner 193471d10453SEric Joyner if (!sc->link_up) 193571d10453SEric Joyner return; 193671d10453SEric Joyner 193771d10453SEric Joyner ifmr->ifm_status |= IFM_ACTIVE; 193871d10453SEric Joyner ifmr->ifm_active |= IFM_FDX; 193971d10453SEric Joyner 194071d10453SEric Joyner if (li->phy_type_low) 194171d10453SEric Joyner ifmr->ifm_active |= ice_get_phy_type_low(li->phy_type_low); 194271d10453SEric Joyner else if (li->phy_type_high) 194371d10453SEric Joyner ifmr->ifm_active |= ice_get_phy_type_high(li->phy_type_high); 194471d10453SEric Joyner else 194571d10453SEric Joyner ifmr->ifm_active |= IFM_UNKNOWN; 194671d10453SEric Joyner 194771d10453SEric Joyner /* Report flow control status as well */ 194871d10453SEric Joyner if (li->an_info & ICE_AQ_LINK_PAUSE_TX) 194971d10453SEric Joyner ifmr->ifm_active |= IFM_ETH_TXPAUSE; 195071d10453SEric Joyner if (li->an_info & ICE_AQ_LINK_PAUSE_RX) 195171d10453SEric Joyner ifmr->ifm_active |= IFM_ETH_RXPAUSE; 195271d10453SEric Joyner } 195371d10453SEric Joyner 195471d10453SEric Joyner /** 195571d10453SEric Joyner * ice_init_tx_tracking - Initialize Tx queue software tracking values 195671d10453SEric Joyner * @vsi: the VSI to initialize 195771d10453SEric Joyner * 195871d10453SEric Joyner * Initialize Tx queue software tracking values, including the Report Status 195971d10453SEric Joyner * queue, and related software tracking values. 196071d10453SEric Joyner */ 196171d10453SEric Joyner static void 196271d10453SEric Joyner ice_init_tx_tracking(struct ice_vsi *vsi) 196371d10453SEric Joyner { 196471d10453SEric Joyner struct ice_tx_queue *txq; 196571d10453SEric Joyner size_t j; 196671d10453SEric Joyner int i; 196771d10453SEric Joyner 196871d10453SEric Joyner for (i = 0, txq = vsi->tx_queues; i < vsi->num_tx_queues; i++, txq++) { 196971d10453SEric Joyner 197071d10453SEric Joyner txq->tx_rs_cidx = txq->tx_rs_pidx = 0; 197171d10453SEric Joyner 197271d10453SEric Joyner /* Initialize the last processed descriptor to be the end of 197371d10453SEric Joyner * the ring, rather than the start, so that we avoid an 197471d10453SEric Joyner * off-by-one error in ice_ift_txd_credits_update for the 197571d10453SEric Joyner * first packet. 197671d10453SEric Joyner */ 197771d10453SEric Joyner txq->tx_cidx_processed = txq->desc_count - 1; 197871d10453SEric Joyner 197971d10453SEric Joyner for (j = 0; j < txq->desc_count; j++) 198071d10453SEric Joyner txq->tx_rsq[j] = QIDX_INVALID; 198171d10453SEric Joyner } 198271d10453SEric Joyner } 198371d10453SEric Joyner 198471d10453SEric Joyner /** 198571d10453SEric Joyner * ice_update_rx_mbuf_sz - Update the Rx buffer size for all queues 198671d10453SEric Joyner * @sc: the device softc 198771d10453SEric Joyner * 198871d10453SEric Joyner * Called to update the Rx queue mbuf_sz parameter for configuring the receive 198971d10453SEric Joyner * buffer sizes when programming hardware. 199071d10453SEric Joyner */ 199171d10453SEric Joyner static void 199271d10453SEric Joyner ice_update_rx_mbuf_sz(struct ice_softc *sc) 199371d10453SEric Joyner { 199471d10453SEric Joyner uint32_t mbuf_sz = iflib_get_rx_mbuf_sz(sc->ctx); 199571d10453SEric Joyner struct ice_vsi *vsi = &sc->pf_vsi; 199671d10453SEric Joyner 199771d10453SEric Joyner MPASS(mbuf_sz <= UINT16_MAX); 199871d10453SEric Joyner vsi->mbuf_sz = mbuf_sz; 199971d10453SEric Joyner } 200071d10453SEric Joyner 200171d10453SEric Joyner /** 200271d10453SEric Joyner * ice_if_init - Initialize the device 200371d10453SEric Joyner * @ctx: iflib ctx structure 200471d10453SEric Joyner * 200571d10453SEric Joyner * Called by iflib to bring the device up, i.e. ifconfig ice0 up. Initializes 200671d10453SEric Joyner * device filters and prepares the Tx and Rx engines. 200771d10453SEric Joyner * 200871d10453SEric Joyner * @pre assumes the caller holds the iflib CTX lock 200971d10453SEric Joyner */ 201071d10453SEric Joyner static void 201171d10453SEric Joyner ice_if_init(if_ctx_t ctx) 201271d10453SEric Joyner { 20139e54973fSEric Joyner struct ice_mirr_if *mif = (struct ice_mirr_if *)iflib_get_softc(ctx); 201471d10453SEric Joyner struct ice_softc *sc = (struct ice_softc *)iflib_get_softc(ctx); 201571d10453SEric Joyner device_t dev = sc->dev; 201671d10453SEric Joyner int err; 201771d10453SEric Joyner 201871d10453SEric Joyner ASSERT_CTX_LOCKED(sc); 201971d10453SEric Joyner 20207d7af7f8SEric Joyner /* 20217d7af7f8SEric Joyner * We've seen an issue with 11.3/12.1 where sideband routines are 20227d7af7f8SEric Joyner * called after detach is called. This would call routines after 20237d7af7f8SEric Joyner * if_stop, causing issues with the teardown process. This has 20247d7af7f8SEric Joyner * seemingly been fixed in STABLE snapshots, but it seems like a 20257d7af7f8SEric Joyner * good idea to have this guard here regardless. 20267d7af7f8SEric Joyner */ 20277d7af7f8SEric Joyner if (ice_driver_is_detaching(sc)) 20287d7af7f8SEric Joyner return; 20297d7af7f8SEric Joyner 203071d10453SEric Joyner if (ice_test_state(&sc->state, ICE_STATE_RECOVERY_MODE)) 203171d10453SEric Joyner return; 203271d10453SEric Joyner 203371d10453SEric Joyner if (ice_test_state(&sc->state, ICE_STATE_RESET_FAILED)) { 203471d10453SEric Joyner device_printf(sc->dev, "request to start interface cannot be completed as the device failed to reset\n"); 203571d10453SEric Joyner return; 203671d10453SEric Joyner } 203771d10453SEric Joyner 203871d10453SEric Joyner if (ice_test_state(&sc->state, ICE_STATE_PREPARED_FOR_RESET)) { 203971d10453SEric Joyner device_printf(sc->dev, "request to start interface while device is prepared for impending reset\n"); 204071d10453SEric Joyner return; 204171d10453SEric Joyner } 204271d10453SEric Joyner 204371d10453SEric Joyner ice_update_rx_mbuf_sz(sc); 204471d10453SEric Joyner 204571d10453SEric Joyner /* Update the MAC address... User might use a LAA */ 204671d10453SEric Joyner err = ice_update_laa_mac(sc); 204771d10453SEric Joyner if (err) { 204871d10453SEric Joyner device_printf(dev, 204971d10453SEric Joyner "LAA address change failed, err %s\n", 205071d10453SEric Joyner ice_err_str(err)); 205171d10453SEric Joyner return; 205271d10453SEric Joyner } 205371d10453SEric Joyner 205471d10453SEric Joyner /* Initialize software Tx tracking values */ 205571d10453SEric Joyner ice_init_tx_tracking(&sc->pf_vsi); 205671d10453SEric Joyner 205771d10453SEric Joyner err = ice_cfg_vsi_for_tx(&sc->pf_vsi); 205871d10453SEric Joyner if (err) { 205971d10453SEric Joyner device_printf(dev, 206071d10453SEric Joyner "Unable to configure the main VSI for Tx: %s\n", 206171d10453SEric Joyner ice_err_str(err)); 206271d10453SEric Joyner return; 206371d10453SEric Joyner } 206471d10453SEric Joyner 206571d10453SEric Joyner err = ice_cfg_vsi_for_rx(&sc->pf_vsi); 206671d10453SEric Joyner if (err) { 206771d10453SEric Joyner device_printf(dev, 206871d10453SEric Joyner "Unable to configure the main VSI for Rx: %s\n", 206971d10453SEric Joyner ice_err_str(err)); 207071d10453SEric Joyner goto err_cleanup_tx; 207171d10453SEric Joyner } 207271d10453SEric Joyner 20739dc2f6e2SEric Joyner err = ice_control_all_rx_queues(&sc->pf_vsi, true); 207471d10453SEric Joyner if (err) { 207571d10453SEric Joyner device_printf(dev, 207671d10453SEric Joyner "Unable to enable Rx rings for transmit: %s\n", 207771d10453SEric Joyner ice_err_str(err)); 207871d10453SEric Joyner goto err_cleanup_tx; 207971d10453SEric Joyner } 208071d10453SEric Joyner 208171d10453SEric Joyner err = ice_cfg_pf_default_mac_filters(sc); 208271d10453SEric Joyner if (err) { 208371d10453SEric Joyner device_printf(dev, 208471d10453SEric Joyner "Unable to configure default MAC filters: %s\n", 208571d10453SEric Joyner ice_err_str(err)); 208671d10453SEric Joyner goto err_stop_rx; 208771d10453SEric Joyner } 208871d10453SEric Joyner 208971d10453SEric Joyner /* We use software interrupts for Tx, so we only program the hardware 209071d10453SEric Joyner * interrupts for Rx. 209171d10453SEric Joyner */ 20929dc2f6e2SEric Joyner ice_configure_all_rxq_interrupts(&sc->pf_vsi); 209371d10453SEric Joyner ice_configure_rx_itr(&sc->pf_vsi); 209471d10453SEric Joyner 209571d10453SEric Joyner /* Configure promiscuous mode */ 209671d10453SEric Joyner ice_if_promisc_set(ctx, if_getflags(sc->ifp)); 209771d10453SEric Joyner 20989c30461dSEric Joyner if (!ice_testandclear_state(&sc->state, ICE_STATE_FIRST_INIT_LINK)) 20999c30461dSEric Joyner if (!sc->link_up && ((if_getflags(sc->ifp) & IFF_UP) || 21009c30461dSEric Joyner ice_test_state(&sc->state, ICE_STATE_LINK_ACTIVE_ON_DOWN))) 21019c30461dSEric Joyner ice_set_link(sc, true); 21029c30461dSEric Joyner 21038a13362dSEric Joyner ice_rdma_pf_init(sc); 21048a13362dSEric Joyner 210571d10453SEric Joyner ice_set_state(&sc->state, ICE_STATE_DRIVER_INITIALIZED); 21069e54973fSEric Joyner 21079e54973fSEric Joyner if (sc->mirr_if && ice_testandclear_state(&mif->state, ICE_STATE_SUBIF_NEEDS_REINIT)) { 21089e54973fSEric Joyner ice_clear_state(&mif->state, ICE_STATE_DRIVER_INITIALIZED); 21099e54973fSEric Joyner iflib_request_reset(sc->mirr_if->subctx); 21109e54973fSEric Joyner iflib_admin_intr_deferred(sc->mirr_if->subctx); 21119e54973fSEric Joyner } 21129e54973fSEric Joyner 211371d10453SEric Joyner return; 211471d10453SEric Joyner 211571d10453SEric Joyner err_stop_rx: 21169dc2f6e2SEric Joyner ice_control_all_rx_queues(&sc->pf_vsi, false); 211771d10453SEric Joyner err_cleanup_tx: 211871d10453SEric Joyner ice_vsi_disable_tx(&sc->pf_vsi); 211971d10453SEric Joyner } 212071d10453SEric Joyner 212171d10453SEric Joyner /** 212271d10453SEric Joyner * ice_poll_for_media_avail - Re-enable link if media is detected 212371d10453SEric Joyner * @sc: device private structure 212471d10453SEric Joyner * 212571d10453SEric Joyner * Intended to be called from the driver's timer function, this function 212671d10453SEric Joyner * sends the Get Link Status AQ command and re-enables HW link if the 212771d10453SEric Joyner * command says that media is available. 212871d10453SEric Joyner * 212971d10453SEric Joyner * If the driver doesn't have the "NO_MEDIA" state set, then this does nothing, 213071d10453SEric Joyner * since media removal events are supposed to be sent to the driver through 213171d10453SEric Joyner * a link status event. 213271d10453SEric Joyner */ 213371d10453SEric Joyner static void 213471d10453SEric Joyner ice_poll_for_media_avail(struct ice_softc *sc) 213571d10453SEric Joyner { 213671d10453SEric Joyner struct ice_hw *hw = &sc->hw; 213771d10453SEric Joyner struct ice_port_info *pi = hw->port_info; 213871d10453SEric Joyner 2139f377a0c7SEric Joyner /* E830 only: There's no interrupt for when the PHY FW has finished loading, 2140f377a0c7SEric Joyner * so poll for the status in the media task here if it's previously 2141f377a0c7SEric Joyner * been detected that it's still loading. 2142f377a0c7SEric Joyner */ 2143f377a0c7SEric Joyner if (ice_is_e830(hw) && 2144f377a0c7SEric Joyner ice_test_state(&sc->state, ICE_STATE_PHY_FW_INIT_PENDING)) { 2145f377a0c7SEric Joyner if (rd32(hw, GL_MNG_FWSM) & GL_MNG_FWSM_FW_LOADING_M) 2146f377a0c7SEric Joyner ice_clear_state(&sc->state, ICE_STATE_PHY_FW_INIT_PENDING); 2147f377a0c7SEric Joyner else 2148f377a0c7SEric Joyner return; 2149f377a0c7SEric Joyner } 2150f377a0c7SEric Joyner 215171d10453SEric Joyner if (ice_test_state(&sc->state, ICE_STATE_NO_MEDIA)) { 215271d10453SEric Joyner pi->phy.get_link_info = true; 215371d10453SEric Joyner ice_get_link_status(pi, &sc->link_up); 215471d10453SEric Joyner 215571d10453SEric Joyner if (pi->phy.link_info.link_info & ICE_AQ_MEDIA_AVAILABLE) { 2156f2635e84SEric Joyner int status; 215771d10453SEric Joyner 215871d10453SEric Joyner /* Re-enable link and re-apply user link settings */ 21599c30461dSEric Joyner if (ice_test_state(&sc->state, ICE_STATE_LINK_ACTIVE_ON_DOWN) || 21609c30461dSEric Joyner (if_getflags(sc->ifp) & IFF_UP)) { 21619cf1841cSEric Joyner ice_apply_saved_phy_cfg(sc, ICE_APPLY_LS_FEC_FC); 216271d10453SEric Joyner 216371d10453SEric Joyner /* Update the OS about changes in media capability */ 216471d10453SEric Joyner status = ice_add_media_types(sc, sc->media); 216571d10453SEric Joyner if (status) 21669c30461dSEric Joyner device_printf(sc->dev, 21679c30461dSEric Joyner "Error adding device media types: %s aq_err %s\n", 216871d10453SEric Joyner ice_status_str(status), 216971d10453SEric Joyner ice_aq_str(hw->adminq.sq_last_status)); 21709c30461dSEric Joyner } 217171d10453SEric Joyner 217271d10453SEric Joyner ice_clear_state(&sc->state, ICE_STATE_NO_MEDIA); 217371d10453SEric Joyner } 217471d10453SEric Joyner } 217571d10453SEric Joyner } 217671d10453SEric Joyner 217771d10453SEric Joyner /** 217871d10453SEric Joyner * ice_if_timer - called by iflib periodically 217971d10453SEric Joyner * @ctx: iflib ctx structure 218071d10453SEric Joyner * @qid: the queue this timer was called for 218171d10453SEric Joyner * 218271d10453SEric Joyner * This callback is triggered by iflib periodically. We use it to update the 218371d10453SEric Joyner * hw statistics. 218471d10453SEric Joyner * 218571d10453SEric Joyner * @remark this function is not protected by the iflib CTX lock. 218671d10453SEric Joyner */ 218771d10453SEric Joyner static void 218871d10453SEric Joyner ice_if_timer(if_ctx_t ctx, uint16_t qid) 218971d10453SEric Joyner { 219071d10453SEric Joyner struct ice_softc *sc = (struct ice_softc *)iflib_get_softc(ctx); 219171d10453SEric Joyner uint64_t prev_link_xoff_rx = sc->stats.cur.link_xoff_rx; 219271d10453SEric Joyner 219371d10453SEric Joyner if (qid != 0) 219471d10453SEric Joyner return; 219571d10453SEric Joyner 219671d10453SEric Joyner /* Do not attempt to update stats when in recovery mode */ 219771d10453SEric Joyner if (ice_test_state(&sc->state, ICE_STATE_RECOVERY_MODE)) 219871d10453SEric Joyner return; 219971d10453SEric Joyner 220071d10453SEric Joyner /* Update device statistics */ 220171d10453SEric Joyner ice_update_pf_stats(sc); 220271d10453SEric Joyner 220371d10453SEric Joyner /* 220471d10453SEric Joyner * For proper watchdog management, the iflib stack needs to know if 220571d10453SEric Joyner * we've been paused during the last interval. Check if the 220671d10453SEric Joyner * link_xoff_rx stat changed, and set the isc_pause_frames, if so. 220771d10453SEric Joyner */ 220871d10453SEric Joyner if (sc->stats.cur.link_xoff_rx != prev_link_xoff_rx) 220971d10453SEric Joyner sc->scctx->isc_pause_frames = 1; 221071d10453SEric Joyner 221171d10453SEric Joyner /* Update the primary VSI stats */ 221271d10453SEric Joyner ice_update_vsi_hw_stats(&sc->pf_vsi); 22139e54973fSEric Joyner 22149e54973fSEric Joyner /* Update mirror VSI stats */ 22159e54973fSEric Joyner if (sc->mirr_if && sc->mirr_if->if_attached) 22169e54973fSEric Joyner ice_update_vsi_hw_stats(sc->mirr_if->vsi); 221771d10453SEric Joyner } 221871d10453SEric Joyner 221971d10453SEric Joyner /** 222071d10453SEric Joyner * ice_admin_timer - called periodically to trigger the admin task 222171d10453SEric Joyner * @arg: callout(9) argument pointing to the device private softc structure 222271d10453SEric Joyner * 222371d10453SEric Joyner * Timer function used as part of a callout(9) timer that will periodically 222471d10453SEric Joyner * trigger the admin task, even when the interface is down. 222571d10453SEric Joyner * 222671d10453SEric Joyner * @remark this function is not called by iflib and is not protected by the 222771d10453SEric Joyner * iflib CTX lock. 222871d10453SEric Joyner * 222971d10453SEric Joyner * @remark because this is a callout function, it cannot sleep and should not 223071d10453SEric Joyner * attempt taking the iflib CTX lock. 223171d10453SEric Joyner */ 223271d10453SEric Joyner static void 223371d10453SEric Joyner ice_admin_timer(void *arg) 223471d10453SEric Joyner { 223571d10453SEric Joyner struct ice_softc *sc = (struct ice_softc *)arg; 223671d10453SEric Joyner 22379cf1841cSEric Joyner /* 22389cf1841cSEric Joyner * There is a point where callout routines are no longer 22399cf1841cSEric Joyner * cancelable. So there exists a window of time where the 22409cf1841cSEric Joyner * driver enters detach() and tries to cancel the callout, but the 22419cf1841cSEric Joyner * callout routine has passed the cancellation point. The detach() 22429cf1841cSEric Joyner * routine is unaware of this and tries to free resources that the 22439cf1841cSEric Joyner * callout routine needs. So we check for the detach state flag to 22449cf1841cSEric Joyner * at least shrink the window of opportunity. 22459cf1841cSEric Joyner */ 22469cf1841cSEric Joyner if (ice_driver_is_detaching(sc)) 22479cf1841cSEric Joyner return; 22489cf1841cSEric Joyner 224971d10453SEric Joyner /* Fire off the admin task */ 225071d10453SEric Joyner iflib_admin_intr_deferred(sc->ctx); 225171d10453SEric Joyner 225271d10453SEric Joyner /* Reschedule the admin timer */ 225371d10453SEric Joyner callout_schedule(&sc->admin_timer, hz/2); 225471d10453SEric Joyner } 225571d10453SEric Joyner 225671d10453SEric Joyner /** 225771d10453SEric Joyner * ice_transition_recovery_mode - Transition to recovery mode 225871d10453SEric Joyner * @sc: the device private softc 225971d10453SEric Joyner * 226071d10453SEric Joyner * Called when the driver detects that the firmware has entered recovery mode 226171d10453SEric Joyner * at run time. 226271d10453SEric Joyner */ 226371d10453SEric Joyner static void 226471d10453SEric Joyner ice_transition_recovery_mode(struct ice_softc *sc) 226571d10453SEric Joyner { 226671d10453SEric Joyner struct ice_vsi *vsi = &sc->pf_vsi; 226771d10453SEric Joyner int i; 226871d10453SEric Joyner 226971d10453SEric Joyner device_printf(sc->dev, "Firmware recovery mode detected. Limiting functionality. Refer to Intel(R) Ethernet Adapters and Devices User Guide for details on firmware recovery mode.\n"); 227071d10453SEric Joyner 227171d10453SEric Joyner /* Tell the stack that the link has gone down */ 227271d10453SEric Joyner iflib_link_state_change(sc->ctx, LINK_STATE_DOWN, 0); 227371d10453SEric Joyner 227471d10453SEric Joyner /* Request that the device be re-initialized */ 227571d10453SEric Joyner ice_request_stack_reinit(sc); 227671d10453SEric Joyner 22778a13362dSEric Joyner ice_rdma_pf_detach(sc); 22788a13362dSEric Joyner ice_clear_bit(ICE_FEATURE_RDMA, sc->feat_cap); 22798a13362dSEric Joyner 228071d10453SEric Joyner ice_clear_bit(ICE_FEATURE_SRIOV, sc->feat_en); 228171d10453SEric Joyner ice_clear_bit(ICE_FEATURE_SRIOV, sc->feat_cap); 228271d10453SEric Joyner 228371d10453SEric Joyner ice_vsi_del_txqs_ctx(vsi); 228471d10453SEric Joyner ice_vsi_del_rxqs_ctx(vsi); 228571d10453SEric Joyner 228671d10453SEric Joyner for (i = 0; i < sc->num_available_vsi; i++) { 228771d10453SEric Joyner if (sc->all_vsi[i]) 228871d10453SEric Joyner ice_release_vsi(sc->all_vsi[i]); 228971d10453SEric Joyner } 229071d10453SEric Joyner sc->num_available_vsi = 0; 229171d10453SEric Joyner 229271d10453SEric Joyner if (sc->all_vsi) { 229371d10453SEric Joyner free(sc->all_vsi, M_ICE); 229471d10453SEric Joyner sc->all_vsi = NULL; 229571d10453SEric Joyner } 229671d10453SEric Joyner 229771d10453SEric Joyner /* Destroy the interrupt manager */ 22989e54973fSEric Joyner ice_resmgr_destroy(&sc->dev_imgr); 229971d10453SEric Joyner /* Destroy the queue managers */ 230071d10453SEric Joyner ice_resmgr_destroy(&sc->tx_qmgr); 230171d10453SEric Joyner ice_resmgr_destroy(&sc->rx_qmgr); 230271d10453SEric Joyner 230371d10453SEric Joyner ice_deinit_hw(&sc->hw); 230471d10453SEric Joyner } 230571d10453SEric Joyner 230671d10453SEric Joyner /** 230771d10453SEric Joyner * ice_transition_safe_mode - Transition to safe mode 230871d10453SEric Joyner * @sc: the device private softc 230971d10453SEric Joyner * 231071d10453SEric Joyner * Called when the driver attempts to reload the DDP package during a device 231171d10453SEric Joyner * reset, and the new download fails. If so, we must transition to safe mode 231271d10453SEric Joyner * at run time. 231371d10453SEric Joyner * 231471d10453SEric Joyner * @remark although safe mode normally allocates only a single queue, we can't 231571d10453SEric Joyner * change the number of queues dynamically when using iflib. Due to this, we 231671d10453SEric Joyner * do not attempt to reduce the number of queues. 231771d10453SEric Joyner */ 231871d10453SEric Joyner static void 231971d10453SEric Joyner ice_transition_safe_mode(struct ice_softc *sc) 232071d10453SEric Joyner { 232171d10453SEric Joyner /* Indicate that we are in Safe mode */ 232271d10453SEric Joyner ice_set_bit(ICE_FEATURE_SAFE_MODE, sc->feat_cap); 232371d10453SEric Joyner ice_set_bit(ICE_FEATURE_SAFE_MODE, sc->feat_en); 232471d10453SEric Joyner 23258a13362dSEric Joyner ice_rdma_pf_detach(sc); 23268a13362dSEric Joyner ice_clear_bit(ICE_FEATURE_RDMA, sc->feat_cap); 23278a13362dSEric Joyner 232871d10453SEric Joyner ice_clear_bit(ICE_FEATURE_SRIOV, sc->feat_en); 232971d10453SEric Joyner ice_clear_bit(ICE_FEATURE_SRIOV, sc->feat_cap); 233071d10453SEric Joyner 233171d10453SEric Joyner ice_clear_bit(ICE_FEATURE_RSS, sc->feat_cap); 233271d10453SEric Joyner ice_clear_bit(ICE_FEATURE_RSS, sc->feat_en); 233371d10453SEric Joyner } 233471d10453SEric Joyner 233571d10453SEric Joyner /** 233671d10453SEric Joyner * ice_if_update_admin_status - update admin status 233771d10453SEric Joyner * @ctx: iflib ctx structure 233871d10453SEric Joyner * 233971d10453SEric Joyner * Called by iflib to update the admin status. For our purposes, this means 234071d10453SEric Joyner * check the adminq, and update the link status. It's ultimately triggered by 234171d10453SEric Joyner * our admin interrupt, or by the ice_if_timer periodically. 234271d10453SEric Joyner * 234371d10453SEric Joyner * @pre assumes the caller holds the iflib CTX lock 234471d10453SEric Joyner */ 234571d10453SEric Joyner static void 234671d10453SEric Joyner ice_if_update_admin_status(if_ctx_t ctx) 234771d10453SEric Joyner { 234871d10453SEric Joyner struct ice_softc *sc = (struct ice_softc *)iflib_get_softc(ctx); 234971d10453SEric Joyner enum ice_fw_modes fw_mode; 235071d10453SEric Joyner bool reschedule = false; 235171d10453SEric Joyner u16 pending = 0; 235271d10453SEric Joyner 235371d10453SEric Joyner ASSERT_CTX_LOCKED(sc); 235471d10453SEric Joyner 235571d10453SEric Joyner /* Check if the firmware entered recovery mode at run time */ 235671d10453SEric Joyner fw_mode = ice_get_fw_mode(&sc->hw); 235771d10453SEric Joyner if (fw_mode == ICE_FW_MODE_REC) { 235871d10453SEric Joyner if (!ice_testandset_state(&sc->state, ICE_STATE_RECOVERY_MODE)) { 235971d10453SEric Joyner /* If we just entered recovery mode, log a warning to 236071d10453SEric Joyner * the system administrator and deinit driver state 236171d10453SEric Joyner * that is no longer functional. 236271d10453SEric Joyner */ 236371d10453SEric Joyner ice_transition_recovery_mode(sc); 236471d10453SEric Joyner } 236571d10453SEric Joyner } else if (fw_mode == ICE_FW_MODE_ROLLBACK) { 236671d10453SEric Joyner if (!ice_testandset_state(&sc->state, ICE_STATE_ROLLBACK_MODE)) { 236771d10453SEric Joyner /* Rollback mode isn't fatal, but we don't want to 236871d10453SEric Joyner * repeatedly post a message about it. 236971d10453SEric Joyner */ 237071d10453SEric Joyner ice_print_rollback_msg(&sc->hw); 237171d10453SEric Joyner } 237271d10453SEric Joyner } 237371d10453SEric Joyner 237471d10453SEric Joyner /* Handle global reset events */ 237571d10453SEric Joyner ice_handle_reset_event(sc); 237671d10453SEric Joyner 237771d10453SEric Joyner /* Handle PF reset requests */ 237871d10453SEric Joyner ice_handle_pf_reset_request(sc); 237971d10453SEric Joyner 238071d10453SEric Joyner /* Handle MDD events */ 238171d10453SEric Joyner ice_handle_mdd_event(sc); 238271d10453SEric Joyner 238371d10453SEric Joyner if (ice_test_state(&sc->state, ICE_STATE_RESET_FAILED) || 238471d10453SEric Joyner ice_test_state(&sc->state, ICE_STATE_PREPARED_FOR_RESET) || 238571d10453SEric Joyner ice_test_state(&sc->state, ICE_STATE_RECOVERY_MODE)) { 238671d10453SEric Joyner /* 238771d10453SEric Joyner * If we know the control queues are disabled, skip processing 238871d10453SEric Joyner * the control queues entirely. 238971d10453SEric Joyner */ 239071d10453SEric Joyner ; 239171d10453SEric Joyner } else if (ice_testandclear_state(&sc->state, ICE_STATE_CONTROLQ_EVENT_PENDING)) { 239271d10453SEric Joyner ice_process_ctrlq(sc, ICE_CTL_Q_ADMIN, &pending); 239371d10453SEric Joyner if (pending > 0) 239471d10453SEric Joyner reschedule = true; 239571d10453SEric Joyner 2396f2635e84SEric Joyner if (ice_is_generic_mac(&sc->hw)) { 2397f2635e84SEric Joyner ice_process_ctrlq(sc, ICE_CTL_Q_SB, &pending); 2398f2635e84SEric Joyner if (pending > 0) 2399f2635e84SEric Joyner reschedule = true; 2400f2635e84SEric Joyner } 2401f2635e84SEric Joyner 240271d10453SEric Joyner ice_process_ctrlq(sc, ICE_CTL_Q_MAILBOX, &pending); 240371d10453SEric Joyner if (pending > 0) 240471d10453SEric Joyner reschedule = true; 240571d10453SEric Joyner } 240671d10453SEric Joyner 240771d10453SEric Joyner /* Poll for link up */ 240871d10453SEric Joyner ice_poll_for_media_avail(sc); 240971d10453SEric Joyner 241071d10453SEric Joyner /* Check and update link status */ 241171d10453SEric Joyner ice_update_link_status(sc, false); 241271d10453SEric Joyner 241371d10453SEric Joyner /* 241471d10453SEric Joyner * If there are still messages to process, we need to reschedule 241571d10453SEric Joyner * ourselves. Otherwise, we can just re-enable the interrupt. We'll be 241671d10453SEric Joyner * woken up at the next interrupt or timer event. 241771d10453SEric Joyner */ 241871d10453SEric Joyner if (reschedule) { 241971d10453SEric Joyner ice_set_state(&sc->state, ICE_STATE_CONTROLQ_EVENT_PENDING); 242071d10453SEric Joyner iflib_admin_intr_deferred(ctx); 242171d10453SEric Joyner } else { 242271d10453SEric Joyner ice_enable_intr(&sc->hw, sc->irqvs[0].me); 242371d10453SEric Joyner } 242471d10453SEric Joyner } 242571d10453SEric Joyner 242671d10453SEric Joyner /** 242771d10453SEric Joyner * ice_prepare_for_reset - Prepare device for an impending reset 242871d10453SEric Joyner * @sc: The device private softc 242971d10453SEric Joyner * 243071d10453SEric Joyner * Prepare the driver for an impending reset, shutting down VSIs, clearing the 243171d10453SEric Joyner * scheduler setup, and shutting down controlqs. Uses the 243271d10453SEric Joyner * ICE_STATE_PREPARED_FOR_RESET to indicate whether we've already prepared the 243371d10453SEric Joyner * driver for reset or not. 243471d10453SEric Joyner */ 243571d10453SEric Joyner static void 243671d10453SEric Joyner ice_prepare_for_reset(struct ice_softc *sc) 243771d10453SEric Joyner { 243871d10453SEric Joyner struct ice_hw *hw = &sc->hw; 243971d10453SEric Joyner 244071d10453SEric Joyner /* If we're already prepared, there's nothing to do */ 244171d10453SEric Joyner if (ice_testandset_state(&sc->state, ICE_STATE_PREPARED_FOR_RESET)) 244271d10453SEric Joyner return; 244371d10453SEric Joyner 2444402810d3SJustin Hibbits log(LOG_INFO, "%s: preparing to reset device logic\n", if_name(sc->ifp)); 244571d10453SEric Joyner 244671d10453SEric Joyner /* In recovery mode, hardware is not initialized */ 244771d10453SEric Joyner if (ice_test_state(&sc->state, ICE_STATE_RECOVERY_MODE)) 244871d10453SEric Joyner return; 244971d10453SEric Joyner 245001fbb869SBartosz Sobczak /* inform the RDMA client */ 245101fbb869SBartosz Sobczak ice_rdma_notify_reset(sc); 24528a13362dSEric Joyner /* stop the RDMA client */ 24538a13362dSEric Joyner ice_rdma_pf_stop(sc); 24548a13362dSEric Joyner 245571d10453SEric Joyner /* Release the main PF VSI queue mappings */ 245671d10453SEric Joyner ice_resmgr_release_map(&sc->tx_qmgr, sc->pf_vsi.tx_qmap, 245771d10453SEric Joyner sc->pf_vsi.num_tx_queues); 245871d10453SEric Joyner ice_resmgr_release_map(&sc->rx_qmgr, sc->pf_vsi.rx_qmap, 245971d10453SEric Joyner sc->pf_vsi.num_rx_queues); 24609e54973fSEric Joyner if (sc->mirr_if) { 24619e54973fSEric Joyner ice_resmgr_release_map(&sc->tx_qmgr, sc->mirr_if->vsi->tx_qmap, 24629e54973fSEric Joyner sc->mirr_if->num_irq_vectors); 24639e54973fSEric Joyner ice_resmgr_release_map(&sc->rx_qmgr, sc->mirr_if->vsi->rx_qmap, 24649e54973fSEric Joyner sc->mirr_if->num_irq_vectors); 24659e54973fSEric Joyner } 246671d10453SEric Joyner 246771d10453SEric Joyner ice_clear_hw_tbls(hw); 246871d10453SEric Joyner 246971d10453SEric Joyner if (hw->port_info) 24709c30461dSEric Joyner ice_sched_cleanup_all(hw); 247171d10453SEric Joyner 24728923de59SPiotr Kubaj ice_shutdown_all_ctrlq(hw, false); 247371d10453SEric Joyner } 247471d10453SEric Joyner 247571d10453SEric Joyner /** 247671d10453SEric Joyner * ice_rebuild_pf_vsi_qmap - Rebuild the main PF VSI queue mapping 247771d10453SEric Joyner * @sc: the device softc pointer 247871d10453SEric Joyner * 247971d10453SEric Joyner * Loops over the Tx and Rx queues for the main PF VSI and reassigns the queue 248071d10453SEric Joyner * mapping after a reset occurred. 248171d10453SEric Joyner */ 248271d10453SEric Joyner static int 248371d10453SEric Joyner ice_rebuild_pf_vsi_qmap(struct ice_softc *sc) 248471d10453SEric Joyner { 248571d10453SEric Joyner struct ice_vsi *vsi = &sc->pf_vsi; 248671d10453SEric Joyner struct ice_tx_queue *txq; 248771d10453SEric Joyner struct ice_rx_queue *rxq; 248871d10453SEric Joyner int err, i; 248971d10453SEric Joyner 249071d10453SEric Joyner /* Re-assign Tx queues from PF space to the main VSI */ 249171d10453SEric Joyner err = ice_resmgr_assign_contiguous(&sc->tx_qmgr, vsi->tx_qmap, 249271d10453SEric Joyner vsi->num_tx_queues); 249371d10453SEric Joyner if (err) { 249471d10453SEric Joyner device_printf(sc->dev, "Unable to re-assign PF Tx queues: %s\n", 249571d10453SEric Joyner ice_err_str(err)); 249671d10453SEric Joyner return (err); 249771d10453SEric Joyner } 249871d10453SEric Joyner 249971d10453SEric Joyner /* Re-assign Rx queues from PF space to this VSI */ 250071d10453SEric Joyner err = ice_resmgr_assign_contiguous(&sc->rx_qmgr, vsi->rx_qmap, 250171d10453SEric Joyner vsi->num_rx_queues); 250271d10453SEric Joyner if (err) { 250371d10453SEric Joyner device_printf(sc->dev, "Unable to re-assign PF Rx queues: %s\n", 250471d10453SEric Joyner ice_err_str(err)); 250571d10453SEric Joyner goto err_release_tx_queues; 250671d10453SEric Joyner } 250771d10453SEric Joyner 250871d10453SEric Joyner vsi->qmap_type = ICE_RESMGR_ALLOC_CONTIGUOUS; 250971d10453SEric Joyner 251071d10453SEric Joyner /* Re-assign Tx queue tail pointers */ 251171d10453SEric Joyner for (i = 0, txq = vsi->tx_queues; i < vsi->num_tx_queues; i++, txq++) 251271d10453SEric Joyner txq->tail = QTX_COMM_DBELL(vsi->tx_qmap[i]); 251371d10453SEric Joyner 251471d10453SEric Joyner /* Re-assign Rx queue tail pointers */ 251571d10453SEric Joyner for (i = 0, rxq = vsi->rx_queues; i < vsi->num_rx_queues; i++, rxq++) 251671d10453SEric Joyner rxq->tail = QRX_TAIL(vsi->rx_qmap[i]); 251771d10453SEric Joyner 251871d10453SEric Joyner return (0); 251971d10453SEric Joyner 252071d10453SEric Joyner err_release_tx_queues: 252171d10453SEric Joyner ice_resmgr_release_map(&sc->tx_qmgr, sc->pf_vsi.tx_qmap, 252271d10453SEric Joyner sc->pf_vsi.num_tx_queues); 252371d10453SEric Joyner 252471d10453SEric Joyner return (err); 252571d10453SEric Joyner } 252671d10453SEric Joyner 252771d10453SEric Joyner /* determine if the iflib context is active */ 252871d10453SEric Joyner #define CTX_ACTIVE(ctx) ((if_getdrvflags(iflib_get_ifp(ctx)) & IFF_DRV_RUNNING)) 252971d10453SEric Joyner 253071d10453SEric Joyner /** 253171d10453SEric Joyner * ice_rebuild_recovery_mode - Rebuild driver state while in recovery mode 253271d10453SEric Joyner * @sc: The device private softc 253371d10453SEric Joyner * 253471d10453SEric Joyner * Handle a driver rebuild while in recovery mode. This will only rebuild the 253571d10453SEric Joyner * limited functionality supported while in recovery mode. 253671d10453SEric Joyner */ 253771d10453SEric Joyner static void 253871d10453SEric Joyner ice_rebuild_recovery_mode(struct ice_softc *sc) 253971d10453SEric Joyner { 254071d10453SEric Joyner device_t dev = sc->dev; 254171d10453SEric Joyner 254271d10453SEric Joyner /* enable PCIe bus master */ 254371d10453SEric Joyner pci_enable_busmaster(dev); 254471d10453SEric Joyner 254571d10453SEric Joyner /* Configure interrupt causes for the administrative interrupt */ 254671d10453SEric Joyner ice_configure_misc_interrupts(sc); 254771d10453SEric Joyner 254871d10453SEric Joyner /* Enable ITR 0 right away, so that we can handle admin interrupts */ 254971d10453SEric Joyner ice_enable_intr(&sc->hw, sc->irqvs[0].me); 255071d10453SEric Joyner 255171d10453SEric Joyner /* Now that the rebuild is finished, we're no longer prepared to reset */ 255271d10453SEric Joyner ice_clear_state(&sc->state, ICE_STATE_PREPARED_FOR_RESET); 255371d10453SEric Joyner 2554402810d3SJustin Hibbits log(LOG_INFO, "%s: device rebuild successful\n", if_name(sc->ifp)); 255571d10453SEric Joyner 255671d10453SEric Joyner /* In order to completely restore device functionality, the iflib core 255771d10453SEric Joyner * needs to be reset. We need to request an iflib reset. Additionally, 255871d10453SEric Joyner * because the state of IFC_DO_RESET is cached within task_fn_admin in 255971d10453SEric Joyner * the iflib core, we also want re-run the admin task so that iflib 256071d10453SEric Joyner * resets immediately instead of waiting for the next interrupt. 256171d10453SEric Joyner */ 256271d10453SEric Joyner ice_request_stack_reinit(sc); 256371d10453SEric Joyner 256471d10453SEric Joyner return; 256571d10453SEric Joyner } 256671d10453SEric Joyner 256771d10453SEric Joyner /** 256871d10453SEric Joyner * ice_rebuild - Rebuild driver state post reset 256971d10453SEric Joyner * @sc: The device private softc 257071d10453SEric Joyner * 257171d10453SEric Joyner * Restore driver state after a reset occurred. Restart the controlqs, setup 257271d10453SEric Joyner * the hardware port, and re-enable the VSIs. 257371d10453SEric Joyner */ 257471d10453SEric Joyner static void 257571d10453SEric Joyner ice_rebuild(struct ice_softc *sc) 257671d10453SEric Joyner { 257771d10453SEric Joyner struct ice_hw *hw = &sc->hw; 257871d10453SEric Joyner device_t dev = sc->dev; 25798923de59SPiotr Kubaj enum ice_ddp_state pkg_state; 2580f2635e84SEric Joyner int status; 258171d10453SEric Joyner int err; 258271d10453SEric Joyner 258371d10453SEric Joyner sc->rebuild_ticks = ticks; 258471d10453SEric Joyner 258571d10453SEric Joyner /* If we're rebuilding, then a reset has succeeded. */ 258671d10453SEric Joyner ice_clear_state(&sc->state, ICE_STATE_RESET_FAILED); 258771d10453SEric Joyner 258871d10453SEric Joyner /* 258971d10453SEric Joyner * If the firmware is in recovery mode, only restore the limited 259071d10453SEric Joyner * functionality supported by recovery mode. 259171d10453SEric Joyner */ 259271d10453SEric Joyner if (ice_test_state(&sc->state, ICE_STATE_RECOVERY_MODE)) { 259371d10453SEric Joyner ice_rebuild_recovery_mode(sc); 259471d10453SEric Joyner return; 259571d10453SEric Joyner } 259671d10453SEric Joyner 259771d10453SEric Joyner /* enable PCIe bus master */ 259871d10453SEric Joyner pci_enable_busmaster(dev); 259971d10453SEric Joyner 260071d10453SEric Joyner status = ice_init_all_ctrlq(hw); 260171d10453SEric Joyner if (status) { 260271d10453SEric Joyner device_printf(dev, "failed to re-init controlqs, err %s\n", 260371d10453SEric Joyner ice_status_str(status)); 260471d10453SEric Joyner goto err_shutdown_ctrlq; 260571d10453SEric Joyner } 260671d10453SEric Joyner 260771d10453SEric Joyner /* Query the allocated resources for Tx scheduler */ 260871d10453SEric Joyner status = ice_sched_query_res_alloc(hw); 260971d10453SEric Joyner if (status) { 261071d10453SEric Joyner device_printf(dev, 261171d10453SEric Joyner "Failed to query scheduler resources, err %s aq_err %s\n", 261271d10453SEric Joyner ice_status_str(status), 261371d10453SEric Joyner ice_aq_str(hw->adminq.sq_last_status)); 261471d10453SEric Joyner goto err_shutdown_ctrlq; 261571d10453SEric Joyner } 261671d10453SEric Joyner 261756429daeSEric Joyner /* Re-enable FW logging. Keep going even if this fails */ 2618440addc6SEric Joyner status = ICE_SUCCESS; 2619440addc6SEric Joyner if (hw->pf_id == 0) 262056429daeSEric Joyner status = ice_fwlog_set(hw, &hw->fwlog_cfg); 262156429daeSEric Joyner if (!status) { 262256429daeSEric Joyner /* 262356429daeSEric Joyner * We should have the most updated cached copy of the 262456429daeSEric Joyner * configuration, regardless of whether we're rebuilding 262556429daeSEric Joyner * or not. So we'll simply check to see if logging was 262656429daeSEric Joyner * enabled pre-rebuild. 262756429daeSEric Joyner */ 262856429daeSEric Joyner if (hw->fwlog_cfg.options & ICE_FWLOG_OPTION_IS_REGISTERED) { 262956429daeSEric Joyner status = ice_fwlog_register(hw); 263056429daeSEric Joyner if (status) 263156429daeSEric Joyner device_printf(dev, "failed to re-register fw logging, err %s aq_err %s\n", 263256429daeSEric Joyner ice_status_str(status), 263356429daeSEric Joyner ice_aq_str(hw->adminq.sq_last_status)); 263456429daeSEric Joyner } 263556429daeSEric Joyner } else 263656429daeSEric Joyner device_printf(dev, "failed to rebuild fw logging configuration, err %s aq_err %s\n", 263756429daeSEric Joyner ice_status_str(status), 263856429daeSEric Joyner ice_aq_str(hw->adminq.sq_last_status)); 263956429daeSEric Joyner 264071d10453SEric Joyner err = ice_send_version(sc); 264171d10453SEric Joyner if (err) 264271d10453SEric Joyner goto err_shutdown_ctrlq; 264371d10453SEric Joyner 264471d10453SEric Joyner err = ice_init_link_events(sc); 264571d10453SEric Joyner if (err) { 264671d10453SEric Joyner device_printf(dev, "ice_init_link_events failed: %s\n", 264771d10453SEric Joyner ice_err_str(err)); 264871d10453SEric Joyner goto err_shutdown_ctrlq; 264971d10453SEric Joyner } 265071d10453SEric Joyner 265171d10453SEric Joyner status = ice_clear_pf_cfg(hw); 265271d10453SEric Joyner if (status) { 265371d10453SEric Joyner device_printf(dev, "failed to clear PF configuration, err %s\n", 265471d10453SEric Joyner ice_status_str(status)); 265571d10453SEric Joyner goto err_shutdown_ctrlq; 265671d10453SEric Joyner } 265771d10453SEric Joyner 26589e54973fSEric Joyner ice_clean_all_vsi_rss_cfg(sc); 26599e54973fSEric Joyner 266071d10453SEric Joyner ice_clear_pxe_mode(hw); 266171d10453SEric Joyner 266271d10453SEric Joyner status = ice_get_caps(hw); 266371d10453SEric Joyner if (status) { 266471d10453SEric Joyner device_printf(dev, "failed to get capabilities, err %s\n", 266571d10453SEric Joyner ice_status_str(status)); 266671d10453SEric Joyner goto err_shutdown_ctrlq; 266771d10453SEric Joyner } 266871d10453SEric Joyner 266971d10453SEric Joyner status = ice_sched_init_port(hw->port_info); 267071d10453SEric Joyner if (status) { 267171d10453SEric Joyner device_printf(dev, "failed to initialize port, err %s\n", 267271d10453SEric Joyner ice_status_str(status)); 267371d10453SEric Joyner goto err_sched_cleanup; 267471d10453SEric Joyner } 267571d10453SEric Joyner 267671d10453SEric Joyner /* If we previously loaded the package, it needs to be reloaded now */ 267771d10453SEric Joyner if (!ice_is_bit_set(sc->feat_en, ICE_FEATURE_SAFE_MODE)) { 26788923de59SPiotr Kubaj pkg_state = ice_init_pkg(hw, hw->pkg_copy, hw->pkg_size); 26798923de59SPiotr Kubaj if (!ice_is_init_pkg_successful(pkg_state)) { 26808923de59SPiotr Kubaj ice_log_pkg_init(sc, pkg_state); 268171d10453SEric Joyner ice_transition_safe_mode(sc); 268271d10453SEric Joyner } 268371d10453SEric Joyner } 268471d10453SEric Joyner 268571d10453SEric Joyner ice_reset_pf_stats(sc); 268671d10453SEric Joyner 268771d10453SEric Joyner err = ice_rebuild_pf_vsi_qmap(sc); 268871d10453SEric Joyner if (err) { 268971d10453SEric Joyner device_printf(sc->dev, "Unable to re-assign main VSI queues, err %s\n", 269071d10453SEric Joyner ice_err_str(err)); 269171d10453SEric Joyner goto err_sched_cleanup; 269271d10453SEric Joyner } 269371d10453SEric Joyner err = ice_initialize_vsi(&sc->pf_vsi); 269471d10453SEric Joyner if (err) { 269571d10453SEric Joyner device_printf(sc->dev, "Unable to re-initialize Main VSI, err %s\n", 269671d10453SEric Joyner ice_err_str(err)); 269771d10453SEric Joyner goto err_release_queue_allocations; 269871d10453SEric Joyner } 269971d10453SEric Joyner 270071d10453SEric Joyner /* Replay all VSI configuration */ 270171d10453SEric Joyner err = ice_replay_all_vsi_cfg(sc); 270271d10453SEric Joyner if (err) 270371d10453SEric Joyner goto err_deinit_pf_vsi; 270471d10453SEric Joyner 27059cf1841cSEric Joyner /* Re-enable FW health event reporting */ 27069cf1841cSEric Joyner ice_init_health_events(sc); 27079cf1841cSEric Joyner 270871d10453SEric Joyner /* Reconfigure the main PF VSI for RSS */ 270971d10453SEric Joyner err = ice_config_rss(&sc->pf_vsi); 271071d10453SEric Joyner if (err) { 271171d10453SEric Joyner device_printf(sc->dev, 271271d10453SEric Joyner "Unable to reconfigure RSS for the main VSI, err %s\n", 271371d10453SEric Joyner ice_err_str(err)); 271471d10453SEric Joyner goto err_deinit_pf_vsi; 271571d10453SEric Joyner } 271671d10453SEric Joyner 27179c30461dSEric Joyner if (hw->port_info->qos_cfg.is_sw_lldp) 27189c30461dSEric Joyner ice_add_rx_lldp_filter(sc); 27199c30461dSEric Joyner 2720f377a0c7SEric Joyner /* Apply previous link settings and refresh link status, if PHY 2721f377a0c7SEric Joyner * FW is ready. 2722f377a0c7SEric Joyner */ 272371d10453SEric Joyner ice_clear_state(&sc->state, ICE_STATE_LINK_STATUS_REPORTED); 2724f377a0c7SEric Joyner ice_init_link(sc); 272571d10453SEric Joyner 27268a13362dSEric Joyner /* RDMA interface will be restarted by the stack re-init */ 27278a13362dSEric Joyner 272871d10453SEric Joyner /* Configure interrupt causes for the administrative interrupt */ 272971d10453SEric Joyner ice_configure_misc_interrupts(sc); 273071d10453SEric Joyner 273171d10453SEric Joyner /* Enable ITR 0 right away, so that we can handle admin interrupts */ 273271d10453SEric Joyner ice_enable_intr(&sc->hw, sc->irqvs[0].me); 273371d10453SEric Joyner 273471d10453SEric Joyner /* Now that the rebuild is finished, we're no longer prepared to reset */ 273571d10453SEric Joyner ice_clear_state(&sc->state, ICE_STATE_PREPARED_FOR_RESET); 273671d10453SEric Joyner 27379e54973fSEric Joyner /* Reconfigure the subinterface */ 27389e54973fSEric Joyner if (sc->mirr_if) { 27399e54973fSEric Joyner err = ice_subif_rebuild(sc); 27409e54973fSEric Joyner if (err) 27419e54973fSEric Joyner goto err_deinit_pf_vsi; 27429e54973fSEric Joyner } 27439e54973fSEric Joyner 2744f2635e84SEric Joyner log(LOG_INFO, "%s: device rebuild successful\n", if_name(sc->ifp)); 274571d10453SEric Joyner 274671d10453SEric Joyner /* In order to completely restore device functionality, the iflib core 274771d10453SEric Joyner * needs to be reset. We need to request an iflib reset. Additionally, 274871d10453SEric Joyner * because the state of IFC_DO_RESET is cached within task_fn_admin in 274971d10453SEric Joyner * the iflib core, we also want re-run the admin task so that iflib 275071d10453SEric Joyner * resets immediately instead of waiting for the next interrupt. 27519c30461dSEric Joyner * If LLDP is enabled we need to reconfig DCB to properly reinit all TC 27529c30461dSEric Joyner * queues, not only 0. It contains ice_request_stack_reinit as well. 275371d10453SEric Joyner */ 27549c30461dSEric Joyner if (hw->port_info->qos_cfg.is_sw_lldp) 275571d10453SEric Joyner ice_request_stack_reinit(sc); 27569c30461dSEric Joyner else 27579c30461dSEric Joyner ice_do_dcb_reconfig(sc, false); 275871d10453SEric Joyner 275971d10453SEric Joyner return; 276071d10453SEric Joyner 276171d10453SEric Joyner err_deinit_pf_vsi: 276271d10453SEric Joyner ice_deinit_vsi(&sc->pf_vsi); 276371d10453SEric Joyner err_release_queue_allocations: 276471d10453SEric Joyner ice_resmgr_release_map(&sc->tx_qmgr, sc->pf_vsi.tx_qmap, 276571d10453SEric Joyner sc->pf_vsi.num_tx_queues); 276671d10453SEric Joyner ice_resmgr_release_map(&sc->rx_qmgr, sc->pf_vsi.rx_qmap, 276771d10453SEric Joyner sc->pf_vsi.num_rx_queues); 276871d10453SEric Joyner err_sched_cleanup: 276971d10453SEric Joyner ice_sched_cleanup_all(hw); 277071d10453SEric Joyner err_shutdown_ctrlq: 27718923de59SPiotr Kubaj ice_shutdown_all_ctrlq(hw, false); 27728923de59SPiotr Kubaj ice_clear_state(&sc->state, ICE_STATE_PREPARED_FOR_RESET); 277371d10453SEric Joyner ice_set_state(&sc->state, ICE_STATE_RESET_FAILED); 277471d10453SEric Joyner device_printf(dev, "Driver rebuild failed, please reload the device driver\n"); 277571d10453SEric Joyner } 277671d10453SEric Joyner 277771d10453SEric Joyner /** 277871d10453SEric Joyner * ice_handle_reset_event - Handle reset events triggered by OICR 277971d10453SEric Joyner * @sc: The device private softc 278071d10453SEric Joyner * 278171d10453SEric Joyner * Handle reset events triggered by an OICR notification. This includes CORER, 278271d10453SEric Joyner * GLOBR, and EMPR resets triggered by software on this or any other PF or by 278371d10453SEric Joyner * firmware. 278471d10453SEric Joyner * 278571d10453SEric Joyner * @pre assumes the iflib context lock is held, and will unlock it while 278671d10453SEric Joyner * waiting for the hardware to finish reset. 278771d10453SEric Joyner */ 278871d10453SEric Joyner static void 278971d10453SEric Joyner ice_handle_reset_event(struct ice_softc *sc) 279071d10453SEric Joyner { 279171d10453SEric Joyner struct ice_hw *hw = &sc->hw; 2792f2635e84SEric Joyner int status; 279371d10453SEric Joyner device_t dev = sc->dev; 279471d10453SEric Joyner 279571d10453SEric Joyner /* When a CORER, GLOBR, or EMPR is about to happen, the hardware will 279671d10453SEric Joyner * trigger an OICR interrupt. Our OICR handler will determine when 279771d10453SEric Joyner * this occurs and set the ICE_STATE_RESET_OICR_RECV bit as 279871d10453SEric Joyner * appropriate. 279971d10453SEric Joyner */ 280071d10453SEric Joyner if (!ice_testandclear_state(&sc->state, ICE_STATE_RESET_OICR_RECV)) 280171d10453SEric Joyner return; 280271d10453SEric Joyner 280371d10453SEric Joyner ice_prepare_for_reset(sc); 280471d10453SEric Joyner 280571d10453SEric Joyner /* 280671d10453SEric Joyner * Release the iflib context lock and wait for the device to finish 280771d10453SEric Joyner * resetting. 280871d10453SEric Joyner */ 280971d10453SEric Joyner IFLIB_CTX_UNLOCK(sc); 2810f377a0c7SEric Joyner 2811f377a0c7SEric Joyner #define ICE_EMPR_ADDL_WAIT_MSEC_SLOW 20000 2812f377a0c7SEric Joyner if ((ice_is_e830(hw) || ice_is_e825c(hw)) && 2813f377a0c7SEric Joyner (((rd32(hw, GLGEN_RSTAT) & GLGEN_RSTAT_RESET_TYPE_M) >> 2814f377a0c7SEric Joyner GLGEN_RSTAT_RESET_TYPE_S) == ICE_RESET_EMPR)) 2815f377a0c7SEric Joyner ice_msec_pause(ICE_EMPR_ADDL_WAIT_MSEC_SLOW); 2816f377a0c7SEric Joyner 281771d10453SEric Joyner status = ice_check_reset(hw); 281871d10453SEric Joyner IFLIB_CTX_LOCK(sc); 281971d10453SEric Joyner if (status) { 282071d10453SEric Joyner device_printf(dev, "Device never came out of reset, err %s\n", 282171d10453SEric Joyner ice_status_str(status)); 2822f377a0c7SEric Joyner 282371d10453SEric Joyner ice_set_state(&sc->state, ICE_STATE_RESET_FAILED); 2824f377a0c7SEric Joyner ice_clear_state(&sc->state, ICE_STATE_RESET_PFR_REQ); 2825f377a0c7SEric Joyner ice_clear_state(&sc->state, ICE_STATE_PREPARED_FOR_RESET); 2826f377a0c7SEric Joyner device_printf(dev, "Reset failed; please reload the device driver\n"); 282771d10453SEric Joyner return; 282871d10453SEric Joyner } 282971d10453SEric Joyner 283071d10453SEric Joyner /* We're done with the reset, so we can rebuild driver state */ 283171d10453SEric Joyner sc->hw.reset_ongoing = false; 283271d10453SEric Joyner ice_rebuild(sc); 283371d10453SEric Joyner 283471d10453SEric Joyner /* In the unlikely event that a PF reset request occurs at the same 283571d10453SEric Joyner * time as a global reset, clear the request now. This avoids 283671d10453SEric Joyner * resetting a second time right after we reset due to a global event. 283771d10453SEric Joyner */ 283871d10453SEric Joyner if (ice_testandclear_state(&sc->state, ICE_STATE_RESET_PFR_REQ)) 283971d10453SEric Joyner device_printf(dev, "Ignoring PFR request that occurred while a reset was ongoing\n"); 284071d10453SEric Joyner } 284171d10453SEric Joyner 284271d10453SEric Joyner /** 284371d10453SEric Joyner * ice_handle_pf_reset_request - Initiate PF reset requested by software 284471d10453SEric Joyner * @sc: The device private softc 284571d10453SEric Joyner * 284671d10453SEric Joyner * Initiate a PF reset requested by software. We handle this in the admin task 284771d10453SEric Joyner * so that only one thread actually handles driver preparation and cleanup, 284871d10453SEric Joyner * rather than having multiple threads possibly attempt to run this code 284971d10453SEric Joyner * simultaneously. 285071d10453SEric Joyner * 285171d10453SEric Joyner * @pre assumes the iflib context lock is held and will unlock it while 285271d10453SEric Joyner * waiting for the PF reset to complete. 285371d10453SEric Joyner */ 285471d10453SEric Joyner static void 285571d10453SEric Joyner ice_handle_pf_reset_request(struct ice_softc *sc) 285671d10453SEric Joyner { 285771d10453SEric Joyner struct ice_hw *hw = &sc->hw; 2858f2635e84SEric Joyner int status; 285971d10453SEric Joyner 286071d10453SEric Joyner /* Check for PF reset requests */ 286171d10453SEric Joyner if (!ice_testandclear_state(&sc->state, ICE_STATE_RESET_PFR_REQ)) 286271d10453SEric Joyner return; 286371d10453SEric Joyner 286471d10453SEric Joyner /* Make sure we're prepared for reset */ 286571d10453SEric Joyner ice_prepare_for_reset(sc); 286671d10453SEric Joyner 286771d10453SEric Joyner /* 286871d10453SEric Joyner * Release the iflib context lock and wait for the device to finish 286971d10453SEric Joyner * resetting. 287071d10453SEric Joyner */ 287171d10453SEric Joyner IFLIB_CTX_UNLOCK(sc); 287271d10453SEric Joyner status = ice_reset(hw, ICE_RESET_PFR); 287371d10453SEric Joyner IFLIB_CTX_LOCK(sc); 287471d10453SEric Joyner if (status) { 287571d10453SEric Joyner device_printf(sc->dev, "device PF reset failed, err %s\n", 287671d10453SEric Joyner ice_status_str(status)); 287771d10453SEric Joyner ice_set_state(&sc->state, ICE_STATE_RESET_FAILED); 287871d10453SEric Joyner return; 287971d10453SEric Joyner } 288071d10453SEric Joyner 288171d10453SEric Joyner sc->soft_stats.pfr_count++; 288271d10453SEric Joyner ice_rebuild(sc); 288371d10453SEric Joyner } 288471d10453SEric Joyner 288571d10453SEric Joyner /** 288671d10453SEric Joyner * ice_init_device_features - Init device driver features 288771d10453SEric Joyner * @sc: driver softc structure 288871d10453SEric Joyner * 288971d10453SEric Joyner * @pre assumes that the function capabilities bits have been set up by 289071d10453SEric Joyner * ice_init_hw(). 289171d10453SEric Joyner */ 289271d10453SEric Joyner static void 289371d10453SEric Joyner ice_init_device_features(struct ice_softc *sc) 289471d10453SEric Joyner { 28959c30461dSEric Joyner struct ice_hw *hw = &sc->hw; 28969c30461dSEric Joyner 28977d7af7f8SEric Joyner /* Set capabilities that all devices support */ 289871d10453SEric Joyner ice_set_bit(ICE_FEATURE_SRIOV, sc->feat_cap); 289971d10453SEric Joyner ice_set_bit(ICE_FEATURE_RSS, sc->feat_cap); 29008a13362dSEric Joyner ice_set_bit(ICE_FEATURE_RDMA, sc->feat_cap); 290171d10453SEric Joyner ice_set_bit(ICE_FEATURE_LENIENT_LINK_MODE, sc->feat_cap); 29029cf1841cSEric Joyner ice_set_bit(ICE_FEATURE_LINK_MGMT_VER_1, sc->feat_cap); 29039cf1841cSEric Joyner ice_set_bit(ICE_FEATURE_LINK_MGMT_VER_2, sc->feat_cap); 29049cf1841cSEric Joyner ice_set_bit(ICE_FEATURE_HEALTH_STATUS, sc->feat_cap); 290556429daeSEric Joyner ice_set_bit(ICE_FEATURE_FW_LOGGING, sc->feat_cap); 290656429daeSEric Joyner ice_set_bit(ICE_FEATURE_HAS_PBA, sc->feat_cap); 29078923de59SPiotr Kubaj ice_set_bit(ICE_FEATURE_DCB, sc->feat_cap); 29088923de59SPiotr Kubaj ice_set_bit(ICE_FEATURE_TX_BALANCE, sc->feat_cap); 2909f2635e84SEric Joyner ice_set_bit(ICE_FEATURE_PHY_STATISTICS, sc->feat_cap); 291071d10453SEric Joyner 2911f2635e84SEric Joyner if (ice_is_e810(hw)) 2912f2635e84SEric Joyner ice_set_bit(ICE_FEATURE_PHY_STATISTICS, sc->feat_en); 2913f2635e84SEric Joyner 2914f377a0c7SEric Joyner if (ice_is_e825c(hw)) 2915f2635e84SEric Joyner ice_set_bit(ICE_FEATURE_DUAL_NAC, sc->feat_cap); 291671d10453SEric Joyner /* Disable features due to hardware limitations... */ 29179c30461dSEric Joyner if (!hw->func_caps.common_cap.rss_table_size) 291871d10453SEric Joyner ice_clear_bit(ICE_FEATURE_RSS, sc->feat_cap); 2919*03e1f25dSEric Joyner if (!hw->func_caps.common_cap.iwarp || !ice_enable_irdma) 29208a13362dSEric Joyner ice_clear_bit(ICE_FEATURE_RDMA, sc->feat_cap); 29219c30461dSEric Joyner if (!hw->func_caps.common_cap.dcb) 29228923de59SPiotr Kubaj ice_clear_bit(ICE_FEATURE_DCB, sc->feat_cap); 29239cf1841cSEric Joyner /* Disable features due to firmware limitations... */ 29249c30461dSEric Joyner if (!ice_is_fw_health_report_supported(hw)) 29259cf1841cSEric Joyner ice_clear_bit(ICE_FEATURE_HEALTH_STATUS, sc->feat_cap); 29269c30461dSEric Joyner if (!ice_fwlog_supported(hw)) 292756429daeSEric Joyner ice_clear_bit(ICE_FEATURE_FW_LOGGING, sc->feat_cap); 29289c30461dSEric Joyner if (hw->fwlog_cfg.options & ICE_FWLOG_OPTION_IS_REGISTERED) { 292956429daeSEric Joyner if (ice_is_bit_set(sc->feat_cap, ICE_FEATURE_FW_LOGGING)) 293056429daeSEric Joyner ice_set_bit(ICE_FEATURE_FW_LOGGING, sc->feat_en); 293156429daeSEric Joyner else 29329c30461dSEric Joyner ice_fwlog_unregister(hw); 293356429daeSEric Joyner } 293471d10453SEric Joyner 293571d10453SEric Joyner /* Disable capabilities not supported by the OS */ 293671d10453SEric Joyner ice_disable_unsupported_features(sc->feat_cap); 293771d10453SEric Joyner 293871d10453SEric Joyner /* RSS is always enabled for iflib */ 293971d10453SEric Joyner if (ice_is_bit_set(sc->feat_cap, ICE_FEATURE_RSS)) 294071d10453SEric Joyner ice_set_bit(ICE_FEATURE_RSS, sc->feat_en); 29418923de59SPiotr Kubaj 29428923de59SPiotr Kubaj /* Disable features based on sysctl settings */ 29438923de59SPiotr Kubaj if (!ice_tx_balance_en) 29448923de59SPiotr Kubaj ice_clear_bit(ICE_FEATURE_TX_BALANCE, sc->feat_cap); 29459c30461dSEric Joyner 29469c30461dSEric Joyner if (hw->dev_caps.supported_sensors & ICE_SENSOR_SUPPORT_E810_INT_TEMP) { 29479c30461dSEric Joyner ice_set_bit(ICE_FEATURE_TEMP_SENSOR, sc->feat_cap); 29489c30461dSEric Joyner ice_set_bit(ICE_FEATURE_TEMP_SENSOR, sc->feat_en); 29499c30461dSEric Joyner } 2950f2635e84SEric Joyner 2951f2635e84SEric Joyner if (hw->func_caps.common_cap.next_cluster_id_support || 2952f2635e84SEric Joyner hw->dev_caps.common_cap.next_cluster_id_support) { 2953f2635e84SEric Joyner ice_set_bit(ICE_FEATURE_NEXT_CLUSTER_ID, sc->feat_cap); 2954f2635e84SEric Joyner ice_set_bit(ICE_FEATURE_NEXT_CLUSTER_ID, sc->feat_en); 2955f2635e84SEric Joyner } 295671d10453SEric Joyner } 295771d10453SEric Joyner 295871d10453SEric Joyner /** 295971d10453SEric Joyner * ice_if_multi_set - Callback to update Multicast filters in HW 296071d10453SEric Joyner * @ctx: iflib ctx structure 296171d10453SEric Joyner * 296271d10453SEric Joyner * Called by iflib in response to SIOCDELMULTI and SIOCADDMULTI. Must search 296371d10453SEric Joyner * the if_multiaddrs list and determine which filters have been added or 296471d10453SEric Joyner * removed from the list, and update HW programming to reflect the new list. 296571d10453SEric Joyner * 296671d10453SEric Joyner * @pre assumes the caller holds the iflib CTX lock 296771d10453SEric Joyner */ 296871d10453SEric Joyner static void 296971d10453SEric Joyner ice_if_multi_set(if_ctx_t ctx) 297071d10453SEric Joyner { 297171d10453SEric Joyner struct ice_softc *sc = (struct ice_softc *)iflib_get_softc(ctx); 297271d10453SEric Joyner int err; 297371d10453SEric Joyner 297471d10453SEric Joyner ASSERT_CTX_LOCKED(sc); 297571d10453SEric Joyner 297671d10453SEric Joyner /* Do not handle multicast configuration in recovery mode */ 297771d10453SEric Joyner if (ice_test_state(&sc->state, ICE_STATE_RECOVERY_MODE)) 297871d10453SEric Joyner return; 297971d10453SEric Joyner 298071d10453SEric Joyner err = ice_sync_multicast_filters(sc); 298171d10453SEric Joyner if (err) { 298271d10453SEric Joyner device_printf(sc->dev, 298371d10453SEric Joyner "Failed to synchronize multicast filter list: %s\n", 298471d10453SEric Joyner ice_err_str(err)); 298571d10453SEric Joyner return; 298671d10453SEric Joyner } 298771d10453SEric Joyner } 298871d10453SEric Joyner 298971d10453SEric Joyner /** 299071d10453SEric Joyner * ice_if_vlan_register - Register a VLAN with the hardware 299171d10453SEric Joyner * @ctx: iflib ctx pointer 299271d10453SEric Joyner * @vtag: VLAN to add 299371d10453SEric Joyner * 299471d10453SEric Joyner * Programs the main PF VSI with a hardware filter for the given VLAN. 299571d10453SEric Joyner * 299671d10453SEric Joyner * @pre assumes the caller holds the iflib CTX lock 299771d10453SEric Joyner */ 299871d10453SEric Joyner static void 299971d10453SEric Joyner ice_if_vlan_register(if_ctx_t ctx, u16 vtag) 300071d10453SEric Joyner { 300171d10453SEric Joyner struct ice_softc *sc = (struct ice_softc *)iflib_get_softc(ctx); 3002f2635e84SEric Joyner int status; 300371d10453SEric Joyner 300471d10453SEric Joyner ASSERT_CTX_LOCKED(sc); 300571d10453SEric Joyner 300671d10453SEric Joyner /* Do not handle VLAN configuration in recovery mode */ 300771d10453SEric Joyner if (ice_test_state(&sc->state, ICE_STATE_RECOVERY_MODE)) 300871d10453SEric Joyner return; 300971d10453SEric Joyner 301071d10453SEric Joyner status = ice_add_vlan_hw_filter(&sc->pf_vsi, vtag); 301171d10453SEric Joyner if (status) { 301271d10453SEric Joyner device_printf(sc->dev, 301371d10453SEric Joyner "Failure adding VLAN %d to main VSI, err %s aq_err %s\n", 301471d10453SEric Joyner vtag, ice_status_str(status), 301571d10453SEric Joyner ice_aq_str(sc->hw.adminq.sq_last_status)); 301671d10453SEric Joyner } 301771d10453SEric Joyner } 301871d10453SEric Joyner 301971d10453SEric Joyner /** 302071d10453SEric Joyner * ice_if_vlan_unregister - Remove a VLAN filter from the hardware 302171d10453SEric Joyner * @ctx: iflib ctx pointer 302271d10453SEric Joyner * @vtag: VLAN to add 302371d10453SEric Joyner * 302471d10453SEric Joyner * Removes the previously programmed VLAN filter from the main PF VSI. 302571d10453SEric Joyner * 302671d10453SEric Joyner * @pre assumes the caller holds the iflib CTX lock 302771d10453SEric Joyner */ 302871d10453SEric Joyner static void 302971d10453SEric Joyner ice_if_vlan_unregister(if_ctx_t ctx, u16 vtag) 303071d10453SEric Joyner { 303171d10453SEric Joyner struct ice_softc *sc = (struct ice_softc *)iflib_get_softc(ctx); 3032f2635e84SEric Joyner int status; 303371d10453SEric Joyner 303471d10453SEric Joyner ASSERT_CTX_LOCKED(sc); 303571d10453SEric Joyner 303671d10453SEric Joyner /* Do not handle VLAN configuration in recovery mode */ 303771d10453SEric Joyner if (ice_test_state(&sc->state, ICE_STATE_RECOVERY_MODE)) 303871d10453SEric Joyner return; 303971d10453SEric Joyner 304071d10453SEric Joyner status = ice_remove_vlan_hw_filter(&sc->pf_vsi, vtag); 304171d10453SEric Joyner if (status) { 304271d10453SEric Joyner device_printf(sc->dev, 304371d10453SEric Joyner "Failure removing VLAN %d from main VSI, err %s aq_err %s\n", 304471d10453SEric Joyner vtag, ice_status_str(status), 304571d10453SEric Joyner ice_aq_str(sc->hw.adminq.sq_last_status)); 304671d10453SEric Joyner } 304771d10453SEric Joyner } 304871d10453SEric Joyner 304971d10453SEric Joyner /** 305071d10453SEric Joyner * ice_if_stop - Stop the device 305171d10453SEric Joyner * @ctx: iflib context structure 305271d10453SEric Joyner * 305371d10453SEric Joyner * Called by iflib to stop the device and bring it down. (i.e. ifconfig ice0 305471d10453SEric Joyner * down) 305571d10453SEric Joyner * 305671d10453SEric Joyner * @pre assumes the caller holds the iflib CTX lock 305771d10453SEric Joyner */ 305871d10453SEric Joyner static void 305971d10453SEric Joyner ice_if_stop(if_ctx_t ctx) 306071d10453SEric Joyner { 30619e54973fSEric Joyner struct ice_mirr_if *mif = (struct ice_mirr_if *)iflib_get_softc(ctx); 306271d10453SEric Joyner struct ice_softc *sc = (struct ice_softc *)iflib_get_softc(ctx); 306371d10453SEric Joyner 306471d10453SEric Joyner ASSERT_CTX_LOCKED(sc); 306571d10453SEric Joyner 306671d10453SEric Joyner /* 306771d10453SEric Joyner * The iflib core may call IFDI_STOP prior to the first call to 306871d10453SEric Joyner * IFDI_INIT. This will cause us to attempt to remove MAC filters we 306971d10453SEric Joyner * don't have, and disable Tx queues which aren't yet configured. 307071d10453SEric Joyner * Although it is likely these extra operations are harmless, they do 307171d10453SEric Joyner * cause spurious warning messages to be displayed, which may confuse 307271d10453SEric Joyner * users. 307371d10453SEric Joyner * 307471d10453SEric Joyner * To avoid these messages, we use a state bit indicating if we've 307571d10453SEric Joyner * been initialized. It will be set when ice_if_init is called, and 307671d10453SEric Joyner * cleared here in ice_if_stop. 307771d10453SEric Joyner */ 307871d10453SEric Joyner if (!ice_testandclear_state(&sc->state, ICE_STATE_DRIVER_INITIALIZED)) 307971d10453SEric Joyner return; 308071d10453SEric Joyner 308171d10453SEric Joyner if (ice_test_state(&sc->state, ICE_STATE_RESET_FAILED)) { 308271d10453SEric Joyner device_printf(sc->dev, "request to stop interface cannot be completed as the device failed to reset\n"); 308371d10453SEric Joyner return; 308471d10453SEric Joyner } 308571d10453SEric Joyner 308671d10453SEric Joyner if (ice_test_state(&sc->state, ICE_STATE_PREPARED_FOR_RESET)) { 308771d10453SEric Joyner device_printf(sc->dev, "request to stop interface while device is prepared for impending reset\n"); 308871d10453SEric Joyner return; 308971d10453SEric Joyner } 309071d10453SEric Joyner 30918a13362dSEric Joyner ice_rdma_pf_stop(sc); 30928a13362dSEric Joyner 309371d10453SEric Joyner /* Remove the MAC filters, stop Tx, and stop Rx. We don't check the 309471d10453SEric Joyner * return of these functions because there's nothing we can really do 309571d10453SEric Joyner * if they fail, and the functions already print error messages. 309671d10453SEric Joyner * Just try to shut down as much as we can. 309771d10453SEric Joyner */ 309871d10453SEric Joyner ice_rm_pf_default_mac_filters(sc); 309971d10453SEric Joyner 310071d10453SEric Joyner /* Dissociate the Tx and Rx queues from the interrupts */ 310171d10453SEric Joyner ice_flush_txq_interrupts(&sc->pf_vsi); 310271d10453SEric Joyner ice_flush_rxq_interrupts(&sc->pf_vsi); 310371d10453SEric Joyner 310471d10453SEric Joyner /* Disable the Tx and Rx queues */ 310571d10453SEric Joyner ice_vsi_disable_tx(&sc->pf_vsi); 31069dc2f6e2SEric Joyner ice_control_all_rx_queues(&sc->pf_vsi, false); 31079c30461dSEric Joyner 31089c30461dSEric Joyner if (!ice_test_state(&sc->state, ICE_STATE_LINK_ACTIVE_ON_DOWN) && 31099c30461dSEric Joyner !(if_getflags(sc->ifp) & IFF_UP) && sc->link_up) 31109c30461dSEric Joyner ice_set_link(sc, false); 31119e54973fSEric Joyner 31129e54973fSEric Joyner if (sc->mirr_if && ice_test_state(&mif->state, ICE_STATE_SUBIF_NEEDS_REINIT)) { 31139e54973fSEric Joyner ice_subif_if_stop(sc->mirr_if->subctx); 31149e54973fSEric Joyner device_printf(sc->dev, "The subinterface also comes down and up after reset\n"); 31159e54973fSEric Joyner } 311671d10453SEric Joyner } 311771d10453SEric Joyner 311871d10453SEric Joyner /** 311971d10453SEric Joyner * ice_if_get_counter - Get current value of an ifnet statistic 312071d10453SEric Joyner * @ctx: iflib context pointer 312171d10453SEric Joyner * @counter: ifnet counter to read 312271d10453SEric Joyner * 312371d10453SEric Joyner * Reads the current value of an ifnet counter for the device. 312471d10453SEric Joyner * 312571d10453SEric Joyner * This function is not protected by the iflib CTX lock. 312671d10453SEric Joyner */ 312771d10453SEric Joyner static uint64_t 312871d10453SEric Joyner ice_if_get_counter(if_ctx_t ctx, ift_counter counter) 312971d10453SEric Joyner { 313071d10453SEric Joyner struct ice_softc *sc = (struct ice_softc *)iflib_get_softc(ctx); 313171d10453SEric Joyner 313271d10453SEric Joyner /* Return the counter for the main PF VSI */ 313371d10453SEric Joyner return ice_get_ifnet_counter(&sc->pf_vsi, counter); 313471d10453SEric Joyner } 313571d10453SEric Joyner 313671d10453SEric Joyner /** 313771d10453SEric Joyner * ice_request_stack_reinit - Request that iflib re-initialize 313871d10453SEric Joyner * @sc: the device private softc 313971d10453SEric Joyner * 314071d10453SEric Joyner * Request that the device be brought down and up, to re-initialize. For 314171d10453SEric Joyner * example, this may be called when a device reset occurs, or when Tx and Rx 314271d10453SEric Joyner * queues need to be re-initialized. 314371d10453SEric Joyner * 314471d10453SEric Joyner * This is required because the iflib state is outside the driver, and must be 314571d10453SEric Joyner * re-initialized if we need to resart Tx and Rx queues. 314671d10453SEric Joyner */ 314771d10453SEric Joyner void 314871d10453SEric Joyner ice_request_stack_reinit(struct ice_softc *sc) 314971d10453SEric Joyner { 315071d10453SEric Joyner if (CTX_ACTIVE(sc->ctx)) { 315171d10453SEric Joyner iflib_request_reset(sc->ctx); 315271d10453SEric Joyner iflib_admin_intr_deferred(sc->ctx); 315371d10453SEric Joyner } 315471d10453SEric Joyner } 315571d10453SEric Joyner 315671d10453SEric Joyner /** 315771d10453SEric Joyner * ice_driver_is_detaching - Check if the driver is detaching/unloading 315871d10453SEric Joyner * @sc: device private softc 315971d10453SEric Joyner * 316071d10453SEric Joyner * Returns true if the driver is detaching, false otherwise. 316171d10453SEric Joyner * 316271d10453SEric Joyner * @remark on newer kernels, take advantage of iflib_in_detach in order to 316371d10453SEric Joyner * report detachment correctly as early as possible. 316471d10453SEric Joyner * 316571d10453SEric Joyner * @remark this function is used by various code paths that want to avoid 316671d10453SEric Joyner * running if the driver is about to be removed. This includes sysctls and 316771d10453SEric Joyner * other driver access points. Note that it does not fully resolve 316871d10453SEric Joyner * detach-based race conditions as it is possible for a thread to race with 316971d10453SEric Joyner * iflib_in_detach. 317071d10453SEric Joyner */ 317171d10453SEric Joyner bool 317271d10453SEric Joyner ice_driver_is_detaching(struct ice_softc *sc) 317371d10453SEric Joyner { 317471d10453SEric Joyner return (ice_test_state(&sc->state, ICE_STATE_DETACHING) || 317571d10453SEric Joyner iflib_in_detach(sc->ctx)); 317671d10453SEric Joyner } 317771d10453SEric Joyner 317871d10453SEric Joyner /** 317971d10453SEric Joyner * ice_if_priv_ioctl - Device private ioctl handler 318071d10453SEric Joyner * @ctx: iflib context pointer 318171d10453SEric Joyner * @command: The ioctl command issued 318271d10453SEric Joyner * @data: ioctl specific data 318371d10453SEric Joyner * 318471d10453SEric Joyner * iflib callback for handling custom driver specific ioctls. 318571d10453SEric Joyner * 318671d10453SEric Joyner * @pre Assumes that the iflib context lock is held. 318771d10453SEric Joyner */ 318871d10453SEric Joyner static int 318971d10453SEric Joyner ice_if_priv_ioctl(if_ctx_t ctx, u_long command, caddr_t data) 319071d10453SEric Joyner { 319171d10453SEric Joyner struct ice_softc *sc = (struct ice_softc *)iflib_get_softc(ctx); 319271d10453SEric Joyner struct ifdrv *ifd; 319371d10453SEric Joyner device_t dev = sc->dev; 319471d10453SEric Joyner 319571d10453SEric Joyner if (data == NULL) 319671d10453SEric Joyner return (EINVAL); 319771d10453SEric Joyner 319871d10453SEric Joyner ASSERT_CTX_LOCKED(sc); 319971d10453SEric Joyner 320071d10453SEric Joyner /* Make sure the command type is valid */ 320171d10453SEric Joyner switch (command) { 320271d10453SEric Joyner case SIOCSDRVSPEC: 320371d10453SEric Joyner case SIOCGDRVSPEC: 320471d10453SEric Joyner /* Accepted commands */ 320571d10453SEric Joyner break; 320671d10453SEric Joyner case SIOCGPRIVATE_0: 320771d10453SEric Joyner /* 320871d10453SEric Joyner * Although we do not support this ioctl command, it's 320971d10453SEric Joyner * expected that iflib will forward it to the IFDI_PRIV_IOCTL 321071d10453SEric Joyner * handler. Do not print a message in this case 321171d10453SEric Joyner */ 321271d10453SEric Joyner return (ENOTSUP); 321371d10453SEric Joyner default: 321471d10453SEric Joyner /* 321571d10453SEric Joyner * If we get a different command for this function, it's 321671d10453SEric Joyner * definitely unexpected, so log a message indicating what 321771d10453SEric Joyner * command we got for debugging purposes. 321871d10453SEric Joyner */ 321971d10453SEric Joyner device_printf(dev, "%s: unexpected ioctl command %08lx\n", 322071d10453SEric Joyner __func__, command); 322171d10453SEric Joyner return (EINVAL); 322271d10453SEric Joyner } 322371d10453SEric Joyner 322471d10453SEric Joyner ifd = (struct ifdrv *)data; 322571d10453SEric Joyner 322671d10453SEric Joyner switch (ifd->ifd_cmd) { 322771d10453SEric Joyner case ICE_NVM_ACCESS: 322871d10453SEric Joyner return ice_handle_nvm_access_ioctl(sc, ifd); 32298923de59SPiotr Kubaj case ICE_DEBUG_DUMP: 32308923de59SPiotr Kubaj return ice_handle_debug_dump_ioctl(sc, ifd); 323171d10453SEric Joyner default: 323271d10453SEric Joyner return EINVAL; 323371d10453SEric Joyner } 323471d10453SEric Joyner } 323571d10453SEric Joyner 323671d10453SEric Joyner /** 323771d10453SEric Joyner * ice_if_i2c_req - I2C request handler for iflib 323871d10453SEric Joyner * @ctx: iflib context pointer 323971d10453SEric Joyner * @req: The I2C parameters to use 324071d10453SEric Joyner * 324171d10453SEric Joyner * Read from the port's I2C eeprom using the parameters from the ioctl. 324271d10453SEric Joyner * 324371d10453SEric Joyner * @remark The iflib-only part is pretty simple. 324471d10453SEric Joyner */ 324571d10453SEric Joyner static int 324671d10453SEric Joyner ice_if_i2c_req(if_ctx_t ctx, struct ifi2creq *req) 324771d10453SEric Joyner { 324871d10453SEric Joyner struct ice_softc *sc = (struct ice_softc *)iflib_get_softc(ctx); 324971d10453SEric Joyner 325071d10453SEric Joyner return ice_handle_i2c_req(sc, req); 325171d10453SEric Joyner } 325271d10453SEric Joyner 32537d7af7f8SEric Joyner /** 32547d7af7f8SEric Joyner * ice_if_suspend - PCI device suspend handler for iflib 32557d7af7f8SEric Joyner * @ctx: iflib context pointer 32567d7af7f8SEric Joyner * 32577d7af7f8SEric Joyner * Deinitializes the driver and clears HW resources in preparation for 32587d7af7f8SEric Joyner * suspend or an FLR. 32597d7af7f8SEric Joyner * 32607d7af7f8SEric Joyner * @returns 0; this return value is ignored 32617d7af7f8SEric Joyner */ 32627d7af7f8SEric Joyner static int 32637d7af7f8SEric Joyner ice_if_suspend(if_ctx_t ctx) 32647d7af7f8SEric Joyner { 32657d7af7f8SEric Joyner struct ice_softc *sc = (struct ice_softc *)iflib_get_softc(ctx); 32667d7af7f8SEric Joyner 32677d7af7f8SEric Joyner /* At least a PFR is always going to happen after this; 32687d7af7f8SEric Joyner * either via FLR or during the D3->D0 transition. 32697d7af7f8SEric Joyner */ 32707d7af7f8SEric Joyner ice_clear_state(&sc->state, ICE_STATE_RESET_PFR_REQ); 32717d7af7f8SEric Joyner 32727d7af7f8SEric Joyner ice_prepare_for_reset(sc); 32737d7af7f8SEric Joyner 32747d7af7f8SEric Joyner return (0); 32757d7af7f8SEric Joyner } 32767d7af7f8SEric Joyner 32777d7af7f8SEric Joyner /** 32787d7af7f8SEric Joyner * ice_if_resume - PCI device resume handler for iflib 32797d7af7f8SEric Joyner * @ctx: iflib context pointer 32807d7af7f8SEric Joyner * 32817d7af7f8SEric Joyner * Reinitializes the driver and the HW after PCI resume or after 32827d7af7f8SEric Joyner * an FLR. An init is performed by iflib after this function is finished. 32837d7af7f8SEric Joyner * 32847d7af7f8SEric Joyner * @returns 0; this return value is ignored 32857d7af7f8SEric Joyner */ 32867d7af7f8SEric Joyner static int 32877d7af7f8SEric Joyner ice_if_resume(if_ctx_t ctx) 32887d7af7f8SEric Joyner { 32897d7af7f8SEric Joyner struct ice_softc *sc = (struct ice_softc *)iflib_get_softc(ctx); 32907d7af7f8SEric Joyner 32917d7af7f8SEric Joyner ice_rebuild(sc); 32927d7af7f8SEric Joyner 32937d7af7f8SEric Joyner return (0); 32947d7af7f8SEric Joyner } 32957d7af7f8SEric Joyner 32969c30461dSEric Joyner /** 32979c30461dSEric Joyner * ice_if_needs_restart - Tell iflib when the driver needs to be reinitialized 32989c30461dSEric Joyner * @ctx: iflib context pointer 329914a14e36SKevin Bowling * @event: event code to check 330014a14e36SKevin Bowling * 33019e54973fSEric Joyner * Defaults to returning true for unknown events. 330214a14e36SKevin Bowling * 330314a14e36SKevin Bowling * @returns true if iflib needs to reinit the interface 330414a14e36SKevin Bowling */ 330514a14e36SKevin Bowling static bool 33069e54973fSEric Joyner ice_if_needs_restart(if_ctx_t ctx, enum iflib_restart_event event) 330714a14e36SKevin Bowling { 33089e54973fSEric Joyner struct ice_softc *sc = (struct ice_softc *)iflib_get_softc(ctx); 33099e54973fSEric Joyner 331014a14e36SKevin Bowling switch (event) { 331114a14e36SKevin Bowling case IFLIB_RESTART_VLAN_CONFIG: 33129e54973fSEric Joyner if (!ice_test_state(&sc->state, ICE_STATE_LINK_ACTIVE_ON_DOWN) && 33139e54973fSEric Joyner !(if_getflags(sc->ifp) & IFF_UP)) 33149e54973fSEric Joyner return false; 331514a14e36SKevin Bowling default: 33169e54973fSEric Joyner return true; 331714a14e36SKevin Bowling } 331814a14e36SKevin Bowling } 331914a14e36SKevin Bowling 3320f377a0c7SEric Joyner /** 3321f377a0c7SEric Joyner * ice_init_link - Do link configuration and link status reporting 3322f377a0c7SEric Joyner * @sc: driver private structure 3323f377a0c7SEric Joyner * 3324f377a0c7SEric Joyner * Contains an extra check that skips link config when an E830 device 3325f377a0c7SEric Joyner * does not have the "FW_LOADING"/"PHYBUSY" bit set in GL_MNG_FWSM set. 3326f377a0c7SEric Joyner */ 3327f377a0c7SEric Joyner static void 3328f377a0c7SEric Joyner ice_init_link(struct ice_softc *sc) 3329f377a0c7SEric Joyner { 3330f377a0c7SEric Joyner struct ice_hw *hw = &sc->hw; 3331f377a0c7SEric Joyner device_t dev = sc->dev; 3332f377a0c7SEric Joyner 3333f377a0c7SEric Joyner /* Check if FW is ready before setting up link; defer setup to the 3334f377a0c7SEric Joyner * admin task if it isn't. 3335f377a0c7SEric Joyner */ 3336f377a0c7SEric Joyner if (ice_is_e830(hw) && 3337f377a0c7SEric Joyner (rd32(hw, GL_MNG_FWSM) & GL_MNG_FWSM_FW_LOADING_M)) { 3338f377a0c7SEric Joyner ice_set_state(&sc->state, ICE_STATE_PHY_FW_INIT_PENDING); 3339f377a0c7SEric Joyner device_printf(dev, 3340f377a0c7SEric Joyner "Link initialization is blocked by PHY FW initialization.\n"); 3341f377a0c7SEric Joyner device_printf(dev, 3342f377a0c7SEric Joyner "Link initialization will continue after PHY FW initialization completes.\n"); 3343f377a0c7SEric Joyner /* Do not access PHY config while PHY FW is busy initializing */ 3344f377a0c7SEric Joyner } else { 3345f377a0c7SEric Joyner ice_clear_state(&sc->state, ICE_STATE_PHY_FW_INIT_PENDING); 3346f377a0c7SEric Joyner ice_init_link_configuration(sc); 3347f377a0c7SEric Joyner ice_update_link_status(sc, true); 3348f377a0c7SEric Joyner } 3349f377a0c7SEric Joyner 3350f377a0c7SEric Joyner } 3351f377a0c7SEric Joyner 33529e54973fSEric Joyner extern struct if_txrx ice_subif_txrx; 33539e54973fSEric Joyner 33549e54973fSEric Joyner /** 33559e54973fSEric Joyner * @var ice_subif_methods 33569e54973fSEric Joyner * @brief ice driver method entry points 33579e54973fSEric Joyner */ 33589e54973fSEric Joyner static device_method_t ice_subif_methods[] = { 33599e54973fSEric Joyner /* Device interface */ 33609e54973fSEric Joyner DEVMETHOD(device_register, ice_subif_register), 33619e54973fSEric Joyner DEVMETHOD_END 33629e54973fSEric Joyner }; 33639e54973fSEric Joyner 33649e54973fSEric Joyner /** 33659e54973fSEric Joyner * @var ice_subif_driver 33669e54973fSEric Joyner * @brief driver structure for the device API 33679e54973fSEric Joyner */ 33689e54973fSEric Joyner static driver_t ice_subif_driver = { 33699e54973fSEric Joyner .name = "ice_subif", 33709e54973fSEric Joyner .methods = ice_subif_methods, 33719e54973fSEric Joyner .size = sizeof(struct ice_mirr_if), 33729e54973fSEric Joyner }; 33739e54973fSEric Joyner 33749e54973fSEric Joyner static device_method_t ice_iflib_subif_methods[] = { 33759e54973fSEric Joyner DEVMETHOD(ifdi_attach_pre, ice_subif_if_attach_pre), 33769e54973fSEric Joyner DEVMETHOD(ifdi_attach_post, ice_subif_if_attach_post), 33779e54973fSEric Joyner DEVMETHOD(ifdi_tx_queues_alloc, ice_subif_if_tx_queues_alloc), 33789e54973fSEric Joyner DEVMETHOD(ifdi_rx_queues_alloc, ice_subif_if_rx_queues_alloc), 33799e54973fSEric Joyner DEVMETHOD(ifdi_msix_intr_assign, ice_subif_if_msix_intr_assign), 33809e54973fSEric Joyner DEVMETHOD(ifdi_intr_enable, ice_subif_if_intr_enable), 33819e54973fSEric Joyner DEVMETHOD(ifdi_rx_queue_intr_enable, ice_subif_if_rx_queue_intr_enable), 33829e54973fSEric Joyner DEVMETHOD(ifdi_tx_queue_intr_enable, ice_subif_if_tx_queue_intr_enable), 33839e54973fSEric Joyner DEVMETHOD(ifdi_init, ice_subif_if_init), 33849e54973fSEric Joyner DEVMETHOD(ifdi_stop, ice_subif_if_stop), 33859e54973fSEric Joyner DEVMETHOD(ifdi_queues_free, ice_subif_if_queues_free), 33869e54973fSEric Joyner DEVMETHOD(ifdi_media_status, ice_subif_if_media_status), 33879e54973fSEric Joyner DEVMETHOD(ifdi_promisc_set, ice_subif_if_promisc_set), 33889e54973fSEric Joyner }; 33899e54973fSEric Joyner 33909e54973fSEric Joyner /** 33919e54973fSEric Joyner * @var ice_iflib_subif_driver 33929e54973fSEric Joyner * @brief driver structure for the iflib stack 33939e54973fSEric Joyner * 33949e54973fSEric Joyner * driver_t definition used to setup the iflib device methods. 33959e54973fSEric Joyner */ 33969e54973fSEric Joyner static driver_t ice_iflib_subif_driver = { 33979e54973fSEric Joyner .name = "ice_subif", 33989e54973fSEric Joyner .methods = ice_iflib_subif_methods, 33999e54973fSEric Joyner .size = sizeof(struct ice_mirr_if), 34009e54973fSEric Joyner }; 34019e54973fSEric Joyner 34029e54973fSEric Joyner /** 34039e54973fSEric Joyner * @var ice_subif_sctx 34049e54973fSEric Joyner * @brief ice driver shared context 34059e54973fSEric Joyner * 34069e54973fSEric Joyner * Similar to the existing ice_sctx, this structure has these differences: 34079e54973fSEric Joyner * - isc_admin_intrcnt is set to 0 34089e54973fSEric Joyner * - Uses subif iflib driver methods 34099e54973fSEric Joyner * - Flagged as a VF for iflib 34109e54973fSEric Joyner */ 34119e54973fSEric Joyner static struct if_shared_ctx ice_subif_sctx = { 34129e54973fSEric Joyner .isc_magic = IFLIB_MAGIC, 34139e54973fSEric Joyner .isc_q_align = PAGE_SIZE, 34149e54973fSEric Joyner 34159e54973fSEric Joyner .isc_tx_maxsize = ICE_MAX_FRAME_SIZE, 34169e54973fSEric Joyner .isc_tx_maxsegsize = ICE_MAX_FRAME_SIZE, 34179e54973fSEric Joyner .isc_tso_maxsize = ICE_TSO_SIZE + sizeof(struct ether_vlan_header), 34189e54973fSEric Joyner .isc_tso_maxsegsize = ICE_MAX_DMA_SEG_SIZE, 34199e54973fSEric Joyner 34209e54973fSEric Joyner .isc_rx_maxsize = ICE_MAX_FRAME_SIZE, 34219e54973fSEric Joyner .isc_rx_nsegments = ICE_MAX_RX_SEGS, 34229e54973fSEric Joyner .isc_rx_maxsegsize = ICE_MAX_FRAME_SIZE, 34239e54973fSEric Joyner 34249e54973fSEric Joyner .isc_nfl = 1, 34259e54973fSEric Joyner .isc_ntxqs = 1, 34269e54973fSEric Joyner .isc_nrxqs = 1, 34279e54973fSEric Joyner 34289e54973fSEric Joyner .isc_admin_intrcnt = 0, 34299e54973fSEric Joyner .isc_vendor_info = ice_vendor_info_array, 34309e54973fSEric Joyner .isc_driver_version = __DECONST(char *, ice_driver_version), 34319e54973fSEric Joyner .isc_driver = &ice_iflib_subif_driver, 34329e54973fSEric Joyner 34339e54973fSEric Joyner .isc_flags = IFLIB_NEED_SCRATCH | IFLIB_TSO_INIT_IP | 34349e54973fSEric Joyner IFLIB_ADMIN_ALWAYS_RUN | IFLIB_SKIP_MSIX | 34359e54973fSEric Joyner IFLIB_IS_VF, 34369e54973fSEric Joyner 34379e54973fSEric Joyner .isc_nrxd_min = {ICE_MIN_DESC_COUNT}, 34389e54973fSEric Joyner .isc_ntxd_min = {ICE_MIN_DESC_COUNT}, 34399e54973fSEric Joyner .isc_nrxd_max = {ICE_IFLIB_MAX_DESC_COUNT}, 34409e54973fSEric Joyner .isc_ntxd_max = {ICE_IFLIB_MAX_DESC_COUNT}, 34419e54973fSEric Joyner .isc_nrxd_default = {ICE_DEFAULT_DESC_COUNT}, 34429e54973fSEric Joyner .isc_ntxd_default = {ICE_DEFAULT_DESC_COUNT}, 34439e54973fSEric Joyner }; 34449e54973fSEric Joyner 34459e54973fSEric Joyner static void * 34469e54973fSEric Joyner ice_subif_register(device_t dev __unused) 34479e54973fSEric Joyner { 34489e54973fSEric Joyner return (&ice_subif_sctx); 34499e54973fSEric Joyner } 34509e54973fSEric Joyner 34519e54973fSEric Joyner static void 34529e54973fSEric Joyner ice_subif_setup_scctx(struct ice_mirr_if *mif) 34539e54973fSEric Joyner { 34549e54973fSEric Joyner if_softc_ctx_t scctx = mif->subscctx; 34559e54973fSEric Joyner 34569e54973fSEric Joyner scctx->isc_txrx = &ice_subif_txrx; 34579e54973fSEric Joyner 34589e54973fSEric Joyner scctx->isc_capenable = ICE_FULL_CAPS; 34599e54973fSEric Joyner scctx->isc_tx_csum_flags = ICE_CSUM_OFFLOAD; 34609e54973fSEric Joyner 34619e54973fSEric Joyner scctx->isc_ntxqsets = 4; 34629e54973fSEric Joyner scctx->isc_nrxqsets = 4; 34639e54973fSEric Joyner scctx->isc_vectors = scctx->isc_nrxqsets; 34649e54973fSEric Joyner 34659e54973fSEric Joyner scctx->isc_ntxqsets_max = 256; 34669e54973fSEric Joyner scctx->isc_nrxqsets_max = 256; 34679e54973fSEric Joyner 34689e54973fSEric Joyner scctx->isc_txqsizes[0] = roundup2(scctx->isc_ntxd[0] 34699e54973fSEric Joyner * sizeof(struct ice_tx_desc), DBA_ALIGN); 34709e54973fSEric Joyner scctx->isc_rxqsizes[0] = roundup2(scctx->isc_nrxd[0] 34719e54973fSEric Joyner * sizeof(union ice_32b_rx_flex_desc), DBA_ALIGN); 34729e54973fSEric Joyner 34739e54973fSEric Joyner scctx->isc_tx_nsegments = ICE_MAX_TX_SEGS; 34749e54973fSEric Joyner scctx->isc_tx_tso_segments_max = ICE_MAX_TSO_SEGS; 34759e54973fSEric Joyner scctx->isc_tx_tso_size_max = ICE_TSO_SIZE; 34769e54973fSEric Joyner scctx->isc_tx_tso_segsize_max = ICE_MAX_DMA_SEG_SIZE; 34779e54973fSEric Joyner } 34789e54973fSEric Joyner 34799e54973fSEric Joyner static int 34809e54973fSEric Joyner ice_subif_if_attach_pre(if_ctx_t ctx) 34819e54973fSEric Joyner { 34829e54973fSEric Joyner struct ice_mirr_if *mif = (struct ice_mirr_if *)iflib_get_softc(ctx); 34839e54973fSEric Joyner device_t dev = iflib_get_dev(ctx); 34849e54973fSEric Joyner 34859e54973fSEric Joyner mif->subctx = ctx; 34869e54973fSEric Joyner mif->subdev = dev; 34879e54973fSEric Joyner mif->subscctx = iflib_get_softc_ctx(ctx); 34889e54973fSEric Joyner 34899e54973fSEric Joyner /* Setup the iflib softc context structure */ 34909e54973fSEric Joyner ice_subif_setup_scctx(mif); 34919e54973fSEric Joyner 34929e54973fSEric Joyner return (0); 34939e54973fSEric Joyner } 34949e54973fSEric Joyner 34959e54973fSEric Joyner static int 34969e54973fSEric Joyner ice_subif_if_attach_post(if_ctx_t ctx __unused) 34979e54973fSEric Joyner { 34989e54973fSEric Joyner return (0); 34999e54973fSEric Joyner } 35009e54973fSEric Joyner 35019e54973fSEric Joyner /** 35029e54973fSEric Joyner * ice_destroy_mirror_interface - destroy mirror interface 35039e54973fSEric Joyner * @sc: driver private data 35049e54973fSEric Joyner * 35059e54973fSEric Joyner * Destroys all resources associated with the mirroring interface. 35069e54973fSEric Joyner * Will not exit early on failure. 35079e54973fSEric Joyner * 35089e54973fSEric Joyner * @pre: Mirror interface already exists and is initialized. 35099e54973fSEric Joyner */ 35109e54973fSEric Joyner void 35119e54973fSEric Joyner ice_destroy_mirror_interface(struct ice_softc *sc) 35129e54973fSEric Joyner { 35139e54973fSEric Joyner struct ice_mirr_if *mif = sc->mirr_if; 35149e54973fSEric Joyner struct ice_vsi *vsi = mif->vsi; 35159e54973fSEric Joyner bool is_locked = false; 35169e54973fSEric Joyner int ret; 35179e54973fSEric Joyner 35189e54973fSEric Joyner is_locked = sx_xlocked(sc->iflib_ctx_lock); 35199e54973fSEric Joyner if (is_locked) 35209e54973fSEric Joyner IFLIB_CTX_UNLOCK(sc); 35219e54973fSEric Joyner 35229e54973fSEric Joyner if (mif->ifp) { 35239e54973fSEric Joyner ret = iflib_device_deregister(mif->subctx); 35249e54973fSEric Joyner if (ret) { 35259e54973fSEric Joyner device_printf(sc->dev, 35269e54973fSEric Joyner "iflib_device_deregister for mirror interface failed: %d\n", 35279e54973fSEric Joyner ret); 35289e54973fSEric Joyner } 35299e54973fSEric Joyner } 35309e54973fSEric Joyner 35319e54973fSEric Joyner bus_topo_lock(); 35329e54973fSEric Joyner ret = device_delete_child(sc->dev, mif->subdev); 35339e54973fSEric Joyner bus_topo_unlock(); 35349e54973fSEric Joyner if (ret) { 35359e54973fSEric Joyner device_printf(sc->dev, 35369e54973fSEric Joyner "device_delete_child for mirror interface failed: %d\n", 35379e54973fSEric Joyner ret); 35389e54973fSEric Joyner } 35399e54973fSEric Joyner 35409e54973fSEric Joyner if (is_locked) 35419e54973fSEric Joyner IFLIB_CTX_LOCK(sc); 35429e54973fSEric Joyner 35439e54973fSEric Joyner if (mif->if_imap) { 35449e54973fSEric Joyner free(mif->if_imap, M_ICE); 35459e54973fSEric Joyner mif->if_imap = NULL; 35469e54973fSEric Joyner } 35479e54973fSEric Joyner if (mif->os_imap) { 35489e54973fSEric Joyner free(mif->os_imap, M_ICE); 35499e54973fSEric Joyner mif->os_imap = NULL; 35509e54973fSEric Joyner } 35519e54973fSEric Joyner 35529e54973fSEric Joyner /* These are freed via ice_subif_queues_free_subif 35539e54973fSEric Joyner * vsi: 35549e54973fSEric Joyner * - rx_irqvs 35559e54973fSEric Joyner * - tx_queues 35569e54973fSEric Joyner * - rx_queues 35579e54973fSEric Joyner */ 35589e54973fSEric Joyner ice_release_vsi(vsi); 35599e54973fSEric Joyner 35609e54973fSEric Joyner free(mif, M_ICE); 35619e54973fSEric Joyner sc->mirr_if = NULL; 35629e54973fSEric Joyner 35639e54973fSEric Joyner } 35649e54973fSEric Joyner 35659e54973fSEric Joyner /** 35669e54973fSEric Joyner * ice_setup_mirror_vsi - Initialize mirror VSI 35679e54973fSEric Joyner * @mif: driver private data for mirror interface 35689e54973fSEric Joyner * 35699e54973fSEric Joyner * Allocates a VSI for a mirror interface, and sets that VSI up for use as a 35709e54973fSEric Joyner * mirror for the main PF VSI. 35719e54973fSEric Joyner * 35729e54973fSEric Joyner * Returns 0 on success, or a standard error code on failure. 35739e54973fSEric Joyner */ 35749e54973fSEric Joyner static int 35759e54973fSEric Joyner ice_setup_mirror_vsi(struct ice_mirr_if *mif) 35769e54973fSEric Joyner { 35779e54973fSEric Joyner struct ice_softc *sc = mif->back; 35789e54973fSEric Joyner device_t dev = sc->dev; 35799e54973fSEric Joyner struct ice_vsi *vsi; 35809e54973fSEric Joyner int ret = 0; 35819e54973fSEric Joyner 35829e54973fSEric Joyner /* vsi is for the new mirror vsi, not the PF's main VSI */ 35839e54973fSEric Joyner vsi = ice_alloc_vsi(sc, ICE_VSI_VMDQ2); 35849e54973fSEric Joyner if (!vsi) { 35859e54973fSEric Joyner /* Already prints an error message */ 35869e54973fSEric Joyner return (ENOMEM); 35879e54973fSEric Joyner } 35889e54973fSEric Joyner mif->vsi = vsi; 35899e54973fSEric Joyner 35909e54973fSEric Joyner /* Reserve VSI queue allocation from PF queues */ 35915f97656fSZhenlei Huang ice_alloc_vsi_qmap(vsi, ICE_DEFAULT_VF_QUEUES, ICE_DEFAULT_VF_QUEUES); 35929e54973fSEric Joyner vsi->num_tx_queues = vsi->num_rx_queues = ICE_DEFAULT_VF_QUEUES; 35939e54973fSEric Joyner 35949e54973fSEric Joyner /* Assign Tx queues from PF space */ 35959e54973fSEric Joyner ret = ice_resmgr_assign_scattered(&sc->tx_qmgr, vsi->tx_qmap, 35969e54973fSEric Joyner vsi->num_tx_queues); 35979e54973fSEric Joyner if (ret) { 35989e54973fSEric Joyner device_printf(dev, "Unable to assign mirror VSI Tx queues: %s\n", 35999e54973fSEric Joyner ice_err_str(ret)); 36009e54973fSEric Joyner goto release_vsi; 36019e54973fSEric Joyner } 36029e54973fSEric Joyner /* Assign Rx queues from PF space */ 36039e54973fSEric Joyner ret = ice_resmgr_assign_scattered(&sc->rx_qmgr, vsi->rx_qmap, 36049e54973fSEric Joyner vsi->num_rx_queues); 36059e54973fSEric Joyner if (ret) { 36069e54973fSEric Joyner device_printf(dev, "Unable to assign mirror VSI Rx queues: %s\n", 36079e54973fSEric Joyner ice_err_str(ret)); 36089e54973fSEric Joyner goto release_vsi; 36099e54973fSEric Joyner } 36109e54973fSEric Joyner vsi->qmap_type = ICE_RESMGR_ALLOC_SCATTERED; 36119e54973fSEric Joyner vsi->max_frame_size = ICE_MAX_FRAME_SIZE; 36129e54973fSEric Joyner 36139e54973fSEric Joyner ret = ice_initialize_vsi(vsi); 36149e54973fSEric Joyner if (ret) { 36159e54973fSEric Joyner device_printf(dev, "%s: Error in ice_initialize_vsi for mirror VSI: %s\n", 36169e54973fSEric Joyner __func__, ice_err_str(ret)); 36179e54973fSEric Joyner goto release_vsi; 36189e54973fSEric Joyner } 36199e54973fSEric Joyner 36209e54973fSEric Joyner /* Setup this VSI for receiving traffic */ 36219e54973fSEric Joyner ret = ice_config_rss(vsi); 36229e54973fSEric Joyner if (ret) { 36239e54973fSEric Joyner device_printf(dev, 36249e54973fSEric Joyner "Unable to configure RSS for mirror VSI: %s\n", 36259e54973fSEric Joyner ice_err_str(ret)); 36269e54973fSEric Joyner goto release_vsi; 36279e54973fSEric Joyner } 36289e54973fSEric Joyner 36299e54973fSEric Joyner /* Set HW rules for mirroring traffic */ 36309e54973fSEric Joyner vsi->mirror_src_vsi = sc->pf_vsi.idx; 36319e54973fSEric Joyner 36329e54973fSEric Joyner ice_debug(&sc->hw, ICE_DBG_INIT, 36339e54973fSEric Joyner "Configuring mirroring from VSI %d to %d\n", 36349e54973fSEric Joyner vsi->mirror_src_vsi, vsi->idx); 36359e54973fSEric Joyner ice_debug(&sc->hw, ICE_DBG_INIT, "(HW num: VSI %d to %d)\n", 36369e54973fSEric Joyner ice_get_hw_vsi_num(&sc->hw, vsi->mirror_src_vsi), 36379e54973fSEric Joyner ice_get_hw_vsi_num(&sc->hw, vsi->idx)); 36389e54973fSEric Joyner 36399e54973fSEric Joyner ret = ice_setup_vsi_mirroring(vsi); 36409e54973fSEric Joyner if (ret) { 36419e54973fSEric Joyner device_printf(dev, 36429e54973fSEric Joyner "Unable to configure mirroring for VSI: %s\n", 36439e54973fSEric Joyner ice_err_str(ret)); 36449e54973fSEric Joyner goto release_vsi; 36459e54973fSEric Joyner } 36469e54973fSEric Joyner 36479e54973fSEric Joyner return (0); 36489e54973fSEric Joyner 36499e54973fSEric Joyner release_vsi: 36509e54973fSEric Joyner ice_release_vsi(vsi); 36519e54973fSEric Joyner mif->vsi = NULL; 36529e54973fSEric Joyner return (ret); 36539e54973fSEric Joyner } 36549e54973fSEric Joyner 36559e54973fSEric Joyner /** 36569e54973fSEric Joyner * ice_create_mirror_interface - Initialize mirror interface 36579e54973fSEric Joyner * @sc: driver private data 36589e54973fSEric Joyner * 36599e54973fSEric Joyner * Creates and sets up a mirror interface that will mirror traffic from 36609e54973fSEric Joyner * the main PF interface. Includes a call to iflib_device_register() in order 36619e54973fSEric Joyner * to setup necessary iflib structures for this new interface as well. 36629e54973fSEric Joyner * 36639e54973fSEric Joyner * If it returns successfully, a new interface will be created and will show 36649e54973fSEric Joyner * up in the ifconfig interface list. 36659e54973fSEric Joyner * 36669e54973fSEric Joyner * Returns 0 on success, or a standard error code on failure. 36679e54973fSEric Joyner */ 36689e54973fSEric Joyner int 36699e54973fSEric Joyner ice_create_mirror_interface(struct ice_softc *sc) 36709e54973fSEric Joyner { 36719e54973fSEric Joyner device_t dev = sc->dev; 36729e54973fSEric Joyner struct ice_mirr_if *mif; 36739e54973fSEric Joyner struct ifmedia *media; 36749e54973fSEric Joyner struct sbuf *sb; 36759e54973fSEric Joyner int ret = 0; 36769e54973fSEric Joyner 36779e54973fSEric Joyner mif = (struct ice_mirr_if *)malloc(sizeof(*mif), M_ICE, M_ZERO | M_NOWAIT); 36789e54973fSEric Joyner if (!mif) { 36799e54973fSEric Joyner device_printf(dev, "malloc() error allocating mirror interface\n"); 36809e54973fSEric Joyner return (ENOMEM); 36819e54973fSEric Joyner } 36829e54973fSEric Joyner 36839e54973fSEric Joyner /* Set pointers */ 36849e54973fSEric Joyner sc->mirr_if = mif; 36859e54973fSEric Joyner mif->back = sc; 36869e54973fSEric Joyner 36879e54973fSEric Joyner /* Do early setup because these will be called during iflib_device_register(): 36889e54973fSEric Joyner * - ice_subif_if_tx_queues_alloc 36899e54973fSEric Joyner * - ice_subif_if_rx_queues_alloc 36909e54973fSEric Joyner */ 36919e54973fSEric Joyner ret = ice_setup_mirror_vsi(mif); 36929e54973fSEric Joyner if (ret) 36939e54973fSEric Joyner goto out; 36949e54973fSEric Joyner 36959e54973fSEric Joyner /* Determine name for new interface: 36969e54973fSEric Joyner * (base interface name)(modifier name)(modifier unit number) 36979e54973fSEric Joyner * e.g. for ice0 with a new mirror interface (modifier m) 36989e54973fSEric Joyner * of index 0, this equals "ice0m0" 36999e54973fSEric Joyner */ 37009e54973fSEric Joyner sb = sbuf_new_auto(); 37019e54973fSEric Joyner MPASS(sb != NULL); 37029e54973fSEric Joyner sbuf_printf(sb, "%sm", device_get_nameunit(dev)); 37039e54973fSEric Joyner sbuf_finish(sb); 37049e54973fSEric Joyner 37059e54973fSEric Joyner bus_topo_lock(); 37069e54973fSEric Joyner mif->subdev = device_add_child(dev, sbuf_data(sb), 0); 37079e54973fSEric Joyner bus_topo_unlock(); 37089e54973fSEric Joyner 37099e54973fSEric Joyner if (!mif->subdev) { 37109e54973fSEric Joyner device_printf(dev, "device_add_child failed for %s0\n", sbuf_data(sb)); 37119e54973fSEric Joyner sbuf_delete(sb); 37129e54973fSEric Joyner free(mif, M_ICE); 37139e54973fSEric Joyner sc->mirr_if = NULL; 37149e54973fSEric Joyner return (ENOMEM); 37159e54973fSEric Joyner } 37169e54973fSEric Joyner sbuf_delete(sb); 37179e54973fSEric Joyner 37189e54973fSEric Joyner device_set_driver(mif->subdev, &ice_subif_driver); 37199e54973fSEric Joyner 37209e54973fSEric Joyner /* Use iflib_device_register() directly because the driver already 37219e54973fSEric Joyner * has an initialized softc to pass to iflib 37229e54973fSEric Joyner */ 37239e54973fSEric Joyner ret = iflib_device_register(mif->subdev, mif, &ice_subif_sctx, &mif->subctx); 37249e54973fSEric Joyner if (ret) 37259e54973fSEric Joyner goto out; 37269e54973fSEric Joyner 37279e54973fSEric Joyner /* Indicate that created interface will be just for monitoring */ 37289e54973fSEric Joyner mif->ifp = iflib_get_ifp(mif->subctx); 37299e54973fSEric Joyner if_setflagbits(mif->ifp, IFF_MONITOR, 0); 37309e54973fSEric Joyner 37319e54973fSEric Joyner /* Use autoselect media by default */ 37329e54973fSEric Joyner media = iflib_get_media(mif->subctx); 37339e54973fSEric Joyner ifmedia_add(media, IFM_ETHER | IFM_AUTO, 0, NULL); 37349e54973fSEric Joyner ifmedia_set(media, IFM_ETHER | IFM_AUTO); 37359e54973fSEric Joyner 37369e54973fSEric Joyner device_printf(dev, "Created dev %s and ifnet %s for mirroring\n", 37379e54973fSEric Joyner device_get_nameunit(mif->subdev), if_name(mif->ifp)); 37389e54973fSEric Joyner 37399e54973fSEric Joyner ice_add_vsi_sysctls(mif->vsi); 37409e54973fSEric Joyner 37419e54973fSEric Joyner ret = ice_wire_mirror_intrs(mif); 37429e54973fSEric Joyner if (ret) 37439e54973fSEric Joyner goto out; 37449e54973fSEric Joyner 37459e54973fSEric Joyner mif->if_attached = true; 37469e54973fSEric Joyner return (0); 37479e54973fSEric Joyner 37489e54973fSEric Joyner out: 37499e54973fSEric Joyner ice_destroy_mirror_interface(sc); 37509e54973fSEric Joyner return (ret); 37519e54973fSEric Joyner } 37529e54973fSEric Joyner 37539e54973fSEric Joyner /** 37549e54973fSEric Joyner * ice_wire_mirror_intrs 37559e54973fSEric Joyner * @mif: driver private subinterface structure 37569e54973fSEric Joyner * 37579e54973fSEric Joyner * Helper function that sets up driver interrupt data and calls 37589e54973fSEric Joyner * into iflib in order to setup interrupts in its data structures as well. 37599e54973fSEric Joyner * 37609e54973fSEric Joyner * Like ice_if_msix_intr_assign, currently requires that we get at least the same 37619e54973fSEric Joyner * number of vectors as we have queues, and that we always have the same number 37629e54973fSEric Joyner * of Tx and Rx queues. Unlike that function, this calls a special 37639e54973fSEric Joyner * iflib_irq_alloc_generic_subif() function for RX interrupts because the 37649e54973fSEric Joyner * driver needs to get MSI-X resources from the parent device. 37659e54973fSEric Joyner * 37669e54973fSEric Joyner * Tx queues use a softirq instead of using their own hardware interrupt so that 37679e54973fSEric Joyner * remains unchanged. 37689e54973fSEric Joyner * 37699e54973fSEric Joyner * Returns 0 on success or an error code from iflib_irq_alloc_generic_subctx() 37709e54973fSEric Joyner * on failure. 37719e54973fSEric Joyner */ 37729e54973fSEric Joyner static int 37739e54973fSEric Joyner ice_wire_mirror_intrs(struct ice_mirr_if *mif) 37749e54973fSEric Joyner { 37759e54973fSEric Joyner struct ice_softc *sc = mif->back; 37769e54973fSEric Joyner struct ice_hw *hw = &sc->hw; 37779e54973fSEric Joyner struct ice_vsi *vsi = mif->vsi; 37789e54973fSEric Joyner device_t dev = mif->subdev; 37799e54973fSEric Joyner int err, i, rid; 37809e54973fSEric Joyner 37819e54973fSEric Joyner if_ctx_t ctx = mif->subctx; 37829e54973fSEric Joyner 37839e54973fSEric Joyner ice_debug(hw, ICE_DBG_INIT, "%s: Last rid: %d\n", __func__, sc->last_rid); 37849e54973fSEric Joyner 37859e54973fSEric Joyner rid = sc->last_rid + 1; 37869e54973fSEric Joyner for (i = 0; i < vsi->num_rx_queues; i++, rid++) { 37879e54973fSEric Joyner struct ice_rx_queue *rxq = &vsi->rx_queues[i]; 37889e54973fSEric Joyner struct ice_tx_queue *txq = &vsi->tx_queues[i]; 37899e54973fSEric Joyner char irq_name[16]; 37909e54973fSEric Joyner 37919e54973fSEric Joyner // TODO: Change to use dynamic interface number 37929e54973fSEric Joyner snprintf(irq_name, sizeof(irq_name), "m0rxq%d", i); 37939e54973fSEric Joyner /* First arg is parent device (physical port's) iflib ctx */ 37949e54973fSEric Joyner err = iflib_irq_alloc_generic_subctx(sc->ctx, ctx, 37959e54973fSEric Joyner &mif->rx_irqvs[i].irq, rid, IFLIB_INTR_RXTX, ice_msix_que, 37969e54973fSEric Joyner rxq, rxq->me, irq_name); 37979e54973fSEric Joyner if (err) { 37989e54973fSEric Joyner device_printf(dev, 37999e54973fSEric Joyner "Failed to allocate q int %d err: %s\n", 38009e54973fSEric Joyner i, ice_err_str(err)); 38019e54973fSEric Joyner i--; 38029e54973fSEric Joyner goto fail; 38039e54973fSEric Joyner } 38049e54973fSEric Joyner MPASS(rid - 1 > 0); 38059e54973fSEric Joyner /* Set vector number used in interrupt enable/disable functions */ 38069e54973fSEric Joyner mif->rx_irqvs[i].me = rid - 1; 38079e54973fSEric Joyner rxq->irqv = &mif->rx_irqvs[i]; 38089e54973fSEric Joyner 38099e54973fSEric Joyner bzero(irq_name, sizeof(irq_name)); 38109e54973fSEric Joyner snprintf(irq_name, sizeof(irq_name), "m0txq%d", i); 38119e54973fSEric Joyner iflib_softirq_alloc_generic(ctx, &mif->rx_irqvs[i].irq, 38129e54973fSEric Joyner IFLIB_INTR_TX, txq, txq->me, irq_name); 38139e54973fSEric Joyner txq->irqv = &mif->rx_irqvs[i]; 38149e54973fSEric Joyner } 38159e54973fSEric Joyner 38169e54973fSEric Joyner sc->last_rid = rid - 1; 38179e54973fSEric Joyner 38189e54973fSEric Joyner ice_debug(hw, ICE_DBG_INIT, "%s: New last rid: %d\n", __func__, 38199e54973fSEric Joyner sc->last_rid); 38209e54973fSEric Joyner 38219e54973fSEric Joyner return (0); 38229e54973fSEric Joyner 38239e54973fSEric Joyner fail: 38249e54973fSEric Joyner for (; i >= 0; i--) 38259e54973fSEric Joyner iflib_irq_free(ctx, &mif->rx_irqvs[i].irq); 38269e54973fSEric Joyner return (err); 38279e54973fSEric Joyner } 38289e54973fSEric Joyner 38299e54973fSEric Joyner /** 38309e54973fSEric Joyner * ice_subif_rebuild - Rebuild subinterface post reset 38319e54973fSEric Joyner * @sc: The device private softc 38329e54973fSEric Joyner * 38339e54973fSEric Joyner * Restore subinterface state after a reset occurred. 38349e54973fSEric Joyner * Restart the VSI and enable the mirroring. 38359e54973fSEric Joyner */ 38369e54973fSEric Joyner static int 38379e54973fSEric Joyner ice_subif_rebuild(struct ice_softc *sc) 38389e54973fSEric Joyner { 38399e54973fSEric Joyner struct ice_mirr_if *mif = (struct ice_mirr_if *)iflib_get_softc(sc->ctx); 38409e54973fSEric Joyner struct ice_vsi *vsi = sc->mirr_if->vsi; 38419e54973fSEric Joyner int err; 38429e54973fSEric Joyner 38439e54973fSEric Joyner err = ice_subif_rebuild_vsi_qmap(sc); 38449e54973fSEric Joyner if (err) { 38459e54973fSEric Joyner device_printf(sc->dev, "Unable to re-assign mirror VSI queues, err %s\n", 38469e54973fSEric Joyner ice_err_str(err)); 38479e54973fSEric Joyner return (err); 38489e54973fSEric Joyner } 38499e54973fSEric Joyner 38509e54973fSEric Joyner err = ice_initialize_vsi(vsi); 38519e54973fSEric Joyner if (err) { 38529e54973fSEric Joyner device_printf(sc->dev, "Unable to re-initialize mirror VSI, err %s\n", 38539e54973fSEric Joyner ice_err_str(err)); 38549e54973fSEric Joyner goto err_release_queue_allocations_subif; 38559e54973fSEric Joyner } 38569e54973fSEric Joyner 38579e54973fSEric Joyner err = ice_config_rss(vsi); 38589e54973fSEric Joyner if (err) { 38599e54973fSEric Joyner device_printf(sc->dev, 38609e54973fSEric Joyner "Unable to reconfigure RSS for the mirror VSI, err %s\n", 38619e54973fSEric Joyner ice_err_str(err)); 38629e54973fSEric Joyner goto err_deinit_subif_vsi; 38639e54973fSEric Joyner } 38649e54973fSEric Joyner 38659e54973fSEric Joyner vsi->mirror_src_vsi = sc->pf_vsi.idx; 38669e54973fSEric Joyner 38679e54973fSEric Joyner err = ice_setup_vsi_mirroring(vsi); 38689e54973fSEric Joyner if (err) { 38699e54973fSEric Joyner device_printf(sc->dev, 38709e54973fSEric Joyner "Unable to configure mirroring for VSI: %s\n", 38719e54973fSEric Joyner ice_err_str(err)); 38729e54973fSEric Joyner goto err_deinit_subif_vsi; 38739e54973fSEric Joyner } 38749e54973fSEric Joyner 38759e54973fSEric Joyner ice_set_state(&mif->state, ICE_STATE_SUBIF_NEEDS_REINIT); 38769e54973fSEric Joyner 38779e54973fSEric Joyner return (0); 38789e54973fSEric Joyner 38799e54973fSEric Joyner err_deinit_subif_vsi: 38809e54973fSEric Joyner ice_deinit_vsi(vsi); 38819e54973fSEric Joyner err_release_queue_allocations_subif: 38829e54973fSEric Joyner ice_resmgr_release_map(&sc->tx_qmgr, vsi->tx_qmap, 38839e54973fSEric Joyner sc->mirr_if->num_irq_vectors); 38849e54973fSEric Joyner ice_resmgr_release_map(&sc->rx_qmgr, vsi->rx_qmap, 38859e54973fSEric Joyner sc->mirr_if->num_irq_vectors); 38869e54973fSEric Joyner 38879e54973fSEric Joyner return (err); 38889e54973fSEric Joyner } 38899e54973fSEric Joyner 38909e54973fSEric Joyner /** 38919e54973fSEric Joyner * ice_subif_rebuild_vsi_qmap - Rebuild the mirror VSI queue mapping 38929e54973fSEric Joyner * @sc: the device softc pointer 38939e54973fSEric Joyner * 38949e54973fSEric Joyner * Loops over the Tx and Rx queues for the mirror VSI and reassigns the queue 38959e54973fSEric Joyner * mapping after a reset occurred. 38969e54973fSEric Joyner */ 38979e54973fSEric Joyner static int 38989e54973fSEric Joyner ice_subif_rebuild_vsi_qmap(struct ice_softc *sc) 38999e54973fSEric Joyner { 39009e54973fSEric Joyner struct ice_vsi *vsi = sc->mirr_if->vsi; 39019e54973fSEric Joyner struct ice_tx_queue *txq; 39029e54973fSEric Joyner struct ice_rx_queue *rxq; 39039e54973fSEric Joyner int err, i; 39049e54973fSEric Joyner 39059e54973fSEric Joyner err = ice_resmgr_assign_scattered(&sc->tx_qmgr, vsi->tx_qmap, sc->mirr_if->num_irq_vectors); 39069e54973fSEric Joyner if (err) { 39079e54973fSEric Joyner device_printf(sc->dev, "Unable to assign mirror VSI Tx queues: %s\n", 39089e54973fSEric Joyner ice_err_str(err)); 39099e54973fSEric Joyner return (err); 39109e54973fSEric Joyner } 39119e54973fSEric Joyner 39129e54973fSEric Joyner err = ice_resmgr_assign_scattered(&sc->rx_qmgr, vsi->rx_qmap, sc->mirr_if->num_irq_vectors); 39139e54973fSEric Joyner if (err) { 39149e54973fSEric Joyner device_printf(sc->dev, "Unable to assign mirror VSI Rx queues: %s\n", 39159e54973fSEric Joyner ice_err_str(err)); 39169e54973fSEric Joyner goto err_release_tx_queues; 39179e54973fSEric Joyner } 39189e54973fSEric Joyner 39199e54973fSEric Joyner vsi->qmap_type = ICE_RESMGR_ALLOC_SCATTERED; 39209e54973fSEric Joyner 39219e54973fSEric Joyner /* Re-assign Tx queue tail pointers */ 39229e54973fSEric Joyner for (i = 0, txq = vsi->tx_queues; i < vsi->num_tx_queues; i++, txq++) 39239e54973fSEric Joyner txq->tail = QTX_COMM_DBELL(vsi->tx_qmap[i]); 39249e54973fSEric Joyner 39259e54973fSEric Joyner /* Re-assign Rx queue tail pointers */ 39269e54973fSEric Joyner for (i = 0, rxq = vsi->rx_queues; i < vsi->num_rx_queues; i++, rxq++) 39279e54973fSEric Joyner rxq->tail = QRX_TAIL(vsi->rx_qmap[i]); 39289e54973fSEric Joyner 39299e54973fSEric Joyner return (0); 39309e54973fSEric Joyner 39319e54973fSEric Joyner err_release_tx_queues: 39329e54973fSEric Joyner ice_resmgr_release_map(&sc->tx_qmgr, vsi->tx_qmap, vsi->num_tx_queues); 39339e54973fSEric Joyner 39349e54973fSEric Joyner return (err); 39359e54973fSEric Joyner } 39369e54973fSEric Joyner 39379e54973fSEric Joyner /** 39389e54973fSEric Joyner * ice_subif_if_tx_queues_alloc - Allocate Tx queue memory for subinterfaces 39399e54973fSEric Joyner * @ctx: iflib context structure 39409e54973fSEric Joyner * @vaddrs: virtual addresses for the queue memory 39419e54973fSEric Joyner * @paddrs: physical addresses for the queue memory 39429e54973fSEric Joyner * @ntxqs: the number of Tx queues per set (should always be 1) 39439e54973fSEric Joyner * @ntxqsets: the number of Tx queue sets to allocate 39449e54973fSEric Joyner * 39459e54973fSEric Joyner * See ice_if_tx_queues_alloc() description. Similar to that function, but 39469e54973fSEric Joyner * for subinterfaces instead. 39479e54973fSEric Joyner */ 39489e54973fSEric Joyner static int 39499e54973fSEric Joyner ice_subif_if_tx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs, uint64_t *paddrs, 39509e54973fSEric Joyner int __invariant_only ntxqs, int ntxqsets) 39519e54973fSEric Joyner { 39529e54973fSEric Joyner struct ice_mirr_if *mif = (struct ice_mirr_if *)iflib_get_softc(ctx); 39539e54973fSEric Joyner struct ice_tx_queue *txq; 39549e54973fSEric Joyner device_t dev = mif->subdev; 39559e54973fSEric Joyner struct ice_vsi *vsi; 39569e54973fSEric Joyner int err, i, j; 39579e54973fSEric Joyner 39589e54973fSEric Joyner MPASS(mif != NULL); 39599e54973fSEric Joyner MPASS(ntxqs == 1); 39609e54973fSEric Joyner MPASS(mif->subscctx->isc_ntxd[0] <= ICE_MAX_DESC_COUNT); 39619e54973fSEric Joyner 39629e54973fSEric Joyner vsi = mif->vsi; 39639e54973fSEric Joyner 39649e54973fSEric Joyner MPASS(vsi->num_tx_queues == ntxqsets); 39659e54973fSEric Joyner 39669e54973fSEric Joyner /* Allocate queue structure memory */ 39679e54973fSEric Joyner if (!(vsi->tx_queues = 39689e54973fSEric Joyner (struct ice_tx_queue *)malloc(sizeof(struct ice_tx_queue) * ntxqsets, M_ICE, M_NOWAIT | M_ZERO))) { 39699e54973fSEric Joyner device_printf(dev, "%s: Unable to allocate Tx queue memory for subfunction\n", 39709e54973fSEric Joyner __func__); 39719e54973fSEric Joyner return (ENOMEM); 39729e54973fSEric Joyner } 39739e54973fSEric Joyner 39749e54973fSEric Joyner /* Allocate report status arrays */ 39759e54973fSEric Joyner for (i = 0, txq = vsi->tx_queues; i < ntxqsets; i++, txq++) { 39769e54973fSEric Joyner if (!(txq->tx_rsq = 39779e54973fSEric Joyner (uint16_t *)malloc(sizeof(uint16_t) * mif->subscctx->isc_ntxd[0], M_ICE, M_NOWAIT))) { 39789e54973fSEric Joyner device_printf(dev, 39799e54973fSEric Joyner "%s: Unable to allocate tx_rsq memory for subfunction\n", __func__); 39809e54973fSEric Joyner err = ENOMEM; 39819e54973fSEric Joyner goto free_tx_queues; 39829e54973fSEric Joyner } 39839e54973fSEric Joyner /* Initialize report status array */ 39849e54973fSEric Joyner for (j = 0; j < mif->subscctx->isc_ntxd[0]; j++) 39859e54973fSEric Joyner txq->tx_rsq[j] = QIDX_INVALID; 39869e54973fSEric Joyner } 39879e54973fSEric Joyner 39889e54973fSEric Joyner /* Add Tx queue sysctls context */ 39899e54973fSEric Joyner ice_vsi_add_txqs_ctx(vsi); 39909e54973fSEric Joyner 39919e54973fSEric Joyner for (i = 0, txq = vsi->tx_queues; i < ntxqsets; i++, txq++) { 39929e54973fSEric Joyner /* q_handle == me when only one TC */ 39939e54973fSEric Joyner txq->me = txq->q_handle = i; 39949e54973fSEric Joyner txq->vsi = vsi; 39959e54973fSEric Joyner 39969e54973fSEric Joyner /* store the queue size for easier access */ 39979e54973fSEric Joyner txq->desc_count = mif->subscctx->isc_ntxd[0]; 39989e54973fSEric Joyner 39999e54973fSEric Joyner /* get the virtual and physical address of the hardware queues */ 40009e54973fSEric Joyner txq->tail = QTX_COMM_DBELL(vsi->tx_qmap[i]); 40019e54973fSEric Joyner txq->tx_base = (struct ice_tx_desc *)vaddrs[i]; 40029e54973fSEric Joyner txq->tx_paddr = paddrs[i]; 40039e54973fSEric Joyner 40049e54973fSEric Joyner ice_add_txq_sysctls(txq); 40059e54973fSEric Joyner } 40069e54973fSEric Joyner 40079e54973fSEric Joyner return (0); 40089e54973fSEric Joyner 40099e54973fSEric Joyner free_tx_queues: 40109e54973fSEric Joyner for (i = 0, txq = vsi->tx_queues; i < ntxqsets; i++, txq++) { 40119e54973fSEric Joyner if (txq->tx_rsq != NULL) { 40129e54973fSEric Joyner free(txq->tx_rsq, M_ICE); 40139e54973fSEric Joyner txq->tx_rsq = NULL; 40149e54973fSEric Joyner } 40159e54973fSEric Joyner } 40169e54973fSEric Joyner free(vsi->tx_queues, M_ICE); 40179e54973fSEric Joyner vsi->tx_queues = NULL; 40189e54973fSEric Joyner return (err); 40199e54973fSEric Joyner } 40209e54973fSEric Joyner 40219e54973fSEric Joyner /** 40229e54973fSEric Joyner * ice_subif_if_rx_queues_alloc - Allocate Rx queue memory for subinterfaces 40239e54973fSEric Joyner * @ctx: iflib context structure 40249e54973fSEric Joyner * @vaddrs: virtual addresses for the queue memory 40259e54973fSEric Joyner * @paddrs: physical addresses for the queue memory 40269e54973fSEric Joyner * @nrxqs: number of Rx queues per set (should always be 1) 40279e54973fSEric Joyner * @nrxqsets: number of Rx queue sets to allocate 40289e54973fSEric Joyner * 40299e54973fSEric Joyner * See ice_if_rx_queues_alloc() for general summary; this is similar to that 40309e54973fSEric Joyner * but implemented for subinterfaces. 40319e54973fSEric Joyner */ 40329e54973fSEric Joyner static int 40339e54973fSEric Joyner ice_subif_if_rx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs, uint64_t *paddrs, 40349e54973fSEric Joyner int __invariant_only nrxqs, int nrxqsets) 40359e54973fSEric Joyner { 40369e54973fSEric Joyner struct ice_mirr_if *mif = (struct ice_mirr_if *)iflib_get_softc(ctx); 40379e54973fSEric Joyner struct ice_rx_queue *rxq; 40389e54973fSEric Joyner device_t dev = mif->subdev; 40399e54973fSEric Joyner struct ice_vsi *vsi; 40409e54973fSEric Joyner int i; 40419e54973fSEric Joyner 40429e54973fSEric Joyner MPASS(mif != NULL); 40439e54973fSEric Joyner MPASS(nrxqs == 1); 40449e54973fSEric Joyner MPASS(mif->subscctx->isc_nrxd[0] <= ICE_MAX_DESC_COUNT); 40459e54973fSEric Joyner 40469e54973fSEric Joyner vsi = mif->vsi; 40479e54973fSEric Joyner 40489e54973fSEric Joyner MPASS(vsi->num_rx_queues == nrxqsets); 40499e54973fSEric Joyner 40509e54973fSEric Joyner /* Allocate queue structure memory */ 40519e54973fSEric Joyner if (!(vsi->rx_queues = 40529e54973fSEric Joyner (struct ice_rx_queue *) malloc(sizeof(struct ice_rx_queue) * nrxqsets, M_ICE, M_NOWAIT | M_ZERO))) { 40539e54973fSEric Joyner device_printf(dev, "%s: Unable to allocate Rx queue memory for subfunction\n", 40549e54973fSEric Joyner __func__); 40559e54973fSEric Joyner return (ENOMEM); 40569e54973fSEric Joyner } 40579e54973fSEric Joyner 40589e54973fSEric Joyner /* Add Rx queue sysctls context */ 40599e54973fSEric Joyner ice_vsi_add_rxqs_ctx(vsi); 40609e54973fSEric Joyner 40619e54973fSEric Joyner for (i = 0, rxq = vsi->rx_queues; i < nrxqsets; i++, rxq++) { 40629e54973fSEric Joyner rxq->me = i; 40639e54973fSEric Joyner rxq->vsi = vsi; 40649e54973fSEric Joyner 40659e54973fSEric Joyner /* store the queue size for easier access */ 40669e54973fSEric Joyner rxq->desc_count = mif->subscctx->isc_nrxd[0]; 40679e54973fSEric Joyner 40689e54973fSEric Joyner /* get the virtual and physical address of the hardware queues */ 40699e54973fSEric Joyner rxq->tail = QRX_TAIL(vsi->rx_qmap[i]); 40709e54973fSEric Joyner rxq->rx_base = (union ice_32b_rx_flex_desc *)vaddrs[i]; 40719e54973fSEric Joyner rxq->rx_paddr = paddrs[i]; 40729e54973fSEric Joyner 40739e54973fSEric Joyner ice_add_rxq_sysctls(rxq); 40749e54973fSEric Joyner } 40759e54973fSEric Joyner 40769e54973fSEric Joyner return (0); 40779e54973fSEric Joyner } 40789e54973fSEric Joyner 40799e54973fSEric Joyner /** 40809e54973fSEric Joyner * ice_subif_if_msix_intr_assign - Assign MSI-X interrupts to new sub interface 40819e54973fSEric Joyner * @ctx: the iflib context structure 40829e54973fSEric Joyner * @msix: the number of vectors we were assigned 40839e54973fSEric Joyner * 40849e54973fSEric Joyner * Allocates and assigns driver private resources for MSI-X interrupt tracking. 40859e54973fSEric Joyner * 40869e54973fSEric Joyner * @pre OS MSI-X resources have been pre-allocated by parent interface. 40879e54973fSEric Joyner */ 40889e54973fSEric Joyner static int 40899e54973fSEric Joyner ice_subif_if_msix_intr_assign(if_ctx_t ctx, int msix) 40909e54973fSEric Joyner { 40919e54973fSEric Joyner struct ice_mirr_if *mif = (struct ice_mirr_if *)iflib_get_softc(ctx); 40929e54973fSEric Joyner struct ice_softc *sc = mif->back; 40939e54973fSEric Joyner struct ice_vsi *vsi = mif->vsi; 40949e54973fSEric Joyner 40959e54973fSEric Joyner device_t dev = mif->subdev; 40969e54973fSEric Joyner int ret; 40979e54973fSEric Joyner 40989e54973fSEric Joyner if (vsi->num_rx_queues != vsi->num_tx_queues) { 40999e54973fSEric Joyner device_printf(dev, 41009e54973fSEric Joyner "iflib requested %d Tx queues, and %d Rx queues, but the driver isn't able to support a differing number of Tx and Rx queues\n", 41019e54973fSEric Joyner vsi->num_tx_queues, vsi->num_rx_queues); 41029e54973fSEric Joyner return (EOPNOTSUPP); 41039e54973fSEric Joyner } 41049e54973fSEric Joyner 41059e54973fSEric Joyner if (msix > sc->extra_vectors) { 41069e54973fSEric Joyner device_printf(dev, 41079e54973fSEric Joyner "%s: Not enough spare (%d) msix vectors for new sub-interface requested (%d)\n", 41089e54973fSEric Joyner __func__, sc->extra_vectors, msix); 41099e54973fSEric Joyner return (ENOSPC); 41109e54973fSEric Joyner } 41119e54973fSEric Joyner device_printf(dev, "%s: Using %d vectors for sub-interface\n", __func__, 41129e54973fSEric Joyner msix); 41139e54973fSEric Joyner 41149e54973fSEric Joyner /* Allocate space to store the IRQ vector data */ 41159e54973fSEric Joyner mif->num_irq_vectors = vsi->num_rx_queues; 41169e54973fSEric Joyner mif->rx_irqvs = (struct ice_irq_vector *) 41179e54973fSEric Joyner malloc(sizeof(struct ice_irq_vector) * (mif->num_irq_vectors), 41189e54973fSEric Joyner M_ICE, M_NOWAIT); 41199e54973fSEric Joyner if (!mif->rx_irqvs) { 41209e54973fSEric Joyner device_printf(dev, 41219e54973fSEric Joyner "Unable to allocate RX irqv memory for mirror's %d vectors\n", 41229e54973fSEric Joyner mif->num_irq_vectors); 41239e54973fSEric Joyner return (ENOMEM); 41249e54973fSEric Joyner } 41259e54973fSEric Joyner 41269e54973fSEric Joyner /* Assign mirror interface interrupts from PF device space */ 41279e54973fSEric Joyner if (!(mif->if_imap = 41289e54973fSEric Joyner (u16 *)malloc(sizeof(u16) * mif->num_irq_vectors, 41299e54973fSEric Joyner M_ICE, M_NOWAIT))) { 41309e54973fSEric Joyner device_printf(dev, "Unable to allocate mirror intfc if_imap memory\n"); 41319e54973fSEric Joyner ret = ENOMEM; 41329e54973fSEric Joyner goto free_irqvs; 41339e54973fSEric Joyner } 41349e54973fSEric Joyner ret = ice_resmgr_assign_contiguous(&sc->dev_imgr, mif->if_imap, mif->num_irq_vectors); 41359e54973fSEric Joyner if (ret) { 41369e54973fSEric Joyner device_printf(dev, "Unable to assign mirror intfc PF device interrupt mapping: %s\n", 41379e54973fSEric Joyner ice_err_str(ret)); 41389e54973fSEric Joyner goto free_if_imap; 41399e54973fSEric Joyner } 41409e54973fSEric Joyner /* Assign mirror interface interrupts from OS interrupt allocation space */ 41419e54973fSEric Joyner if (!(mif->os_imap = 41429e54973fSEric Joyner (u16 *)malloc(sizeof(u16) * mif->num_irq_vectors, 41439e54973fSEric Joyner M_ICE, M_NOWAIT))) { 41449e54973fSEric Joyner device_printf(dev, "Unable to allocate mirror intfc os_imap memory\n"); 41459e54973fSEric Joyner ret = ENOMEM; 41469e54973fSEric Joyner goto free_if_imap; 41479e54973fSEric Joyner } 41489e54973fSEric Joyner ret = ice_resmgr_assign_contiguous(&sc->os_imgr, mif->os_imap, mif->num_irq_vectors); 41499e54973fSEric Joyner if (ret) { 41509e54973fSEric Joyner device_printf(dev, "Unable to assign mirror intfc OS interrupt mapping: %s\n", 41519e54973fSEric Joyner ice_err_str(ret)); 41529e54973fSEric Joyner goto free_if_imap; 41539e54973fSEric Joyner } 41549e54973fSEric Joyner 41559e54973fSEric Joyner return (0); 41569e54973fSEric Joyner 41579e54973fSEric Joyner free_if_imap: 41589e54973fSEric Joyner free(mif->if_imap, M_ICE); 41599e54973fSEric Joyner mif->if_imap = NULL; 41609e54973fSEric Joyner free_irqvs: 41619e54973fSEric Joyner free(mif->rx_irqvs, M_ICE); 41629e54973fSEric Joyner mif->rx_irqvs = NULL; 41639e54973fSEric Joyner return (ret); 41649e54973fSEric Joyner } 41659e54973fSEric Joyner 41669e54973fSEric Joyner /** 41679e54973fSEric Joyner * ice_subif_if_intr_enable - Enable device interrupts for a subinterface 41689e54973fSEric Joyner * @ctx: iflib context structure 41699e54973fSEric Joyner * 41709e54973fSEric Joyner * Called by iflib to request enabling all interrupts that belong to a 41719e54973fSEric Joyner * subinterface. 41729e54973fSEric Joyner */ 41739e54973fSEric Joyner static void 41749e54973fSEric Joyner ice_subif_if_intr_enable(if_ctx_t ctx) 41759e54973fSEric Joyner { 41769e54973fSEric Joyner struct ice_mirr_if *mif = (struct ice_mirr_if *)iflib_get_softc(ctx); 41779e54973fSEric Joyner struct ice_softc *sc = mif->back; 41789e54973fSEric Joyner struct ice_vsi *vsi = mif->vsi; 41799e54973fSEric Joyner struct ice_hw *hw = &sc->hw; 41809e54973fSEric Joyner 41819e54973fSEric Joyner /* Do not enable queue interrupts in recovery mode */ 41829e54973fSEric Joyner if (ice_test_state(&sc->state, ICE_STATE_RECOVERY_MODE)) 41839e54973fSEric Joyner return; 41849e54973fSEric Joyner 41859e54973fSEric Joyner /* Enable all queue interrupts */ 41869e54973fSEric Joyner for (int i = 0; i < vsi->num_rx_queues; i++) 41879e54973fSEric Joyner ice_enable_intr(hw, vsi->rx_queues[i].irqv->me); 41889e54973fSEric Joyner } 41899e54973fSEric Joyner 41909e54973fSEric Joyner /** 41919e54973fSEric Joyner * ice_subif_if_rx_queue_intr_enable - Enable a specific Rx queue interrupt 41929e54973fSEric Joyner * @ctx: iflib context structure 41939e54973fSEric Joyner * @rxqid: the Rx queue to enable 41949e54973fSEric Joyner * 41959e54973fSEric Joyner * Enable a specific Rx queue interrupt. 41969e54973fSEric Joyner * 41979e54973fSEric Joyner * This function is not protected by the iflib CTX lock. 41989e54973fSEric Joyner */ 41999e54973fSEric Joyner static int 42009e54973fSEric Joyner ice_subif_if_rx_queue_intr_enable(if_ctx_t ctx, uint16_t rxqid) 42019e54973fSEric Joyner { 42029e54973fSEric Joyner struct ice_mirr_if *mif = (struct ice_mirr_if *)iflib_get_softc(ctx); 42039e54973fSEric Joyner struct ice_softc *sc = mif->back; 42049e54973fSEric Joyner struct ice_vsi *vsi = mif->vsi; 42059e54973fSEric Joyner struct ice_hw *hw = &sc->hw; 42069e54973fSEric Joyner 42079e54973fSEric Joyner /* Do not enable queue interrupts in recovery mode */ 42089e54973fSEric Joyner if (ice_test_state(&sc->state, ICE_STATE_RECOVERY_MODE)) 42099e54973fSEric Joyner return (ENOSYS); 42109e54973fSEric Joyner 42119e54973fSEric Joyner ice_enable_intr(hw, vsi->rx_queues[rxqid].irqv->me); 42129e54973fSEric Joyner return (0); 42139e54973fSEric Joyner } 42149e54973fSEric Joyner 42159e54973fSEric Joyner /** 42169e54973fSEric Joyner * ice_subif_if_tx_queue_intr_enable - Enable a specific Tx queue interrupt 42179e54973fSEric Joyner * @ctx: iflib context structure 42189e54973fSEric Joyner * @txqid: the Tx queue to enable 42199e54973fSEric Joyner * 42209e54973fSEric Joyner * Enable a specific Tx queue interrupt. 42219e54973fSEric Joyner * 42229e54973fSEric Joyner * This function is not protected by the iflib CTX lock. 42239e54973fSEric Joyner */ 42249e54973fSEric Joyner static int 42259e54973fSEric Joyner ice_subif_if_tx_queue_intr_enable(if_ctx_t ctx, uint16_t txqid) 42269e54973fSEric Joyner { 42279e54973fSEric Joyner struct ice_mirr_if *mif = (struct ice_mirr_if *)iflib_get_softc(ctx); 42289e54973fSEric Joyner struct ice_softc *sc = mif->back; 42299e54973fSEric Joyner struct ice_vsi *vsi = mif->vsi; 42309e54973fSEric Joyner struct ice_hw *hw = &sc->hw; 42319e54973fSEric Joyner 42329e54973fSEric Joyner /* Do not enable queue interrupts in recovery mode */ 42339e54973fSEric Joyner if (ice_test_state(&sc->state, ICE_STATE_RECOVERY_MODE)) 42349e54973fSEric Joyner return (ENOSYS); 42359e54973fSEric Joyner 42369e54973fSEric Joyner ice_enable_intr(hw, vsi->tx_queues[txqid].irqv->me); 42379e54973fSEric Joyner return (0); 42389e54973fSEric Joyner } 42399e54973fSEric Joyner 42409e54973fSEric Joyner /** 42419e54973fSEric Joyner * ice_subif_if_init - Initialize the subinterface 42429e54973fSEric Joyner * @ctx: iflib ctx structure 42439e54973fSEric Joyner * 42449e54973fSEric Joyner * Called by iflib to bring the device up, i.e. ifconfig ice0m0 up. 42459e54973fSEric Joyner * Prepares the Tx and Rx engines and enables interrupts. 42469e54973fSEric Joyner * 42479e54973fSEric Joyner * @pre assumes the caller holds the iflib CTX lock 42489e54973fSEric Joyner */ 42499e54973fSEric Joyner static void 42509e54973fSEric Joyner ice_subif_if_init(if_ctx_t ctx) 42519e54973fSEric Joyner { 42529e54973fSEric Joyner struct ice_mirr_if *mif = (struct ice_mirr_if *)iflib_get_softc(ctx); 42539e54973fSEric Joyner struct ice_softc *sc = mif->back; 42549e54973fSEric Joyner struct ice_vsi *vsi = mif->vsi; 42559e54973fSEric Joyner device_t dev = mif->subdev; 42569e54973fSEric Joyner int err; 42579e54973fSEric Joyner 42589e54973fSEric Joyner if (ice_driver_is_detaching(sc)) 42599e54973fSEric Joyner return; 42609e54973fSEric Joyner 42619e54973fSEric Joyner if (ice_test_state(&sc->state, ICE_STATE_RECOVERY_MODE)) 42629e54973fSEric Joyner return; 42639e54973fSEric Joyner 42649e54973fSEric Joyner if (ice_test_state(&sc->state, ICE_STATE_RESET_FAILED)) { 42659e54973fSEric Joyner device_printf(dev, 42669e54973fSEric Joyner "request to start interface cannot be completed as the parent device %s failed to reset\n", 42679e54973fSEric Joyner device_get_nameunit(sc->dev)); 42689e54973fSEric Joyner return; 42699e54973fSEric Joyner } 42709e54973fSEric Joyner 42719e54973fSEric Joyner if (ice_test_state(&sc->state, ICE_STATE_PREPARED_FOR_RESET)) { 42729e54973fSEric Joyner device_printf(dev, 42739e54973fSEric Joyner "request to start interface cannot be completed while parent device %s is prepared for impending reset\n", 42749e54973fSEric Joyner device_get_nameunit(sc->dev)); 42759e54973fSEric Joyner return; 42769e54973fSEric Joyner } 42779e54973fSEric Joyner 42789e54973fSEric Joyner /* XXX: Equiv to ice_update_rx_mbuf_sz */ 42799e54973fSEric Joyner vsi->mbuf_sz = iflib_get_rx_mbuf_sz(ctx); 42809e54973fSEric Joyner 42819e54973fSEric Joyner /* Initialize software Tx tracking values */ 42829e54973fSEric Joyner ice_init_tx_tracking(vsi); 42839e54973fSEric Joyner 42849e54973fSEric Joyner err = ice_cfg_vsi_for_tx(vsi); 42859e54973fSEric Joyner if (err) { 42869e54973fSEric Joyner device_printf(dev, 42879e54973fSEric Joyner "Unable to configure subif VSI for Tx: %s\n", 42889e54973fSEric Joyner ice_err_str(err)); 42899e54973fSEric Joyner return; 42909e54973fSEric Joyner } 42919e54973fSEric Joyner 42929e54973fSEric Joyner err = ice_cfg_vsi_for_rx(vsi); 42939e54973fSEric Joyner if (err) { 42949e54973fSEric Joyner device_printf(dev, 42959e54973fSEric Joyner "Unable to configure subif VSI for Rx: %s\n", 42969e54973fSEric Joyner ice_err_str(err)); 42979e54973fSEric Joyner goto err_cleanup_tx; 42989e54973fSEric Joyner } 42999e54973fSEric Joyner 43009e54973fSEric Joyner err = ice_control_all_rx_queues(vsi, true); 43019e54973fSEric Joyner if (err) { 43029e54973fSEric Joyner device_printf(dev, 43039e54973fSEric Joyner "Unable to enable subif Rx rings for receive: %s\n", 43049e54973fSEric Joyner ice_err_str(err)); 43059e54973fSEric Joyner goto err_cleanup_tx; 43069e54973fSEric Joyner } 43079e54973fSEric Joyner 43089e54973fSEric Joyner ice_configure_all_rxq_interrupts(vsi); 43099e54973fSEric Joyner ice_configure_rx_itr(vsi); 43109e54973fSEric Joyner 43119e54973fSEric Joyner ice_set_state(&mif->state, ICE_STATE_DRIVER_INITIALIZED); 43129e54973fSEric Joyner return; 43139e54973fSEric Joyner 43149e54973fSEric Joyner err_cleanup_tx: 43159e54973fSEric Joyner ice_vsi_disable_tx(vsi); 43169e54973fSEric Joyner } 43179e54973fSEric Joyner 43189e54973fSEric Joyner /** 43199e54973fSEric Joyner * ice_if_stop_subif - Stop the subinterface 43209e54973fSEric Joyner * @ctx: iflib context structure 43219e54973fSEric Joyner * @ifs: subinterface context structure 43229e54973fSEric Joyner * 43239e54973fSEric Joyner * Called by iflib to stop the subinterface and bring it down. 43249e54973fSEric Joyner * (e.g. ifconfig ice0m0 down) 43259e54973fSEric Joyner * 43269e54973fSEric Joyner * @pre assumes the caller holds the iflib CTX lock 43279e54973fSEric Joyner */ 43289e54973fSEric Joyner static void 43299e54973fSEric Joyner ice_subif_if_stop(if_ctx_t ctx) 43309e54973fSEric Joyner { 43319e54973fSEric Joyner struct ice_mirr_if *mif = (struct ice_mirr_if *)iflib_get_softc(ctx); 43329e54973fSEric Joyner struct ice_softc *sc = mif->back; 43339e54973fSEric Joyner struct ice_vsi *vsi = mif->vsi; 43349e54973fSEric Joyner device_t dev = mif->subdev; 43359e54973fSEric Joyner 43369e54973fSEric Joyner if (!ice_testandclear_state(&mif->state, ICE_STATE_DRIVER_INITIALIZED)) 43379e54973fSEric Joyner return; 43389e54973fSEric Joyner 43399e54973fSEric Joyner if (ice_test_state(&sc->state, ICE_STATE_RESET_FAILED)) { 43409e54973fSEric Joyner device_printf(dev, 43419e54973fSEric Joyner "request to stop interface cannot be completed as the parent device %s failed to reset\n", 43429e54973fSEric Joyner device_get_nameunit(sc->dev)); 43439e54973fSEric Joyner return; 43449e54973fSEric Joyner } 43459e54973fSEric Joyner 43469e54973fSEric Joyner if (ice_test_state(&sc->state, ICE_STATE_PREPARED_FOR_RESET)) { 43479e54973fSEric Joyner device_printf(dev, 43489e54973fSEric Joyner "request to stop interface cannot be completed while parent device %s is prepared for impending reset\n", 43499e54973fSEric Joyner device_get_nameunit(sc->dev)); 43509e54973fSEric Joyner return; 43519e54973fSEric Joyner } 43529e54973fSEric Joyner 43539e54973fSEric Joyner /* Dissociate the Tx and Rx queues from the interrupts */ 43549e54973fSEric Joyner ice_flush_txq_interrupts(vsi); 43559e54973fSEric Joyner ice_flush_rxq_interrupts(vsi); 43569e54973fSEric Joyner 43579e54973fSEric Joyner /* Disable the Tx and Rx queues */ 43589e54973fSEric Joyner ice_vsi_disable_tx(vsi); 43599e54973fSEric Joyner ice_control_all_rx_queues(vsi, false); 43609e54973fSEric Joyner } 43619e54973fSEric Joyner 43629e54973fSEric Joyner /** 43639e54973fSEric Joyner * ice_free_irqvs_subif - Free IRQ vector memory for subinterfaces 43649e54973fSEric Joyner * @mif: Mirror interface private structure 43659e54973fSEric Joyner * 43669e54973fSEric Joyner * Free IRQ vector memory allocated during ice_subif_if_msix_intr_assign. 43679e54973fSEric Joyner */ 43689e54973fSEric Joyner static void 43699e54973fSEric Joyner ice_free_irqvs_subif(struct ice_mirr_if *mif) 43709e54973fSEric Joyner { 43719e54973fSEric Joyner struct ice_softc *sc = mif->back; 43729e54973fSEric Joyner struct ice_vsi *vsi = mif->vsi; 43739e54973fSEric Joyner if_ctx_t ctx = sc->ctx; 43749e54973fSEric Joyner int i; 43759e54973fSEric Joyner 43769e54973fSEric Joyner /* If the irqvs array is NULL, then there are no vectors to free */ 43779e54973fSEric Joyner if (mif->rx_irqvs == NULL) 43789e54973fSEric Joyner return; 43799e54973fSEric Joyner 43809e54973fSEric Joyner /* Free the IRQ vectors -- currently subinterfaces have number 43819e54973fSEric Joyner * of vectors equal to number of RX queues 43829e54973fSEric Joyner * 43839e54973fSEric Joyner * XXX: ctx is parent device's ctx, not the subinterface ctx 43849e54973fSEric Joyner */ 43859e54973fSEric Joyner for (i = 0; i < vsi->num_rx_queues; i++) 43869e54973fSEric Joyner iflib_irq_free(ctx, &mif->rx_irqvs[i].irq); 43879e54973fSEric Joyner 43889e54973fSEric Joyner ice_resmgr_release_map(&sc->os_imgr, mif->os_imap, 43899e54973fSEric Joyner mif->num_irq_vectors); 43909e54973fSEric Joyner ice_resmgr_release_map(&sc->dev_imgr, mif->if_imap, 43919e54973fSEric Joyner mif->num_irq_vectors); 43929e54973fSEric Joyner 43939e54973fSEric Joyner sc->last_rid -= vsi->num_rx_queues; 43949e54973fSEric Joyner 43959e54973fSEric Joyner /* Clear the irqv pointers */ 43969e54973fSEric Joyner for (i = 0; i < vsi->num_rx_queues; i++) 43979e54973fSEric Joyner vsi->rx_queues[i].irqv = NULL; 43989e54973fSEric Joyner 43999e54973fSEric Joyner for (i = 0; i < vsi->num_tx_queues; i++) 44009e54973fSEric Joyner vsi->tx_queues[i].irqv = NULL; 44019e54973fSEric Joyner 44029e54973fSEric Joyner /* Release the vector array memory */ 44039e54973fSEric Joyner free(mif->rx_irqvs, M_ICE); 44049e54973fSEric Joyner mif->rx_irqvs = NULL; 44059e54973fSEric Joyner } 44069e54973fSEric Joyner 44079e54973fSEric Joyner /** 44089e54973fSEric Joyner * ice_subif_if_queues_free - Free queue memory for subinterfaces 44099e54973fSEric Joyner * @ctx: the iflib context structure 44109e54973fSEric Joyner * 44119e54973fSEric Joyner * Free queue memory allocated by ice_subif_tx_queues_alloc() and 44129e54973fSEric Joyner * ice_subif_if_rx_queues_alloc(). 44139e54973fSEric Joyner */ 44149e54973fSEric Joyner static void 44159e54973fSEric Joyner ice_subif_if_queues_free(if_ctx_t ctx) 44169e54973fSEric Joyner { 44179e54973fSEric Joyner struct ice_mirr_if *mif = (struct ice_mirr_if *)iflib_get_softc(ctx); 44189e54973fSEric Joyner struct ice_vsi *vsi = mif->vsi; 44199e54973fSEric Joyner struct ice_tx_queue *txq; 44209e54973fSEric Joyner int i; 44219e54973fSEric Joyner 44229e54973fSEric Joyner /* Free the Tx and Rx sysctl contexts, and assign NULL to the node 44239e54973fSEric Joyner * pointers. 44249e54973fSEric Joyner */ 44259e54973fSEric Joyner ice_vsi_del_txqs_ctx(vsi); 44269e54973fSEric Joyner ice_vsi_del_rxqs_ctx(vsi); 44279e54973fSEric Joyner 44289e54973fSEric Joyner /* Release MSI-X IRQ vectors */ 44299e54973fSEric Joyner ice_free_irqvs_subif(mif); 44309e54973fSEric Joyner 44319e54973fSEric Joyner if (vsi->tx_queues != NULL) { 44329e54973fSEric Joyner /* free the tx_rsq arrays */ 44339e54973fSEric Joyner for (i = 0, txq = vsi->tx_queues; i < vsi->num_tx_queues; i++, txq++) { 44349e54973fSEric Joyner if (txq->tx_rsq != NULL) { 44359e54973fSEric Joyner free(txq->tx_rsq, M_ICE); 44369e54973fSEric Joyner txq->tx_rsq = NULL; 44379e54973fSEric Joyner } 44389e54973fSEric Joyner } 44399e54973fSEric Joyner free(vsi->tx_queues, M_ICE); 44409e54973fSEric Joyner vsi->tx_queues = NULL; 44419e54973fSEric Joyner } 44429e54973fSEric Joyner if (vsi->rx_queues != NULL) { 44439e54973fSEric Joyner free(vsi->rx_queues, M_ICE); 44449e54973fSEric Joyner vsi->rx_queues = NULL; 44459e54973fSEric Joyner } 44469e54973fSEric Joyner } 44479e54973fSEric Joyner 44489e54973fSEric Joyner /** 44499e54973fSEric Joyner * ice_subif_if_media_status - Report subinterface media 44509e54973fSEric Joyner * @ctx: iflib context structure 44519e54973fSEric Joyner * @ifmr: ifmedia request structure to update 44529e54973fSEric Joyner * 44539e54973fSEric Joyner * Updates the provided ifmr with something, in order to prevent a 44549e54973fSEric Joyner * "no media types?" message from ifconfig. 44559e54973fSEric Joyner * 44569e54973fSEric Joyner * Mirror interfaces are always up. 44579e54973fSEric Joyner */ 44589e54973fSEric Joyner static void 44599e54973fSEric Joyner ice_subif_if_media_status(if_ctx_t ctx __unused, struct ifmediareq *ifmr) 44609e54973fSEric Joyner { 44619e54973fSEric Joyner ifmr->ifm_status = IFM_AVALID | IFM_ACTIVE; 44629e54973fSEric Joyner ifmr->ifm_active = IFM_ETHER | IFM_AUTO; 44639e54973fSEric Joyner } 44649e54973fSEric Joyner 44659e54973fSEric Joyner /** 44669e54973fSEric Joyner * ice_subif_if_promisc_set - Set subinterface promiscuous mode 44679e54973fSEric Joyner * @ctx: iflib context structure 44689e54973fSEric Joyner * @flags: promiscuous flags to configure 44699e54973fSEric Joyner * 44709e54973fSEric Joyner * Called by iflib to configure device promiscuous mode. 44719e54973fSEric Joyner * 44729e54973fSEric Joyner * @remark This does not need to be implemented for now. 44739e54973fSEric Joyner */ 44749e54973fSEric Joyner static int 44759e54973fSEric Joyner ice_subif_if_promisc_set(if_ctx_t ctx __unused, int flags __unused) 44769e54973fSEric Joyner { 44779e54973fSEric Joyner return (0); 44789e54973fSEric Joyner } 44799e54973fSEric Joyner 4480