1837f08fdSAnirudh Venkataramanan // SPDX-License-Identifier: GPL-2.0 2837f08fdSAnirudh Venkataramanan /* Copyright (c) 2018, Intel Corporation. */ 3837f08fdSAnirudh Venkataramanan 4837f08fdSAnirudh Venkataramanan /* Intel(R) Ethernet Connection E800 Series Linux Driver */ 5837f08fdSAnirudh Venkataramanan 6837f08fdSAnirudh Venkataramanan #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 7837f08fdSAnirudh Venkataramanan 834a2a3b8SJeff Kirsher #include <generated/utsrelease.h> 9837f08fdSAnirudh Venkataramanan #include "ice.h" 10eff380aaSAnirudh Venkataramanan #include "ice_base.h" 1145d3d428SAnirudh Venkataramanan #include "ice_lib.h" 121b8f15b6SMichal Swiatkowski #include "ice_fltr.h" 1337b6f646SAnirudh Venkataramanan #include "ice_dcb_lib.h" 14b94b013eSDave Ertman #include "ice_dcb_nl.h" 151adf7eadSJacob Keller #include "ice_devlink.h" 163089cf6dSJesse Brandeburg /* Including ice_trace.h with CREATE_TRACE_POINTS defined will generate the 173089cf6dSJesse Brandeburg * ice tracepoint functions. This must be done exactly once across the 183089cf6dSJesse Brandeburg * ice driver. 193089cf6dSJesse Brandeburg */ 203089cf6dSJesse Brandeburg #define CREATE_TRACE_POINTS 213089cf6dSJesse Brandeburg #include "ice_trace.h" 22b3be918dSGrzegorz Nitka #include "ice_eswitch.h" 230d08a441SKiran Patil #include "ice_tc_lib.h" 24c31af68aSBrett Creeley #include "ice_vsi_vlan_ops.h" 25837f08fdSAnirudh Venkataramanan 26837f08fdSAnirudh Venkataramanan #define DRV_SUMMARY "Intel(R) Ethernet Connection E800 Series Linux Driver" 27837f08fdSAnirudh Venkataramanan static const char ice_driver_string[] = DRV_SUMMARY; 28837f08fdSAnirudh Venkataramanan static const char ice_copyright[] = "Copyright (c) 2018, Intel Corporation."; 29837f08fdSAnirudh Venkataramanan 30462acf6aSTony Nguyen /* DDP Package file located in firmware search paths (e.g. /lib/firmware/) */ 31462acf6aSTony Nguyen #define ICE_DDP_PKG_PATH "intel/ice/ddp/" 32462acf6aSTony Nguyen #define ICE_DDP_PKG_FILE ICE_DDP_PKG_PATH "ice.pkg" 33462acf6aSTony Nguyen 34837f08fdSAnirudh Venkataramanan MODULE_AUTHOR("Intel Corporation, <linux.nics@intel.com>"); 35837f08fdSAnirudh Venkataramanan MODULE_DESCRIPTION(DRV_SUMMARY); 3698674ebeSJesse Brandeburg MODULE_LICENSE("GPL v2"); 37462acf6aSTony Nguyen MODULE_FIRMWARE(ICE_DDP_PKG_FILE); 38837f08fdSAnirudh Venkataramanan 39837f08fdSAnirudh Venkataramanan static int debug = -1; 40837f08fdSAnirudh Venkataramanan module_param(debug, int, 0644); 417ec59eeaSAnirudh Venkataramanan #ifndef CONFIG_DYNAMIC_DEBUG 427ec59eeaSAnirudh Venkataramanan MODULE_PARM_DESC(debug, "netif level (0=none,...,16=all), hw debug_mask (0x8XXXXXXX)"); 437ec59eeaSAnirudh Venkataramanan #else 447ec59eeaSAnirudh Venkataramanan MODULE_PARM_DESC(debug, "netif level (0=none,...,16=all)"); 457ec59eeaSAnirudh Venkataramanan #endif /* !CONFIG_DYNAMIC_DEBUG */ 46837f08fdSAnirudh Venkataramanan 47d25a0fc4SDave Ertman static DEFINE_IDA(ice_aux_ida); 4822bf877eSMaciej Fijalkowski DEFINE_STATIC_KEY_FALSE(ice_xdp_locking_key); 4922bf877eSMaciej Fijalkowski EXPORT_SYMBOL(ice_xdp_locking_key); 50d25a0fc4SDave Ertman 51649c87c6SJacob Keller /** 52649c87c6SJacob Keller * ice_hw_to_dev - Get device pointer from the hardware structure 53649c87c6SJacob Keller * @hw: pointer to the device HW structure 54649c87c6SJacob Keller * 55649c87c6SJacob Keller * Used to access the device pointer from compilation units which can't easily 56649c87c6SJacob Keller * include the definition of struct ice_pf without leading to circular header 57649c87c6SJacob Keller * dependencies. 58649c87c6SJacob Keller */ 59649c87c6SJacob Keller struct device *ice_hw_to_dev(struct ice_hw *hw) 60649c87c6SJacob Keller { 61649c87c6SJacob Keller struct ice_pf *pf = container_of(hw, struct ice_pf, hw); 62649c87c6SJacob Keller 63649c87c6SJacob Keller return &pf->pdev->dev; 64649c87c6SJacob Keller } 65649c87c6SJacob Keller 66940b61afSAnirudh Venkataramanan static struct workqueue_struct *ice_wq; 67462acf6aSTony Nguyen static const struct net_device_ops ice_netdev_safe_mode_ops; 68cdedef59SAnirudh Venkataramanan static const struct net_device_ops ice_netdev_ops; 69940b61afSAnirudh Venkataramanan 70462acf6aSTony Nguyen static void ice_rebuild(struct ice_pf *pf, enum ice_reset_req reset_type); 7128c2a645SAnirudh Venkataramanan 720f9d5027SAnirudh Venkataramanan static void ice_vsi_release_all(struct ice_pf *pf); 733a858ba3SAnirudh Venkataramanan 74fbc7b27aSKiran Patil static int ice_rebuild_channels(struct ice_pf *pf); 75fbc7b27aSKiran Patil static void ice_remove_q_channels(struct ice_vsi *vsi, bool rem_adv_fltr); 76fbc7b27aSKiran Patil 77195bb48fSMichal Swiatkowski static int 78195bb48fSMichal Swiatkowski ice_indr_setup_tc_cb(struct net_device *netdev, struct Qdisc *sch, 79195bb48fSMichal Swiatkowski void *cb_priv, enum tc_setup_type type, void *type_data, 80195bb48fSMichal Swiatkowski void *data, 81195bb48fSMichal Swiatkowski void (*cleanup)(struct flow_block_cb *block_cb)); 82195bb48fSMichal Swiatkowski 83df006dd4SDave Ertman bool netif_is_ice(struct net_device *dev) 84df006dd4SDave Ertman { 85df006dd4SDave Ertman return dev && (dev->netdev_ops == &ice_netdev_ops); 86df006dd4SDave Ertman } 87df006dd4SDave Ertman 883a858ba3SAnirudh Venkataramanan /** 89b3969fd7SSudheer Mogilappagari * ice_get_tx_pending - returns number of Tx descriptors not processed 90b3969fd7SSudheer Mogilappagari * @ring: the ring of descriptors 91b3969fd7SSudheer Mogilappagari */ 92e72bba21SMaciej Fijalkowski static u16 ice_get_tx_pending(struct ice_tx_ring *ring) 93b3969fd7SSudheer Mogilappagari { 94c1ddf1f5SBrett Creeley u16 head, tail; 95b3969fd7SSudheer Mogilappagari 96b3969fd7SSudheer Mogilappagari head = ring->next_to_clean; 97c1ddf1f5SBrett Creeley tail = ring->next_to_use; 98b3969fd7SSudheer Mogilappagari 99b3969fd7SSudheer Mogilappagari if (head != tail) 100b3969fd7SSudheer Mogilappagari return (head < tail) ? 101b3969fd7SSudheer Mogilappagari tail - head : (tail + ring->count - head); 102b3969fd7SSudheer Mogilappagari return 0; 103b3969fd7SSudheer Mogilappagari } 104b3969fd7SSudheer Mogilappagari 105b3969fd7SSudheer Mogilappagari /** 106b3969fd7SSudheer Mogilappagari * ice_check_for_hang_subtask - check for and recover hung queues 107b3969fd7SSudheer Mogilappagari * @pf: pointer to PF struct 108b3969fd7SSudheer Mogilappagari */ 109b3969fd7SSudheer Mogilappagari static void ice_check_for_hang_subtask(struct ice_pf *pf) 110b3969fd7SSudheer Mogilappagari { 111b3969fd7SSudheer Mogilappagari struct ice_vsi *vsi = NULL; 112e89e899fSBrett Creeley struct ice_hw *hw; 113b3969fd7SSudheer Mogilappagari unsigned int i; 114b3969fd7SSudheer Mogilappagari int packets; 115e89e899fSBrett Creeley u32 v; 116b3969fd7SSudheer Mogilappagari 117b3969fd7SSudheer Mogilappagari ice_for_each_vsi(pf, v) 118b3969fd7SSudheer Mogilappagari if (pf->vsi[v] && pf->vsi[v]->type == ICE_VSI_PF) { 119b3969fd7SSudheer Mogilappagari vsi = pf->vsi[v]; 120b3969fd7SSudheer Mogilappagari break; 121b3969fd7SSudheer Mogilappagari } 122b3969fd7SSudheer Mogilappagari 123e97fb1aeSAnirudh Venkataramanan if (!vsi || test_bit(ICE_VSI_DOWN, vsi->state)) 124b3969fd7SSudheer Mogilappagari return; 125b3969fd7SSudheer Mogilappagari 126b3969fd7SSudheer Mogilappagari if (!(vsi->netdev && netif_carrier_ok(vsi->netdev))) 127b3969fd7SSudheer Mogilappagari return; 128b3969fd7SSudheer Mogilappagari 129e89e899fSBrett Creeley hw = &vsi->back->hw; 130e89e899fSBrett Creeley 1312faf63b6SMaciej Fijalkowski ice_for_each_txq(vsi, i) { 132e72bba21SMaciej Fijalkowski struct ice_tx_ring *tx_ring = vsi->tx_rings[i]; 133b3969fd7SSudheer Mogilappagari 134fbc7b27aSKiran Patil if (!tx_ring) 135fbc7b27aSKiran Patil continue; 136fbc7b27aSKiran Patil if (ice_ring_ch_enabled(tx_ring)) 137fbc7b27aSKiran Patil continue; 138fbc7b27aSKiran Patil 139fbc7b27aSKiran Patil if (tx_ring->desc) { 140b3969fd7SSudheer Mogilappagari /* If packet counter has not changed the queue is 141b3969fd7SSudheer Mogilappagari * likely stalled, so force an interrupt for this 142b3969fd7SSudheer Mogilappagari * queue. 143b3969fd7SSudheer Mogilappagari * 144b3969fd7SSudheer Mogilappagari * prev_pkt would be negative if there was no 145b3969fd7SSudheer Mogilappagari * pending work. 146b3969fd7SSudheer Mogilappagari */ 147b3969fd7SSudheer Mogilappagari packets = tx_ring->stats.pkts & INT_MAX; 148b3969fd7SSudheer Mogilappagari if (tx_ring->tx_stats.prev_pkt == packets) { 149b3969fd7SSudheer Mogilappagari /* Trigger sw interrupt to revive the queue */ 150e89e899fSBrett Creeley ice_trigger_sw_intr(hw, tx_ring->q_vector); 151b3969fd7SSudheer Mogilappagari continue; 152b3969fd7SSudheer Mogilappagari } 153b3969fd7SSudheer Mogilappagari 154b3969fd7SSudheer Mogilappagari /* Memory barrier between read of packet count and call 155b3969fd7SSudheer Mogilappagari * to ice_get_tx_pending() 156b3969fd7SSudheer Mogilappagari */ 157b3969fd7SSudheer Mogilappagari smp_rmb(); 158b3969fd7SSudheer Mogilappagari tx_ring->tx_stats.prev_pkt = 159b3969fd7SSudheer Mogilappagari ice_get_tx_pending(tx_ring) ? packets : -1; 160b3969fd7SSudheer Mogilappagari } 161b3969fd7SSudheer Mogilappagari } 162b3969fd7SSudheer Mogilappagari } 163b3969fd7SSudheer Mogilappagari 164b3969fd7SSudheer Mogilappagari /** 165561f4379STony Nguyen * ice_init_mac_fltr - Set initial MAC filters 166561f4379STony Nguyen * @pf: board private structure 167561f4379STony Nguyen * 1682f2da36eSAnirudh Venkataramanan * Set initial set of MAC filters for PF VSI; configure filters for permanent 169561f4379STony Nguyen * address and broadcast address. If an error is encountered, netdevice will be 170561f4379STony Nguyen * unregistered. 171561f4379STony Nguyen */ 172561f4379STony Nguyen static int ice_init_mac_fltr(struct ice_pf *pf) 173561f4379STony Nguyen { 174561f4379STony Nguyen struct ice_vsi *vsi; 1751b8f15b6SMichal Swiatkowski u8 *perm_addr; 176561f4379STony Nguyen 177208ff751SAnirudh Venkataramanan vsi = ice_get_main_vsi(pf); 178561f4379STony Nguyen if (!vsi) 179561f4379STony Nguyen return -EINVAL; 180561f4379STony Nguyen 1811b8f15b6SMichal Swiatkowski perm_addr = vsi->port_info->mac.perm_addr; 182c1484691STony Nguyen return ice_fltr_add_mac_and_broadcast(vsi, perm_addr, ICE_FWD_TO_VSI); 183561f4379STony Nguyen } 184561f4379STony Nguyen 185561f4379STony Nguyen /** 186f9867df6SAnirudh Venkataramanan * ice_add_mac_to_sync_list - creates list of MAC addresses to be synced 187e94d4478SAnirudh Venkataramanan * @netdev: the net device on which the sync is happening 188f9867df6SAnirudh Venkataramanan * @addr: MAC address to sync 189e94d4478SAnirudh Venkataramanan * 190e94d4478SAnirudh Venkataramanan * This is a callback function which is called by the in kernel device sync 191e94d4478SAnirudh Venkataramanan * functions (like __dev_uc_sync, __dev_mc_sync, etc). This function only 192e94d4478SAnirudh Venkataramanan * populates the tmp_sync_list, which is later used by ice_add_mac to add the 193f9867df6SAnirudh Venkataramanan * MAC filters from the hardware. 194e94d4478SAnirudh Venkataramanan */ 195e94d4478SAnirudh Venkataramanan static int ice_add_mac_to_sync_list(struct net_device *netdev, const u8 *addr) 196e94d4478SAnirudh Venkataramanan { 197e94d4478SAnirudh Venkataramanan struct ice_netdev_priv *np = netdev_priv(netdev); 198e94d4478SAnirudh Venkataramanan struct ice_vsi *vsi = np->vsi; 199e94d4478SAnirudh Venkataramanan 2001b8f15b6SMichal Swiatkowski if (ice_fltr_add_mac_to_list(vsi, &vsi->tmp_sync_list, addr, 2011b8f15b6SMichal Swiatkowski ICE_FWD_TO_VSI)) 202e94d4478SAnirudh Venkataramanan return -EINVAL; 203e94d4478SAnirudh Venkataramanan 204e94d4478SAnirudh Venkataramanan return 0; 205e94d4478SAnirudh Venkataramanan } 206e94d4478SAnirudh Venkataramanan 207e94d4478SAnirudh Venkataramanan /** 208f9867df6SAnirudh Venkataramanan * ice_add_mac_to_unsync_list - creates list of MAC addresses to be unsynced 209e94d4478SAnirudh Venkataramanan * @netdev: the net device on which the unsync is happening 210f9867df6SAnirudh Venkataramanan * @addr: MAC address to unsync 211e94d4478SAnirudh Venkataramanan * 212e94d4478SAnirudh Venkataramanan * This is a callback function which is called by the in kernel device unsync 213e94d4478SAnirudh Venkataramanan * functions (like __dev_uc_unsync, __dev_mc_unsync, etc). This function only 214e94d4478SAnirudh Venkataramanan * populates the tmp_unsync_list, which is later used by ice_remove_mac to 215f9867df6SAnirudh Venkataramanan * delete the MAC filters from the hardware. 216e94d4478SAnirudh Venkataramanan */ 217e94d4478SAnirudh Venkataramanan static int ice_add_mac_to_unsync_list(struct net_device *netdev, const u8 *addr) 218e94d4478SAnirudh Venkataramanan { 219e94d4478SAnirudh Venkataramanan struct ice_netdev_priv *np = netdev_priv(netdev); 220e94d4478SAnirudh Venkataramanan struct ice_vsi *vsi = np->vsi; 221e94d4478SAnirudh Venkataramanan 2223ba7f53fSBrett Creeley /* Under some circumstances, we might receive a request to delete our 2233ba7f53fSBrett Creeley * own device address from our uc list. Because we store the device 2243ba7f53fSBrett Creeley * address in the VSI's MAC filter list, we need to ignore such 2253ba7f53fSBrett Creeley * requests and not delete our device address from this list. 2263ba7f53fSBrett Creeley */ 2273ba7f53fSBrett Creeley if (ether_addr_equal(addr, netdev->dev_addr)) 2283ba7f53fSBrett Creeley return 0; 2293ba7f53fSBrett Creeley 2301b8f15b6SMichal Swiatkowski if (ice_fltr_add_mac_to_list(vsi, &vsi->tmp_unsync_list, addr, 2311b8f15b6SMichal Swiatkowski ICE_FWD_TO_VSI)) 232e94d4478SAnirudh Venkataramanan return -EINVAL; 233e94d4478SAnirudh Venkataramanan 234e94d4478SAnirudh Venkataramanan return 0; 235e94d4478SAnirudh Venkataramanan } 236e94d4478SAnirudh Venkataramanan 237e94d4478SAnirudh Venkataramanan /** 238e94d4478SAnirudh Venkataramanan * ice_vsi_fltr_changed - check if filter state changed 239e94d4478SAnirudh Venkataramanan * @vsi: VSI to be checked 240e94d4478SAnirudh Venkataramanan * 241e94d4478SAnirudh Venkataramanan * returns true if filter state has changed, false otherwise. 242e94d4478SAnirudh Venkataramanan */ 243e94d4478SAnirudh Venkataramanan static bool ice_vsi_fltr_changed(struct ice_vsi *vsi) 244e94d4478SAnirudh Venkataramanan { 245e97fb1aeSAnirudh Venkataramanan return test_bit(ICE_VSI_UMAC_FLTR_CHANGED, vsi->state) || 2461273f895SIvan Vecera test_bit(ICE_VSI_MMAC_FLTR_CHANGED, vsi->state); 247e94d4478SAnirudh Venkataramanan } 248e94d4478SAnirudh Venkataramanan 249e94d4478SAnirudh Venkataramanan /** 250fabf480bSBrett Creeley * ice_set_promisc - Enable promiscuous mode for a given PF 2515eda8afdSAkeem G Abodunrin * @vsi: the VSI being configured 2525eda8afdSAkeem G Abodunrin * @promisc_m: mask of promiscuous config bits 2535eda8afdSAkeem G Abodunrin * 2545eda8afdSAkeem G Abodunrin */ 255fabf480bSBrett Creeley static int ice_set_promisc(struct ice_vsi *vsi, u8 promisc_m) 2565eda8afdSAkeem G Abodunrin { 2575e24d598STony Nguyen int status; 2585eda8afdSAkeem G Abodunrin 2595eda8afdSAkeem G Abodunrin if (vsi->type != ICE_VSI_PF) 2605eda8afdSAkeem G Abodunrin return 0; 2615eda8afdSAkeem G Abodunrin 2621273f895SIvan Vecera if (ice_vsi_has_non_zero_vlans(vsi)) { 2631273f895SIvan Vecera promisc_m |= (ICE_PROMISC_VLAN_RX | ICE_PROMISC_VLAN_TX); 2641273f895SIvan Vecera status = ice_fltr_set_vlan_vsi_promisc(&vsi->back->hw, vsi, 2651273f895SIvan Vecera promisc_m); 2661273f895SIvan Vecera } else { 2671273f895SIvan Vecera status = ice_fltr_set_vsi_promisc(&vsi->back->hw, vsi->idx, 2681273f895SIvan Vecera promisc_m, 0); 2691273f895SIvan Vecera } 270abddafd4SGrzegorz Siwik if (status && status != -EEXIST) 271c1484691STony Nguyen return status; 272abddafd4SGrzegorz Siwik 273abddafd4SGrzegorz Siwik return 0; 2745eda8afdSAkeem G Abodunrin } 2755eda8afdSAkeem G Abodunrin 276fabf480bSBrett Creeley /** 277fabf480bSBrett Creeley * ice_clear_promisc - Disable promiscuous mode for a given PF 278fabf480bSBrett Creeley * @vsi: the VSI being configured 279fabf480bSBrett Creeley * @promisc_m: mask of promiscuous config bits 280fabf480bSBrett Creeley * 281fabf480bSBrett Creeley */ 282fabf480bSBrett Creeley static int ice_clear_promisc(struct ice_vsi *vsi, u8 promisc_m) 283fabf480bSBrett Creeley { 2845e24d598STony Nguyen int status; 285fabf480bSBrett Creeley 286fabf480bSBrett Creeley if (vsi->type != ICE_VSI_PF) 287fabf480bSBrett Creeley return 0; 288fabf480bSBrett Creeley 2891273f895SIvan Vecera if (ice_vsi_has_non_zero_vlans(vsi)) { 2901273f895SIvan Vecera promisc_m |= (ICE_PROMISC_VLAN_RX | ICE_PROMISC_VLAN_TX); 2911273f895SIvan Vecera status = ice_fltr_clear_vlan_vsi_promisc(&vsi->back->hw, vsi, 2921273f895SIvan Vecera promisc_m); 2931273f895SIvan Vecera } else { 2941273f895SIvan Vecera status = ice_fltr_clear_vsi_promisc(&vsi->back->hw, vsi->idx, 2951273f895SIvan Vecera promisc_m, 0); 2961273f895SIvan Vecera } 2971273f895SIvan Vecera 298c1484691STony Nguyen return status; 2995eda8afdSAkeem G Abodunrin } 3005eda8afdSAkeem G Abodunrin 3015eda8afdSAkeem G Abodunrin /** 3024b889474SMichal Swiatkowski * ice_get_devlink_port - Get devlink port from netdev 3034b889474SMichal Swiatkowski * @netdev: the netdevice structure 3044b889474SMichal Swiatkowski */ 3054b889474SMichal Swiatkowski static struct devlink_port *ice_get_devlink_port(struct net_device *netdev) 3064b889474SMichal Swiatkowski { 3074b889474SMichal Swiatkowski struct ice_pf *pf = ice_netdev_to_pf(netdev); 3084b889474SMichal Swiatkowski 3094b889474SMichal Swiatkowski if (!ice_is_switchdev_running(pf)) 3104b889474SMichal Swiatkowski return NULL; 3114b889474SMichal Swiatkowski 3124b889474SMichal Swiatkowski return &pf->devlink_port; 3134b889474SMichal Swiatkowski } 3144b889474SMichal Swiatkowski 3154b889474SMichal Swiatkowski /** 316e94d4478SAnirudh Venkataramanan * ice_vsi_sync_fltr - Update the VSI filter list to the HW 317e94d4478SAnirudh Venkataramanan * @vsi: ptr to the VSI 318e94d4478SAnirudh Venkataramanan * 319e94d4478SAnirudh Venkataramanan * Push any outstanding VSI filter changes through the AdminQ. 320e94d4478SAnirudh Venkataramanan */ 321e94d4478SAnirudh Venkataramanan static int ice_vsi_sync_fltr(struct ice_vsi *vsi) 322e94d4478SAnirudh Venkataramanan { 323c31af68aSBrett Creeley struct ice_vsi_vlan_ops *vlan_ops = ice_get_compat_vsi_vlan_ops(vsi); 3249a946843SAnirudh Venkataramanan struct device *dev = ice_pf_to_dev(vsi->back); 325e94d4478SAnirudh Venkataramanan struct net_device *netdev = vsi->netdev; 326e94d4478SAnirudh Venkataramanan bool promisc_forced_on = false; 327e94d4478SAnirudh Venkataramanan struct ice_pf *pf = vsi->back; 328e94d4478SAnirudh Venkataramanan struct ice_hw *hw = &pf->hw; 329e94d4478SAnirudh Venkataramanan u32 changed_flags = 0; 3302ccc1c1cSTony Nguyen int err; 331e94d4478SAnirudh Venkataramanan 332e94d4478SAnirudh Venkataramanan if (!vsi->netdev) 333e94d4478SAnirudh Venkataramanan return -EINVAL; 334e94d4478SAnirudh Venkataramanan 3357e408e07SAnirudh Venkataramanan while (test_and_set_bit(ICE_CFG_BUSY, vsi->state)) 336e94d4478SAnirudh Venkataramanan usleep_range(1000, 2000); 337e94d4478SAnirudh Venkataramanan 338e94d4478SAnirudh Venkataramanan changed_flags = vsi->current_netdev_flags ^ vsi->netdev->flags; 339e94d4478SAnirudh Venkataramanan vsi->current_netdev_flags = vsi->netdev->flags; 340e94d4478SAnirudh Venkataramanan 341e94d4478SAnirudh Venkataramanan INIT_LIST_HEAD(&vsi->tmp_sync_list); 342e94d4478SAnirudh Venkataramanan INIT_LIST_HEAD(&vsi->tmp_unsync_list); 343e94d4478SAnirudh Venkataramanan 344e94d4478SAnirudh Venkataramanan if (ice_vsi_fltr_changed(vsi)) { 345e97fb1aeSAnirudh Venkataramanan clear_bit(ICE_VSI_UMAC_FLTR_CHANGED, vsi->state); 346e97fb1aeSAnirudh Venkataramanan clear_bit(ICE_VSI_MMAC_FLTR_CHANGED, vsi->state); 347e94d4478SAnirudh Venkataramanan 348e94d4478SAnirudh Venkataramanan /* grab the netdev's addr_list_lock */ 349e94d4478SAnirudh Venkataramanan netif_addr_lock_bh(netdev); 350e94d4478SAnirudh Venkataramanan __dev_uc_sync(netdev, ice_add_mac_to_sync_list, 351e94d4478SAnirudh Venkataramanan ice_add_mac_to_unsync_list); 352e94d4478SAnirudh Venkataramanan __dev_mc_sync(netdev, ice_add_mac_to_sync_list, 353e94d4478SAnirudh Venkataramanan ice_add_mac_to_unsync_list); 354e94d4478SAnirudh Venkataramanan /* our temp lists are populated. release lock */ 355e94d4478SAnirudh Venkataramanan netif_addr_unlock_bh(netdev); 356e94d4478SAnirudh Venkataramanan } 357e94d4478SAnirudh Venkataramanan 358f9867df6SAnirudh Venkataramanan /* Remove MAC addresses in the unsync list */ 3592ccc1c1cSTony Nguyen err = ice_fltr_remove_mac_list(vsi, &vsi->tmp_unsync_list); 3601b8f15b6SMichal Swiatkowski ice_fltr_free_list(dev, &vsi->tmp_unsync_list); 3612ccc1c1cSTony Nguyen if (err) { 362e94d4478SAnirudh Venkataramanan netdev_err(netdev, "Failed to delete MAC filters\n"); 363e94d4478SAnirudh Venkataramanan /* if we failed because of alloc failures, just bail */ 3642ccc1c1cSTony Nguyen if (err == -ENOMEM) 365e94d4478SAnirudh Venkataramanan goto out; 366e94d4478SAnirudh Venkataramanan } 367e94d4478SAnirudh Venkataramanan 368f9867df6SAnirudh Venkataramanan /* Add MAC addresses in the sync list */ 3692ccc1c1cSTony Nguyen err = ice_fltr_add_mac_list(vsi, &vsi->tmp_sync_list); 3701b8f15b6SMichal Swiatkowski ice_fltr_free_list(dev, &vsi->tmp_sync_list); 37189f3e4a5SPreethi Banala /* If filter is added successfully or already exists, do not go into 37289f3e4a5SPreethi Banala * 'if' condition and report it as error. Instead continue processing 37389f3e4a5SPreethi Banala * rest of the function. 37489f3e4a5SPreethi Banala */ 3752ccc1c1cSTony Nguyen if (err && err != -EEXIST) { 376e94d4478SAnirudh Venkataramanan netdev_err(netdev, "Failed to add MAC filters\n"); 377f9867df6SAnirudh Venkataramanan /* If there is no more space for new umac filters, VSI 378e94d4478SAnirudh Venkataramanan * should go into promiscuous mode. There should be some 379e94d4478SAnirudh Venkataramanan * space reserved for promiscuous filters. 380e94d4478SAnirudh Venkataramanan */ 381e94d4478SAnirudh Venkataramanan if (hw->adminq.sq_last_status == ICE_AQ_RC_ENOSPC && 3827e408e07SAnirudh Venkataramanan !test_and_set_bit(ICE_FLTR_OVERFLOW_PROMISC, 383e94d4478SAnirudh Venkataramanan vsi->state)) { 384e94d4478SAnirudh Venkataramanan promisc_forced_on = true; 38519cce2c6SAnirudh Venkataramanan netdev_warn(netdev, "Reached MAC filter limit, forcing promisc mode on VSI %d\n", 386e94d4478SAnirudh Venkataramanan vsi->vsi_num); 387e94d4478SAnirudh Venkataramanan } else { 388e94d4478SAnirudh Venkataramanan goto out; 389e94d4478SAnirudh Venkataramanan } 390e94d4478SAnirudh Venkataramanan } 3912ccc1c1cSTony Nguyen err = 0; 392e94d4478SAnirudh Venkataramanan /* check for changes in promiscuous modes */ 3935eda8afdSAkeem G Abodunrin if (changed_flags & IFF_ALLMULTI) { 3945eda8afdSAkeem G Abodunrin if (vsi->current_netdev_flags & IFF_ALLMULTI) { 3951273f895SIvan Vecera err = ice_set_promisc(vsi, ICE_MCAST_PROMISC_BITS); 3965eda8afdSAkeem G Abodunrin if (err) { 3975eda8afdSAkeem G Abodunrin vsi->current_netdev_flags &= ~IFF_ALLMULTI; 3985eda8afdSAkeem G Abodunrin goto out_promisc; 3995eda8afdSAkeem G Abodunrin } 40092ace482SBruce Allan } else { 40192ace482SBruce Allan /* !(vsi->current_netdev_flags & IFF_ALLMULTI) */ 4021273f895SIvan Vecera err = ice_clear_promisc(vsi, ICE_MCAST_PROMISC_BITS); 4035eda8afdSAkeem G Abodunrin if (err) { 4045eda8afdSAkeem G Abodunrin vsi->current_netdev_flags |= IFF_ALLMULTI; 4055eda8afdSAkeem G Abodunrin goto out_promisc; 4065eda8afdSAkeem G Abodunrin } 4075eda8afdSAkeem G Abodunrin } 4085eda8afdSAkeem G Abodunrin } 409e94d4478SAnirudh Venkataramanan 410e94d4478SAnirudh Venkataramanan if (((changed_flags & IFF_PROMISC) || promisc_forced_on) || 411e97fb1aeSAnirudh Venkataramanan test_bit(ICE_VSI_PROMISC_CHANGED, vsi->state)) { 412e97fb1aeSAnirudh Venkataramanan clear_bit(ICE_VSI_PROMISC_CHANGED, vsi->state); 413e94d4478SAnirudh Venkataramanan if (vsi->current_netdev_flags & IFF_PROMISC) { 414f9867df6SAnirudh Venkataramanan /* Apply Rx filter rule to get traffic from wire */ 415d7393425SMichal Wilczynski if (!ice_is_dflt_vsi_in_use(vsi->port_info)) { 416d7393425SMichal Wilczynski err = ice_set_dflt_vsi(vsi); 417fc0f39bcSBrett Creeley if (err && err != -EEXIST) { 41819cce2c6SAnirudh Venkataramanan netdev_err(netdev, "Error %d setting default VSI %i Rx rule\n", 419fc0f39bcSBrett Creeley err, vsi->vsi_num); 420fc0f39bcSBrett Creeley vsi->current_netdev_flags &= 421fc0f39bcSBrett Creeley ~IFF_PROMISC; 422e94d4478SAnirudh Venkataramanan goto out_promisc; 423e94d4478SAnirudh Venkataramanan } 4242ccc1c1cSTony Nguyen err = 0; 425c31af68aSBrett Creeley vlan_ops->dis_rx_filtering(vsi); 426fc0f39bcSBrett Creeley } 427e94d4478SAnirudh Venkataramanan } else { 428f9867df6SAnirudh Venkataramanan /* Clear Rx filter to remove traffic from wire */ 429d7393425SMichal Wilczynski if (ice_is_vsi_dflt_vsi(vsi)) { 430d7393425SMichal Wilczynski err = ice_clear_dflt_vsi(vsi); 431fc0f39bcSBrett Creeley if (err) { 43219cce2c6SAnirudh Venkataramanan netdev_err(netdev, "Error %d clearing default VSI %i Rx rule\n", 433fc0f39bcSBrett Creeley err, vsi->vsi_num); 434fc0f39bcSBrett Creeley vsi->current_netdev_flags |= 435fc0f39bcSBrett Creeley IFF_PROMISC; 436e94d4478SAnirudh Venkataramanan goto out_promisc; 437e94d4478SAnirudh Venkataramanan } 4387dc839feSJian Shen if (vsi->netdev->features & 4391babaf77SBrett Creeley NETIF_F_HW_VLAN_CTAG_FILTER) 440c31af68aSBrett Creeley vlan_ops->ena_rx_filtering(vsi); 441e94d4478SAnirudh Venkataramanan } 442e94d4478SAnirudh Venkataramanan } 443fc0f39bcSBrett Creeley } 444e94d4478SAnirudh Venkataramanan goto exit; 445e94d4478SAnirudh Venkataramanan 446e94d4478SAnirudh Venkataramanan out_promisc: 447e97fb1aeSAnirudh Venkataramanan set_bit(ICE_VSI_PROMISC_CHANGED, vsi->state); 448e94d4478SAnirudh Venkataramanan goto exit; 449e94d4478SAnirudh Venkataramanan out: 450e94d4478SAnirudh Venkataramanan /* if something went wrong then set the changed flag so we try again */ 451e97fb1aeSAnirudh Venkataramanan set_bit(ICE_VSI_UMAC_FLTR_CHANGED, vsi->state); 452e97fb1aeSAnirudh Venkataramanan set_bit(ICE_VSI_MMAC_FLTR_CHANGED, vsi->state); 453e94d4478SAnirudh Venkataramanan exit: 4547e408e07SAnirudh Venkataramanan clear_bit(ICE_CFG_BUSY, vsi->state); 455e94d4478SAnirudh Venkataramanan return err; 456e94d4478SAnirudh Venkataramanan } 457e94d4478SAnirudh Venkataramanan 458e94d4478SAnirudh Venkataramanan /** 459e94d4478SAnirudh Venkataramanan * ice_sync_fltr_subtask - Sync the VSI filter list with HW 460e94d4478SAnirudh Venkataramanan * @pf: board private structure 461e94d4478SAnirudh Venkataramanan */ 462e94d4478SAnirudh Venkataramanan static void ice_sync_fltr_subtask(struct ice_pf *pf) 463e94d4478SAnirudh Venkataramanan { 464e94d4478SAnirudh Venkataramanan int v; 465e94d4478SAnirudh Venkataramanan 466e94d4478SAnirudh Venkataramanan if (!pf || !(test_bit(ICE_FLAG_FLTR_SYNC, pf->flags))) 467e94d4478SAnirudh Venkataramanan return; 468e94d4478SAnirudh Venkataramanan 469e94d4478SAnirudh Venkataramanan clear_bit(ICE_FLAG_FLTR_SYNC, pf->flags); 470e94d4478SAnirudh Venkataramanan 47180ed404aSBrett Creeley ice_for_each_vsi(pf, v) 472e94d4478SAnirudh Venkataramanan if (pf->vsi[v] && ice_vsi_fltr_changed(pf->vsi[v]) && 473e94d4478SAnirudh Venkataramanan ice_vsi_sync_fltr(pf->vsi[v])) { 474e94d4478SAnirudh Venkataramanan /* come back and try again later */ 475e94d4478SAnirudh Venkataramanan set_bit(ICE_FLAG_FLTR_SYNC, pf->flags); 476e94d4478SAnirudh Venkataramanan break; 477e94d4478SAnirudh Venkataramanan } 478e94d4478SAnirudh Venkataramanan } 479e94d4478SAnirudh Venkataramanan 480e94d4478SAnirudh Venkataramanan /** 4817b9ffc76SAnirudh Venkataramanan * ice_pf_dis_all_vsi - Pause all VSIs on a PF 4827b9ffc76SAnirudh Venkataramanan * @pf: the PF 4837b9ffc76SAnirudh Venkataramanan * @locked: is the rtnl_lock already held 4847b9ffc76SAnirudh Venkataramanan */ 4857b9ffc76SAnirudh Venkataramanan static void ice_pf_dis_all_vsi(struct ice_pf *pf, bool locked) 4867b9ffc76SAnirudh Venkataramanan { 487b126bd6bSKiran Patil int node; 4887b9ffc76SAnirudh Venkataramanan int v; 4897b9ffc76SAnirudh Venkataramanan 4907b9ffc76SAnirudh Venkataramanan ice_for_each_vsi(pf, v) 4917b9ffc76SAnirudh Venkataramanan if (pf->vsi[v]) 4927b9ffc76SAnirudh Venkataramanan ice_dis_vsi(pf->vsi[v], locked); 493b126bd6bSKiran Patil 494b126bd6bSKiran Patil for (node = 0; node < ICE_MAX_PF_AGG_NODES; node++) 495b126bd6bSKiran Patil pf->pf_agg_node[node].num_vsis = 0; 496b126bd6bSKiran Patil 497b126bd6bSKiran Patil for (node = 0; node < ICE_MAX_VF_AGG_NODES; node++) 498b126bd6bSKiran Patil pf->vf_agg_node[node].num_vsis = 0; 4997b9ffc76SAnirudh Venkataramanan } 5007b9ffc76SAnirudh Venkataramanan 5017b9ffc76SAnirudh Venkataramanan /** 502c1e5da5dSWojciech Drewek * ice_clear_sw_switch_recipes - clear switch recipes 503c1e5da5dSWojciech Drewek * @pf: board private structure 504c1e5da5dSWojciech Drewek * 505c1e5da5dSWojciech Drewek * Mark switch recipes as not created in sw structures. There are cases where 506c1e5da5dSWojciech Drewek * rules (especially advanced rules) need to be restored, either re-read from 507c1e5da5dSWojciech Drewek * hardware or added again. For example after the reset. 'recp_created' flag 508c1e5da5dSWojciech Drewek * prevents from doing that and need to be cleared upfront. 509c1e5da5dSWojciech Drewek */ 510c1e5da5dSWojciech Drewek static void ice_clear_sw_switch_recipes(struct ice_pf *pf) 511c1e5da5dSWojciech Drewek { 512c1e5da5dSWojciech Drewek struct ice_sw_recipe *recp; 513c1e5da5dSWojciech Drewek u8 i; 514c1e5da5dSWojciech Drewek 515c1e5da5dSWojciech Drewek recp = pf->hw.switch_info->recp_list; 516c1e5da5dSWojciech Drewek for (i = 0; i < ICE_MAX_NUM_RECIPES; i++) 517c1e5da5dSWojciech Drewek recp[i].recp_created = false; 518c1e5da5dSWojciech Drewek } 519c1e5da5dSWojciech Drewek 520c1e5da5dSWojciech Drewek /** 521fbc7b27aSKiran Patil * ice_prepare_for_reset - prep for reset 5220b28b702SAnirudh Venkataramanan * @pf: board private structure 523fbc7b27aSKiran Patil * @reset_type: reset type requested 5240b28b702SAnirudh Venkataramanan * 5250b28b702SAnirudh Venkataramanan * Inform or close all dependent features in prep for reset. 5260b28b702SAnirudh Venkataramanan */ 5270b28b702SAnirudh Venkataramanan static void 528fbc7b27aSKiran Patil ice_prepare_for_reset(struct ice_pf *pf, enum ice_reset_req reset_type) 5290b28b702SAnirudh Venkataramanan { 5300b28b702SAnirudh Venkataramanan struct ice_hw *hw = &pf->hw; 531fbc7b27aSKiran Patil struct ice_vsi *vsi; 532c4c2c7dbSJacob Keller struct ice_vf *vf; 533c4c2c7dbSJacob Keller unsigned int bkt; 5340b28b702SAnirudh Venkataramanan 535fbc7b27aSKiran Patil dev_dbg(ice_pf_to_dev(pf), "reset_type=%d\n", reset_type); 536fbc7b27aSKiran Patil 5375abac9d7SBrett Creeley /* already prepared for reset */ 5387e408e07SAnirudh Venkataramanan if (test_bit(ICE_PREPARED_FOR_RESET, pf->state)) 5395abac9d7SBrett Creeley return; 5405abac9d7SBrett Creeley 541f9f5301eSDave Ertman ice_unplug_aux_dev(pf); 542f9f5301eSDave Ertman 543007676b4SAnirudh Venkataramanan /* Notify VFs of impending reset */ 544007676b4SAnirudh Venkataramanan if (ice_check_sq_alive(hw, &hw->mailboxq)) 545007676b4SAnirudh Venkataramanan ice_vc_notify_reset(pf); 546007676b4SAnirudh Venkataramanan 547c7aeb4d1SAkeem G Abodunrin /* Disable VFs until reset is completed */ 5483d5985a1SJacob Keller mutex_lock(&pf->vfs.table_lock); 549c4c2c7dbSJacob Keller ice_for_each_vf(pf, bkt, vf) 550c4c2c7dbSJacob Keller ice_set_vf_state_qs_dis(vf); 5513d5985a1SJacob Keller mutex_unlock(&pf->vfs.table_lock); 552c7aeb4d1SAkeem G Abodunrin 553c1e5da5dSWojciech Drewek if (ice_is_eswitch_mode_switchdev(pf)) { 554c1e5da5dSWojciech Drewek if (reset_type != ICE_RESET_PFR) 555c1e5da5dSWojciech Drewek ice_clear_sw_switch_recipes(pf); 556c1e5da5dSWojciech Drewek } 557c1e5da5dSWojciech Drewek 558fbc7b27aSKiran Patil /* release ADQ specific HW and SW resources */ 559fbc7b27aSKiran Patil vsi = ice_get_main_vsi(pf); 560fbc7b27aSKiran Patil if (!vsi) 561fbc7b27aSKiran Patil goto skip; 562fbc7b27aSKiran Patil 563fbc7b27aSKiran Patil /* to be on safe side, reset orig_rss_size so that normal flow 564fbc7b27aSKiran Patil * of deciding rss_size can take precedence 565fbc7b27aSKiran Patil */ 566fbc7b27aSKiran Patil vsi->orig_rss_size = 0; 567fbc7b27aSKiran Patil 568fbc7b27aSKiran Patil if (test_bit(ICE_FLAG_TC_MQPRIO, pf->flags)) { 569fbc7b27aSKiran Patil if (reset_type == ICE_RESET_PFR) { 570fbc7b27aSKiran Patil vsi->old_ena_tc = vsi->all_enatc; 571fbc7b27aSKiran Patil vsi->old_numtc = vsi->all_numtc; 572fbc7b27aSKiran Patil } else { 573fbc7b27aSKiran Patil ice_remove_q_channels(vsi, true); 574fbc7b27aSKiran Patil 575fbc7b27aSKiran Patil /* for other reset type, do not support channel rebuild 576fbc7b27aSKiran Patil * hence reset needed info 577fbc7b27aSKiran Patil */ 578fbc7b27aSKiran Patil vsi->old_ena_tc = 0; 579fbc7b27aSKiran Patil vsi->all_enatc = 0; 580fbc7b27aSKiran Patil vsi->old_numtc = 0; 581fbc7b27aSKiran Patil vsi->all_numtc = 0; 582fbc7b27aSKiran Patil vsi->req_txq = 0; 583fbc7b27aSKiran Patil vsi->req_rxq = 0; 584fbc7b27aSKiran Patil clear_bit(ICE_FLAG_TC_MQPRIO, pf->flags); 585fbc7b27aSKiran Patil memset(&vsi->mqprio_qopt, 0, sizeof(vsi->mqprio_qopt)); 586fbc7b27aSKiran Patil } 587fbc7b27aSKiran Patil } 588fbc7b27aSKiran Patil skip: 589fbc7b27aSKiran Patil 590462acf6aSTony Nguyen /* clear SW filtering DB */ 591462acf6aSTony Nguyen ice_clear_hw_tbls(hw); 5920b28b702SAnirudh Venkataramanan /* disable the VSIs and their queues that are not already DOWN */ 5937b9ffc76SAnirudh Venkataramanan ice_pf_dis_all_vsi(pf, false); 5940b28b702SAnirudh Venkataramanan 59506c16d89SJacob Keller if (test_bit(ICE_FLAG_PTP_SUPPORTED, pf->flags)) 59648096710SKarol Kolacinski ice_ptp_prepare_for_reset(pf); 59706c16d89SJacob Keller 59843113ff7SKarol Kolacinski if (ice_is_feature_supported(pf, ICE_F_GNSS)) 59943113ff7SKarol Kolacinski ice_gnss_exit(pf); 60043113ff7SKarol Kolacinski 601c5a2a4a3SUsha Ketineni if (hw->port_info) 602c5a2a4a3SUsha Ketineni ice_sched_clear_port(hw->port_info); 603c5a2a4a3SUsha Ketineni 6040b28b702SAnirudh Venkataramanan ice_shutdown_all_ctrlq(hw); 6050f9d5027SAnirudh Venkataramanan 6067e408e07SAnirudh Venkataramanan set_bit(ICE_PREPARED_FOR_RESET, pf->state); 6070b28b702SAnirudh Venkataramanan } 6080b28b702SAnirudh Venkataramanan 6090b28b702SAnirudh Venkataramanan /** 6100b28b702SAnirudh Venkataramanan * ice_do_reset - Initiate one of many types of resets 6110b28b702SAnirudh Venkataramanan * @pf: board private structure 612fbc7b27aSKiran Patil * @reset_type: reset type requested before this function was called. 6130b28b702SAnirudh Venkataramanan */ 6140b28b702SAnirudh Venkataramanan static void ice_do_reset(struct ice_pf *pf, enum ice_reset_req reset_type) 6150b28b702SAnirudh Venkataramanan { 6164015d11eSBrett Creeley struct device *dev = ice_pf_to_dev(pf); 6170b28b702SAnirudh Venkataramanan struct ice_hw *hw = &pf->hw; 6180b28b702SAnirudh Venkataramanan 6190b28b702SAnirudh Venkataramanan dev_dbg(dev, "reset_type 0x%x requested\n", reset_type); 6200b28b702SAnirudh Venkataramanan 621fbc7b27aSKiran Patil ice_prepare_for_reset(pf, reset_type); 6220b28b702SAnirudh Venkataramanan 6230b28b702SAnirudh Venkataramanan /* trigger the reset */ 6240b28b702SAnirudh Venkataramanan if (ice_reset(hw, reset_type)) { 6250b28b702SAnirudh Venkataramanan dev_err(dev, "reset %d failed\n", reset_type); 6267e408e07SAnirudh Venkataramanan set_bit(ICE_RESET_FAILED, pf->state); 6277e408e07SAnirudh Venkataramanan clear_bit(ICE_RESET_OICR_RECV, pf->state); 6287e408e07SAnirudh Venkataramanan clear_bit(ICE_PREPARED_FOR_RESET, pf->state); 6297e408e07SAnirudh Venkataramanan clear_bit(ICE_PFR_REQ, pf->state); 6307e408e07SAnirudh Venkataramanan clear_bit(ICE_CORER_REQ, pf->state); 6317e408e07SAnirudh Venkataramanan clear_bit(ICE_GLOBR_REQ, pf->state); 6321c08052eSJacob Keller wake_up(&pf->reset_wait_queue); 6330b28b702SAnirudh Venkataramanan return; 6340b28b702SAnirudh Venkataramanan } 6350b28b702SAnirudh Venkataramanan 6360f9d5027SAnirudh Venkataramanan /* PFR is a bit of a special case because it doesn't result in an OICR 6370f9d5027SAnirudh Venkataramanan * interrupt. So for PFR, rebuild after the reset and clear the reset- 6380f9d5027SAnirudh Venkataramanan * associated state bits. 6390f9d5027SAnirudh Venkataramanan */ 6400b28b702SAnirudh Venkataramanan if (reset_type == ICE_RESET_PFR) { 6410b28b702SAnirudh Venkataramanan pf->pfr_count++; 642462acf6aSTony Nguyen ice_rebuild(pf, reset_type); 6437e408e07SAnirudh Venkataramanan clear_bit(ICE_PREPARED_FOR_RESET, pf->state); 6447e408e07SAnirudh Venkataramanan clear_bit(ICE_PFR_REQ, pf->state); 6451c08052eSJacob Keller wake_up(&pf->reset_wait_queue); 646dac57288SJacob Keller ice_reset_all_vfs(pf); 6470b28b702SAnirudh Venkataramanan } 6480b28b702SAnirudh Venkataramanan } 6490b28b702SAnirudh Venkataramanan 6500b28b702SAnirudh Venkataramanan /** 6510b28b702SAnirudh Venkataramanan * ice_reset_subtask - Set up for resetting the device and driver 6520b28b702SAnirudh Venkataramanan * @pf: board private structure 6530b28b702SAnirudh Venkataramanan */ 6540b28b702SAnirudh Venkataramanan static void ice_reset_subtask(struct ice_pf *pf) 6550b28b702SAnirudh Venkataramanan { 6560f9d5027SAnirudh Venkataramanan enum ice_reset_req reset_type = ICE_RESET_INVAL; 6570b28b702SAnirudh Venkataramanan 6580b28b702SAnirudh Venkataramanan /* When a CORER/GLOBR/EMPR is about to happen, the hardware triggers an 6590f9d5027SAnirudh Venkataramanan * OICR interrupt. The OICR handler (ice_misc_intr) determines what type 6600f9d5027SAnirudh Venkataramanan * of reset is pending and sets bits in pf->state indicating the reset 6617e408e07SAnirudh Venkataramanan * type and ICE_RESET_OICR_RECV. So, if the latter bit is set 6620f9d5027SAnirudh Venkataramanan * prepare for pending reset if not already (for PF software-initiated 6630f9d5027SAnirudh Venkataramanan * global resets the software should already be prepared for it as 6647e408e07SAnirudh Venkataramanan * indicated by ICE_PREPARED_FOR_RESET; for global resets initiated 6650f9d5027SAnirudh Venkataramanan * by firmware or software on other PFs, that bit is not set so prepare 6660f9d5027SAnirudh Venkataramanan * for the reset now), poll for reset done, rebuild and return. 6670b28b702SAnirudh Venkataramanan */ 6687e408e07SAnirudh Venkataramanan if (test_bit(ICE_RESET_OICR_RECV, pf->state)) { 6692ebd4428SDave Ertman /* Perform the largest reset requested */ 6707e408e07SAnirudh Venkataramanan if (test_and_clear_bit(ICE_CORER_RECV, pf->state)) 6712ebd4428SDave Ertman reset_type = ICE_RESET_CORER; 6727e408e07SAnirudh Venkataramanan if (test_and_clear_bit(ICE_GLOBR_RECV, pf->state)) 6732ebd4428SDave Ertman reset_type = ICE_RESET_GLOBR; 6747e408e07SAnirudh Venkataramanan if (test_and_clear_bit(ICE_EMPR_RECV, pf->state)) 67503af8406SAnirudh Venkataramanan reset_type = ICE_RESET_EMPR; 6762ebd4428SDave Ertman /* return if no valid reset type requested */ 6772ebd4428SDave Ertman if (reset_type == ICE_RESET_INVAL) 6782ebd4428SDave Ertman return; 679fbc7b27aSKiran Patil ice_prepare_for_reset(pf, reset_type); 6800b28b702SAnirudh Venkataramanan 6810b28b702SAnirudh Venkataramanan /* make sure we are ready to rebuild */ 682fd2a9817SAnirudh Venkataramanan if (ice_check_reset(&pf->hw)) { 6837e408e07SAnirudh Venkataramanan set_bit(ICE_RESET_FAILED, pf->state); 684fd2a9817SAnirudh Venkataramanan } else { 685fd2a9817SAnirudh Venkataramanan /* done with reset. start rebuild */ 686fd2a9817SAnirudh Venkataramanan pf->hw.reset_ongoing = false; 687462acf6aSTony Nguyen ice_rebuild(pf, reset_type); 6880f9d5027SAnirudh Venkataramanan /* clear bit to resume normal operations, but 6890f9d5027SAnirudh Venkataramanan * ICE_NEEDS_RESTART bit is set in case rebuild failed 6900f9d5027SAnirudh Venkataramanan */ 6917e408e07SAnirudh Venkataramanan clear_bit(ICE_RESET_OICR_RECV, pf->state); 6927e408e07SAnirudh Venkataramanan clear_bit(ICE_PREPARED_FOR_RESET, pf->state); 6937e408e07SAnirudh Venkataramanan clear_bit(ICE_PFR_REQ, pf->state); 6947e408e07SAnirudh Venkataramanan clear_bit(ICE_CORER_REQ, pf->state); 6957e408e07SAnirudh Venkataramanan clear_bit(ICE_GLOBR_REQ, pf->state); 6961c08052eSJacob Keller wake_up(&pf->reset_wait_queue); 697dac57288SJacob Keller ice_reset_all_vfs(pf); 6980f9d5027SAnirudh Venkataramanan } 6990f9d5027SAnirudh Venkataramanan 7000f9d5027SAnirudh Venkataramanan return; 7010b28b702SAnirudh Venkataramanan } 7020b28b702SAnirudh Venkataramanan 7030b28b702SAnirudh Venkataramanan /* No pending resets to finish processing. Check for new resets */ 7047e408e07SAnirudh Venkataramanan if (test_bit(ICE_PFR_REQ, pf->state)) 7050f9d5027SAnirudh Venkataramanan reset_type = ICE_RESET_PFR; 7067e408e07SAnirudh Venkataramanan if (test_bit(ICE_CORER_REQ, pf->state)) 7070f9d5027SAnirudh Venkataramanan reset_type = ICE_RESET_CORER; 7087e408e07SAnirudh Venkataramanan if (test_bit(ICE_GLOBR_REQ, pf->state)) 7090b28b702SAnirudh Venkataramanan reset_type = ICE_RESET_GLOBR; 7100f9d5027SAnirudh Venkataramanan /* If no valid reset type requested just return */ 7110f9d5027SAnirudh Venkataramanan if (reset_type == ICE_RESET_INVAL) 7120f9d5027SAnirudh Venkataramanan return; 7130b28b702SAnirudh Venkataramanan 7140f9d5027SAnirudh Venkataramanan /* reset if not already down or busy */ 7157e408e07SAnirudh Venkataramanan if (!test_bit(ICE_DOWN, pf->state) && 7167e408e07SAnirudh Venkataramanan !test_bit(ICE_CFG_BUSY, pf->state)) { 7170b28b702SAnirudh Venkataramanan ice_do_reset(pf, reset_type); 7180b28b702SAnirudh Venkataramanan } 7190b28b702SAnirudh Venkataramanan } 7200b28b702SAnirudh Venkataramanan 7210b28b702SAnirudh Venkataramanan /** 7222e0ab37cSJesse Brandeburg * ice_print_topo_conflict - print topology conflict message 7232e0ab37cSJesse Brandeburg * @vsi: the VSI whose topology status is being checked 7242e0ab37cSJesse Brandeburg */ 7252e0ab37cSJesse Brandeburg static void ice_print_topo_conflict(struct ice_vsi *vsi) 7262e0ab37cSJesse Brandeburg { 7272e0ab37cSJesse Brandeburg switch (vsi->port_info->phy.link_info.topo_media_conflict) { 7282e0ab37cSJesse Brandeburg case ICE_AQ_LINK_TOPO_CONFLICT: 7292e0ab37cSJesse Brandeburg case ICE_AQ_LINK_MEDIA_CONFLICT: 7305878589dSPaul Greenwalt case ICE_AQ_LINK_TOPO_UNREACH_PRT: 7315878589dSPaul Greenwalt case ICE_AQ_LINK_TOPO_UNDRUTIL_PRT: 7325878589dSPaul Greenwalt case ICE_AQ_LINK_TOPO_UNDRUTIL_MEDIA: 7335c57145aSPaul Greenwalt netdev_info(vsi->netdev, "Potential misconfiguration of the Ethernet port detected. If it was not intended, please use the Intel (R) Ethernet Port Configuration Tool to address the issue.\n"); 7342e0ab37cSJesse Brandeburg break; 7355878589dSPaul Greenwalt case ICE_AQ_LINK_TOPO_UNSUPP_MEDIA: 7364fc5fbeeSAnirudh Venkataramanan if (test_bit(ICE_FLAG_LINK_LENIENT_MODE_ENA, vsi->back->flags)) 7374fc5fbeeSAnirudh Venkataramanan netdev_warn(vsi->netdev, "An unsupported module type was detected. Refer to the Intel(R) Ethernet Adapters and Devices User Guide for a list of supported modules\n"); 7384fc5fbeeSAnirudh Venkataramanan else 7394fc5fbeeSAnirudh Venkataramanan netdev_err(vsi->netdev, "Rx/Tx is disabled on this device because an unsupported module type was detected. Refer to the Intel(R) Ethernet Adapters and Devices User Guide for a list of supported modules.\n"); 7405878589dSPaul Greenwalt break; 7412e0ab37cSJesse Brandeburg default: 7422e0ab37cSJesse Brandeburg break; 7432e0ab37cSJesse Brandeburg } 7442e0ab37cSJesse Brandeburg } 7452e0ab37cSJesse Brandeburg 7462e0ab37cSJesse Brandeburg /** 747cdedef59SAnirudh Venkataramanan * ice_print_link_msg - print link up or down message 748cdedef59SAnirudh Venkataramanan * @vsi: the VSI whose link status is being queried 749cdedef59SAnirudh Venkataramanan * @isup: boolean for if the link is now up or down 750cdedef59SAnirudh Venkataramanan */ 751fcea6f3dSAnirudh Venkataramanan void ice_print_link_msg(struct ice_vsi *vsi, bool isup) 752cdedef59SAnirudh Venkataramanan { 753f776b3acSPaul Greenwalt struct ice_aqc_get_phy_caps_data *caps; 7545ee30564SPaul Greenwalt const char *an_advertised; 755f776b3acSPaul Greenwalt const char *fec_req; 756cdedef59SAnirudh Venkataramanan const char *speed; 757f776b3acSPaul Greenwalt const char *fec; 758cdedef59SAnirudh Venkataramanan const char *fc; 75943260988SJesse Brandeburg const char *an; 7605518ac2aSTony Nguyen int status; 761cdedef59SAnirudh Venkataramanan 762c2a23e00SBrett Creeley if (!vsi) 763c2a23e00SBrett Creeley return; 764c2a23e00SBrett Creeley 765cdedef59SAnirudh Venkataramanan if (vsi->current_isup == isup) 766cdedef59SAnirudh Venkataramanan return; 767cdedef59SAnirudh Venkataramanan 768cdedef59SAnirudh Venkataramanan vsi->current_isup = isup; 769cdedef59SAnirudh Venkataramanan 770cdedef59SAnirudh Venkataramanan if (!isup) { 771cdedef59SAnirudh Venkataramanan netdev_info(vsi->netdev, "NIC Link is Down\n"); 772cdedef59SAnirudh Venkataramanan return; 773cdedef59SAnirudh Venkataramanan } 774cdedef59SAnirudh Venkataramanan 775cdedef59SAnirudh Venkataramanan switch (vsi->port_info->phy.link_info.link_speed) { 776072efdf8SAnirudh Venkataramanan case ICE_AQ_LINK_SPEED_100GB: 777072efdf8SAnirudh Venkataramanan speed = "100 G"; 778072efdf8SAnirudh Venkataramanan break; 779072efdf8SAnirudh Venkataramanan case ICE_AQ_LINK_SPEED_50GB: 780072efdf8SAnirudh Venkataramanan speed = "50 G"; 781072efdf8SAnirudh Venkataramanan break; 782cdedef59SAnirudh Venkataramanan case ICE_AQ_LINK_SPEED_40GB: 783cdedef59SAnirudh Venkataramanan speed = "40 G"; 784cdedef59SAnirudh Venkataramanan break; 785cdedef59SAnirudh Venkataramanan case ICE_AQ_LINK_SPEED_25GB: 786cdedef59SAnirudh Venkataramanan speed = "25 G"; 787cdedef59SAnirudh Venkataramanan break; 788cdedef59SAnirudh Venkataramanan case ICE_AQ_LINK_SPEED_20GB: 789cdedef59SAnirudh Venkataramanan speed = "20 G"; 790cdedef59SAnirudh Venkataramanan break; 791cdedef59SAnirudh Venkataramanan case ICE_AQ_LINK_SPEED_10GB: 792cdedef59SAnirudh Venkataramanan speed = "10 G"; 793cdedef59SAnirudh Venkataramanan break; 794cdedef59SAnirudh Venkataramanan case ICE_AQ_LINK_SPEED_5GB: 795cdedef59SAnirudh Venkataramanan speed = "5 G"; 796cdedef59SAnirudh Venkataramanan break; 797cdedef59SAnirudh Venkataramanan case ICE_AQ_LINK_SPEED_2500MB: 798cdedef59SAnirudh Venkataramanan speed = "2.5 G"; 799cdedef59SAnirudh Venkataramanan break; 800cdedef59SAnirudh Venkataramanan case ICE_AQ_LINK_SPEED_1000MB: 801cdedef59SAnirudh Venkataramanan speed = "1 G"; 802cdedef59SAnirudh Venkataramanan break; 803cdedef59SAnirudh Venkataramanan case ICE_AQ_LINK_SPEED_100MB: 804cdedef59SAnirudh Venkataramanan speed = "100 M"; 805cdedef59SAnirudh Venkataramanan break; 806cdedef59SAnirudh Venkataramanan default: 807cdedef59SAnirudh Venkataramanan speed = "Unknown "; 808cdedef59SAnirudh Venkataramanan break; 809cdedef59SAnirudh Venkataramanan } 810cdedef59SAnirudh Venkataramanan 811cdedef59SAnirudh Venkataramanan switch (vsi->port_info->fc.current_mode) { 812cdedef59SAnirudh Venkataramanan case ICE_FC_FULL: 8132f2da36eSAnirudh Venkataramanan fc = "Rx/Tx"; 814cdedef59SAnirudh Venkataramanan break; 815cdedef59SAnirudh Venkataramanan case ICE_FC_TX_PAUSE: 8162f2da36eSAnirudh Venkataramanan fc = "Tx"; 817cdedef59SAnirudh Venkataramanan break; 818cdedef59SAnirudh Venkataramanan case ICE_FC_RX_PAUSE: 8192f2da36eSAnirudh Venkataramanan fc = "Rx"; 820cdedef59SAnirudh Venkataramanan break; 821203a068aSBrett Creeley case ICE_FC_NONE: 822203a068aSBrett Creeley fc = "None"; 823203a068aSBrett Creeley break; 824cdedef59SAnirudh Venkataramanan default: 825cdedef59SAnirudh Venkataramanan fc = "Unknown"; 826cdedef59SAnirudh Venkataramanan break; 827cdedef59SAnirudh Venkataramanan } 828cdedef59SAnirudh Venkataramanan 829f776b3acSPaul Greenwalt /* Get FEC mode based on negotiated link info */ 830f776b3acSPaul Greenwalt switch (vsi->port_info->phy.link_info.fec_info) { 831f776b3acSPaul Greenwalt case ICE_AQ_LINK_25G_RS_528_FEC_EN: 832f776b3acSPaul Greenwalt case ICE_AQ_LINK_25G_RS_544_FEC_EN: 833f776b3acSPaul Greenwalt fec = "RS-FEC"; 834f776b3acSPaul Greenwalt break; 835f776b3acSPaul Greenwalt case ICE_AQ_LINK_25G_KR_FEC_EN: 836f776b3acSPaul Greenwalt fec = "FC-FEC/BASE-R"; 837f776b3acSPaul Greenwalt break; 838f776b3acSPaul Greenwalt default: 839f776b3acSPaul Greenwalt fec = "NONE"; 840f776b3acSPaul Greenwalt break; 841f776b3acSPaul Greenwalt } 842f776b3acSPaul Greenwalt 84343260988SJesse Brandeburg /* check if autoneg completed, might be false due to not supported */ 84443260988SJesse Brandeburg if (vsi->port_info->phy.link_info.an_info & ICE_AQ_AN_COMPLETED) 84543260988SJesse Brandeburg an = "True"; 84643260988SJesse Brandeburg else 84743260988SJesse Brandeburg an = "False"; 84843260988SJesse Brandeburg 849f776b3acSPaul Greenwalt /* Get FEC mode requested based on PHY caps last SW configuration */ 8509efe35d0STony Nguyen caps = kzalloc(sizeof(*caps), GFP_KERNEL); 851f776b3acSPaul Greenwalt if (!caps) { 852f776b3acSPaul Greenwalt fec_req = "Unknown"; 8535ee30564SPaul Greenwalt an_advertised = "Unknown"; 854f776b3acSPaul Greenwalt goto done; 855f776b3acSPaul Greenwalt } 856f776b3acSPaul Greenwalt 857f776b3acSPaul Greenwalt status = ice_aq_get_phy_caps(vsi->port_info, false, 858d6730a87SAnirudh Venkataramanan ICE_AQC_REPORT_ACTIVE_CFG, caps, NULL); 859f776b3acSPaul Greenwalt if (status) 860f776b3acSPaul Greenwalt netdev_info(vsi->netdev, "Get phy capability failed.\n"); 861f776b3acSPaul Greenwalt 8625ee30564SPaul Greenwalt an_advertised = ice_is_phy_caps_an_enabled(caps) ? "On" : "Off"; 8635ee30564SPaul Greenwalt 864f776b3acSPaul Greenwalt if (caps->link_fec_options & ICE_AQC_PHY_FEC_25G_RS_528_REQ || 865f776b3acSPaul Greenwalt caps->link_fec_options & ICE_AQC_PHY_FEC_25G_RS_544_REQ) 866f776b3acSPaul Greenwalt fec_req = "RS-FEC"; 867f776b3acSPaul Greenwalt else if (caps->link_fec_options & ICE_AQC_PHY_FEC_10G_KR_40G_KR4_REQ || 868f776b3acSPaul Greenwalt caps->link_fec_options & ICE_AQC_PHY_FEC_25G_KR_REQ) 869f776b3acSPaul Greenwalt fec_req = "FC-FEC/BASE-R"; 870f776b3acSPaul Greenwalt else 871f776b3acSPaul Greenwalt fec_req = "NONE"; 872f776b3acSPaul Greenwalt 8739efe35d0STony Nguyen kfree(caps); 874f776b3acSPaul Greenwalt 875f776b3acSPaul Greenwalt done: 8765ee30564SPaul Greenwalt netdev_info(vsi->netdev, "NIC Link is up %sbps Full Duplex, Requested FEC: %s, Negotiated FEC: %s, Autoneg Advertised: %s, Autoneg Negotiated: %s, Flow Control: %s\n", 8775ee30564SPaul Greenwalt speed, fec_req, fec, an_advertised, an, fc); 8782e0ab37cSJesse Brandeburg ice_print_topo_conflict(vsi); 879cdedef59SAnirudh Venkataramanan } 880cdedef59SAnirudh Venkataramanan 881cdedef59SAnirudh Venkataramanan /** 882f9867df6SAnirudh Venkataramanan * ice_vsi_link_event - update the VSI's netdev 883f9867df6SAnirudh Venkataramanan * @vsi: the VSI on which the link event occurred 884f9867df6SAnirudh Venkataramanan * @link_up: whether or not the VSI needs to be set up or down 8850b28b702SAnirudh Venkataramanan */ 8860b28b702SAnirudh Venkataramanan static void ice_vsi_link_event(struct ice_vsi *vsi, bool link_up) 8870b28b702SAnirudh Venkataramanan { 888c2a23e00SBrett Creeley if (!vsi) 889c2a23e00SBrett Creeley return; 890c2a23e00SBrett Creeley 891e97fb1aeSAnirudh Venkataramanan if (test_bit(ICE_VSI_DOWN, vsi->state) || !vsi->netdev) 8920b28b702SAnirudh Venkataramanan return; 8930b28b702SAnirudh Venkataramanan 8940b28b702SAnirudh Venkataramanan if (vsi->type == ICE_VSI_PF) { 895c2a23e00SBrett Creeley if (link_up == netif_carrier_ok(vsi->netdev)) 8960b28b702SAnirudh Venkataramanan return; 897c2a23e00SBrett Creeley 8980b28b702SAnirudh Venkataramanan if (link_up) { 8990b28b702SAnirudh Venkataramanan netif_carrier_on(vsi->netdev); 9000b28b702SAnirudh Venkataramanan netif_tx_wake_all_queues(vsi->netdev); 9010b28b702SAnirudh Venkataramanan } else { 9020b28b702SAnirudh Venkataramanan netif_carrier_off(vsi->netdev); 9030b28b702SAnirudh Venkataramanan netif_tx_stop_all_queues(vsi->netdev); 9040b28b702SAnirudh Venkataramanan } 9050b28b702SAnirudh Venkataramanan } 9060b28b702SAnirudh Venkataramanan } 9070b28b702SAnirudh Venkataramanan 9080b28b702SAnirudh Venkataramanan /** 9097d9c9b79SDave Ertman * ice_set_dflt_mib - send a default config MIB to the FW 9107d9c9b79SDave Ertman * @pf: private PF struct 9117d9c9b79SDave Ertman * 9127d9c9b79SDave Ertman * This function sends a default configuration MIB to the FW. 9137d9c9b79SDave Ertman * 9147d9c9b79SDave Ertman * If this function errors out at any point, the driver is still able to 9157d9c9b79SDave Ertman * function. The main impact is that LFC may not operate as expected. 9167d9c9b79SDave Ertman * Therefore an error state in this function should be treated with a DBG 9177d9c9b79SDave Ertman * message and continue on with driver rebuild/reenable. 9187d9c9b79SDave Ertman */ 9197d9c9b79SDave Ertman static void ice_set_dflt_mib(struct ice_pf *pf) 9207d9c9b79SDave Ertman { 9217d9c9b79SDave Ertman struct device *dev = ice_pf_to_dev(pf); 9227d9c9b79SDave Ertman u8 mib_type, *buf, *lldpmib = NULL; 9237d9c9b79SDave Ertman u16 len, typelen, offset = 0; 9247d9c9b79SDave Ertman struct ice_lldp_org_tlv *tlv; 92512aae8f1SBruce Allan struct ice_hw *hw = &pf->hw; 9267d9c9b79SDave Ertman u32 ouisubtype; 9277d9c9b79SDave Ertman 9287d9c9b79SDave Ertman mib_type = SET_LOCAL_MIB_TYPE_LOCAL_MIB; 9297d9c9b79SDave Ertman lldpmib = kzalloc(ICE_LLDPDU_SIZE, GFP_KERNEL); 9307d9c9b79SDave Ertman if (!lldpmib) { 9317d9c9b79SDave Ertman dev_dbg(dev, "%s Failed to allocate MIB memory\n", 9327d9c9b79SDave Ertman __func__); 9337d9c9b79SDave Ertman return; 9347d9c9b79SDave Ertman } 9357d9c9b79SDave Ertman 9367d9c9b79SDave Ertman /* Add ETS CFG TLV */ 9377d9c9b79SDave Ertman tlv = (struct ice_lldp_org_tlv *)lldpmib; 9387d9c9b79SDave Ertman typelen = ((ICE_TLV_TYPE_ORG << ICE_LLDP_TLV_TYPE_S) | 9397d9c9b79SDave Ertman ICE_IEEE_ETS_TLV_LEN); 9407d9c9b79SDave Ertman tlv->typelen = htons(typelen); 9417d9c9b79SDave Ertman ouisubtype = ((ICE_IEEE_8021QAZ_OUI << ICE_LLDP_TLV_OUI_S) | 9427d9c9b79SDave Ertman ICE_IEEE_SUBTYPE_ETS_CFG); 9437d9c9b79SDave Ertman tlv->ouisubtype = htonl(ouisubtype); 9447d9c9b79SDave Ertman 9457d9c9b79SDave Ertman buf = tlv->tlvinfo; 9467d9c9b79SDave Ertman buf[0] = 0; 9477d9c9b79SDave Ertman 9487d9c9b79SDave Ertman /* ETS CFG all UPs map to TC 0. Next 4 (1 - 4) Octets = 0. 9497d9c9b79SDave Ertman * Octets 5 - 12 are BW values, set octet 5 to 100% BW. 9507d9c9b79SDave Ertman * Octets 13 - 20 are TSA values - leave as zeros 9517d9c9b79SDave Ertman */ 9527d9c9b79SDave Ertman buf[5] = 0x64; 9537d9c9b79SDave Ertman len = (typelen & ICE_LLDP_TLV_LEN_M) >> ICE_LLDP_TLV_LEN_S; 9547d9c9b79SDave Ertman offset += len + 2; 9557d9c9b79SDave Ertman tlv = (struct ice_lldp_org_tlv *) 9567d9c9b79SDave Ertman ((char *)tlv + sizeof(tlv->typelen) + len); 9577d9c9b79SDave Ertman 9587d9c9b79SDave Ertman /* Add ETS REC TLV */ 9597d9c9b79SDave Ertman buf = tlv->tlvinfo; 9607d9c9b79SDave Ertman tlv->typelen = htons(typelen); 9617d9c9b79SDave Ertman 9627d9c9b79SDave Ertman ouisubtype = ((ICE_IEEE_8021QAZ_OUI << ICE_LLDP_TLV_OUI_S) | 9637d9c9b79SDave Ertman ICE_IEEE_SUBTYPE_ETS_REC); 9647d9c9b79SDave Ertman tlv->ouisubtype = htonl(ouisubtype); 9657d9c9b79SDave Ertman 9667d9c9b79SDave Ertman /* First octet of buf is reserved 9677d9c9b79SDave Ertman * Octets 1 - 4 map UP to TC - all UPs map to zero 9687d9c9b79SDave Ertman * Octets 5 - 12 are BW values - set TC 0 to 100%. 9697d9c9b79SDave Ertman * Octets 13 - 20 are TSA value - leave as zeros 9707d9c9b79SDave Ertman */ 9717d9c9b79SDave Ertman buf[5] = 0x64; 9727d9c9b79SDave Ertman offset += len + 2; 9737d9c9b79SDave Ertman tlv = (struct ice_lldp_org_tlv *) 9747d9c9b79SDave Ertman ((char *)tlv + sizeof(tlv->typelen) + len); 9757d9c9b79SDave Ertman 9767d9c9b79SDave Ertman /* Add PFC CFG TLV */ 9777d9c9b79SDave Ertman typelen = ((ICE_TLV_TYPE_ORG << ICE_LLDP_TLV_TYPE_S) | 9787d9c9b79SDave Ertman ICE_IEEE_PFC_TLV_LEN); 9797d9c9b79SDave Ertman tlv->typelen = htons(typelen); 9807d9c9b79SDave Ertman 9817d9c9b79SDave Ertman ouisubtype = ((ICE_IEEE_8021QAZ_OUI << ICE_LLDP_TLV_OUI_S) | 9827d9c9b79SDave Ertman ICE_IEEE_SUBTYPE_PFC_CFG); 9837d9c9b79SDave Ertman tlv->ouisubtype = htonl(ouisubtype); 9847d9c9b79SDave Ertman 9857d9c9b79SDave Ertman /* Octet 1 left as all zeros - PFC disabled */ 9867d9c9b79SDave Ertman buf[0] = 0x08; 9877d9c9b79SDave Ertman len = (typelen & ICE_LLDP_TLV_LEN_M) >> ICE_LLDP_TLV_LEN_S; 9887d9c9b79SDave Ertman offset += len + 2; 9897d9c9b79SDave Ertman 9907d9c9b79SDave Ertman if (ice_aq_set_lldp_mib(hw, mib_type, (void *)lldpmib, offset, NULL)) 9917d9c9b79SDave Ertman dev_dbg(dev, "%s Failed to set default LLDP MIB\n", __func__); 9927d9c9b79SDave Ertman 9937d9c9b79SDave Ertman kfree(lldpmib); 9947d9c9b79SDave Ertman } 9957d9c9b79SDave Ertman 9967d9c9b79SDave Ertman /** 99799d40752SBrett Creeley * ice_check_phy_fw_load - check if PHY FW load failed 99899d40752SBrett Creeley * @pf: pointer to PF struct 99999d40752SBrett Creeley * @link_cfg_err: bitmap from the link info structure 100099d40752SBrett Creeley * 100199d40752SBrett Creeley * check if external PHY FW load failed and print an error message if it did 100299d40752SBrett Creeley */ 100399d40752SBrett Creeley static void ice_check_phy_fw_load(struct ice_pf *pf, u8 link_cfg_err) 100499d40752SBrett Creeley { 100599d40752SBrett Creeley if (!(link_cfg_err & ICE_AQ_LINK_EXTERNAL_PHY_LOAD_FAILURE)) { 100699d40752SBrett Creeley clear_bit(ICE_FLAG_PHY_FW_LOAD_FAILED, pf->flags); 100799d40752SBrett Creeley return; 100899d40752SBrett Creeley } 100999d40752SBrett Creeley 101099d40752SBrett Creeley if (test_bit(ICE_FLAG_PHY_FW_LOAD_FAILED, pf->flags)) 101199d40752SBrett Creeley return; 101299d40752SBrett Creeley 101399d40752SBrett Creeley if (link_cfg_err & ICE_AQ_LINK_EXTERNAL_PHY_LOAD_FAILURE) { 101499d40752SBrett Creeley dev_err(ice_pf_to_dev(pf), "Device failed to load the FW for the external PHY. Please download and install the latest NVM for your device and try again\n"); 101599d40752SBrett Creeley set_bit(ICE_FLAG_PHY_FW_LOAD_FAILED, pf->flags); 101699d40752SBrett Creeley } 101799d40752SBrett Creeley } 101899d40752SBrett Creeley 101999d40752SBrett Creeley /** 1020c77849f5SAnirudh Venkataramanan * ice_check_module_power 1021c77849f5SAnirudh Venkataramanan * @pf: pointer to PF struct 1022c77849f5SAnirudh Venkataramanan * @link_cfg_err: bitmap from the link info structure 1023c77849f5SAnirudh Venkataramanan * 1024c77849f5SAnirudh Venkataramanan * check module power level returned by a previous call to aq_get_link_info 1025c77849f5SAnirudh Venkataramanan * and print error messages if module power level is not supported 1026c77849f5SAnirudh Venkataramanan */ 1027c77849f5SAnirudh Venkataramanan static void ice_check_module_power(struct ice_pf *pf, u8 link_cfg_err) 1028c77849f5SAnirudh Venkataramanan { 1029c77849f5SAnirudh Venkataramanan /* if module power level is supported, clear the flag */ 1030c77849f5SAnirudh Venkataramanan if (!(link_cfg_err & (ICE_AQ_LINK_INVAL_MAX_POWER_LIMIT | 1031c77849f5SAnirudh Venkataramanan ICE_AQ_LINK_MODULE_POWER_UNSUPPORTED))) { 1032c77849f5SAnirudh Venkataramanan clear_bit(ICE_FLAG_MOD_POWER_UNSUPPORTED, pf->flags); 1033c77849f5SAnirudh Venkataramanan return; 1034c77849f5SAnirudh Venkataramanan } 1035c77849f5SAnirudh Venkataramanan 1036c77849f5SAnirudh Venkataramanan /* if ICE_FLAG_MOD_POWER_UNSUPPORTED was previously set and the 1037c77849f5SAnirudh Venkataramanan * above block didn't clear this bit, there's nothing to do 1038c77849f5SAnirudh Venkataramanan */ 1039c77849f5SAnirudh Venkataramanan if (test_bit(ICE_FLAG_MOD_POWER_UNSUPPORTED, pf->flags)) 1040c77849f5SAnirudh Venkataramanan return; 1041c77849f5SAnirudh Venkataramanan 1042c77849f5SAnirudh Venkataramanan if (link_cfg_err & ICE_AQ_LINK_INVAL_MAX_POWER_LIMIT) { 1043c77849f5SAnirudh Venkataramanan dev_err(ice_pf_to_dev(pf), "The installed module is incompatible with the device's NVM image. Cannot start link\n"); 1044c77849f5SAnirudh Venkataramanan set_bit(ICE_FLAG_MOD_POWER_UNSUPPORTED, pf->flags); 1045c77849f5SAnirudh Venkataramanan } else if (link_cfg_err & ICE_AQ_LINK_MODULE_POWER_UNSUPPORTED) { 1046c77849f5SAnirudh Venkataramanan dev_err(ice_pf_to_dev(pf), "The module's power requirements exceed the device's power supply. Cannot start link\n"); 1047c77849f5SAnirudh Venkataramanan set_bit(ICE_FLAG_MOD_POWER_UNSUPPORTED, pf->flags); 1048c77849f5SAnirudh Venkataramanan } 1049c77849f5SAnirudh Venkataramanan } 1050c77849f5SAnirudh Venkataramanan 1051c77849f5SAnirudh Venkataramanan /** 105299d40752SBrett Creeley * ice_check_link_cfg_err - check if link configuration failed 105399d40752SBrett Creeley * @pf: pointer to the PF struct 105499d40752SBrett Creeley * @link_cfg_err: bitmap from the link info structure 105599d40752SBrett Creeley * 105699d40752SBrett Creeley * print if any link configuration failure happens due to the value in the 105799d40752SBrett Creeley * link_cfg_err parameter in the link info structure 105899d40752SBrett Creeley */ 105999d40752SBrett Creeley static void ice_check_link_cfg_err(struct ice_pf *pf, u8 link_cfg_err) 106099d40752SBrett Creeley { 106199d40752SBrett Creeley ice_check_module_power(pf, link_cfg_err); 106299d40752SBrett Creeley ice_check_phy_fw_load(pf, link_cfg_err); 106399d40752SBrett Creeley } 106499d40752SBrett Creeley 106599d40752SBrett Creeley /** 10660b28b702SAnirudh Venkataramanan * ice_link_event - process the link event 10672f2da36eSAnirudh Venkataramanan * @pf: PF that the link event is associated with 10680b28b702SAnirudh Venkataramanan * @pi: port_info for the port that the link event is associated with 1069c2a23e00SBrett Creeley * @link_up: true if the physical link is up and false if it is down 1070c2a23e00SBrett Creeley * @link_speed: current link speed received from the link event 10710b28b702SAnirudh Venkataramanan * 1072c2a23e00SBrett Creeley * Returns 0 on success and negative on failure 10730b28b702SAnirudh Venkataramanan */ 10740b28b702SAnirudh Venkataramanan static int 1075c2a23e00SBrett Creeley ice_link_event(struct ice_pf *pf, struct ice_port_info *pi, bool link_up, 1076c2a23e00SBrett Creeley u16 link_speed) 10770b28b702SAnirudh Venkataramanan { 10784015d11eSBrett Creeley struct device *dev = ice_pf_to_dev(pf); 10790b28b702SAnirudh Venkataramanan struct ice_phy_info *phy_info; 1080c2a23e00SBrett Creeley struct ice_vsi *vsi; 1081c2a23e00SBrett Creeley u16 old_link_speed; 1082c2a23e00SBrett Creeley bool old_link; 10835518ac2aSTony Nguyen int status; 10840b28b702SAnirudh Venkataramanan 10850b28b702SAnirudh Venkataramanan phy_info = &pi->phy; 10860b28b702SAnirudh Venkataramanan phy_info->link_info_old = phy_info->link_info; 10870b28b702SAnirudh Venkataramanan 1088c2a23e00SBrett Creeley old_link = !!(phy_info->link_info_old.link_info & ICE_AQ_LINK_UP); 10890b28b702SAnirudh Venkataramanan old_link_speed = phy_info->link_info_old.link_speed; 10900b28b702SAnirudh Venkataramanan 1091c2a23e00SBrett Creeley /* update the link info structures and re-enable link events, 1092c2a23e00SBrett Creeley * don't bail on failure due to other book keeping needed 1093c2a23e00SBrett Creeley */ 1094d348d517SAnirudh Venkataramanan status = ice_update_link_info(pi); 1095d348d517SAnirudh Venkataramanan if (status) 10965f87ec48STony Nguyen dev_dbg(dev, "Failed to update link status on port %d, err %d aq_err %s\n", 10975f87ec48STony Nguyen pi->lport, status, 1098d348d517SAnirudh Venkataramanan ice_aq_str(pi->hw->adminq.sq_last_status)); 10990b28b702SAnirudh Venkataramanan 110099d40752SBrett Creeley ice_check_link_cfg_err(pf, pi->phy.link_info.link_cfg_err); 1101c77849f5SAnirudh Venkataramanan 11020ce6c34aSDave Ertman /* Check if the link state is up after updating link info, and treat 11030ce6c34aSDave Ertman * this event as an UP event since the link is actually UP now. 11040ce6c34aSDave Ertman */ 11050ce6c34aSDave Ertman if (phy_info->link_info.link_info & ICE_AQ_LINK_UP) 11060ce6c34aSDave Ertman link_up = true; 11070ce6c34aSDave Ertman 1108208ff751SAnirudh Venkataramanan vsi = ice_get_main_vsi(pf); 11090b28b702SAnirudh Venkataramanan if (!vsi || !vsi->port_info) 1110c2a23e00SBrett Creeley return -EINVAL; 11110b28b702SAnirudh Venkataramanan 11126d599946STony Nguyen /* turn off PHY if media was removed */ 11136d599946STony Nguyen if (!test_bit(ICE_FLAG_NO_MEDIA, pf->flags) && 11146d599946STony Nguyen !(pi->phy.link_info.link_info & ICE_AQ_MEDIA_AVAILABLE)) { 11156d599946STony Nguyen set_bit(ICE_FLAG_NO_MEDIA, pf->flags); 1116d348d517SAnirudh Venkataramanan ice_set_link(vsi, false); 11176d599946STony Nguyen } 11186d599946STony Nguyen 11191a3571b5SPaul Greenwalt /* if the old link up/down and speed is the same as the new */ 11201a3571b5SPaul Greenwalt if (link_up == old_link && link_speed == old_link_speed) 1121d348d517SAnirudh Venkataramanan return 0; 11221a3571b5SPaul Greenwalt 11233a749623SJacob Keller if (!ice_is_e810(&pf->hw)) 11243a749623SJacob Keller ice_ptp_link_change(pf, pf->hw.pf_id, link_up); 11253a749623SJacob Keller 11267d9c9b79SDave Ertman if (ice_is_dcb_active(pf)) { 11277d9c9b79SDave Ertman if (test_bit(ICE_FLAG_DCB_ENA, pf->flags)) 1128242b5e06SDave Ertman ice_dcb_rebuild(pf); 11297d9c9b79SDave Ertman } else { 11307d9c9b79SDave Ertman if (link_up) 11317d9c9b79SDave Ertman ice_set_dflt_mib(pf); 11327d9c9b79SDave Ertman } 1133c2a23e00SBrett Creeley ice_vsi_link_event(vsi, link_up); 1134c2a23e00SBrett Creeley ice_print_link_msg(vsi, link_up); 11350b28b702SAnirudh Venkataramanan 113653b8decbSAnirudh Venkataramanan ice_vc_notify_link_state(pf); 113753b8decbSAnirudh Venkataramanan 1138d348d517SAnirudh Venkataramanan return 0; 11390b28b702SAnirudh Venkataramanan } 11400b28b702SAnirudh Venkataramanan 11410b28b702SAnirudh Venkataramanan /** 11424f4be03bSAnirudh Venkataramanan * ice_watchdog_subtask - periodic tasks not using event driven scheduling 11434f4be03bSAnirudh Venkataramanan * @pf: board private structure 11440b28b702SAnirudh Venkataramanan */ 11454f4be03bSAnirudh Venkataramanan static void ice_watchdog_subtask(struct ice_pf *pf) 11460b28b702SAnirudh Venkataramanan { 11474f4be03bSAnirudh Venkataramanan int i; 11480b28b702SAnirudh Venkataramanan 11494f4be03bSAnirudh Venkataramanan /* if interface is down do nothing */ 11507e408e07SAnirudh Venkataramanan if (test_bit(ICE_DOWN, pf->state) || 11517e408e07SAnirudh Venkataramanan test_bit(ICE_CFG_BUSY, pf->state)) 11524f4be03bSAnirudh Venkataramanan return; 11530b28b702SAnirudh Venkataramanan 11544f4be03bSAnirudh Venkataramanan /* make sure we don't do these things too often */ 11554f4be03bSAnirudh Venkataramanan if (time_before(jiffies, 11564f4be03bSAnirudh Venkataramanan pf->serv_tmr_prev + pf->serv_tmr_period)) 11574f4be03bSAnirudh Venkataramanan return; 11580b28b702SAnirudh Venkataramanan 11594f4be03bSAnirudh Venkataramanan pf->serv_tmr_prev = jiffies; 11604f4be03bSAnirudh Venkataramanan 11614f4be03bSAnirudh Venkataramanan /* Update the stats for active netdevs so the network stack 11624f4be03bSAnirudh Venkataramanan * can look at updated numbers whenever it cares to 11634f4be03bSAnirudh Venkataramanan */ 11644f4be03bSAnirudh Venkataramanan ice_update_pf_stats(pf); 116580ed404aSBrett Creeley ice_for_each_vsi(pf, i) 11664f4be03bSAnirudh Venkataramanan if (pf->vsi[i] && pf->vsi[i]->netdev) 11674f4be03bSAnirudh Venkataramanan ice_update_vsi_stats(pf->vsi[i]); 11680b28b702SAnirudh Venkataramanan } 11690b28b702SAnirudh Venkataramanan 11700b28b702SAnirudh Venkataramanan /** 1171250c3b3eSBrett Creeley * ice_init_link_events - enable/initialize link events 1172250c3b3eSBrett Creeley * @pi: pointer to the port_info instance 1173250c3b3eSBrett Creeley * 1174250c3b3eSBrett Creeley * Returns -EIO on failure, 0 on success 1175250c3b3eSBrett Creeley */ 1176250c3b3eSBrett Creeley static int ice_init_link_events(struct ice_port_info *pi) 1177250c3b3eSBrett Creeley { 1178250c3b3eSBrett Creeley u16 mask; 1179250c3b3eSBrett Creeley 1180250c3b3eSBrett Creeley mask = ~((u16)(ICE_AQ_LINK_EVENT_UPDOWN | ICE_AQ_LINK_EVENT_MEDIA_NA | 118199d40752SBrett Creeley ICE_AQ_LINK_EVENT_MODULE_QUAL_FAIL | 118299d40752SBrett Creeley ICE_AQ_LINK_EVENT_PHY_FW_LOAD_FAIL)); 1183250c3b3eSBrett Creeley 1184250c3b3eSBrett Creeley if (ice_aq_set_event_mask(pi->hw, pi->lport, mask, NULL)) { 118519cce2c6SAnirudh Venkataramanan dev_dbg(ice_hw_to_dev(pi->hw), "Failed to set link event mask for port %d\n", 1186250c3b3eSBrett Creeley pi->lport); 1187250c3b3eSBrett Creeley return -EIO; 1188250c3b3eSBrett Creeley } 1189250c3b3eSBrett Creeley 1190250c3b3eSBrett Creeley if (ice_aq_get_link_info(pi, true, NULL, NULL)) { 119119cce2c6SAnirudh Venkataramanan dev_dbg(ice_hw_to_dev(pi->hw), "Failed to enable link events for port %d\n", 1192250c3b3eSBrett Creeley pi->lport); 1193250c3b3eSBrett Creeley return -EIO; 1194250c3b3eSBrett Creeley } 1195250c3b3eSBrett Creeley 1196250c3b3eSBrett Creeley return 0; 1197250c3b3eSBrett Creeley } 1198250c3b3eSBrett Creeley 1199250c3b3eSBrett Creeley /** 1200250c3b3eSBrett Creeley * ice_handle_link_event - handle link event via ARQ 12012f2da36eSAnirudh Venkataramanan * @pf: PF that the link event is associated with 1202c2a23e00SBrett Creeley * @event: event structure containing link status info 1203250c3b3eSBrett Creeley */ 1204c2a23e00SBrett Creeley static int 1205c2a23e00SBrett Creeley ice_handle_link_event(struct ice_pf *pf, struct ice_rq_event_info *event) 1206250c3b3eSBrett Creeley { 1207c2a23e00SBrett Creeley struct ice_aqc_get_link_status_data *link_data; 1208250c3b3eSBrett Creeley struct ice_port_info *port_info; 1209250c3b3eSBrett Creeley int status; 1210250c3b3eSBrett Creeley 1211c2a23e00SBrett Creeley link_data = (struct ice_aqc_get_link_status_data *)event->msg_buf; 1212250c3b3eSBrett Creeley port_info = pf->hw.port_info; 1213250c3b3eSBrett Creeley if (!port_info) 1214250c3b3eSBrett Creeley return -EINVAL; 1215250c3b3eSBrett Creeley 1216c2a23e00SBrett Creeley status = ice_link_event(pf, port_info, 1217c2a23e00SBrett Creeley !!(link_data->link_info & ICE_AQ_LINK_UP), 1218c2a23e00SBrett Creeley le16_to_cpu(link_data->link_speed)); 1219250c3b3eSBrett Creeley if (status) 122019cce2c6SAnirudh Venkataramanan dev_dbg(ice_pf_to_dev(pf), "Could not process link event, error %d\n", 122119cce2c6SAnirudh Venkataramanan status); 1222250c3b3eSBrett Creeley 1223250c3b3eSBrett Creeley return status; 1224250c3b3eSBrett Creeley } 1225250c3b3eSBrett Creeley 1226d69ea414SJacob Keller enum ice_aq_task_state { 1227d69ea414SJacob Keller ICE_AQ_TASK_WAITING = 0, 1228d69ea414SJacob Keller ICE_AQ_TASK_COMPLETE, 1229d69ea414SJacob Keller ICE_AQ_TASK_CANCELED, 1230d69ea414SJacob Keller }; 1231d69ea414SJacob Keller 1232d69ea414SJacob Keller struct ice_aq_task { 1233d69ea414SJacob Keller struct hlist_node entry; 1234d69ea414SJacob Keller 1235d69ea414SJacob Keller u16 opcode; 1236d69ea414SJacob Keller struct ice_rq_event_info *event; 1237d69ea414SJacob Keller enum ice_aq_task_state state; 1238d69ea414SJacob Keller }; 1239d69ea414SJacob Keller 1240d69ea414SJacob Keller /** 1241ef860480STony Nguyen * ice_aq_wait_for_event - Wait for an AdminQ event from firmware 1242d69ea414SJacob Keller * @pf: pointer to the PF private structure 1243d69ea414SJacob Keller * @opcode: the opcode to wait for 1244d69ea414SJacob Keller * @timeout: how long to wait, in jiffies 1245d69ea414SJacob Keller * @event: storage for the event info 1246d69ea414SJacob Keller * 1247d69ea414SJacob Keller * Waits for a specific AdminQ completion event on the ARQ for a given PF. The 1248d69ea414SJacob Keller * current thread will be put to sleep until the specified event occurs or 1249d69ea414SJacob Keller * until the given timeout is reached. 1250d69ea414SJacob Keller * 1251d69ea414SJacob Keller * To obtain only the descriptor contents, pass an event without an allocated 1252d69ea414SJacob Keller * msg_buf. If the complete data buffer is desired, allocate the 1253d69ea414SJacob Keller * event->msg_buf with enough space ahead of time. 1254d69ea414SJacob Keller * 1255d69ea414SJacob Keller * Returns: zero on success, or a negative error code on failure. 1256d69ea414SJacob Keller */ 1257d69ea414SJacob Keller int ice_aq_wait_for_event(struct ice_pf *pf, u16 opcode, unsigned long timeout, 1258d69ea414SJacob Keller struct ice_rq_event_info *event) 1259d69ea414SJacob Keller { 12601e8249ccSJacob Keller struct device *dev = ice_pf_to_dev(pf); 1261d69ea414SJacob Keller struct ice_aq_task *task; 12621e8249ccSJacob Keller unsigned long start; 1263d69ea414SJacob Keller long ret; 1264d69ea414SJacob Keller int err; 1265d69ea414SJacob Keller 1266d69ea414SJacob Keller task = kzalloc(sizeof(*task), GFP_KERNEL); 1267d69ea414SJacob Keller if (!task) 1268d69ea414SJacob Keller return -ENOMEM; 1269d69ea414SJacob Keller 1270d69ea414SJacob Keller INIT_HLIST_NODE(&task->entry); 1271d69ea414SJacob Keller task->opcode = opcode; 1272d69ea414SJacob Keller task->event = event; 1273d69ea414SJacob Keller task->state = ICE_AQ_TASK_WAITING; 1274d69ea414SJacob Keller 1275d69ea414SJacob Keller spin_lock_bh(&pf->aq_wait_lock); 1276d69ea414SJacob Keller hlist_add_head(&task->entry, &pf->aq_wait_list); 1277d69ea414SJacob Keller spin_unlock_bh(&pf->aq_wait_lock); 1278d69ea414SJacob Keller 12791e8249ccSJacob Keller start = jiffies; 12801e8249ccSJacob Keller 1281d69ea414SJacob Keller ret = wait_event_interruptible_timeout(pf->aq_wait_queue, task->state, 1282d69ea414SJacob Keller timeout); 1283d69ea414SJacob Keller switch (task->state) { 1284d69ea414SJacob Keller case ICE_AQ_TASK_WAITING: 1285d69ea414SJacob Keller err = ret < 0 ? ret : -ETIMEDOUT; 1286d69ea414SJacob Keller break; 1287d69ea414SJacob Keller case ICE_AQ_TASK_CANCELED: 1288d69ea414SJacob Keller err = ret < 0 ? ret : -ECANCELED; 1289d69ea414SJacob Keller break; 1290d69ea414SJacob Keller case ICE_AQ_TASK_COMPLETE: 1291d69ea414SJacob Keller err = ret < 0 ? ret : 0; 1292d69ea414SJacob Keller break; 1293d69ea414SJacob Keller default: 1294d69ea414SJacob Keller WARN(1, "Unexpected AdminQ wait task state %u", task->state); 1295d69ea414SJacob Keller err = -EINVAL; 1296d69ea414SJacob Keller break; 1297d69ea414SJacob Keller } 1298d69ea414SJacob Keller 12991e8249ccSJacob Keller dev_dbg(dev, "Waited %u msecs (max %u msecs) for firmware response to op 0x%04x\n", 13001e8249ccSJacob Keller jiffies_to_msecs(jiffies - start), 13011e8249ccSJacob Keller jiffies_to_msecs(timeout), 13021e8249ccSJacob Keller opcode); 13031e8249ccSJacob Keller 1304d69ea414SJacob Keller spin_lock_bh(&pf->aq_wait_lock); 1305d69ea414SJacob Keller hlist_del(&task->entry); 1306d69ea414SJacob Keller spin_unlock_bh(&pf->aq_wait_lock); 1307d69ea414SJacob Keller kfree(task); 1308d69ea414SJacob Keller 1309d69ea414SJacob Keller return err; 1310d69ea414SJacob Keller } 1311d69ea414SJacob Keller 1312d69ea414SJacob Keller /** 1313d69ea414SJacob Keller * ice_aq_check_events - Check if any thread is waiting for an AdminQ event 1314d69ea414SJacob Keller * @pf: pointer to the PF private structure 1315d69ea414SJacob Keller * @opcode: the opcode of the event 1316d69ea414SJacob Keller * @event: the event to check 1317d69ea414SJacob Keller * 1318d69ea414SJacob Keller * Loops over the current list of pending threads waiting for an AdminQ event. 1319d69ea414SJacob Keller * For each matching task, copy the contents of the event into the task 1320d69ea414SJacob Keller * structure and wake up the thread. 1321d69ea414SJacob Keller * 1322d69ea414SJacob Keller * If multiple threads wait for the same opcode, they will all be woken up. 1323d69ea414SJacob Keller * 1324d69ea414SJacob Keller * Note that event->msg_buf will only be duplicated if the event has a buffer 1325d69ea414SJacob Keller * with enough space already allocated. Otherwise, only the descriptor and 1326d69ea414SJacob Keller * message length will be copied. 1327d69ea414SJacob Keller * 1328d69ea414SJacob Keller * Returns: true if an event was found, false otherwise 1329d69ea414SJacob Keller */ 1330d69ea414SJacob Keller static void ice_aq_check_events(struct ice_pf *pf, u16 opcode, 1331d69ea414SJacob Keller struct ice_rq_event_info *event) 1332d69ea414SJacob Keller { 1333d69ea414SJacob Keller struct ice_aq_task *task; 1334d69ea414SJacob Keller bool found = false; 1335d69ea414SJacob Keller 1336d69ea414SJacob Keller spin_lock_bh(&pf->aq_wait_lock); 1337d69ea414SJacob Keller hlist_for_each_entry(task, &pf->aq_wait_list, entry) { 1338d69ea414SJacob Keller if (task->state || task->opcode != opcode) 1339d69ea414SJacob Keller continue; 1340d69ea414SJacob Keller 1341d69ea414SJacob Keller memcpy(&task->event->desc, &event->desc, sizeof(event->desc)); 1342d69ea414SJacob Keller task->event->msg_len = event->msg_len; 1343d69ea414SJacob Keller 1344d69ea414SJacob Keller /* Only copy the data buffer if a destination was set */ 1345d69ea414SJacob Keller if (task->event->msg_buf && 1346d69ea414SJacob Keller task->event->buf_len > event->buf_len) { 1347d69ea414SJacob Keller memcpy(task->event->msg_buf, event->msg_buf, 1348d69ea414SJacob Keller event->buf_len); 1349d69ea414SJacob Keller task->event->buf_len = event->buf_len; 1350d69ea414SJacob Keller } 1351d69ea414SJacob Keller 1352d69ea414SJacob Keller task->state = ICE_AQ_TASK_COMPLETE; 1353d69ea414SJacob Keller found = true; 1354d69ea414SJacob Keller } 1355d69ea414SJacob Keller spin_unlock_bh(&pf->aq_wait_lock); 1356d69ea414SJacob Keller 1357d69ea414SJacob Keller if (found) 1358d69ea414SJacob Keller wake_up(&pf->aq_wait_queue); 1359d69ea414SJacob Keller } 1360d69ea414SJacob Keller 1361d69ea414SJacob Keller /** 1362d69ea414SJacob Keller * ice_aq_cancel_waiting_tasks - Immediately cancel all waiting tasks 1363d69ea414SJacob Keller * @pf: the PF private structure 1364d69ea414SJacob Keller * 1365d69ea414SJacob Keller * Set all waiting tasks to ICE_AQ_TASK_CANCELED, and wake up their threads. 1366d69ea414SJacob Keller * This will then cause ice_aq_wait_for_event to exit with -ECANCELED. 1367d69ea414SJacob Keller */ 1368d69ea414SJacob Keller static void ice_aq_cancel_waiting_tasks(struct ice_pf *pf) 1369d69ea414SJacob Keller { 1370d69ea414SJacob Keller struct ice_aq_task *task; 1371d69ea414SJacob Keller 1372d69ea414SJacob Keller spin_lock_bh(&pf->aq_wait_lock); 1373d69ea414SJacob Keller hlist_for_each_entry(task, &pf->aq_wait_list, entry) 1374d69ea414SJacob Keller task->state = ICE_AQ_TASK_CANCELED; 1375d69ea414SJacob Keller spin_unlock_bh(&pf->aq_wait_lock); 1376d69ea414SJacob Keller 1377d69ea414SJacob Keller wake_up(&pf->aq_wait_queue); 1378d69ea414SJacob Keller } 1379d69ea414SJacob Keller 1380250c3b3eSBrett Creeley /** 1381940b61afSAnirudh Venkataramanan * __ice_clean_ctrlq - helper function to clean controlq rings 1382940b61afSAnirudh Venkataramanan * @pf: ptr to struct ice_pf 1383940b61afSAnirudh Venkataramanan * @q_type: specific Control queue type 1384940b61afSAnirudh Venkataramanan */ 1385940b61afSAnirudh Venkataramanan static int __ice_clean_ctrlq(struct ice_pf *pf, enum ice_ctl_q q_type) 1386940b61afSAnirudh Venkataramanan { 13874015d11eSBrett Creeley struct device *dev = ice_pf_to_dev(pf); 1388940b61afSAnirudh Venkataramanan struct ice_rq_event_info event; 1389940b61afSAnirudh Venkataramanan struct ice_hw *hw = &pf->hw; 1390940b61afSAnirudh Venkataramanan struct ice_ctl_q_info *cq; 1391940b61afSAnirudh Venkataramanan u16 pending, i = 0; 1392940b61afSAnirudh Venkataramanan const char *qtype; 1393940b61afSAnirudh Venkataramanan u32 oldval, val; 1394940b61afSAnirudh Venkataramanan 13950b28b702SAnirudh Venkataramanan /* Do not clean control queue if/when PF reset fails */ 13967e408e07SAnirudh Venkataramanan if (test_bit(ICE_RESET_FAILED, pf->state)) 13970b28b702SAnirudh Venkataramanan return 0; 13980b28b702SAnirudh Venkataramanan 1399940b61afSAnirudh Venkataramanan switch (q_type) { 1400940b61afSAnirudh Venkataramanan case ICE_CTL_Q_ADMIN: 1401940b61afSAnirudh Venkataramanan cq = &hw->adminq; 1402940b61afSAnirudh Venkataramanan qtype = "Admin"; 1403940b61afSAnirudh Venkataramanan break; 14048f5ee3c4SJacob Keller case ICE_CTL_Q_SB: 14058f5ee3c4SJacob Keller cq = &hw->sbq; 14068f5ee3c4SJacob Keller qtype = "Sideband"; 14078f5ee3c4SJacob Keller break; 140875d2b253SAnirudh Venkataramanan case ICE_CTL_Q_MAILBOX: 140975d2b253SAnirudh Venkataramanan cq = &hw->mailboxq; 141075d2b253SAnirudh Venkataramanan qtype = "Mailbox"; 14110891c896SVignesh Sridhar /* we are going to try to detect a malicious VF, so set the 14120891c896SVignesh Sridhar * state to begin detection 14130891c896SVignesh Sridhar */ 14140891c896SVignesh Sridhar hw->mbx_snapshot.mbx_buf.state = ICE_MAL_VF_DETECT_STATE_NEW_SNAPSHOT; 141575d2b253SAnirudh Venkataramanan break; 1416940b61afSAnirudh Venkataramanan default: 14174015d11eSBrett Creeley dev_warn(dev, "Unknown control queue type 0x%x\n", q_type); 1418940b61afSAnirudh Venkataramanan return 0; 1419940b61afSAnirudh Venkataramanan } 1420940b61afSAnirudh Venkataramanan 1421940b61afSAnirudh Venkataramanan /* check for error indications - PF_xx_AxQLEN register layout for 1422940b61afSAnirudh Venkataramanan * FW/MBX/SB are identical so just use defines for PF_FW_AxQLEN. 1423940b61afSAnirudh Venkataramanan */ 1424940b61afSAnirudh Venkataramanan val = rd32(hw, cq->rq.len); 1425940b61afSAnirudh Venkataramanan if (val & (PF_FW_ARQLEN_ARQVFE_M | PF_FW_ARQLEN_ARQOVFL_M | 1426940b61afSAnirudh Venkataramanan PF_FW_ARQLEN_ARQCRIT_M)) { 1427940b61afSAnirudh Venkataramanan oldval = val; 1428940b61afSAnirudh Venkataramanan if (val & PF_FW_ARQLEN_ARQVFE_M) 14294015d11eSBrett Creeley dev_dbg(dev, "%s Receive Queue VF Error detected\n", 14304015d11eSBrett Creeley qtype); 1431940b61afSAnirudh Venkataramanan if (val & PF_FW_ARQLEN_ARQOVFL_M) { 143219cce2c6SAnirudh Venkataramanan dev_dbg(dev, "%s Receive Queue Overflow Error detected\n", 1433940b61afSAnirudh Venkataramanan qtype); 1434940b61afSAnirudh Venkataramanan } 1435940b61afSAnirudh Venkataramanan if (val & PF_FW_ARQLEN_ARQCRIT_M) 143619cce2c6SAnirudh Venkataramanan dev_dbg(dev, "%s Receive Queue Critical Error detected\n", 1437940b61afSAnirudh Venkataramanan qtype); 1438940b61afSAnirudh Venkataramanan val &= ~(PF_FW_ARQLEN_ARQVFE_M | PF_FW_ARQLEN_ARQOVFL_M | 1439940b61afSAnirudh Venkataramanan PF_FW_ARQLEN_ARQCRIT_M); 1440940b61afSAnirudh Venkataramanan if (oldval != val) 1441940b61afSAnirudh Venkataramanan wr32(hw, cq->rq.len, val); 1442940b61afSAnirudh Venkataramanan } 1443940b61afSAnirudh Venkataramanan 1444940b61afSAnirudh Venkataramanan val = rd32(hw, cq->sq.len); 1445940b61afSAnirudh Venkataramanan if (val & (PF_FW_ATQLEN_ATQVFE_M | PF_FW_ATQLEN_ATQOVFL_M | 1446940b61afSAnirudh Venkataramanan PF_FW_ATQLEN_ATQCRIT_M)) { 1447940b61afSAnirudh Venkataramanan oldval = val; 1448940b61afSAnirudh Venkataramanan if (val & PF_FW_ATQLEN_ATQVFE_M) 144919cce2c6SAnirudh Venkataramanan dev_dbg(dev, "%s Send Queue VF Error detected\n", 145019cce2c6SAnirudh Venkataramanan qtype); 1451940b61afSAnirudh Venkataramanan if (val & PF_FW_ATQLEN_ATQOVFL_M) { 14524015d11eSBrett Creeley dev_dbg(dev, "%s Send Queue Overflow Error detected\n", 1453940b61afSAnirudh Venkataramanan qtype); 1454940b61afSAnirudh Venkataramanan } 1455940b61afSAnirudh Venkataramanan if (val & PF_FW_ATQLEN_ATQCRIT_M) 14564015d11eSBrett Creeley dev_dbg(dev, "%s Send Queue Critical Error detected\n", 1457940b61afSAnirudh Venkataramanan qtype); 1458940b61afSAnirudh Venkataramanan val &= ~(PF_FW_ATQLEN_ATQVFE_M | PF_FW_ATQLEN_ATQOVFL_M | 1459940b61afSAnirudh Venkataramanan PF_FW_ATQLEN_ATQCRIT_M); 1460940b61afSAnirudh Venkataramanan if (oldval != val) 1461940b61afSAnirudh Venkataramanan wr32(hw, cq->sq.len, val); 1462940b61afSAnirudh Venkataramanan } 1463940b61afSAnirudh Venkataramanan 1464940b61afSAnirudh Venkataramanan event.buf_len = cq->rq_buf_size; 14659efe35d0STony Nguyen event.msg_buf = kzalloc(event.buf_len, GFP_KERNEL); 1466940b61afSAnirudh Venkataramanan if (!event.msg_buf) 1467940b61afSAnirudh Venkataramanan return 0; 1468940b61afSAnirudh Venkataramanan 1469940b61afSAnirudh Venkataramanan do { 14700b28b702SAnirudh Venkataramanan u16 opcode; 14715518ac2aSTony Nguyen int ret; 1472940b61afSAnirudh Venkataramanan 1473940b61afSAnirudh Venkataramanan ret = ice_clean_rq_elem(hw, cq, &event, &pending); 1474d54699e2STony Nguyen if (ret == -EALREADY) 1475940b61afSAnirudh Venkataramanan break; 1476940b61afSAnirudh Venkataramanan if (ret) { 14775f87ec48STony Nguyen dev_err(dev, "%s Receive Queue event error %d\n", qtype, 14785f87ec48STony Nguyen ret); 1479940b61afSAnirudh Venkataramanan break; 1480940b61afSAnirudh Venkataramanan } 14810b28b702SAnirudh Venkataramanan 14820b28b702SAnirudh Venkataramanan opcode = le16_to_cpu(event.desc.opcode); 14830b28b702SAnirudh Venkataramanan 1484d69ea414SJacob Keller /* Notify any thread that might be waiting for this event */ 1485d69ea414SJacob Keller ice_aq_check_events(pf, opcode, &event); 1486d69ea414SJacob Keller 14870b28b702SAnirudh Venkataramanan switch (opcode) { 1488250c3b3eSBrett Creeley case ice_aqc_opc_get_link_status: 1489c2a23e00SBrett Creeley if (ice_handle_link_event(pf, &event)) 14904015d11eSBrett Creeley dev_err(dev, "Could not handle link event\n"); 1491250c3b3eSBrett Creeley break; 14922309ae38SBrett Creeley case ice_aqc_opc_event_lan_overflow: 14932309ae38SBrett Creeley ice_vf_lan_overflow_event(pf, &event); 14942309ae38SBrett Creeley break; 14951071a835SAnirudh Venkataramanan case ice_mbx_opc_send_msg_to_pf: 14960891c896SVignesh Sridhar if (!ice_is_malicious_vf(pf, &event, i, pending)) 14971071a835SAnirudh Venkataramanan ice_vc_process_vf_msg(pf, &event); 14981071a835SAnirudh Venkataramanan break; 14998b97ceb1SHieu Tran case ice_aqc_opc_fw_logging: 15008b97ceb1SHieu Tran ice_output_fw_log(hw, &event.desc, event.msg_buf); 15018b97ceb1SHieu Tran break; 150200cc3f1bSAnirudh Venkataramanan case ice_aqc_opc_lldp_set_mib_change: 150300cc3f1bSAnirudh Venkataramanan ice_dcb_process_lldp_set_mib_change(pf, &event); 150400cc3f1bSAnirudh Venkataramanan break; 15050b28b702SAnirudh Venkataramanan default: 150619cce2c6SAnirudh Venkataramanan dev_dbg(dev, "%s Receive Queue unknown event 0x%04x ignored\n", 15070b28b702SAnirudh Venkataramanan qtype, opcode); 15080b28b702SAnirudh Venkataramanan break; 15090b28b702SAnirudh Venkataramanan } 1510940b61afSAnirudh Venkataramanan } while (pending && (i++ < ICE_DFLT_IRQ_WORK)); 1511940b61afSAnirudh Venkataramanan 15129efe35d0STony Nguyen kfree(event.msg_buf); 1513940b61afSAnirudh Venkataramanan 1514940b61afSAnirudh Venkataramanan return pending && (i == ICE_DFLT_IRQ_WORK); 1515940b61afSAnirudh Venkataramanan } 1516940b61afSAnirudh Venkataramanan 1517940b61afSAnirudh Venkataramanan /** 15183d6b640eSAnirudh Venkataramanan * ice_ctrlq_pending - check if there is a difference between ntc and ntu 15193d6b640eSAnirudh Venkataramanan * @hw: pointer to hardware info 15203d6b640eSAnirudh Venkataramanan * @cq: control queue information 15213d6b640eSAnirudh Venkataramanan * 15223d6b640eSAnirudh Venkataramanan * returns true if there are pending messages in a queue, false if there aren't 15233d6b640eSAnirudh Venkataramanan */ 15243d6b640eSAnirudh Venkataramanan static bool ice_ctrlq_pending(struct ice_hw *hw, struct ice_ctl_q_info *cq) 15253d6b640eSAnirudh Venkataramanan { 15263d6b640eSAnirudh Venkataramanan u16 ntu; 15273d6b640eSAnirudh Venkataramanan 15283d6b640eSAnirudh Venkataramanan ntu = (u16)(rd32(hw, cq->rq.head) & cq->rq.head_mask); 15293d6b640eSAnirudh Venkataramanan return cq->rq.next_to_clean != ntu; 15303d6b640eSAnirudh Venkataramanan } 15313d6b640eSAnirudh Venkataramanan 15323d6b640eSAnirudh Venkataramanan /** 1533940b61afSAnirudh Venkataramanan * ice_clean_adminq_subtask - clean the AdminQ rings 1534940b61afSAnirudh Venkataramanan * @pf: board private structure 1535940b61afSAnirudh Venkataramanan */ 1536940b61afSAnirudh Venkataramanan static void ice_clean_adminq_subtask(struct ice_pf *pf) 1537940b61afSAnirudh Venkataramanan { 1538940b61afSAnirudh Venkataramanan struct ice_hw *hw = &pf->hw; 1539940b61afSAnirudh Venkataramanan 15407e408e07SAnirudh Venkataramanan if (!test_bit(ICE_ADMINQ_EVENT_PENDING, pf->state)) 1541940b61afSAnirudh Venkataramanan return; 1542940b61afSAnirudh Venkataramanan 1543940b61afSAnirudh Venkataramanan if (__ice_clean_ctrlq(pf, ICE_CTL_Q_ADMIN)) 1544940b61afSAnirudh Venkataramanan return; 1545940b61afSAnirudh Venkataramanan 15467e408e07SAnirudh Venkataramanan clear_bit(ICE_ADMINQ_EVENT_PENDING, pf->state); 1547940b61afSAnirudh Venkataramanan 15483d6b640eSAnirudh Venkataramanan /* There might be a situation where new messages arrive to a control 15493d6b640eSAnirudh Venkataramanan * queue between processing the last message and clearing the 15503d6b640eSAnirudh Venkataramanan * EVENT_PENDING bit. So before exiting, check queue head again (using 15513d6b640eSAnirudh Venkataramanan * ice_ctrlq_pending) and process new messages if any. 15523d6b640eSAnirudh Venkataramanan */ 15533d6b640eSAnirudh Venkataramanan if (ice_ctrlq_pending(hw, &hw->adminq)) 15543d6b640eSAnirudh Venkataramanan __ice_clean_ctrlq(pf, ICE_CTL_Q_ADMIN); 1555940b61afSAnirudh Venkataramanan 1556940b61afSAnirudh Venkataramanan ice_flush(hw); 1557940b61afSAnirudh Venkataramanan } 1558940b61afSAnirudh Venkataramanan 1559940b61afSAnirudh Venkataramanan /** 156075d2b253SAnirudh Venkataramanan * ice_clean_mailboxq_subtask - clean the MailboxQ rings 156175d2b253SAnirudh Venkataramanan * @pf: board private structure 156275d2b253SAnirudh Venkataramanan */ 156375d2b253SAnirudh Venkataramanan static void ice_clean_mailboxq_subtask(struct ice_pf *pf) 156475d2b253SAnirudh Venkataramanan { 156575d2b253SAnirudh Venkataramanan struct ice_hw *hw = &pf->hw; 156675d2b253SAnirudh Venkataramanan 15677e408e07SAnirudh Venkataramanan if (!test_bit(ICE_MAILBOXQ_EVENT_PENDING, pf->state)) 156875d2b253SAnirudh Venkataramanan return; 156975d2b253SAnirudh Venkataramanan 157075d2b253SAnirudh Venkataramanan if (__ice_clean_ctrlq(pf, ICE_CTL_Q_MAILBOX)) 157175d2b253SAnirudh Venkataramanan return; 157275d2b253SAnirudh Venkataramanan 15737e408e07SAnirudh Venkataramanan clear_bit(ICE_MAILBOXQ_EVENT_PENDING, pf->state); 157475d2b253SAnirudh Venkataramanan 157575d2b253SAnirudh Venkataramanan if (ice_ctrlq_pending(hw, &hw->mailboxq)) 157675d2b253SAnirudh Venkataramanan __ice_clean_ctrlq(pf, ICE_CTL_Q_MAILBOX); 157775d2b253SAnirudh Venkataramanan 157875d2b253SAnirudh Venkataramanan ice_flush(hw); 157975d2b253SAnirudh Venkataramanan } 158075d2b253SAnirudh Venkataramanan 158175d2b253SAnirudh Venkataramanan /** 15828f5ee3c4SJacob Keller * ice_clean_sbq_subtask - clean the Sideband Queue rings 15838f5ee3c4SJacob Keller * @pf: board private structure 15848f5ee3c4SJacob Keller */ 15858f5ee3c4SJacob Keller static void ice_clean_sbq_subtask(struct ice_pf *pf) 15868f5ee3c4SJacob Keller { 15878f5ee3c4SJacob Keller struct ice_hw *hw = &pf->hw; 15888f5ee3c4SJacob Keller 15898f5ee3c4SJacob Keller /* Nothing to do here if sideband queue is not supported */ 15908f5ee3c4SJacob Keller if (!ice_is_sbq_supported(hw)) { 15918f5ee3c4SJacob Keller clear_bit(ICE_SIDEBANDQ_EVENT_PENDING, pf->state); 15928f5ee3c4SJacob Keller return; 15938f5ee3c4SJacob Keller } 15948f5ee3c4SJacob Keller 15958f5ee3c4SJacob Keller if (!test_bit(ICE_SIDEBANDQ_EVENT_PENDING, pf->state)) 15968f5ee3c4SJacob Keller return; 15978f5ee3c4SJacob Keller 15988f5ee3c4SJacob Keller if (__ice_clean_ctrlq(pf, ICE_CTL_Q_SB)) 15998f5ee3c4SJacob Keller return; 16008f5ee3c4SJacob Keller 16018f5ee3c4SJacob Keller clear_bit(ICE_SIDEBANDQ_EVENT_PENDING, pf->state); 16028f5ee3c4SJacob Keller 16038f5ee3c4SJacob Keller if (ice_ctrlq_pending(hw, &hw->sbq)) 16048f5ee3c4SJacob Keller __ice_clean_ctrlq(pf, ICE_CTL_Q_SB); 16058f5ee3c4SJacob Keller 16068f5ee3c4SJacob Keller ice_flush(hw); 16078f5ee3c4SJacob Keller } 16088f5ee3c4SJacob Keller 16098f5ee3c4SJacob Keller /** 1610940b61afSAnirudh Venkataramanan * ice_service_task_schedule - schedule the service task to wake up 1611940b61afSAnirudh Venkataramanan * @pf: board private structure 1612940b61afSAnirudh Venkataramanan * 1613940b61afSAnirudh Venkataramanan * If not already scheduled, this puts the task into the work queue. 1614940b61afSAnirudh Venkataramanan */ 161528bf2672SBrett Creeley void ice_service_task_schedule(struct ice_pf *pf) 1616940b61afSAnirudh Venkataramanan { 16177e408e07SAnirudh Venkataramanan if (!test_bit(ICE_SERVICE_DIS, pf->state) && 16187e408e07SAnirudh Venkataramanan !test_and_set_bit(ICE_SERVICE_SCHED, pf->state) && 16197e408e07SAnirudh Venkataramanan !test_bit(ICE_NEEDS_RESTART, pf->state)) 1620940b61afSAnirudh Venkataramanan queue_work(ice_wq, &pf->serv_task); 1621940b61afSAnirudh Venkataramanan } 1622940b61afSAnirudh Venkataramanan 1623940b61afSAnirudh Venkataramanan /** 1624940b61afSAnirudh Venkataramanan * ice_service_task_complete - finish up the service task 1625940b61afSAnirudh Venkataramanan * @pf: board private structure 1626940b61afSAnirudh Venkataramanan */ 1627940b61afSAnirudh Venkataramanan static void ice_service_task_complete(struct ice_pf *pf) 1628940b61afSAnirudh Venkataramanan { 16297e408e07SAnirudh Venkataramanan WARN_ON(!test_bit(ICE_SERVICE_SCHED, pf->state)); 1630940b61afSAnirudh Venkataramanan 1631940b61afSAnirudh Venkataramanan /* force memory (pf->state) to sync before next service task */ 1632940b61afSAnirudh Venkataramanan smp_mb__before_atomic(); 16337e408e07SAnirudh Venkataramanan clear_bit(ICE_SERVICE_SCHED, pf->state); 1634940b61afSAnirudh Venkataramanan } 1635940b61afSAnirudh Venkataramanan 1636940b61afSAnirudh Venkataramanan /** 16378d81fa55SAkeem G Abodunrin * ice_service_task_stop - stop service task and cancel works 16388d81fa55SAkeem G Abodunrin * @pf: board private structure 1639769c500dSAkeem G Abodunrin * 16407e408e07SAnirudh Venkataramanan * Return 0 if the ICE_SERVICE_DIS bit was not already set, 1641769c500dSAkeem G Abodunrin * 1 otherwise. 16428d81fa55SAkeem G Abodunrin */ 1643769c500dSAkeem G Abodunrin static int ice_service_task_stop(struct ice_pf *pf) 16448d81fa55SAkeem G Abodunrin { 1645769c500dSAkeem G Abodunrin int ret; 1646769c500dSAkeem G Abodunrin 16477e408e07SAnirudh Venkataramanan ret = test_and_set_bit(ICE_SERVICE_DIS, pf->state); 16488d81fa55SAkeem G Abodunrin 16498d81fa55SAkeem G Abodunrin if (pf->serv_tmr.function) 16508d81fa55SAkeem G Abodunrin del_timer_sync(&pf->serv_tmr); 16518d81fa55SAkeem G Abodunrin if (pf->serv_task.func) 16528d81fa55SAkeem G Abodunrin cancel_work_sync(&pf->serv_task); 16538d81fa55SAkeem G Abodunrin 16547e408e07SAnirudh Venkataramanan clear_bit(ICE_SERVICE_SCHED, pf->state); 1655769c500dSAkeem G Abodunrin return ret; 16568d81fa55SAkeem G Abodunrin } 16578d81fa55SAkeem G Abodunrin 16588d81fa55SAkeem G Abodunrin /** 16595995b6d0SBrett Creeley * ice_service_task_restart - restart service task and schedule works 16605995b6d0SBrett Creeley * @pf: board private structure 16615995b6d0SBrett Creeley * 16625995b6d0SBrett Creeley * This function is needed for suspend and resume works (e.g WoL scenario) 16635995b6d0SBrett Creeley */ 16645995b6d0SBrett Creeley static void ice_service_task_restart(struct ice_pf *pf) 16655995b6d0SBrett Creeley { 16667e408e07SAnirudh Venkataramanan clear_bit(ICE_SERVICE_DIS, pf->state); 16675995b6d0SBrett Creeley ice_service_task_schedule(pf); 16685995b6d0SBrett Creeley } 16695995b6d0SBrett Creeley 16705995b6d0SBrett Creeley /** 1671940b61afSAnirudh Venkataramanan * ice_service_timer - timer callback to schedule service task 1672940b61afSAnirudh Venkataramanan * @t: pointer to timer_list 1673940b61afSAnirudh Venkataramanan */ 1674940b61afSAnirudh Venkataramanan static void ice_service_timer(struct timer_list *t) 1675940b61afSAnirudh Venkataramanan { 1676940b61afSAnirudh Venkataramanan struct ice_pf *pf = from_timer(pf, t, serv_tmr); 1677940b61afSAnirudh Venkataramanan 1678940b61afSAnirudh Venkataramanan mod_timer(&pf->serv_tmr, round_jiffies(pf->serv_tmr_period + jiffies)); 1679940b61afSAnirudh Venkataramanan ice_service_task_schedule(pf); 1680940b61afSAnirudh Venkataramanan } 1681940b61afSAnirudh Venkataramanan 1682940b61afSAnirudh Venkataramanan /** 1683b3969fd7SSudheer Mogilappagari * ice_handle_mdd_event - handle malicious driver detect event 1684b3969fd7SSudheer Mogilappagari * @pf: pointer to the PF structure 1685b3969fd7SSudheer Mogilappagari * 16869d5c5a52SPaul Greenwalt * Called from service task. OICR interrupt handler indicates MDD event. 16879d5c5a52SPaul Greenwalt * VF MDD logging is guarded by net_ratelimit. Additional PF and VF log 16889d5c5a52SPaul Greenwalt * messages are wrapped by netif_msg_[rx|tx]_err. Since VF Rx MDD events 16899d5c5a52SPaul Greenwalt * disable the queue, the PF can be configured to reset the VF using ethtool 16909d5c5a52SPaul Greenwalt * private flag mdd-auto-reset-vf. 1691b3969fd7SSudheer Mogilappagari */ 1692b3969fd7SSudheer Mogilappagari static void ice_handle_mdd_event(struct ice_pf *pf) 1693b3969fd7SSudheer Mogilappagari { 16944015d11eSBrett Creeley struct device *dev = ice_pf_to_dev(pf); 1695b3969fd7SSudheer Mogilappagari struct ice_hw *hw = &pf->hw; 1696c4c2c7dbSJacob Keller struct ice_vf *vf; 1697c4c2c7dbSJacob Keller unsigned int bkt; 1698b3969fd7SSudheer Mogilappagari u32 reg; 1699b3969fd7SSudheer Mogilappagari 17007e408e07SAnirudh Venkataramanan if (!test_and_clear_bit(ICE_MDD_EVENT_PENDING, pf->state)) { 17019d5c5a52SPaul Greenwalt /* Since the VF MDD event logging is rate limited, check if 17029d5c5a52SPaul Greenwalt * there are pending MDD events. 17039d5c5a52SPaul Greenwalt */ 17049d5c5a52SPaul Greenwalt ice_print_vfs_mdd_events(pf); 1705b3969fd7SSudheer Mogilappagari return; 17069d5c5a52SPaul Greenwalt } 1707b3969fd7SSudheer Mogilappagari 17089d5c5a52SPaul Greenwalt /* find what triggered an MDD event */ 1709b3969fd7SSudheer Mogilappagari reg = rd32(hw, GL_MDET_TX_PQM); 1710b3969fd7SSudheer Mogilappagari if (reg & GL_MDET_TX_PQM_VALID_M) { 1711b3969fd7SSudheer Mogilappagari u8 pf_num = (reg & GL_MDET_TX_PQM_PF_NUM_M) >> 1712b3969fd7SSudheer Mogilappagari GL_MDET_TX_PQM_PF_NUM_S; 1713b3969fd7SSudheer Mogilappagari u16 vf_num = (reg & GL_MDET_TX_PQM_VF_NUM_M) >> 1714b3969fd7SSudheer Mogilappagari GL_MDET_TX_PQM_VF_NUM_S; 1715b3969fd7SSudheer Mogilappagari u8 event = (reg & GL_MDET_TX_PQM_MAL_TYPE_M) >> 1716b3969fd7SSudheer Mogilappagari GL_MDET_TX_PQM_MAL_TYPE_S; 1717b3969fd7SSudheer Mogilappagari u16 queue = ((reg & GL_MDET_TX_PQM_QNUM_M) >> 1718b3969fd7SSudheer Mogilappagari GL_MDET_TX_PQM_QNUM_S); 1719b3969fd7SSudheer Mogilappagari 1720b3969fd7SSudheer Mogilappagari if (netif_msg_tx_err(pf)) 17214015d11eSBrett Creeley dev_info(dev, "Malicious Driver Detection event %d on TX queue %d PF# %d VF# %d\n", 1722b3969fd7SSudheer Mogilappagari event, queue, pf_num, vf_num); 1723b3969fd7SSudheer Mogilappagari wr32(hw, GL_MDET_TX_PQM, 0xffffffff); 1724b3969fd7SSudheer Mogilappagari } 1725b3969fd7SSudheer Mogilappagari 1726b3969fd7SSudheer Mogilappagari reg = rd32(hw, GL_MDET_TX_TCLAN); 1727b3969fd7SSudheer Mogilappagari if (reg & GL_MDET_TX_TCLAN_VALID_M) { 1728b3969fd7SSudheer Mogilappagari u8 pf_num = (reg & GL_MDET_TX_TCLAN_PF_NUM_M) >> 1729b3969fd7SSudheer Mogilappagari GL_MDET_TX_TCLAN_PF_NUM_S; 1730b3969fd7SSudheer Mogilappagari u16 vf_num = (reg & GL_MDET_TX_TCLAN_VF_NUM_M) >> 1731b3969fd7SSudheer Mogilappagari GL_MDET_TX_TCLAN_VF_NUM_S; 1732b3969fd7SSudheer Mogilappagari u8 event = (reg & GL_MDET_TX_TCLAN_MAL_TYPE_M) >> 1733b3969fd7SSudheer Mogilappagari GL_MDET_TX_TCLAN_MAL_TYPE_S; 1734b3969fd7SSudheer Mogilappagari u16 queue = ((reg & GL_MDET_TX_TCLAN_QNUM_M) >> 1735b3969fd7SSudheer Mogilappagari GL_MDET_TX_TCLAN_QNUM_S); 1736b3969fd7SSudheer Mogilappagari 17371d8bd992SBen Shelton if (netif_msg_tx_err(pf)) 17384015d11eSBrett Creeley dev_info(dev, "Malicious Driver Detection event %d on TX queue %d PF# %d VF# %d\n", 1739b3969fd7SSudheer Mogilappagari event, queue, pf_num, vf_num); 1740b3969fd7SSudheer Mogilappagari wr32(hw, GL_MDET_TX_TCLAN, 0xffffffff); 1741b3969fd7SSudheer Mogilappagari } 1742b3969fd7SSudheer Mogilappagari 1743b3969fd7SSudheer Mogilappagari reg = rd32(hw, GL_MDET_RX); 1744b3969fd7SSudheer Mogilappagari if (reg & GL_MDET_RX_VALID_M) { 1745b3969fd7SSudheer Mogilappagari u8 pf_num = (reg & GL_MDET_RX_PF_NUM_M) >> 1746b3969fd7SSudheer Mogilappagari GL_MDET_RX_PF_NUM_S; 1747b3969fd7SSudheer Mogilappagari u16 vf_num = (reg & GL_MDET_RX_VF_NUM_M) >> 1748b3969fd7SSudheer Mogilappagari GL_MDET_RX_VF_NUM_S; 1749b3969fd7SSudheer Mogilappagari u8 event = (reg & GL_MDET_RX_MAL_TYPE_M) >> 1750b3969fd7SSudheer Mogilappagari GL_MDET_RX_MAL_TYPE_S; 1751b3969fd7SSudheer Mogilappagari u16 queue = ((reg & GL_MDET_RX_QNUM_M) >> 1752b3969fd7SSudheer Mogilappagari GL_MDET_RX_QNUM_S); 1753b3969fd7SSudheer Mogilappagari 1754b3969fd7SSudheer Mogilappagari if (netif_msg_rx_err(pf)) 17554015d11eSBrett Creeley dev_info(dev, "Malicious Driver Detection event %d on RX queue %d PF# %d VF# %d\n", 1756b3969fd7SSudheer Mogilappagari event, queue, pf_num, vf_num); 1757b3969fd7SSudheer Mogilappagari wr32(hw, GL_MDET_RX, 0xffffffff); 1758b3969fd7SSudheer Mogilappagari } 1759b3969fd7SSudheer Mogilappagari 17609d5c5a52SPaul Greenwalt /* check to see if this PF caused an MDD event */ 1761b3969fd7SSudheer Mogilappagari reg = rd32(hw, PF_MDET_TX_PQM); 1762b3969fd7SSudheer Mogilappagari if (reg & PF_MDET_TX_PQM_VALID_M) { 1763b3969fd7SSudheer Mogilappagari wr32(hw, PF_MDET_TX_PQM, 0xFFFF); 17649d5c5a52SPaul Greenwalt if (netif_msg_tx_err(pf)) 17659d5c5a52SPaul Greenwalt dev_info(dev, "Malicious Driver Detection event TX_PQM detected on PF\n"); 1766b3969fd7SSudheer Mogilappagari } 1767b3969fd7SSudheer Mogilappagari 1768b3969fd7SSudheer Mogilappagari reg = rd32(hw, PF_MDET_TX_TCLAN); 1769b3969fd7SSudheer Mogilappagari if (reg & PF_MDET_TX_TCLAN_VALID_M) { 1770b3969fd7SSudheer Mogilappagari wr32(hw, PF_MDET_TX_TCLAN, 0xFFFF); 17719d5c5a52SPaul Greenwalt if (netif_msg_tx_err(pf)) 17729d5c5a52SPaul Greenwalt dev_info(dev, "Malicious Driver Detection event TX_TCLAN detected on PF\n"); 1773b3969fd7SSudheer Mogilappagari } 1774b3969fd7SSudheer Mogilappagari 1775b3969fd7SSudheer Mogilappagari reg = rd32(hw, PF_MDET_RX); 1776b3969fd7SSudheer Mogilappagari if (reg & PF_MDET_RX_VALID_M) { 1777b3969fd7SSudheer Mogilappagari wr32(hw, PF_MDET_RX, 0xFFFF); 17789d5c5a52SPaul Greenwalt if (netif_msg_rx_err(pf)) 17799d5c5a52SPaul Greenwalt dev_info(dev, "Malicious Driver Detection event RX detected on PF\n"); 1780b3969fd7SSudheer Mogilappagari } 1781b3969fd7SSudheer Mogilappagari 17829d5c5a52SPaul Greenwalt /* Check to see if one of the VFs caused an MDD event, and then 17839d5c5a52SPaul Greenwalt * increment counters and set print pending 17849d5c5a52SPaul Greenwalt */ 17853d5985a1SJacob Keller mutex_lock(&pf->vfs.table_lock); 1786c4c2c7dbSJacob Keller ice_for_each_vf(pf, bkt, vf) { 1787c4c2c7dbSJacob Keller reg = rd32(hw, VP_MDET_TX_PQM(vf->vf_id)); 17887c4bc1f5SAnirudh Venkataramanan if (reg & VP_MDET_TX_PQM_VALID_M) { 1789c4c2c7dbSJacob Keller wr32(hw, VP_MDET_TX_PQM(vf->vf_id), 0xFFFF); 17909d5c5a52SPaul Greenwalt vf->mdd_tx_events.count++; 17917e408e07SAnirudh Venkataramanan set_bit(ICE_MDD_VF_PRINT_PENDING, pf->state); 17929d5c5a52SPaul Greenwalt if (netif_msg_tx_err(pf)) 17939d5c5a52SPaul Greenwalt dev_info(dev, "Malicious Driver Detection event TX_PQM detected on VF %d\n", 1794c4c2c7dbSJacob Keller vf->vf_id); 17957c4bc1f5SAnirudh Venkataramanan } 17967c4bc1f5SAnirudh Venkataramanan 1797c4c2c7dbSJacob Keller reg = rd32(hw, VP_MDET_TX_TCLAN(vf->vf_id)); 17987c4bc1f5SAnirudh Venkataramanan if (reg & VP_MDET_TX_TCLAN_VALID_M) { 1799c4c2c7dbSJacob Keller wr32(hw, VP_MDET_TX_TCLAN(vf->vf_id), 0xFFFF); 18009d5c5a52SPaul Greenwalt vf->mdd_tx_events.count++; 18017e408e07SAnirudh Venkataramanan set_bit(ICE_MDD_VF_PRINT_PENDING, pf->state); 18029d5c5a52SPaul Greenwalt if (netif_msg_tx_err(pf)) 18039d5c5a52SPaul Greenwalt dev_info(dev, "Malicious Driver Detection event TX_TCLAN detected on VF %d\n", 1804c4c2c7dbSJacob Keller vf->vf_id); 18057c4bc1f5SAnirudh Venkataramanan } 18067c4bc1f5SAnirudh Venkataramanan 1807c4c2c7dbSJacob Keller reg = rd32(hw, VP_MDET_TX_TDPU(vf->vf_id)); 18087c4bc1f5SAnirudh Venkataramanan if (reg & VP_MDET_TX_TDPU_VALID_M) { 1809c4c2c7dbSJacob Keller wr32(hw, VP_MDET_TX_TDPU(vf->vf_id), 0xFFFF); 18109d5c5a52SPaul Greenwalt vf->mdd_tx_events.count++; 18117e408e07SAnirudh Venkataramanan set_bit(ICE_MDD_VF_PRINT_PENDING, pf->state); 18129d5c5a52SPaul Greenwalt if (netif_msg_tx_err(pf)) 18139d5c5a52SPaul Greenwalt dev_info(dev, "Malicious Driver Detection event TX_TDPU detected on VF %d\n", 1814c4c2c7dbSJacob Keller vf->vf_id); 18157c4bc1f5SAnirudh Venkataramanan } 18167c4bc1f5SAnirudh Venkataramanan 1817c4c2c7dbSJacob Keller reg = rd32(hw, VP_MDET_RX(vf->vf_id)); 18187c4bc1f5SAnirudh Venkataramanan if (reg & VP_MDET_RX_VALID_M) { 1819c4c2c7dbSJacob Keller wr32(hw, VP_MDET_RX(vf->vf_id), 0xFFFF); 18209d5c5a52SPaul Greenwalt vf->mdd_rx_events.count++; 18217e408e07SAnirudh Venkataramanan set_bit(ICE_MDD_VF_PRINT_PENDING, pf->state); 18229d5c5a52SPaul Greenwalt if (netif_msg_rx_err(pf)) 18239d5c5a52SPaul Greenwalt dev_info(dev, "Malicious Driver Detection event RX detected on VF %d\n", 1824c4c2c7dbSJacob Keller vf->vf_id); 18259d5c5a52SPaul Greenwalt 18269d5c5a52SPaul Greenwalt /* Since the queue is disabled on VF Rx MDD events, the 18279d5c5a52SPaul Greenwalt * PF can be configured to reset the VF through ethtool 18289d5c5a52SPaul Greenwalt * private flag mdd-auto-reset-vf. 18299d5c5a52SPaul Greenwalt */ 18307438a3b0SPaul Greenwalt if (test_bit(ICE_FLAG_MDD_AUTO_RESET_VF, pf->flags)) { 18317438a3b0SPaul Greenwalt /* VF MDD event counters will be cleared by 18327438a3b0SPaul Greenwalt * reset, so print the event prior to reset. 18337438a3b0SPaul Greenwalt */ 18347438a3b0SPaul Greenwalt ice_print_vf_rx_mdd_event(vf); 1835f5f085c0SJacob Keller ice_reset_vf(vf, ICE_VF_RESET_LOCK); 18369d5c5a52SPaul Greenwalt } 18377c4bc1f5SAnirudh Venkataramanan } 18387438a3b0SPaul Greenwalt } 18393d5985a1SJacob Keller mutex_unlock(&pf->vfs.table_lock); 18407c4bc1f5SAnirudh Venkataramanan 18419d5c5a52SPaul Greenwalt ice_print_vfs_mdd_events(pf); 1842b3969fd7SSudheer Mogilappagari } 1843b3969fd7SSudheer Mogilappagari 1844b3969fd7SSudheer Mogilappagari /** 18456d599946STony Nguyen * ice_force_phys_link_state - Force the physical link state 18466d599946STony Nguyen * @vsi: VSI to force the physical link state to up/down 18476d599946STony Nguyen * @link_up: true/false indicates to set the physical link to up/down 18486d599946STony Nguyen * 18496d599946STony Nguyen * Force the physical link state by getting the current PHY capabilities from 18506d599946STony Nguyen * hardware and setting the PHY config based on the determined capabilities. If 18516d599946STony Nguyen * link changes a link event will be triggered because both the Enable Automatic 18526d599946STony Nguyen * Link Update and LESM Enable bits are set when setting the PHY capabilities. 18536d599946STony Nguyen * 18546d599946STony Nguyen * Returns 0 on success, negative on failure 18556d599946STony Nguyen */ 18566d599946STony Nguyen static int ice_force_phys_link_state(struct ice_vsi *vsi, bool link_up) 18576d599946STony Nguyen { 18586d599946STony Nguyen struct ice_aqc_get_phy_caps_data *pcaps; 18596d599946STony Nguyen struct ice_aqc_set_phy_cfg_data *cfg; 18606d599946STony Nguyen struct ice_port_info *pi; 18616d599946STony Nguyen struct device *dev; 18626d599946STony Nguyen int retcode; 18636d599946STony Nguyen 18646d599946STony Nguyen if (!vsi || !vsi->port_info || !vsi->back) 18656d599946STony Nguyen return -EINVAL; 18666d599946STony Nguyen if (vsi->type != ICE_VSI_PF) 18676d599946STony Nguyen return 0; 18686d599946STony Nguyen 18699a946843SAnirudh Venkataramanan dev = ice_pf_to_dev(vsi->back); 18706d599946STony Nguyen 18716d599946STony Nguyen pi = vsi->port_info; 18726d599946STony Nguyen 18739efe35d0STony Nguyen pcaps = kzalloc(sizeof(*pcaps), GFP_KERNEL); 18746d599946STony Nguyen if (!pcaps) 18756d599946STony Nguyen return -ENOMEM; 18766d599946STony Nguyen 1877d6730a87SAnirudh Venkataramanan retcode = ice_aq_get_phy_caps(pi, false, ICE_AQC_REPORT_ACTIVE_CFG, pcaps, 18786d599946STony Nguyen NULL); 18796d599946STony Nguyen if (retcode) { 188019cce2c6SAnirudh Venkataramanan dev_err(dev, "Failed to get phy capabilities, VSI %d error %d\n", 18816d599946STony Nguyen vsi->vsi_num, retcode); 18826d599946STony Nguyen retcode = -EIO; 18836d599946STony Nguyen goto out; 18846d599946STony Nguyen } 18856d599946STony Nguyen 18866d599946STony Nguyen /* No change in link */ 18876d599946STony Nguyen if (link_up == !!(pcaps->caps & ICE_AQC_PHY_EN_LINK) && 18886d599946STony Nguyen link_up == !!(pi->phy.link_info.link_info & ICE_AQ_LINK_UP)) 18896d599946STony Nguyen goto out; 18906d599946STony Nguyen 18911a3571b5SPaul Greenwalt /* Use the current user PHY configuration. The current user PHY 18921a3571b5SPaul Greenwalt * configuration is initialized during probe from PHY capabilities 18931a3571b5SPaul Greenwalt * software mode, and updated on set PHY configuration. 18941a3571b5SPaul Greenwalt */ 18951a3571b5SPaul Greenwalt cfg = kmemdup(&pi->phy.curr_user_phy_cfg, sizeof(*cfg), GFP_KERNEL); 18966d599946STony Nguyen if (!cfg) { 18976d599946STony Nguyen retcode = -ENOMEM; 18986d599946STony Nguyen goto out; 18996d599946STony Nguyen } 19006d599946STony Nguyen 19011a3571b5SPaul Greenwalt cfg->caps |= ICE_AQ_PHY_ENA_AUTO_LINK_UPDT; 19026d599946STony Nguyen if (link_up) 19036d599946STony Nguyen cfg->caps |= ICE_AQ_PHY_ENA_LINK; 19046d599946STony Nguyen else 19056d599946STony Nguyen cfg->caps &= ~ICE_AQ_PHY_ENA_LINK; 19066d599946STony Nguyen 19071a3571b5SPaul Greenwalt retcode = ice_aq_set_phy_cfg(&vsi->back->hw, pi, cfg, NULL); 19086d599946STony Nguyen if (retcode) { 19096d599946STony Nguyen dev_err(dev, "Failed to set phy config, VSI %d error %d\n", 19106d599946STony Nguyen vsi->vsi_num, retcode); 19116d599946STony Nguyen retcode = -EIO; 19126d599946STony Nguyen } 19136d599946STony Nguyen 19149efe35d0STony Nguyen kfree(cfg); 19156d599946STony Nguyen out: 19169efe35d0STony Nguyen kfree(pcaps); 19176d599946STony Nguyen return retcode; 19186d599946STony Nguyen } 19196d599946STony Nguyen 19206d599946STony Nguyen /** 19211a3571b5SPaul Greenwalt * ice_init_nvm_phy_type - Initialize the NVM PHY type 19221a3571b5SPaul Greenwalt * @pi: port info structure 19231a3571b5SPaul Greenwalt * 1924ea78ce4dSPaul Greenwalt * Initialize nvm_phy_type_[low|high] for link lenient mode support 19251a3571b5SPaul Greenwalt */ 19261a3571b5SPaul Greenwalt static int ice_init_nvm_phy_type(struct ice_port_info *pi) 19271a3571b5SPaul Greenwalt { 19281a3571b5SPaul Greenwalt struct ice_aqc_get_phy_caps_data *pcaps; 19291a3571b5SPaul Greenwalt struct ice_pf *pf = pi->hw->back; 19302ccc1c1cSTony Nguyen int err; 19311a3571b5SPaul Greenwalt 19321a3571b5SPaul Greenwalt pcaps = kzalloc(sizeof(*pcaps), GFP_KERNEL); 19331a3571b5SPaul Greenwalt if (!pcaps) 19341a3571b5SPaul Greenwalt return -ENOMEM; 19351a3571b5SPaul Greenwalt 19362ccc1c1cSTony Nguyen err = ice_aq_get_phy_caps(pi, false, ICE_AQC_REPORT_TOPO_CAP_NO_MEDIA, 19372ccc1c1cSTony Nguyen pcaps, NULL); 19381a3571b5SPaul Greenwalt 19392ccc1c1cSTony Nguyen if (err) { 19401a3571b5SPaul Greenwalt dev_err(ice_pf_to_dev(pf), "Get PHY capability failed.\n"); 19411a3571b5SPaul Greenwalt goto out; 19421a3571b5SPaul Greenwalt } 19431a3571b5SPaul Greenwalt 19441a3571b5SPaul Greenwalt pf->nvm_phy_type_hi = pcaps->phy_type_high; 19451a3571b5SPaul Greenwalt pf->nvm_phy_type_lo = pcaps->phy_type_low; 19461a3571b5SPaul Greenwalt 19471a3571b5SPaul Greenwalt out: 19481a3571b5SPaul Greenwalt kfree(pcaps); 19491a3571b5SPaul Greenwalt return err; 19501a3571b5SPaul Greenwalt } 19511a3571b5SPaul Greenwalt 19521a3571b5SPaul Greenwalt /** 1953ea78ce4dSPaul Greenwalt * ice_init_link_dflt_override - Initialize link default override 1954ea78ce4dSPaul Greenwalt * @pi: port info structure 1955b4e813ddSBruce Allan * 1956b4e813ddSBruce Allan * Initialize link default override and PHY total port shutdown during probe 1957ea78ce4dSPaul Greenwalt */ 1958ea78ce4dSPaul Greenwalt static void ice_init_link_dflt_override(struct ice_port_info *pi) 1959ea78ce4dSPaul Greenwalt { 1960ea78ce4dSPaul Greenwalt struct ice_link_default_override_tlv *ldo; 1961ea78ce4dSPaul Greenwalt struct ice_pf *pf = pi->hw->back; 1962ea78ce4dSPaul Greenwalt 1963ea78ce4dSPaul Greenwalt ldo = &pf->link_dflt_override; 1964b4e813ddSBruce Allan if (ice_get_link_default_override(ldo, pi)) 1965b4e813ddSBruce Allan return; 1966b4e813ddSBruce Allan 1967b4e813ddSBruce Allan if (!(ldo->options & ICE_LINK_OVERRIDE_PORT_DIS)) 1968b4e813ddSBruce Allan return; 1969b4e813ddSBruce Allan 1970b4e813ddSBruce Allan /* Enable Total Port Shutdown (override/replace link-down-on-close 1971b4e813ddSBruce Allan * ethtool private flag) for ports with Port Disable bit set. 1972b4e813ddSBruce Allan */ 1973b4e813ddSBruce Allan set_bit(ICE_FLAG_TOTAL_PORT_SHUTDOWN_ENA, pf->flags); 1974b4e813ddSBruce Allan set_bit(ICE_FLAG_LINK_DOWN_ON_CLOSE_ENA, pf->flags); 1975ea78ce4dSPaul Greenwalt } 1976ea78ce4dSPaul Greenwalt 1977ea78ce4dSPaul Greenwalt /** 1978ea78ce4dSPaul Greenwalt * ice_init_phy_cfg_dflt_override - Initialize PHY cfg default override settings 1979ea78ce4dSPaul Greenwalt * @pi: port info structure 1980ea78ce4dSPaul Greenwalt * 19810a02944fSAnirudh Venkataramanan * If default override is enabled, initialize the user PHY cfg speed and FEC 1982ea78ce4dSPaul Greenwalt * settings using the default override mask from the NVM. 1983ea78ce4dSPaul Greenwalt * 1984ea78ce4dSPaul Greenwalt * The PHY should only be configured with the default override settings the 19857e408e07SAnirudh Venkataramanan * first time media is available. The ICE_LINK_DEFAULT_OVERRIDE_PENDING state 1986ea78ce4dSPaul Greenwalt * is used to indicate that the user PHY cfg default override is initialized 1987ea78ce4dSPaul Greenwalt * and the PHY has not been configured with the default override settings. The 1988ea78ce4dSPaul Greenwalt * state is set here, and cleared in ice_configure_phy the first time the PHY is 1989ea78ce4dSPaul Greenwalt * configured. 19900a02944fSAnirudh Venkataramanan * 19910a02944fSAnirudh Venkataramanan * This function should be called only if the FW doesn't support default 19920a02944fSAnirudh Venkataramanan * configuration mode, as reported by ice_fw_supports_report_dflt_cfg. 1993ea78ce4dSPaul Greenwalt */ 1994ea78ce4dSPaul Greenwalt static void ice_init_phy_cfg_dflt_override(struct ice_port_info *pi) 1995ea78ce4dSPaul Greenwalt { 1996ea78ce4dSPaul Greenwalt struct ice_link_default_override_tlv *ldo; 1997ea78ce4dSPaul Greenwalt struct ice_aqc_set_phy_cfg_data *cfg; 1998ea78ce4dSPaul Greenwalt struct ice_phy_info *phy = &pi->phy; 1999ea78ce4dSPaul Greenwalt struct ice_pf *pf = pi->hw->back; 2000ea78ce4dSPaul Greenwalt 2001ea78ce4dSPaul Greenwalt ldo = &pf->link_dflt_override; 2002ea78ce4dSPaul Greenwalt 2003ea78ce4dSPaul Greenwalt /* If link default override is enabled, use to mask NVM PHY capabilities 2004ea78ce4dSPaul Greenwalt * for speed and FEC default configuration. 2005ea78ce4dSPaul Greenwalt */ 2006ea78ce4dSPaul Greenwalt cfg = &phy->curr_user_phy_cfg; 2007ea78ce4dSPaul Greenwalt 2008ea78ce4dSPaul Greenwalt if (ldo->phy_type_low || ldo->phy_type_high) { 2009ea78ce4dSPaul Greenwalt cfg->phy_type_low = pf->nvm_phy_type_lo & 2010ea78ce4dSPaul Greenwalt cpu_to_le64(ldo->phy_type_low); 2011ea78ce4dSPaul Greenwalt cfg->phy_type_high = pf->nvm_phy_type_hi & 2012ea78ce4dSPaul Greenwalt cpu_to_le64(ldo->phy_type_high); 2013ea78ce4dSPaul Greenwalt } 2014ea78ce4dSPaul Greenwalt cfg->link_fec_opt = ldo->fec_options; 2015ea78ce4dSPaul Greenwalt phy->curr_user_fec_req = ICE_FEC_AUTO; 2016ea78ce4dSPaul Greenwalt 20177e408e07SAnirudh Venkataramanan set_bit(ICE_LINK_DEFAULT_OVERRIDE_PENDING, pf->state); 2018ea78ce4dSPaul Greenwalt } 2019ea78ce4dSPaul Greenwalt 2020ea78ce4dSPaul Greenwalt /** 20211a3571b5SPaul Greenwalt * ice_init_phy_user_cfg - Initialize the PHY user configuration 20221a3571b5SPaul Greenwalt * @pi: port info structure 20231a3571b5SPaul Greenwalt * 20241a3571b5SPaul Greenwalt * Initialize the current user PHY configuration, speed, FEC, and FC requested 20251a3571b5SPaul Greenwalt * mode to default. The PHY defaults are from get PHY capabilities topology 20261a3571b5SPaul Greenwalt * with media so call when media is first available. An error is returned if 20271a3571b5SPaul Greenwalt * called when media is not available. The PHY initialization completed state is 20281a3571b5SPaul Greenwalt * set here. 20291a3571b5SPaul Greenwalt * 20301a3571b5SPaul Greenwalt * These configurations are used when setting PHY 20311a3571b5SPaul Greenwalt * configuration. The user PHY configuration is updated on set PHY 20321a3571b5SPaul Greenwalt * configuration. Returns 0 on success, negative on failure 20331a3571b5SPaul Greenwalt */ 20341a3571b5SPaul Greenwalt static int ice_init_phy_user_cfg(struct ice_port_info *pi) 20351a3571b5SPaul Greenwalt { 20361a3571b5SPaul Greenwalt struct ice_aqc_get_phy_caps_data *pcaps; 20371a3571b5SPaul Greenwalt struct ice_phy_info *phy = &pi->phy; 20381a3571b5SPaul Greenwalt struct ice_pf *pf = pi->hw->back; 20392ccc1c1cSTony Nguyen int err; 20401a3571b5SPaul Greenwalt 20411a3571b5SPaul Greenwalt if (!(phy->link_info.link_info & ICE_AQ_MEDIA_AVAILABLE)) 20421a3571b5SPaul Greenwalt return -EIO; 20431a3571b5SPaul Greenwalt 20441a3571b5SPaul Greenwalt pcaps = kzalloc(sizeof(*pcaps), GFP_KERNEL); 20451a3571b5SPaul Greenwalt if (!pcaps) 20461a3571b5SPaul Greenwalt return -ENOMEM; 20471a3571b5SPaul Greenwalt 20480a02944fSAnirudh Venkataramanan if (ice_fw_supports_report_dflt_cfg(pi->hw)) 20492ccc1c1cSTony Nguyen err = ice_aq_get_phy_caps(pi, false, ICE_AQC_REPORT_DFLT_CFG, 20500a02944fSAnirudh Venkataramanan pcaps, NULL); 20510a02944fSAnirudh Venkataramanan else 20522ccc1c1cSTony Nguyen err = ice_aq_get_phy_caps(pi, false, ICE_AQC_REPORT_TOPO_CAP_MEDIA, 20530a02944fSAnirudh Venkataramanan pcaps, NULL); 20542ccc1c1cSTony Nguyen if (err) { 20551a3571b5SPaul Greenwalt dev_err(ice_pf_to_dev(pf), "Get PHY capability failed.\n"); 20561a3571b5SPaul Greenwalt goto err_out; 20571a3571b5SPaul Greenwalt } 20581a3571b5SPaul Greenwalt 2059ea78ce4dSPaul Greenwalt ice_copy_phy_caps_to_cfg(pi, pcaps, &pi->phy.curr_user_phy_cfg); 2060ea78ce4dSPaul Greenwalt 2061ea78ce4dSPaul Greenwalt /* check if lenient mode is supported and enabled */ 2062dc6aaa13SAnirudh Venkataramanan if (ice_fw_supports_link_override(pi->hw) && 2063ea78ce4dSPaul Greenwalt !(pcaps->module_compliance_enforcement & 2064ea78ce4dSPaul Greenwalt ICE_AQC_MOD_ENFORCE_STRICT_MODE)) { 2065ea78ce4dSPaul Greenwalt set_bit(ICE_FLAG_LINK_LENIENT_MODE_ENA, pf->flags); 2066ea78ce4dSPaul Greenwalt 20670a02944fSAnirudh Venkataramanan /* if the FW supports default PHY configuration mode, then the driver 20680a02944fSAnirudh Venkataramanan * does not have to apply link override settings. If not, 20690a02944fSAnirudh Venkataramanan * initialize user PHY configuration with link override values 2070ea78ce4dSPaul Greenwalt */ 20710a02944fSAnirudh Venkataramanan if (!ice_fw_supports_report_dflt_cfg(pi->hw) && 20720a02944fSAnirudh Venkataramanan (pf->link_dflt_override.options & ICE_LINK_OVERRIDE_EN)) { 2073ea78ce4dSPaul Greenwalt ice_init_phy_cfg_dflt_override(pi); 2074ea78ce4dSPaul Greenwalt goto out; 2075ea78ce4dSPaul Greenwalt } 2076ea78ce4dSPaul Greenwalt } 2077ea78ce4dSPaul Greenwalt 20780a02944fSAnirudh Venkataramanan /* if link default override is not enabled, set user flow control and 20790a02944fSAnirudh Venkataramanan * FEC settings based on what get_phy_caps returned 2080ea78ce4dSPaul Greenwalt */ 20811a3571b5SPaul Greenwalt phy->curr_user_fec_req = ice_caps_to_fec_mode(pcaps->caps, 20821a3571b5SPaul Greenwalt pcaps->link_fec_options); 20831a3571b5SPaul Greenwalt phy->curr_user_fc_req = ice_caps_to_fc_mode(pcaps->caps); 20841a3571b5SPaul Greenwalt 2085ea78ce4dSPaul Greenwalt out: 20861a3571b5SPaul Greenwalt phy->curr_user_speed_req = ICE_AQ_LINK_SPEED_M; 20877e408e07SAnirudh Venkataramanan set_bit(ICE_PHY_INIT_COMPLETE, pf->state); 20881a3571b5SPaul Greenwalt err_out: 20891a3571b5SPaul Greenwalt kfree(pcaps); 20901a3571b5SPaul Greenwalt return err; 20911a3571b5SPaul Greenwalt } 20921a3571b5SPaul Greenwalt 20931a3571b5SPaul Greenwalt /** 20941a3571b5SPaul Greenwalt * ice_configure_phy - configure PHY 20951a3571b5SPaul Greenwalt * @vsi: VSI of PHY 20961a3571b5SPaul Greenwalt * 20971a3571b5SPaul Greenwalt * Set the PHY configuration. If the current PHY configuration is the same as 20981a3571b5SPaul Greenwalt * the curr_user_phy_cfg, then do nothing to avoid link flap. Otherwise 20991a3571b5SPaul Greenwalt * configure the based get PHY capabilities for topology with media. 21001a3571b5SPaul Greenwalt */ 21011a3571b5SPaul Greenwalt static int ice_configure_phy(struct ice_vsi *vsi) 21021a3571b5SPaul Greenwalt { 21031a3571b5SPaul Greenwalt struct device *dev = ice_pf_to_dev(vsi->back); 2104efc1eddbSAnirudh Venkataramanan struct ice_port_info *pi = vsi->port_info; 21051a3571b5SPaul Greenwalt struct ice_aqc_get_phy_caps_data *pcaps; 21061a3571b5SPaul Greenwalt struct ice_aqc_set_phy_cfg_data *cfg; 2107efc1eddbSAnirudh Venkataramanan struct ice_phy_info *phy = &pi->phy; 2108efc1eddbSAnirudh Venkataramanan struct ice_pf *pf = vsi->back; 21092ccc1c1cSTony Nguyen int err; 21101a3571b5SPaul Greenwalt 21111a3571b5SPaul Greenwalt /* Ensure we have media as we cannot configure a medialess port */ 2112efc1eddbSAnirudh Venkataramanan if (!(phy->link_info.link_info & ICE_AQ_MEDIA_AVAILABLE)) 21131a3571b5SPaul Greenwalt return -EPERM; 21141a3571b5SPaul Greenwalt 21151a3571b5SPaul Greenwalt ice_print_topo_conflict(vsi); 21161a3571b5SPaul Greenwalt 21174fc5fbeeSAnirudh Venkataramanan if (!test_bit(ICE_FLAG_LINK_LENIENT_MODE_ENA, pf->flags) && 21184fc5fbeeSAnirudh Venkataramanan phy->link_info.topo_media_conflict == ICE_AQ_LINK_TOPO_UNSUPP_MEDIA) 21191a3571b5SPaul Greenwalt return -EPERM; 21201a3571b5SPaul Greenwalt 2121efc1eddbSAnirudh Venkataramanan if (test_bit(ICE_FLAG_LINK_DOWN_ON_CLOSE_ENA, pf->flags)) 21221a3571b5SPaul Greenwalt return ice_force_phys_link_state(vsi, true); 21231a3571b5SPaul Greenwalt 21241a3571b5SPaul Greenwalt pcaps = kzalloc(sizeof(*pcaps), GFP_KERNEL); 21251a3571b5SPaul Greenwalt if (!pcaps) 21261a3571b5SPaul Greenwalt return -ENOMEM; 21271a3571b5SPaul Greenwalt 21281a3571b5SPaul Greenwalt /* Get current PHY config */ 21292ccc1c1cSTony Nguyen err = ice_aq_get_phy_caps(pi, false, ICE_AQC_REPORT_ACTIVE_CFG, pcaps, 21301a3571b5SPaul Greenwalt NULL); 21312ccc1c1cSTony Nguyen if (err) { 21325f87ec48STony Nguyen dev_err(dev, "Failed to get PHY configuration, VSI %d error %d\n", 21332ccc1c1cSTony Nguyen vsi->vsi_num, err); 21341a3571b5SPaul Greenwalt goto done; 21351a3571b5SPaul Greenwalt } 21361a3571b5SPaul Greenwalt 21371a3571b5SPaul Greenwalt /* If PHY enable link is configured and configuration has not changed, 21381a3571b5SPaul Greenwalt * there's nothing to do 21391a3571b5SPaul Greenwalt */ 21401a3571b5SPaul Greenwalt if (pcaps->caps & ICE_AQC_PHY_EN_LINK && 2141efc1eddbSAnirudh Venkataramanan ice_phy_caps_equals_cfg(pcaps, &phy->curr_user_phy_cfg)) 21421a3571b5SPaul Greenwalt goto done; 21431a3571b5SPaul Greenwalt 21441a3571b5SPaul Greenwalt /* Use PHY topology as baseline for configuration */ 21451a3571b5SPaul Greenwalt memset(pcaps, 0, sizeof(*pcaps)); 21460a02944fSAnirudh Venkataramanan if (ice_fw_supports_report_dflt_cfg(pi->hw)) 21472ccc1c1cSTony Nguyen err = ice_aq_get_phy_caps(pi, false, ICE_AQC_REPORT_DFLT_CFG, 21480a02944fSAnirudh Venkataramanan pcaps, NULL); 21490a02944fSAnirudh Venkataramanan else 21502ccc1c1cSTony Nguyen err = ice_aq_get_phy_caps(pi, false, ICE_AQC_REPORT_TOPO_CAP_MEDIA, 21510a02944fSAnirudh Venkataramanan pcaps, NULL); 21522ccc1c1cSTony Nguyen if (err) { 21535f87ec48STony Nguyen dev_err(dev, "Failed to get PHY caps, VSI %d error %d\n", 21542ccc1c1cSTony Nguyen vsi->vsi_num, err); 21551a3571b5SPaul Greenwalt goto done; 21561a3571b5SPaul Greenwalt } 21571a3571b5SPaul Greenwalt 21581a3571b5SPaul Greenwalt cfg = kzalloc(sizeof(*cfg), GFP_KERNEL); 21591a3571b5SPaul Greenwalt if (!cfg) { 21601a3571b5SPaul Greenwalt err = -ENOMEM; 21611a3571b5SPaul Greenwalt goto done; 21621a3571b5SPaul Greenwalt } 21631a3571b5SPaul Greenwalt 2164ea78ce4dSPaul Greenwalt ice_copy_phy_caps_to_cfg(pi, pcaps, cfg); 21651a3571b5SPaul Greenwalt 21661a3571b5SPaul Greenwalt /* Speed - If default override pending, use curr_user_phy_cfg set in 21671a3571b5SPaul Greenwalt * ice_init_phy_user_cfg_ldo. 21681a3571b5SPaul Greenwalt */ 21697e408e07SAnirudh Venkataramanan if (test_and_clear_bit(ICE_LINK_DEFAULT_OVERRIDE_PENDING, 2170ea78ce4dSPaul Greenwalt vsi->back->state)) { 2171efc1eddbSAnirudh Venkataramanan cfg->phy_type_low = phy->curr_user_phy_cfg.phy_type_low; 2172efc1eddbSAnirudh Venkataramanan cfg->phy_type_high = phy->curr_user_phy_cfg.phy_type_high; 2173ea78ce4dSPaul Greenwalt } else { 2174ea78ce4dSPaul Greenwalt u64 phy_low = 0, phy_high = 0; 2175ea78ce4dSPaul Greenwalt 2176ea78ce4dSPaul Greenwalt ice_update_phy_type(&phy_low, &phy_high, 2177ea78ce4dSPaul Greenwalt pi->phy.curr_user_speed_req); 21781a3571b5SPaul Greenwalt cfg->phy_type_low = pcaps->phy_type_low & cpu_to_le64(phy_low); 2179ea78ce4dSPaul Greenwalt cfg->phy_type_high = pcaps->phy_type_high & 2180ea78ce4dSPaul Greenwalt cpu_to_le64(phy_high); 2181ea78ce4dSPaul Greenwalt } 21821a3571b5SPaul Greenwalt 21831a3571b5SPaul Greenwalt /* Can't provide what was requested; use PHY capabilities */ 21841a3571b5SPaul Greenwalt if (!cfg->phy_type_low && !cfg->phy_type_high) { 21851a3571b5SPaul Greenwalt cfg->phy_type_low = pcaps->phy_type_low; 21861a3571b5SPaul Greenwalt cfg->phy_type_high = pcaps->phy_type_high; 21871a3571b5SPaul Greenwalt } 21881a3571b5SPaul Greenwalt 21891a3571b5SPaul Greenwalt /* FEC */ 2190efc1eddbSAnirudh Venkataramanan ice_cfg_phy_fec(pi, cfg, phy->curr_user_fec_req); 21911a3571b5SPaul Greenwalt 21921a3571b5SPaul Greenwalt /* Can't provide what was requested; use PHY capabilities */ 21931a3571b5SPaul Greenwalt if (cfg->link_fec_opt != 21941a3571b5SPaul Greenwalt (cfg->link_fec_opt & pcaps->link_fec_options)) { 21951a3571b5SPaul Greenwalt cfg->caps |= pcaps->caps & ICE_AQC_PHY_EN_AUTO_FEC; 21961a3571b5SPaul Greenwalt cfg->link_fec_opt = pcaps->link_fec_options; 21971a3571b5SPaul Greenwalt } 21981a3571b5SPaul Greenwalt 21991a3571b5SPaul Greenwalt /* Flow Control - always supported; no need to check against 22001a3571b5SPaul Greenwalt * capabilities 22011a3571b5SPaul Greenwalt */ 2202efc1eddbSAnirudh Venkataramanan ice_cfg_phy_fc(pi, cfg, phy->curr_user_fc_req); 22031a3571b5SPaul Greenwalt 22041a3571b5SPaul Greenwalt /* Enable link and link update */ 22051a3571b5SPaul Greenwalt cfg->caps |= ICE_AQ_PHY_ENA_AUTO_LINK_UPDT | ICE_AQ_PHY_ENA_LINK; 22061a3571b5SPaul Greenwalt 22072ccc1c1cSTony Nguyen err = ice_aq_set_phy_cfg(&pf->hw, pi, cfg, NULL); 2208c1484691STony Nguyen if (err) 22095f87ec48STony Nguyen dev_err(dev, "Failed to set phy config, VSI %d error %d\n", 22102ccc1c1cSTony Nguyen vsi->vsi_num, err); 22111a3571b5SPaul Greenwalt 22121a3571b5SPaul Greenwalt kfree(cfg); 22131a3571b5SPaul Greenwalt done: 22141a3571b5SPaul Greenwalt kfree(pcaps); 22151a3571b5SPaul Greenwalt return err; 22161a3571b5SPaul Greenwalt } 22171a3571b5SPaul Greenwalt 22181a3571b5SPaul Greenwalt /** 22191a3571b5SPaul Greenwalt * ice_check_media_subtask - Check for media 22206d599946STony Nguyen * @pf: pointer to PF struct 22211a3571b5SPaul Greenwalt * 22221a3571b5SPaul Greenwalt * If media is available, then initialize PHY user configuration if it is not 22231a3571b5SPaul Greenwalt * been, and configure the PHY if the interface is up. 22246d599946STony Nguyen */ 22256d599946STony Nguyen static void ice_check_media_subtask(struct ice_pf *pf) 22266d599946STony Nguyen { 22276d599946STony Nguyen struct ice_port_info *pi; 22286d599946STony Nguyen struct ice_vsi *vsi; 22296d599946STony Nguyen int err; 22306d599946STony Nguyen 22311a3571b5SPaul Greenwalt /* No need to check for media if it's already present */ 22321a3571b5SPaul Greenwalt if (!test_bit(ICE_FLAG_NO_MEDIA, pf->flags)) 22336d599946STony Nguyen return; 22346d599946STony Nguyen 22351a3571b5SPaul Greenwalt vsi = ice_get_main_vsi(pf); 22361a3571b5SPaul Greenwalt if (!vsi) 22376d599946STony Nguyen return; 22386d599946STony Nguyen 22396d599946STony Nguyen /* Refresh link info and check if media is present */ 22406d599946STony Nguyen pi = vsi->port_info; 22416d599946STony Nguyen err = ice_update_link_info(pi); 22426d599946STony Nguyen if (err) 22436d599946STony Nguyen return; 22446d599946STony Nguyen 224599d40752SBrett Creeley ice_check_link_cfg_err(pf, pi->phy.link_info.link_cfg_err); 2246c77849f5SAnirudh Venkataramanan 22476d599946STony Nguyen if (pi->phy.link_info.link_info & ICE_AQ_MEDIA_AVAILABLE) { 22487e408e07SAnirudh Venkataramanan if (!test_bit(ICE_PHY_INIT_COMPLETE, pf->state)) 22491a3571b5SPaul Greenwalt ice_init_phy_user_cfg(pi); 22501a3571b5SPaul Greenwalt 22511a3571b5SPaul Greenwalt /* PHY settings are reset on media insertion, reconfigure 22521a3571b5SPaul Greenwalt * PHY to preserve settings. 22531a3571b5SPaul Greenwalt */ 2254e97fb1aeSAnirudh Venkataramanan if (test_bit(ICE_VSI_DOWN, vsi->state) && 22551a3571b5SPaul Greenwalt test_bit(ICE_FLAG_LINK_DOWN_ON_CLOSE_ENA, vsi->back->flags)) 22566d599946STony Nguyen return; 22571a3571b5SPaul Greenwalt 22581a3571b5SPaul Greenwalt err = ice_configure_phy(vsi); 22591a3571b5SPaul Greenwalt if (!err) 22606d599946STony Nguyen clear_bit(ICE_FLAG_NO_MEDIA, pf->flags); 22616d599946STony Nguyen 22626d599946STony Nguyen /* A Link Status Event will be generated; the event handler 22636d599946STony Nguyen * will complete bringing the interface up 22646d599946STony Nguyen */ 22656d599946STony Nguyen } 22666d599946STony Nguyen } 22676d599946STony Nguyen 22686d599946STony Nguyen /** 2269940b61afSAnirudh Venkataramanan * ice_service_task - manage and run subtasks 2270940b61afSAnirudh Venkataramanan * @work: pointer to work_struct contained by the PF struct 2271940b61afSAnirudh Venkataramanan */ 2272940b61afSAnirudh Venkataramanan static void ice_service_task(struct work_struct *work) 2273940b61afSAnirudh Venkataramanan { 2274940b61afSAnirudh Venkataramanan struct ice_pf *pf = container_of(work, struct ice_pf, serv_task); 2275940b61afSAnirudh Venkataramanan unsigned long start_time = jiffies; 2276940b61afSAnirudh Venkataramanan 2277940b61afSAnirudh Venkataramanan /* subtasks */ 22780b28b702SAnirudh Venkataramanan 22790b28b702SAnirudh Venkataramanan /* process reset requests first */ 22800b28b702SAnirudh Venkataramanan ice_reset_subtask(pf); 22810b28b702SAnirudh Venkataramanan 22820f9d5027SAnirudh Venkataramanan /* bail if a reset/recovery cycle is pending or rebuild failed */ 22835df7e45dSDave Ertman if (ice_is_reset_in_progress(pf->state) || 22847e408e07SAnirudh Venkataramanan test_bit(ICE_SUSPENDED, pf->state) || 22857e408e07SAnirudh Venkataramanan test_bit(ICE_NEEDS_RESTART, pf->state)) { 22860b28b702SAnirudh Venkataramanan ice_service_task_complete(pf); 22870b28b702SAnirudh Venkataramanan return; 22880b28b702SAnirudh Venkataramanan } 22890b28b702SAnirudh Venkataramanan 229032d53c0aSAlexander Lobakin if (test_and_clear_bit(ICE_AUX_ERR_PENDING, pf->state)) { 229132d53c0aSAlexander Lobakin struct iidc_event *event; 229232d53c0aSAlexander Lobakin 229332d53c0aSAlexander Lobakin event = kzalloc(sizeof(*event), GFP_KERNEL); 229432d53c0aSAlexander Lobakin if (event) { 229532d53c0aSAlexander Lobakin set_bit(IIDC_EVENT_CRIT_ERR, event->type); 229632d53c0aSAlexander Lobakin /* report the entire OICR value to AUX driver */ 229732d53c0aSAlexander Lobakin swap(event->reg, pf->oicr_err_reg); 229832d53c0aSAlexander Lobakin ice_send_event_to_aux(pf, event); 229932d53c0aSAlexander Lobakin kfree(event); 230032d53c0aSAlexander Lobakin } 230132d53c0aSAlexander Lobakin } 230232d53c0aSAlexander Lobakin 23035cb1ebdbSIvan Vecera if (test_bit(ICE_FLAG_PLUG_AUX_DEV, pf->flags)) { 23045cb1ebdbSIvan Vecera /* Plug aux device per request */ 23055dbbbd01SDave Ertman ice_plug_aux_dev(pf); 23065dbbbd01SDave Ertman 23075cb1ebdbSIvan Vecera /* Mark plugging as done but check whether unplug was 23085cb1ebdbSIvan Vecera * requested during ice_plug_aux_dev() call 23095cb1ebdbSIvan Vecera * (e.g. from ice_clear_rdma_cap()) and if so then 23105cb1ebdbSIvan Vecera * plug aux device. 23115cb1ebdbSIvan Vecera */ 23125cb1ebdbSIvan Vecera if (!test_and_clear_bit(ICE_FLAG_PLUG_AUX_DEV, pf->flags)) 23135cb1ebdbSIvan Vecera ice_unplug_aux_dev(pf); 23145cb1ebdbSIvan Vecera } 23155cb1ebdbSIvan Vecera 231697b01291SDave Ertman if (test_and_clear_bit(ICE_FLAG_MTU_CHANGED, pf->flags)) { 231797b01291SDave Ertman struct iidc_event *event; 231897b01291SDave Ertman 231997b01291SDave Ertman event = kzalloc(sizeof(*event), GFP_KERNEL); 232097b01291SDave Ertman if (event) { 232197b01291SDave Ertman set_bit(IIDC_EVENT_AFTER_MTU_CHANGE, event->type); 232297b01291SDave Ertman ice_send_event_to_aux(pf, event); 232397b01291SDave Ertman kfree(event); 232497b01291SDave Ertman } 232597b01291SDave Ertman } 232697b01291SDave Ertman 2327462acf6aSTony Nguyen ice_clean_adminq_subtask(pf); 23286d599946STony Nguyen ice_check_media_subtask(pf); 2329b3969fd7SSudheer Mogilappagari ice_check_for_hang_subtask(pf); 2330e94d4478SAnirudh Venkataramanan ice_sync_fltr_subtask(pf); 2331b3969fd7SSudheer Mogilappagari ice_handle_mdd_event(pf); 2332fcea6f3dSAnirudh Venkataramanan ice_watchdog_subtask(pf); 2333462acf6aSTony Nguyen 2334462acf6aSTony Nguyen if (ice_is_safe_mode(pf)) { 2335462acf6aSTony Nguyen ice_service_task_complete(pf); 2336462acf6aSTony Nguyen return; 2337462acf6aSTony Nguyen } 2338462acf6aSTony Nguyen 2339462acf6aSTony Nguyen ice_process_vflr_event(pf); 234075d2b253SAnirudh Venkataramanan ice_clean_mailboxq_subtask(pf); 23418f5ee3c4SJacob Keller ice_clean_sbq_subtask(pf); 234228bf2672SBrett Creeley ice_sync_arfs_fltrs(pf); 2343d6218317SQi Zhang ice_flush_fdir_ctx(pf); 23447e408e07SAnirudh Venkataramanan 23457e408e07SAnirudh Venkataramanan /* Clear ICE_SERVICE_SCHED flag to allow scheduling next event */ 2346940b61afSAnirudh Venkataramanan ice_service_task_complete(pf); 2347940b61afSAnirudh Venkataramanan 2348940b61afSAnirudh Venkataramanan /* If the tasks have taken longer than one service timer period 2349940b61afSAnirudh Venkataramanan * or there is more work to be done, reset the service timer to 2350940b61afSAnirudh Venkataramanan * schedule the service task now. 2351940b61afSAnirudh Venkataramanan */ 2352940b61afSAnirudh Venkataramanan if (time_after(jiffies, (start_time + pf->serv_tmr_period)) || 23537e408e07SAnirudh Venkataramanan test_bit(ICE_MDD_EVENT_PENDING, pf->state) || 23547e408e07SAnirudh Venkataramanan test_bit(ICE_VFLR_EVENT_PENDING, pf->state) || 23557e408e07SAnirudh Venkataramanan test_bit(ICE_MAILBOXQ_EVENT_PENDING, pf->state) || 23567e408e07SAnirudh Venkataramanan test_bit(ICE_FD_VF_FLUSH_CTX, pf->state) || 23578f5ee3c4SJacob Keller test_bit(ICE_SIDEBANDQ_EVENT_PENDING, pf->state) || 23587e408e07SAnirudh Venkataramanan test_bit(ICE_ADMINQ_EVENT_PENDING, pf->state)) 2359940b61afSAnirudh Venkataramanan mod_timer(&pf->serv_tmr, jiffies); 2360940b61afSAnirudh Venkataramanan } 2361940b61afSAnirudh Venkataramanan 2362837f08fdSAnirudh Venkataramanan /** 2363f31e4b6fSAnirudh Venkataramanan * ice_set_ctrlq_len - helper function to set controlq length 2364f9867df6SAnirudh Venkataramanan * @hw: pointer to the HW instance 2365f31e4b6fSAnirudh Venkataramanan */ 2366f31e4b6fSAnirudh Venkataramanan static void ice_set_ctrlq_len(struct ice_hw *hw) 2367f31e4b6fSAnirudh Venkataramanan { 2368f31e4b6fSAnirudh Venkataramanan hw->adminq.num_rq_entries = ICE_AQ_LEN; 2369f31e4b6fSAnirudh Venkataramanan hw->adminq.num_sq_entries = ICE_AQ_LEN; 2370f31e4b6fSAnirudh Venkataramanan hw->adminq.rq_buf_size = ICE_AQ_MAX_BUF_LEN; 2371f31e4b6fSAnirudh Venkataramanan hw->adminq.sq_buf_size = ICE_AQ_MAX_BUF_LEN; 2372c8a1071dSLukasz Czapnik hw->mailboxq.num_rq_entries = PF_MBX_ARQLEN_ARQLEN_M; 237311836214SBrett Creeley hw->mailboxq.num_sq_entries = ICE_MBXSQ_LEN; 237475d2b253SAnirudh Venkataramanan hw->mailboxq.rq_buf_size = ICE_MBXQ_MAX_BUF_LEN; 237575d2b253SAnirudh Venkataramanan hw->mailboxq.sq_buf_size = ICE_MBXQ_MAX_BUF_LEN; 23768f5ee3c4SJacob Keller hw->sbq.num_rq_entries = ICE_SBQ_LEN; 23778f5ee3c4SJacob Keller hw->sbq.num_sq_entries = ICE_SBQ_LEN; 23788f5ee3c4SJacob Keller hw->sbq.rq_buf_size = ICE_SBQ_MAX_BUF_LEN; 23798f5ee3c4SJacob Keller hw->sbq.sq_buf_size = ICE_SBQ_MAX_BUF_LEN; 2380f31e4b6fSAnirudh Venkataramanan } 2381f31e4b6fSAnirudh Venkataramanan 2382f31e4b6fSAnirudh Venkataramanan /** 238387324e74SHenry Tieman * ice_schedule_reset - schedule a reset 238487324e74SHenry Tieman * @pf: board private structure 238587324e74SHenry Tieman * @reset: reset being requested 238687324e74SHenry Tieman */ 238787324e74SHenry Tieman int ice_schedule_reset(struct ice_pf *pf, enum ice_reset_req reset) 238887324e74SHenry Tieman { 238987324e74SHenry Tieman struct device *dev = ice_pf_to_dev(pf); 239087324e74SHenry Tieman 239187324e74SHenry Tieman /* bail out if earlier reset has failed */ 23927e408e07SAnirudh Venkataramanan if (test_bit(ICE_RESET_FAILED, pf->state)) { 239387324e74SHenry Tieman dev_dbg(dev, "earlier reset has failed\n"); 239487324e74SHenry Tieman return -EIO; 239587324e74SHenry Tieman } 239687324e74SHenry Tieman /* bail if reset/recovery already in progress */ 239787324e74SHenry Tieman if (ice_is_reset_in_progress(pf->state)) { 239887324e74SHenry Tieman dev_dbg(dev, "Reset already in progress\n"); 239987324e74SHenry Tieman return -EBUSY; 240087324e74SHenry Tieman } 240187324e74SHenry Tieman 2402f9f5301eSDave Ertman ice_unplug_aux_dev(pf); 2403f9f5301eSDave Ertman 240487324e74SHenry Tieman switch (reset) { 240587324e74SHenry Tieman case ICE_RESET_PFR: 24067e408e07SAnirudh Venkataramanan set_bit(ICE_PFR_REQ, pf->state); 240787324e74SHenry Tieman break; 240887324e74SHenry Tieman case ICE_RESET_CORER: 24097e408e07SAnirudh Venkataramanan set_bit(ICE_CORER_REQ, pf->state); 241087324e74SHenry Tieman break; 241187324e74SHenry Tieman case ICE_RESET_GLOBR: 24127e408e07SAnirudh Venkataramanan set_bit(ICE_GLOBR_REQ, pf->state); 241387324e74SHenry Tieman break; 241487324e74SHenry Tieman default: 241587324e74SHenry Tieman return -EINVAL; 241687324e74SHenry Tieman } 241787324e74SHenry Tieman 241887324e74SHenry Tieman ice_service_task_schedule(pf); 241987324e74SHenry Tieman return 0; 242087324e74SHenry Tieman } 242187324e74SHenry Tieman 242287324e74SHenry Tieman /** 2423cdedef59SAnirudh Venkataramanan * ice_irq_affinity_notify - Callback for affinity changes 2424cdedef59SAnirudh Venkataramanan * @notify: context as to what irq was changed 2425cdedef59SAnirudh Venkataramanan * @mask: the new affinity mask 2426cdedef59SAnirudh Venkataramanan * 2427cdedef59SAnirudh Venkataramanan * This is a callback function used by the irq_set_affinity_notifier function 2428cdedef59SAnirudh Venkataramanan * so that we may register to receive changes to the irq affinity masks. 2429cdedef59SAnirudh Venkataramanan */ 2430c8b7abddSBruce Allan static void 2431c8b7abddSBruce Allan ice_irq_affinity_notify(struct irq_affinity_notify *notify, 2432cdedef59SAnirudh Venkataramanan const cpumask_t *mask) 2433cdedef59SAnirudh Venkataramanan { 2434cdedef59SAnirudh Venkataramanan struct ice_q_vector *q_vector = 2435cdedef59SAnirudh Venkataramanan container_of(notify, struct ice_q_vector, affinity_notify); 2436cdedef59SAnirudh Venkataramanan 2437cdedef59SAnirudh Venkataramanan cpumask_copy(&q_vector->affinity_mask, mask); 2438cdedef59SAnirudh Venkataramanan } 2439cdedef59SAnirudh Venkataramanan 2440cdedef59SAnirudh Venkataramanan /** 2441cdedef59SAnirudh Venkataramanan * ice_irq_affinity_release - Callback for affinity notifier release 2442cdedef59SAnirudh Venkataramanan * @ref: internal core kernel usage 2443cdedef59SAnirudh Venkataramanan * 2444cdedef59SAnirudh Venkataramanan * This is a callback function used by the irq_set_affinity_notifier function 2445cdedef59SAnirudh Venkataramanan * to inform the current notification subscriber that they will no longer 2446cdedef59SAnirudh Venkataramanan * receive notifications. 2447cdedef59SAnirudh Venkataramanan */ 2448cdedef59SAnirudh Venkataramanan static void ice_irq_affinity_release(struct kref __always_unused *ref) {} 2449cdedef59SAnirudh Venkataramanan 2450cdedef59SAnirudh Venkataramanan /** 2451cdedef59SAnirudh Venkataramanan * ice_vsi_ena_irq - Enable IRQ for the given VSI 2452cdedef59SAnirudh Venkataramanan * @vsi: the VSI being configured 2453cdedef59SAnirudh Venkataramanan */ 2454cdedef59SAnirudh Venkataramanan static int ice_vsi_ena_irq(struct ice_vsi *vsi) 2455cdedef59SAnirudh Venkataramanan { 2456ba880734SBrett Creeley struct ice_hw *hw = &vsi->back->hw; 2457cdedef59SAnirudh Venkataramanan int i; 2458cdedef59SAnirudh Venkataramanan 24590c2561c8SBrett Creeley ice_for_each_q_vector(vsi, i) 2460cdedef59SAnirudh Venkataramanan ice_irq_dynamic_ena(hw, vsi, vsi->q_vectors[i]); 2461cdedef59SAnirudh Venkataramanan 2462cdedef59SAnirudh Venkataramanan ice_flush(hw); 2463cdedef59SAnirudh Venkataramanan return 0; 2464cdedef59SAnirudh Venkataramanan } 2465cdedef59SAnirudh Venkataramanan 2466cdedef59SAnirudh Venkataramanan /** 2467cdedef59SAnirudh Venkataramanan * ice_vsi_req_irq_msix - get MSI-X vectors from the OS for the VSI 2468cdedef59SAnirudh Venkataramanan * @vsi: the VSI being configured 2469cdedef59SAnirudh Venkataramanan * @basename: name for the vector 2470cdedef59SAnirudh Venkataramanan */ 2471cdedef59SAnirudh Venkataramanan static int ice_vsi_req_irq_msix(struct ice_vsi *vsi, char *basename) 2472cdedef59SAnirudh Venkataramanan { 2473cdedef59SAnirudh Venkataramanan int q_vectors = vsi->num_q_vectors; 2474cdedef59SAnirudh Venkataramanan struct ice_pf *pf = vsi->back; 2475cbe66bfeSBrett Creeley int base = vsi->base_vector; 24764015d11eSBrett Creeley struct device *dev; 2477cdedef59SAnirudh Venkataramanan int rx_int_idx = 0; 2478cdedef59SAnirudh Venkataramanan int tx_int_idx = 0; 2479cdedef59SAnirudh Venkataramanan int vector, err; 2480cdedef59SAnirudh Venkataramanan int irq_num; 2481cdedef59SAnirudh Venkataramanan 24824015d11eSBrett Creeley dev = ice_pf_to_dev(pf); 2483cdedef59SAnirudh Venkataramanan for (vector = 0; vector < q_vectors; vector++) { 2484cdedef59SAnirudh Venkataramanan struct ice_q_vector *q_vector = vsi->q_vectors[vector]; 2485cdedef59SAnirudh Venkataramanan 2486cdedef59SAnirudh Venkataramanan irq_num = pf->msix_entries[base + vector].vector; 2487cdedef59SAnirudh Venkataramanan 2488e72bba21SMaciej Fijalkowski if (q_vector->tx.tx_ring && q_vector->rx.rx_ring) { 2489cdedef59SAnirudh Venkataramanan snprintf(q_vector->name, sizeof(q_vector->name) - 1, 2490cdedef59SAnirudh Venkataramanan "%s-%s-%d", basename, "TxRx", rx_int_idx++); 2491cdedef59SAnirudh Venkataramanan tx_int_idx++; 2492e72bba21SMaciej Fijalkowski } else if (q_vector->rx.rx_ring) { 2493cdedef59SAnirudh Venkataramanan snprintf(q_vector->name, sizeof(q_vector->name) - 1, 2494cdedef59SAnirudh Venkataramanan "%s-%s-%d", basename, "rx", rx_int_idx++); 2495e72bba21SMaciej Fijalkowski } else if (q_vector->tx.tx_ring) { 2496cdedef59SAnirudh Venkataramanan snprintf(q_vector->name, sizeof(q_vector->name) - 1, 2497cdedef59SAnirudh Venkataramanan "%s-%s-%d", basename, "tx", tx_int_idx++); 2498cdedef59SAnirudh Venkataramanan } else { 2499cdedef59SAnirudh Venkataramanan /* skip this unused q_vector */ 2500cdedef59SAnirudh Venkataramanan continue; 2501cdedef59SAnirudh Venkataramanan } 2502b03d519dSJacob Keller if (vsi->type == ICE_VSI_CTRL && vsi->vf) 2503da62c5ffSQi Zhang err = devm_request_irq(dev, irq_num, vsi->irq_handler, 2504da62c5ffSQi Zhang IRQF_SHARED, q_vector->name, 2505da62c5ffSQi Zhang q_vector); 2506da62c5ffSQi Zhang else 2507da62c5ffSQi Zhang err = devm_request_irq(dev, irq_num, vsi->irq_handler, 2508da62c5ffSQi Zhang 0, q_vector->name, q_vector); 2509cdedef59SAnirudh Venkataramanan if (err) { 251019cce2c6SAnirudh Venkataramanan netdev_err(vsi->netdev, "MSIX request_irq failed, error: %d\n", 251119cce2c6SAnirudh Venkataramanan err); 2512cdedef59SAnirudh Venkataramanan goto free_q_irqs; 2513cdedef59SAnirudh Venkataramanan } 2514cdedef59SAnirudh Venkataramanan 2515cdedef59SAnirudh Venkataramanan /* register for affinity change notifications */ 251628bf2672SBrett Creeley if (!IS_ENABLED(CONFIG_RFS_ACCEL)) { 251728bf2672SBrett Creeley struct irq_affinity_notify *affinity_notify; 251828bf2672SBrett Creeley 251928bf2672SBrett Creeley affinity_notify = &q_vector->affinity_notify; 252028bf2672SBrett Creeley affinity_notify->notify = ice_irq_affinity_notify; 252128bf2672SBrett Creeley affinity_notify->release = ice_irq_affinity_release; 252228bf2672SBrett Creeley irq_set_affinity_notifier(irq_num, affinity_notify); 252328bf2672SBrett Creeley } 2524cdedef59SAnirudh Venkataramanan 2525cdedef59SAnirudh Venkataramanan /* assign the mask for this irq */ 2526cdedef59SAnirudh Venkataramanan irq_set_affinity_hint(irq_num, &q_vector->affinity_mask); 2527cdedef59SAnirudh Venkataramanan } 2528cdedef59SAnirudh Venkataramanan 2529d7442f51SAlexander Lobakin err = ice_set_cpu_rx_rmap(vsi); 2530d7442f51SAlexander Lobakin if (err) { 2531d7442f51SAlexander Lobakin netdev_err(vsi->netdev, "Failed to setup CPU RMAP on VSI %u: %pe\n", 2532d7442f51SAlexander Lobakin vsi->vsi_num, ERR_PTR(err)); 2533d7442f51SAlexander Lobakin goto free_q_irqs; 2534d7442f51SAlexander Lobakin } 2535d7442f51SAlexander Lobakin 2536cdedef59SAnirudh Venkataramanan vsi->irqs_ready = true; 2537cdedef59SAnirudh Venkataramanan return 0; 2538cdedef59SAnirudh Venkataramanan 2539cdedef59SAnirudh Venkataramanan free_q_irqs: 2540cdedef59SAnirudh Venkataramanan while (vector) { 2541cdedef59SAnirudh Venkataramanan vector--; 254228bf2672SBrett Creeley irq_num = pf->msix_entries[base + vector].vector; 254328bf2672SBrett Creeley if (!IS_ENABLED(CONFIG_RFS_ACCEL)) 2544cdedef59SAnirudh Venkataramanan irq_set_affinity_notifier(irq_num, NULL); 2545cdedef59SAnirudh Venkataramanan irq_set_affinity_hint(irq_num, NULL); 25464015d11eSBrett Creeley devm_free_irq(dev, irq_num, &vsi->q_vectors[vector]); 2547cdedef59SAnirudh Venkataramanan } 2548cdedef59SAnirudh Venkataramanan return err; 2549cdedef59SAnirudh Venkataramanan } 2550cdedef59SAnirudh Venkataramanan 2551cdedef59SAnirudh Venkataramanan /** 2552efc2214bSMaciej Fijalkowski * ice_xdp_alloc_setup_rings - Allocate and setup Tx rings for XDP 2553efc2214bSMaciej Fijalkowski * @vsi: VSI to setup Tx rings used by XDP 2554efc2214bSMaciej Fijalkowski * 2555efc2214bSMaciej Fijalkowski * Return 0 on success and negative value on error 2556efc2214bSMaciej Fijalkowski */ 2557efc2214bSMaciej Fijalkowski static int ice_xdp_alloc_setup_rings(struct ice_vsi *vsi) 2558efc2214bSMaciej Fijalkowski { 25599a946843SAnirudh Venkataramanan struct device *dev = ice_pf_to_dev(vsi->back); 25609610bd98SMaciej Fijalkowski struct ice_tx_desc *tx_desc; 25619610bd98SMaciej Fijalkowski int i, j; 2562efc2214bSMaciej Fijalkowski 25632faf63b6SMaciej Fijalkowski ice_for_each_xdp_txq(vsi, i) { 2564efc2214bSMaciej Fijalkowski u16 xdp_q_idx = vsi->alloc_txq + i; 2565e72bba21SMaciej Fijalkowski struct ice_tx_ring *xdp_ring; 2566efc2214bSMaciej Fijalkowski 2567efc2214bSMaciej Fijalkowski xdp_ring = kzalloc(sizeof(*xdp_ring), GFP_KERNEL); 2568efc2214bSMaciej Fijalkowski 2569efc2214bSMaciej Fijalkowski if (!xdp_ring) 2570efc2214bSMaciej Fijalkowski goto free_xdp_rings; 2571efc2214bSMaciej Fijalkowski 2572efc2214bSMaciej Fijalkowski xdp_ring->q_index = xdp_q_idx; 2573efc2214bSMaciej Fijalkowski xdp_ring->reg_idx = vsi->txq_map[xdp_q_idx]; 2574efc2214bSMaciej Fijalkowski xdp_ring->vsi = vsi; 2575efc2214bSMaciej Fijalkowski xdp_ring->netdev = NULL; 2576efc2214bSMaciej Fijalkowski xdp_ring->dev = dev; 2577efc2214bSMaciej Fijalkowski xdp_ring->count = vsi->num_tx_desc; 25783dd411efSMaciej Fijalkowski xdp_ring->next_dd = ICE_RING_QUARTER(xdp_ring) - 1; 25793dd411efSMaciej Fijalkowski xdp_ring->next_rs = ICE_RING_QUARTER(xdp_ring) - 1; 2580b1d95cc2SCiara Loftus WRITE_ONCE(vsi->xdp_rings[i], xdp_ring); 2581efc2214bSMaciej Fijalkowski if (ice_setup_tx_ring(xdp_ring)) 2582efc2214bSMaciej Fijalkowski goto free_xdp_rings; 2583efc2214bSMaciej Fijalkowski ice_set_ring_xdp(xdp_ring); 258422bf877eSMaciej Fijalkowski spin_lock_init(&xdp_ring->tx_lock); 25859610bd98SMaciej Fijalkowski for (j = 0; j < xdp_ring->count; j++) { 25869610bd98SMaciej Fijalkowski tx_desc = ICE_TX_DESC(xdp_ring, j); 2587e19778e6SMaciej Fijalkowski tx_desc->cmd_type_offset_bsz = 0; 25889610bd98SMaciej Fijalkowski } 2589efc2214bSMaciej Fijalkowski } 2590efc2214bSMaciej Fijalkowski 2591efc2214bSMaciej Fijalkowski return 0; 2592efc2214bSMaciej Fijalkowski 2593efc2214bSMaciej Fijalkowski free_xdp_rings: 2594efc2214bSMaciej Fijalkowski for (; i >= 0; i--) 2595efc2214bSMaciej Fijalkowski if (vsi->xdp_rings[i] && vsi->xdp_rings[i]->desc) 2596efc2214bSMaciej Fijalkowski ice_free_tx_ring(vsi->xdp_rings[i]); 2597efc2214bSMaciej Fijalkowski return -ENOMEM; 2598efc2214bSMaciej Fijalkowski } 2599efc2214bSMaciej Fijalkowski 2600efc2214bSMaciej Fijalkowski /** 2601efc2214bSMaciej Fijalkowski * ice_vsi_assign_bpf_prog - set or clear bpf prog pointer on VSI 2602efc2214bSMaciej Fijalkowski * @vsi: VSI to set the bpf prog on 2603efc2214bSMaciej Fijalkowski * @prog: the bpf prog pointer 2604efc2214bSMaciej Fijalkowski */ 2605efc2214bSMaciej Fijalkowski static void ice_vsi_assign_bpf_prog(struct ice_vsi *vsi, struct bpf_prog *prog) 2606efc2214bSMaciej Fijalkowski { 2607efc2214bSMaciej Fijalkowski struct bpf_prog *old_prog; 2608efc2214bSMaciej Fijalkowski int i; 2609efc2214bSMaciej Fijalkowski 2610efc2214bSMaciej Fijalkowski old_prog = xchg(&vsi->xdp_prog, prog); 2611efc2214bSMaciej Fijalkowski if (old_prog) 2612efc2214bSMaciej Fijalkowski bpf_prog_put(old_prog); 2613efc2214bSMaciej Fijalkowski 2614efc2214bSMaciej Fijalkowski ice_for_each_rxq(vsi, i) 2615efc2214bSMaciej Fijalkowski WRITE_ONCE(vsi->rx_rings[i]->xdp_prog, vsi->xdp_prog); 2616efc2214bSMaciej Fijalkowski } 2617efc2214bSMaciej Fijalkowski 2618efc2214bSMaciej Fijalkowski /** 2619efc2214bSMaciej Fijalkowski * ice_prepare_xdp_rings - Allocate, configure and setup Tx rings for XDP 2620efc2214bSMaciej Fijalkowski * @vsi: VSI to bring up Tx rings used by XDP 2621efc2214bSMaciej Fijalkowski * @prog: bpf program that will be assigned to VSI 2622efc2214bSMaciej Fijalkowski * 2623efc2214bSMaciej Fijalkowski * Return 0 on success and negative value on error 2624efc2214bSMaciej Fijalkowski */ 2625efc2214bSMaciej Fijalkowski int ice_prepare_xdp_rings(struct ice_vsi *vsi, struct bpf_prog *prog) 2626efc2214bSMaciej Fijalkowski { 2627efc2214bSMaciej Fijalkowski u16 max_txqs[ICE_MAX_TRAFFIC_CLASS] = { 0 }; 2628efc2214bSMaciej Fijalkowski int xdp_rings_rem = vsi->num_xdp_txq; 2629efc2214bSMaciej Fijalkowski struct ice_pf *pf = vsi->back; 2630efc2214bSMaciej Fijalkowski struct ice_qs_cfg xdp_qs_cfg = { 2631efc2214bSMaciej Fijalkowski .qs_mutex = &pf->avail_q_mutex, 2632efc2214bSMaciej Fijalkowski .pf_map = pf->avail_txqs, 2633efc2214bSMaciej Fijalkowski .pf_map_size = pf->max_pf_txqs, 2634efc2214bSMaciej Fijalkowski .q_count = vsi->num_xdp_txq, 2635efc2214bSMaciej Fijalkowski .scatter_count = ICE_MAX_SCATTER_TXQS, 2636efc2214bSMaciej Fijalkowski .vsi_map = vsi->txq_map, 2637efc2214bSMaciej Fijalkowski .vsi_map_offset = vsi->alloc_txq, 2638efc2214bSMaciej Fijalkowski .mapping_mode = ICE_VSI_MAP_CONTIG 2639efc2214bSMaciej Fijalkowski }; 26404015d11eSBrett Creeley struct device *dev; 2641efc2214bSMaciej Fijalkowski int i, v_idx; 26425518ac2aSTony Nguyen int status; 2643efc2214bSMaciej Fijalkowski 26444015d11eSBrett Creeley dev = ice_pf_to_dev(pf); 26454015d11eSBrett Creeley vsi->xdp_rings = devm_kcalloc(dev, vsi->num_xdp_txq, 2646efc2214bSMaciej Fijalkowski sizeof(*vsi->xdp_rings), GFP_KERNEL); 2647efc2214bSMaciej Fijalkowski if (!vsi->xdp_rings) 2648efc2214bSMaciej Fijalkowski return -ENOMEM; 2649efc2214bSMaciej Fijalkowski 2650efc2214bSMaciej Fijalkowski vsi->xdp_mapping_mode = xdp_qs_cfg.mapping_mode; 2651efc2214bSMaciej Fijalkowski if (__ice_vsi_get_qs(&xdp_qs_cfg)) 2652efc2214bSMaciej Fijalkowski goto err_map_xdp; 2653efc2214bSMaciej Fijalkowski 265422bf877eSMaciej Fijalkowski if (static_key_enabled(&ice_xdp_locking_key)) 265522bf877eSMaciej Fijalkowski netdev_warn(vsi->netdev, 265622bf877eSMaciej Fijalkowski "Could not allocate one XDP Tx ring per CPU, XDP_TX/XDP_REDIRECT actions will be slower\n"); 265722bf877eSMaciej Fijalkowski 2658efc2214bSMaciej Fijalkowski if (ice_xdp_alloc_setup_rings(vsi)) 2659efc2214bSMaciej Fijalkowski goto clear_xdp_rings; 2660efc2214bSMaciej Fijalkowski 2661efc2214bSMaciej Fijalkowski /* follow the logic from ice_vsi_map_rings_to_vectors */ 2662efc2214bSMaciej Fijalkowski ice_for_each_q_vector(vsi, v_idx) { 2663efc2214bSMaciej Fijalkowski struct ice_q_vector *q_vector = vsi->q_vectors[v_idx]; 2664efc2214bSMaciej Fijalkowski int xdp_rings_per_v, q_id, q_base; 2665efc2214bSMaciej Fijalkowski 2666efc2214bSMaciej Fijalkowski xdp_rings_per_v = DIV_ROUND_UP(xdp_rings_rem, 2667efc2214bSMaciej Fijalkowski vsi->num_q_vectors - v_idx); 2668efc2214bSMaciej Fijalkowski q_base = vsi->num_xdp_txq - xdp_rings_rem; 2669efc2214bSMaciej Fijalkowski 2670efc2214bSMaciej Fijalkowski for (q_id = q_base; q_id < (q_base + xdp_rings_per_v); q_id++) { 2671e72bba21SMaciej Fijalkowski struct ice_tx_ring *xdp_ring = vsi->xdp_rings[q_id]; 2672efc2214bSMaciej Fijalkowski 2673efc2214bSMaciej Fijalkowski xdp_ring->q_vector = q_vector; 2674e72bba21SMaciej Fijalkowski xdp_ring->next = q_vector->tx.tx_ring; 2675e72bba21SMaciej Fijalkowski q_vector->tx.tx_ring = xdp_ring; 2676efc2214bSMaciej Fijalkowski } 2677efc2214bSMaciej Fijalkowski xdp_rings_rem -= xdp_rings_per_v; 2678efc2214bSMaciej Fijalkowski } 2679efc2214bSMaciej Fijalkowski 26809ead7e74SMaciej Fijalkowski ice_for_each_rxq(vsi, i) { 26819ead7e74SMaciej Fijalkowski if (static_key_enabled(&ice_xdp_locking_key)) { 26829ead7e74SMaciej Fijalkowski vsi->rx_rings[i]->xdp_ring = vsi->xdp_rings[i % vsi->num_xdp_txq]; 26839ead7e74SMaciej Fijalkowski } else { 26849ead7e74SMaciej Fijalkowski struct ice_q_vector *q_vector = vsi->rx_rings[i]->q_vector; 26859ead7e74SMaciej Fijalkowski struct ice_tx_ring *ring; 26869ead7e74SMaciej Fijalkowski 26879ead7e74SMaciej Fijalkowski ice_for_each_tx_ring(ring, q_vector->tx) { 26889ead7e74SMaciej Fijalkowski if (ice_ring_is_xdp(ring)) { 26899ead7e74SMaciej Fijalkowski vsi->rx_rings[i]->xdp_ring = ring; 26909ead7e74SMaciej Fijalkowski break; 26919ead7e74SMaciej Fijalkowski } 26929ead7e74SMaciej Fijalkowski } 26939ead7e74SMaciej Fijalkowski } 26949ead7e74SMaciej Fijalkowski ice_tx_xsk_pool(vsi, i); 26959ead7e74SMaciej Fijalkowski } 26969ead7e74SMaciej Fijalkowski 2697efc2214bSMaciej Fijalkowski /* omit the scheduler update if in reset path; XDP queues will be 2698efc2214bSMaciej Fijalkowski * taken into account at the end of ice_vsi_rebuild, where 2699efc2214bSMaciej Fijalkowski * ice_cfg_vsi_lan is being called 2700efc2214bSMaciej Fijalkowski */ 2701efc2214bSMaciej Fijalkowski if (ice_is_reset_in_progress(pf->state)) 2702efc2214bSMaciej Fijalkowski return 0; 2703efc2214bSMaciej Fijalkowski 2704efc2214bSMaciej Fijalkowski /* tell the Tx scheduler that right now we have 2705efc2214bSMaciej Fijalkowski * additional queues 2706efc2214bSMaciej Fijalkowski */ 2707efc2214bSMaciej Fijalkowski for (i = 0; i < vsi->tc_cfg.numtc; i++) 2708efc2214bSMaciej Fijalkowski max_txqs[i] = vsi->num_txq + vsi->num_xdp_txq; 2709efc2214bSMaciej Fijalkowski 2710efc2214bSMaciej Fijalkowski status = ice_cfg_vsi_lan(vsi->port_info, vsi->idx, vsi->tc_cfg.ena_tc, 2711efc2214bSMaciej Fijalkowski max_txqs); 2712efc2214bSMaciej Fijalkowski if (status) { 27135f87ec48STony Nguyen dev_err(dev, "Failed VSI LAN queue config for XDP, error: %d\n", 27145f87ec48STony Nguyen status); 2715efc2214bSMaciej Fijalkowski goto clear_xdp_rings; 2716efc2214bSMaciej Fijalkowski } 2717f65ee535SMarta Plantykow 2718f65ee535SMarta Plantykow /* assign the prog only when it's not already present on VSI; 2719f65ee535SMarta Plantykow * this flow is a subject of both ethtool -L and ndo_bpf flows; 2720f65ee535SMarta Plantykow * VSI rebuild that happens under ethtool -L can expose us to 2721f65ee535SMarta Plantykow * the bpf_prog refcount issues as we would be swapping same 2722f65ee535SMarta Plantykow * bpf_prog pointers from vsi->xdp_prog and calling bpf_prog_put 2723f65ee535SMarta Plantykow * on it as it would be treated as an 'old_prog'; for ndo_bpf 2724f65ee535SMarta Plantykow * this is not harmful as dev_xdp_install bumps the refcount 2725f65ee535SMarta Plantykow * before calling the op exposed by the driver; 2726f65ee535SMarta Plantykow */ 2727f65ee535SMarta Plantykow if (!ice_is_xdp_ena_vsi(vsi)) 2728efc2214bSMaciej Fijalkowski ice_vsi_assign_bpf_prog(vsi, prog); 2729efc2214bSMaciej Fijalkowski 2730efc2214bSMaciej Fijalkowski return 0; 2731efc2214bSMaciej Fijalkowski clear_xdp_rings: 27322faf63b6SMaciej Fijalkowski ice_for_each_xdp_txq(vsi, i) 2733efc2214bSMaciej Fijalkowski if (vsi->xdp_rings[i]) { 2734efc2214bSMaciej Fijalkowski kfree_rcu(vsi->xdp_rings[i], rcu); 2735efc2214bSMaciej Fijalkowski vsi->xdp_rings[i] = NULL; 2736efc2214bSMaciej Fijalkowski } 2737efc2214bSMaciej Fijalkowski 2738efc2214bSMaciej Fijalkowski err_map_xdp: 2739efc2214bSMaciej Fijalkowski mutex_lock(&pf->avail_q_mutex); 27402faf63b6SMaciej Fijalkowski ice_for_each_xdp_txq(vsi, i) { 2741efc2214bSMaciej Fijalkowski clear_bit(vsi->txq_map[i + vsi->alloc_txq], pf->avail_txqs); 2742efc2214bSMaciej Fijalkowski vsi->txq_map[i + vsi->alloc_txq] = ICE_INVAL_Q_INDEX; 2743efc2214bSMaciej Fijalkowski } 2744efc2214bSMaciej Fijalkowski mutex_unlock(&pf->avail_q_mutex); 2745efc2214bSMaciej Fijalkowski 27464015d11eSBrett Creeley devm_kfree(dev, vsi->xdp_rings); 2747efc2214bSMaciej Fijalkowski return -ENOMEM; 2748efc2214bSMaciej Fijalkowski } 2749efc2214bSMaciej Fijalkowski 2750efc2214bSMaciej Fijalkowski /** 2751efc2214bSMaciej Fijalkowski * ice_destroy_xdp_rings - undo the configuration made by ice_prepare_xdp_rings 2752efc2214bSMaciej Fijalkowski * @vsi: VSI to remove XDP rings 2753efc2214bSMaciej Fijalkowski * 2754efc2214bSMaciej Fijalkowski * Detach XDP rings from irq vectors, clean up the PF bitmap and free 2755efc2214bSMaciej Fijalkowski * resources 2756efc2214bSMaciej Fijalkowski */ 2757efc2214bSMaciej Fijalkowski int ice_destroy_xdp_rings(struct ice_vsi *vsi) 2758efc2214bSMaciej Fijalkowski { 2759efc2214bSMaciej Fijalkowski u16 max_txqs[ICE_MAX_TRAFFIC_CLASS] = { 0 }; 2760efc2214bSMaciej Fijalkowski struct ice_pf *pf = vsi->back; 2761efc2214bSMaciej Fijalkowski int i, v_idx; 2762efc2214bSMaciej Fijalkowski 2763efc2214bSMaciej Fijalkowski /* q_vectors are freed in reset path so there's no point in detaching 2764ac382a09SBruce Allan * rings; in case of rebuild being triggered not from reset bits 2765efc2214bSMaciej Fijalkowski * in pf->state won't be set, so additionally check first q_vector 2766efc2214bSMaciej Fijalkowski * against NULL 2767efc2214bSMaciej Fijalkowski */ 2768efc2214bSMaciej Fijalkowski if (ice_is_reset_in_progress(pf->state) || !vsi->q_vectors[0]) 2769efc2214bSMaciej Fijalkowski goto free_qmap; 2770efc2214bSMaciej Fijalkowski 2771efc2214bSMaciej Fijalkowski ice_for_each_q_vector(vsi, v_idx) { 2772efc2214bSMaciej Fijalkowski struct ice_q_vector *q_vector = vsi->q_vectors[v_idx]; 2773e72bba21SMaciej Fijalkowski struct ice_tx_ring *ring; 2774efc2214bSMaciej Fijalkowski 2775e72bba21SMaciej Fijalkowski ice_for_each_tx_ring(ring, q_vector->tx) 2776efc2214bSMaciej Fijalkowski if (!ring->tx_buf || !ice_ring_is_xdp(ring)) 2777efc2214bSMaciej Fijalkowski break; 2778efc2214bSMaciej Fijalkowski 2779efc2214bSMaciej Fijalkowski /* restore the value of last node prior to XDP setup */ 2780e72bba21SMaciej Fijalkowski q_vector->tx.tx_ring = ring; 2781efc2214bSMaciej Fijalkowski } 2782efc2214bSMaciej Fijalkowski 2783efc2214bSMaciej Fijalkowski free_qmap: 2784efc2214bSMaciej Fijalkowski mutex_lock(&pf->avail_q_mutex); 27852faf63b6SMaciej Fijalkowski ice_for_each_xdp_txq(vsi, i) { 2786efc2214bSMaciej Fijalkowski clear_bit(vsi->txq_map[i + vsi->alloc_txq], pf->avail_txqs); 2787efc2214bSMaciej Fijalkowski vsi->txq_map[i + vsi->alloc_txq] = ICE_INVAL_Q_INDEX; 2788efc2214bSMaciej Fijalkowski } 2789efc2214bSMaciej Fijalkowski mutex_unlock(&pf->avail_q_mutex); 2790efc2214bSMaciej Fijalkowski 27912faf63b6SMaciej Fijalkowski ice_for_each_xdp_txq(vsi, i) 2792efc2214bSMaciej Fijalkowski if (vsi->xdp_rings[i]) { 2793f9124c68SMaciej Fijalkowski if (vsi->xdp_rings[i]->desc) { 2794f9124c68SMaciej Fijalkowski synchronize_rcu(); 2795efc2214bSMaciej Fijalkowski ice_free_tx_ring(vsi->xdp_rings[i]); 2796f9124c68SMaciej Fijalkowski } 2797efc2214bSMaciej Fijalkowski kfree_rcu(vsi->xdp_rings[i], rcu); 2798efc2214bSMaciej Fijalkowski vsi->xdp_rings[i] = NULL; 2799efc2214bSMaciej Fijalkowski } 2800efc2214bSMaciej Fijalkowski 28014015d11eSBrett Creeley devm_kfree(ice_pf_to_dev(pf), vsi->xdp_rings); 2802efc2214bSMaciej Fijalkowski vsi->xdp_rings = NULL; 2803efc2214bSMaciej Fijalkowski 280422bf877eSMaciej Fijalkowski if (static_key_enabled(&ice_xdp_locking_key)) 280522bf877eSMaciej Fijalkowski static_branch_dec(&ice_xdp_locking_key); 280622bf877eSMaciej Fijalkowski 2807efc2214bSMaciej Fijalkowski if (ice_is_reset_in_progress(pf->state) || !vsi->q_vectors[0]) 2808efc2214bSMaciej Fijalkowski return 0; 2809efc2214bSMaciej Fijalkowski 2810efc2214bSMaciej Fijalkowski ice_vsi_assign_bpf_prog(vsi, NULL); 2811efc2214bSMaciej Fijalkowski 2812efc2214bSMaciej Fijalkowski /* notify Tx scheduler that we destroyed XDP queues and bring 2813efc2214bSMaciej Fijalkowski * back the old number of child nodes 2814efc2214bSMaciej Fijalkowski */ 2815efc2214bSMaciej Fijalkowski for (i = 0; i < vsi->tc_cfg.numtc; i++) 2816efc2214bSMaciej Fijalkowski max_txqs[i] = vsi->num_txq; 2817efc2214bSMaciej Fijalkowski 2818c8f135c6SMarta Plantykow /* change number of XDP Tx queues to 0 */ 2819c8f135c6SMarta Plantykow vsi->num_xdp_txq = 0; 2820c8f135c6SMarta Plantykow 2821efc2214bSMaciej Fijalkowski return ice_cfg_vsi_lan(vsi->port_info, vsi->idx, vsi->tc_cfg.ena_tc, 2822efc2214bSMaciej Fijalkowski max_txqs); 2823efc2214bSMaciej Fijalkowski } 2824efc2214bSMaciej Fijalkowski 2825efc2214bSMaciej Fijalkowski /** 2826c7a21904SMichal Swiatkowski * ice_vsi_rx_napi_schedule - Schedule napi on RX queues from VSI 2827c7a21904SMichal Swiatkowski * @vsi: VSI to schedule napi on 2828c7a21904SMichal Swiatkowski */ 2829c7a21904SMichal Swiatkowski static void ice_vsi_rx_napi_schedule(struct ice_vsi *vsi) 2830c7a21904SMichal Swiatkowski { 2831c7a21904SMichal Swiatkowski int i; 2832c7a21904SMichal Swiatkowski 2833c7a21904SMichal Swiatkowski ice_for_each_rxq(vsi, i) { 2834e72bba21SMaciej Fijalkowski struct ice_rx_ring *rx_ring = vsi->rx_rings[i]; 2835c7a21904SMichal Swiatkowski 2836c7a21904SMichal Swiatkowski if (rx_ring->xsk_pool) 2837c7a21904SMichal Swiatkowski napi_schedule(&rx_ring->q_vector->napi); 2838c7a21904SMichal Swiatkowski } 2839c7a21904SMichal Swiatkowski } 2840c7a21904SMichal Swiatkowski 2841c7a21904SMichal Swiatkowski /** 284222bf877eSMaciej Fijalkowski * ice_vsi_determine_xdp_res - figure out how many Tx qs can XDP have 284322bf877eSMaciej Fijalkowski * @vsi: VSI to determine the count of XDP Tx qs 284422bf877eSMaciej Fijalkowski * 284522bf877eSMaciej Fijalkowski * returns 0 if Tx qs count is higher than at least half of CPU count, 284622bf877eSMaciej Fijalkowski * -ENOMEM otherwise 284722bf877eSMaciej Fijalkowski */ 284822bf877eSMaciej Fijalkowski int ice_vsi_determine_xdp_res(struct ice_vsi *vsi) 284922bf877eSMaciej Fijalkowski { 285022bf877eSMaciej Fijalkowski u16 avail = ice_get_avail_txq_count(vsi->back); 285122bf877eSMaciej Fijalkowski u16 cpus = num_possible_cpus(); 285222bf877eSMaciej Fijalkowski 285322bf877eSMaciej Fijalkowski if (avail < cpus / 2) 285422bf877eSMaciej Fijalkowski return -ENOMEM; 285522bf877eSMaciej Fijalkowski 285622bf877eSMaciej Fijalkowski vsi->num_xdp_txq = min_t(u16, avail, cpus); 285722bf877eSMaciej Fijalkowski 285822bf877eSMaciej Fijalkowski if (vsi->num_xdp_txq < cpus) 285922bf877eSMaciej Fijalkowski static_branch_inc(&ice_xdp_locking_key); 286022bf877eSMaciej Fijalkowski 286122bf877eSMaciej Fijalkowski return 0; 286222bf877eSMaciej Fijalkowski } 286322bf877eSMaciej Fijalkowski 286422bf877eSMaciej Fijalkowski /** 2865efc2214bSMaciej Fijalkowski * ice_xdp_setup_prog - Add or remove XDP eBPF program 2866efc2214bSMaciej Fijalkowski * @vsi: VSI to setup XDP for 2867efc2214bSMaciej Fijalkowski * @prog: XDP program 2868efc2214bSMaciej Fijalkowski * @extack: netlink extended ack 2869efc2214bSMaciej Fijalkowski */ 2870efc2214bSMaciej Fijalkowski static int 2871efc2214bSMaciej Fijalkowski ice_xdp_setup_prog(struct ice_vsi *vsi, struct bpf_prog *prog, 2872efc2214bSMaciej Fijalkowski struct netlink_ext_ack *extack) 2873efc2214bSMaciej Fijalkowski { 2874efc2214bSMaciej Fijalkowski int frame_size = vsi->netdev->mtu + ICE_ETH_PKT_HDR_PAD; 2875efc2214bSMaciej Fijalkowski bool if_running = netif_running(vsi->netdev); 2876efc2214bSMaciej Fijalkowski int ret = 0, xdp_ring_err = 0; 2877efc2214bSMaciej Fijalkowski 2878efc2214bSMaciej Fijalkowski if (frame_size > vsi->rx_buf_len) { 2879efc2214bSMaciej Fijalkowski NL_SET_ERR_MSG_MOD(extack, "MTU too large for loading XDP"); 2880efc2214bSMaciej Fijalkowski return -EOPNOTSUPP; 2881efc2214bSMaciej Fijalkowski } 2882efc2214bSMaciej Fijalkowski 2883efc2214bSMaciej Fijalkowski /* need to stop netdev while setting up the program for Rx rings */ 2884e97fb1aeSAnirudh Venkataramanan if (if_running && !test_and_set_bit(ICE_VSI_DOWN, vsi->state)) { 2885efc2214bSMaciej Fijalkowski ret = ice_down(vsi); 2886efc2214bSMaciej Fijalkowski if (ret) { 2887af23635aSJesse Brandeburg NL_SET_ERR_MSG_MOD(extack, "Preparing device for XDP attach failed"); 2888efc2214bSMaciej Fijalkowski return ret; 2889efc2214bSMaciej Fijalkowski } 2890efc2214bSMaciej Fijalkowski } 2891efc2214bSMaciej Fijalkowski 2892efc2214bSMaciej Fijalkowski if (!ice_is_xdp_ena_vsi(vsi) && prog) { 289322bf877eSMaciej Fijalkowski xdp_ring_err = ice_vsi_determine_xdp_res(vsi); 289422bf877eSMaciej Fijalkowski if (xdp_ring_err) { 289522bf877eSMaciej Fijalkowski NL_SET_ERR_MSG_MOD(extack, "Not enough Tx resources for XDP"); 289622bf877eSMaciej Fijalkowski } else { 2897efc2214bSMaciej Fijalkowski xdp_ring_err = ice_prepare_xdp_rings(vsi, prog); 2898efc2214bSMaciej Fijalkowski if (xdp_ring_err) 2899af23635aSJesse Brandeburg NL_SET_ERR_MSG_MOD(extack, "Setting up XDP Tx resources failed"); 290022bf877eSMaciej Fijalkowski } 2901efc2214bSMaciej Fijalkowski } else if (ice_is_xdp_ena_vsi(vsi) && !prog) { 2902efc2214bSMaciej Fijalkowski xdp_ring_err = ice_destroy_xdp_rings(vsi); 2903efc2214bSMaciej Fijalkowski if (xdp_ring_err) 2904af23635aSJesse Brandeburg NL_SET_ERR_MSG_MOD(extack, "Freeing XDP Tx resources failed"); 2905efc2214bSMaciej Fijalkowski } else { 2906f65ee535SMarta Plantykow /* safe to call even when prog == vsi->xdp_prog as 2907f65ee535SMarta Plantykow * dev_xdp_install in net/core/dev.c incremented prog's 2908f65ee535SMarta Plantykow * refcount so corresponding bpf_prog_put won't cause 2909f65ee535SMarta Plantykow * underflow 2910f65ee535SMarta Plantykow */ 2911efc2214bSMaciej Fijalkowski ice_vsi_assign_bpf_prog(vsi, prog); 2912efc2214bSMaciej Fijalkowski } 2913efc2214bSMaciej Fijalkowski 2914efc2214bSMaciej Fijalkowski if (if_running) 2915efc2214bSMaciej Fijalkowski ret = ice_up(vsi); 2916efc2214bSMaciej Fijalkowski 2917c7a21904SMichal Swiatkowski if (!ret && prog) 2918c7a21904SMichal Swiatkowski ice_vsi_rx_napi_schedule(vsi); 29192d4238f5SKrzysztof Kazimierczak 2920efc2214bSMaciej Fijalkowski return (ret || xdp_ring_err) ? -ENOMEM : 0; 2921efc2214bSMaciej Fijalkowski } 2922efc2214bSMaciej Fijalkowski 2923efc2214bSMaciej Fijalkowski /** 2924ebc5399eSMaciej Fijalkowski * ice_xdp_safe_mode - XDP handler for safe mode 2925ebc5399eSMaciej Fijalkowski * @dev: netdevice 2926ebc5399eSMaciej Fijalkowski * @xdp: XDP command 2927ebc5399eSMaciej Fijalkowski */ 2928ebc5399eSMaciej Fijalkowski static int ice_xdp_safe_mode(struct net_device __always_unused *dev, 2929ebc5399eSMaciej Fijalkowski struct netdev_bpf *xdp) 2930ebc5399eSMaciej Fijalkowski { 2931ebc5399eSMaciej Fijalkowski NL_SET_ERR_MSG_MOD(xdp->extack, 2932ebc5399eSMaciej Fijalkowski "Please provide working DDP firmware package in order to use XDP\n" 2933ebc5399eSMaciej Fijalkowski "Refer to Documentation/networking/device_drivers/ethernet/intel/ice.rst"); 2934ebc5399eSMaciej Fijalkowski return -EOPNOTSUPP; 2935ebc5399eSMaciej Fijalkowski } 2936ebc5399eSMaciej Fijalkowski 2937ebc5399eSMaciej Fijalkowski /** 2938efc2214bSMaciej Fijalkowski * ice_xdp - implements XDP handler 2939efc2214bSMaciej Fijalkowski * @dev: netdevice 2940efc2214bSMaciej Fijalkowski * @xdp: XDP command 2941efc2214bSMaciej Fijalkowski */ 2942efc2214bSMaciej Fijalkowski static int ice_xdp(struct net_device *dev, struct netdev_bpf *xdp) 2943efc2214bSMaciej Fijalkowski { 2944efc2214bSMaciej Fijalkowski struct ice_netdev_priv *np = netdev_priv(dev); 2945efc2214bSMaciej Fijalkowski struct ice_vsi *vsi = np->vsi; 2946efc2214bSMaciej Fijalkowski 2947efc2214bSMaciej Fijalkowski if (vsi->type != ICE_VSI_PF) { 2948af23635aSJesse Brandeburg NL_SET_ERR_MSG_MOD(xdp->extack, "XDP can be loaded only on PF VSI"); 2949efc2214bSMaciej Fijalkowski return -EINVAL; 2950efc2214bSMaciej Fijalkowski } 2951efc2214bSMaciej Fijalkowski 2952efc2214bSMaciej Fijalkowski switch (xdp->command) { 2953efc2214bSMaciej Fijalkowski case XDP_SETUP_PROG: 2954efc2214bSMaciej Fijalkowski return ice_xdp_setup_prog(vsi, xdp->prog, xdp->extack); 29551742b3d5SMagnus Karlsson case XDP_SETUP_XSK_POOL: 29561742b3d5SMagnus Karlsson return ice_xsk_pool_setup(vsi, xdp->xsk.pool, 29572d4238f5SKrzysztof Kazimierczak xdp->xsk.queue_id); 2958efc2214bSMaciej Fijalkowski default: 2959efc2214bSMaciej Fijalkowski return -EINVAL; 2960efc2214bSMaciej Fijalkowski } 2961efc2214bSMaciej Fijalkowski } 2962efc2214bSMaciej Fijalkowski 2963efc2214bSMaciej Fijalkowski /** 2964940b61afSAnirudh Venkataramanan * ice_ena_misc_vector - enable the non-queue interrupts 2965940b61afSAnirudh Venkataramanan * @pf: board private structure 2966940b61afSAnirudh Venkataramanan */ 2967940b61afSAnirudh Venkataramanan static void ice_ena_misc_vector(struct ice_pf *pf) 2968940b61afSAnirudh Venkataramanan { 2969940b61afSAnirudh Venkataramanan struct ice_hw *hw = &pf->hw; 2970940b61afSAnirudh Venkataramanan u32 val; 2971940b61afSAnirudh Venkataramanan 29729d5c5a52SPaul Greenwalt /* Disable anti-spoof detection interrupt to prevent spurious event 29739d5c5a52SPaul Greenwalt * interrupts during a function reset. Anti-spoof functionally is 29749d5c5a52SPaul Greenwalt * still supported. 29759d5c5a52SPaul Greenwalt */ 29769d5c5a52SPaul Greenwalt val = rd32(hw, GL_MDCK_TX_TDPU); 29779d5c5a52SPaul Greenwalt val |= GL_MDCK_TX_TDPU_RCU_ANTISPOOF_ITR_DIS_M; 29789d5c5a52SPaul Greenwalt wr32(hw, GL_MDCK_TX_TDPU, val); 29799d5c5a52SPaul Greenwalt 2980940b61afSAnirudh Venkataramanan /* clear things first */ 2981940b61afSAnirudh Venkataramanan wr32(hw, PFINT_OICR_ENA, 0); /* disable all */ 2982940b61afSAnirudh Venkataramanan rd32(hw, PFINT_OICR); /* read to clear */ 2983940b61afSAnirudh Venkataramanan 29843bcd7fa3SBruce Allan val = (PFINT_OICR_ECC_ERR_M | 2985940b61afSAnirudh Venkataramanan PFINT_OICR_MAL_DETECT_M | 2986940b61afSAnirudh Venkataramanan PFINT_OICR_GRST_M | 2987940b61afSAnirudh Venkataramanan PFINT_OICR_PCI_EXCEPTION_M | 2988007676b4SAnirudh Venkataramanan PFINT_OICR_VFLR_M | 29893bcd7fa3SBruce Allan PFINT_OICR_HMC_ERR_M | 2990348048e7SDave Ertman PFINT_OICR_PE_PUSH_M | 29913bcd7fa3SBruce Allan PFINT_OICR_PE_CRITERR_M); 2992940b61afSAnirudh Venkataramanan 2993940b61afSAnirudh Venkataramanan wr32(hw, PFINT_OICR_ENA, val); 2994940b61afSAnirudh Venkataramanan 2995940b61afSAnirudh Venkataramanan /* SW_ITR_IDX = 0, but don't change INTENA */ 2996cbe66bfeSBrett Creeley wr32(hw, GLINT_DYN_CTL(pf->oicr_idx), 2997940b61afSAnirudh Venkataramanan GLINT_DYN_CTL_SW_ITR_INDX_M | GLINT_DYN_CTL_INTENA_MSK_M); 2998940b61afSAnirudh Venkataramanan } 2999940b61afSAnirudh Venkataramanan 3000940b61afSAnirudh Venkataramanan /** 3001940b61afSAnirudh Venkataramanan * ice_misc_intr - misc interrupt handler 3002940b61afSAnirudh Venkataramanan * @irq: interrupt number 3003940b61afSAnirudh Venkataramanan * @data: pointer to a q_vector 3004940b61afSAnirudh Venkataramanan */ 3005940b61afSAnirudh Venkataramanan static irqreturn_t ice_misc_intr(int __always_unused irq, void *data) 3006940b61afSAnirudh Venkataramanan { 3007940b61afSAnirudh Venkataramanan struct ice_pf *pf = (struct ice_pf *)data; 3008940b61afSAnirudh Venkataramanan struct ice_hw *hw = &pf->hw; 3009940b61afSAnirudh Venkataramanan irqreturn_t ret = IRQ_NONE; 30104015d11eSBrett Creeley struct device *dev; 3011940b61afSAnirudh Venkataramanan u32 oicr, ena_mask; 3012940b61afSAnirudh Venkataramanan 30134015d11eSBrett Creeley dev = ice_pf_to_dev(pf); 30147e408e07SAnirudh Venkataramanan set_bit(ICE_ADMINQ_EVENT_PENDING, pf->state); 30157e408e07SAnirudh Venkataramanan set_bit(ICE_MAILBOXQ_EVENT_PENDING, pf->state); 30168f5ee3c4SJacob Keller set_bit(ICE_SIDEBANDQ_EVENT_PENDING, pf->state); 3017940b61afSAnirudh Venkataramanan 3018940b61afSAnirudh Venkataramanan oicr = rd32(hw, PFINT_OICR); 3019940b61afSAnirudh Venkataramanan ena_mask = rd32(hw, PFINT_OICR_ENA); 3020940b61afSAnirudh Venkataramanan 30210e674aebSAnirudh Venkataramanan if (oicr & PFINT_OICR_SWINT_M) { 30220e674aebSAnirudh Venkataramanan ena_mask &= ~PFINT_OICR_SWINT_M; 30230e674aebSAnirudh Venkataramanan pf->sw_int_count++; 30240e674aebSAnirudh Venkataramanan } 30250e674aebSAnirudh Venkataramanan 3026b3969fd7SSudheer Mogilappagari if (oicr & PFINT_OICR_MAL_DETECT_M) { 3027b3969fd7SSudheer Mogilappagari ena_mask &= ~PFINT_OICR_MAL_DETECT_M; 30287e408e07SAnirudh Venkataramanan set_bit(ICE_MDD_EVENT_PENDING, pf->state); 3029b3969fd7SSudheer Mogilappagari } 3030007676b4SAnirudh Venkataramanan if (oicr & PFINT_OICR_VFLR_M) { 3031f844d521SBrett Creeley /* disable any further VFLR event notifications */ 30327e408e07SAnirudh Venkataramanan if (test_bit(ICE_VF_RESETS_DISABLED, pf->state)) { 3033f844d521SBrett Creeley u32 reg = rd32(hw, PFINT_OICR_ENA); 3034f844d521SBrett Creeley 3035f844d521SBrett Creeley reg &= ~PFINT_OICR_VFLR_M; 3036f844d521SBrett Creeley wr32(hw, PFINT_OICR_ENA, reg); 3037f844d521SBrett Creeley } else { 3038007676b4SAnirudh Venkataramanan ena_mask &= ~PFINT_OICR_VFLR_M; 30397e408e07SAnirudh Venkataramanan set_bit(ICE_VFLR_EVENT_PENDING, pf->state); 3040007676b4SAnirudh Venkataramanan } 3041f844d521SBrett Creeley } 3042b3969fd7SSudheer Mogilappagari 30430b28b702SAnirudh Venkataramanan if (oicr & PFINT_OICR_GRST_M) { 30440b28b702SAnirudh Venkataramanan u32 reset; 3045b3969fd7SSudheer Mogilappagari 30460b28b702SAnirudh Venkataramanan /* we have a reset warning */ 30470b28b702SAnirudh Venkataramanan ena_mask &= ~PFINT_OICR_GRST_M; 30480b28b702SAnirudh Venkataramanan reset = (rd32(hw, GLGEN_RSTAT) & GLGEN_RSTAT_RESET_TYPE_M) >> 30490b28b702SAnirudh Venkataramanan GLGEN_RSTAT_RESET_TYPE_S; 30500b28b702SAnirudh Venkataramanan 30510b28b702SAnirudh Venkataramanan if (reset == ICE_RESET_CORER) 30520b28b702SAnirudh Venkataramanan pf->corer_count++; 30530b28b702SAnirudh Venkataramanan else if (reset == ICE_RESET_GLOBR) 30540b28b702SAnirudh Venkataramanan pf->globr_count++; 3055ca4929b6SBrett Creeley else if (reset == ICE_RESET_EMPR) 30560b28b702SAnirudh Venkataramanan pf->empr_count++; 3057ca4929b6SBrett Creeley else 30584015d11eSBrett Creeley dev_dbg(dev, "Invalid reset type %d\n", reset); 30590b28b702SAnirudh Venkataramanan 30600b28b702SAnirudh Venkataramanan /* If a reset cycle isn't already in progress, we set a bit in 30610b28b702SAnirudh Venkataramanan * pf->state so that the service task can start a reset/rebuild. 30620b28b702SAnirudh Venkataramanan */ 30637e408e07SAnirudh Venkataramanan if (!test_and_set_bit(ICE_RESET_OICR_RECV, pf->state)) { 30640b28b702SAnirudh Venkataramanan if (reset == ICE_RESET_CORER) 30657e408e07SAnirudh Venkataramanan set_bit(ICE_CORER_RECV, pf->state); 30660b28b702SAnirudh Venkataramanan else if (reset == ICE_RESET_GLOBR) 30677e408e07SAnirudh Venkataramanan set_bit(ICE_GLOBR_RECV, pf->state); 30680b28b702SAnirudh Venkataramanan else 30697e408e07SAnirudh Venkataramanan set_bit(ICE_EMPR_RECV, pf->state); 30700b28b702SAnirudh Venkataramanan 3071fd2a9817SAnirudh Venkataramanan /* There are couple of different bits at play here. 3072fd2a9817SAnirudh Venkataramanan * hw->reset_ongoing indicates whether the hardware is 3073fd2a9817SAnirudh Venkataramanan * in reset. This is set to true when a reset interrupt 3074fd2a9817SAnirudh Venkataramanan * is received and set back to false after the driver 3075fd2a9817SAnirudh Venkataramanan * has determined that the hardware is out of reset. 3076fd2a9817SAnirudh Venkataramanan * 30777e408e07SAnirudh Venkataramanan * ICE_RESET_OICR_RECV in pf->state indicates 3078fd2a9817SAnirudh Venkataramanan * that a post reset rebuild is required before the 3079fd2a9817SAnirudh Venkataramanan * driver is operational again. This is set above. 3080fd2a9817SAnirudh Venkataramanan * 3081fd2a9817SAnirudh Venkataramanan * As this is the start of the reset/rebuild cycle, set 3082fd2a9817SAnirudh Venkataramanan * both to indicate that. 3083fd2a9817SAnirudh Venkataramanan */ 3084fd2a9817SAnirudh Venkataramanan hw->reset_ongoing = true; 30850b28b702SAnirudh Venkataramanan } 30860b28b702SAnirudh Venkataramanan } 30870b28b702SAnirudh Venkataramanan 3088ea9b847cSJacob Keller if (oicr & PFINT_OICR_TSYN_TX_M) { 3089ea9b847cSJacob Keller ena_mask &= ~PFINT_OICR_TSYN_TX_M; 3090ea9b847cSJacob Keller ice_ptp_process_ts(pf); 3091ea9b847cSJacob Keller } 3092ea9b847cSJacob Keller 3093172db5f9SMaciej Machnikowski if (oicr & PFINT_OICR_TSYN_EVNT_M) { 3094172db5f9SMaciej Machnikowski u8 tmr_idx = hw->func_caps.ts_func_info.tmr_index_owned; 3095172db5f9SMaciej Machnikowski u32 gltsyn_stat = rd32(hw, GLTSYN_STAT(tmr_idx)); 3096172db5f9SMaciej Machnikowski 3097172db5f9SMaciej Machnikowski /* Save EVENTs from GTSYN register */ 3098172db5f9SMaciej Machnikowski pf->ptp.ext_ts_irq |= gltsyn_stat & (GLTSYN_STAT_EVENT0_M | 3099172db5f9SMaciej Machnikowski GLTSYN_STAT_EVENT1_M | 3100172db5f9SMaciej Machnikowski GLTSYN_STAT_EVENT2_M); 3101172db5f9SMaciej Machnikowski ena_mask &= ~PFINT_OICR_TSYN_EVNT_M; 3102172db5f9SMaciej Machnikowski kthread_queue_work(pf->ptp.kworker, &pf->ptp.extts_work); 3103172db5f9SMaciej Machnikowski } 3104172db5f9SMaciej Machnikowski 3105348048e7SDave Ertman #define ICE_AUX_CRIT_ERR (PFINT_OICR_PE_CRITERR_M | PFINT_OICR_HMC_ERR_M | PFINT_OICR_PE_PUSH_M) 3106348048e7SDave Ertman if (oicr & ICE_AUX_CRIT_ERR) { 310732d53c0aSAlexander Lobakin pf->oicr_err_reg |= oicr; 310832d53c0aSAlexander Lobakin set_bit(ICE_AUX_ERR_PENDING, pf->state); 3109348048e7SDave Ertman ena_mask &= ~ICE_AUX_CRIT_ERR; 3110940b61afSAnirudh Venkataramanan } 3111940b61afSAnirudh Venkataramanan 31128d7189d2SMd Fahad Iqbal Polash /* Report any remaining unexpected interrupts */ 3113940b61afSAnirudh Venkataramanan oicr &= ena_mask; 3114940b61afSAnirudh Venkataramanan if (oicr) { 31154015d11eSBrett Creeley dev_dbg(dev, "unhandled interrupt oicr=0x%08x\n", oicr); 3116940b61afSAnirudh Venkataramanan /* If a critical error is pending there is no choice but to 3117940b61afSAnirudh Venkataramanan * reset the device. 3118940b61afSAnirudh Venkataramanan */ 3119348048e7SDave Ertman if (oicr & (PFINT_OICR_PCI_EXCEPTION_M | 31200b28b702SAnirudh Venkataramanan PFINT_OICR_ECC_ERR_M)) { 31217e408e07SAnirudh Venkataramanan set_bit(ICE_PFR_REQ, pf->state); 31220b28b702SAnirudh Venkataramanan ice_service_task_schedule(pf); 31230b28b702SAnirudh Venkataramanan } 3124940b61afSAnirudh Venkataramanan } 3125940b61afSAnirudh Venkataramanan ret = IRQ_HANDLED; 3126940b61afSAnirudh Venkataramanan 3127940b61afSAnirudh Venkataramanan ice_service_task_schedule(pf); 3128cdedef59SAnirudh Venkataramanan ice_irq_dynamic_ena(hw, NULL, NULL); 3129940b61afSAnirudh Venkataramanan 3130940b61afSAnirudh Venkataramanan return ret; 3131940b61afSAnirudh Venkataramanan } 3132940b61afSAnirudh Venkataramanan 3133940b61afSAnirudh Venkataramanan /** 31340e04e8e1SBrett Creeley * ice_dis_ctrlq_interrupts - disable control queue interrupts 31350e04e8e1SBrett Creeley * @hw: pointer to HW structure 31360e04e8e1SBrett Creeley */ 31370e04e8e1SBrett Creeley static void ice_dis_ctrlq_interrupts(struct ice_hw *hw) 31380e04e8e1SBrett Creeley { 31390e04e8e1SBrett Creeley /* disable Admin queue Interrupt causes */ 31400e04e8e1SBrett Creeley wr32(hw, PFINT_FW_CTL, 31410e04e8e1SBrett Creeley rd32(hw, PFINT_FW_CTL) & ~PFINT_FW_CTL_CAUSE_ENA_M); 31420e04e8e1SBrett Creeley 31430e04e8e1SBrett Creeley /* disable Mailbox queue Interrupt causes */ 31440e04e8e1SBrett Creeley wr32(hw, PFINT_MBX_CTL, 31450e04e8e1SBrett Creeley rd32(hw, PFINT_MBX_CTL) & ~PFINT_MBX_CTL_CAUSE_ENA_M); 31460e04e8e1SBrett Creeley 31478f5ee3c4SJacob Keller wr32(hw, PFINT_SB_CTL, 31488f5ee3c4SJacob Keller rd32(hw, PFINT_SB_CTL) & ~PFINT_SB_CTL_CAUSE_ENA_M); 31498f5ee3c4SJacob Keller 31500e04e8e1SBrett Creeley /* disable Control queue Interrupt causes */ 31510e04e8e1SBrett Creeley wr32(hw, PFINT_OICR_CTL, 31520e04e8e1SBrett Creeley rd32(hw, PFINT_OICR_CTL) & ~PFINT_OICR_CTL_CAUSE_ENA_M); 31530e04e8e1SBrett Creeley 31540e04e8e1SBrett Creeley ice_flush(hw); 31550e04e8e1SBrett Creeley } 31560e04e8e1SBrett Creeley 31570e04e8e1SBrett Creeley /** 3158940b61afSAnirudh Venkataramanan * ice_free_irq_msix_misc - Unroll misc vector setup 3159940b61afSAnirudh Venkataramanan * @pf: board private structure 3160940b61afSAnirudh Venkataramanan */ 3161940b61afSAnirudh Venkataramanan static void ice_free_irq_msix_misc(struct ice_pf *pf) 3162940b61afSAnirudh Venkataramanan { 31630e04e8e1SBrett Creeley struct ice_hw *hw = &pf->hw; 31640e04e8e1SBrett Creeley 31650e04e8e1SBrett Creeley ice_dis_ctrlq_interrupts(hw); 31660e04e8e1SBrett Creeley 3167940b61afSAnirudh Venkataramanan /* disable OICR interrupt */ 31680e04e8e1SBrett Creeley wr32(hw, PFINT_OICR_ENA, 0); 31690e04e8e1SBrett Creeley ice_flush(hw); 3170940b61afSAnirudh Venkataramanan 3171ba880734SBrett Creeley if (pf->msix_entries) { 3172cbe66bfeSBrett Creeley synchronize_irq(pf->msix_entries[pf->oicr_idx].vector); 31734015d11eSBrett Creeley devm_free_irq(ice_pf_to_dev(pf), 3174cbe66bfeSBrett Creeley pf->msix_entries[pf->oicr_idx].vector, pf); 3175940b61afSAnirudh Venkataramanan } 3176940b61afSAnirudh Venkataramanan 3177eb0208ecSPreethi Banala pf->num_avail_sw_msix += 1; 3178cbe66bfeSBrett Creeley ice_free_res(pf->irq_tracker, pf->oicr_idx, ICE_RES_MISC_VEC_ID); 3179940b61afSAnirudh Venkataramanan } 3180940b61afSAnirudh Venkataramanan 3181940b61afSAnirudh Venkataramanan /** 31820e04e8e1SBrett Creeley * ice_ena_ctrlq_interrupts - enable control queue interrupts 31830e04e8e1SBrett Creeley * @hw: pointer to HW structure 3184b07833a0SBrett Creeley * @reg_idx: HW vector index to associate the control queue interrupts with 31850e04e8e1SBrett Creeley */ 3186b07833a0SBrett Creeley static void ice_ena_ctrlq_interrupts(struct ice_hw *hw, u16 reg_idx) 31870e04e8e1SBrett Creeley { 31880e04e8e1SBrett Creeley u32 val; 31890e04e8e1SBrett Creeley 3190b07833a0SBrett Creeley val = ((reg_idx & PFINT_OICR_CTL_MSIX_INDX_M) | 31910e04e8e1SBrett Creeley PFINT_OICR_CTL_CAUSE_ENA_M); 31920e04e8e1SBrett Creeley wr32(hw, PFINT_OICR_CTL, val); 31930e04e8e1SBrett Creeley 31940e04e8e1SBrett Creeley /* enable Admin queue Interrupt causes */ 3195b07833a0SBrett Creeley val = ((reg_idx & PFINT_FW_CTL_MSIX_INDX_M) | 31960e04e8e1SBrett Creeley PFINT_FW_CTL_CAUSE_ENA_M); 31970e04e8e1SBrett Creeley wr32(hw, PFINT_FW_CTL, val); 31980e04e8e1SBrett Creeley 31990e04e8e1SBrett Creeley /* enable Mailbox queue Interrupt causes */ 3200b07833a0SBrett Creeley val = ((reg_idx & PFINT_MBX_CTL_MSIX_INDX_M) | 32010e04e8e1SBrett Creeley PFINT_MBX_CTL_CAUSE_ENA_M); 32020e04e8e1SBrett Creeley wr32(hw, PFINT_MBX_CTL, val); 32030e04e8e1SBrett Creeley 32048f5ee3c4SJacob Keller /* This enables Sideband queue Interrupt causes */ 32058f5ee3c4SJacob Keller val = ((reg_idx & PFINT_SB_CTL_MSIX_INDX_M) | 32068f5ee3c4SJacob Keller PFINT_SB_CTL_CAUSE_ENA_M); 32078f5ee3c4SJacob Keller wr32(hw, PFINT_SB_CTL, val); 32088f5ee3c4SJacob Keller 32090e04e8e1SBrett Creeley ice_flush(hw); 32100e04e8e1SBrett Creeley } 32110e04e8e1SBrett Creeley 32120e04e8e1SBrett Creeley /** 3213940b61afSAnirudh Venkataramanan * ice_req_irq_msix_misc - Setup the misc vector to handle non queue events 3214940b61afSAnirudh Venkataramanan * @pf: board private structure 3215940b61afSAnirudh Venkataramanan * 3216940b61afSAnirudh Venkataramanan * This sets up the handler for MSIX 0, which is used to manage the 3217940b61afSAnirudh Venkataramanan * non-queue interrupts, e.g. AdminQ and errors. This is not used 3218940b61afSAnirudh Venkataramanan * when in MSI or Legacy interrupt mode. 3219940b61afSAnirudh Venkataramanan */ 3220940b61afSAnirudh Venkataramanan static int ice_req_irq_msix_misc(struct ice_pf *pf) 3221940b61afSAnirudh Venkataramanan { 32224015d11eSBrett Creeley struct device *dev = ice_pf_to_dev(pf); 3223940b61afSAnirudh Venkataramanan struct ice_hw *hw = &pf->hw; 3224940b61afSAnirudh Venkataramanan int oicr_idx, err = 0; 3225940b61afSAnirudh Venkataramanan 3226940b61afSAnirudh Venkataramanan if (!pf->int_name[0]) 3227940b61afSAnirudh Venkataramanan snprintf(pf->int_name, sizeof(pf->int_name) - 1, "%s-%s:misc", 32284015d11eSBrett Creeley dev_driver_string(dev), dev_name(dev)); 3229940b61afSAnirudh Venkataramanan 32300b28b702SAnirudh Venkataramanan /* Do not request IRQ but do enable OICR interrupt since settings are 32310b28b702SAnirudh Venkataramanan * lost during reset. Note that this function is called only during 32320b28b702SAnirudh Venkataramanan * rebuild path and not while reset is in progress. 32330b28b702SAnirudh Venkataramanan */ 32345df7e45dSDave Ertman if (ice_is_reset_in_progress(pf->state)) 32350b28b702SAnirudh Venkataramanan goto skip_req_irq; 32360b28b702SAnirudh Venkataramanan 3237cbe66bfeSBrett Creeley /* reserve one vector in irq_tracker for misc interrupts */ 3238cbe66bfeSBrett Creeley oicr_idx = ice_get_res(pf, pf->irq_tracker, 1, ICE_RES_MISC_VEC_ID); 3239940b61afSAnirudh Venkataramanan if (oicr_idx < 0) 3240940b61afSAnirudh Venkataramanan return oicr_idx; 3241940b61afSAnirudh Venkataramanan 3242eb0208ecSPreethi Banala pf->num_avail_sw_msix -= 1; 324388865fc4SKarol Kolacinski pf->oicr_idx = (u16)oicr_idx; 3244940b61afSAnirudh Venkataramanan 32454015d11eSBrett Creeley err = devm_request_irq(dev, pf->msix_entries[pf->oicr_idx].vector, 3246940b61afSAnirudh Venkataramanan ice_misc_intr, 0, pf->int_name, pf); 3247940b61afSAnirudh Venkataramanan if (err) { 32484015d11eSBrett Creeley dev_err(dev, "devm_request_irq for %s failed: %d\n", 3249940b61afSAnirudh Venkataramanan pf->int_name, err); 3250cbe66bfeSBrett Creeley ice_free_res(pf->irq_tracker, 1, ICE_RES_MISC_VEC_ID); 3251eb0208ecSPreethi Banala pf->num_avail_sw_msix += 1; 3252940b61afSAnirudh Venkataramanan return err; 3253940b61afSAnirudh Venkataramanan } 3254940b61afSAnirudh Venkataramanan 32550b28b702SAnirudh Venkataramanan skip_req_irq: 3256940b61afSAnirudh Venkataramanan ice_ena_misc_vector(pf); 3257940b61afSAnirudh Venkataramanan 3258cbe66bfeSBrett Creeley ice_ena_ctrlq_interrupts(hw, pf->oicr_idx); 3259cbe66bfeSBrett Creeley wr32(hw, GLINT_ITR(ICE_RX_ITR, pf->oicr_idx), 326063f545edSBrett Creeley ITR_REG_ALIGN(ICE_ITR_8K) >> ICE_ITR_GRAN_S); 3261940b61afSAnirudh Venkataramanan 3262940b61afSAnirudh Venkataramanan ice_flush(hw); 3263cdedef59SAnirudh Venkataramanan ice_irq_dynamic_ena(hw, NULL, NULL); 3264940b61afSAnirudh Venkataramanan 3265940b61afSAnirudh Venkataramanan return 0; 3266940b61afSAnirudh Venkataramanan } 3267940b61afSAnirudh Venkataramanan 3268940b61afSAnirudh Venkataramanan /** 3269df0f8479SAnirudh Venkataramanan * ice_napi_add - register NAPI handler for the VSI 3270df0f8479SAnirudh Venkataramanan * @vsi: VSI for which NAPI handler is to be registered 3271df0f8479SAnirudh Venkataramanan * 3272df0f8479SAnirudh Venkataramanan * This function is only called in the driver's load path. Registering the NAPI 3273df0f8479SAnirudh Venkataramanan * handler is done in ice_vsi_alloc_q_vector() for all other cases (i.e. resume, 3274df0f8479SAnirudh Venkataramanan * reset/rebuild, etc.) 3275df0f8479SAnirudh Venkataramanan */ 3276df0f8479SAnirudh Venkataramanan static void ice_napi_add(struct ice_vsi *vsi) 3277df0f8479SAnirudh Venkataramanan { 3278df0f8479SAnirudh Venkataramanan int v_idx; 3279df0f8479SAnirudh Venkataramanan 3280df0f8479SAnirudh Venkataramanan if (!vsi->netdev) 3281df0f8479SAnirudh Venkataramanan return; 3282df0f8479SAnirudh Venkataramanan 32830c2561c8SBrett Creeley ice_for_each_q_vector(vsi, v_idx) 3284df0f8479SAnirudh Venkataramanan netif_napi_add(vsi->netdev, &vsi->q_vectors[v_idx]->napi, 3285df0f8479SAnirudh Venkataramanan ice_napi_poll, NAPI_POLL_WEIGHT); 3286df0f8479SAnirudh Venkataramanan } 3287df0f8479SAnirudh Venkataramanan 3288df0f8479SAnirudh Venkataramanan /** 3289462acf6aSTony Nguyen * ice_set_ops - set netdev and ethtools ops for the given netdev 3290462acf6aSTony Nguyen * @netdev: netdev instance 32913a858ba3SAnirudh Venkataramanan */ 3292462acf6aSTony Nguyen static void ice_set_ops(struct net_device *netdev) 32933a858ba3SAnirudh Venkataramanan { 3294462acf6aSTony Nguyen struct ice_pf *pf = ice_netdev_to_pf(netdev); 3295462acf6aSTony Nguyen 3296462acf6aSTony Nguyen if (ice_is_safe_mode(pf)) { 3297462acf6aSTony Nguyen netdev->netdev_ops = &ice_netdev_safe_mode_ops; 3298462acf6aSTony Nguyen ice_set_ethtool_safe_mode_ops(netdev); 3299462acf6aSTony Nguyen return; 3300462acf6aSTony Nguyen } 3301462acf6aSTony Nguyen 3302462acf6aSTony Nguyen netdev->netdev_ops = &ice_netdev_ops; 3303b20e6c17SJakub Kicinski netdev->udp_tunnel_nic_info = &pf->hw.udp_tunnel_nic; 3304462acf6aSTony Nguyen ice_set_ethtool_ops(netdev); 3305462acf6aSTony Nguyen } 3306462acf6aSTony Nguyen 3307462acf6aSTony Nguyen /** 3308462acf6aSTony Nguyen * ice_set_netdev_features - set features for the given netdev 3309462acf6aSTony Nguyen * @netdev: netdev instance 3310462acf6aSTony Nguyen */ 3311462acf6aSTony Nguyen static void ice_set_netdev_features(struct net_device *netdev) 3312462acf6aSTony Nguyen { 3313462acf6aSTony Nguyen struct ice_pf *pf = ice_netdev_to_pf(netdev); 33141babaf77SBrett Creeley bool is_dvm_ena = ice_is_dvm_ena(&pf->hw); 3315d76a60baSAnirudh Venkataramanan netdev_features_t csumo_features; 3316d76a60baSAnirudh Venkataramanan netdev_features_t vlano_features; 3317d76a60baSAnirudh Venkataramanan netdev_features_t dflt_features; 3318d76a60baSAnirudh Venkataramanan netdev_features_t tso_features; 33193a858ba3SAnirudh Venkataramanan 3320462acf6aSTony Nguyen if (ice_is_safe_mode(pf)) { 3321462acf6aSTony Nguyen /* safe mode */ 3322462acf6aSTony Nguyen netdev->features = NETIF_F_SG | NETIF_F_HIGHDMA; 3323462acf6aSTony Nguyen netdev->hw_features = netdev->features; 3324462acf6aSTony Nguyen return; 3325462acf6aSTony Nguyen } 33263a858ba3SAnirudh Venkataramanan 3327d76a60baSAnirudh Venkataramanan dflt_features = NETIF_F_SG | 33283a858ba3SAnirudh Venkataramanan NETIF_F_HIGHDMA | 3329148beb61SHenry Tieman NETIF_F_NTUPLE | 33303a858ba3SAnirudh Venkataramanan NETIF_F_RXHASH; 33313a858ba3SAnirudh Venkataramanan 3332d76a60baSAnirudh Venkataramanan csumo_features = NETIF_F_RXCSUM | 3333d76a60baSAnirudh Venkataramanan NETIF_F_IP_CSUM | 3334cf909e19SAnirudh Venkataramanan NETIF_F_SCTP_CRC | 3335d76a60baSAnirudh Venkataramanan NETIF_F_IPV6_CSUM; 3336d76a60baSAnirudh Venkataramanan 3337d76a60baSAnirudh Venkataramanan vlano_features = NETIF_F_HW_VLAN_CTAG_FILTER | 3338d76a60baSAnirudh Venkataramanan NETIF_F_HW_VLAN_CTAG_TX | 3339d76a60baSAnirudh Venkataramanan NETIF_F_HW_VLAN_CTAG_RX; 3340d76a60baSAnirudh Venkataramanan 33411babaf77SBrett Creeley /* Enable CTAG/STAG filtering by default in Double VLAN Mode (DVM) */ 33421babaf77SBrett Creeley if (is_dvm_ena) 33431babaf77SBrett Creeley vlano_features |= NETIF_F_HW_VLAN_STAG_FILTER; 33441babaf77SBrett Creeley 3345a54e3b8cSBrett Creeley tso_features = NETIF_F_TSO | 3346a4e82a81STony Nguyen NETIF_F_TSO_ECN | 3347a4e82a81STony Nguyen NETIF_F_TSO6 | 3348a4e82a81STony Nguyen NETIF_F_GSO_GRE | 3349a4e82a81STony Nguyen NETIF_F_GSO_UDP_TUNNEL | 3350a4e82a81STony Nguyen NETIF_F_GSO_GRE_CSUM | 3351a4e82a81STony Nguyen NETIF_F_GSO_UDP_TUNNEL_CSUM | 3352a4e82a81STony Nguyen NETIF_F_GSO_PARTIAL | 3353a4e82a81STony Nguyen NETIF_F_GSO_IPXIP4 | 3354a4e82a81STony Nguyen NETIF_F_GSO_IPXIP6 | 3355a54e3b8cSBrett Creeley NETIF_F_GSO_UDP_L4; 3356d76a60baSAnirudh Venkataramanan 3357a4e82a81STony Nguyen netdev->gso_partial_features |= NETIF_F_GSO_UDP_TUNNEL_CSUM | 3358a4e82a81STony Nguyen NETIF_F_GSO_GRE_CSUM; 3359d76a60baSAnirudh Venkataramanan /* set features that user can change */ 3360d76a60baSAnirudh Venkataramanan netdev->hw_features = dflt_features | csumo_features | 3361d76a60baSAnirudh Venkataramanan vlano_features | tso_features; 3362d76a60baSAnirudh Venkataramanan 3363a4e82a81STony Nguyen /* add support for HW_CSUM on packets with MPLS header */ 336469e66c04SJoe Damato netdev->mpls_features = NETIF_F_HW_CSUM | 336569e66c04SJoe Damato NETIF_F_TSO | 336669e66c04SJoe Damato NETIF_F_TSO6; 3367a4e82a81STony Nguyen 33683a858ba3SAnirudh Venkataramanan /* enable features */ 33693a858ba3SAnirudh Venkataramanan netdev->features |= netdev->hw_features; 33700d08a441SKiran Patil 33710d08a441SKiran Patil netdev->hw_features |= NETIF_F_HW_TC; 337244ece4e1SMaciej Fijalkowski netdev->hw_features |= NETIF_F_LOOPBACK; 33730d08a441SKiran Patil 3374d76a60baSAnirudh Venkataramanan /* encap and VLAN devices inherit default, csumo and tso features */ 3375d76a60baSAnirudh Venkataramanan netdev->hw_enc_features |= dflt_features | csumo_features | 3376d76a60baSAnirudh Venkataramanan tso_features; 3377d76a60baSAnirudh Venkataramanan netdev->vlan_features |= dflt_features | csumo_features | 3378d76a60baSAnirudh Venkataramanan tso_features; 33791babaf77SBrett Creeley 33801babaf77SBrett Creeley /* advertise support but don't enable by default since only one type of 33811babaf77SBrett Creeley * VLAN offload can be enabled at a time (i.e. CTAG or STAG). When one 33821babaf77SBrett Creeley * type turns on the other has to be turned off. This is enforced by the 33831babaf77SBrett Creeley * ice_fix_features() ndo callback. 33841babaf77SBrett Creeley */ 33851babaf77SBrett Creeley if (is_dvm_ena) 33861babaf77SBrett Creeley netdev->hw_features |= NETIF_F_HW_VLAN_STAG_RX | 33871babaf77SBrett Creeley NETIF_F_HW_VLAN_STAG_TX; 3388dddd406dSJesse Brandeburg 3389dddd406dSJesse Brandeburg /* Leave CRC / FCS stripping enabled by default, but allow the value to 3390dddd406dSJesse Brandeburg * be changed at runtime 3391dddd406dSJesse Brandeburg */ 3392dddd406dSJesse Brandeburg netdev->hw_features |= NETIF_F_RXFCS; 3393462acf6aSTony Nguyen } 3394462acf6aSTony Nguyen 3395462acf6aSTony Nguyen /** 3396462acf6aSTony Nguyen * ice_cfg_netdev - Allocate, configure and register a netdev 3397462acf6aSTony Nguyen * @vsi: the VSI associated with the new netdev 3398462acf6aSTony Nguyen * 3399462acf6aSTony Nguyen * Returns 0 on success, negative value on failure 3400462acf6aSTony Nguyen */ 3401462acf6aSTony Nguyen static int ice_cfg_netdev(struct ice_vsi *vsi) 3402462acf6aSTony Nguyen { 3403462acf6aSTony Nguyen struct ice_netdev_priv *np; 3404462acf6aSTony Nguyen struct net_device *netdev; 3405462acf6aSTony Nguyen u8 mac_addr[ETH_ALEN]; 34061adf7eadSJacob Keller 3407462acf6aSTony Nguyen netdev = alloc_etherdev_mqs(sizeof(*np), vsi->alloc_txq, 3408462acf6aSTony Nguyen vsi->alloc_rxq); 34091e23f076SAnirudh Venkataramanan if (!netdev) 34101e23f076SAnirudh Venkataramanan return -ENOMEM; 3411462acf6aSTony Nguyen 3412a476d72aSAnirudh Venkataramanan set_bit(ICE_VSI_NETDEV_ALLOCD, vsi->state); 3413462acf6aSTony Nguyen vsi->netdev = netdev; 3414462acf6aSTony Nguyen np = netdev_priv(netdev); 3415462acf6aSTony Nguyen np->vsi = vsi; 3416462acf6aSTony Nguyen 3417462acf6aSTony Nguyen ice_set_netdev_features(netdev); 3418462acf6aSTony Nguyen 3419462acf6aSTony Nguyen ice_set_ops(netdev); 34203a858ba3SAnirudh Venkataramanan 34213a858ba3SAnirudh Venkataramanan if (vsi->type == ICE_VSI_PF) { 3422c73bf3bdSPaul M Stillwell Jr SET_NETDEV_DEV(netdev, ice_pf_to_dev(vsi->back)); 34233a858ba3SAnirudh Venkataramanan ether_addr_copy(mac_addr, vsi->port_info->mac.perm_addr); 3424f3956ebbSJakub Kicinski eth_hw_addr_set(netdev, mac_addr); 34253a858ba3SAnirudh Venkataramanan ether_addr_copy(netdev->perm_addr, mac_addr); 34263a858ba3SAnirudh Venkataramanan } 34273a858ba3SAnirudh Venkataramanan 34283a858ba3SAnirudh Venkataramanan netdev->priv_flags |= IFF_UNICAST_FLT; 34293a858ba3SAnirudh Venkataramanan 3430462acf6aSTony Nguyen /* Setup netdev TC information */ 3431462acf6aSTony Nguyen ice_vsi_cfg_netdev_tc(vsi, vsi->tc_cfg.ena_tc); 3432cdedef59SAnirudh Venkataramanan 34333a858ba3SAnirudh Venkataramanan /* setup watchdog timeout value to be 5 second */ 34343a858ba3SAnirudh Venkataramanan netdev->watchdog_timeo = 5 * HZ; 34353a858ba3SAnirudh Venkataramanan 34363a858ba3SAnirudh Venkataramanan netdev->min_mtu = ETH_MIN_MTU; 34373a858ba3SAnirudh Venkataramanan netdev->max_mtu = ICE_MAX_MTU; 34383a858ba3SAnirudh Venkataramanan 34393a858ba3SAnirudh Venkataramanan return 0; 34403a858ba3SAnirudh Venkataramanan } 34413a858ba3SAnirudh Venkataramanan 34423a858ba3SAnirudh Venkataramanan /** 3443d76a60baSAnirudh Venkataramanan * ice_fill_rss_lut - Fill the RSS lookup table with default values 3444d76a60baSAnirudh Venkataramanan * @lut: Lookup table 3445d76a60baSAnirudh Venkataramanan * @rss_table_size: Lookup table size 3446d76a60baSAnirudh Venkataramanan * @rss_size: Range of queue number for hashing 3447d76a60baSAnirudh Venkataramanan */ 3448d76a60baSAnirudh Venkataramanan void ice_fill_rss_lut(u8 *lut, u16 rss_table_size, u16 rss_size) 3449d76a60baSAnirudh Venkataramanan { 3450d76a60baSAnirudh Venkataramanan u16 i; 3451d76a60baSAnirudh Venkataramanan 3452d76a60baSAnirudh Venkataramanan for (i = 0; i < rss_table_size; i++) 3453d76a60baSAnirudh Venkataramanan lut[i] = i % rss_size; 3454d76a60baSAnirudh Venkataramanan } 3455d76a60baSAnirudh Venkataramanan 3456d76a60baSAnirudh Venkataramanan /** 34570f9d5027SAnirudh Venkataramanan * ice_pf_vsi_setup - Set up a PF VSI 34580f9d5027SAnirudh Venkataramanan * @pf: board private structure 34590f9d5027SAnirudh Venkataramanan * @pi: pointer to the port_info instance 34600f9d5027SAnirudh Venkataramanan * 34610e674aebSAnirudh Venkataramanan * Returns pointer to the successfully allocated VSI software struct 34620e674aebSAnirudh Venkataramanan * on success, otherwise returns NULL on failure. 34630f9d5027SAnirudh Venkataramanan */ 34640f9d5027SAnirudh Venkataramanan static struct ice_vsi * 34650f9d5027SAnirudh Venkataramanan ice_pf_vsi_setup(struct ice_pf *pf, struct ice_port_info *pi) 34660f9d5027SAnirudh Venkataramanan { 3467b03d519dSJacob Keller return ice_vsi_setup(pf, pi, ICE_VSI_PF, NULL, NULL); 34680f9d5027SAnirudh Venkataramanan } 34690f9d5027SAnirudh Venkataramanan 3470fbc7b27aSKiran Patil static struct ice_vsi * 3471fbc7b27aSKiran Patil ice_chnl_vsi_setup(struct ice_pf *pf, struct ice_port_info *pi, 3472fbc7b27aSKiran Patil struct ice_channel *ch) 3473fbc7b27aSKiran Patil { 3474b03d519dSJacob Keller return ice_vsi_setup(pf, pi, ICE_VSI_CHNL, NULL, ch); 3475fbc7b27aSKiran Patil } 3476fbc7b27aSKiran Patil 34770f9d5027SAnirudh Venkataramanan /** 3478148beb61SHenry Tieman * ice_ctrl_vsi_setup - Set up a control VSI 3479148beb61SHenry Tieman * @pf: board private structure 3480148beb61SHenry Tieman * @pi: pointer to the port_info instance 3481148beb61SHenry Tieman * 3482148beb61SHenry Tieman * Returns pointer to the successfully allocated VSI software struct 3483148beb61SHenry Tieman * on success, otherwise returns NULL on failure. 3484148beb61SHenry Tieman */ 3485148beb61SHenry Tieman static struct ice_vsi * 3486148beb61SHenry Tieman ice_ctrl_vsi_setup(struct ice_pf *pf, struct ice_port_info *pi) 3487148beb61SHenry Tieman { 3488b03d519dSJacob Keller return ice_vsi_setup(pf, pi, ICE_VSI_CTRL, NULL, NULL); 3489148beb61SHenry Tieman } 3490148beb61SHenry Tieman 3491148beb61SHenry Tieman /** 34920e674aebSAnirudh Venkataramanan * ice_lb_vsi_setup - Set up a loopback VSI 34930e674aebSAnirudh Venkataramanan * @pf: board private structure 34940e674aebSAnirudh Venkataramanan * @pi: pointer to the port_info instance 34950e674aebSAnirudh Venkataramanan * 34960e674aebSAnirudh Venkataramanan * Returns pointer to the successfully allocated VSI software struct 34970e674aebSAnirudh Venkataramanan * on success, otherwise returns NULL on failure. 34980e674aebSAnirudh Venkataramanan */ 34990e674aebSAnirudh Venkataramanan struct ice_vsi * 35000e674aebSAnirudh Venkataramanan ice_lb_vsi_setup(struct ice_pf *pf, struct ice_port_info *pi) 35010e674aebSAnirudh Venkataramanan { 3502b03d519dSJacob Keller return ice_vsi_setup(pf, pi, ICE_VSI_LB, NULL, NULL); 35030e674aebSAnirudh Venkataramanan } 35040e674aebSAnirudh Venkataramanan 35050e674aebSAnirudh Venkataramanan /** 3506f9867df6SAnirudh Venkataramanan * ice_vlan_rx_add_vid - Add a VLAN ID filter to HW offload 3507d76a60baSAnirudh Venkataramanan * @netdev: network interface to be adjusted 35082bfefa2dSBrett Creeley * @proto: VLAN TPID 3509f9867df6SAnirudh Venkataramanan * @vid: VLAN ID to be added 3510d76a60baSAnirudh Venkataramanan * 3511f9867df6SAnirudh Venkataramanan * net_device_ops implementation for adding VLAN IDs 3512d76a60baSAnirudh Venkataramanan */ 3513c8b7abddSBruce Allan static int 35142bfefa2dSBrett Creeley ice_vlan_rx_add_vid(struct net_device *netdev, __be16 proto, u16 vid) 3515d76a60baSAnirudh Venkataramanan { 3516d76a60baSAnirudh Venkataramanan struct ice_netdev_priv *np = netdev_priv(netdev); 3517c31af68aSBrett Creeley struct ice_vsi_vlan_ops *vlan_ops; 3518d76a60baSAnirudh Venkataramanan struct ice_vsi *vsi = np->vsi; 3519fb05ba12SBrett Creeley struct ice_vlan vlan; 35205eda8afdSAkeem G Abodunrin int ret; 3521d76a60baSAnirudh Venkataramanan 352242f3efefSBrett Creeley /* VLAN 0 is added by default during load/reset */ 352342f3efefSBrett Creeley if (!vid) 352442f3efefSBrett Creeley return 0; 352542f3efefSBrett Creeley 35261273f895SIvan Vecera while (test_and_set_bit(ICE_CFG_BUSY, vsi->state)) 35271273f895SIvan Vecera usleep_range(1000, 2000); 35281273f895SIvan Vecera 35291273f895SIvan Vecera /* Add multicast promisc rule for the VLAN ID to be added if 35301273f895SIvan Vecera * all-multicast is currently enabled. 35311273f895SIvan Vecera */ 35321273f895SIvan Vecera if (vsi->current_netdev_flags & IFF_ALLMULTI) { 35331273f895SIvan Vecera ret = ice_fltr_set_vsi_promisc(&vsi->back->hw, vsi->idx, 35341273f895SIvan Vecera ICE_MCAST_VLAN_PROMISC_BITS, 35351273f895SIvan Vecera vid); 35361273f895SIvan Vecera if (ret) 35371273f895SIvan Vecera goto finish; 35381273f895SIvan Vecera } 35391273f895SIvan Vecera 3540c31af68aSBrett Creeley vlan_ops = ice_get_compat_vsi_vlan_ops(vsi); 35414f74dcc1SBrett Creeley 354242f3efefSBrett Creeley /* Add a switch rule for this VLAN ID so its corresponding VLAN tagged 354342f3efefSBrett Creeley * packets aren't pruned by the device's internal switch on Rx 3544d76a60baSAnirudh Venkataramanan */ 35452bfefa2dSBrett Creeley vlan = ICE_VLAN(be16_to_cpu(proto), vid, 0); 3546c31af68aSBrett Creeley ret = vlan_ops->add_vlan(vsi, &vlan); 35471273f895SIvan Vecera if (ret) 35481273f895SIvan Vecera goto finish; 35491273f895SIvan Vecera 35501273f895SIvan Vecera /* If all-multicast is currently enabled and this VLAN ID is only one 35511273f895SIvan Vecera * besides VLAN-0 we have to update look-up type of multicast promisc 35521273f895SIvan Vecera * rule for VLAN-0 from ICE_SW_LKUP_PROMISC to ICE_SW_LKUP_PROMISC_VLAN. 35531273f895SIvan Vecera */ 35541273f895SIvan Vecera if ((vsi->current_netdev_flags & IFF_ALLMULTI) && 35551273f895SIvan Vecera ice_vsi_num_non_zero_vlans(vsi) == 1) { 35561273f895SIvan Vecera ice_fltr_clear_vsi_promisc(&vsi->back->hw, vsi->idx, 35571273f895SIvan Vecera ICE_MCAST_PROMISC_BITS, 0); 35581273f895SIvan Vecera ice_fltr_set_vsi_promisc(&vsi->back->hw, vsi->idx, 35591273f895SIvan Vecera ICE_MCAST_VLAN_PROMISC_BITS, 0); 35601273f895SIvan Vecera } 35611273f895SIvan Vecera 35621273f895SIvan Vecera finish: 35631273f895SIvan Vecera clear_bit(ICE_CFG_BUSY, vsi->state); 35645eda8afdSAkeem G Abodunrin 35655eda8afdSAkeem G Abodunrin return ret; 3566d76a60baSAnirudh Venkataramanan } 3567d76a60baSAnirudh Venkataramanan 3568d76a60baSAnirudh Venkataramanan /** 3569f9867df6SAnirudh Venkataramanan * ice_vlan_rx_kill_vid - Remove a VLAN ID filter from HW offload 3570d76a60baSAnirudh Venkataramanan * @netdev: network interface to be adjusted 35712bfefa2dSBrett Creeley * @proto: VLAN TPID 3572f9867df6SAnirudh Venkataramanan * @vid: VLAN ID to be removed 3573d76a60baSAnirudh Venkataramanan * 3574f9867df6SAnirudh Venkataramanan * net_device_ops implementation for removing VLAN IDs 3575d76a60baSAnirudh Venkataramanan */ 3576c8b7abddSBruce Allan static int 35772bfefa2dSBrett Creeley ice_vlan_rx_kill_vid(struct net_device *netdev, __be16 proto, u16 vid) 3578d76a60baSAnirudh Venkataramanan { 3579d76a60baSAnirudh Venkataramanan struct ice_netdev_priv *np = netdev_priv(netdev); 3580c31af68aSBrett Creeley struct ice_vsi_vlan_ops *vlan_ops; 3581d76a60baSAnirudh Venkataramanan struct ice_vsi *vsi = np->vsi; 3582fb05ba12SBrett Creeley struct ice_vlan vlan; 35835eda8afdSAkeem G Abodunrin int ret; 3584d76a60baSAnirudh Venkataramanan 358542f3efefSBrett Creeley /* don't allow removal of VLAN 0 */ 358642f3efefSBrett Creeley if (!vid) 358742f3efefSBrett Creeley return 0; 358842f3efefSBrett Creeley 35891273f895SIvan Vecera while (test_and_set_bit(ICE_CFG_BUSY, vsi->state)) 35901273f895SIvan Vecera usleep_range(1000, 2000); 35911273f895SIvan Vecera 3592abddafd4SGrzegorz Siwik ret = ice_clear_vsi_promisc(&vsi->back->hw, vsi->idx, 3593abddafd4SGrzegorz Siwik ICE_MCAST_VLAN_PROMISC_BITS, vid); 3594abddafd4SGrzegorz Siwik if (ret) { 3595abddafd4SGrzegorz Siwik netdev_err(netdev, "Error clearing multicast promiscuous mode on VSI %i\n", 3596abddafd4SGrzegorz Siwik vsi->vsi_num); 3597abddafd4SGrzegorz Siwik vsi->current_netdev_flags |= IFF_ALLMULTI; 3598abddafd4SGrzegorz Siwik } 3599abddafd4SGrzegorz Siwik 3600c31af68aSBrett Creeley vlan_ops = ice_get_compat_vsi_vlan_ops(vsi); 3601c31af68aSBrett Creeley 3602bc42afa9SBrett Creeley /* Make sure VLAN delete is successful before updating VLAN 36034f74dcc1SBrett Creeley * information 3604d76a60baSAnirudh Venkataramanan */ 36052bfefa2dSBrett Creeley vlan = ICE_VLAN(be16_to_cpu(proto), vid, 0); 3606c31af68aSBrett Creeley ret = vlan_ops->del_vlan(vsi, &vlan); 36075eda8afdSAkeem G Abodunrin if (ret) 36081273f895SIvan Vecera goto finish; 3609d76a60baSAnirudh Venkataramanan 36101273f895SIvan Vecera /* Remove multicast promisc rule for the removed VLAN ID if 36111273f895SIvan Vecera * all-multicast is enabled. 36121273f895SIvan Vecera */ 36131273f895SIvan Vecera if (vsi->current_netdev_flags & IFF_ALLMULTI) 36141273f895SIvan Vecera ice_fltr_clear_vsi_promisc(&vsi->back->hw, vsi->idx, 36151273f895SIvan Vecera ICE_MCAST_VLAN_PROMISC_BITS, vid); 36161273f895SIvan Vecera 36171273f895SIvan Vecera if (!ice_vsi_has_non_zero_vlans(vsi)) { 36181273f895SIvan Vecera /* Update look-up type of multicast promisc rule for VLAN 0 36191273f895SIvan Vecera * from ICE_SW_LKUP_PROMISC_VLAN to ICE_SW_LKUP_PROMISC when 36201273f895SIvan Vecera * all-multicast is enabled and VLAN 0 is the only VLAN rule. 36211273f895SIvan Vecera */ 36221273f895SIvan Vecera if (vsi->current_netdev_flags & IFF_ALLMULTI) { 36231273f895SIvan Vecera ice_fltr_clear_vsi_promisc(&vsi->back->hw, vsi->idx, 36241273f895SIvan Vecera ICE_MCAST_VLAN_PROMISC_BITS, 36251273f895SIvan Vecera 0); 36261273f895SIvan Vecera ice_fltr_set_vsi_promisc(&vsi->back->hw, vsi->idx, 36271273f895SIvan Vecera ICE_MCAST_PROMISC_BITS, 0); 36281273f895SIvan Vecera } 36291273f895SIvan Vecera } 36301273f895SIvan Vecera 36311273f895SIvan Vecera finish: 36321273f895SIvan Vecera clear_bit(ICE_CFG_BUSY, vsi->state); 36331273f895SIvan Vecera 36341273f895SIvan Vecera return ret; 3635d76a60baSAnirudh Venkataramanan } 3636d76a60baSAnirudh Venkataramanan 3637d76a60baSAnirudh Venkataramanan /** 3638195bb48fSMichal Swiatkowski * ice_rep_indr_tc_block_unbind 3639195bb48fSMichal Swiatkowski * @cb_priv: indirection block private data 3640195bb48fSMichal Swiatkowski */ 3641195bb48fSMichal Swiatkowski static void ice_rep_indr_tc_block_unbind(void *cb_priv) 3642195bb48fSMichal Swiatkowski { 3643195bb48fSMichal Swiatkowski struct ice_indr_block_priv *indr_priv = cb_priv; 3644195bb48fSMichal Swiatkowski 3645195bb48fSMichal Swiatkowski list_del(&indr_priv->list); 3646195bb48fSMichal Swiatkowski kfree(indr_priv); 3647195bb48fSMichal Swiatkowski } 3648195bb48fSMichal Swiatkowski 3649195bb48fSMichal Swiatkowski /** 3650195bb48fSMichal Swiatkowski * ice_tc_indir_block_unregister - Unregister TC indirect block notifications 3651195bb48fSMichal Swiatkowski * @vsi: VSI struct which has the netdev 3652195bb48fSMichal Swiatkowski */ 3653195bb48fSMichal Swiatkowski static void ice_tc_indir_block_unregister(struct ice_vsi *vsi) 3654195bb48fSMichal Swiatkowski { 3655195bb48fSMichal Swiatkowski struct ice_netdev_priv *np = netdev_priv(vsi->netdev); 3656195bb48fSMichal Swiatkowski 3657195bb48fSMichal Swiatkowski flow_indr_dev_unregister(ice_indr_setup_tc_cb, np, 3658195bb48fSMichal Swiatkowski ice_rep_indr_tc_block_unbind); 3659195bb48fSMichal Swiatkowski } 3660195bb48fSMichal Swiatkowski 3661195bb48fSMichal Swiatkowski /** 3662195bb48fSMichal Swiatkowski * ice_tc_indir_block_remove - clean indirect TC block notifications 3663195bb48fSMichal Swiatkowski * @pf: PF structure 3664195bb48fSMichal Swiatkowski */ 3665195bb48fSMichal Swiatkowski static void ice_tc_indir_block_remove(struct ice_pf *pf) 3666195bb48fSMichal Swiatkowski { 3667195bb48fSMichal Swiatkowski struct ice_vsi *pf_vsi = ice_get_main_vsi(pf); 3668195bb48fSMichal Swiatkowski 3669195bb48fSMichal Swiatkowski if (!pf_vsi) 3670195bb48fSMichal Swiatkowski return; 3671195bb48fSMichal Swiatkowski 3672195bb48fSMichal Swiatkowski ice_tc_indir_block_unregister(pf_vsi); 3673195bb48fSMichal Swiatkowski } 3674195bb48fSMichal Swiatkowski 3675195bb48fSMichal Swiatkowski /** 3676195bb48fSMichal Swiatkowski * ice_tc_indir_block_register - Register TC indirect block notifications 3677195bb48fSMichal Swiatkowski * @vsi: VSI struct which has the netdev 3678195bb48fSMichal Swiatkowski * 3679195bb48fSMichal Swiatkowski * Returns 0 on success, negative value on failure 3680195bb48fSMichal Swiatkowski */ 3681195bb48fSMichal Swiatkowski static int ice_tc_indir_block_register(struct ice_vsi *vsi) 3682195bb48fSMichal Swiatkowski { 3683195bb48fSMichal Swiatkowski struct ice_netdev_priv *np; 3684195bb48fSMichal Swiatkowski 3685195bb48fSMichal Swiatkowski if (!vsi || !vsi->netdev) 3686195bb48fSMichal Swiatkowski return -EINVAL; 3687195bb48fSMichal Swiatkowski 3688195bb48fSMichal Swiatkowski np = netdev_priv(vsi->netdev); 3689195bb48fSMichal Swiatkowski 3690195bb48fSMichal Swiatkowski INIT_LIST_HEAD(&np->tc_indr_block_priv_list); 3691195bb48fSMichal Swiatkowski return flow_indr_dev_register(ice_indr_setup_tc_cb, np); 3692195bb48fSMichal Swiatkowski } 3693195bb48fSMichal Swiatkowski 3694195bb48fSMichal Swiatkowski /** 36953a858ba3SAnirudh Venkataramanan * ice_setup_pf_sw - Setup the HW switch on startup or after reset 36963a858ba3SAnirudh Venkataramanan * @pf: board private structure 36973a858ba3SAnirudh Venkataramanan * 36983a858ba3SAnirudh Venkataramanan * Returns 0 on success, negative value on failure 36993a858ba3SAnirudh Venkataramanan */ 37003a858ba3SAnirudh Venkataramanan static int ice_setup_pf_sw(struct ice_pf *pf) 37013a858ba3SAnirudh Venkataramanan { 3702195bb48fSMichal Swiatkowski struct device *dev = ice_pf_to_dev(pf); 3703a1ffafb0SBrett Creeley bool dvm = ice_is_dvm_ena(&pf->hw); 37043a858ba3SAnirudh Venkataramanan struct ice_vsi *vsi; 37052ccc1c1cSTony Nguyen int status; 37063a858ba3SAnirudh Venkataramanan 37075df7e45dSDave Ertman if (ice_is_reset_in_progress(pf->state)) 37080f9d5027SAnirudh Venkataramanan return -EBUSY; 37090f9d5027SAnirudh Venkataramanan 3710a1ffafb0SBrett Creeley status = ice_aq_set_port_params(pf->hw.port_info, dvm, NULL); 3711a1ffafb0SBrett Creeley if (status) 3712a1ffafb0SBrett Creeley return -EIO; 3713a1ffafb0SBrett Creeley 37140f9d5027SAnirudh Venkataramanan vsi = ice_pf_vsi_setup(pf, pf->hw.port_info); 3715135f4b9eSJacob Keller if (!vsi) 3716135f4b9eSJacob Keller return -ENOMEM; 37173a858ba3SAnirudh Venkataramanan 3718fbc7b27aSKiran Patil /* init channel list */ 3719fbc7b27aSKiran Patil INIT_LIST_HEAD(&vsi->ch_list); 3720fbc7b27aSKiran Patil 3721df0f8479SAnirudh Venkataramanan status = ice_cfg_netdev(vsi); 3722c1484691STony Nguyen if (status) 3723df0f8479SAnirudh Venkataramanan goto unroll_vsi_setup; 3724efc2214bSMaciej Fijalkowski /* netdev has to be configured before setting frame size */ 3725efc2214bSMaciej Fijalkowski ice_vsi_cfg_frame_size(vsi); 3726df0f8479SAnirudh Venkataramanan 3727195bb48fSMichal Swiatkowski /* init indirect block notifications */ 3728195bb48fSMichal Swiatkowski status = ice_tc_indir_block_register(vsi); 3729195bb48fSMichal Swiatkowski if (status) { 3730195bb48fSMichal Swiatkowski dev_err(dev, "Failed to register netdev notifier\n"); 3731195bb48fSMichal Swiatkowski goto unroll_cfg_netdev; 3732195bb48fSMichal Swiatkowski } 3733195bb48fSMichal Swiatkowski 3734b94b013eSDave Ertman /* Setup DCB netlink interface */ 3735b94b013eSDave Ertman ice_dcbnl_setup(vsi); 3736b94b013eSDave Ertman 3737df0f8479SAnirudh Venkataramanan /* registering the NAPI handler requires both the queues and 3738df0f8479SAnirudh Venkataramanan * netdev to be created, which are done in ice_pf_vsi_setup() 3739df0f8479SAnirudh Venkataramanan * and ice_cfg_netdev() respectively 3740df0f8479SAnirudh Venkataramanan */ 3741df0f8479SAnirudh Venkataramanan ice_napi_add(vsi); 3742df0f8479SAnirudh Venkataramanan 3743561f4379STony Nguyen status = ice_init_mac_fltr(pf); 37449daf8208SAnirudh Venkataramanan if (status) 3745d7442f51SAlexander Lobakin goto unroll_napi_add; 37469daf8208SAnirudh Venkataramanan 37472ccc1c1cSTony Nguyen return 0; 37489daf8208SAnirudh Venkataramanan 3749df0f8479SAnirudh Venkataramanan unroll_napi_add: 3750195bb48fSMichal Swiatkowski ice_tc_indir_block_unregister(vsi); 3751195bb48fSMichal Swiatkowski unroll_cfg_netdev: 37523a858ba3SAnirudh Venkataramanan if (vsi) { 3753df0f8479SAnirudh Venkataramanan ice_napi_del(vsi); 37543a858ba3SAnirudh Venkataramanan if (vsi->netdev) { 3755a476d72aSAnirudh Venkataramanan clear_bit(ICE_VSI_NETDEV_ALLOCD, vsi->state); 37563a858ba3SAnirudh Venkataramanan free_netdev(vsi->netdev); 37573a858ba3SAnirudh Venkataramanan vsi->netdev = NULL; 37583a858ba3SAnirudh Venkataramanan } 3759df0f8479SAnirudh Venkataramanan } 37609daf8208SAnirudh Venkataramanan 3761df0f8479SAnirudh Venkataramanan unroll_vsi_setup: 3762135f4b9eSJacob Keller ice_vsi_release(vsi); 37633a858ba3SAnirudh Venkataramanan return status; 37643a858ba3SAnirudh Venkataramanan } 37653a858ba3SAnirudh Venkataramanan 37663a858ba3SAnirudh Venkataramanan /** 37678c243700SAnirudh Venkataramanan * ice_get_avail_q_count - Get count of queues in use 37688c243700SAnirudh Venkataramanan * @pf_qmap: bitmap to get queue use count from 37698c243700SAnirudh Venkataramanan * @lock: pointer to a mutex that protects access to pf_qmap 37708c243700SAnirudh Venkataramanan * @size: size of the bitmap 3771940b61afSAnirudh Venkataramanan */ 37728c243700SAnirudh Venkataramanan static u16 37738c243700SAnirudh Venkataramanan ice_get_avail_q_count(unsigned long *pf_qmap, struct mutex *lock, u16 size) 3774940b61afSAnirudh Venkataramanan { 377588865fc4SKarol Kolacinski unsigned long bit; 377688865fc4SKarol Kolacinski u16 count = 0; 3777940b61afSAnirudh Venkataramanan 37788c243700SAnirudh Venkataramanan mutex_lock(lock); 37798c243700SAnirudh Venkataramanan for_each_clear_bit(bit, pf_qmap, size) 37808c243700SAnirudh Venkataramanan count++; 37818c243700SAnirudh Venkataramanan mutex_unlock(lock); 3782940b61afSAnirudh Venkataramanan 37838c243700SAnirudh Venkataramanan return count; 37848c243700SAnirudh Venkataramanan } 3785d76a60baSAnirudh Venkataramanan 37868c243700SAnirudh Venkataramanan /** 37878c243700SAnirudh Venkataramanan * ice_get_avail_txq_count - Get count of Tx queues in use 37888c243700SAnirudh Venkataramanan * @pf: pointer to an ice_pf instance 37898c243700SAnirudh Venkataramanan */ 37908c243700SAnirudh Venkataramanan u16 ice_get_avail_txq_count(struct ice_pf *pf) 37918c243700SAnirudh Venkataramanan { 37928c243700SAnirudh Venkataramanan return ice_get_avail_q_count(pf->avail_txqs, &pf->avail_q_mutex, 37938c243700SAnirudh Venkataramanan pf->max_pf_txqs); 37948c243700SAnirudh Venkataramanan } 3795940b61afSAnirudh Venkataramanan 37968c243700SAnirudh Venkataramanan /** 37978c243700SAnirudh Venkataramanan * ice_get_avail_rxq_count - Get count of Rx queues in use 37988c243700SAnirudh Venkataramanan * @pf: pointer to an ice_pf instance 37998c243700SAnirudh Venkataramanan */ 38008c243700SAnirudh Venkataramanan u16 ice_get_avail_rxq_count(struct ice_pf *pf) 38018c243700SAnirudh Venkataramanan { 38028c243700SAnirudh Venkataramanan return ice_get_avail_q_count(pf->avail_rxqs, &pf->avail_q_mutex, 38038c243700SAnirudh Venkataramanan pf->max_pf_rxqs); 3804940b61afSAnirudh Venkataramanan } 3805940b61afSAnirudh Venkataramanan 3806940b61afSAnirudh Venkataramanan /** 3807940b61afSAnirudh Venkataramanan * ice_deinit_pf - Unrolls initialziations done by ice_init_pf 3808940b61afSAnirudh Venkataramanan * @pf: board private structure to initialize 3809940b61afSAnirudh Venkataramanan */ 3810940b61afSAnirudh Venkataramanan static void ice_deinit_pf(struct ice_pf *pf) 3811940b61afSAnirudh Venkataramanan { 38128d81fa55SAkeem G Abodunrin ice_service_task_stop(pf); 3813486b9eeeSIvan Vecera mutex_destroy(&pf->adev_mutex); 3814940b61afSAnirudh Venkataramanan mutex_destroy(&pf->sw_mutex); 3815b94b013eSDave Ertman mutex_destroy(&pf->tc_mutex); 3816940b61afSAnirudh Venkataramanan mutex_destroy(&pf->avail_q_mutex); 38173d5985a1SJacob Keller mutex_destroy(&pf->vfs.table_lock); 381878b5713aSAnirudh Venkataramanan 381978b5713aSAnirudh Venkataramanan if (pf->avail_txqs) { 382078b5713aSAnirudh Venkataramanan bitmap_free(pf->avail_txqs); 382178b5713aSAnirudh Venkataramanan pf->avail_txqs = NULL; 382278b5713aSAnirudh Venkataramanan } 382378b5713aSAnirudh Venkataramanan 382478b5713aSAnirudh Venkataramanan if (pf->avail_rxqs) { 382578b5713aSAnirudh Venkataramanan bitmap_free(pf->avail_rxqs); 382678b5713aSAnirudh Venkataramanan pf->avail_rxqs = NULL; 382778b5713aSAnirudh Venkataramanan } 382806c16d89SJacob Keller 382906c16d89SJacob Keller if (pf->ptp.clock) 383006c16d89SJacob Keller ptp_clock_unregister(pf->ptp.clock); 3831940b61afSAnirudh Venkataramanan } 3832940b61afSAnirudh Venkataramanan 3833940b61afSAnirudh Venkataramanan /** 3834462acf6aSTony Nguyen * ice_set_pf_caps - set PFs capability flags 3835462acf6aSTony Nguyen * @pf: pointer to the PF instance 3836462acf6aSTony Nguyen */ 3837462acf6aSTony Nguyen static void ice_set_pf_caps(struct ice_pf *pf) 3838462acf6aSTony Nguyen { 3839462acf6aSTony Nguyen struct ice_hw_func_caps *func_caps = &pf->hw.func_caps; 3840462acf6aSTony Nguyen 3841d25a0fc4SDave Ertman clear_bit(ICE_FLAG_RDMA_ENA, pf->flags); 384288f62aeaSDave Ertman if (func_caps->common_cap.rdma) 3843d25a0fc4SDave Ertman set_bit(ICE_FLAG_RDMA_ENA, pf->flags); 3844462acf6aSTony Nguyen clear_bit(ICE_FLAG_DCB_CAPABLE, pf->flags); 3845462acf6aSTony Nguyen if (func_caps->common_cap.dcb) 3846462acf6aSTony Nguyen set_bit(ICE_FLAG_DCB_CAPABLE, pf->flags); 3847462acf6aSTony Nguyen clear_bit(ICE_FLAG_SRIOV_CAPABLE, pf->flags); 3848462acf6aSTony Nguyen if (func_caps->common_cap.sr_iov_1_1) { 3849462acf6aSTony Nguyen set_bit(ICE_FLAG_SRIOV_CAPABLE, pf->flags); 3850000773c0SJacob Keller pf->vfs.num_supported = min_t(int, func_caps->num_allocd_vfs, 3851dc36796eSJacob Keller ICE_MAX_SRIOV_VFS); 3852462acf6aSTony Nguyen } 3853462acf6aSTony Nguyen clear_bit(ICE_FLAG_RSS_ENA, pf->flags); 3854462acf6aSTony Nguyen if (func_caps->common_cap.rss_table_size) 3855462acf6aSTony Nguyen set_bit(ICE_FLAG_RSS_ENA, pf->flags); 3856462acf6aSTony Nguyen 3857148beb61SHenry Tieman clear_bit(ICE_FLAG_FD_ENA, pf->flags); 3858148beb61SHenry Tieman if (func_caps->fd_fltr_guar > 0 || func_caps->fd_fltr_best_effort > 0) { 3859148beb61SHenry Tieman u16 unused; 3860148beb61SHenry Tieman 3861148beb61SHenry Tieman /* ctrl_vsi_idx will be set to a valid value when flow director 3862148beb61SHenry Tieman * is setup by ice_init_fdir 3863148beb61SHenry Tieman */ 3864148beb61SHenry Tieman pf->ctrl_vsi_idx = ICE_NO_VSI; 3865148beb61SHenry Tieman set_bit(ICE_FLAG_FD_ENA, pf->flags); 3866148beb61SHenry Tieman /* force guaranteed filter pool for PF */ 3867148beb61SHenry Tieman ice_alloc_fd_guar_item(&pf->hw, &unused, 3868148beb61SHenry Tieman func_caps->fd_fltr_guar); 3869148beb61SHenry Tieman /* force shared filter pool for PF */ 3870148beb61SHenry Tieman ice_alloc_fd_shrd_item(&pf->hw, &unused, 3871148beb61SHenry Tieman func_caps->fd_fltr_best_effort); 3872148beb61SHenry Tieman } 3873148beb61SHenry Tieman 387406c16d89SJacob Keller clear_bit(ICE_FLAG_PTP_SUPPORTED, pf->flags); 387506c16d89SJacob Keller if (func_caps->common_cap.ieee_1588) 387606c16d89SJacob Keller set_bit(ICE_FLAG_PTP_SUPPORTED, pf->flags); 387706c16d89SJacob Keller 3878462acf6aSTony Nguyen pf->max_pf_txqs = func_caps->common_cap.num_txq; 3879462acf6aSTony Nguyen pf->max_pf_rxqs = func_caps->common_cap.num_rxq; 3880462acf6aSTony Nguyen } 3881462acf6aSTony Nguyen 3882462acf6aSTony Nguyen /** 3883940b61afSAnirudh Venkataramanan * ice_init_pf - Initialize general software structures (struct ice_pf) 3884940b61afSAnirudh Venkataramanan * @pf: board private structure to initialize 3885940b61afSAnirudh Venkataramanan */ 388678b5713aSAnirudh Venkataramanan static int ice_init_pf(struct ice_pf *pf) 3887940b61afSAnirudh Venkataramanan { 3888462acf6aSTony Nguyen ice_set_pf_caps(pf); 3889940b61afSAnirudh Venkataramanan 3890940b61afSAnirudh Venkataramanan mutex_init(&pf->sw_mutex); 3891b94b013eSDave Ertman mutex_init(&pf->tc_mutex); 3892486b9eeeSIvan Vecera mutex_init(&pf->adev_mutex); 3893d76a60baSAnirudh Venkataramanan 3894d69ea414SJacob Keller INIT_HLIST_HEAD(&pf->aq_wait_list); 3895d69ea414SJacob Keller spin_lock_init(&pf->aq_wait_lock); 3896d69ea414SJacob Keller init_waitqueue_head(&pf->aq_wait_queue); 3897d69ea414SJacob Keller 38981c08052eSJacob Keller init_waitqueue_head(&pf->reset_wait_queue); 38991c08052eSJacob Keller 3900940b61afSAnirudh Venkataramanan /* setup service timer and periodic service task */ 3901940b61afSAnirudh Venkataramanan timer_setup(&pf->serv_tmr, ice_service_timer, 0); 3902940b61afSAnirudh Venkataramanan pf->serv_tmr_period = HZ; 3903940b61afSAnirudh Venkataramanan INIT_WORK(&pf->serv_task, ice_service_task); 39047e408e07SAnirudh Venkataramanan clear_bit(ICE_SERVICE_SCHED, pf->state); 390578b5713aSAnirudh Venkataramanan 3906462acf6aSTony Nguyen mutex_init(&pf->avail_q_mutex); 390778b5713aSAnirudh Venkataramanan pf->avail_txqs = bitmap_zalloc(pf->max_pf_txqs, GFP_KERNEL); 390878b5713aSAnirudh Venkataramanan if (!pf->avail_txqs) 390978b5713aSAnirudh Venkataramanan return -ENOMEM; 391078b5713aSAnirudh Venkataramanan 391178b5713aSAnirudh Venkataramanan pf->avail_rxqs = bitmap_zalloc(pf->max_pf_rxqs, GFP_KERNEL); 391278b5713aSAnirudh Venkataramanan if (!pf->avail_rxqs) { 39134015d11eSBrett Creeley devm_kfree(ice_pf_to_dev(pf), pf->avail_txqs); 391478b5713aSAnirudh Venkataramanan pf->avail_txqs = NULL; 391578b5713aSAnirudh Venkataramanan return -ENOMEM; 391678b5713aSAnirudh Venkataramanan } 391778b5713aSAnirudh Venkataramanan 39183d5985a1SJacob Keller mutex_init(&pf->vfs.table_lock); 39193d5985a1SJacob Keller hash_init(pf->vfs.table); 39203d5985a1SJacob Keller 392178b5713aSAnirudh Venkataramanan return 0; 3922940b61afSAnirudh Venkataramanan } 3923940b61afSAnirudh Venkataramanan 3924940b61afSAnirudh Venkataramanan /** 3925*ce462613STony Nguyen * ice_reduce_msix_usage - Reduce usage of MSI-X vectors 3926*ce462613STony Nguyen * @pf: board private structure 3927*ce462613STony Nguyen * @v_remain: number of remaining MSI-X vectors to be distributed 3928*ce462613STony Nguyen * 3929*ce462613STony Nguyen * Reduce the usage of MSI-X vectors when entire request cannot be fulfilled. 3930*ce462613STony Nguyen * pf->num_lan_msix and pf->num_rdma_msix values are set based on number of 3931*ce462613STony Nguyen * remaining vectors. 3932*ce462613STony Nguyen */ 3933*ce462613STony Nguyen static void ice_reduce_msix_usage(struct ice_pf *pf, int v_remain) 3934*ce462613STony Nguyen { 3935*ce462613STony Nguyen int v_rdma; 3936*ce462613STony Nguyen 3937*ce462613STony Nguyen if (!ice_is_rdma_ena(pf)) { 3938*ce462613STony Nguyen pf->num_lan_msix = v_remain; 3939*ce462613STony Nguyen return; 3940*ce462613STony Nguyen } 3941*ce462613STony Nguyen 3942*ce462613STony Nguyen /* RDMA needs at least 1 interrupt in addition to AEQ MSIX */ 3943*ce462613STony Nguyen v_rdma = ICE_RDMA_NUM_AEQ_MSIX + 1; 3944*ce462613STony Nguyen 3945*ce462613STony Nguyen if (v_remain < ICE_MIN_LAN_TXRX_MSIX + ICE_MIN_RDMA_MSIX) { 3946*ce462613STony Nguyen dev_warn(ice_pf_to_dev(pf), "Not enough MSI-X vectors to support RDMA.\n"); 3947*ce462613STony Nguyen clear_bit(ICE_FLAG_RDMA_ENA, pf->flags); 3948*ce462613STony Nguyen 3949*ce462613STony Nguyen pf->num_rdma_msix = 0; 3950*ce462613STony Nguyen pf->num_lan_msix = ICE_MIN_LAN_TXRX_MSIX; 3951*ce462613STony Nguyen } else if ((v_remain < ICE_MIN_LAN_TXRX_MSIX + v_rdma) || 3952*ce462613STony Nguyen (v_remain - v_rdma < v_rdma)) { 3953*ce462613STony Nguyen /* Support minimum RDMA and give remaining vectors to LAN MSIX */ 3954*ce462613STony Nguyen pf->num_rdma_msix = ICE_MIN_RDMA_MSIX; 3955*ce462613STony Nguyen pf->num_lan_msix = v_remain - ICE_MIN_RDMA_MSIX; 3956*ce462613STony Nguyen } else { 3957*ce462613STony Nguyen /* Split remaining MSIX with RDMA after accounting for AEQ MSIX 3958*ce462613STony Nguyen */ 3959*ce462613STony Nguyen pf->num_rdma_msix = (v_remain - ICE_RDMA_NUM_AEQ_MSIX) / 2 + 3960*ce462613STony Nguyen ICE_RDMA_NUM_AEQ_MSIX; 3961*ce462613STony Nguyen pf->num_lan_msix = v_remain - pf->num_rdma_msix; 3962*ce462613STony Nguyen } 3963*ce462613STony Nguyen } 3964*ce462613STony Nguyen 3965*ce462613STony Nguyen /** 3966940b61afSAnirudh Venkataramanan * ice_ena_msix_range - Request a range of MSIX vectors from the OS 3967940b61afSAnirudh Venkataramanan * @pf: board private structure 3968940b61afSAnirudh Venkataramanan * 3969*ce462613STony Nguyen * Compute the number of MSIX vectors wanted and request from the OS. Adjust 3970*ce462613STony Nguyen * device usage if there are not enough vectors. Return the number of vectors 3971*ce462613STony Nguyen * reserved or negative on failure. 3972940b61afSAnirudh Venkataramanan */ 3973940b61afSAnirudh Venkataramanan static int ice_ena_msix_range(struct ice_pf *pf) 3974940b61afSAnirudh Venkataramanan { 3975*ce462613STony Nguyen int num_cpus, hw_num_msix, v_other, v_wanted, v_actual; 39764015d11eSBrett Creeley struct device *dev = ice_pf_to_dev(pf); 3977*ce462613STony Nguyen int err, i; 3978940b61afSAnirudh Venkataramanan 3979*ce462613STony Nguyen hw_num_msix = pf->hw.func_caps.common_cap.num_msix_vectors; 3980d25a0fc4SDave Ertman num_cpus = num_online_cpus(); 3981940b61afSAnirudh Venkataramanan 3982*ce462613STony Nguyen /* LAN miscellaneous handler */ 3983*ce462613STony Nguyen v_other = ICE_MIN_LAN_OICR_MSIX; 3984940b61afSAnirudh Venkataramanan 3985*ce462613STony Nguyen /* Flow Director */ 3986*ce462613STony Nguyen if (test_bit(ICE_FLAG_FD_ENA, pf->flags)) 3987*ce462613STony Nguyen v_other += ICE_FDIR_MSIX; 3988741106f7STony Nguyen 3989*ce462613STony Nguyen /* switchdev */ 3990*ce462613STony Nguyen v_other += ICE_ESWITCH_MSIX; 3991f66756e0SGrzegorz Nitka 3992*ce462613STony Nguyen v_wanted = v_other; 3993741106f7STony Nguyen 3994*ce462613STony Nguyen /* LAN traffic */ 3995*ce462613STony Nguyen pf->num_lan_msix = num_cpus; 3996*ce462613STony Nguyen v_wanted += pf->num_lan_msix; 3997940b61afSAnirudh Venkataramanan 3998*ce462613STony Nguyen /* RDMA auxiliary driver */ 399988f62aeaSDave Ertman if (ice_is_rdma_ena(pf)) { 4000*ce462613STony Nguyen pf->num_rdma_msix = num_cpus + ICE_RDMA_NUM_AEQ_MSIX; 4001*ce462613STony Nguyen v_wanted += pf->num_rdma_msix; 4002d25a0fc4SDave Ertman } 4003d25a0fc4SDave Ertman 4004*ce462613STony Nguyen if (v_wanted > hw_num_msix) { 4005*ce462613STony Nguyen int v_remain; 4006*ce462613STony Nguyen 4007*ce462613STony Nguyen dev_warn(dev, "not enough device MSI-X vectors. wanted = %d, available = %d\n", 4008*ce462613STony Nguyen v_wanted, hw_num_msix); 4009*ce462613STony Nguyen 4010*ce462613STony Nguyen if (hw_num_msix < ICE_MIN_MSIX) { 4011*ce462613STony Nguyen err = -ERANGE; 4012*ce462613STony Nguyen goto exit_err; 4013*ce462613STony Nguyen } 4014*ce462613STony Nguyen 4015*ce462613STony Nguyen v_remain = hw_num_msix - v_other; 4016*ce462613STony Nguyen if (v_remain < ICE_MIN_LAN_TXRX_MSIX) { 4017*ce462613STony Nguyen v_other = ICE_MIN_MSIX - ICE_MIN_LAN_TXRX_MSIX; 4018*ce462613STony Nguyen v_remain = ICE_MIN_LAN_TXRX_MSIX; 4019*ce462613STony Nguyen } 4020*ce462613STony Nguyen 4021*ce462613STony Nguyen ice_reduce_msix_usage(pf, v_remain); 4022*ce462613STony Nguyen v_wanted = pf->num_lan_msix + pf->num_rdma_msix + v_other; 4023*ce462613STony Nguyen 4024*ce462613STony Nguyen dev_notice(dev, "Reducing request to %d MSI-X vectors for LAN traffic.\n", 4025*ce462613STony Nguyen pf->num_lan_msix); 4026*ce462613STony Nguyen if (ice_is_rdma_ena(pf)) 4027*ce462613STony Nguyen dev_notice(dev, "Reducing request to %d MSI-X vectors for RDMA.\n", 4028*ce462613STony Nguyen pf->num_rdma_msix); 4029*ce462613STony Nguyen } 4030*ce462613STony Nguyen 4031*ce462613STony Nguyen pf->msix_entries = devm_kcalloc(dev, v_wanted, 4032c6dfd690SBruce Allan sizeof(*pf->msix_entries), GFP_KERNEL); 4033940b61afSAnirudh Venkataramanan if (!pf->msix_entries) { 4034940b61afSAnirudh Venkataramanan err = -ENOMEM; 4035940b61afSAnirudh Venkataramanan goto exit_err; 4036940b61afSAnirudh Venkataramanan } 4037940b61afSAnirudh Venkataramanan 4038*ce462613STony Nguyen for (i = 0; i < v_wanted; i++) 4039940b61afSAnirudh Venkataramanan pf->msix_entries[i].entry = i; 4040940b61afSAnirudh Venkataramanan 4041940b61afSAnirudh Venkataramanan /* actually reserve the vectors */ 4042940b61afSAnirudh Venkataramanan v_actual = pci_enable_msix_range(pf->pdev, pf->msix_entries, 4043*ce462613STony Nguyen ICE_MIN_MSIX, v_wanted); 4044940b61afSAnirudh Venkataramanan if (v_actual < 0) { 40454015d11eSBrett Creeley dev_err(dev, "unable to reserve MSI-X vectors\n"); 4046940b61afSAnirudh Venkataramanan err = v_actual; 4047940b61afSAnirudh Venkataramanan goto msix_err; 4048940b61afSAnirudh Venkataramanan } 4049940b61afSAnirudh Venkataramanan 4050*ce462613STony Nguyen if (v_actual < v_wanted) { 405119cce2c6SAnirudh Venkataramanan dev_warn(dev, "not enough OS MSI-X vectors. requested = %d, obtained = %d\n", 4052*ce462613STony Nguyen v_wanted, v_actual); 4053152b978aSAnirudh Venkataramanan 4054f3fe97f6SBrett Creeley if (v_actual < ICE_MIN_MSIX) { 4055152b978aSAnirudh Venkataramanan /* error if we can't get minimum vectors */ 4056940b61afSAnirudh Venkataramanan pci_disable_msix(pf->pdev); 4057940b61afSAnirudh Venkataramanan err = -ERANGE; 4058940b61afSAnirudh Venkataramanan goto msix_err; 4059152b978aSAnirudh Venkataramanan } else { 4060d25a0fc4SDave Ertman int v_remain = v_actual - v_other; 4061d25a0fc4SDave Ertman 4062*ce462613STony Nguyen if (v_remain < ICE_MIN_LAN_TXRX_MSIX) 4063*ce462613STony Nguyen v_remain = ICE_MIN_LAN_TXRX_MSIX; 4064741106f7STony Nguyen 4065*ce462613STony Nguyen ice_reduce_msix_usage(pf, v_remain); 4066741106f7STony Nguyen 4067741106f7STony Nguyen dev_notice(dev, "Enabled %d MSI-X vectors for LAN traffic.\n", 4068741106f7STony Nguyen pf->num_lan_msix); 4069d25a0fc4SDave Ertman 407088f62aeaSDave Ertman if (ice_is_rdma_ena(pf)) 4071d25a0fc4SDave Ertman dev_notice(dev, "Enabled %d MSI-X vectors for RDMA.\n", 4072d25a0fc4SDave Ertman pf->num_rdma_msix); 4073940b61afSAnirudh Venkataramanan } 4074940b61afSAnirudh Venkataramanan } 4075940b61afSAnirudh Venkataramanan 4076940b61afSAnirudh Venkataramanan return v_actual; 4077940b61afSAnirudh Venkataramanan 4078940b61afSAnirudh Venkataramanan msix_err: 40794015d11eSBrett Creeley devm_kfree(dev, pf->msix_entries); 4080940b61afSAnirudh Venkataramanan 4081940b61afSAnirudh Venkataramanan exit_err: 4082d25a0fc4SDave Ertman pf->num_rdma_msix = 0; 4083940b61afSAnirudh Venkataramanan pf->num_lan_msix = 0; 4084940b61afSAnirudh Venkataramanan return err; 4085940b61afSAnirudh Venkataramanan } 4086940b61afSAnirudh Venkataramanan 4087940b61afSAnirudh Venkataramanan /** 4088940b61afSAnirudh Venkataramanan * ice_dis_msix - Disable MSI-X interrupt setup in OS 4089940b61afSAnirudh Venkataramanan * @pf: board private structure 4090940b61afSAnirudh Venkataramanan */ 4091940b61afSAnirudh Venkataramanan static void ice_dis_msix(struct ice_pf *pf) 4092940b61afSAnirudh Venkataramanan { 4093940b61afSAnirudh Venkataramanan pci_disable_msix(pf->pdev); 40944015d11eSBrett Creeley devm_kfree(ice_pf_to_dev(pf), pf->msix_entries); 4095940b61afSAnirudh Venkataramanan pf->msix_entries = NULL; 4096940b61afSAnirudh Venkataramanan } 4097940b61afSAnirudh Venkataramanan 4098940b61afSAnirudh Venkataramanan /** 4099eb0208ecSPreethi Banala * ice_clear_interrupt_scheme - Undo things done by ice_init_interrupt_scheme 4100eb0208ecSPreethi Banala * @pf: board private structure 4101eb0208ecSPreethi Banala */ 4102eb0208ecSPreethi Banala static void ice_clear_interrupt_scheme(struct ice_pf *pf) 4103eb0208ecSPreethi Banala { 4104eb0208ecSPreethi Banala ice_dis_msix(pf); 4105eb0208ecSPreethi Banala 4106cbe66bfeSBrett Creeley if (pf->irq_tracker) { 41074015d11eSBrett Creeley devm_kfree(ice_pf_to_dev(pf), pf->irq_tracker); 4108cbe66bfeSBrett Creeley pf->irq_tracker = NULL; 4109eb0208ecSPreethi Banala } 4110eb0208ecSPreethi Banala } 4111eb0208ecSPreethi Banala 4112eb0208ecSPreethi Banala /** 4113940b61afSAnirudh Venkataramanan * ice_init_interrupt_scheme - Determine proper interrupt scheme 4114940b61afSAnirudh Venkataramanan * @pf: board private structure to initialize 4115940b61afSAnirudh Venkataramanan */ 4116940b61afSAnirudh Venkataramanan static int ice_init_interrupt_scheme(struct ice_pf *pf) 4117940b61afSAnirudh Venkataramanan { 4118cbe66bfeSBrett Creeley int vectors; 4119940b61afSAnirudh Venkataramanan 4120940b61afSAnirudh Venkataramanan vectors = ice_ena_msix_range(pf); 4121940b61afSAnirudh Venkataramanan 4122940b61afSAnirudh Venkataramanan if (vectors < 0) 4123940b61afSAnirudh Venkataramanan return vectors; 4124940b61afSAnirudh Venkataramanan 4125940b61afSAnirudh Venkataramanan /* set up vector assignment tracking */ 4126e94c0df9SGustavo A. R. Silva pf->irq_tracker = devm_kzalloc(ice_pf_to_dev(pf), 4127e94c0df9SGustavo A. R. Silva struct_size(pf->irq_tracker, list, vectors), 4128e94c0df9SGustavo A. R. Silva GFP_KERNEL); 4129cbe66bfeSBrett Creeley if (!pf->irq_tracker) { 4130940b61afSAnirudh Venkataramanan ice_dis_msix(pf); 4131940b61afSAnirudh Venkataramanan return -ENOMEM; 4132940b61afSAnirudh Venkataramanan } 4133940b61afSAnirudh Venkataramanan 4134eb0208ecSPreethi Banala /* populate SW interrupts pool with number of OS granted IRQs. */ 413588865fc4SKarol Kolacinski pf->num_avail_sw_msix = (u16)vectors; 413688865fc4SKarol Kolacinski pf->irq_tracker->num_entries = (u16)vectors; 4137cbe66bfeSBrett Creeley pf->irq_tracker->end = pf->irq_tracker->num_entries; 4138940b61afSAnirudh Venkataramanan 4139940b61afSAnirudh Venkataramanan return 0; 4140940b61afSAnirudh Venkataramanan } 4141940b61afSAnirudh Venkataramanan 4142940b61afSAnirudh Venkataramanan /** 414331765519SAnirudh Venkataramanan * ice_is_wol_supported - check if WoL is supported 414431765519SAnirudh Venkataramanan * @hw: pointer to hardware info 4145769c500dSAkeem G Abodunrin * 4146769c500dSAkeem G Abodunrin * Check if WoL is supported based on the HW configuration. 4147769c500dSAkeem G Abodunrin * Returns true if NVM supports and enables WoL for this port, false otherwise 4148769c500dSAkeem G Abodunrin */ 414931765519SAnirudh Venkataramanan bool ice_is_wol_supported(struct ice_hw *hw) 4150769c500dSAkeem G Abodunrin { 4151769c500dSAkeem G Abodunrin u16 wol_ctrl; 4152769c500dSAkeem G Abodunrin 4153769c500dSAkeem G Abodunrin /* A bit set to 1 in the NVM Software Reserved Word 2 (WoL control 4154769c500dSAkeem G Abodunrin * word) indicates WoL is not supported on the corresponding PF ID. 4155769c500dSAkeem G Abodunrin */ 4156769c500dSAkeem G Abodunrin if (ice_read_sr_word(hw, ICE_SR_NVM_WOL_CFG, &wol_ctrl)) 4157769c500dSAkeem G Abodunrin return false; 4158769c500dSAkeem G Abodunrin 415931765519SAnirudh Venkataramanan return !(BIT(hw->port_info->lport) & wol_ctrl); 4160769c500dSAkeem G Abodunrin } 4161769c500dSAkeem G Abodunrin 4162769c500dSAkeem G Abodunrin /** 416387324e74SHenry Tieman * ice_vsi_recfg_qs - Change the number of queues on a VSI 416487324e74SHenry Tieman * @vsi: VSI being changed 416587324e74SHenry Tieman * @new_rx: new number of Rx queues 416687324e74SHenry Tieman * @new_tx: new number of Tx queues 416787324e74SHenry Tieman * 416887324e74SHenry Tieman * Only change the number of queues if new_tx, or new_rx is non-0. 416987324e74SHenry Tieman * 417087324e74SHenry Tieman * Returns 0 on success. 417187324e74SHenry Tieman */ 417287324e74SHenry Tieman int ice_vsi_recfg_qs(struct ice_vsi *vsi, int new_rx, int new_tx) 417387324e74SHenry Tieman { 417487324e74SHenry Tieman struct ice_pf *pf = vsi->back; 417587324e74SHenry Tieman int err = 0, timeout = 50; 417687324e74SHenry Tieman 417787324e74SHenry Tieman if (!new_rx && !new_tx) 417887324e74SHenry Tieman return -EINVAL; 417987324e74SHenry Tieman 41807e408e07SAnirudh Venkataramanan while (test_and_set_bit(ICE_CFG_BUSY, pf->state)) { 418187324e74SHenry Tieman timeout--; 418287324e74SHenry Tieman if (!timeout) 418387324e74SHenry Tieman return -EBUSY; 418487324e74SHenry Tieman usleep_range(1000, 2000); 418587324e74SHenry Tieman } 418687324e74SHenry Tieman 418787324e74SHenry Tieman if (new_tx) 418888865fc4SKarol Kolacinski vsi->req_txq = (u16)new_tx; 418987324e74SHenry Tieman if (new_rx) 419088865fc4SKarol Kolacinski vsi->req_rxq = (u16)new_rx; 419187324e74SHenry Tieman 419287324e74SHenry Tieman /* set for the next time the netdev is started */ 419387324e74SHenry Tieman if (!netif_running(vsi->netdev)) { 419487324e74SHenry Tieman ice_vsi_rebuild(vsi, false); 419587324e74SHenry Tieman dev_dbg(ice_pf_to_dev(pf), "Link is down, queue count change happens when link is brought up\n"); 419687324e74SHenry Tieman goto done; 419787324e74SHenry Tieman } 419887324e74SHenry Tieman 419987324e74SHenry Tieman ice_vsi_close(vsi); 420087324e74SHenry Tieman ice_vsi_rebuild(vsi, false); 420187324e74SHenry Tieman ice_pf_dcb_recfg(pf); 420287324e74SHenry Tieman ice_vsi_open(vsi); 420387324e74SHenry Tieman done: 42047e408e07SAnirudh Venkataramanan clear_bit(ICE_CFG_BUSY, pf->state); 420587324e74SHenry Tieman return err; 420687324e74SHenry Tieman } 420787324e74SHenry Tieman 420887324e74SHenry Tieman /** 4209cd1f56f4SBrett Creeley * ice_set_safe_mode_vlan_cfg - configure PF VSI to allow all VLANs in safe mode 4210cd1f56f4SBrett Creeley * @pf: PF to configure 4211cd1f56f4SBrett Creeley * 4212cd1f56f4SBrett Creeley * No VLAN offloads/filtering are advertised in safe mode so make sure the PF 4213cd1f56f4SBrett Creeley * VSI can still Tx/Rx VLAN tagged packets. 4214cd1f56f4SBrett Creeley */ 4215cd1f56f4SBrett Creeley static void ice_set_safe_mode_vlan_cfg(struct ice_pf *pf) 4216cd1f56f4SBrett Creeley { 4217cd1f56f4SBrett Creeley struct ice_vsi *vsi = ice_get_main_vsi(pf); 4218cd1f56f4SBrett Creeley struct ice_vsi_ctx *ctxt; 4219cd1f56f4SBrett Creeley struct ice_hw *hw; 42205518ac2aSTony Nguyen int status; 4221cd1f56f4SBrett Creeley 4222cd1f56f4SBrett Creeley if (!vsi) 4223cd1f56f4SBrett Creeley return; 4224cd1f56f4SBrett Creeley 4225cd1f56f4SBrett Creeley ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL); 4226cd1f56f4SBrett Creeley if (!ctxt) 4227cd1f56f4SBrett Creeley return; 4228cd1f56f4SBrett Creeley 4229cd1f56f4SBrett Creeley hw = &pf->hw; 4230cd1f56f4SBrett Creeley ctxt->info = vsi->info; 4231cd1f56f4SBrett Creeley 4232cd1f56f4SBrett Creeley ctxt->info.valid_sections = 4233cd1f56f4SBrett Creeley cpu_to_le16(ICE_AQ_VSI_PROP_VLAN_VALID | 4234cd1f56f4SBrett Creeley ICE_AQ_VSI_PROP_SECURITY_VALID | 4235cd1f56f4SBrett Creeley ICE_AQ_VSI_PROP_SW_VALID); 4236cd1f56f4SBrett Creeley 4237cd1f56f4SBrett Creeley /* disable VLAN anti-spoof */ 4238cd1f56f4SBrett Creeley ctxt->info.sec_flags &= ~(ICE_AQ_VSI_SEC_TX_VLAN_PRUNE_ENA << 4239cd1f56f4SBrett Creeley ICE_AQ_VSI_SEC_TX_PRUNE_ENA_S); 4240cd1f56f4SBrett Creeley 4241cd1f56f4SBrett Creeley /* disable VLAN pruning and keep all other settings */ 4242cd1f56f4SBrett Creeley ctxt->info.sw_flags2 &= ~ICE_AQ_VSI_SW_FLAG_RX_VLAN_PRUNE_ENA; 4243cd1f56f4SBrett Creeley 4244cd1f56f4SBrett Creeley /* allow all VLANs on Tx and don't strip on Rx */ 42457bd527aaSBrett Creeley ctxt->info.inner_vlan_flags = ICE_AQ_VSI_INNER_VLAN_TX_MODE_ALL | 42467bd527aaSBrett Creeley ICE_AQ_VSI_INNER_VLAN_EMODE_NOTHING; 4247cd1f56f4SBrett Creeley 4248cd1f56f4SBrett Creeley status = ice_update_vsi(hw, vsi->idx, ctxt, NULL); 4249cd1f56f4SBrett Creeley if (status) { 42505f87ec48STony Nguyen dev_err(ice_pf_to_dev(vsi->back), "Failed to update VSI for safe mode VLANs, err %d aq_err %s\n", 42515518ac2aSTony Nguyen status, ice_aq_str(hw->adminq.sq_last_status)); 4252cd1f56f4SBrett Creeley } else { 4253cd1f56f4SBrett Creeley vsi->info.sec_flags = ctxt->info.sec_flags; 4254cd1f56f4SBrett Creeley vsi->info.sw_flags2 = ctxt->info.sw_flags2; 42557bd527aaSBrett Creeley vsi->info.inner_vlan_flags = ctxt->info.inner_vlan_flags; 4256cd1f56f4SBrett Creeley } 4257cd1f56f4SBrett Creeley 4258cd1f56f4SBrett Creeley kfree(ctxt); 4259cd1f56f4SBrett Creeley } 4260cd1f56f4SBrett Creeley 4261cd1f56f4SBrett Creeley /** 4262462acf6aSTony Nguyen * ice_log_pkg_init - log result of DDP package load 4263462acf6aSTony Nguyen * @hw: pointer to hardware info 4264247dd97dSWojciech Drewek * @state: state of package load 4265462acf6aSTony Nguyen */ 4266247dd97dSWojciech Drewek static void ice_log_pkg_init(struct ice_hw *hw, enum ice_ddp_state state) 4267462acf6aSTony Nguyen { 4268247dd97dSWojciech Drewek struct ice_pf *pf = hw->back; 4269247dd97dSWojciech Drewek struct device *dev; 4270462acf6aSTony Nguyen 4271247dd97dSWojciech Drewek dev = ice_pf_to_dev(pf); 4272247dd97dSWojciech Drewek 4273247dd97dSWojciech Drewek switch (state) { 4274247dd97dSWojciech Drewek case ICE_DDP_PKG_SUCCESS: 427519cce2c6SAnirudh Venkataramanan dev_info(dev, "The DDP package was successfully loaded: %s version %d.%d.%d.%d\n", 4276462acf6aSTony Nguyen hw->active_pkg_name, 4277462acf6aSTony Nguyen hw->active_pkg_ver.major, 4278462acf6aSTony Nguyen hw->active_pkg_ver.minor, 4279462acf6aSTony Nguyen hw->active_pkg_ver.update, 4280462acf6aSTony Nguyen hw->active_pkg_ver.draft); 4281247dd97dSWojciech Drewek break; 4282247dd97dSWojciech Drewek case ICE_DDP_PKG_SAME_VERSION_ALREADY_LOADED: 4283247dd97dSWojciech Drewek dev_info(dev, "DDP package already present on device: %s version %d.%d.%d.%d\n", 4284247dd97dSWojciech Drewek hw->active_pkg_name, 4285247dd97dSWojciech Drewek hw->active_pkg_ver.major, 4286247dd97dSWojciech Drewek hw->active_pkg_ver.minor, 4287247dd97dSWojciech Drewek hw->active_pkg_ver.update, 4288247dd97dSWojciech Drewek hw->active_pkg_ver.draft); 4289247dd97dSWojciech Drewek break; 4290247dd97dSWojciech Drewek case ICE_DDP_PKG_ALREADY_LOADED_NOT_SUPPORTED: 429119cce2c6SAnirudh Venkataramanan dev_err(dev, "The device has a DDP package that is not supported by the driver. The device has package '%s' version %d.%d.x.x. The driver requires version %d.%d.x.x. Entering Safe Mode.\n", 4292462acf6aSTony Nguyen hw->active_pkg_name, 4293462acf6aSTony Nguyen hw->active_pkg_ver.major, 4294462acf6aSTony Nguyen hw->active_pkg_ver.minor, 4295462acf6aSTony Nguyen ICE_PKG_SUPP_VER_MAJ, ICE_PKG_SUPP_VER_MNR); 4296247dd97dSWojciech Drewek break; 4297247dd97dSWojciech Drewek case ICE_DDP_PKG_COMPATIBLE_ALREADY_LOADED: 429819cce2c6SAnirudh Venkataramanan dev_info(dev, "The driver could not load the DDP package file because a compatible DDP package is already present on the device. The device has package '%s' version %d.%d.%d.%d. The package file found by the driver: '%s' version %d.%d.%d.%d.\n", 4299462acf6aSTony Nguyen hw->active_pkg_name, 4300462acf6aSTony Nguyen hw->active_pkg_ver.major, 4301462acf6aSTony Nguyen hw->active_pkg_ver.minor, 4302462acf6aSTony Nguyen hw->active_pkg_ver.update, 4303462acf6aSTony Nguyen hw->active_pkg_ver.draft, 4304462acf6aSTony Nguyen hw->pkg_name, 4305462acf6aSTony Nguyen hw->pkg_ver.major, 4306462acf6aSTony Nguyen hw->pkg_ver.minor, 4307462acf6aSTony Nguyen hw->pkg_ver.update, 4308462acf6aSTony Nguyen hw->pkg_ver.draft); 4309462acf6aSTony Nguyen break; 4310247dd97dSWojciech Drewek case ICE_DDP_PKG_FW_MISMATCH: 4311b8272919SVictor Raj dev_err(dev, "The firmware loaded on the device is not compatible with the DDP package. Please update the device's NVM. Entering safe mode.\n"); 4312b8272919SVictor Raj break; 4313247dd97dSWojciech Drewek case ICE_DDP_PKG_INVALID_FILE: 431419cce2c6SAnirudh Venkataramanan dev_err(dev, "The DDP package file is invalid. Entering Safe Mode.\n"); 4315462acf6aSTony Nguyen break; 4316247dd97dSWojciech Drewek case ICE_DDP_PKG_FILE_VERSION_TOO_HIGH: 431719cce2c6SAnirudh Venkataramanan dev_err(dev, "The DDP package file version is higher than the driver supports. Please use an updated driver. Entering Safe Mode.\n"); 4318247dd97dSWojciech Drewek break; 4319247dd97dSWojciech Drewek case ICE_DDP_PKG_FILE_VERSION_TOO_LOW: 432019cce2c6SAnirudh Venkataramanan dev_err(dev, "The DDP package file version is lower than the driver supports. The driver requires version %d.%d.x.x. Please use an updated DDP Package file. Entering Safe Mode.\n", 4321462acf6aSTony Nguyen ICE_PKG_SUPP_VER_MAJ, ICE_PKG_SUPP_VER_MNR); 4322462acf6aSTony Nguyen break; 4323247dd97dSWojciech Drewek case ICE_DDP_PKG_FILE_SIGNATURE_INVALID: 432419cce2c6SAnirudh Venkataramanan dev_err(dev, "The DDP package could not be loaded because its signature is not valid. Please use a valid DDP Package. Entering Safe Mode.\n"); 4325247dd97dSWojciech Drewek break; 4326247dd97dSWojciech Drewek case ICE_DDP_PKG_FILE_REVISION_TOO_LOW: 432719cce2c6SAnirudh Venkataramanan dev_err(dev, "The DDP Package could not be loaded because its security revision is too low. Please use an updated DDP Package. Entering Safe Mode.\n"); 4328247dd97dSWojciech Drewek break; 4329247dd97dSWojciech Drewek case ICE_DDP_PKG_LOAD_ERROR: 433019cce2c6SAnirudh Venkataramanan dev_err(dev, "An error occurred on the device while loading the DDP package. The device will be reset.\n"); 43319918f2d2SAnirudh Venkataramanan /* poll for reset to complete */ 43329918f2d2SAnirudh Venkataramanan if (ice_check_reset(hw)) 43339918f2d2SAnirudh Venkataramanan dev_err(dev, "Error resetting device. Please reload the driver\n"); 4334462acf6aSTony Nguyen break; 4335247dd97dSWojciech Drewek case ICE_DDP_PKG_ERR: 4336462acf6aSTony Nguyen default: 4337247dd97dSWojciech Drewek dev_err(dev, "An unknown error occurred when loading the DDP package. Entering Safe Mode.\n"); 43380092db5fSJesse Brandeburg break; 4339462acf6aSTony Nguyen } 4340462acf6aSTony Nguyen } 4341462acf6aSTony Nguyen 4342462acf6aSTony Nguyen /** 4343462acf6aSTony Nguyen * ice_load_pkg - load/reload the DDP Package file 4344462acf6aSTony Nguyen * @firmware: firmware structure when firmware requested or NULL for reload 4345462acf6aSTony Nguyen * @pf: pointer to the PF instance 4346462acf6aSTony Nguyen * 4347462acf6aSTony Nguyen * Called on probe and post CORER/GLOBR rebuild to load DDP Package and 4348462acf6aSTony Nguyen * initialize HW tables. 4349462acf6aSTony Nguyen */ 4350462acf6aSTony Nguyen static void 4351462acf6aSTony Nguyen ice_load_pkg(const struct firmware *firmware, struct ice_pf *pf) 4352462acf6aSTony Nguyen { 4353247dd97dSWojciech Drewek enum ice_ddp_state state = ICE_DDP_PKG_ERR; 43544015d11eSBrett Creeley struct device *dev = ice_pf_to_dev(pf); 4355462acf6aSTony Nguyen struct ice_hw *hw = &pf->hw; 4356462acf6aSTony Nguyen 4357462acf6aSTony Nguyen /* Load DDP Package */ 4358462acf6aSTony Nguyen if (firmware && !hw->pkg_copy) { 4359247dd97dSWojciech Drewek state = ice_copy_and_init_pkg(hw, firmware->data, 4360462acf6aSTony Nguyen firmware->size); 4361247dd97dSWojciech Drewek ice_log_pkg_init(hw, state); 4362462acf6aSTony Nguyen } else if (!firmware && hw->pkg_copy) { 4363462acf6aSTony Nguyen /* Reload package during rebuild after CORER/GLOBR reset */ 4364247dd97dSWojciech Drewek state = ice_init_pkg(hw, hw->pkg_copy, hw->pkg_size); 4365247dd97dSWojciech Drewek ice_log_pkg_init(hw, state); 4366462acf6aSTony Nguyen } else { 436719cce2c6SAnirudh Venkataramanan dev_err(dev, "The DDP package file failed to load. Entering Safe Mode.\n"); 4368462acf6aSTony Nguyen } 4369462acf6aSTony Nguyen 4370247dd97dSWojciech Drewek if (!ice_is_init_pkg_successful(state)) { 4371462acf6aSTony Nguyen /* Safe Mode */ 4372462acf6aSTony Nguyen clear_bit(ICE_FLAG_ADV_FEATURES, pf->flags); 4373462acf6aSTony Nguyen return; 4374462acf6aSTony Nguyen } 4375462acf6aSTony Nguyen 4376462acf6aSTony Nguyen /* Successful download package is the precondition for advanced 4377462acf6aSTony Nguyen * features, hence setting the ICE_FLAG_ADV_FEATURES flag 4378462acf6aSTony Nguyen */ 4379462acf6aSTony Nguyen set_bit(ICE_FLAG_ADV_FEATURES, pf->flags); 4380462acf6aSTony Nguyen } 4381462acf6aSTony Nguyen 4382462acf6aSTony Nguyen /** 4383c585ea42SBrett Creeley * ice_verify_cacheline_size - verify driver's assumption of 64 Byte cache lines 4384c585ea42SBrett Creeley * @pf: pointer to the PF structure 4385c585ea42SBrett Creeley * 4386c585ea42SBrett Creeley * There is no error returned here because the driver should be able to handle 4387c585ea42SBrett Creeley * 128 Byte cache lines, so we only print a warning in case issues are seen, 4388c585ea42SBrett Creeley * specifically with Tx. 4389c585ea42SBrett Creeley */ 4390c585ea42SBrett Creeley static void ice_verify_cacheline_size(struct ice_pf *pf) 4391c585ea42SBrett Creeley { 4392c585ea42SBrett Creeley if (rd32(&pf->hw, GLPCI_CNF2) & GLPCI_CNF2_CACHELINE_SIZE_M) 439319cce2c6SAnirudh Venkataramanan dev_warn(ice_pf_to_dev(pf), "%d Byte cache line assumption is invalid, driver may have Tx timeouts!\n", 4394c585ea42SBrett Creeley ICE_CACHE_LINE_BYTES); 4395c585ea42SBrett Creeley } 4396c585ea42SBrett Creeley 4397c585ea42SBrett Creeley /** 4398e3710a01SPaul M Stillwell Jr * ice_send_version - update firmware with driver version 4399e3710a01SPaul M Stillwell Jr * @pf: PF struct 4400e3710a01SPaul M Stillwell Jr * 4401d54699e2STony Nguyen * Returns 0 on success, else error code 4402e3710a01SPaul M Stillwell Jr */ 44035e24d598STony Nguyen static int ice_send_version(struct ice_pf *pf) 4404e3710a01SPaul M Stillwell Jr { 4405e3710a01SPaul M Stillwell Jr struct ice_driver_ver dv; 4406e3710a01SPaul M Stillwell Jr 440734a2a3b8SJeff Kirsher dv.major_ver = 0xff; 440834a2a3b8SJeff Kirsher dv.minor_ver = 0xff; 440934a2a3b8SJeff Kirsher dv.build_ver = 0xff; 4410e3710a01SPaul M Stillwell Jr dv.subbuild_ver = 0; 441134a2a3b8SJeff Kirsher strscpy((char *)dv.driver_string, UTS_RELEASE, 4412e3710a01SPaul M Stillwell Jr sizeof(dv.driver_string)); 4413e3710a01SPaul M Stillwell Jr return ice_aq_send_driver_ver(&pf->hw, &dv, NULL); 4414e3710a01SPaul M Stillwell Jr } 4415e3710a01SPaul M Stillwell Jr 4416e3710a01SPaul M Stillwell Jr /** 4417148beb61SHenry Tieman * ice_init_fdir - Initialize flow director VSI and configuration 4418148beb61SHenry Tieman * @pf: pointer to the PF instance 4419148beb61SHenry Tieman * 4420148beb61SHenry Tieman * returns 0 on success, negative on error 4421148beb61SHenry Tieman */ 4422148beb61SHenry Tieman static int ice_init_fdir(struct ice_pf *pf) 4423148beb61SHenry Tieman { 4424148beb61SHenry Tieman struct device *dev = ice_pf_to_dev(pf); 4425148beb61SHenry Tieman struct ice_vsi *ctrl_vsi; 4426148beb61SHenry Tieman int err; 4427148beb61SHenry Tieman 4428148beb61SHenry Tieman /* Side Band Flow Director needs to have a control VSI. 4429148beb61SHenry Tieman * Allocate it and store it in the PF. 4430148beb61SHenry Tieman */ 4431148beb61SHenry Tieman ctrl_vsi = ice_ctrl_vsi_setup(pf, pf->hw.port_info); 4432148beb61SHenry Tieman if (!ctrl_vsi) { 4433148beb61SHenry Tieman dev_dbg(dev, "could not create control VSI\n"); 4434148beb61SHenry Tieman return -ENOMEM; 4435148beb61SHenry Tieman } 4436148beb61SHenry Tieman 4437148beb61SHenry Tieman err = ice_vsi_open_ctrl(ctrl_vsi); 4438148beb61SHenry Tieman if (err) { 4439148beb61SHenry Tieman dev_dbg(dev, "could not open control VSI\n"); 4440148beb61SHenry Tieman goto err_vsi_open; 4441148beb61SHenry Tieman } 4442148beb61SHenry Tieman 4443148beb61SHenry Tieman mutex_init(&pf->hw.fdir_fltr_lock); 4444148beb61SHenry Tieman 4445148beb61SHenry Tieman err = ice_fdir_create_dflt_rules(pf); 4446148beb61SHenry Tieman if (err) 4447148beb61SHenry Tieman goto err_fdir_rule; 4448148beb61SHenry Tieman 4449148beb61SHenry Tieman return 0; 4450148beb61SHenry Tieman 4451148beb61SHenry Tieman err_fdir_rule: 4452148beb61SHenry Tieman ice_fdir_release_flows(&pf->hw); 4453148beb61SHenry Tieman ice_vsi_close(ctrl_vsi); 4454148beb61SHenry Tieman err_vsi_open: 4455148beb61SHenry Tieman ice_vsi_release(ctrl_vsi); 4456148beb61SHenry Tieman if (pf->ctrl_vsi_idx != ICE_NO_VSI) { 4457148beb61SHenry Tieman pf->vsi[pf->ctrl_vsi_idx] = NULL; 4458148beb61SHenry Tieman pf->ctrl_vsi_idx = ICE_NO_VSI; 4459148beb61SHenry Tieman } 4460148beb61SHenry Tieman return err; 4461148beb61SHenry Tieman } 4462148beb61SHenry Tieman 4463148beb61SHenry Tieman /** 4464462acf6aSTony Nguyen * ice_get_opt_fw_name - return optional firmware file name or NULL 4465462acf6aSTony Nguyen * @pf: pointer to the PF instance 4466462acf6aSTony Nguyen */ 4467462acf6aSTony Nguyen static char *ice_get_opt_fw_name(struct ice_pf *pf) 4468462acf6aSTony Nguyen { 4469462acf6aSTony Nguyen /* Optional firmware name same as default with additional dash 4470462acf6aSTony Nguyen * followed by a EUI-64 identifier (PCIe Device Serial Number) 4471462acf6aSTony Nguyen */ 4472462acf6aSTony Nguyen struct pci_dev *pdev = pf->pdev; 4473ceb2f007SJacob Keller char *opt_fw_filename; 4474ceb2f007SJacob Keller u64 dsn; 4475462acf6aSTony Nguyen 4476462acf6aSTony Nguyen /* Determine the name of the optional file using the DSN (two 4477462acf6aSTony Nguyen * dwords following the start of the DSN Capability). 4478462acf6aSTony Nguyen */ 4479ceb2f007SJacob Keller dsn = pci_get_dsn(pdev); 4480ceb2f007SJacob Keller if (!dsn) 4481ceb2f007SJacob Keller return NULL; 4482ceb2f007SJacob Keller 4483462acf6aSTony Nguyen opt_fw_filename = kzalloc(NAME_MAX, GFP_KERNEL); 4484462acf6aSTony Nguyen if (!opt_fw_filename) 4485462acf6aSTony Nguyen return NULL; 4486462acf6aSTony Nguyen 44871a9c561aSPaul M Stillwell Jr snprintf(opt_fw_filename, NAME_MAX, "%sice-%016llx.pkg", 4488ceb2f007SJacob Keller ICE_DDP_PKG_PATH, dsn); 4489462acf6aSTony Nguyen 4490462acf6aSTony Nguyen return opt_fw_filename; 4491462acf6aSTony Nguyen } 4492462acf6aSTony Nguyen 4493462acf6aSTony Nguyen /** 4494462acf6aSTony Nguyen * ice_request_fw - Device initialization routine 4495462acf6aSTony Nguyen * @pf: pointer to the PF instance 4496462acf6aSTony Nguyen */ 4497462acf6aSTony Nguyen static void ice_request_fw(struct ice_pf *pf) 4498462acf6aSTony Nguyen { 4499462acf6aSTony Nguyen char *opt_fw_filename = ice_get_opt_fw_name(pf); 4500462acf6aSTony Nguyen const struct firmware *firmware = NULL; 45014015d11eSBrett Creeley struct device *dev = ice_pf_to_dev(pf); 4502462acf6aSTony Nguyen int err = 0; 4503462acf6aSTony Nguyen 4504462acf6aSTony Nguyen /* optional device-specific DDP (if present) overrides the default DDP 4505462acf6aSTony Nguyen * package file. kernel logs a debug message if the file doesn't exist, 4506462acf6aSTony Nguyen * and warning messages for other errors. 4507462acf6aSTony Nguyen */ 4508462acf6aSTony Nguyen if (opt_fw_filename) { 4509462acf6aSTony Nguyen err = firmware_request_nowarn(&firmware, opt_fw_filename, dev); 4510462acf6aSTony Nguyen if (err) { 4511462acf6aSTony Nguyen kfree(opt_fw_filename); 4512462acf6aSTony Nguyen goto dflt_pkg_load; 4513462acf6aSTony Nguyen } 4514462acf6aSTony Nguyen 4515462acf6aSTony Nguyen /* request for firmware was successful. Download to device */ 4516462acf6aSTony Nguyen ice_load_pkg(firmware, pf); 4517462acf6aSTony Nguyen kfree(opt_fw_filename); 4518462acf6aSTony Nguyen release_firmware(firmware); 4519462acf6aSTony Nguyen return; 4520462acf6aSTony Nguyen } 4521462acf6aSTony Nguyen 4522462acf6aSTony Nguyen dflt_pkg_load: 4523462acf6aSTony Nguyen err = request_firmware(&firmware, ICE_DDP_PKG_FILE, dev); 4524462acf6aSTony Nguyen if (err) { 452519cce2c6SAnirudh Venkataramanan dev_err(dev, "The DDP package file was not found or could not be read. Entering Safe Mode\n"); 4526462acf6aSTony Nguyen return; 4527462acf6aSTony Nguyen } 4528462acf6aSTony Nguyen 4529462acf6aSTony Nguyen /* request for firmware was successful. Download to device */ 4530462acf6aSTony Nguyen ice_load_pkg(firmware, pf); 4531462acf6aSTony Nguyen release_firmware(firmware); 4532462acf6aSTony Nguyen } 4533462acf6aSTony Nguyen 4534462acf6aSTony Nguyen /** 4535769c500dSAkeem G Abodunrin * ice_print_wake_reason - show the wake up cause in the log 4536769c500dSAkeem G Abodunrin * @pf: pointer to the PF struct 4537769c500dSAkeem G Abodunrin */ 4538769c500dSAkeem G Abodunrin static void ice_print_wake_reason(struct ice_pf *pf) 4539769c500dSAkeem G Abodunrin { 4540769c500dSAkeem G Abodunrin u32 wus = pf->wakeup_reason; 4541769c500dSAkeem G Abodunrin const char *wake_str; 4542769c500dSAkeem G Abodunrin 4543769c500dSAkeem G Abodunrin /* if no wake event, nothing to print */ 4544769c500dSAkeem G Abodunrin if (!wus) 4545769c500dSAkeem G Abodunrin return; 4546769c500dSAkeem G Abodunrin 4547769c500dSAkeem G Abodunrin if (wus & PFPM_WUS_LNKC_M) 4548769c500dSAkeem G Abodunrin wake_str = "Link\n"; 4549769c500dSAkeem G Abodunrin else if (wus & PFPM_WUS_MAG_M) 4550769c500dSAkeem G Abodunrin wake_str = "Magic Packet\n"; 4551769c500dSAkeem G Abodunrin else if (wus & PFPM_WUS_MNG_M) 4552769c500dSAkeem G Abodunrin wake_str = "Management\n"; 4553769c500dSAkeem G Abodunrin else if (wus & PFPM_WUS_FW_RST_WK_M) 4554769c500dSAkeem G Abodunrin wake_str = "Firmware Reset\n"; 4555769c500dSAkeem G Abodunrin else 4556769c500dSAkeem G Abodunrin wake_str = "Unknown\n"; 4557769c500dSAkeem G Abodunrin 4558769c500dSAkeem G Abodunrin dev_info(ice_pf_to_dev(pf), "Wake reason: %s", wake_str); 4559769c500dSAkeem G Abodunrin } 4560769c500dSAkeem G Abodunrin 4561769c500dSAkeem G Abodunrin /** 45621e23f076SAnirudh Venkataramanan * ice_register_netdev - register netdev and devlink port 45631e23f076SAnirudh Venkataramanan * @pf: pointer to the PF struct 45641e23f076SAnirudh Venkataramanan */ 45651e23f076SAnirudh Venkataramanan static int ice_register_netdev(struct ice_pf *pf) 45661e23f076SAnirudh Venkataramanan { 45671e23f076SAnirudh Venkataramanan struct ice_vsi *vsi; 45681e23f076SAnirudh Venkataramanan int err = 0; 45691e23f076SAnirudh Venkataramanan 45701e23f076SAnirudh Venkataramanan vsi = ice_get_main_vsi(pf); 45711e23f076SAnirudh Venkataramanan if (!vsi || !vsi->netdev) 45721e23f076SAnirudh Venkataramanan return -EIO; 45731e23f076SAnirudh Venkataramanan 45741e23f076SAnirudh Venkataramanan err = register_netdev(vsi->netdev); 45751e23f076SAnirudh Venkataramanan if (err) 45761e23f076SAnirudh Venkataramanan goto err_register_netdev; 45771e23f076SAnirudh Venkataramanan 4578a476d72aSAnirudh Venkataramanan set_bit(ICE_VSI_NETDEV_REGISTERED, vsi->state); 45791e23f076SAnirudh Venkataramanan netif_carrier_off(vsi->netdev); 45801e23f076SAnirudh Venkataramanan netif_tx_stop_all_queues(vsi->netdev); 45812ae0aa47SWojciech Drewek err = ice_devlink_create_pf_port(pf); 45821e23f076SAnirudh Venkataramanan if (err) 45831e23f076SAnirudh Venkataramanan goto err_devlink_create; 45841e23f076SAnirudh Venkataramanan 45852ae0aa47SWojciech Drewek devlink_port_type_eth_set(&pf->devlink_port, vsi->netdev); 45861e23f076SAnirudh Venkataramanan 45871e23f076SAnirudh Venkataramanan return 0; 45881e23f076SAnirudh Venkataramanan err_devlink_create: 45891e23f076SAnirudh Venkataramanan unregister_netdev(vsi->netdev); 4590a476d72aSAnirudh Venkataramanan clear_bit(ICE_VSI_NETDEV_REGISTERED, vsi->state); 45911e23f076SAnirudh Venkataramanan err_register_netdev: 45921e23f076SAnirudh Venkataramanan free_netdev(vsi->netdev); 45931e23f076SAnirudh Venkataramanan vsi->netdev = NULL; 4594a476d72aSAnirudh Venkataramanan clear_bit(ICE_VSI_NETDEV_ALLOCD, vsi->state); 45951e23f076SAnirudh Venkataramanan return err; 45961e23f076SAnirudh Venkataramanan } 45971e23f076SAnirudh Venkataramanan 45981e23f076SAnirudh Venkataramanan /** 4599837f08fdSAnirudh Venkataramanan * ice_probe - Device initialization routine 4600837f08fdSAnirudh Venkataramanan * @pdev: PCI device information struct 4601837f08fdSAnirudh Venkataramanan * @ent: entry in ice_pci_tbl 4602837f08fdSAnirudh Venkataramanan * 4603837f08fdSAnirudh Venkataramanan * Returns 0 on success, negative on failure 4604837f08fdSAnirudh Venkataramanan */ 4605c8b7abddSBruce Allan static int 4606c8b7abddSBruce Allan ice_probe(struct pci_dev *pdev, const struct pci_device_id __always_unused *ent) 4607837f08fdSAnirudh Venkataramanan { 460877ed84f4SBruce Allan struct device *dev = &pdev->dev; 4609837f08fdSAnirudh Venkataramanan struct ice_pf *pf; 4610837f08fdSAnirudh Venkataramanan struct ice_hw *hw; 4611b20e6c17SJakub Kicinski int i, err; 4612837f08fdSAnirudh Venkataramanan 461350ac7479SAnirudh Venkataramanan if (pdev->is_virtfn) { 461450ac7479SAnirudh Venkataramanan dev_err(dev, "can't probe a virtual function\n"); 461550ac7479SAnirudh Venkataramanan return -EINVAL; 461650ac7479SAnirudh Venkataramanan } 461750ac7479SAnirudh Venkataramanan 46184ee656bbSTony Nguyen /* this driver uses devres, see 46194ee656bbSTony Nguyen * Documentation/driver-api/driver-model/devres.rst 46204ee656bbSTony Nguyen */ 4621837f08fdSAnirudh Venkataramanan err = pcim_enable_device(pdev); 4622837f08fdSAnirudh Venkataramanan if (err) 4623837f08fdSAnirudh Venkataramanan return err; 4624837f08fdSAnirudh Venkataramanan 462580ad6ddeSJesse Brandeburg err = pcim_iomap_regions(pdev, BIT(ICE_BAR0), dev_driver_string(dev)); 4626837f08fdSAnirudh Venkataramanan if (err) { 462777ed84f4SBruce Allan dev_err(dev, "BAR0 I/O map error %d\n", err); 4628837f08fdSAnirudh Venkataramanan return err; 4629837f08fdSAnirudh Venkataramanan } 4630837f08fdSAnirudh Venkataramanan 46311adf7eadSJacob Keller pf = ice_allocate_pf(dev); 4632837f08fdSAnirudh Venkataramanan if (!pf) 4633837f08fdSAnirudh Venkataramanan return -ENOMEM; 4634837f08fdSAnirudh Venkataramanan 463573e30a62SDave Ertman /* initialize Auxiliary index to invalid value */ 463673e30a62SDave Ertman pf->aux_idx = -1; 463773e30a62SDave Ertman 46382f2da36eSAnirudh Venkataramanan /* set up for high or low DMA */ 463977ed84f4SBruce Allan err = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(64)); 4640837f08fdSAnirudh Venkataramanan if (err) { 464177ed84f4SBruce Allan dev_err(dev, "DMA configuration failed: 0x%x\n", err); 4642837f08fdSAnirudh Venkataramanan return err; 4643837f08fdSAnirudh Venkataramanan } 4644837f08fdSAnirudh Venkataramanan 4645837f08fdSAnirudh Venkataramanan pci_enable_pcie_error_reporting(pdev); 4646837f08fdSAnirudh Venkataramanan pci_set_master(pdev); 4647837f08fdSAnirudh Venkataramanan 4648837f08fdSAnirudh Venkataramanan pf->pdev = pdev; 4649837f08fdSAnirudh Venkataramanan pci_set_drvdata(pdev, pf); 46507e408e07SAnirudh Venkataramanan set_bit(ICE_DOWN, pf->state); 46518d81fa55SAkeem G Abodunrin /* Disable service task until DOWN bit is cleared */ 46527e408e07SAnirudh Venkataramanan set_bit(ICE_SERVICE_DIS, pf->state); 4653837f08fdSAnirudh Venkataramanan 4654837f08fdSAnirudh Venkataramanan hw = &pf->hw; 4655837f08fdSAnirudh Venkataramanan hw->hw_addr = pcim_iomap_table(pdev)[ICE_BAR0]; 46564e56802eSMichal Swiatkowski pci_save_state(pdev); 46574e56802eSMichal Swiatkowski 4658837f08fdSAnirudh Venkataramanan hw->back = pf; 4659837f08fdSAnirudh Venkataramanan hw->vendor_id = pdev->vendor; 4660837f08fdSAnirudh Venkataramanan hw->device_id = pdev->device; 4661837f08fdSAnirudh Venkataramanan pci_read_config_byte(pdev, PCI_REVISION_ID, &hw->revision_id); 4662837f08fdSAnirudh Venkataramanan hw->subsystem_vendor_id = pdev->subsystem_vendor; 4663837f08fdSAnirudh Venkataramanan hw->subsystem_device_id = pdev->subsystem_device; 4664837f08fdSAnirudh Venkataramanan hw->bus.device = PCI_SLOT(pdev->devfn); 4665837f08fdSAnirudh Venkataramanan hw->bus.func = PCI_FUNC(pdev->devfn); 4666f31e4b6fSAnirudh Venkataramanan ice_set_ctrlq_len(hw); 4667f31e4b6fSAnirudh Venkataramanan 4668837f08fdSAnirudh Venkataramanan pf->msg_enable = netif_msg_init(debug, ICE_DFLT_NETIF_M); 4669837f08fdSAnirudh Venkataramanan 46707ec59eeaSAnirudh Venkataramanan #ifndef CONFIG_DYNAMIC_DEBUG 46717ec59eeaSAnirudh Venkataramanan if (debug < -1) 46727ec59eeaSAnirudh Venkataramanan hw->debug_mask = debug; 46737ec59eeaSAnirudh Venkataramanan #endif 46747ec59eeaSAnirudh Venkataramanan 4675f31e4b6fSAnirudh Venkataramanan err = ice_init_hw(hw); 4676f31e4b6fSAnirudh Venkataramanan if (err) { 467777ed84f4SBruce Allan dev_err(dev, "ice_init_hw failed: %d\n", err); 4678f31e4b6fSAnirudh Venkataramanan err = -EIO; 4679f31e4b6fSAnirudh Venkataramanan goto err_exit_unroll; 4680f31e4b6fSAnirudh Venkataramanan } 4681f31e4b6fSAnirudh Venkataramanan 468240b24760SAnirudh Venkataramanan ice_init_feature_support(pf); 468340b24760SAnirudh Venkataramanan 4684462acf6aSTony Nguyen ice_request_fw(pf); 4685462acf6aSTony Nguyen 4686462acf6aSTony Nguyen /* if ice_request_fw fails, ICE_FLAG_ADV_FEATURES bit won't be 4687462acf6aSTony Nguyen * set in pf->state, which will cause ice_is_safe_mode to return 4688462acf6aSTony Nguyen * true 4689462acf6aSTony Nguyen */ 4690462acf6aSTony Nguyen if (ice_is_safe_mode(pf)) { 4691462acf6aSTony Nguyen /* we already got function/device capabilities but these don't 4692462acf6aSTony Nguyen * reflect what the driver needs to do in safe mode. Instead of 4693462acf6aSTony Nguyen * adding conditional logic everywhere to ignore these 4694462acf6aSTony Nguyen * device/function capabilities, override them. 4695462acf6aSTony Nguyen */ 4696462acf6aSTony Nguyen ice_set_safe_mode_caps(hw); 4697462acf6aSTony Nguyen } 4698462acf6aSTony Nguyen 469978b5713aSAnirudh Venkataramanan err = ice_init_pf(pf); 470078b5713aSAnirudh Venkataramanan if (err) { 470178b5713aSAnirudh Venkataramanan dev_err(dev, "ice_init_pf failed: %d\n", err); 470278b5713aSAnirudh Venkataramanan goto err_init_pf_unroll; 470378b5713aSAnirudh Venkataramanan } 4704940b61afSAnirudh Venkataramanan 4705dce730f1SJacob Keller ice_devlink_init_regions(pf); 4706dce730f1SJacob Keller 4707b20e6c17SJakub Kicinski pf->hw.udp_tunnel_nic.set_port = ice_udp_tunnel_set_port; 4708b20e6c17SJakub Kicinski pf->hw.udp_tunnel_nic.unset_port = ice_udp_tunnel_unset_port; 4709b20e6c17SJakub Kicinski pf->hw.udp_tunnel_nic.flags = UDP_TUNNEL_NIC_INFO_MAY_SLEEP; 4710b20e6c17SJakub Kicinski pf->hw.udp_tunnel_nic.shared = &pf->hw.udp_tunnel_shared; 4711b20e6c17SJakub Kicinski i = 0; 4712b20e6c17SJakub Kicinski if (pf->hw.tnl.valid_count[TNL_VXLAN]) { 4713b20e6c17SJakub Kicinski pf->hw.udp_tunnel_nic.tables[i].n_entries = 4714b20e6c17SJakub Kicinski pf->hw.tnl.valid_count[TNL_VXLAN]; 4715b20e6c17SJakub Kicinski pf->hw.udp_tunnel_nic.tables[i].tunnel_types = 4716b20e6c17SJakub Kicinski UDP_TUNNEL_TYPE_VXLAN; 4717b20e6c17SJakub Kicinski i++; 4718b20e6c17SJakub Kicinski } 4719b20e6c17SJakub Kicinski if (pf->hw.tnl.valid_count[TNL_GENEVE]) { 4720b20e6c17SJakub Kicinski pf->hw.udp_tunnel_nic.tables[i].n_entries = 4721b20e6c17SJakub Kicinski pf->hw.tnl.valid_count[TNL_GENEVE]; 4722b20e6c17SJakub Kicinski pf->hw.udp_tunnel_nic.tables[i].tunnel_types = 4723b20e6c17SJakub Kicinski UDP_TUNNEL_TYPE_GENEVE; 4724b20e6c17SJakub Kicinski i++; 4725b20e6c17SJakub Kicinski } 4726b20e6c17SJakub Kicinski 4727995c90f2SAnirudh Venkataramanan pf->num_alloc_vsi = hw->func_caps.guar_num_vsi; 4728940b61afSAnirudh Venkataramanan if (!pf->num_alloc_vsi) { 4729940b61afSAnirudh Venkataramanan err = -EIO; 4730940b61afSAnirudh Venkataramanan goto err_init_pf_unroll; 4731940b61afSAnirudh Venkataramanan } 4732b20e6c17SJakub Kicinski if (pf->num_alloc_vsi > UDP_TUNNEL_NIC_MAX_SHARING_DEVICES) { 4733b20e6c17SJakub Kicinski dev_warn(&pf->pdev->dev, 4734b20e6c17SJakub Kicinski "limiting the VSI count due to UDP tunnel limitation %d > %d\n", 4735b20e6c17SJakub Kicinski pf->num_alloc_vsi, UDP_TUNNEL_NIC_MAX_SHARING_DEVICES); 4736b20e6c17SJakub Kicinski pf->num_alloc_vsi = UDP_TUNNEL_NIC_MAX_SHARING_DEVICES; 4737b20e6c17SJakub Kicinski } 4738940b61afSAnirudh Venkataramanan 473977ed84f4SBruce Allan pf->vsi = devm_kcalloc(dev, pf->num_alloc_vsi, sizeof(*pf->vsi), 474077ed84f4SBruce Allan GFP_KERNEL); 4741940b61afSAnirudh Venkataramanan if (!pf->vsi) { 4742940b61afSAnirudh Venkataramanan err = -ENOMEM; 4743940b61afSAnirudh Venkataramanan goto err_init_pf_unroll; 4744940b61afSAnirudh Venkataramanan } 4745940b61afSAnirudh Venkataramanan 4746940b61afSAnirudh Venkataramanan err = ice_init_interrupt_scheme(pf); 4747940b61afSAnirudh Venkataramanan if (err) { 474877ed84f4SBruce Allan dev_err(dev, "ice_init_interrupt_scheme failed: %d\n", err); 4749940b61afSAnirudh Venkataramanan err = -EIO; 4750bc3a0241SJacob Keller goto err_init_vsi_unroll; 4751940b61afSAnirudh Venkataramanan } 4752940b61afSAnirudh Venkataramanan 4753940b61afSAnirudh Venkataramanan /* In case of MSIX we are going to setup the misc vector right here 4754940b61afSAnirudh Venkataramanan * to handle admin queue events etc. In case of legacy and MSI 4755940b61afSAnirudh Venkataramanan * the misc functionality and queue processing is combined in 4756940b61afSAnirudh Venkataramanan * the same vector and that gets setup at open. 4757940b61afSAnirudh Venkataramanan */ 4758940b61afSAnirudh Venkataramanan err = ice_req_irq_msix_misc(pf); 4759940b61afSAnirudh Venkataramanan if (err) { 476077ed84f4SBruce Allan dev_err(dev, "setup of misc vector failed: %d\n", err); 4761940b61afSAnirudh Venkataramanan goto err_init_interrupt_unroll; 4762940b61afSAnirudh Venkataramanan } 4763940b61afSAnirudh Venkataramanan 4764940b61afSAnirudh Venkataramanan /* create switch struct for the switch element created by FW on boot */ 476577ed84f4SBruce Allan pf->first_sw = devm_kzalloc(dev, sizeof(*pf->first_sw), GFP_KERNEL); 4766940b61afSAnirudh Venkataramanan if (!pf->first_sw) { 4767940b61afSAnirudh Venkataramanan err = -ENOMEM; 4768940b61afSAnirudh Venkataramanan goto err_msix_misc_unroll; 4769940b61afSAnirudh Venkataramanan } 4770940b61afSAnirudh Venkataramanan 4771b1edc14aSMd Fahad Iqbal Polash if (hw->evb_veb) 4772940b61afSAnirudh Venkataramanan pf->first_sw->bridge_mode = BRIDGE_MODE_VEB; 4773b1edc14aSMd Fahad Iqbal Polash else 4774b1edc14aSMd Fahad Iqbal Polash pf->first_sw->bridge_mode = BRIDGE_MODE_VEPA; 4775b1edc14aSMd Fahad Iqbal Polash 4776940b61afSAnirudh Venkataramanan pf->first_sw->pf = pf; 4777940b61afSAnirudh Venkataramanan 4778940b61afSAnirudh Venkataramanan /* record the sw_id available for later use */ 4779940b61afSAnirudh Venkataramanan pf->first_sw->sw_id = hw->port_info->sw_id; 4780940b61afSAnirudh Venkataramanan 47813a858ba3SAnirudh Venkataramanan err = ice_setup_pf_sw(pf); 47823a858ba3SAnirudh Venkataramanan if (err) { 47832f2da36eSAnirudh Venkataramanan dev_err(dev, "probe failed due to setup PF switch: %d\n", err); 47843a858ba3SAnirudh Venkataramanan goto err_alloc_sw_unroll; 47853a858ba3SAnirudh Venkataramanan } 47869daf8208SAnirudh Venkataramanan 47877e408e07SAnirudh Venkataramanan clear_bit(ICE_SERVICE_DIS, pf->state); 47889daf8208SAnirudh Venkataramanan 4789e3710a01SPaul M Stillwell Jr /* tell the firmware we are up */ 4790e3710a01SPaul M Stillwell Jr err = ice_send_version(pf); 4791e3710a01SPaul M Stillwell Jr if (err) { 479219cce2c6SAnirudh Venkataramanan dev_err(dev, "probe failed sending driver version %s. error: %d\n", 479334a2a3b8SJeff Kirsher UTS_RELEASE, err); 479478116e97SMarcin Szycik goto err_send_version_unroll; 4795e3710a01SPaul M Stillwell Jr } 4796e3710a01SPaul M Stillwell Jr 47979daf8208SAnirudh Venkataramanan /* since everything is good, start the service timer */ 47989daf8208SAnirudh Venkataramanan mod_timer(&pf->serv_tmr, round_jiffies(jiffies + pf->serv_tmr_period)); 47999daf8208SAnirudh Venkataramanan 4800250c3b3eSBrett Creeley err = ice_init_link_events(pf->hw.port_info); 4801250c3b3eSBrett Creeley if (err) { 4802250c3b3eSBrett Creeley dev_err(dev, "ice_init_link_events failed: %d\n", err); 480378116e97SMarcin Szycik goto err_send_version_unroll; 4804250c3b3eSBrett Creeley } 4805250c3b3eSBrett Creeley 480608771bceSAnirudh Venkataramanan /* not a fatal error if this fails */ 48071a3571b5SPaul Greenwalt err = ice_init_nvm_phy_type(pf->hw.port_info); 480808771bceSAnirudh Venkataramanan if (err) 48091a3571b5SPaul Greenwalt dev_err(dev, "ice_init_nvm_phy_type failed: %d\n", err); 48101a3571b5SPaul Greenwalt 481108771bceSAnirudh Venkataramanan /* not a fatal error if this fails */ 48121a3571b5SPaul Greenwalt err = ice_update_link_info(pf->hw.port_info); 481308771bceSAnirudh Venkataramanan if (err) 48141a3571b5SPaul Greenwalt dev_err(dev, "ice_update_link_info failed: %d\n", err); 48151a3571b5SPaul Greenwalt 4816ea78ce4dSPaul Greenwalt ice_init_link_dflt_override(pf->hw.port_info); 4817ea78ce4dSPaul Greenwalt 481899d40752SBrett Creeley ice_check_link_cfg_err(pf, 481999d40752SBrett Creeley pf->hw.port_info->phy.link_info.link_cfg_err); 4820c77849f5SAnirudh Venkataramanan 48211a3571b5SPaul Greenwalt /* if media available, initialize PHY settings */ 48221a3571b5SPaul Greenwalt if (pf->hw.port_info->phy.link_info.link_info & 48231a3571b5SPaul Greenwalt ICE_AQ_MEDIA_AVAILABLE) { 482408771bceSAnirudh Venkataramanan /* not a fatal error if this fails */ 48251a3571b5SPaul Greenwalt err = ice_init_phy_user_cfg(pf->hw.port_info); 482608771bceSAnirudh Venkataramanan if (err) 48271a3571b5SPaul Greenwalt dev_err(dev, "ice_init_phy_user_cfg failed: %d\n", err); 48281a3571b5SPaul Greenwalt 48291a3571b5SPaul Greenwalt if (!test_bit(ICE_FLAG_LINK_DOWN_ON_CLOSE_ENA, pf->flags)) { 48301a3571b5SPaul Greenwalt struct ice_vsi *vsi = ice_get_main_vsi(pf); 48311a3571b5SPaul Greenwalt 48321a3571b5SPaul Greenwalt if (vsi) 48331a3571b5SPaul Greenwalt ice_configure_phy(vsi); 48341a3571b5SPaul Greenwalt } 48351a3571b5SPaul Greenwalt } else { 48361a3571b5SPaul Greenwalt set_bit(ICE_FLAG_NO_MEDIA, pf->flags); 48371a3571b5SPaul Greenwalt } 48381a3571b5SPaul Greenwalt 4839c585ea42SBrett Creeley ice_verify_cacheline_size(pf); 4840c585ea42SBrett Creeley 4841769c500dSAkeem G Abodunrin /* Save wakeup reason register for later use */ 4842769c500dSAkeem G Abodunrin pf->wakeup_reason = rd32(hw, PFPM_WUS); 4843769c500dSAkeem G Abodunrin 4844769c500dSAkeem G Abodunrin /* check for a power management event */ 4845769c500dSAkeem G Abodunrin ice_print_wake_reason(pf); 4846769c500dSAkeem G Abodunrin 4847769c500dSAkeem G Abodunrin /* clear wake status, all bits */ 4848769c500dSAkeem G Abodunrin wr32(hw, PFPM_WUS, U32_MAX); 4849769c500dSAkeem G Abodunrin 4850769c500dSAkeem G Abodunrin /* Disable WoL at init, wait for user to enable */ 4851769c500dSAkeem G Abodunrin device_set_wakeup_enable(dev, false); 4852769c500dSAkeem G Abodunrin 4853cd1f56f4SBrett Creeley if (ice_is_safe_mode(pf)) { 4854cd1f56f4SBrett Creeley ice_set_safe_mode_vlan_cfg(pf); 4855de75135bSAnirudh Venkataramanan goto probe_done; 4856cd1f56f4SBrett Creeley } 4857462acf6aSTony Nguyen 4858462acf6aSTony Nguyen /* initialize DDP driven features */ 485906c16d89SJacob Keller if (test_bit(ICE_FLAG_PTP_SUPPORTED, pf->flags)) 486006c16d89SJacob Keller ice_ptp_init(pf); 4861462acf6aSTony Nguyen 486243113ff7SKarol Kolacinski if (ice_is_feature_supported(pf, ICE_F_GNSS)) 486343113ff7SKarol Kolacinski ice_gnss_init(pf); 486443113ff7SKarol Kolacinski 4865148beb61SHenry Tieman /* Note: Flow director init failure is non-fatal to load */ 4866148beb61SHenry Tieman if (ice_init_fdir(pf)) 4867148beb61SHenry Tieman dev_err(dev, "could not initialize flow director\n"); 4868148beb61SHenry Tieman 4869462acf6aSTony Nguyen /* Note: DCB init failure is non-fatal to load */ 4870462acf6aSTony Nguyen if (ice_init_pf_dcb(pf, false)) { 4871462acf6aSTony Nguyen clear_bit(ICE_FLAG_DCB_CAPABLE, pf->flags); 4872462acf6aSTony Nguyen clear_bit(ICE_FLAG_DCB_ENA, pf->flags); 4873462acf6aSTony Nguyen } else { 4874462acf6aSTony Nguyen ice_cfg_lldp_mib_change(&pf->hw, true); 4875462acf6aSTony Nguyen } 4876462acf6aSTony Nguyen 4877df006dd4SDave Ertman if (ice_init_lag(pf)) 4878df006dd4SDave Ertman dev_warn(dev, "Failed to init link aggregation support\n"); 4879df006dd4SDave Ertman 4880e18ff118SPaul Greenwalt /* print PCI link speed and width */ 4881e18ff118SPaul Greenwalt pcie_print_link_status(pf->pdev); 4882e18ff118SPaul Greenwalt 4883de75135bSAnirudh Venkataramanan probe_done: 48841e23f076SAnirudh Venkataramanan err = ice_register_netdev(pf); 48851e23f076SAnirudh Venkataramanan if (err) 48861e23f076SAnirudh Venkataramanan goto err_netdev_reg; 48871e23f076SAnirudh Venkataramanan 4888e523af4eSShiraz Saleem err = ice_devlink_register_params(pf); 4889e523af4eSShiraz Saleem if (err) 4890e523af4eSShiraz Saleem goto err_netdev_reg; 4891e523af4eSShiraz Saleem 4892de75135bSAnirudh Venkataramanan /* ready to go, so clear down state bit */ 48937e408e07SAnirudh Venkataramanan clear_bit(ICE_DOWN, pf->state); 489488f62aeaSDave Ertman if (ice_is_rdma_ena(pf)) { 4895d25a0fc4SDave Ertman pf->aux_idx = ida_alloc(&ice_aux_ida, GFP_KERNEL); 4896d25a0fc4SDave Ertman if (pf->aux_idx < 0) { 4897d25a0fc4SDave Ertman dev_err(dev, "Failed to allocate device ID for AUX driver\n"); 4898d25a0fc4SDave Ertman err = -ENOMEM; 4899e523af4eSShiraz Saleem goto err_devlink_reg_param; 4900d25a0fc4SDave Ertman } 4901d25a0fc4SDave Ertman 4902d25a0fc4SDave Ertman err = ice_init_rdma(pf); 4903d25a0fc4SDave Ertman if (err) { 4904d25a0fc4SDave Ertman dev_err(dev, "Failed to initialize RDMA: %d\n", err); 4905d25a0fc4SDave Ertman err = -EIO; 4906d25a0fc4SDave Ertman goto err_init_aux_unroll; 4907d25a0fc4SDave Ertman } 4908d25a0fc4SDave Ertman } else { 4909d25a0fc4SDave Ertman dev_warn(dev, "RDMA is not supported on this device\n"); 4910d25a0fc4SDave Ertman } 4911d25a0fc4SDave Ertman 4912838cefd5SLeon Romanovsky ice_devlink_register(pf); 4913837f08fdSAnirudh Venkataramanan return 0; 4914f31e4b6fSAnirudh Venkataramanan 4915d25a0fc4SDave Ertman err_init_aux_unroll: 4916d25a0fc4SDave Ertman pf->adev = NULL; 4917d25a0fc4SDave Ertman ida_free(&ice_aux_ida, pf->aux_idx); 4918e523af4eSShiraz Saleem err_devlink_reg_param: 4919e523af4eSShiraz Saleem ice_devlink_unregister_params(pf); 49201e23f076SAnirudh Venkataramanan err_netdev_reg: 492178116e97SMarcin Szycik err_send_version_unroll: 492278116e97SMarcin Szycik ice_vsi_release_all(pf); 49233a858ba3SAnirudh Venkataramanan err_alloc_sw_unroll: 49247e408e07SAnirudh Venkataramanan set_bit(ICE_SERVICE_DIS, pf->state); 49257e408e07SAnirudh Venkataramanan set_bit(ICE_DOWN, pf->state); 49264015d11eSBrett Creeley devm_kfree(dev, pf->first_sw); 4927940b61afSAnirudh Venkataramanan err_msix_misc_unroll: 4928940b61afSAnirudh Venkataramanan ice_free_irq_msix_misc(pf); 4929940b61afSAnirudh Venkataramanan err_init_interrupt_unroll: 4930940b61afSAnirudh Venkataramanan ice_clear_interrupt_scheme(pf); 4931bc3a0241SJacob Keller err_init_vsi_unroll: 493277ed84f4SBruce Allan devm_kfree(dev, pf->vsi); 4933940b61afSAnirudh Venkataramanan err_init_pf_unroll: 4934940b61afSAnirudh Venkataramanan ice_deinit_pf(pf); 4935dce730f1SJacob Keller ice_devlink_destroy_regions(pf); 4936940b61afSAnirudh Venkataramanan ice_deinit_hw(hw); 4937f31e4b6fSAnirudh Venkataramanan err_exit_unroll: 4938f31e4b6fSAnirudh Venkataramanan pci_disable_pcie_error_reporting(pdev); 4939769c500dSAkeem G Abodunrin pci_disable_device(pdev); 4940f31e4b6fSAnirudh Venkataramanan return err; 4941837f08fdSAnirudh Venkataramanan } 4942837f08fdSAnirudh Venkataramanan 4943837f08fdSAnirudh Venkataramanan /** 4944769c500dSAkeem G Abodunrin * ice_set_wake - enable or disable Wake on LAN 4945769c500dSAkeem G Abodunrin * @pf: pointer to the PF struct 4946769c500dSAkeem G Abodunrin * 4947769c500dSAkeem G Abodunrin * Simple helper for WoL control 4948769c500dSAkeem G Abodunrin */ 4949769c500dSAkeem G Abodunrin static void ice_set_wake(struct ice_pf *pf) 4950769c500dSAkeem G Abodunrin { 4951769c500dSAkeem G Abodunrin struct ice_hw *hw = &pf->hw; 4952769c500dSAkeem G Abodunrin bool wol = pf->wol_ena; 4953769c500dSAkeem G Abodunrin 4954769c500dSAkeem G Abodunrin /* clear wake state, otherwise new wake events won't fire */ 4955769c500dSAkeem G Abodunrin wr32(hw, PFPM_WUS, U32_MAX); 4956769c500dSAkeem G Abodunrin 4957769c500dSAkeem G Abodunrin /* enable / disable APM wake up, no RMW needed */ 4958769c500dSAkeem G Abodunrin wr32(hw, PFPM_APM, wol ? PFPM_APM_APME_M : 0); 4959769c500dSAkeem G Abodunrin 4960769c500dSAkeem G Abodunrin /* set magic packet filter enabled */ 4961769c500dSAkeem G Abodunrin wr32(hw, PFPM_WUFC, wol ? PFPM_WUFC_MAG_M : 0); 4962769c500dSAkeem G Abodunrin } 4963769c500dSAkeem G Abodunrin 4964769c500dSAkeem G Abodunrin /** 4965ef860480STony Nguyen * ice_setup_mc_magic_wake - setup device to wake on multicast magic packet 4966769c500dSAkeem G Abodunrin * @pf: pointer to the PF struct 4967769c500dSAkeem G Abodunrin * 4968769c500dSAkeem G Abodunrin * Issue firmware command to enable multicast magic wake, making 4969769c500dSAkeem G Abodunrin * sure that any locally administered address (LAA) is used for 4970769c500dSAkeem G Abodunrin * wake, and that PF reset doesn't undo the LAA. 4971769c500dSAkeem G Abodunrin */ 4972769c500dSAkeem G Abodunrin static void ice_setup_mc_magic_wake(struct ice_pf *pf) 4973769c500dSAkeem G Abodunrin { 4974769c500dSAkeem G Abodunrin struct device *dev = ice_pf_to_dev(pf); 4975769c500dSAkeem G Abodunrin struct ice_hw *hw = &pf->hw; 4976769c500dSAkeem G Abodunrin u8 mac_addr[ETH_ALEN]; 4977769c500dSAkeem G Abodunrin struct ice_vsi *vsi; 49785518ac2aSTony Nguyen int status; 4979769c500dSAkeem G Abodunrin u8 flags; 4980769c500dSAkeem G Abodunrin 4981769c500dSAkeem G Abodunrin if (!pf->wol_ena) 4982769c500dSAkeem G Abodunrin return; 4983769c500dSAkeem G Abodunrin 4984769c500dSAkeem G Abodunrin vsi = ice_get_main_vsi(pf); 4985769c500dSAkeem G Abodunrin if (!vsi) 4986769c500dSAkeem G Abodunrin return; 4987769c500dSAkeem G Abodunrin 4988769c500dSAkeem G Abodunrin /* Get current MAC address in case it's an LAA */ 4989769c500dSAkeem G Abodunrin if (vsi->netdev) 4990769c500dSAkeem G Abodunrin ether_addr_copy(mac_addr, vsi->netdev->dev_addr); 4991769c500dSAkeem G Abodunrin else 4992769c500dSAkeem G Abodunrin ether_addr_copy(mac_addr, vsi->port_info->mac.perm_addr); 4993769c500dSAkeem G Abodunrin 4994769c500dSAkeem G Abodunrin flags = ICE_AQC_MAN_MAC_WR_MC_MAG_EN | 4995769c500dSAkeem G Abodunrin ICE_AQC_MAN_MAC_UPDATE_LAA_WOL | 4996769c500dSAkeem G Abodunrin ICE_AQC_MAN_MAC_WR_WOL_LAA_PFR_KEEP; 4997769c500dSAkeem G Abodunrin 4998769c500dSAkeem G Abodunrin status = ice_aq_manage_mac_write(hw, mac_addr, flags, NULL); 4999769c500dSAkeem G Abodunrin if (status) 50005f87ec48STony Nguyen dev_err(dev, "Failed to enable Multicast Magic Packet wake, err %d aq_err %s\n", 50015518ac2aSTony Nguyen status, ice_aq_str(hw->adminq.sq_last_status)); 5002769c500dSAkeem G Abodunrin } 5003769c500dSAkeem G Abodunrin 5004769c500dSAkeem G Abodunrin /** 5005837f08fdSAnirudh Venkataramanan * ice_remove - Device removal routine 5006837f08fdSAnirudh Venkataramanan * @pdev: PCI device information struct 5007837f08fdSAnirudh Venkataramanan */ 5008837f08fdSAnirudh Venkataramanan static void ice_remove(struct pci_dev *pdev) 5009837f08fdSAnirudh Venkataramanan { 5010837f08fdSAnirudh Venkataramanan struct ice_pf *pf = pci_get_drvdata(pdev); 501181b23589SDave Ertman int i; 5012837f08fdSAnirudh Venkataramanan 5013838cefd5SLeon Romanovsky ice_devlink_unregister(pf); 5014afd9d4abSAnirudh Venkataramanan for (i = 0; i < ICE_MAX_RESET_WAIT; i++) { 5015afd9d4abSAnirudh Venkataramanan if (!ice_is_reset_in_progress(pf->state)) 5016afd9d4abSAnirudh Venkataramanan break; 5017afd9d4abSAnirudh Venkataramanan msleep(100); 5018afd9d4abSAnirudh Venkataramanan } 5019afd9d4abSAnirudh Venkataramanan 5020195bb48fSMichal Swiatkowski ice_tc_indir_block_remove(pf); 5021195bb48fSMichal Swiatkowski 5022f844d521SBrett Creeley if (test_bit(ICE_FLAG_SRIOV_ENA, pf->flags)) { 50237e408e07SAnirudh Venkataramanan set_bit(ICE_VF_RESETS_DISABLED, pf->state); 5024f844d521SBrett Creeley ice_free_vfs(pf); 5025f844d521SBrett Creeley } 5026f844d521SBrett Creeley 50278d81fa55SAkeem G Abodunrin ice_service_task_stop(pf); 5028f31e4b6fSAnirudh Venkataramanan 5029d69ea414SJacob Keller ice_aq_cancel_waiting_tasks(pf); 5030f9f5301eSDave Ertman ice_unplug_aux_dev(pf); 503173e30a62SDave Ertman if (pf->aux_idx >= 0) 5032d25a0fc4SDave Ertman ida_free(&ice_aux_ida, pf->aux_idx); 5033e523af4eSShiraz Saleem ice_devlink_unregister_params(pf); 5034f9f5301eSDave Ertman set_bit(ICE_DOWN, pf->state); 5035d69ea414SJacob Keller 5036df006dd4SDave Ertman ice_deinit_lag(pf); 503706c16d89SJacob Keller if (test_bit(ICE_FLAG_PTP_SUPPORTED, pf->flags)) 503806c16d89SJacob Keller ice_ptp_release(pf); 503943113ff7SKarol Kolacinski if (ice_is_feature_supported(pf, ICE_F_GNSS)) 504043113ff7SKarol Kolacinski ice_gnss_exit(pf); 504128bf2672SBrett Creeley if (!ice_is_safe_mode(pf)) 504228bf2672SBrett Creeley ice_remove_arfs(pf); 5043769c500dSAkeem G Abodunrin ice_setup_mc_magic_wake(pf); 50440f9d5027SAnirudh Venkataramanan ice_vsi_release_all(pf); 50451b4ae7d9SSudheer Mogilappagari mutex_destroy(&(&pf->hw)->fdir_fltr_lock); 5046769c500dSAkeem G Abodunrin ice_set_wake(pf); 5047940b61afSAnirudh Venkataramanan ice_free_irq_msix_misc(pf); 504881b23589SDave Ertman ice_for_each_vsi(pf, i) { 504981b23589SDave Ertman if (!pf->vsi[i]) 505081b23589SDave Ertman continue; 505181b23589SDave Ertman ice_vsi_free_q_vectors(pf->vsi[i]); 505281b23589SDave Ertman } 5053940b61afSAnirudh Venkataramanan ice_deinit_pf(pf); 5054dce730f1SJacob Keller ice_devlink_destroy_regions(pf); 5055f31e4b6fSAnirudh Venkataramanan ice_deinit_hw(&pf->hw); 50561adf7eadSJacob Keller 505718057cb3SBruce Allan /* Issue a PFR as part of the prescribed driver unload flow. Do not 505818057cb3SBruce Allan * do it via ice_schedule_reset() since there is no need to rebuild 505918057cb3SBruce Allan * and the service task is already stopped. 506018057cb3SBruce Allan */ 506118057cb3SBruce Allan ice_reset(&pf->hw, ICE_RESET_PFR); 5062c6012ac1SBruce Allan pci_wait_for_pending_transaction(pdev); 5063c6012ac1SBruce Allan ice_clear_interrupt_scheme(pf); 5064837f08fdSAnirudh Venkataramanan pci_disable_pcie_error_reporting(pdev); 5065769c500dSAkeem G Abodunrin pci_disable_device(pdev); 5066837f08fdSAnirudh Venkataramanan } 5067837f08fdSAnirudh Venkataramanan 50685995b6d0SBrett Creeley /** 5069769c500dSAkeem G Abodunrin * ice_shutdown - PCI callback for shutting down device 5070769c500dSAkeem G Abodunrin * @pdev: PCI device information struct 5071769c500dSAkeem G Abodunrin */ 5072769c500dSAkeem G Abodunrin static void ice_shutdown(struct pci_dev *pdev) 5073769c500dSAkeem G Abodunrin { 5074769c500dSAkeem G Abodunrin struct ice_pf *pf = pci_get_drvdata(pdev); 5075769c500dSAkeem G Abodunrin 5076769c500dSAkeem G Abodunrin ice_remove(pdev); 5077769c500dSAkeem G Abodunrin 5078769c500dSAkeem G Abodunrin if (system_state == SYSTEM_POWER_OFF) { 5079769c500dSAkeem G Abodunrin pci_wake_from_d3(pdev, pf->wol_ena); 5080769c500dSAkeem G Abodunrin pci_set_power_state(pdev, PCI_D3hot); 5081769c500dSAkeem G Abodunrin } 5082769c500dSAkeem G Abodunrin } 5083769c500dSAkeem G Abodunrin 5084769c500dSAkeem G Abodunrin #ifdef CONFIG_PM 5085769c500dSAkeem G Abodunrin /** 5086769c500dSAkeem G Abodunrin * ice_prepare_for_shutdown - prep for PCI shutdown 5087769c500dSAkeem G Abodunrin * @pf: board private structure 5088769c500dSAkeem G Abodunrin * 5089769c500dSAkeem G Abodunrin * Inform or close all dependent features in prep for PCI device shutdown 5090769c500dSAkeem G Abodunrin */ 5091769c500dSAkeem G Abodunrin static void ice_prepare_for_shutdown(struct ice_pf *pf) 5092769c500dSAkeem G Abodunrin { 5093769c500dSAkeem G Abodunrin struct ice_hw *hw = &pf->hw; 5094769c500dSAkeem G Abodunrin u32 v; 5095769c500dSAkeem G Abodunrin 5096769c500dSAkeem G Abodunrin /* Notify VFs of impending reset */ 5097769c500dSAkeem G Abodunrin if (ice_check_sq_alive(hw, &hw->mailboxq)) 5098769c500dSAkeem G Abodunrin ice_vc_notify_reset(pf); 5099769c500dSAkeem G Abodunrin 5100769c500dSAkeem G Abodunrin dev_dbg(ice_pf_to_dev(pf), "Tearing down internal switch for shutdown\n"); 5101769c500dSAkeem G Abodunrin 5102769c500dSAkeem G Abodunrin /* disable the VSIs and their queues that are not already DOWN */ 5103769c500dSAkeem G Abodunrin ice_pf_dis_all_vsi(pf, false); 5104769c500dSAkeem G Abodunrin 5105769c500dSAkeem G Abodunrin ice_for_each_vsi(pf, v) 5106769c500dSAkeem G Abodunrin if (pf->vsi[v]) 5107769c500dSAkeem G Abodunrin pf->vsi[v]->vsi_num = 0; 5108769c500dSAkeem G Abodunrin 5109769c500dSAkeem G Abodunrin ice_shutdown_all_ctrlq(hw); 5110769c500dSAkeem G Abodunrin } 5111769c500dSAkeem G Abodunrin 5112769c500dSAkeem G Abodunrin /** 5113769c500dSAkeem G Abodunrin * ice_reinit_interrupt_scheme - Reinitialize interrupt scheme 5114769c500dSAkeem G Abodunrin * @pf: board private structure to reinitialize 5115769c500dSAkeem G Abodunrin * 5116769c500dSAkeem G Abodunrin * This routine reinitialize interrupt scheme that was cleared during 5117769c500dSAkeem G Abodunrin * power management suspend callback. 5118769c500dSAkeem G Abodunrin * 5119769c500dSAkeem G Abodunrin * This should be called during resume routine to re-allocate the q_vectors 5120769c500dSAkeem G Abodunrin * and reacquire interrupts. 5121769c500dSAkeem G Abodunrin */ 5122769c500dSAkeem G Abodunrin static int ice_reinit_interrupt_scheme(struct ice_pf *pf) 5123769c500dSAkeem G Abodunrin { 5124769c500dSAkeem G Abodunrin struct device *dev = ice_pf_to_dev(pf); 5125769c500dSAkeem G Abodunrin int ret, v; 5126769c500dSAkeem G Abodunrin 5127769c500dSAkeem G Abodunrin /* Since we clear MSIX flag during suspend, we need to 5128769c500dSAkeem G Abodunrin * set it back during resume... 5129769c500dSAkeem G Abodunrin */ 5130769c500dSAkeem G Abodunrin 5131769c500dSAkeem G Abodunrin ret = ice_init_interrupt_scheme(pf); 5132769c500dSAkeem G Abodunrin if (ret) { 5133769c500dSAkeem G Abodunrin dev_err(dev, "Failed to re-initialize interrupt %d\n", ret); 5134769c500dSAkeem G Abodunrin return ret; 5135769c500dSAkeem G Abodunrin } 5136769c500dSAkeem G Abodunrin 5137769c500dSAkeem G Abodunrin /* Remap vectors and rings, after successful re-init interrupts */ 5138769c500dSAkeem G Abodunrin ice_for_each_vsi(pf, v) { 5139769c500dSAkeem G Abodunrin if (!pf->vsi[v]) 5140769c500dSAkeem G Abodunrin continue; 5141769c500dSAkeem G Abodunrin 5142769c500dSAkeem G Abodunrin ret = ice_vsi_alloc_q_vectors(pf->vsi[v]); 5143769c500dSAkeem G Abodunrin if (ret) 5144769c500dSAkeem G Abodunrin goto err_reinit; 5145769c500dSAkeem G Abodunrin ice_vsi_map_rings_to_vectors(pf->vsi[v]); 5146769c500dSAkeem G Abodunrin } 5147769c500dSAkeem G Abodunrin 5148769c500dSAkeem G Abodunrin ret = ice_req_irq_msix_misc(pf); 5149769c500dSAkeem G Abodunrin if (ret) { 5150769c500dSAkeem G Abodunrin dev_err(dev, "Setting up misc vector failed after device suspend %d\n", 5151769c500dSAkeem G Abodunrin ret); 5152769c500dSAkeem G Abodunrin goto err_reinit; 5153769c500dSAkeem G Abodunrin } 5154769c500dSAkeem G Abodunrin 5155769c500dSAkeem G Abodunrin return 0; 5156769c500dSAkeem G Abodunrin 5157769c500dSAkeem G Abodunrin err_reinit: 5158769c500dSAkeem G Abodunrin while (v--) 5159769c500dSAkeem G Abodunrin if (pf->vsi[v]) 5160769c500dSAkeem G Abodunrin ice_vsi_free_q_vectors(pf->vsi[v]); 5161769c500dSAkeem G Abodunrin 5162769c500dSAkeem G Abodunrin return ret; 5163769c500dSAkeem G Abodunrin } 5164769c500dSAkeem G Abodunrin 5165769c500dSAkeem G Abodunrin /** 5166769c500dSAkeem G Abodunrin * ice_suspend 5167769c500dSAkeem G Abodunrin * @dev: generic device information structure 5168769c500dSAkeem G Abodunrin * 5169769c500dSAkeem G Abodunrin * Power Management callback to quiesce the device and prepare 5170769c500dSAkeem G Abodunrin * for D3 transition. 5171769c500dSAkeem G Abodunrin */ 517265c72291SWei Yongjun static int __maybe_unused ice_suspend(struct device *dev) 5173769c500dSAkeem G Abodunrin { 5174769c500dSAkeem G Abodunrin struct pci_dev *pdev = to_pci_dev(dev); 5175769c500dSAkeem G Abodunrin struct ice_pf *pf; 5176769c500dSAkeem G Abodunrin int disabled, v; 5177769c500dSAkeem G Abodunrin 5178769c500dSAkeem G Abodunrin pf = pci_get_drvdata(pdev); 5179769c500dSAkeem G Abodunrin 5180769c500dSAkeem G Abodunrin if (!ice_pf_state_is_nominal(pf)) { 5181769c500dSAkeem G Abodunrin dev_err(dev, "Device is not ready, no need to suspend it\n"); 5182769c500dSAkeem G Abodunrin return -EBUSY; 5183769c500dSAkeem G Abodunrin } 5184769c500dSAkeem G Abodunrin 5185769c500dSAkeem G Abodunrin /* Stop watchdog tasks until resume completion. 5186769c500dSAkeem G Abodunrin * Even though it is most likely that the service task is 5187769c500dSAkeem G Abodunrin * disabled if the device is suspended or down, the service task's 5188769c500dSAkeem G Abodunrin * state is controlled by a different state bit, and we should 5189769c500dSAkeem G Abodunrin * store and honor whatever state that bit is in at this point. 5190769c500dSAkeem G Abodunrin */ 5191769c500dSAkeem G Abodunrin disabled = ice_service_task_stop(pf); 5192769c500dSAkeem G Abodunrin 5193f9f5301eSDave Ertman ice_unplug_aux_dev(pf); 5194f9f5301eSDave Ertman 5195769c500dSAkeem G Abodunrin /* Already suspended?, then there is nothing to do */ 51967e408e07SAnirudh Venkataramanan if (test_and_set_bit(ICE_SUSPENDED, pf->state)) { 5197769c500dSAkeem G Abodunrin if (!disabled) 5198769c500dSAkeem G Abodunrin ice_service_task_restart(pf); 5199769c500dSAkeem G Abodunrin return 0; 5200769c500dSAkeem G Abodunrin } 5201769c500dSAkeem G Abodunrin 52027e408e07SAnirudh Venkataramanan if (test_bit(ICE_DOWN, pf->state) || 5203769c500dSAkeem G Abodunrin ice_is_reset_in_progress(pf->state)) { 5204769c500dSAkeem G Abodunrin dev_err(dev, "can't suspend device in reset or already down\n"); 5205769c500dSAkeem G Abodunrin if (!disabled) 5206769c500dSAkeem G Abodunrin ice_service_task_restart(pf); 5207769c500dSAkeem G Abodunrin return 0; 5208769c500dSAkeem G Abodunrin } 5209769c500dSAkeem G Abodunrin 5210769c500dSAkeem G Abodunrin ice_setup_mc_magic_wake(pf); 5211769c500dSAkeem G Abodunrin 5212769c500dSAkeem G Abodunrin ice_prepare_for_shutdown(pf); 5213769c500dSAkeem G Abodunrin 5214769c500dSAkeem G Abodunrin ice_set_wake(pf); 5215769c500dSAkeem G Abodunrin 5216769c500dSAkeem G Abodunrin /* Free vectors, clear the interrupt scheme and release IRQs 5217769c500dSAkeem G Abodunrin * for proper hibernation, especially with large number of CPUs. 5218769c500dSAkeem G Abodunrin * Otherwise hibernation might fail when mapping all the vectors back 5219769c500dSAkeem G Abodunrin * to CPU0. 5220769c500dSAkeem G Abodunrin */ 5221769c500dSAkeem G Abodunrin ice_free_irq_msix_misc(pf); 5222769c500dSAkeem G Abodunrin ice_for_each_vsi(pf, v) { 5223769c500dSAkeem G Abodunrin if (!pf->vsi[v]) 5224769c500dSAkeem G Abodunrin continue; 5225769c500dSAkeem G Abodunrin ice_vsi_free_q_vectors(pf->vsi[v]); 5226769c500dSAkeem G Abodunrin } 5227769c500dSAkeem G Abodunrin ice_clear_interrupt_scheme(pf); 5228769c500dSAkeem G Abodunrin 5229466e4392SAnirudh Venkataramanan pci_save_state(pdev); 5230769c500dSAkeem G Abodunrin pci_wake_from_d3(pdev, pf->wol_ena); 5231769c500dSAkeem G Abodunrin pci_set_power_state(pdev, PCI_D3hot); 5232769c500dSAkeem G Abodunrin return 0; 5233769c500dSAkeem G Abodunrin } 5234769c500dSAkeem G Abodunrin 5235769c500dSAkeem G Abodunrin /** 5236769c500dSAkeem G Abodunrin * ice_resume - PM callback for waking up from D3 5237769c500dSAkeem G Abodunrin * @dev: generic device information structure 5238769c500dSAkeem G Abodunrin */ 523965c72291SWei Yongjun static int __maybe_unused ice_resume(struct device *dev) 5240769c500dSAkeem G Abodunrin { 5241769c500dSAkeem G Abodunrin struct pci_dev *pdev = to_pci_dev(dev); 5242769c500dSAkeem G Abodunrin enum ice_reset_req reset_type; 5243769c500dSAkeem G Abodunrin struct ice_pf *pf; 5244769c500dSAkeem G Abodunrin struct ice_hw *hw; 5245769c500dSAkeem G Abodunrin int ret; 5246769c500dSAkeem G Abodunrin 5247769c500dSAkeem G Abodunrin pci_set_power_state(pdev, PCI_D0); 5248769c500dSAkeem G Abodunrin pci_restore_state(pdev); 5249769c500dSAkeem G Abodunrin pci_save_state(pdev); 5250769c500dSAkeem G Abodunrin 5251769c500dSAkeem G Abodunrin if (!pci_device_is_present(pdev)) 5252769c500dSAkeem G Abodunrin return -ENODEV; 5253769c500dSAkeem G Abodunrin 5254769c500dSAkeem G Abodunrin ret = pci_enable_device_mem(pdev); 5255769c500dSAkeem G Abodunrin if (ret) { 5256769c500dSAkeem G Abodunrin dev_err(dev, "Cannot enable device after suspend\n"); 5257769c500dSAkeem G Abodunrin return ret; 5258769c500dSAkeem G Abodunrin } 5259769c500dSAkeem G Abodunrin 5260769c500dSAkeem G Abodunrin pf = pci_get_drvdata(pdev); 5261769c500dSAkeem G Abodunrin hw = &pf->hw; 5262769c500dSAkeem G Abodunrin 5263769c500dSAkeem G Abodunrin pf->wakeup_reason = rd32(hw, PFPM_WUS); 5264769c500dSAkeem G Abodunrin ice_print_wake_reason(pf); 5265769c500dSAkeem G Abodunrin 5266769c500dSAkeem G Abodunrin /* We cleared the interrupt scheme when we suspended, so we need to 5267769c500dSAkeem G Abodunrin * restore it now to resume device functionality. 5268769c500dSAkeem G Abodunrin */ 5269769c500dSAkeem G Abodunrin ret = ice_reinit_interrupt_scheme(pf); 5270769c500dSAkeem G Abodunrin if (ret) 5271769c500dSAkeem G Abodunrin dev_err(dev, "Cannot restore interrupt scheme: %d\n", ret); 5272769c500dSAkeem G Abodunrin 52737e408e07SAnirudh Venkataramanan clear_bit(ICE_DOWN, pf->state); 5274769c500dSAkeem G Abodunrin /* Now perform PF reset and rebuild */ 5275769c500dSAkeem G Abodunrin reset_type = ICE_RESET_PFR; 5276769c500dSAkeem G Abodunrin /* re-enable service task for reset, but allow reset to schedule it */ 52777e408e07SAnirudh Venkataramanan clear_bit(ICE_SERVICE_DIS, pf->state); 5278769c500dSAkeem G Abodunrin 5279769c500dSAkeem G Abodunrin if (ice_schedule_reset(pf, reset_type)) 5280769c500dSAkeem G Abodunrin dev_err(dev, "Reset during resume failed.\n"); 5281769c500dSAkeem G Abodunrin 52827e408e07SAnirudh Venkataramanan clear_bit(ICE_SUSPENDED, pf->state); 5283769c500dSAkeem G Abodunrin ice_service_task_restart(pf); 5284769c500dSAkeem G Abodunrin 5285769c500dSAkeem G Abodunrin /* Restart the service task */ 5286769c500dSAkeem G Abodunrin mod_timer(&pf->serv_tmr, round_jiffies(jiffies + pf->serv_tmr_period)); 5287769c500dSAkeem G Abodunrin 5288769c500dSAkeem G Abodunrin return 0; 5289769c500dSAkeem G Abodunrin } 5290769c500dSAkeem G Abodunrin #endif /* CONFIG_PM */ 5291769c500dSAkeem G Abodunrin 5292769c500dSAkeem G Abodunrin /** 52935995b6d0SBrett Creeley * ice_pci_err_detected - warning that PCI error has been detected 52945995b6d0SBrett Creeley * @pdev: PCI device information struct 52955995b6d0SBrett Creeley * @err: the type of PCI error 52965995b6d0SBrett Creeley * 52975995b6d0SBrett Creeley * Called to warn that something happened on the PCI bus and the error handling 52985995b6d0SBrett Creeley * is in progress. Allows the driver to gracefully prepare/handle PCI errors. 52995995b6d0SBrett Creeley */ 53005995b6d0SBrett Creeley static pci_ers_result_t 530116d79cd4SLuc Van Oostenryck ice_pci_err_detected(struct pci_dev *pdev, pci_channel_state_t err) 53025995b6d0SBrett Creeley { 53035995b6d0SBrett Creeley struct ice_pf *pf = pci_get_drvdata(pdev); 53045995b6d0SBrett Creeley 53055995b6d0SBrett Creeley if (!pf) { 53065995b6d0SBrett Creeley dev_err(&pdev->dev, "%s: unrecoverable device error %d\n", 53075995b6d0SBrett Creeley __func__, err); 53085995b6d0SBrett Creeley return PCI_ERS_RESULT_DISCONNECT; 53095995b6d0SBrett Creeley } 53105995b6d0SBrett Creeley 53117e408e07SAnirudh Venkataramanan if (!test_bit(ICE_SUSPENDED, pf->state)) { 53125995b6d0SBrett Creeley ice_service_task_stop(pf); 53135995b6d0SBrett Creeley 53147e408e07SAnirudh Venkataramanan if (!test_bit(ICE_PREPARED_FOR_RESET, pf->state)) { 53157e408e07SAnirudh Venkataramanan set_bit(ICE_PFR_REQ, pf->state); 5316fbc7b27aSKiran Patil ice_prepare_for_reset(pf, ICE_RESET_PFR); 53175995b6d0SBrett Creeley } 53185995b6d0SBrett Creeley } 53195995b6d0SBrett Creeley 53205995b6d0SBrett Creeley return PCI_ERS_RESULT_NEED_RESET; 53215995b6d0SBrett Creeley } 53225995b6d0SBrett Creeley 53235995b6d0SBrett Creeley /** 53245995b6d0SBrett Creeley * ice_pci_err_slot_reset - a PCI slot reset has just happened 53255995b6d0SBrett Creeley * @pdev: PCI device information struct 53265995b6d0SBrett Creeley * 53275995b6d0SBrett Creeley * Called to determine if the driver can recover from the PCI slot reset by 53285995b6d0SBrett Creeley * using a register read to determine if the device is recoverable. 53295995b6d0SBrett Creeley */ 53305995b6d0SBrett Creeley static pci_ers_result_t ice_pci_err_slot_reset(struct pci_dev *pdev) 53315995b6d0SBrett Creeley { 53325995b6d0SBrett Creeley struct ice_pf *pf = pci_get_drvdata(pdev); 53335995b6d0SBrett Creeley pci_ers_result_t result; 53345995b6d0SBrett Creeley int err; 53355995b6d0SBrett Creeley u32 reg; 53365995b6d0SBrett Creeley 53375995b6d0SBrett Creeley err = pci_enable_device_mem(pdev); 53385995b6d0SBrett Creeley if (err) { 533919cce2c6SAnirudh Venkataramanan dev_err(&pdev->dev, "Cannot re-enable PCI device after reset, error %d\n", 53405995b6d0SBrett Creeley err); 53415995b6d0SBrett Creeley result = PCI_ERS_RESULT_DISCONNECT; 53425995b6d0SBrett Creeley } else { 53435995b6d0SBrett Creeley pci_set_master(pdev); 53445995b6d0SBrett Creeley pci_restore_state(pdev); 53455995b6d0SBrett Creeley pci_save_state(pdev); 53465995b6d0SBrett Creeley pci_wake_from_d3(pdev, false); 53475995b6d0SBrett Creeley 53485995b6d0SBrett Creeley /* Check for life */ 53495995b6d0SBrett Creeley reg = rd32(&pf->hw, GLGEN_RTRIG); 53505995b6d0SBrett Creeley if (!reg) 53515995b6d0SBrett Creeley result = PCI_ERS_RESULT_RECOVERED; 53525995b6d0SBrett Creeley else 53535995b6d0SBrett Creeley result = PCI_ERS_RESULT_DISCONNECT; 53545995b6d0SBrett Creeley } 53555995b6d0SBrett Creeley 53565995b6d0SBrett Creeley return result; 53575995b6d0SBrett Creeley } 53585995b6d0SBrett Creeley 53595995b6d0SBrett Creeley /** 53605995b6d0SBrett Creeley * ice_pci_err_resume - restart operations after PCI error recovery 53615995b6d0SBrett Creeley * @pdev: PCI device information struct 53625995b6d0SBrett Creeley * 53635995b6d0SBrett Creeley * Called to allow the driver to bring things back up after PCI error and/or 53645995b6d0SBrett Creeley * reset recovery have finished 53655995b6d0SBrett Creeley */ 53665995b6d0SBrett Creeley static void ice_pci_err_resume(struct pci_dev *pdev) 53675995b6d0SBrett Creeley { 53685995b6d0SBrett Creeley struct ice_pf *pf = pci_get_drvdata(pdev); 53695995b6d0SBrett Creeley 53705995b6d0SBrett Creeley if (!pf) { 537119cce2c6SAnirudh Venkataramanan dev_err(&pdev->dev, "%s failed, device is unrecoverable\n", 537219cce2c6SAnirudh Venkataramanan __func__); 53735995b6d0SBrett Creeley return; 53745995b6d0SBrett Creeley } 53755995b6d0SBrett Creeley 53767e408e07SAnirudh Venkataramanan if (test_bit(ICE_SUSPENDED, pf->state)) { 53775995b6d0SBrett Creeley dev_dbg(&pdev->dev, "%s failed to resume normal operations!\n", 53785995b6d0SBrett Creeley __func__); 53795995b6d0SBrett Creeley return; 53805995b6d0SBrett Creeley } 53815995b6d0SBrett Creeley 5382a54a0b24SNick Nunley ice_restore_all_vfs_msi_state(pdev); 5383a54a0b24SNick Nunley 53845995b6d0SBrett Creeley ice_do_reset(pf, ICE_RESET_PFR); 53855995b6d0SBrett Creeley ice_service_task_restart(pf); 53865995b6d0SBrett Creeley mod_timer(&pf->serv_tmr, round_jiffies(jiffies + pf->serv_tmr_period)); 53875995b6d0SBrett Creeley } 53885995b6d0SBrett Creeley 53895995b6d0SBrett Creeley /** 53905995b6d0SBrett Creeley * ice_pci_err_reset_prepare - prepare device driver for PCI reset 53915995b6d0SBrett Creeley * @pdev: PCI device information struct 53925995b6d0SBrett Creeley */ 53935995b6d0SBrett Creeley static void ice_pci_err_reset_prepare(struct pci_dev *pdev) 53945995b6d0SBrett Creeley { 53955995b6d0SBrett Creeley struct ice_pf *pf = pci_get_drvdata(pdev); 53965995b6d0SBrett Creeley 53977e408e07SAnirudh Venkataramanan if (!test_bit(ICE_SUSPENDED, pf->state)) { 53985995b6d0SBrett Creeley ice_service_task_stop(pf); 53995995b6d0SBrett Creeley 54007e408e07SAnirudh Venkataramanan if (!test_bit(ICE_PREPARED_FOR_RESET, pf->state)) { 54017e408e07SAnirudh Venkataramanan set_bit(ICE_PFR_REQ, pf->state); 5402fbc7b27aSKiran Patil ice_prepare_for_reset(pf, ICE_RESET_PFR); 54035995b6d0SBrett Creeley } 54045995b6d0SBrett Creeley } 54055995b6d0SBrett Creeley } 54065995b6d0SBrett Creeley 54075995b6d0SBrett Creeley /** 54085995b6d0SBrett Creeley * ice_pci_err_reset_done - PCI reset done, device driver reset can begin 54095995b6d0SBrett Creeley * @pdev: PCI device information struct 54105995b6d0SBrett Creeley */ 54115995b6d0SBrett Creeley static void ice_pci_err_reset_done(struct pci_dev *pdev) 54125995b6d0SBrett Creeley { 54135995b6d0SBrett Creeley ice_pci_err_resume(pdev); 54145995b6d0SBrett Creeley } 54155995b6d0SBrett Creeley 5416837f08fdSAnirudh Venkataramanan /* ice_pci_tbl - PCI Device ID Table 5417837f08fdSAnirudh Venkataramanan * 5418837f08fdSAnirudh Venkataramanan * Wildcard entries (PCI_ANY_ID) should come last 5419837f08fdSAnirudh Venkataramanan * Last entry must be all 0s 5420837f08fdSAnirudh Venkataramanan * 5421837f08fdSAnirudh Venkataramanan * { Vendor ID, Device ID, SubVendor ID, SubDevice ID, 5422837f08fdSAnirudh Venkataramanan * Class, Class Mask, private data (not used) } 5423837f08fdSAnirudh Venkataramanan */ 5424837f08fdSAnirudh Venkataramanan static const struct pci_device_id ice_pci_tbl[] = { 5425633d7449SAnirudh Venkataramanan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E810C_BACKPLANE), 0 }, 5426633d7449SAnirudh Venkataramanan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E810C_QSFP), 0 }, 5427633d7449SAnirudh Venkataramanan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E810C_SFP), 0 }, 54287dcf78b8STony Nguyen { PCI_VDEVICE(INTEL, ICE_DEV_ID_E810_XXV_BACKPLANE), 0 }, 54297dcf78b8STony Nguyen { PCI_VDEVICE(INTEL, ICE_DEV_ID_E810_XXV_QSFP), 0 }, 5430195fb977SBruce Allan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E810_XXV_SFP), 0 }, 5431e36aeec0SBruce Allan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E823C_BACKPLANE), 0 }, 5432e36aeec0SBruce Allan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E823C_QSFP), 0 }, 5433e36aeec0SBruce Allan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E823C_SFP), 0 }, 5434e36aeec0SBruce Allan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E823C_10G_BASE_T), 0 }, 5435e36aeec0SBruce Allan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E823C_SGMII), 0 }, 54365d9e618cSJacob Keller { PCI_VDEVICE(INTEL, ICE_DEV_ID_E822C_BACKPLANE), 0 }, 54375d9e618cSJacob Keller { PCI_VDEVICE(INTEL, ICE_DEV_ID_E822C_QSFP), 0 }, 54385d9e618cSJacob Keller { PCI_VDEVICE(INTEL, ICE_DEV_ID_E822C_SFP), 0 }, 54395d9e618cSJacob Keller { PCI_VDEVICE(INTEL, ICE_DEV_ID_E822C_10G_BASE_T), 0 }, 54405d9e618cSJacob Keller { PCI_VDEVICE(INTEL, ICE_DEV_ID_E822C_SGMII), 0 }, 54412fbfa966SBruce Allan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E822L_BACKPLANE), 0 }, 54425d9e618cSJacob Keller { PCI_VDEVICE(INTEL, ICE_DEV_ID_E822L_SFP), 0 }, 54435d9e618cSJacob Keller { PCI_VDEVICE(INTEL, ICE_DEV_ID_E822L_10G_BASE_T), 0 }, 54445d9e618cSJacob Keller { PCI_VDEVICE(INTEL, ICE_DEV_ID_E822L_SGMII), 0 }, 5445e36aeec0SBruce Allan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E823L_BACKPLANE), 0 }, 5446e36aeec0SBruce Allan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E823L_SFP), 0 }, 5447e36aeec0SBruce Allan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E823L_10G_BASE_T), 0 }, 5448e36aeec0SBruce Allan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E823L_1GBE), 0 }, 5449e36aeec0SBruce Allan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E823L_QSFP), 0 }, 5450f52d1668SPaul M Stillwell Jr { PCI_VDEVICE(INTEL, ICE_DEV_ID_E822_SI_DFLT), 0 }, 5451837f08fdSAnirudh Venkataramanan /* required last entry */ 5452837f08fdSAnirudh Venkataramanan { 0, } 5453837f08fdSAnirudh Venkataramanan }; 5454837f08fdSAnirudh Venkataramanan MODULE_DEVICE_TABLE(pci, ice_pci_tbl); 5455837f08fdSAnirudh Venkataramanan 5456769c500dSAkeem G Abodunrin static __maybe_unused SIMPLE_DEV_PM_OPS(ice_pm_ops, ice_suspend, ice_resume); 5457769c500dSAkeem G Abodunrin 54585995b6d0SBrett Creeley static const struct pci_error_handlers ice_pci_err_handler = { 54595995b6d0SBrett Creeley .error_detected = ice_pci_err_detected, 54605995b6d0SBrett Creeley .slot_reset = ice_pci_err_slot_reset, 54615995b6d0SBrett Creeley .reset_prepare = ice_pci_err_reset_prepare, 54625995b6d0SBrett Creeley .reset_done = ice_pci_err_reset_done, 54635995b6d0SBrett Creeley .resume = ice_pci_err_resume 54645995b6d0SBrett Creeley }; 54655995b6d0SBrett Creeley 5466837f08fdSAnirudh Venkataramanan static struct pci_driver ice_driver = { 5467837f08fdSAnirudh Venkataramanan .name = KBUILD_MODNAME, 5468837f08fdSAnirudh Venkataramanan .id_table = ice_pci_tbl, 5469837f08fdSAnirudh Venkataramanan .probe = ice_probe, 5470837f08fdSAnirudh Venkataramanan .remove = ice_remove, 5471769c500dSAkeem G Abodunrin #ifdef CONFIG_PM 5472769c500dSAkeem G Abodunrin .driver.pm = &ice_pm_ops, 5473769c500dSAkeem G Abodunrin #endif /* CONFIG_PM */ 5474769c500dSAkeem G Abodunrin .shutdown = ice_shutdown, 5475ddf30f7fSAnirudh Venkataramanan .sriov_configure = ice_sriov_configure, 54765995b6d0SBrett Creeley .err_handler = &ice_pci_err_handler 5477837f08fdSAnirudh Venkataramanan }; 5478837f08fdSAnirudh Venkataramanan 5479837f08fdSAnirudh Venkataramanan /** 5480837f08fdSAnirudh Venkataramanan * ice_module_init - Driver registration routine 5481837f08fdSAnirudh Venkataramanan * 5482837f08fdSAnirudh Venkataramanan * ice_module_init is the first routine called when the driver is 5483837f08fdSAnirudh Venkataramanan * loaded. All it does is register with the PCI subsystem. 5484837f08fdSAnirudh Venkataramanan */ 5485837f08fdSAnirudh Venkataramanan static int __init ice_module_init(void) 5486837f08fdSAnirudh Venkataramanan { 5487837f08fdSAnirudh Venkataramanan int status; 5488837f08fdSAnirudh Venkataramanan 548934a2a3b8SJeff Kirsher pr_info("%s\n", ice_driver_string); 5490837f08fdSAnirudh Venkataramanan pr_info("%s\n", ice_copyright); 5491837f08fdSAnirudh Venkataramanan 54920f9d5027SAnirudh Venkataramanan ice_wq = alloc_workqueue("%s", WQ_MEM_RECLAIM, 0, KBUILD_MODNAME); 5493940b61afSAnirudh Venkataramanan if (!ice_wq) { 5494940b61afSAnirudh Venkataramanan pr_err("Failed to create workqueue\n"); 5495940b61afSAnirudh Venkataramanan return -ENOMEM; 5496940b61afSAnirudh Venkataramanan } 5497940b61afSAnirudh Venkataramanan 5498837f08fdSAnirudh Venkataramanan status = pci_register_driver(&ice_driver); 5499940b61afSAnirudh Venkataramanan if (status) { 55002f2da36eSAnirudh Venkataramanan pr_err("failed to register PCI driver, err %d\n", status); 5501940b61afSAnirudh Venkataramanan destroy_workqueue(ice_wq); 5502940b61afSAnirudh Venkataramanan } 5503837f08fdSAnirudh Venkataramanan 5504837f08fdSAnirudh Venkataramanan return status; 5505837f08fdSAnirudh Venkataramanan } 5506837f08fdSAnirudh Venkataramanan module_init(ice_module_init); 5507837f08fdSAnirudh Venkataramanan 5508837f08fdSAnirudh Venkataramanan /** 5509837f08fdSAnirudh Venkataramanan * ice_module_exit - Driver exit cleanup routine 5510837f08fdSAnirudh Venkataramanan * 5511837f08fdSAnirudh Venkataramanan * ice_module_exit is called just before the driver is removed 5512837f08fdSAnirudh Venkataramanan * from memory. 5513837f08fdSAnirudh Venkataramanan */ 5514837f08fdSAnirudh Venkataramanan static void __exit ice_module_exit(void) 5515837f08fdSAnirudh Venkataramanan { 5516837f08fdSAnirudh Venkataramanan pci_unregister_driver(&ice_driver); 5517940b61afSAnirudh Venkataramanan destroy_workqueue(ice_wq); 5518837f08fdSAnirudh Venkataramanan pr_info("module unloaded\n"); 5519837f08fdSAnirudh Venkataramanan } 5520837f08fdSAnirudh Venkataramanan module_exit(ice_module_exit); 55213a858ba3SAnirudh Venkataramanan 55223a858ba3SAnirudh Venkataramanan /** 5523f9867df6SAnirudh Venkataramanan * ice_set_mac_address - NDO callback to set MAC address 5524e94d4478SAnirudh Venkataramanan * @netdev: network interface device structure 5525e94d4478SAnirudh Venkataramanan * @pi: pointer to an address structure 5526e94d4478SAnirudh Venkataramanan * 5527e94d4478SAnirudh Venkataramanan * Returns 0 on success, negative on failure 5528e94d4478SAnirudh Venkataramanan */ 5529e94d4478SAnirudh Venkataramanan static int ice_set_mac_address(struct net_device *netdev, void *pi) 5530e94d4478SAnirudh Venkataramanan { 5531e94d4478SAnirudh Venkataramanan struct ice_netdev_priv *np = netdev_priv(netdev); 5532e94d4478SAnirudh Venkataramanan struct ice_vsi *vsi = np->vsi; 5533e94d4478SAnirudh Venkataramanan struct ice_pf *pf = vsi->back; 5534e94d4478SAnirudh Venkataramanan struct ice_hw *hw = &pf->hw; 5535e94d4478SAnirudh Venkataramanan struct sockaddr *addr = pi; 5536b357d971SBrett Creeley u8 old_mac[ETH_ALEN]; 5537e94d4478SAnirudh Venkataramanan u8 flags = 0; 5538e94d4478SAnirudh Venkataramanan u8 *mac; 55392ccc1c1cSTony Nguyen int err; 5540e94d4478SAnirudh Venkataramanan 5541e94d4478SAnirudh Venkataramanan mac = (u8 *)addr->sa_data; 5542e94d4478SAnirudh Venkataramanan 5543e94d4478SAnirudh Venkataramanan if (!is_valid_ether_addr(mac)) 5544e94d4478SAnirudh Venkataramanan return -EADDRNOTAVAIL; 5545e94d4478SAnirudh Venkataramanan 5546e94d4478SAnirudh Venkataramanan if (ether_addr_equal(netdev->dev_addr, mac)) { 55473ba7f53fSBrett Creeley netdev_dbg(netdev, "already using mac %pM\n", mac); 5548e94d4478SAnirudh Venkataramanan return 0; 5549e94d4478SAnirudh Venkataramanan } 5550e94d4478SAnirudh Venkataramanan 55517e408e07SAnirudh Venkataramanan if (test_bit(ICE_DOWN, pf->state) || 55525df7e45dSDave Ertman ice_is_reset_in_progress(pf->state)) { 5553e94d4478SAnirudh Venkataramanan netdev_err(netdev, "can't set mac %pM. device not ready\n", 5554e94d4478SAnirudh Venkataramanan mac); 5555e94d4478SAnirudh Venkataramanan return -EBUSY; 5556e94d4478SAnirudh Venkataramanan } 5557e94d4478SAnirudh Venkataramanan 55589fea7498SKiran Patil if (ice_chnl_dmac_fltr_cnt(pf)) { 55599fea7498SKiran Patil netdev_err(netdev, "can't set mac %pM. Device has tc-flower filters, delete all of them and try again\n", 55609fea7498SKiran Patil mac); 55619fea7498SKiran Patil return -EAGAIN; 55629fea7498SKiran Patil } 55639fea7498SKiran Patil 55643ba7f53fSBrett Creeley netif_addr_lock_bh(netdev); 5565b357d971SBrett Creeley ether_addr_copy(old_mac, netdev->dev_addr); 5566b357d971SBrett Creeley /* change the netdev's MAC address */ 5567a05e4c0aSJakub Kicinski eth_hw_addr_set(netdev, mac); 5568b357d971SBrett Creeley netif_addr_unlock_bh(netdev); 5569b357d971SBrett Creeley 5570757976abSLihong Yang /* Clean up old MAC filter. Not an error if old filter doesn't exist */ 55712ccc1c1cSTony Nguyen err = ice_fltr_remove_mac(vsi, old_mac, ICE_FWD_TO_VSI); 55722ccc1c1cSTony Nguyen if (err && err != -ENOENT) { 5573e94d4478SAnirudh Venkataramanan err = -EADDRNOTAVAIL; 5574bbb968e8SAkeem G Abodunrin goto err_update_filters; 5575e94d4478SAnirudh Venkataramanan } 5576e94d4478SAnirudh Venkataramanan 557713ed5e8aSNick Nunley /* Add filter for new MAC. If filter exists, return success */ 55782ccc1c1cSTony Nguyen err = ice_fltr_add_mac(vsi, mac, ICE_FWD_TO_VSI); 55792c0069f3SIvan Vecera if (err == -EEXIST) { 558013ed5e8aSNick Nunley /* Although this MAC filter is already present in hardware it's 558113ed5e8aSNick Nunley * possible in some cases (e.g. bonding) that dev_addr was 558213ed5e8aSNick Nunley * modified outside of the driver and needs to be restored back 558313ed5e8aSNick Nunley * to this value. 558413ed5e8aSNick Nunley */ 5585757976abSLihong Yang netdev_dbg(netdev, "filter for MAC %pM already exists\n", mac); 55862c0069f3SIvan Vecera 55872c0069f3SIvan Vecera return 0; 55882c0069f3SIvan Vecera } else if (err) { 5589757976abSLihong Yang /* error if the new filter addition failed */ 5590757976abSLihong Yang err = -EADDRNOTAVAIL; 55912c0069f3SIvan Vecera } 5592757976abSLihong Yang 5593bbb968e8SAkeem G Abodunrin err_update_filters: 5594e94d4478SAnirudh Venkataramanan if (err) { 55952f2da36eSAnirudh Venkataramanan netdev_err(netdev, "can't set MAC %pM. filter update failed\n", 5596e94d4478SAnirudh Venkataramanan mac); 5597b357d971SBrett Creeley netif_addr_lock_bh(netdev); 5598f3956ebbSJakub Kicinski eth_hw_addr_set(netdev, old_mac); 55993ba7f53fSBrett Creeley netif_addr_unlock_bh(netdev); 5600e94d4478SAnirudh Venkataramanan return err; 5601e94d4478SAnirudh Venkataramanan } 5602e94d4478SAnirudh Venkataramanan 56032f2da36eSAnirudh Venkataramanan netdev_dbg(vsi->netdev, "updated MAC address to %pM\n", 5604e94d4478SAnirudh Venkataramanan netdev->dev_addr); 5605e94d4478SAnirudh Venkataramanan 5606f9867df6SAnirudh Venkataramanan /* write new MAC address to the firmware */ 5607e94d4478SAnirudh Venkataramanan flags = ICE_AQC_MAN_MAC_UPDATE_LAA_WOL; 56082ccc1c1cSTony Nguyen err = ice_aq_manage_mac_write(hw, mac, flags, NULL); 56092ccc1c1cSTony Nguyen if (err) { 56105f87ec48STony Nguyen netdev_err(netdev, "can't set MAC %pM. write to firmware failed error %d\n", 56112ccc1c1cSTony Nguyen mac, err); 5612e94d4478SAnirudh Venkataramanan } 5613e94d4478SAnirudh Venkataramanan return 0; 5614e94d4478SAnirudh Venkataramanan } 5615e94d4478SAnirudh Venkataramanan 5616e94d4478SAnirudh Venkataramanan /** 5617e94d4478SAnirudh Venkataramanan * ice_set_rx_mode - NDO callback to set the netdev filters 5618e94d4478SAnirudh Venkataramanan * @netdev: network interface device structure 5619e94d4478SAnirudh Venkataramanan */ 5620e94d4478SAnirudh Venkataramanan static void ice_set_rx_mode(struct net_device *netdev) 5621e94d4478SAnirudh Venkataramanan { 5622e94d4478SAnirudh Venkataramanan struct ice_netdev_priv *np = netdev_priv(netdev); 5623e94d4478SAnirudh Venkataramanan struct ice_vsi *vsi = np->vsi; 5624e94d4478SAnirudh Venkataramanan 5625e94d4478SAnirudh Venkataramanan if (!vsi) 5626e94d4478SAnirudh Venkataramanan return; 5627e94d4478SAnirudh Venkataramanan 5628e94d4478SAnirudh Venkataramanan /* Set the flags to synchronize filters 5629e94d4478SAnirudh Venkataramanan * ndo_set_rx_mode may be triggered even without a change in netdev 5630e94d4478SAnirudh Venkataramanan * flags 5631e94d4478SAnirudh Venkataramanan */ 5632e97fb1aeSAnirudh Venkataramanan set_bit(ICE_VSI_UMAC_FLTR_CHANGED, vsi->state); 5633e97fb1aeSAnirudh Venkataramanan set_bit(ICE_VSI_MMAC_FLTR_CHANGED, vsi->state); 5634e94d4478SAnirudh Venkataramanan set_bit(ICE_FLAG_FLTR_SYNC, vsi->back->flags); 5635e94d4478SAnirudh Venkataramanan 5636e94d4478SAnirudh Venkataramanan /* schedule our worker thread which will take care of 5637e94d4478SAnirudh Venkataramanan * applying the new filter changes 5638e94d4478SAnirudh Venkataramanan */ 5639e94d4478SAnirudh Venkataramanan ice_service_task_schedule(vsi->back); 5640e94d4478SAnirudh Venkataramanan } 5641e94d4478SAnirudh Venkataramanan 5642e94d4478SAnirudh Venkataramanan /** 56431ddef455SUsha Ketineni * ice_set_tx_maxrate - NDO callback to set the maximum per-queue bitrate 56441ddef455SUsha Ketineni * @netdev: network interface device structure 56451ddef455SUsha Ketineni * @queue_index: Queue ID 56461ddef455SUsha Ketineni * @maxrate: maximum bandwidth in Mbps 56471ddef455SUsha Ketineni */ 56481ddef455SUsha Ketineni static int 56491ddef455SUsha Ketineni ice_set_tx_maxrate(struct net_device *netdev, int queue_index, u32 maxrate) 56501ddef455SUsha Ketineni { 56511ddef455SUsha Ketineni struct ice_netdev_priv *np = netdev_priv(netdev); 56521ddef455SUsha Ketineni struct ice_vsi *vsi = np->vsi; 56531ddef455SUsha Ketineni u16 q_handle; 56545518ac2aSTony Nguyen int status; 56551ddef455SUsha Ketineni u8 tc; 56561ddef455SUsha Ketineni 56571ddef455SUsha Ketineni /* Validate maxrate requested is within permitted range */ 56581ddef455SUsha Ketineni if (maxrate && (maxrate > (ICE_SCHED_MAX_BW / 1000))) { 565919cce2c6SAnirudh Venkataramanan netdev_err(netdev, "Invalid max rate %d specified for the queue %d\n", 56601ddef455SUsha Ketineni maxrate, queue_index); 56611ddef455SUsha Ketineni return -EINVAL; 56621ddef455SUsha Ketineni } 56631ddef455SUsha Ketineni 56641ddef455SUsha Ketineni q_handle = vsi->tx_rings[queue_index]->q_handle; 56651ddef455SUsha Ketineni tc = ice_dcb_get_tc(vsi, queue_index); 56661ddef455SUsha Ketineni 56671ddef455SUsha Ketineni /* Set BW back to default, when user set maxrate to 0 */ 56681ddef455SUsha Ketineni if (!maxrate) 56691ddef455SUsha Ketineni status = ice_cfg_q_bw_dflt_lmt(vsi->port_info, vsi->idx, tc, 56701ddef455SUsha Ketineni q_handle, ICE_MAX_BW); 56711ddef455SUsha Ketineni else 56721ddef455SUsha Ketineni status = ice_cfg_q_bw_lmt(vsi->port_info, vsi->idx, tc, 56731ddef455SUsha Ketineni q_handle, ICE_MAX_BW, maxrate * 1000); 5674c1484691STony Nguyen if (status) 56755f87ec48STony Nguyen netdev_err(netdev, "Unable to set Tx max rate, error %d\n", 56765f87ec48STony Nguyen status); 56771ddef455SUsha Ketineni 5678c1484691STony Nguyen return status; 56791ddef455SUsha Ketineni } 56801ddef455SUsha Ketineni 56811ddef455SUsha Ketineni /** 5682e94d4478SAnirudh Venkataramanan * ice_fdb_add - add an entry to the hardware database 5683e94d4478SAnirudh Venkataramanan * @ndm: the input from the stack 5684e94d4478SAnirudh Venkataramanan * @tb: pointer to array of nladdr (unused) 5685e94d4478SAnirudh Venkataramanan * @dev: the net device pointer 5686e94d4478SAnirudh Venkataramanan * @addr: the MAC address entry being added 5687f9867df6SAnirudh Venkataramanan * @vid: VLAN ID 5688e94d4478SAnirudh Venkataramanan * @flags: instructions from stack about fdb operation 568999be37edSBruce Allan * @extack: netlink extended ack 5690e94d4478SAnirudh Venkataramanan */ 569199be37edSBruce Allan static int 569299be37edSBruce Allan ice_fdb_add(struct ndmsg *ndm, struct nlattr __always_unused *tb[], 569399be37edSBruce Allan struct net_device *dev, const unsigned char *addr, u16 vid, 569499be37edSBruce Allan u16 flags, struct netlink_ext_ack __always_unused *extack) 5695e94d4478SAnirudh Venkataramanan { 5696e94d4478SAnirudh Venkataramanan int err; 5697e94d4478SAnirudh Venkataramanan 5698e94d4478SAnirudh Venkataramanan if (vid) { 5699e94d4478SAnirudh Venkataramanan netdev_err(dev, "VLANs aren't supported yet for dev_uc|mc_add()\n"); 5700e94d4478SAnirudh Venkataramanan return -EINVAL; 5701e94d4478SAnirudh Venkataramanan } 5702e94d4478SAnirudh Venkataramanan if (ndm->ndm_state && !(ndm->ndm_state & NUD_PERMANENT)) { 5703e94d4478SAnirudh Venkataramanan netdev_err(dev, "FDB only supports static addresses\n"); 5704e94d4478SAnirudh Venkataramanan return -EINVAL; 5705e94d4478SAnirudh Venkataramanan } 5706e94d4478SAnirudh Venkataramanan 5707e94d4478SAnirudh Venkataramanan if (is_unicast_ether_addr(addr) || is_link_local_ether_addr(addr)) 5708e94d4478SAnirudh Venkataramanan err = dev_uc_add_excl(dev, addr); 5709e94d4478SAnirudh Venkataramanan else if (is_multicast_ether_addr(addr)) 5710e94d4478SAnirudh Venkataramanan err = dev_mc_add_excl(dev, addr); 5711e94d4478SAnirudh Venkataramanan else 5712e94d4478SAnirudh Venkataramanan err = -EINVAL; 5713e94d4478SAnirudh Venkataramanan 5714e94d4478SAnirudh Venkataramanan /* Only return duplicate errors if NLM_F_EXCL is set */ 5715e94d4478SAnirudh Venkataramanan if (err == -EEXIST && !(flags & NLM_F_EXCL)) 5716e94d4478SAnirudh Venkataramanan err = 0; 5717e94d4478SAnirudh Venkataramanan 5718e94d4478SAnirudh Venkataramanan return err; 5719e94d4478SAnirudh Venkataramanan } 5720e94d4478SAnirudh Venkataramanan 5721e94d4478SAnirudh Venkataramanan /** 5722e94d4478SAnirudh Venkataramanan * ice_fdb_del - delete an entry from the hardware database 5723e94d4478SAnirudh Venkataramanan * @ndm: the input from the stack 5724e94d4478SAnirudh Venkataramanan * @tb: pointer to array of nladdr (unused) 5725e94d4478SAnirudh Venkataramanan * @dev: the net device pointer 5726e94d4478SAnirudh Venkataramanan * @addr: the MAC address entry being added 5727f9867df6SAnirudh Venkataramanan * @vid: VLAN ID 5728ca4567f1SAlaa Mohamed * @extack: netlink extended ack 5729e94d4478SAnirudh Venkataramanan */ 5730c8b7abddSBruce Allan static int 5731c8b7abddSBruce Allan ice_fdb_del(struct ndmsg *ndm, __always_unused struct nlattr *tb[], 5732e94d4478SAnirudh Venkataramanan struct net_device *dev, const unsigned char *addr, 5733ca4567f1SAlaa Mohamed __always_unused u16 vid, struct netlink_ext_ack *extack) 5734e94d4478SAnirudh Venkataramanan { 5735e94d4478SAnirudh Venkataramanan int err; 5736e94d4478SAnirudh Venkataramanan 5737e94d4478SAnirudh Venkataramanan if (ndm->ndm_state & NUD_PERMANENT) { 5738e94d4478SAnirudh Venkataramanan netdev_err(dev, "FDB only supports static addresses\n"); 5739e94d4478SAnirudh Venkataramanan return -EINVAL; 5740e94d4478SAnirudh Venkataramanan } 5741e94d4478SAnirudh Venkataramanan 5742e94d4478SAnirudh Venkataramanan if (is_unicast_ether_addr(addr)) 5743e94d4478SAnirudh Venkataramanan err = dev_uc_del(dev, addr); 5744e94d4478SAnirudh Venkataramanan else if (is_multicast_ether_addr(addr)) 5745e94d4478SAnirudh Venkataramanan err = dev_mc_del(dev, addr); 5746e94d4478SAnirudh Venkataramanan else 5747e94d4478SAnirudh Venkataramanan err = -EINVAL; 5748e94d4478SAnirudh Venkataramanan 5749e94d4478SAnirudh Venkataramanan return err; 5750e94d4478SAnirudh Venkataramanan } 5751e94d4478SAnirudh Venkataramanan 57521babaf77SBrett Creeley #define NETIF_VLAN_OFFLOAD_FEATURES (NETIF_F_HW_VLAN_CTAG_RX | \ 57531babaf77SBrett Creeley NETIF_F_HW_VLAN_CTAG_TX | \ 57541babaf77SBrett Creeley NETIF_F_HW_VLAN_STAG_RX | \ 57551babaf77SBrett Creeley NETIF_F_HW_VLAN_STAG_TX) 57561babaf77SBrett Creeley 5757affa1029SAnatolii Gerasymenko #define NETIF_VLAN_STRIPPING_FEATURES (NETIF_F_HW_VLAN_CTAG_RX | \ 5758affa1029SAnatolii Gerasymenko NETIF_F_HW_VLAN_STAG_RX) 5759affa1029SAnatolii Gerasymenko 57601babaf77SBrett Creeley #define NETIF_VLAN_FILTERING_FEATURES (NETIF_F_HW_VLAN_CTAG_FILTER | \ 57611babaf77SBrett Creeley NETIF_F_HW_VLAN_STAG_FILTER) 57621babaf77SBrett Creeley 57631babaf77SBrett Creeley /** 57641babaf77SBrett Creeley * ice_fix_features - fix the netdev features flags based on device limitations 57651babaf77SBrett Creeley * @netdev: ptr to the netdev that flags are being fixed on 57661babaf77SBrett Creeley * @features: features that need to be checked and possibly fixed 57671babaf77SBrett Creeley * 57681babaf77SBrett Creeley * Make sure any fixups are made to features in this callback. This enables the 57691babaf77SBrett Creeley * driver to not have to check unsupported configurations throughout the driver 57701babaf77SBrett Creeley * because that's the responsiblity of this callback. 57711babaf77SBrett Creeley * 57721babaf77SBrett Creeley * Single VLAN Mode (SVM) Supported Features: 57731babaf77SBrett Creeley * NETIF_F_HW_VLAN_CTAG_FILTER 57741babaf77SBrett Creeley * NETIF_F_HW_VLAN_CTAG_RX 57751babaf77SBrett Creeley * NETIF_F_HW_VLAN_CTAG_TX 57761babaf77SBrett Creeley * 57771babaf77SBrett Creeley * Double VLAN Mode (DVM) Supported Features: 57781babaf77SBrett Creeley * NETIF_F_HW_VLAN_CTAG_FILTER 57791babaf77SBrett Creeley * NETIF_F_HW_VLAN_CTAG_RX 57801babaf77SBrett Creeley * NETIF_F_HW_VLAN_CTAG_TX 57811babaf77SBrett Creeley * 57821babaf77SBrett Creeley * NETIF_F_HW_VLAN_STAG_FILTER 57831babaf77SBrett Creeley * NETIF_HW_VLAN_STAG_RX 57841babaf77SBrett Creeley * NETIF_HW_VLAN_STAG_TX 57851babaf77SBrett Creeley * 57861babaf77SBrett Creeley * Features that need fixing: 57871babaf77SBrett Creeley * Cannot simultaneously enable CTAG and STAG stripping and/or insertion. 57881babaf77SBrett Creeley * These are mutually exlusive as the VSI context cannot support multiple 57891babaf77SBrett Creeley * VLAN ethertypes simultaneously for stripping and/or insertion. If this 57901babaf77SBrett Creeley * is not done, then default to clearing the requested STAG offload 57911babaf77SBrett Creeley * settings. 57921babaf77SBrett Creeley * 57931babaf77SBrett Creeley * All supported filtering has to be enabled or disabled together. For 57941babaf77SBrett Creeley * example, in DVM, CTAG and STAG filtering have to be enabled and disabled 57951babaf77SBrett Creeley * together. If this is not done, then default to VLAN filtering disabled. 57961babaf77SBrett Creeley * These are mutually exclusive as there is currently no way to 57971babaf77SBrett Creeley * enable/disable VLAN filtering based on VLAN ethertype when using VLAN 57981babaf77SBrett Creeley * prune rules. 57991babaf77SBrett Creeley */ 58001babaf77SBrett Creeley static netdev_features_t 58011babaf77SBrett Creeley ice_fix_features(struct net_device *netdev, netdev_features_t features) 58021babaf77SBrett Creeley { 58031babaf77SBrett Creeley struct ice_netdev_priv *np = netdev_priv(netdev); 58049542ef4fSRoman Storozhenko netdev_features_t req_vlan_fltr, cur_vlan_fltr; 58059542ef4fSRoman Storozhenko bool cur_ctag, cur_stag, req_ctag, req_stag; 58061babaf77SBrett Creeley 58079542ef4fSRoman Storozhenko cur_vlan_fltr = netdev->features & NETIF_VLAN_FILTERING_FEATURES; 58089542ef4fSRoman Storozhenko cur_ctag = cur_vlan_fltr & NETIF_F_HW_VLAN_CTAG_FILTER; 58099542ef4fSRoman Storozhenko cur_stag = cur_vlan_fltr & NETIF_F_HW_VLAN_STAG_FILTER; 58101babaf77SBrett Creeley 58119542ef4fSRoman Storozhenko req_vlan_fltr = features & NETIF_VLAN_FILTERING_FEATURES; 58129542ef4fSRoman Storozhenko req_ctag = req_vlan_fltr & NETIF_F_HW_VLAN_CTAG_FILTER; 58139542ef4fSRoman Storozhenko req_stag = req_vlan_fltr & NETIF_F_HW_VLAN_STAG_FILTER; 58141babaf77SBrett Creeley 58159542ef4fSRoman Storozhenko if (req_vlan_fltr != cur_vlan_fltr) { 58169542ef4fSRoman Storozhenko if (ice_is_dvm_ena(&np->vsi->back->hw)) { 58179542ef4fSRoman Storozhenko if (req_ctag && req_stag) { 58189542ef4fSRoman Storozhenko features |= NETIF_VLAN_FILTERING_FEATURES; 58199542ef4fSRoman Storozhenko } else if (!req_ctag && !req_stag) { 58209542ef4fSRoman Storozhenko features &= ~NETIF_VLAN_FILTERING_FEATURES; 58219542ef4fSRoman Storozhenko } else if ((!cur_ctag && req_ctag && !cur_stag) || 58229542ef4fSRoman Storozhenko (!cur_stag && req_stag && !cur_ctag)) { 58239542ef4fSRoman Storozhenko features |= NETIF_VLAN_FILTERING_FEATURES; 58249542ef4fSRoman Storozhenko netdev_warn(netdev, "802.1Q and 802.1ad VLAN filtering must be either both on or both off. VLAN filtering has been enabled for both types.\n"); 58259542ef4fSRoman Storozhenko } else if ((cur_ctag && !req_ctag && cur_stag) || 58269542ef4fSRoman Storozhenko (cur_stag && !req_stag && cur_ctag)) { 58279542ef4fSRoman Storozhenko features &= ~NETIF_VLAN_FILTERING_FEATURES; 58289542ef4fSRoman Storozhenko netdev_warn(netdev, "802.1Q and 802.1ad VLAN filtering must be either both on or both off. VLAN filtering has been disabled for both types.\n"); 58299542ef4fSRoman Storozhenko } 58301babaf77SBrett Creeley } else { 58319542ef4fSRoman Storozhenko if (req_vlan_fltr & NETIF_F_HW_VLAN_STAG_FILTER) 58329542ef4fSRoman Storozhenko netdev_warn(netdev, "cannot support requested 802.1ad filtering setting in SVM mode\n"); 58339542ef4fSRoman Storozhenko 58349542ef4fSRoman Storozhenko if (req_vlan_fltr & NETIF_F_HW_VLAN_CTAG_FILTER) 58359542ef4fSRoman Storozhenko features |= NETIF_F_HW_VLAN_CTAG_FILTER; 58361babaf77SBrett Creeley } 58371babaf77SBrett Creeley } 58381babaf77SBrett Creeley 58391babaf77SBrett Creeley if ((features & (NETIF_F_HW_VLAN_CTAG_RX | NETIF_F_HW_VLAN_CTAG_TX)) && 58401babaf77SBrett Creeley (features & (NETIF_F_HW_VLAN_STAG_RX | NETIF_F_HW_VLAN_STAG_TX))) { 58411babaf77SBrett Creeley netdev_warn(netdev, "cannot support CTAG and STAG VLAN stripping and/or insertion simultaneously since CTAG and STAG offloads are mutually exclusive, clearing STAG offload settings\n"); 58421babaf77SBrett Creeley features &= ~(NETIF_F_HW_VLAN_STAG_RX | 58431babaf77SBrett Creeley NETIF_F_HW_VLAN_STAG_TX); 58441babaf77SBrett Creeley } 58451babaf77SBrett Creeley 5846affa1029SAnatolii Gerasymenko if (!(netdev->features & NETIF_F_RXFCS) && 5847affa1029SAnatolii Gerasymenko (features & NETIF_F_RXFCS) && 5848affa1029SAnatolii Gerasymenko (features & NETIF_VLAN_STRIPPING_FEATURES) && 5849affa1029SAnatolii Gerasymenko !ice_vsi_has_non_zero_vlans(np->vsi)) { 5850affa1029SAnatolii Gerasymenko netdev_warn(netdev, "Disabling VLAN stripping as FCS/CRC stripping is also disabled and there is no VLAN configured\n"); 5851affa1029SAnatolii Gerasymenko features &= ~NETIF_VLAN_STRIPPING_FEATURES; 5852affa1029SAnatolii Gerasymenko } 5853affa1029SAnatolii Gerasymenko 58541babaf77SBrett Creeley return features; 58551babaf77SBrett Creeley } 58561babaf77SBrett Creeley 58571babaf77SBrett Creeley /** 58581babaf77SBrett Creeley * ice_set_vlan_offload_features - set VLAN offload features for the PF VSI 58591babaf77SBrett Creeley * @vsi: PF's VSI 58601babaf77SBrett Creeley * @features: features used to determine VLAN offload settings 58611babaf77SBrett Creeley * 58621babaf77SBrett Creeley * First, determine the vlan_ethertype based on the VLAN offload bits in 58631babaf77SBrett Creeley * features. Then determine if stripping and insertion should be enabled or 58641babaf77SBrett Creeley * disabled. Finally enable or disable VLAN stripping and insertion. 58651babaf77SBrett Creeley */ 58661babaf77SBrett Creeley static int 58671babaf77SBrett Creeley ice_set_vlan_offload_features(struct ice_vsi *vsi, netdev_features_t features) 58681babaf77SBrett Creeley { 58691babaf77SBrett Creeley bool enable_stripping = true, enable_insertion = true; 58701babaf77SBrett Creeley struct ice_vsi_vlan_ops *vlan_ops; 58711babaf77SBrett Creeley int strip_err = 0, insert_err = 0; 58721babaf77SBrett Creeley u16 vlan_ethertype = 0; 58731babaf77SBrett Creeley 58741babaf77SBrett Creeley vlan_ops = ice_get_compat_vsi_vlan_ops(vsi); 58751babaf77SBrett Creeley 58761babaf77SBrett Creeley if (features & (NETIF_F_HW_VLAN_STAG_RX | NETIF_F_HW_VLAN_STAG_TX)) 58771babaf77SBrett Creeley vlan_ethertype = ETH_P_8021AD; 58781babaf77SBrett Creeley else if (features & (NETIF_F_HW_VLAN_CTAG_RX | NETIF_F_HW_VLAN_CTAG_TX)) 58791babaf77SBrett Creeley vlan_ethertype = ETH_P_8021Q; 58801babaf77SBrett Creeley 58811babaf77SBrett Creeley if (!(features & (NETIF_F_HW_VLAN_STAG_RX | NETIF_F_HW_VLAN_CTAG_RX))) 58821babaf77SBrett Creeley enable_stripping = false; 58831babaf77SBrett Creeley if (!(features & (NETIF_F_HW_VLAN_STAG_TX | NETIF_F_HW_VLAN_CTAG_TX))) 58841babaf77SBrett Creeley enable_insertion = false; 58851babaf77SBrett Creeley 58861babaf77SBrett Creeley if (enable_stripping) 58871babaf77SBrett Creeley strip_err = vlan_ops->ena_stripping(vsi, vlan_ethertype); 58881babaf77SBrett Creeley else 58891babaf77SBrett Creeley strip_err = vlan_ops->dis_stripping(vsi); 58901babaf77SBrett Creeley 58911babaf77SBrett Creeley if (enable_insertion) 58921babaf77SBrett Creeley insert_err = vlan_ops->ena_insertion(vsi, vlan_ethertype); 58931babaf77SBrett Creeley else 58941babaf77SBrett Creeley insert_err = vlan_ops->dis_insertion(vsi); 58951babaf77SBrett Creeley 58961babaf77SBrett Creeley if (strip_err || insert_err) 58971babaf77SBrett Creeley return -EIO; 58981babaf77SBrett Creeley 58991babaf77SBrett Creeley return 0; 59001babaf77SBrett Creeley } 59011babaf77SBrett Creeley 59021babaf77SBrett Creeley /** 59031babaf77SBrett Creeley * ice_set_vlan_filtering_features - set VLAN filtering features for the PF VSI 59041babaf77SBrett Creeley * @vsi: PF's VSI 59051babaf77SBrett Creeley * @features: features used to determine VLAN filtering settings 59061babaf77SBrett Creeley * 59071babaf77SBrett Creeley * Enable or disable Rx VLAN filtering based on the VLAN filtering bits in the 59081babaf77SBrett Creeley * features. 59091babaf77SBrett Creeley */ 59101babaf77SBrett Creeley static int 59111babaf77SBrett Creeley ice_set_vlan_filtering_features(struct ice_vsi *vsi, netdev_features_t features) 59121babaf77SBrett Creeley { 59131babaf77SBrett Creeley struct ice_vsi_vlan_ops *vlan_ops = ice_get_compat_vsi_vlan_ops(vsi); 59141babaf77SBrett Creeley int err = 0; 59151babaf77SBrett Creeley 59161babaf77SBrett Creeley /* support Single VLAN Mode (SVM) and Double VLAN Mode (DVM) by checking 59171babaf77SBrett Creeley * if either bit is set 59181babaf77SBrett Creeley */ 59191babaf77SBrett Creeley if (features & 59201babaf77SBrett Creeley (NETIF_F_HW_VLAN_CTAG_FILTER | NETIF_F_HW_VLAN_STAG_FILTER)) 59211babaf77SBrett Creeley err = vlan_ops->ena_rx_filtering(vsi); 59221babaf77SBrett Creeley else 59231babaf77SBrett Creeley err = vlan_ops->dis_rx_filtering(vsi); 59241babaf77SBrett Creeley 59251babaf77SBrett Creeley return err; 59261babaf77SBrett Creeley } 59271babaf77SBrett Creeley 59281babaf77SBrett Creeley /** 59291babaf77SBrett Creeley * ice_set_vlan_features - set VLAN settings based on suggested feature set 59301babaf77SBrett Creeley * @netdev: ptr to the netdev being adjusted 59311babaf77SBrett Creeley * @features: the feature set that the stack is suggesting 59321babaf77SBrett Creeley * 59331babaf77SBrett Creeley * Only update VLAN settings if the requested_vlan_features are different than 59341babaf77SBrett Creeley * the current_vlan_features. 59351babaf77SBrett Creeley */ 59361babaf77SBrett Creeley static int 59371babaf77SBrett Creeley ice_set_vlan_features(struct net_device *netdev, netdev_features_t features) 59381babaf77SBrett Creeley { 59391babaf77SBrett Creeley netdev_features_t current_vlan_features, requested_vlan_features; 59401babaf77SBrett Creeley struct ice_netdev_priv *np = netdev_priv(netdev); 59411babaf77SBrett Creeley struct ice_vsi *vsi = np->vsi; 59421babaf77SBrett Creeley int err; 59431babaf77SBrett Creeley 59441babaf77SBrett Creeley current_vlan_features = netdev->features & NETIF_VLAN_OFFLOAD_FEATURES; 59451babaf77SBrett Creeley requested_vlan_features = features & NETIF_VLAN_OFFLOAD_FEATURES; 59461babaf77SBrett Creeley if (current_vlan_features ^ requested_vlan_features) { 5947affa1029SAnatolii Gerasymenko if ((features & NETIF_F_RXFCS) && 5948affa1029SAnatolii Gerasymenko (features & NETIF_VLAN_STRIPPING_FEATURES)) { 5949affa1029SAnatolii Gerasymenko dev_err(ice_pf_to_dev(vsi->back), 5950affa1029SAnatolii Gerasymenko "To enable VLAN stripping, you must first enable FCS/CRC stripping\n"); 5951affa1029SAnatolii Gerasymenko return -EIO; 5952affa1029SAnatolii Gerasymenko } 5953affa1029SAnatolii Gerasymenko 59541babaf77SBrett Creeley err = ice_set_vlan_offload_features(vsi, features); 59551babaf77SBrett Creeley if (err) 59561babaf77SBrett Creeley return err; 59571babaf77SBrett Creeley } 59581babaf77SBrett Creeley 59591babaf77SBrett Creeley current_vlan_features = netdev->features & 59601babaf77SBrett Creeley NETIF_VLAN_FILTERING_FEATURES; 59611babaf77SBrett Creeley requested_vlan_features = features & NETIF_VLAN_FILTERING_FEATURES; 59621babaf77SBrett Creeley if (current_vlan_features ^ requested_vlan_features) { 59631babaf77SBrett Creeley err = ice_set_vlan_filtering_features(vsi, features); 59641babaf77SBrett Creeley if (err) 59651babaf77SBrett Creeley return err; 59661babaf77SBrett Creeley } 59671babaf77SBrett Creeley 59681babaf77SBrett Creeley return 0; 59691babaf77SBrett Creeley } 59701babaf77SBrett Creeley 5971e94d4478SAnirudh Venkataramanan /** 597244ece4e1SMaciej Fijalkowski * ice_set_loopback - turn on/off loopback mode on underlying PF 597344ece4e1SMaciej Fijalkowski * @vsi: ptr to VSI 597444ece4e1SMaciej Fijalkowski * @ena: flag to indicate the on/off setting 597544ece4e1SMaciej Fijalkowski */ 597644ece4e1SMaciej Fijalkowski static int ice_set_loopback(struct ice_vsi *vsi, bool ena) 597744ece4e1SMaciej Fijalkowski { 597844ece4e1SMaciej Fijalkowski bool if_running = netif_running(vsi->netdev); 597944ece4e1SMaciej Fijalkowski int ret; 598044ece4e1SMaciej Fijalkowski 598144ece4e1SMaciej Fijalkowski if (if_running && !test_and_set_bit(ICE_VSI_DOWN, vsi->state)) { 598244ece4e1SMaciej Fijalkowski ret = ice_down(vsi); 598344ece4e1SMaciej Fijalkowski if (ret) { 598444ece4e1SMaciej Fijalkowski netdev_err(vsi->netdev, "Preparing device to toggle loopback failed\n"); 598544ece4e1SMaciej Fijalkowski return ret; 598644ece4e1SMaciej Fijalkowski } 598744ece4e1SMaciej Fijalkowski } 598844ece4e1SMaciej Fijalkowski ret = ice_aq_set_mac_loopback(&vsi->back->hw, ena, NULL); 598944ece4e1SMaciej Fijalkowski if (ret) 599044ece4e1SMaciej Fijalkowski netdev_err(vsi->netdev, "Failed to toggle loopback state\n"); 599144ece4e1SMaciej Fijalkowski if (if_running) 599244ece4e1SMaciej Fijalkowski ret = ice_up(vsi); 599344ece4e1SMaciej Fijalkowski 599444ece4e1SMaciej Fijalkowski return ret; 599544ece4e1SMaciej Fijalkowski } 599644ece4e1SMaciej Fijalkowski 599744ece4e1SMaciej Fijalkowski /** 5998d76a60baSAnirudh Venkataramanan * ice_set_features - set the netdev feature flags 5999d76a60baSAnirudh Venkataramanan * @netdev: ptr to the netdev being adjusted 6000d76a60baSAnirudh Venkataramanan * @features: the feature set that the stack is suggesting 6001d76a60baSAnirudh Venkataramanan */ 6002c8b7abddSBruce Allan static int 6003c8b7abddSBruce Allan ice_set_features(struct net_device *netdev, netdev_features_t features) 6004d76a60baSAnirudh Venkataramanan { 6005c67672faSMaciej Fijalkowski netdev_features_t changed = netdev->features ^ features; 6006d76a60baSAnirudh Venkataramanan struct ice_netdev_priv *np = netdev_priv(netdev); 6007d76a60baSAnirudh Venkataramanan struct ice_vsi *vsi = np->vsi; 60085f8cc355SHenry Tieman struct ice_pf *pf = vsi->back; 6009d76a60baSAnirudh Venkataramanan int ret = 0; 6010d76a60baSAnirudh Venkataramanan 6011462acf6aSTony Nguyen /* Don't set any netdev advanced features with device in Safe Mode */ 6012c67672faSMaciej Fijalkowski if (ice_is_safe_mode(pf)) { 6013c67672faSMaciej Fijalkowski dev_err(ice_pf_to_dev(pf), 6014c67672faSMaciej Fijalkowski "Device is in Safe Mode - not enabling advanced netdev features\n"); 6015462acf6aSTony Nguyen return ret; 6016462acf6aSTony Nguyen } 6017462acf6aSTony Nguyen 60185f8cc355SHenry Tieman /* Do not change setting during reset */ 60195f8cc355SHenry Tieman if (ice_is_reset_in_progress(pf->state)) { 6020c67672faSMaciej Fijalkowski dev_err(ice_pf_to_dev(pf), 6021c67672faSMaciej Fijalkowski "Device is resetting, changing advanced netdev features temporarily unavailable.\n"); 60225f8cc355SHenry Tieman return -EBUSY; 60235f8cc355SHenry Tieman } 60245f8cc355SHenry Tieman 60258f529ff9STony Nguyen /* Multiple features can be changed in one call so keep features in 60268f529ff9STony Nguyen * separate if/else statements to guarantee each feature is checked 60278f529ff9STony Nguyen */ 6028c67672faSMaciej Fijalkowski if (changed & NETIF_F_RXHASH) 6029c67672faSMaciej Fijalkowski ice_vsi_manage_rss_lut(vsi, !!(features & NETIF_F_RXHASH)); 6030492af0abSMd Fahad Iqbal Polash 60311babaf77SBrett Creeley ret = ice_set_vlan_features(netdev, features); 60321babaf77SBrett Creeley if (ret) 60331babaf77SBrett Creeley return ret; 60343171948eSTony Nguyen 6035dddd406dSJesse Brandeburg /* Turn on receive of FCS aka CRC, and after setting this 6036dddd406dSJesse Brandeburg * flag the packet data will have the 4 byte CRC appended 6037dddd406dSJesse Brandeburg */ 6038dddd406dSJesse Brandeburg if (changed & NETIF_F_RXFCS) { 6039affa1029SAnatolii Gerasymenko if ((features & NETIF_F_RXFCS) && 6040affa1029SAnatolii Gerasymenko (features & NETIF_VLAN_STRIPPING_FEATURES)) { 6041affa1029SAnatolii Gerasymenko dev_err(ice_pf_to_dev(vsi->back), 6042affa1029SAnatolii Gerasymenko "To disable FCS/CRC stripping, you must first disable VLAN stripping\n"); 6043affa1029SAnatolii Gerasymenko return -EIO; 6044affa1029SAnatolii Gerasymenko } 6045affa1029SAnatolii Gerasymenko 6046dddd406dSJesse Brandeburg ice_vsi_cfg_crc_strip(vsi, !!(features & NETIF_F_RXFCS)); 6047dddd406dSJesse Brandeburg ret = ice_down_up(vsi); 6048dddd406dSJesse Brandeburg if (ret) 6049dddd406dSJesse Brandeburg return ret; 6050dddd406dSJesse Brandeburg } 6051dddd406dSJesse Brandeburg 6052c67672faSMaciej Fijalkowski if (changed & NETIF_F_NTUPLE) { 6053c67672faSMaciej Fijalkowski bool ena = !!(features & NETIF_F_NTUPLE); 6054c67672faSMaciej Fijalkowski 6055c67672faSMaciej Fijalkowski ice_vsi_manage_fdir(vsi, ena); 6056c67672faSMaciej Fijalkowski ena ? ice_init_arfs(vsi) : ice_clear_arfs(vsi); 605728bf2672SBrett Creeley } 6058148beb61SHenry Tieman 6059fbc7b27aSKiran Patil /* don't turn off hw_tc_offload when ADQ is already enabled */ 6060fbc7b27aSKiran Patil if (!(features & NETIF_F_HW_TC) && ice_is_adq_active(pf)) { 6061fbc7b27aSKiran Patil dev_err(ice_pf_to_dev(pf), "ADQ is active, can't turn hw_tc_offload off\n"); 6062fbc7b27aSKiran Patil return -EACCES; 6063fbc7b27aSKiran Patil } 60649fea7498SKiran Patil 6065c67672faSMaciej Fijalkowski if (changed & NETIF_F_HW_TC) { 6066c67672faSMaciej Fijalkowski bool ena = !!(features & NETIF_F_HW_TC); 60679fea7498SKiran Patil 6068c67672faSMaciej Fijalkowski ena ? set_bit(ICE_FLAG_CLS_FLOWER, pf->flags) : 6069f9867df6SAnirudh Venkataramanan clear_bit(ICE_FLAG_CLS_FLOWER, pf->flags); 6070c67672faSMaciej Fijalkowski } 6071d76a60baSAnirudh Venkataramanan 607244ece4e1SMaciej Fijalkowski if (changed & NETIF_F_LOOPBACK) 607344ece4e1SMaciej Fijalkowski ret = ice_set_loopback(vsi, !!(features & NETIF_F_LOOPBACK)); 607444ece4e1SMaciej Fijalkowski 607544ece4e1SMaciej Fijalkowski return ret; 6076d76a60baSAnirudh Venkataramanan } 6077d76a60baSAnirudh Venkataramanan 6078d76a60baSAnirudh Venkataramanan /** 6079c31af68aSBrett Creeley * ice_vsi_vlan_setup - Setup VLAN offload properties on a PF VSI 6080d76a60baSAnirudh Venkataramanan * @vsi: VSI to setup VLAN properties for 6081d76a60baSAnirudh Venkataramanan */ 6082d76a60baSAnirudh Venkataramanan static int ice_vsi_vlan_setup(struct ice_vsi *vsi) 6083d76a60baSAnirudh Venkataramanan { 60841babaf77SBrett Creeley int err; 6085d76a60baSAnirudh Venkataramanan 60861babaf77SBrett Creeley err = ice_set_vlan_offload_features(vsi, vsi->netdev->features); 60871babaf77SBrett Creeley if (err) 60881babaf77SBrett Creeley return err; 6089d76a60baSAnirudh Venkataramanan 60901babaf77SBrett Creeley err = ice_set_vlan_filtering_features(vsi, vsi->netdev->features); 60911babaf77SBrett Creeley if (err) 60921babaf77SBrett Creeley return err; 6093d76a60baSAnirudh Venkataramanan 6094c31af68aSBrett Creeley return ice_vsi_add_vlan_zero(vsi); 6095d76a60baSAnirudh Venkataramanan } 6096d76a60baSAnirudh Venkataramanan 6097d76a60baSAnirudh Venkataramanan /** 6098cdedef59SAnirudh Venkataramanan * ice_vsi_cfg - Setup the VSI 6099cdedef59SAnirudh Venkataramanan * @vsi: the VSI being configured 6100cdedef59SAnirudh Venkataramanan * 6101cdedef59SAnirudh Venkataramanan * Return 0 on success and negative value on error 6102cdedef59SAnirudh Venkataramanan */ 61030e674aebSAnirudh Venkataramanan int ice_vsi_cfg(struct ice_vsi *vsi) 6104cdedef59SAnirudh Venkataramanan { 6105cdedef59SAnirudh Venkataramanan int err; 6106cdedef59SAnirudh Venkataramanan 6107c7f2c42bSAnirudh Venkataramanan if (vsi->netdev) { 6108e94d4478SAnirudh Venkataramanan ice_set_rx_mode(vsi->netdev); 61099ecd25c2SAnirudh Venkataramanan 6110cc019545SMaciej Fijalkowski if (vsi->type != ICE_VSI_LB) { 61119ecd25c2SAnirudh Venkataramanan err = ice_vsi_vlan_setup(vsi); 61129ecd25c2SAnirudh Venkataramanan 6113d76a60baSAnirudh Venkataramanan if (err) 6114d76a60baSAnirudh Venkataramanan return err; 6115c7f2c42bSAnirudh Venkataramanan } 6116cc019545SMaciej Fijalkowski } 6117a629cf0aSAnirudh Venkataramanan ice_vsi_cfg_dcb_rings(vsi); 611803f7a986SAnirudh Venkataramanan 611903f7a986SAnirudh Venkataramanan err = ice_vsi_cfg_lan_txqs(vsi); 6120efc2214bSMaciej Fijalkowski if (!err && ice_is_xdp_ena_vsi(vsi)) 6121efc2214bSMaciej Fijalkowski err = ice_vsi_cfg_xdp_txqs(vsi); 6122cdedef59SAnirudh Venkataramanan if (!err) 6123cdedef59SAnirudh Venkataramanan err = ice_vsi_cfg_rxqs(vsi); 6124cdedef59SAnirudh Venkataramanan 6125cdedef59SAnirudh Venkataramanan return err; 6126cdedef59SAnirudh Venkataramanan } 6127cdedef59SAnirudh Venkataramanan 6128cdf1f1f1SJacob Keller /* THEORY OF MODERATION: 6129d8eb7ad5SJesse Brandeburg * The ice driver hardware works differently than the hardware that DIMLIB was 6130cdf1f1f1SJacob Keller * originally made for. ice hardware doesn't have packet count limits that 6131cdf1f1f1SJacob Keller * can trigger an interrupt, but it *does* have interrupt rate limit support, 6132d8eb7ad5SJesse Brandeburg * which is hard-coded to a limit of 250,000 ints/second. 6133d8eb7ad5SJesse Brandeburg * If not using dynamic moderation, the INTRL value can be modified 6134d8eb7ad5SJesse Brandeburg * by ethtool rx-usecs-high. 6135cdf1f1f1SJacob Keller */ 6136cdf1f1f1SJacob Keller struct ice_dim { 6137cdf1f1f1SJacob Keller /* the throttle rate for interrupts, basically worst case delay before 6138cdf1f1f1SJacob Keller * an initial interrupt fires, value is stored in microseconds. 6139cdf1f1f1SJacob Keller */ 6140cdf1f1f1SJacob Keller u16 itr; 6141cdf1f1f1SJacob Keller }; 6142cdf1f1f1SJacob Keller 6143cdf1f1f1SJacob Keller /* Make a different profile for Rx that doesn't allow quite so aggressive 6144d8eb7ad5SJesse Brandeburg * moderation at the high end (it maxes out at 126us or about 8k interrupts a 6145d8eb7ad5SJesse Brandeburg * second. 6146cdf1f1f1SJacob Keller */ 6147cdf1f1f1SJacob Keller static const struct ice_dim rx_profile[] = { 6148d8eb7ad5SJesse Brandeburg {2}, /* 500,000 ints/s, capped at 250K by INTRL */ 6149d8eb7ad5SJesse Brandeburg {8}, /* 125,000 ints/s */ 6150d8eb7ad5SJesse Brandeburg {16}, /* 62,500 ints/s */ 6151d8eb7ad5SJesse Brandeburg {62}, /* 16,129 ints/s */ 6152d8eb7ad5SJesse Brandeburg {126} /* 7,936 ints/s */ 6153cdf1f1f1SJacob Keller }; 6154cdf1f1f1SJacob Keller 6155cdf1f1f1SJacob Keller /* The transmit profile, which has the same sorts of values 6156cdf1f1f1SJacob Keller * as the previous struct 6157cdf1f1f1SJacob Keller */ 6158cdf1f1f1SJacob Keller static const struct ice_dim tx_profile[] = { 6159d8eb7ad5SJesse Brandeburg {2}, /* 500,000 ints/s, capped at 250K by INTRL */ 6160d8eb7ad5SJesse Brandeburg {8}, /* 125,000 ints/s */ 6161d8eb7ad5SJesse Brandeburg {40}, /* 16,125 ints/s */ 6162d8eb7ad5SJesse Brandeburg {128}, /* 7,812 ints/s */ 6163d8eb7ad5SJesse Brandeburg {256} /* 3,906 ints/s */ 6164cdf1f1f1SJacob Keller }; 6165cdf1f1f1SJacob Keller 6166cdf1f1f1SJacob Keller static void ice_tx_dim_work(struct work_struct *work) 6167cdf1f1f1SJacob Keller { 6168cdf1f1f1SJacob Keller struct ice_ring_container *rc; 6169cdf1f1f1SJacob Keller struct dim *dim; 6170d8eb7ad5SJesse Brandeburg u16 itr; 6171cdf1f1f1SJacob Keller 6172cdf1f1f1SJacob Keller dim = container_of(work, struct dim, work); 6173d8eb7ad5SJesse Brandeburg rc = (struct ice_ring_container *)dim->priv; 6174cdf1f1f1SJacob Keller 6175d8eb7ad5SJesse Brandeburg WARN_ON(dim->profile_ix >= ARRAY_SIZE(tx_profile)); 6176cdf1f1f1SJacob Keller 6177cdf1f1f1SJacob Keller /* look up the values in our local table */ 6178cdf1f1f1SJacob Keller itr = tx_profile[dim->profile_ix].itr; 6179cdf1f1f1SJacob Keller 6180d8eb7ad5SJesse Brandeburg ice_trace(tx_dim_work, container_of(rc, struct ice_q_vector, tx), dim); 6181cdf1f1f1SJacob Keller ice_write_itr(rc, itr); 6182cdf1f1f1SJacob Keller 6183cdf1f1f1SJacob Keller dim->state = DIM_START_MEASURE; 6184cdf1f1f1SJacob Keller } 6185cdf1f1f1SJacob Keller 6186cdf1f1f1SJacob Keller static void ice_rx_dim_work(struct work_struct *work) 6187cdf1f1f1SJacob Keller { 6188cdf1f1f1SJacob Keller struct ice_ring_container *rc; 6189cdf1f1f1SJacob Keller struct dim *dim; 6190d8eb7ad5SJesse Brandeburg u16 itr; 6191cdf1f1f1SJacob Keller 6192cdf1f1f1SJacob Keller dim = container_of(work, struct dim, work); 6193d8eb7ad5SJesse Brandeburg rc = (struct ice_ring_container *)dim->priv; 6194cdf1f1f1SJacob Keller 6195d8eb7ad5SJesse Brandeburg WARN_ON(dim->profile_ix >= ARRAY_SIZE(rx_profile)); 6196cdf1f1f1SJacob Keller 6197cdf1f1f1SJacob Keller /* look up the values in our local table */ 6198cdf1f1f1SJacob Keller itr = rx_profile[dim->profile_ix].itr; 6199cdf1f1f1SJacob Keller 6200d8eb7ad5SJesse Brandeburg ice_trace(rx_dim_work, container_of(rc, struct ice_q_vector, rx), dim); 6201cdf1f1f1SJacob Keller ice_write_itr(rc, itr); 6202cdf1f1f1SJacob Keller 6203cdf1f1f1SJacob Keller dim->state = DIM_START_MEASURE; 6204cdf1f1f1SJacob Keller } 6205cdf1f1f1SJacob Keller 6206d8eb7ad5SJesse Brandeburg #define ICE_DIM_DEFAULT_PROFILE_IX 1 6207d8eb7ad5SJesse Brandeburg 6208d8eb7ad5SJesse Brandeburg /** 6209d8eb7ad5SJesse Brandeburg * ice_init_moderation - set up interrupt moderation 6210d8eb7ad5SJesse Brandeburg * @q_vector: the vector containing rings to be configured 6211d8eb7ad5SJesse Brandeburg * 6212d8eb7ad5SJesse Brandeburg * Set up interrupt moderation registers, with the intent to do the right thing 6213d8eb7ad5SJesse Brandeburg * when called from reset or from probe, and whether or not dynamic moderation 6214d8eb7ad5SJesse Brandeburg * is enabled or not. Take special care to write all the registers in both 6215d8eb7ad5SJesse Brandeburg * dynamic moderation mode or not in order to make sure hardware is in a known 6216d8eb7ad5SJesse Brandeburg * state. 6217d8eb7ad5SJesse Brandeburg */ 6218d8eb7ad5SJesse Brandeburg static void ice_init_moderation(struct ice_q_vector *q_vector) 6219d8eb7ad5SJesse Brandeburg { 6220d8eb7ad5SJesse Brandeburg struct ice_ring_container *rc; 6221d8eb7ad5SJesse Brandeburg bool tx_dynamic, rx_dynamic; 6222d8eb7ad5SJesse Brandeburg 6223d8eb7ad5SJesse Brandeburg rc = &q_vector->tx; 6224d8eb7ad5SJesse Brandeburg INIT_WORK(&rc->dim.work, ice_tx_dim_work); 6225d8eb7ad5SJesse Brandeburg rc->dim.mode = DIM_CQ_PERIOD_MODE_START_FROM_EQE; 6226d8eb7ad5SJesse Brandeburg rc->dim.profile_ix = ICE_DIM_DEFAULT_PROFILE_IX; 6227d8eb7ad5SJesse Brandeburg rc->dim.priv = rc; 6228d8eb7ad5SJesse Brandeburg tx_dynamic = ITR_IS_DYNAMIC(rc); 6229d8eb7ad5SJesse Brandeburg 6230d8eb7ad5SJesse Brandeburg /* set the initial TX ITR to match the above */ 6231d8eb7ad5SJesse Brandeburg ice_write_itr(rc, tx_dynamic ? 6232d8eb7ad5SJesse Brandeburg tx_profile[rc->dim.profile_ix].itr : rc->itr_setting); 6233d8eb7ad5SJesse Brandeburg 6234d8eb7ad5SJesse Brandeburg rc = &q_vector->rx; 6235d8eb7ad5SJesse Brandeburg INIT_WORK(&rc->dim.work, ice_rx_dim_work); 6236d8eb7ad5SJesse Brandeburg rc->dim.mode = DIM_CQ_PERIOD_MODE_START_FROM_EQE; 6237d8eb7ad5SJesse Brandeburg rc->dim.profile_ix = ICE_DIM_DEFAULT_PROFILE_IX; 6238d8eb7ad5SJesse Brandeburg rc->dim.priv = rc; 6239d8eb7ad5SJesse Brandeburg rx_dynamic = ITR_IS_DYNAMIC(rc); 6240d8eb7ad5SJesse Brandeburg 6241d8eb7ad5SJesse Brandeburg /* set the initial RX ITR to match the above */ 6242d8eb7ad5SJesse Brandeburg ice_write_itr(rc, rx_dynamic ? rx_profile[rc->dim.profile_ix].itr : 6243d8eb7ad5SJesse Brandeburg rc->itr_setting); 6244d8eb7ad5SJesse Brandeburg 6245d8eb7ad5SJesse Brandeburg ice_set_q_vector_intrl(q_vector); 6246d8eb7ad5SJesse Brandeburg } 6247d8eb7ad5SJesse Brandeburg 6248cdedef59SAnirudh Venkataramanan /** 62492b245cb2SAnirudh Venkataramanan * ice_napi_enable_all - Enable NAPI for all q_vectors in the VSI 62502b245cb2SAnirudh Venkataramanan * @vsi: the VSI being configured 62512b245cb2SAnirudh Venkataramanan */ 62522b245cb2SAnirudh Venkataramanan static void ice_napi_enable_all(struct ice_vsi *vsi) 62532b245cb2SAnirudh Venkataramanan { 62542b245cb2SAnirudh Venkataramanan int q_idx; 62552b245cb2SAnirudh Venkataramanan 62562b245cb2SAnirudh Venkataramanan if (!vsi->netdev) 62572b245cb2SAnirudh Venkataramanan return; 62582b245cb2SAnirudh Venkataramanan 62590c2561c8SBrett Creeley ice_for_each_q_vector(vsi, q_idx) { 6260eec90376SYoung Xiao struct ice_q_vector *q_vector = vsi->q_vectors[q_idx]; 6261eec90376SYoung Xiao 6262d8eb7ad5SJesse Brandeburg ice_init_moderation(q_vector); 6263cdf1f1f1SJacob Keller 6264e72bba21SMaciej Fijalkowski if (q_vector->rx.rx_ring || q_vector->tx.tx_ring) 6265eec90376SYoung Xiao napi_enable(&q_vector->napi); 6266eec90376SYoung Xiao } 62672b245cb2SAnirudh Venkataramanan } 62682b245cb2SAnirudh Venkataramanan 62692b245cb2SAnirudh Venkataramanan /** 6270cdedef59SAnirudh Venkataramanan * ice_up_complete - Finish the last steps of bringing up a connection 6271cdedef59SAnirudh Venkataramanan * @vsi: The VSI being configured 6272cdedef59SAnirudh Venkataramanan * 6273cdedef59SAnirudh Venkataramanan * Return 0 on success and negative value on error 6274cdedef59SAnirudh Venkataramanan */ 6275cdedef59SAnirudh Venkataramanan static int ice_up_complete(struct ice_vsi *vsi) 6276cdedef59SAnirudh Venkataramanan { 6277cdedef59SAnirudh Venkataramanan struct ice_pf *pf = vsi->back; 6278cdedef59SAnirudh Venkataramanan int err; 6279cdedef59SAnirudh Venkataramanan 6280cdedef59SAnirudh Venkataramanan ice_vsi_cfg_msix(vsi); 6281cdedef59SAnirudh Venkataramanan 6282cdedef59SAnirudh Venkataramanan /* Enable only Rx rings, Tx rings were enabled by the FW when the 6283cdedef59SAnirudh Venkataramanan * Tx queue group list was configured and the context bits were 6284cdedef59SAnirudh Venkataramanan * programmed using ice_vsi_cfg_txqs 6285cdedef59SAnirudh Venkataramanan */ 628613a6233bSBrett Creeley err = ice_vsi_start_all_rx_rings(vsi); 6287cdedef59SAnirudh Venkataramanan if (err) 6288cdedef59SAnirudh Venkataramanan return err; 6289cdedef59SAnirudh Venkataramanan 6290e97fb1aeSAnirudh Venkataramanan clear_bit(ICE_VSI_DOWN, vsi->state); 62912b245cb2SAnirudh Venkataramanan ice_napi_enable_all(vsi); 6292cdedef59SAnirudh Venkataramanan ice_vsi_ena_irq(vsi); 6293cdedef59SAnirudh Venkataramanan 6294cdedef59SAnirudh Venkataramanan if (vsi->port_info && 6295cdedef59SAnirudh Venkataramanan (vsi->port_info->phy.link_info.link_info & ICE_AQ_LINK_UP) && 6296cdedef59SAnirudh Venkataramanan vsi->netdev) { 6297cdedef59SAnirudh Venkataramanan ice_print_link_msg(vsi, true); 6298cdedef59SAnirudh Venkataramanan netif_tx_start_all_queues(vsi->netdev); 6299cdedef59SAnirudh Venkataramanan netif_carrier_on(vsi->netdev); 63003a749623SJacob Keller if (!ice_is_e810(&pf->hw)) 63013a749623SJacob Keller ice_ptp_link_change(pf, pf->hw.pf_id, true); 6302cdedef59SAnirudh Venkataramanan } 6303cdedef59SAnirudh Venkataramanan 630431b6298fSPaul Greenwalt /* Perform an initial read of the statistics registers now to 630531b6298fSPaul Greenwalt * set the baseline so counters are ready when interface is up 630631b6298fSPaul Greenwalt */ 630731b6298fSPaul Greenwalt ice_update_eth_stats(vsi); 6308cdedef59SAnirudh Venkataramanan ice_service_task_schedule(pf); 6309cdedef59SAnirudh Venkataramanan 63101b5c19c7SBruce Allan return 0; 6311cdedef59SAnirudh Venkataramanan } 6312cdedef59SAnirudh Venkataramanan 6313cdedef59SAnirudh Venkataramanan /** 6314fcea6f3dSAnirudh Venkataramanan * ice_up - Bring the connection back up after being down 6315fcea6f3dSAnirudh Venkataramanan * @vsi: VSI being configured 6316fcea6f3dSAnirudh Venkataramanan */ 6317fcea6f3dSAnirudh Venkataramanan int ice_up(struct ice_vsi *vsi) 6318fcea6f3dSAnirudh Venkataramanan { 6319fcea6f3dSAnirudh Venkataramanan int err; 6320fcea6f3dSAnirudh Venkataramanan 6321fcea6f3dSAnirudh Venkataramanan err = ice_vsi_cfg(vsi); 6322fcea6f3dSAnirudh Venkataramanan if (!err) 6323fcea6f3dSAnirudh Venkataramanan err = ice_up_complete(vsi); 6324fcea6f3dSAnirudh Venkataramanan 6325fcea6f3dSAnirudh Venkataramanan return err; 6326fcea6f3dSAnirudh Venkataramanan } 6327fcea6f3dSAnirudh Venkataramanan 6328fcea6f3dSAnirudh Venkataramanan /** 6329fcea6f3dSAnirudh Venkataramanan * ice_fetch_u64_stats_per_ring - get packets and bytes stats per ring 6330e72bba21SMaciej Fijalkowski * @syncp: pointer to u64_stats_sync 6331e72bba21SMaciej Fijalkowski * @stats: stats that pkts and bytes count will be taken from 6332fcea6f3dSAnirudh Venkataramanan * @pkts: packets stats counter 6333fcea6f3dSAnirudh Venkataramanan * @bytes: bytes stats counter 6334fcea6f3dSAnirudh Venkataramanan * 6335fcea6f3dSAnirudh Venkataramanan * This function fetches stats from the ring considering the atomic operations 6336fcea6f3dSAnirudh Venkataramanan * that needs to be performed to read u64 values in 32 bit machine. 6337fcea6f3dSAnirudh Venkataramanan */ 6338c8ff29b5SMarcin Szycik void 6339c8ff29b5SMarcin Szycik ice_fetch_u64_stats_per_ring(struct u64_stats_sync *syncp, 6340c8ff29b5SMarcin Szycik struct ice_q_stats stats, u64 *pkts, u64 *bytes) 6341fcea6f3dSAnirudh Venkataramanan { 6342fcea6f3dSAnirudh Venkataramanan unsigned int start; 6343fcea6f3dSAnirudh Venkataramanan 6344fcea6f3dSAnirudh Venkataramanan do { 6345e72bba21SMaciej Fijalkowski start = u64_stats_fetch_begin_irq(syncp); 6346e72bba21SMaciej Fijalkowski *pkts = stats.pkts; 6347e72bba21SMaciej Fijalkowski *bytes = stats.bytes; 6348e72bba21SMaciej Fijalkowski } while (u64_stats_fetch_retry_irq(syncp, start)); 6349fcea6f3dSAnirudh Venkataramanan } 6350fcea6f3dSAnirudh Venkataramanan 6351fcea6f3dSAnirudh Venkataramanan /** 635249d358e0SMarta Plantykow * ice_update_vsi_tx_ring_stats - Update VSI Tx ring stats counters 635349d358e0SMarta Plantykow * @vsi: the VSI to be updated 63541a0f25a5SJesse Brandeburg * @vsi_stats: the stats struct to be updated 635549d358e0SMarta Plantykow * @rings: rings to work on 635649d358e0SMarta Plantykow * @count: number of rings 635749d358e0SMarta Plantykow */ 635849d358e0SMarta Plantykow static void 63591a0f25a5SJesse Brandeburg ice_update_vsi_tx_ring_stats(struct ice_vsi *vsi, 63601a0f25a5SJesse Brandeburg struct rtnl_link_stats64 *vsi_stats, 63611a0f25a5SJesse Brandeburg struct ice_tx_ring **rings, u16 count) 636249d358e0SMarta Plantykow { 636349d358e0SMarta Plantykow u16 i; 636449d358e0SMarta Plantykow 636549d358e0SMarta Plantykow for (i = 0; i < count; i++) { 6366e72bba21SMaciej Fijalkowski struct ice_tx_ring *ring; 6367e72bba21SMaciej Fijalkowski u64 pkts = 0, bytes = 0; 636849d358e0SMarta Plantykow 636949d358e0SMarta Plantykow ring = READ_ONCE(rings[i]); 6370f1535469SMaciej Fijalkowski if (!ring) 6371f1535469SMaciej Fijalkowski continue; 6372e72bba21SMaciej Fijalkowski ice_fetch_u64_stats_per_ring(&ring->syncp, ring->stats, &pkts, &bytes); 637349d358e0SMarta Plantykow vsi_stats->tx_packets += pkts; 637449d358e0SMarta Plantykow vsi_stats->tx_bytes += bytes; 637549d358e0SMarta Plantykow vsi->tx_restart += ring->tx_stats.restart_q; 637649d358e0SMarta Plantykow vsi->tx_busy += ring->tx_stats.tx_busy; 637749d358e0SMarta Plantykow vsi->tx_linearize += ring->tx_stats.tx_linearize; 637849d358e0SMarta Plantykow } 637949d358e0SMarta Plantykow } 638049d358e0SMarta Plantykow 638149d358e0SMarta Plantykow /** 6382fcea6f3dSAnirudh Venkataramanan * ice_update_vsi_ring_stats - Update VSI stats counters 6383fcea6f3dSAnirudh Venkataramanan * @vsi: the VSI to be updated 6384fcea6f3dSAnirudh Venkataramanan */ 6385fcea6f3dSAnirudh Venkataramanan static void ice_update_vsi_ring_stats(struct ice_vsi *vsi) 6386fcea6f3dSAnirudh Venkataramanan { 63871a0f25a5SJesse Brandeburg struct rtnl_link_stats64 *vsi_stats; 6388fcea6f3dSAnirudh Venkataramanan u64 pkts, bytes; 6389fcea6f3dSAnirudh Venkataramanan int i; 6390fcea6f3dSAnirudh Venkataramanan 63911a0f25a5SJesse Brandeburg vsi_stats = kzalloc(sizeof(*vsi_stats), GFP_ATOMIC); 63921a0f25a5SJesse Brandeburg if (!vsi_stats) 63931a0f25a5SJesse Brandeburg return; 6394fcea6f3dSAnirudh Venkataramanan 6395fcea6f3dSAnirudh Venkataramanan /* reset non-netdev (extended) stats */ 6396fcea6f3dSAnirudh Venkataramanan vsi->tx_restart = 0; 6397fcea6f3dSAnirudh Venkataramanan vsi->tx_busy = 0; 6398fcea6f3dSAnirudh Venkataramanan vsi->tx_linearize = 0; 6399fcea6f3dSAnirudh Venkataramanan vsi->rx_buf_failed = 0; 6400fcea6f3dSAnirudh Venkataramanan vsi->rx_page_failed = 0; 6401fcea6f3dSAnirudh Venkataramanan 6402fcea6f3dSAnirudh Venkataramanan rcu_read_lock(); 6403fcea6f3dSAnirudh Venkataramanan 6404fcea6f3dSAnirudh Venkataramanan /* update Tx rings counters */ 64051a0f25a5SJesse Brandeburg ice_update_vsi_tx_ring_stats(vsi, vsi_stats, vsi->tx_rings, 64061a0f25a5SJesse Brandeburg vsi->num_txq); 6407fcea6f3dSAnirudh Venkataramanan 6408fcea6f3dSAnirudh Venkataramanan /* update Rx rings counters */ 6409fcea6f3dSAnirudh Venkataramanan ice_for_each_rxq(vsi, i) { 6410e72bba21SMaciej Fijalkowski struct ice_rx_ring *ring = READ_ONCE(vsi->rx_rings[i]); 6411b6b0501dSPaul M Stillwell Jr 6412e72bba21SMaciej Fijalkowski ice_fetch_u64_stats_per_ring(&ring->syncp, ring->stats, &pkts, &bytes); 6413fcea6f3dSAnirudh Venkataramanan vsi_stats->rx_packets += pkts; 6414fcea6f3dSAnirudh Venkataramanan vsi_stats->rx_bytes += bytes; 6415fcea6f3dSAnirudh Venkataramanan vsi->rx_buf_failed += ring->rx_stats.alloc_buf_failed; 6416fcea6f3dSAnirudh Venkataramanan vsi->rx_page_failed += ring->rx_stats.alloc_page_failed; 6417fcea6f3dSAnirudh Venkataramanan } 6418fcea6f3dSAnirudh Venkataramanan 641949d358e0SMarta Plantykow /* update XDP Tx rings counters */ 642049d358e0SMarta Plantykow if (ice_is_xdp_ena_vsi(vsi)) 64211a0f25a5SJesse Brandeburg ice_update_vsi_tx_ring_stats(vsi, vsi_stats, vsi->xdp_rings, 642249d358e0SMarta Plantykow vsi->num_xdp_txq); 642349d358e0SMarta Plantykow 6424fcea6f3dSAnirudh Venkataramanan rcu_read_unlock(); 64251a0f25a5SJesse Brandeburg 64261a0f25a5SJesse Brandeburg vsi->net_stats.tx_packets = vsi_stats->tx_packets; 64271a0f25a5SJesse Brandeburg vsi->net_stats.tx_bytes = vsi_stats->tx_bytes; 64281a0f25a5SJesse Brandeburg vsi->net_stats.rx_packets = vsi_stats->rx_packets; 64291a0f25a5SJesse Brandeburg vsi->net_stats.rx_bytes = vsi_stats->rx_bytes; 64301a0f25a5SJesse Brandeburg 64311a0f25a5SJesse Brandeburg kfree(vsi_stats); 6432fcea6f3dSAnirudh Venkataramanan } 6433fcea6f3dSAnirudh Venkataramanan 6434fcea6f3dSAnirudh Venkataramanan /** 6435fcea6f3dSAnirudh Venkataramanan * ice_update_vsi_stats - Update VSI stats counters 6436fcea6f3dSAnirudh Venkataramanan * @vsi: the VSI to be updated 6437fcea6f3dSAnirudh Venkataramanan */ 64385a4a8673SBruce Allan void ice_update_vsi_stats(struct ice_vsi *vsi) 6439fcea6f3dSAnirudh Venkataramanan { 6440fcea6f3dSAnirudh Venkataramanan struct rtnl_link_stats64 *cur_ns = &vsi->net_stats; 6441fcea6f3dSAnirudh Venkataramanan struct ice_eth_stats *cur_es = &vsi->eth_stats; 6442fcea6f3dSAnirudh Venkataramanan struct ice_pf *pf = vsi->back; 6443fcea6f3dSAnirudh Venkataramanan 6444e97fb1aeSAnirudh Venkataramanan if (test_bit(ICE_VSI_DOWN, vsi->state) || 64457e408e07SAnirudh Venkataramanan test_bit(ICE_CFG_BUSY, pf->state)) 6446fcea6f3dSAnirudh Venkataramanan return; 6447fcea6f3dSAnirudh Venkataramanan 6448fcea6f3dSAnirudh Venkataramanan /* get stats as recorded by Tx/Rx rings */ 6449fcea6f3dSAnirudh Venkataramanan ice_update_vsi_ring_stats(vsi); 6450fcea6f3dSAnirudh Venkataramanan 6451fcea6f3dSAnirudh Venkataramanan /* get VSI stats as recorded by the hardware */ 6452fcea6f3dSAnirudh Venkataramanan ice_update_eth_stats(vsi); 6453fcea6f3dSAnirudh Venkataramanan 6454fcea6f3dSAnirudh Venkataramanan cur_ns->tx_errors = cur_es->tx_errors; 645551fe27e1SAnirudh Venkataramanan cur_ns->rx_dropped = cur_es->rx_discards; 6456fcea6f3dSAnirudh Venkataramanan cur_ns->tx_dropped = cur_es->tx_discards; 6457fcea6f3dSAnirudh Venkataramanan cur_ns->multicast = cur_es->rx_multicast; 6458fcea6f3dSAnirudh Venkataramanan 6459fcea6f3dSAnirudh Venkataramanan /* update some more netdev stats if this is main VSI */ 6460fcea6f3dSAnirudh Venkataramanan if (vsi->type == ICE_VSI_PF) { 6461fcea6f3dSAnirudh Venkataramanan cur_ns->rx_crc_errors = pf->stats.crc_errors; 6462fcea6f3dSAnirudh Venkataramanan cur_ns->rx_errors = pf->stats.crc_errors + 64634f1fe43cSBrett Creeley pf->stats.illegal_bytes + 64644f1fe43cSBrett Creeley pf->stats.rx_len_errors + 64654f1fe43cSBrett Creeley pf->stats.rx_undersize + 64664f1fe43cSBrett Creeley pf->hw_csum_rx_error + 64674f1fe43cSBrett Creeley pf->stats.rx_jabber + 64684f1fe43cSBrett Creeley pf->stats.rx_fragments + 64694f1fe43cSBrett Creeley pf->stats.rx_oversize; 6470fcea6f3dSAnirudh Venkataramanan cur_ns->rx_length_errors = pf->stats.rx_len_errors; 647156923ab6SBrett Creeley /* record drops from the port level */ 647256923ab6SBrett Creeley cur_ns->rx_missed_errors = pf->stats.eth.rx_discards; 6473fcea6f3dSAnirudh Venkataramanan } 6474fcea6f3dSAnirudh Venkataramanan } 6475fcea6f3dSAnirudh Venkataramanan 6476fcea6f3dSAnirudh Venkataramanan /** 6477fcea6f3dSAnirudh Venkataramanan * ice_update_pf_stats - Update PF port stats counters 6478fcea6f3dSAnirudh Venkataramanan * @pf: PF whose stats needs to be updated 6479fcea6f3dSAnirudh Venkataramanan */ 64805a4a8673SBruce Allan void ice_update_pf_stats(struct ice_pf *pf) 6481fcea6f3dSAnirudh Venkataramanan { 6482fcea6f3dSAnirudh Venkataramanan struct ice_hw_port_stats *prev_ps, *cur_ps; 6483fcea6f3dSAnirudh Venkataramanan struct ice_hw *hw = &pf->hw; 64844ab95646SHenry Tieman u16 fd_ctr_base; 64859e7a5d17SUsha Ketineni u8 port; 6486fcea6f3dSAnirudh Venkataramanan 64879e7a5d17SUsha Ketineni port = hw->port_info->lport; 6488fcea6f3dSAnirudh Venkataramanan prev_ps = &pf->stats_prev; 6489fcea6f3dSAnirudh Venkataramanan cur_ps = &pf->stats; 6490fcea6f3dSAnirudh Venkataramanan 64919e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_GORCL(port), pf->stat_prev_loaded, 649236517fd3SJacob Keller &prev_ps->eth.rx_bytes, 6493fcea6f3dSAnirudh Venkataramanan &cur_ps->eth.rx_bytes); 6494fcea6f3dSAnirudh Venkataramanan 64959e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_UPRCL(port), pf->stat_prev_loaded, 649636517fd3SJacob Keller &prev_ps->eth.rx_unicast, 6497fcea6f3dSAnirudh Venkataramanan &cur_ps->eth.rx_unicast); 6498fcea6f3dSAnirudh Venkataramanan 64999e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_MPRCL(port), pf->stat_prev_loaded, 650036517fd3SJacob Keller &prev_ps->eth.rx_multicast, 6501fcea6f3dSAnirudh Venkataramanan &cur_ps->eth.rx_multicast); 6502fcea6f3dSAnirudh Venkataramanan 65039e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_BPRCL(port), pf->stat_prev_loaded, 650436517fd3SJacob Keller &prev_ps->eth.rx_broadcast, 6505fcea6f3dSAnirudh Venkataramanan &cur_ps->eth.rx_broadcast); 6506fcea6f3dSAnirudh Venkataramanan 650756923ab6SBrett Creeley ice_stat_update32(hw, PRTRPB_RDPC, pf->stat_prev_loaded, 650856923ab6SBrett Creeley &prev_ps->eth.rx_discards, 650956923ab6SBrett Creeley &cur_ps->eth.rx_discards); 651056923ab6SBrett Creeley 65119e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_GOTCL(port), pf->stat_prev_loaded, 651236517fd3SJacob Keller &prev_ps->eth.tx_bytes, 6513fcea6f3dSAnirudh Venkataramanan &cur_ps->eth.tx_bytes); 6514fcea6f3dSAnirudh Venkataramanan 65159e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_UPTCL(port), pf->stat_prev_loaded, 651636517fd3SJacob Keller &prev_ps->eth.tx_unicast, 6517fcea6f3dSAnirudh Venkataramanan &cur_ps->eth.tx_unicast); 6518fcea6f3dSAnirudh Venkataramanan 65199e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_MPTCL(port), pf->stat_prev_loaded, 652036517fd3SJacob Keller &prev_ps->eth.tx_multicast, 6521fcea6f3dSAnirudh Venkataramanan &cur_ps->eth.tx_multicast); 6522fcea6f3dSAnirudh Venkataramanan 65239e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_BPTCL(port), pf->stat_prev_loaded, 652436517fd3SJacob Keller &prev_ps->eth.tx_broadcast, 6525fcea6f3dSAnirudh Venkataramanan &cur_ps->eth.tx_broadcast); 6526fcea6f3dSAnirudh Venkataramanan 65279e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_TDOLD(port), pf->stat_prev_loaded, 6528fcea6f3dSAnirudh Venkataramanan &prev_ps->tx_dropped_link_down, 6529fcea6f3dSAnirudh Venkataramanan &cur_ps->tx_dropped_link_down); 6530fcea6f3dSAnirudh Venkataramanan 65319e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PRC64L(port), pf->stat_prev_loaded, 653236517fd3SJacob Keller &prev_ps->rx_size_64, &cur_ps->rx_size_64); 6533fcea6f3dSAnirudh Venkataramanan 65349e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PRC127L(port), pf->stat_prev_loaded, 653536517fd3SJacob Keller &prev_ps->rx_size_127, &cur_ps->rx_size_127); 6536fcea6f3dSAnirudh Venkataramanan 65379e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PRC255L(port), pf->stat_prev_loaded, 653836517fd3SJacob Keller &prev_ps->rx_size_255, &cur_ps->rx_size_255); 6539fcea6f3dSAnirudh Venkataramanan 65409e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PRC511L(port), pf->stat_prev_loaded, 654136517fd3SJacob Keller &prev_ps->rx_size_511, &cur_ps->rx_size_511); 6542fcea6f3dSAnirudh Venkataramanan 65439e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PRC1023L(port), pf->stat_prev_loaded, 6544fcea6f3dSAnirudh Venkataramanan &prev_ps->rx_size_1023, &cur_ps->rx_size_1023); 6545fcea6f3dSAnirudh Venkataramanan 65469e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PRC1522L(port), pf->stat_prev_loaded, 6547fcea6f3dSAnirudh Venkataramanan &prev_ps->rx_size_1522, &cur_ps->rx_size_1522); 6548fcea6f3dSAnirudh Venkataramanan 65499e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PRC9522L(port), pf->stat_prev_loaded, 6550fcea6f3dSAnirudh Venkataramanan &prev_ps->rx_size_big, &cur_ps->rx_size_big); 6551fcea6f3dSAnirudh Venkataramanan 65529e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PTC64L(port), pf->stat_prev_loaded, 655336517fd3SJacob Keller &prev_ps->tx_size_64, &cur_ps->tx_size_64); 6554fcea6f3dSAnirudh Venkataramanan 65559e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PTC127L(port), pf->stat_prev_loaded, 655636517fd3SJacob Keller &prev_ps->tx_size_127, &cur_ps->tx_size_127); 6557fcea6f3dSAnirudh Venkataramanan 65589e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PTC255L(port), pf->stat_prev_loaded, 655936517fd3SJacob Keller &prev_ps->tx_size_255, &cur_ps->tx_size_255); 6560fcea6f3dSAnirudh Venkataramanan 65619e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PTC511L(port), pf->stat_prev_loaded, 656236517fd3SJacob Keller &prev_ps->tx_size_511, &cur_ps->tx_size_511); 6563fcea6f3dSAnirudh Venkataramanan 65649e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PTC1023L(port), pf->stat_prev_loaded, 6565fcea6f3dSAnirudh Venkataramanan &prev_ps->tx_size_1023, &cur_ps->tx_size_1023); 6566fcea6f3dSAnirudh Venkataramanan 65679e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PTC1522L(port), pf->stat_prev_loaded, 6568fcea6f3dSAnirudh Venkataramanan &prev_ps->tx_size_1522, &cur_ps->tx_size_1522); 6569fcea6f3dSAnirudh Venkataramanan 65709e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PTC9522L(port), pf->stat_prev_loaded, 6571fcea6f3dSAnirudh Venkataramanan &prev_ps->tx_size_big, &cur_ps->tx_size_big); 6572fcea6f3dSAnirudh Venkataramanan 65734ab95646SHenry Tieman fd_ctr_base = hw->fd_ctr_base; 65744ab95646SHenry Tieman 65754ab95646SHenry Tieman ice_stat_update40(hw, 65764ab95646SHenry Tieman GLSTAT_FD_CNT0L(ICE_FD_SB_STAT_IDX(fd_ctr_base)), 65774ab95646SHenry Tieman pf->stat_prev_loaded, &prev_ps->fd_sb_match, 65784ab95646SHenry Tieman &cur_ps->fd_sb_match); 65799e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_LXONRXC(port), pf->stat_prev_loaded, 6580fcea6f3dSAnirudh Venkataramanan &prev_ps->link_xon_rx, &cur_ps->link_xon_rx); 6581fcea6f3dSAnirudh Venkataramanan 65829e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_LXOFFRXC(port), pf->stat_prev_loaded, 6583fcea6f3dSAnirudh Venkataramanan &prev_ps->link_xoff_rx, &cur_ps->link_xoff_rx); 6584fcea6f3dSAnirudh Venkataramanan 65859e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_LXONTXC(port), pf->stat_prev_loaded, 6586fcea6f3dSAnirudh Venkataramanan &prev_ps->link_xon_tx, &cur_ps->link_xon_tx); 6587fcea6f3dSAnirudh Venkataramanan 65889e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_LXOFFTXC(port), pf->stat_prev_loaded, 6589fcea6f3dSAnirudh Venkataramanan &prev_ps->link_xoff_tx, &cur_ps->link_xoff_tx); 6590fcea6f3dSAnirudh Venkataramanan 65914b0fdcebSAnirudh Venkataramanan ice_update_dcb_stats(pf); 65924b0fdcebSAnirudh Venkataramanan 65939e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_CRCERRS(port), pf->stat_prev_loaded, 6594fcea6f3dSAnirudh Venkataramanan &prev_ps->crc_errors, &cur_ps->crc_errors); 6595fcea6f3dSAnirudh Venkataramanan 65969e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_ILLERRC(port), pf->stat_prev_loaded, 6597fcea6f3dSAnirudh Venkataramanan &prev_ps->illegal_bytes, &cur_ps->illegal_bytes); 6598fcea6f3dSAnirudh Venkataramanan 65999e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_MLFC(port), pf->stat_prev_loaded, 6600fcea6f3dSAnirudh Venkataramanan &prev_ps->mac_local_faults, 6601fcea6f3dSAnirudh Venkataramanan &cur_ps->mac_local_faults); 6602fcea6f3dSAnirudh Venkataramanan 66039e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_MRFC(port), pf->stat_prev_loaded, 6604fcea6f3dSAnirudh Venkataramanan &prev_ps->mac_remote_faults, 6605fcea6f3dSAnirudh Venkataramanan &cur_ps->mac_remote_faults); 6606fcea6f3dSAnirudh Venkataramanan 66079e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_RLEC(port), pf->stat_prev_loaded, 6608fcea6f3dSAnirudh Venkataramanan &prev_ps->rx_len_errors, &cur_ps->rx_len_errors); 6609fcea6f3dSAnirudh Venkataramanan 66109e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_RUC(port), pf->stat_prev_loaded, 6611fcea6f3dSAnirudh Venkataramanan &prev_ps->rx_undersize, &cur_ps->rx_undersize); 6612fcea6f3dSAnirudh Venkataramanan 66139e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_RFC(port), pf->stat_prev_loaded, 6614fcea6f3dSAnirudh Venkataramanan &prev_ps->rx_fragments, &cur_ps->rx_fragments); 6615fcea6f3dSAnirudh Venkataramanan 66169e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_ROC(port), pf->stat_prev_loaded, 6617fcea6f3dSAnirudh Venkataramanan &prev_ps->rx_oversize, &cur_ps->rx_oversize); 6618fcea6f3dSAnirudh Venkataramanan 66199e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_RJC(port), pf->stat_prev_loaded, 6620fcea6f3dSAnirudh Venkataramanan &prev_ps->rx_jabber, &cur_ps->rx_jabber); 6621fcea6f3dSAnirudh Venkataramanan 66224ab95646SHenry Tieman cur_ps->fd_sb_status = test_bit(ICE_FLAG_FD_ENA, pf->flags) ? 1 : 0; 66234ab95646SHenry Tieman 6624fcea6f3dSAnirudh Venkataramanan pf->stat_prev_loaded = true; 6625fcea6f3dSAnirudh Venkataramanan } 6626fcea6f3dSAnirudh Venkataramanan 6627fcea6f3dSAnirudh Venkataramanan /** 6628fcea6f3dSAnirudh Venkataramanan * ice_get_stats64 - get statistics for network device structure 6629fcea6f3dSAnirudh Venkataramanan * @netdev: network interface device structure 6630fcea6f3dSAnirudh Venkataramanan * @stats: main device statistics structure 6631fcea6f3dSAnirudh Venkataramanan */ 6632fcea6f3dSAnirudh Venkataramanan static 6633fcea6f3dSAnirudh Venkataramanan void ice_get_stats64(struct net_device *netdev, struct rtnl_link_stats64 *stats) 6634fcea6f3dSAnirudh Venkataramanan { 6635fcea6f3dSAnirudh Venkataramanan struct ice_netdev_priv *np = netdev_priv(netdev); 6636fcea6f3dSAnirudh Venkataramanan struct rtnl_link_stats64 *vsi_stats; 6637fcea6f3dSAnirudh Venkataramanan struct ice_vsi *vsi = np->vsi; 6638fcea6f3dSAnirudh Venkataramanan 6639fcea6f3dSAnirudh Venkataramanan vsi_stats = &vsi->net_stats; 6640fcea6f3dSAnirudh Venkataramanan 66413d57fd10SDave Ertman if (!vsi->num_txq || !vsi->num_rxq) 6642fcea6f3dSAnirudh Venkataramanan return; 66433d57fd10SDave Ertman 6644fcea6f3dSAnirudh Venkataramanan /* netdev packet/byte stats come from ring counter. These are obtained 6645fcea6f3dSAnirudh Venkataramanan * by summing up ring counters (done by ice_update_vsi_ring_stats). 66463d57fd10SDave Ertman * But, only call the update routine and read the registers if VSI is 66473d57fd10SDave Ertman * not down. 6648fcea6f3dSAnirudh Venkataramanan */ 6649e97fb1aeSAnirudh Venkataramanan if (!test_bit(ICE_VSI_DOWN, vsi->state)) 6650fcea6f3dSAnirudh Venkataramanan ice_update_vsi_ring_stats(vsi); 6651fcea6f3dSAnirudh Venkataramanan stats->tx_packets = vsi_stats->tx_packets; 6652fcea6f3dSAnirudh Venkataramanan stats->tx_bytes = vsi_stats->tx_bytes; 6653fcea6f3dSAnirudh Venkataramanan stats->rx_packets = vsi_stats->rx_packets; 6654fcea6f3dSAnirudh Venkataramanan stats->rx_bytes = vsi_stats->rx_bytes; 6655fcea6f3dSAnirudh Venkataramanan 6656fcea6f3dSAnirudh Venkataramanan /* The rest of the stats can be read from the hardware but instead we 6657fcea6f3dSAnirudh Venkataramanan * just return values that the watchdog task has already obtained from 6658fcea6f3dSAnirudh Venkataramanan * the hardware. 6659fcea6f3dSAnirudh Venkataramanan */ 6660fcea6f3dSAnirudh Venkataramanan stats->multicast = vsi_stats->multicast; 6661fcea6f3dSAnirudh Venkataramanan stats->tx_errors = vsi_stats->tx_errors; 6662fcea6f3dSAnirudh Venkataramanan stats->tx_dropped = vsi_stats->tx_dropped; 6663fcea6f3dSAnirudh Venkataramanan stats->rx_errors = vsi_stats->rx_errors; 6664fcea6f3dSAnirudh Venkataramanan stats->rx_dropped = vsi_stats->rx_dropped; 6665fcea6f3dSAnirudh Venkataramanan stats->rx_crc_errors = vsi_stats->rx_crc_errors; 6666fcea6f3dSAnirudh Venkataramanan stats->rx_length_errors = vsi_stats->rx_length_errors; 6667fcea6f3dSAnirudh Venkataramanan } 6668fcea6f3dSAnirudh Venkataramanan 6669fcea6f3dSAnirudh Venkataramanan /** 66702b245cb2SAnirudh Venkataramanan * ice_napi_disable_all - Disable NAPI for all q_vectors in the VSI 66712b245cb2SAnirudh Venkataramanan * @vsi: VSI having NAPI disabled 66722b245cb2SAnirudh Venkataramanan */ 66732b245cb2SAnirudh Venkataramanan static void ice_napi_disable_all(struct ice_vsi *vsi) 66742b245cb2SAnirudh Venkataramanan { 66752b245cb2SAnirudh Venkataramanan int q_idx; 66762b245cb2SAnirudh Venkataramanan 66772b245cb2SAnirudh Venkataramanan if (!vsi->netdev) 66782b245cb2SAnirudh Venkataramanan return; 66792b245cb2SAnirudh Venkataramanan 66800c2561c8SBrett Creeley ice_for_each_q_vector(vsi, q_idx) { 6681eec90376SYoung Xiao struct ice_q_vector *q_vector = vsi->q_vectors[q_idx]; 6682eec90376SYoung Xiao 6683e72bba21SMaciej Fijalkowski if (q_vector->rx.rx_ring || q_vector->tx.tx_ring) 6684eec90376SYoung Xiao napi_disable(&q_vector->napi); 6685cdf1f1f1SJacob Keller 6686cdf1f1f1SJacob Keller cancel_work_sync(&q_vector->tx.dim.work); 6687cdf1f1f1SJacob Keller cancel_work_sync(&q_vector->rx.dim.work); 6688eec90376SYoung Xiao } 66892b245cb2SAnirudh Venkataramanan } 66902b245cb2SAnirudh Venkataramanan 66912b245cb2SAnirudh Venkataramanan /** 6692cdedef59SAnirudh Venkataramanan * ice_down - Shutdown the connection 6693cdedef59SAnirudh Venkataramanan * @vsi: The VSI being stopped 669421c6e36bSJesse Brandeburg * 669521c6e36bSJesse Brandeburg * Caller of this function is expected to set the vsi->state ICE_DOWN bit 6696cdedef59SAnirudh Venkataramanan */ 6697fcea6f3dSAnirudh Venkataramanan int ice_down(struct ice_vsi *vsi) 6698cdedef59SAnirudh Venkataramanan { 6699c31af68aSBrett Creeley int i, tx_err, rx_err, link_err = 0, vlan_err = 0; 6700cdedef59SAnirudh Venkataramanan 670121c6e36bSJesse Brandeburg WARN_ON(!test_bit(ICE_VSI_DOWN, vsi->state)); 670221c6e36bSJesse Brandeburg 6703b3be918dSGrzegorz Nitka if (vsi->netdev && vsi->type == ICE_VSI_PF) { 6704c31af68aSBrett Creeley vlan_err = ice_vsi_del_vlan_zero(vsi); 67053a749623SJacob Keller if (!ice_is_e810(&vsi->back->hw)) 67063a749623SJacob Keller ice_ptp_link_change(vsi->back, vsi->back->hw.pf_id, false); 6707cdedef59SAnirudh Venkataramanan netif_carrier_off(vsi->netdev); 6708cdedef59SAnirudh Venkataramanan netif_tx_disable(vsi->netdev); 6709b3be918dSGrzegorz Nitka } else if (vsi->type == ICE_VSI_SWITCHDEV_CTRL) { 6710b3be918dSGrzegorz Nitka ice_eswitch_stop_all_tx_queues(vsi->back); 6711cdedef59SAnirudh Venkataramanan } 6712cdedef59SAnirudh Venkataramanan 6713cdedef59SAnirudh Venkataramanan ice_vsi_dis_irq(vsi); 671403f7a986SAnirudh Venkataramanan 671503f7a986SAnirudh Venkataramanan tx_err = ice_vsi_stop_lan_tx_rings(vsi, ICE_NO_RESET, 0); 671672adf242SAnirudh Venkataramanan if (tx_err) 671719cce2c6SAnirudh Venkataramanan netdev_err(vsi->netdev, "Failed stop Tx rings, VSI %d error %d\n", 671872adf242SAnirudh Venkataramanan vsi->vsi_num, tx_err); 6719efc2214bSMaciej Fijalkowski if (!tx_err && ice_is_xdp_ena_vsi(vsi)) { 6720efc2214bSMaciej Fijalkowski tx_err = ice_vsi_stop_xdp_tx_rings(vsi); 6721efc2214bSMaciej Fijalkowski if (tx_err) 672219cce2c6SAnirudh Venkataramanan netdev_err(vsi->netdev, "Failed stop XDP rings, VSI %d error %d\n", 6723efc2214bSMaciej Fijalkowski vsi->vsi_num, tx_err); 6724efc2214bSMaciej Fijalkowski } 672572adf242SAnirudh Venkataramanan 672613a6233bSBrett Creeley rx_err = ice_vsi_stop_all_rx_rings(vsi); 672772adf242SAnirudh Venkataramanan if (rx_err) 672819cce2c6SAnirudh Venkataramanan netdev_err(vsi->netdev, "Failed stop Rx rings, VSI %d error %d\n", 672972adf242SAnirudh Venkataramanan vsi->vsi_num, rx_err); 673072adf242SAnirudh Venkataramanan 67312b245cb2SAnirudh Venkataramanan ice_napi_disable_all(vsi); 6732cdedef59SAnirudh Venkataramanan 6733ab4ab73fSBruce Allan if (test_bit(ICE_FLAG_LINK_DOWN_ON_CLOSE_ENA, vsi->back->flags)) { 6734b6f934f0SBrett Creeley link_err = ice_force_phys_link_state(vsi, false); 6735b6f934f0SBrett Creeley if (link_err) 673619cce2c6SAnirudh Venkataramanan netdev_err(vsi->netdev, "Failed to set physical link down, VSI %d error %d\n", 6737b6f934f0SBrett Creeley vsi->vsi_num, link_err); 6738ab4ab73fSBruce Allan } 6739b6f934f0SBrett Creeley 6740cdedef59SAnirudh Venkataramanan ice_for_each_txq(vsi, i) 6741cdedef59SAnirudh Venkataramanan ice_clean_tx_ring(vsi->tx_rings[i]); 6742cdedef59SAnirudh Venkataramanan 6743cdedef59SAnirudh Venkataramanan ice_for_each_rxq(vsi, i) 6744cdedef59SAnirudh Venkataramanan ice_clean_rx_ring(vsi->rx_rings[i]); 6745cdedef59SAnirudh Venkataramanan 6746c31af68aSBrett Creeley if (tx_err || rx_err || link_err || vlan_err) { 674719cce2c6SAnirudh Venkataramanan netdev_err(vsi->netdev, "Failed to close VSI 0x%04X on switch 0x%04X\n", 6748cdedef59SAnirudh Venkataramanan vsi->vsi_num, vsi->vsw->sw_id); 674972adf242SAnirudh Venkataramanan return -EIO; 675072adf242SAnirudh Venkataramanan } 675172adf242SAnirudh Venkataramanan 675272adf242SAnirudh Venkataramanan return 0; 6753cdedef59SAnirudh Venkataramanan } 6754cdedef59SAnirudh Venkataramanan 6755cdedef59SAnirudh Venkataramanan /** 6756dddd406dSJesse Brandeburg * ice_down_up - shutdown the VSI connection and bring it up 6757dddd406dSJesse Brandeburg * @vsi: the VSI to be reconnected 6758dddd406dSJesse Brandeburg */ 6759dddd406dSJesse Brandeburg int ice_down_up(struct ice_vsi *vsi) 6760dddd406dSJesse Brandeburg { 6761dddd406dSJesse Brandeburg int ret; 6762dddd406dSJesse Brandeburg 6763dddd406dSJesse Brandeburg /* if DOWN already set, nothing to do */ 6764dddd406dSJesse Brandeburg if (test_and_set_bit(ICE_VSI_DOWN, vsi->state)) 6765dddd406dSJesse Brandeburg return 0; 6766dddd406dSJesse Brandeburg 6767dddd406dSJesse Brandeburg ret = ice_down(vsi); 6768dddd406dSJesse Brandeburg if (ret) 6769dddd406dSJesse Brandeburg return ret; 6770dddd406dSJesse Brandeburg 6771dddd406dSJesse Brandeburg ret = ice_up(vsi); 6772dddd406dSJesse Brandeburg if (ret) { 6773dddd406dSJesse Brandeburg netdev_err(vsi->netdev, "reallocating resources failed during netdev features change, may need to reload driver\n"); 6774dddd406dSJesse Brandeburg return ret; 6775dddd406dSJesse Brandeburg } 6776dddd406dSJesse Brandeburg 6777dddd406dSJesse Brandeburg return 0; 6778dddd406dSJesse Brandeburg } 6779dddd406dSJesse Brandeburg 6780dddd406dSJesse Brandeburg /** 6781cdedef59SAnirudh Venkataramanan * ice_vsi_setup_tx_rings - Allocate VSI Tx queue resources 6782cdedef59SAnirudh Venkataramanan * @vsi: VSI having resources allocated 6783cdedef59SAnirudh Venkataramanan * 6784cdedef59SAnirudh Venkataramanan * Return 0 on success, negative on failure 6785cdedef59SAnirudh Venkataramanan */ 67860e674aebSAnirudh Venkataramanan int ice_vsi_setup_tx_rings(struct ice_vsi *vsi) 6787cdedef59SAnirudh Venkataramanan { 6788dab0588fSJesse Brandeburg int i, err = 0; 6789cdedef59SAnirudh Venkataramanan 6790cdedef59SAnirudh Venkataramanan if (!vsi->num_txq) { 67919a946843SAnirudh Venkataramanan dev_err(ice_pf_to_dev(vsi->back), "VSI %d has 0 Tx queues\n", 6792cdedef59SAnirudh Venkataramanan vsi->vsi_num); 6793cdedef59SAnirudh Venkataramanan return -EINVAL; 6794cdedef59SAnirudh Venkataramanan } 6795cdedef59SAnirudh Venkataramanan 6796cdedef59SAnirudh Venkataramanan ice_for_each_txq(vsi, i) { 6797e72bba21SMaciej Fijalkowski struct ice_tx_ring *ring = vsi->tx_rings[i]; 6798eb0ee8abSMichal Swiatkowski 6799eb0ee8abSMichal Swiatkowski if (!ring) 6800eb0ee8abSMichal Swiatkowski return -EINVAL; 6801eb0ee8abSMichal Swiatkowski 68021c54c839SGrzegorz Nitka if (vsi->netdev) 6803eb0ee8abSMichal Swiatkowski ring->netdev = vsi->netdev; 6804eb0ee8abSMichal Swiatkowski err = ice_setup_tx_ring(ring); 6805cdedef59SAnirudh Venkataramanan if (err) 6806cdedef59SAnirudh Venkataramanan break; 6807cdedef59SAnirudh Venkataramanan } 6808cdedef59SAnirudh Venkataramanan 6809cdedef59SAnirudh Venkataramanan return err; 6810cdedef59SAnirudh Venkataramanan } 6811cdedef59SAnirudh Venkataramanan 6812cdedef59SAnirudh Venkataramanan /** 6813cdedef59SAnirudh Venkataramanan * ice_vsi_setup_rx_rings - Allocate VSI Rx queue resources 6814cdedef59SAnirudh Venkataramanan * @vsi: VSI having resources allocated 6815cdedef59SAnirudh Venkataramanan * 6816cdedef59SAnirudh Venkataramanan * Return 0 on success, negative on failure 6817cdedef59SAnirudh Venkataramanan */ 68180e674aebSAnirudh Venkataramanan int ice_vsi_setup_rx_rings(struct ice_vsi *vsi) 6819cdedef59SAnirudh Venkataramanan { 6820dab0588fSJesse Brandeburg int i, err = 0; 6821cdedef59SAnirudh Venkataramanan 6822cdedef59SAnirudh Venkataramanan if (!vsi->num_rxq) { 68239a946843SAnirudh Venkataramanan dev_err(ice_pf_to_dev(vsi->back), "VSI %d has 0 Rx queues\n", 6824cdedef59SAnirudh Venkataramanan vsi->vsi_num); 6825cdedef59SAnirudh Venkataramanan return -EINVAL; 6826cdedef59SAnirudh Venkataramanan } 6827cdedef59SAnirudh Venkataramanan 6828cdedef59SAnirudh Venkataramanan ice_for_each_rxq(vsi, i) { 6829e72bba21SMaciej Fijalkowski struct ice_rx_ring *ring = vsi->rx_rings[i]; 6830eb0ee8abSMichal Swiatkowski 6831eb0ee8abSMichal Swiatkowski if (!ring) 6832eb0ee8abSMichal Swiatkowski return -EINVAL; 6833eb0ee8abSMichal Swiatkowski 68341c54c839SGrzegorz Nitka if (vsi->netdev) 6835eb0ee8abSMichal Swiatkowski ring->netdev = vsi->netdev; 6836eb0ee8abSMichal Swiatkowski err = ice_setup_rx_ring(ring); 6837cdedef59SAnirudh Venkataramanan if (err) 6838cdedef59SAnirudh Venkataramanan break; 6839cdedef59SAnirudh Venkataramanan } 6840cdedef59SAnirudh Venkataramanan 6841cdedef59SAnirudh Venkataramanan return err; 6842cdedef59SAnirudh Venkataramanan } 6843cdedef59SAnirudh Venkataramanan 6844cdedef59SAnirudh Venkataramanan /** 6845148beb61SHenry Tieman * ice_vsi_open_ctrl - open control VSI for use 6846148beb61SHenry Tieman * @vsi: the VSI to open 6847148beb61SHenry Tieman * 6848148beb61SHenry Tieman * Initialization of the Control VSI 6849148beb61SHenry Tieman * 6850148beb61SHenry Tieman * Returns 0 on success, negative value on error 6851148beb61SHenry Tieman */ 6852148beb61SHenry Tieman int ice_vsi_open_ctrl(struct ice_vsi *vsi) 6853148beb61SHenry Tieman { 6854148beb61SHenry Tieman char int_name[ICE_INT_NAME_STR_LEN]; 6855148beb61SHenry Tieman struct ice_pf *pf = vsi->back; 6856148beb61SHenry Tieman struct device *dev; 6857148beb61SHenry Tieman int err; 6858148beb61SHenry Tieman 6859148beb61SHenry Tieman dev = ice_pf_to_dev(pf); 6860148beb61SHenry Tieman /* allocate descriptors */ 6861148beb61SHenry Tieman err = ice_vsi_setup_tx_rings(vsi); 6862148beb61SHenry Tieman if (err) 6863148beb61SHenry Tieman goto err_setup_tx; 6864148beb61SHenry Tieman 6865148beb61SHenry Tieman err = ice_vsi_setup_rx_rings(vsi); 6866148beb61SHenry Tieman if (err) 6867148beb61SHenry Tieman goto err_setup_rx; 6868148beb61SHenry Tieman 6869148beb61SHenry Tieman err = ice_vsi_cfg(vsi); 6870148beb61SHenry Tieman if (err) 6871148beb61SHenry Tieman goto err_setup_rx; 6872148beb61SHenry Tieman 6873148beb61SHenry Tieman snprintf(int_name, sizeof(int_name) - 1, "%s-%s:ctrl", 6874148beb61SHenry Tieman dev_driver_string(dev), dev_name(dev)); 6875148beb61SHenry Tieman err = ice_vsi_req_irq_msix(vsi, int_name); 6876148beb61SHenry Tieman if (err) 6877148beb61SHenry Tieman goto err_setup_rx; 6878148beb61SHenry Tieman 6879148beb61SHenry Tieman ice_vsi_cfg_msix(vsi); 6880148beb61SHenry Tieman 6881148beb61SHenry Tieman err = ice_vsi_start_all_rx_rings(vsi); 6882148beb61SHenry Tieman if (err) 6883148beb61SHenry Tieman goto err_up_complete; 6884148beb61SHenry Tieman 6885e97fb1aeSAnirudh Venkataramanan clear_bit(ICE_VSI_DOWN, vsi->state); 6886148beb61SHenry Tieman ice_vsi_ena_irq(vsi); 6887148beb61SHenry Tieman 6888148beb61SHenry Tieman return 0; 6889148beb61SHenry Tieman 6890148beb61SHenry Tieman err_up_complete: 6891148beb61SHenry Tieman ice_down(vsi); 6892148beb61SHenry Tieman err_setup_rx: 6893148beb61SHenry Tieman ice_vsi_free_rx_rings(vsi); 6894148beb61SHenry Tieman err_setup_tx: 6895148beb61SHenry Tieman ice_vsi_free_tx_rings(vsi); 6896148beb61SHenry Tieman 6897148beb61SHenry Tieman return err; 6898148beb61SHenry Tieman } 6899148beb61SHenry Tieman 6900148beb61SHenry Tieman /** 6901cdedef59SAnirudh Venkataramanan * ice_vsi_open - Called when a network interface is made active 6902cdedef59SAnirudh Venkataramanan * @vsi: the VSI to open 6903cdedef59SAnirudh Venkataramanan * 6904cdedef59SAnirudh Venkataramanan * Initialization of the VSI 6905cdedef59SAnirudh Venkataramanan * 6906cdedef59SAnirudh Venkataramanan * Returns 0 on success, negative value on error 6907cdedef59SAnirudh Venkataramanan */ 69081a1c40dfSGrzegorz Nitka int ice_vsi_open(struct ice_vsi *vsi) 6909cdedef59SAnirudh Venkataramanan { 6910cdedef59SAnirudh Venkataramanan char int_name[ICE_INT_NAME_STR_LEN]; 6911cdedef59SAnirudh Venkataramanan struct ice_pf *pf = vsi->back; 6912cdedef59SAnirudh Venkataramanan int err; 6913cdedef59SAnirudh Venkataramanan 6914cdedef59SAnirudh Venkataramanan /* allocate descriptors */ 6915cdedef59SAnirudh Venkataramanan err = ice_vsi_setup_tx_rings(vsi); 6916cdedef59SAnirudh Venkataramanan if (err) 6917cdedef59SAnirudh Venkataramanan goto err_setup_tx; 6918cdedef59SAnirudh Venkataramanan 6919cdedef59SAnirudh Venkataramanan err = ice_vsi_setup_rx_rings(vsi); 6920cdedef59SAnirudh Venkataramanan if (err) 6921cdedef59SAnirudh Venkataramanan goto err_setup_rx; 6922cdedef59SAnirudh Venkataramanan 6923cdedef59SAnirudh Venkataramanan err = ice_vsi_cfg(vsi); 6924cdedef59SAnirudh Venkataramanan if (err) 6925cdedef59SAnirudh Venkataramanan goto err_setup_rx; 6926cdedef59SAnirudh Venkataramanan 6927cdedef59SAnirudh Venkataramanan snprintf(int_name, sizeof(int_name) - 1, "%s-%s", 69284015d11eSBrett Creeley dev_driver_string(ice_pf_to_dev(pf)), vsi->netdev->name); 6929ba880734SBrett Creeley err = ice_vsi_req_irq_msix(vsi, int_name); 6930cdedef59SAnirudh Venkataramanan if (err) 6931cdedef59SAnirudh Venkataramanan goto err_setup_rx; 6932cdedef59SAnirudh Venkataramanan 69331a1c40dfSGrzegorz Nitka if (vsi->type == ICE_VSI_PF) { 6934cdedef59SAnirudh Venkataramanan /* Notify the stack of the actual queue counts. */ 6935cdedef59SAnirudh Venkataramanan err = netif_set_real_num_tx_queues(vsi->netdev, vsi->num_txq); 6936cdedef59SAnirudh Venkataramanan if (err) 6937cdedef59SAnirudh Venkataramanan goto err_set_qs; 6938cdedef59SAnirudh Venkataramanan 6939cdedef59SAnirudh Venkataramanan err = netif_set_real_num_rx_queues(vsi->netdev, vsi->num_rxq); 6940cdedef59SAnirudh Venkataramanan if (err) 6941cdedef59SAnirudh Venkataramanan goto err_set_qs; 69421a1c40dfSGrzegorz Nitka } 6943cdedef59SAnirudh Venkataramanan 6944cdedef59SAnirudh Venkataramanan err = ice_up_complete(vsi); 6945cdedef59SAnirudh Venkataramanan if (err) 6946cdedef59SAnirudh Venkataramanan goto err_up_complete; 6947cdedef59SAnirudh Venkataramanan 6948cdedef59SAnirudh Venkataramanan return 0; 6949cdedef59SAnirudh Venkataramanan 6950cdedef59SAnirudh Venkataramanan err_up_complete: 6951cdedef59SAnirudh Venkataramanan ice_down(vsi); 6952cdedef59SAnirudh Venkataramanan err_set_qs: 6953cdedef59SAnirudh Venkataramanan ice_vsi_free_irq(vsi); 6954cdedef59SAnirudh Venkataramanan err_setup_rx: 6955cdedef59SAnirudh Venkataramanan ice_vsi_free_rx_rings(vsi); 6956cdedef59SAnirudh Venkataramanan err_setup_tx: 6957cdedef59SAnirudh Venkataramanan ice_vsi_free_tx_rings(vsi); 6958cdedef59SAnirudh Venkataramanan 6959cdedef59SAnirudh Venkataramanan return err; 6960cdedef59SAnirudh Venkataramanan } 6961cdedef59SAnirudh Venkataramanan 6962cdedef59SAnirudh Venkataramanan /** 69630f9d5027SAnirudh Venkataramanan * ice_vsi_release_all - Delete all VSIs 69640f9d5027SAnirudh Venkataramanan * @pf: PF from which all VSIs are being removed 69650f9d5027SAnirudh Venkataramanan */ 69660f9d5027SAnirudh Venkataramanan static void ice_vsi_release_all(struct ice_pf *pf) 69670f9d5027SAnirudh Venkataramanan { 69680f9d5027SAnirudh Venkataramanan int err, i; 69690f9d5027SAnirudh Venkataramanan 69700f9d5027SAnirudh Venkataramanan if (!pf->vsi) 69710f9d5027SAnirudh Venkataramanan return; 69720f9d5027SAnirudh Venkataramanan 697380ed404aSBrett Creeley ice_for_each_vsi(pf, i) { 69740f9d5027SAnirudh Venkataramanan if (!pf->vsi[i]) 69750f9d5027SAnirudh Venkataramanan continue; 69760f9d5027SAnirudh Venkataramanan 6977fbc7b27aSKiran Patil if (pf->vsi[i]->type == ICE_VSI_CHNL) 6978fbc7b27aSKiran Patil continue; 6979fbc7b27aSKiran Patil 69800f9d5027SAnirudh Venkataramanan err = ice_vsi_release(pf->vsi[i]); 69810f9d5027SAnirudh Venkataramanan if (err) 698219cce2c6SAnirudh Venkataramanan dev_dbg(ice_pf_to_dev(pf), "Failed to release pf->vsi[%d], err %d, vsi_num = %d\n", 69830f9d5027SAnirudh Venkataramanan i, err, pf->vsi[i]->vsi_num); 69840f9d5027SAnirudh Venkataramanan } 69850f9d5027SAnirudh Venkataramanan } 69860f9d5027SAnirudh Venkataramanan 69870f9d5027SAnirudh Venkataramanan /** 6988462acf6aSTony Nguyen * ice_vsi_rebuild_by_type - Rebuild VSI of a given type 6989462acf6aSTony Nguyen * @pf: pointer to the PF instance 6990462acf6aSTony Nguyen * @type: VSI type to rebuild 6991462acf6aSTony Nguyen * 6992462acf6aSTony Nguyen * Iterates through the pf->vsi array and rebuilds VSIs of the requested type 69930f9d5027SAnirudh Venkataramanan */ 6994462acf6aSTony Nguyen static int ice_vsi_rebuild_by_type(struct ice_pf *pf, enum ice_vsi_type type) 69950f9d5027SAnirudh Venkataramanan { 69964015d11eSBrett Creeley struct device *dev = ice_pf_to_dev(pf); 6997462acf6aSTony Nguyen int i, err; 69980f9d5027SAnirudh Venkataramanan 699980ed404aSBrett Creeley ice_for_each_vsi(pf, i) { 70004425e053SKrzysztof Kazimierczak struct ice_vsi *vsi = pf->vsi[i]; 70010f9d5027SAnirudh Venkataramanan 7002462acf6aSTony Nguyen if (!vsi || vsi->type != type) 70030f9d5027SAnirudh Venkataramanan continue; 70040f9d5027SAnirudh Venkataramanan 7005462acf6aSTony Nguyen /* rebuild the VSI */ 700687324e74SHenry Tieman err = ice_vsi_rebuild(vsi, true); 70070f9d5027SAnirudh Venkataramanan if (err) { 700819cce2c6SAnirudh Venkataramanan dev_err(dev, "rebuild VSI failed, err %d, VSI index %d, type %s\n", 7009964674f1SAnirudh Venkataramanan err, vsi->idx, ice_vsi_type_str(type)); 70100f9d5027SAnirudh Venkataramanan return err; 70110f9d5027SAnirudh Venkataramanan } 70120f9d5027SAnirudh Venkataramanan 7013462acf6aSTony Nguyen /* replay filters for the VSI */ 70142ccc1c1cSTony Nguyen err = ice_replay_vsi(&pf->hw, vsi->idx); 70152ccc1c1cSTony Nguyen if (err) { 70165f87ec48STony Nguyen dev_err(dev, "replay VSI failed, error %d, VSI index %d, type %s\n", 70172ccc1c1cSTony Nguyen err, vsi->idx, ice_vsi_type_str(type)); 7018c1484691STony Nguyen return err; 7019334cb062SAnirudh Venkataramanan } 7020334cb062SAnirudh Venkataramanan 7021334cb062SAnirudh Venkataramanan /* Re-map HW VSI number, using VSI handle that has been 7022334cb062SAnirudh Venkataramanan * previously validated in ice_replay_vsi() call above 7023334cb062SAnirudh Venkataramanan */ 7024462acf6aSTony Nguyen vsi->vsi_num = ice_get_hw_vsi_num(&pf->hw, vsi->idx); 7025334cb062SAnirudh Venkataramanan 7026462acf6aSTony Nguyen /* enable the VSI */ 7027462acf6aSTony Nguyen err = ice_ena_vsi(vsi, false); 7028462acf6aSTony Nguyen if (err) { 702919cce2c6SAnirudh Venkataramanan dev_err(dev, "enable VSI failed, err %d, VSI index %d, type %s\n", 7030964674f1SAnirudh Venkataramanan err, vsi->idx, ice_vsi_type_str(type)); 7031462acf6aSTony Nguyen return err; 7032334cb062SAnirudh Venkataramanan } 7033334cb062SAnirudh Venkataramanan 70344015d11eSBrett Creeley dev_info(dev, "VSI rebuilt. VSI index %d, type %s\n", vsi->idx, 70354015d11eSBrett Creeley ice_vsi_type_str(type)); 7036462acf6aSTony Nguyen } 7037462acf6aSTony Nguyen 7038334cb062SAnirudh Venkataramanan return 0; 7039334cb062SAnirudh Venkataramanan } 7040334cb062SAnirudh Venkataramanan 7041334cb062SAnirudh Venkataramanan /** 7042462acf6aSTony Nguyen * ice_update_pf_netdev_link - Update PF netdev link status 7043462acf6aSTony Nguyen * @pf: pointer to the PF instance 7044462acf6aSTony Nguyen */ 7045462acf6aSTony Nguyen static void ice_update_pf_netdev_link(struct ice_pf *pf) 7046462acf6aSTony Nguyen { 7047462acf6aSTony Nguyen bool link_up; 7048462acf6aSTony Nguyen int i; 7049462acf6aSTony Nguyen 7050462acf6aSTony Nguyen ice_for_each_vsi(pf, i) { 7051462acf6aSTony Nguyen struct ice_vsi *vsi = pf->vsi[i]; 7052462acf6aSTony Nguyen 7053462acf6aSTony Nguyen if (!vsi || vsi->type != ICE_VSI_PF) 7054462acf6aSTony Nguyen return; 7055462acf6aSTony Nguyen 7056462acf6aSTony Nguyen ice_get_link_status(pf->vsi[i]->port_info, &link_up); 7057462acf6aSTony Nguyen if (link_up) { 7058462acf6aSTony Nguyen netif_carrier_on(pf->vsi[i]->netdev); 7059462acf6aSTony Nguyen netif_tx_wake_all_queues(pf->vsi[i]->netdev); 7060462acf6aSTony Nguyen } else { 7061462acf6aSTony Nguyen netif_carrier_off(pf->vsi[i]->netdev); 7062462acf6aSTony Nguyen netif_tx_stop_all_queues(pf->vsi[i]->netdev); 7063462acf6aSTony Nguyen } 7064462acf6aSTony Nguyen } 7065462acf6aSTony Nguyen } 7066462acf6aSTony Nguyen 7067462acf6aSTony Nguyen /** 70680b28b702SAnirudh Venkataramanan * ice_rebuild - rebuild after reset 70692f2da36eSAnirudh Venkataramanan * @pf: PF to rebuild 7070462acf6aSTony Nguyen * @reset_type: type of reset 707112bb018cSBrett Creeley * 707212bb018cSBrett Creeley * Do not rebuild VF VSI in this flow because that is already handled via 707312bb018cSBrett Creeley * ice_reset_all_vfs(). This is because requirements for resetting a VF after a 707412bb018cSBrett Creeley * PFR/CORER/GLOBER/etc. are different than the normal flow. Also, we don't want 707512bb018cSBrett Creeley * to reset/rebuild all the VF VSI twice. 70760b28b702SAnirudh Venkataramanan */ 7077462acf6aSTony Nguyen static void ice_rebuild(struct ice_pf *pf, enum ice_reset_req reset_type) 70780b28b702SAnirudh Venkataramanan { 70794015d11eSBrett Creeley struct device *dev = ice_pf_to_dev(pf); 70800b28b702SAnirudh Venkataramanan struct ice_hw *hw = &pf->hw; 7081a1ffafb0SBrett Creeley bool dvm; 7082462acf6aSTony Nguyen int err; 70830b28b702SAnirudh Venkataramanan 70847e408e07SAnirudh Venkataramanan if (test_bit(ICE_DOWN, pf->state)) 70850b28b702SAnirudh Venkataramanan goto clear_recovery; 70860b28b702SAnirudh Venkataramanan 7087462acf6aSTony Nguyen dev_dbg(dev, "rebuilding PF after reset_type=%d\n", reset_type); 70880b28b702SAnirudh Venkataramanan 7089b537752eSPetr Oros #define ICE_EMP_RESET_SLEEP_MS 5000 7090399e27dbSJacob Keller if (reset_type == ICE_RESET_EMPR) { 7091399e27dbSJacob Keller /* If an EMP reset has occurred, any previously pending flash 7092399e27dbSJacob Keller * update will have completed. We no longer know whether or 7093399e27dbSJacob Keller * not the NVM update EMP reset is restricted. 7094399e27dbSJacob Keller */ 7095399e27dbSJacob Keller pf->fw_emp_reset_disabled = false; 7096b537752eSPetr Oros 7097b537752eSPetr Oros msleep(ICE_EMP_RESET_SLEEP_MS); 7098399e27dbSJacob Keller } 7099399e27dbSJacob Keller 71002ccc1c1cSTony Nguyen err = ice_init_all_ctrlq(hw); 71012ccc1c1cSTony Nguyen if (err) { 71022ccc1c1cSTony Nguyen dev_err(dev, "control queues init failed %d\n", err); 71030f9d5027SAnirudh Venkataramanan goto err_init_ctrlq; 71040b28b702SAnirudh Venkataramanan } 71050b28b702SAnirudh Venkataramanan 7106462acf6aSTony Nguyen /* if DDP was previously loaded successfully */ 7107462acf6aSTony Nguyen if (!ice_is_safe_mode(pf)) { 7108462acf6aSTony Nguyen /* reload the SW DB of filter tables */ 7109462acf6aSTony Nguyen if (reset_type == ICE_RESET_PFR) 7110462acf6aSTony Nguyen ice_fill_blk_tbls(hw); 7111462acf6aSTony Nguyen else 7112462acf6aSTony Nguyen /* Reload DDP Package after CORER/GLOBR reset */ 7113462acf6aSTony Nguyen ice_load_pkg(NULL, pf); 7114462acf6aSTony Nguyen } 7115462acf6aSTony Nguyen 71162ccc1c1cSTony Nguyen err = ice_clear_pf_cfg(hw); 71172ccc1c1cSTony Nguyen if (err) { 71182ccc1c1cSTony Nguyen dev_err(dev, "clear PF configuration failed %d\n", err); 71190f9d5027SAnirudh Venkataramanan goto err_init_ctrlq; 71200b28b702SAnirudh Venkataramanan } 71210b28b702SAnirudh Venkataramanan 71220b28b702SAnirudh Venkataramanan ice_clear_pxe_mode(hw); 71230b28b702SAnirudh Venkataramanan 71242ccc1c1cSTony Nguyen err = ice_init_nvm(hw); 71252ccc1c1cSTony Nguyen if (err) { 71262ccc1c1cSTony Nguyen dev_err(dev, "ice_init_nvm failed %d\n", err); 712797a4ec01SJacob Keller goto err_init_ctrlq; 712897a4ec01SJacob Keller } 712997a4ec01SJacob Keller 71302ccc1c1cSTony Nguyen err = ice_get_caps(hw); 71312ccc1c1cSTony Nguyen if (err) { 71322ccc1c1cSTony Nguyen dev_err(dev, "ice_get_caps failed %d\n", err); 71330f9d5027SAnirudh Venkataramanan goto err_init_ctrlq; 71340b28b702SAnirudh Venkataramanan } 71350b28b702SAnirudh Venkataramanan 71362ccc1c1cSTony Nguyen err = ice_aq_set_mac_cfg(hw, ICE_AQ_SET_MAC_FRAME_SIZE_MAX, NULL); 71372ccc1c1cSTony Nguyen if (err) { 71382ccc1c1cSTony Nguyen dev_err(dev, "set_mac_cfg failed %d\n", err); 713942449105SAnirudh Venkataramanan goto err_init_ctrlq; 714042449105SAnirudh Venkataramanan } 714142449105SAnirudh Venkataramanan 7142a1ffafb0SBrett Creeley dvm = ice_is_dvm_ena(hw); 7143a1ffafb0SBrett Creeley 7144a1ffafb0SBrett Creeley err = ice_aq_set_port_params(pf->hw.port_info, dvm, NULL); 7145a1ffafb0SBrett Creeley if (err) 7146a1ffafb0SBrett Creeley goto err_init_ctrlq; 7147a1ffafb0SBrett Creeley 71480f9d5027SAnirudh Venkataramanan err = ice_sched_init_port(hw->port_info); 71490f9d5027SAnirudh Venkataramanan if (err) 71500f9d5027SAnirudh Venkataramanan goto err_sched_init_port; 71510f9d5027SAnirudh Venkataramanan 71520b28b702SAnirudh Venkataramanan /* start misc vector */ 71530b28b702SAnirudh Venkataramanan err = ice_req_irq_msix_misc(pf); 71540b28b702SAnirudh Venkataramanan if (err) { 71550b28b702SAnirudh Venkataramanan dev_err(dev, "misc vector setup failed: %d\n", err); 7156462acf6aSTony Nguyen goto err_sched_init_port; 71570b28b702SAnirudh Venkataramanan } 71580b28b702SAnirudh Venkataramanan 715983af0039SHenry Tieman if (test_bit(ICE_FLAG_FD_ENA, pf->flags)) { 716083af0039SHenry Tieman wr32(hw, PFQF_FD_ENA, PFQF_FD_ENA_FD_ENA_M); 716183af0039SHenry Tieman if (!rd32(hw, PFQF_FD_SIZE)) { 716283af0039SHenry Tieman u16 unused, guar, b_effort; 716383af0039SHenry Tieman 716483af0039SHenry Tieman guar = hw->func_caps.fd_fltr_guar; 716583af0039SHenry Tieman b_effort = hw->func_caps.fd_fltr_best_effort; 716683af0039SHenry Tieman 716783af0039SHenry Tieman /* force guaranteed filter pool for PF */ 716883af0039SHenry Tieman ice_alloc_fd_guar_item(hw, &unused, guar); 716983af0039SHenry Tieman /* force shared filter pool for PF */ 717083af0039SHenry Tieman ice_alloc_fd_shrd_item(hw, &unused, b_effort); 717183af0039SHenry Tieman } 717283af0039SHenry Tieman } 717383af0039SHenry Tieman 7174462acf6aSTony Nguyen if (test_bit(ICE_FLAG_DCB_ENA, pf->flags)) 7175462acf6aSTony Nguyen ice_dcb_rebuild(pf); 7176462acf6aSTony Nguyen 717706c16d89SJacob Keller /* If the PF previously had enabled PTP, PTP init needs to happen before 717806c16d89SJacob Keller * the VSI rebuild. If not, this causes the PTP link status events to 717906c16d89SJacob Keller * fail. 718006c16d89SJacob Keller */ 718106c16d89SJacob Keller if (test_bit(ICE_FLAG_PTP_SUPPORTED, pf->flags)) 718248096710SKarol Kolacinski ice_ptp_reset(pf); 718306c16d89SJacob Keller 718443113ff7SKarol Kolacinski if (ice_is_feature_supported(pf, ICE_F_GNSS)) 718543113ff7SKarol Kolacinski ice_gnss_init(pf); 718643113ff7SKarol Kolacinski 7187462acf6aSTony Nguyen /* rebuild PF VSI */ 7188462acf6aSTony Nguyen err = ice_vsi_rebuild_by_type(pf, ICE_VSI_PF); 71890f9d5027SAnirudh Venkataramanan if (err) { 7190462acf6aSTony Nguyen dev_err(dev, "PF VSI rebuild failed: %d\n", err); 71910f9d5027SAnirudh Venkataramanan goto err_vsi_rebuild; 71920f9d5027SAnirudh Venkataramanan } 71930b28b702SAnirudh Venkataramanan 719448096710SKarol Kolacinski /* configure PTP timestamping after VSI rebuild */ 719548096710SKarol Kolacinski if (test_bit(ICE_FLAG_PTP_SUPPORTED, pf->flags)) 719648096710SKarol Kolacinski ice_ptp_cfg_timestamp(pf, false); 719748096710SKarol Kolacinski 7198b3be918dSGrzegorz Nitka err = ice_vsi_rebuild_by_type(pf, ICE_VSI_SWITCHDEV_CTRL); 7199b3be918dSGrzegorz Nitka if (err) { 7200b3be918dSGrzegorz Nitka dev_err(dev, "Switchdev CTRL VSI rebuild failed: %d\n", err); 7201b3be918dSGrzegorz Nitka goto err_vsi_rebuild; 7202b3be918dSGrzegorz Nitka } 7203b3be918dSGrzegorz Nitka 7204fbc7b27aSKiran Patil if (reset_type == ICE_RESET_PFR) { 7205fbc7b27aSKiran Patil err = ice_rebuild_channels(pf); 7206fbc7b27aSKiran Patil if (err) { 7207fbc7b27aSKiran Patil dev_err(dev, "failed to rebuild and replay ADQ VSIs, err %d\n", 7208fbc7b27aSKiran Patil err); 7209fbc7b27aSKiran Patil goto err_vsi_rebuild; 7210fbc7b27aSKiran Patil } 7211fbc7b27aSKiran Patil } 7212fbc7b27aSKiran Patil 721383af0039SHenry Tieman /* If Flow Director is active */ 721483af0039SHenry Tieman if (test_bit(ICE_FLAG_FD_ENA, pf->flags)) { 721583af0039SHenry Tieman err = ice_vsi_rebuild_by_type(pf, ICE_VSI_CTRL); 721683af0039SHenry Tieman if (err) { 721783af0039SHenry Tieman dev_err(dev, "control VSI rebuild failed: %d\n", err); 721883af0039SHenry Tieman goto err_vsi_rebuild; 721983af0039SHenry Tieman } 722083af0039SHenry Tieman 722183af0039SHenry Tieman /* replay HW Flow Director recipes */ 722283af0039SHenry Tieman if (hw->fdir_prof) 722383af0039SHenry Tieman ice_fdir_replay_flows(hw); 722483af0039SHenry Tieman 722583af0039SHenry Tieman /* replay Flow Director filters */ 722683af0039SHenry Tieman ice_fdir_replay_fltrs(pf); 722728bf2672SBrett Creeley 722828bf2672SBrett Creeley ice_rebuild_arfs(pf); 722983af0039SHenry Tieman } 723083af0039SHenry Tieman 7231462acf6aSTony Nguyen ice_update_pf_netdev_link(pf); 7232462acf6aSTony Nguyen 7233462acf6aSTony Nguyen /* tell the firmware we are up */ 72342ccc1c1cSTony Nguyen err = ice_send_version(pf); 72352ccc1c1cSTony Nguyen if (err) { 72365f87ec48STony Nguyen dev_err(dev, "Rebuild failed due to error sending driver version: %d\n", 72372ccc1c1cSTony Nguyen err); 7238462acf6aSTony Nguyen goto err_vsi_rebuild; 7239ce317dd9SAnirudh Venkataramanan } 7240462acf6aSTony Nguyen 7241462acf6aSTony Nguyen ice_replay_post(hw); 7242ce317dd9SAnirudh Venkataramanan 72430f9d5027SAnirudh Venkataramanan /* if we get here, reset flow is successful */ 72447e408e07SAnirudh Venkataramanan clear_bit(ICE_RESET_FAILED, pf->state); 7245f9f5301eSDave Ertman 7246f9f5301eSDave Ertman ice_plug_aux_dev(pf); 72470b28b702SAnirudh Venkataramanan return; 72480b28b702SAnirudh Venkataramanan 72490f9d5027SAnirudh Venkataramanan err_vsi_rebuild: 72500f9d5027SAnirudh Venkataramanan err_sched_init_port: 72510f9d5027SAnirudh Venkataramanan ice_sched_cleanup_all(hw); 72520f9d5027SAnirudh Venkataramanan err_init_ctrlq: 72530b28b702SAnirudh Venkataramanan ice_shutdown_all_ctrlq(hw); 72547e408e07SAnirudh Venkataramanan set_bit(ICE_RESET_FAILED, pf->state); 72550b28b702SAnirudh Venkataramanan clear_recovery: 72560f9d5027SAnirudh Venkataramanan /* set this bit in PF state to control service task scheduling */ 72577e408e07SAnirudh Venkataramanan set_bit(ICE_NEEDS_RESTART, pf->state); 72580f9d5027SAnirudh Venkataramanan dev_err(dev, "Rebuild failed, unload and reload driver\n"); 72590b28b702SAnirudh Venkataramanan } 72600b28b702SAnirudh Venkataramanan 72610b28b702SAnirudh Venkataramanan /** 726223b44513SMaciej Fijalkowski * ice_max_xdp_frame_size - returns the maximum allowed frame size for XDP 726323b44513SMaciej Fijalkowski * @vsi: Pointer to VSI structure 726423b44513SMaciej Fijalkowski */ 726523b44513SMaciej Fijalkowski static int ice_max_xdp_frame_size(struct ice_vsi *vsi) 726623b44513SMaciej Fijalkowski { 726723b44513SMaciej Fijalkowski if (PAGE_SIZE >= 8192 || test_bit(ICE_FLAG_LEGACY_RX, vsi->back->flags)) 726823b44513SMaciej Fijalkowski return ICE_RXBUF_2048 - XDP_PACKET_HEADROOM; 726923b44513SMaciej Fijalkowski else 727023b44513SMaciej Fijalkowski return ICE_RXBUF_3072; 727123b44513SMaciej Fijalkowski } 727223b44513SMaciej Fijalkowski 727323b44513SMaciej Fijalkowski /** 7274e94d4478SAnirudh Venkataramanan * ice_change_mtu - NDO callback to change the MTU 7275e94d4478SAnirudh Venkataramanan * @netdev: network interface device structure 7276e94d4478SAnirudh Venkataramanan * @new_mtu: new value for maximum frame size 7277e94d4478SAnirudh Venkataramanan * 7278e94d4478SAnirudh Venkataramanan * Returns 0 on success, negative on failure 7279e94d4478SAnirudh Venkataramanan */ 7280e94d4478SAnirudh Venkataramanan static int ice_change_mtu(struct net_device *netdev, int new_mtu) 7281e94d4478SAnirudh Venkataramanan { 7282e94d4478SAnirudh Venkataramanan struct ice_netdev_priv *np = netdev_priv(netdev); 7283e94d4478SAnirudh Venkataramanan struct ice_vsi *vsi = np->vsi; 7284e94d4478SAnirudh Venkataramanan struct ice_pf *pf = vsi->back; 7285e94d4478SAnirudh Venkataramanan u8 count = 0; 7286348048e7SDave Ertman int err = 0; 7287e94d4478SAnirudh Venkataramanan 728822bef5e7SJesse Brandeburg if (new_mtu == (int)netdev->mtu) { 72892f2da36eSAnirudh Venkataramanan netdev_warn(netdev, "MTU is already %u\n", netdev->mtu); 7290e94d4478SAnirudh Venkataramanan return 0; 7291e94d4478SAnirudh Venkataramanan } 7292e94d4478SAnirudh Venkataramanan 7293efc2214bSMaciej Fijalkowski if (ice_is_xdp_ena_vsi(vsi)) { 729423b44513SMaciej Fijalkowski int frame_size = ice_max_xdp_frame_size(vsi); 7295efc2214bSMaciej Fijalkowski 7296efc2214bSMaciej Fijalkowski if (new_mtu + ICE_ETH_PKT_HDR_PAD > frame_size) { 7297efc2214bSMaciej Fijalkowski netdev_err(netdev, "max MTU for XDP usage is %d\n", 729823b44513SMaciej Fijalkowski frame_size - ICE_ETH_PKT_HDR_PAD); 7299efc2214bSMaciej Fijalkowski return -EINVAL; 7300efc2214bSMaciej Fijalkowski } 7301efc2214bSMaciej Fijalkowski } 7302efc2214bSMaciej Fijalkowski 7303e94d4478SAnirudh Venkataramanan /* if a reset is in progress, wait for some time for it to complete */ 7304e94d4478SAnirudh Venkataramanan do { 73055df7e45dSDave Ertman if (ice_is_reset_in_progress(pf->state)) { 7306e94d4478SAnirudh Venkataramanan count++; 7307e94d4478SAnirudh Venkataramanan usleep_range(1000, 2000); 7308e94d4478SAnirudh Venkataramanan } else { 7309e94d4478SAnirudh Venkataramanan break; 7310e94d4478SAnirudh Venkataramanan } 7311e94d4478SAnirudh Venkataramanan 7312e94d4478SAnirudh Venkataramanan } while (count < 100); 7313e94d4478SAnirudh Venkataramanan 7314e94d4478SAnirudh Venkataramanan if (count == 100) { 73152f2da36eSAnirudh Venkataramanan netdev_err(netdev, "can't change MTU. Device is busy\n"); 7316e94d4478SAnirudh Venkataramanan return -EBUSY; 7317e94d4478SAnirudh Venkataramanan } 7318e94d4478SAnirudh Venkataramanan 731922bef5e7SJesse Brandeburg netdev->mtu = (unsigned int)new_mtu; 7320e94d4478SAnirudh Venkataramanan 7321e94d4478SAnirudh Venkataramanan /* if VSI is up, bring it down and then back up */ 7322e97fb1aeSAnirudh Venkataramanan if (!test_and_set_bit(ICE_VSI_DOWN, vsi->state)) { 7323e94d4478SAnirudh Venkataramanan err = ice_down(vsi); 7324e94d4478SAnirudh Venkataramanan if (err) { 7325fe6cd890SMitch Williams netdev_err(netdev, "change MTU if_down err %d\n", err); 732697b01291SDave Ertman return err; 7327e94d4478SAnirudh Venkataramanan } 7328e94d4478SAnirudh Venkataramanan 7329e94d4478SAnirudh Venkataramanan err = ice_up(vsi); 7330e94d4478SAnirudh Venkataramanan if (err) { 73312f2da36eSAnirudh Venkataramanan netdev_err(netdev, "change MTU if_up err %d\n", err); 733297b01291SDave Ertman return err; 7333e94d4478SAnirudh Venkataramanan } 7334e94d4478SAnirudh Venkataramanan } 7335e94d4478SAnirudh Venkataramanan 7336bda5b7dbSTony Nguyen netdev_dbg(netdev, "changed MTU to %d\n", new_mtu); 733797b01291SDave Ertman set_bit(ICE_FLAG_MTU_CHANGED, pf->flags); 7338348048e7SDave Ertman 7339348048e7SDave Ertman return err; 7340e94d4478SAnirudh Venkataramanan } 7341e94d4478SAnirudh Venkataramanan 7342e94d4478SAnirudh Venkataramanan /** 7343a7605370SArnd Bergmann * ice_eth_ioctl - Access the hwtstamp interface 734477a78115SJacob Keller * @netdev: network interface device structure 734577a78115SJacob Keller * @ifr: interface request data 734677a78115SJacob Keller * @cmd: ioctl command 734777a78115SJacob Keller */ 7348a7605370SArnd Bergmann static int ice_eth_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd) 734977a78115SJacob Keller { 735077a78115SJacob Keller struct ice_netdev_priv *np = netdev_priv(netdev); 735177a78115SJacob Keller struct ice_pf *pf = np->vsi->back; 735277a78115SJacob Keller 735377a78115SJacob Keller switch (cmd) { 735477a78115SJacob Keller case SIOCGHWTSTAMP: 735577a78115SJacob Keller return ice_ptp_get_ts_config(pf, ifr); 735677a78115SJacob Keller case SIOCSHWTSTAMP: 735777a78115SJacob Keller return ice_ptp_set_ts_config(pf, ifr); 735877a78115SJacob Keller default: 735977a78115SJacob Keller return -EOPNOTSUPP; 736077a78115SJacob Keller } 736177a78115SJacob Keller } 736277a78115SJacob Keller 736377a78115SJacob Keller /** 73640fee3577SLihong Yang * ice_aq_str - convert AQ err code to a string 73650fee3577SLihong Yang * @aq_err: the AQ error code to convert 73660fee3577SLihong Yang */ 73670fee3577SLihong Yang const char *ice_aq_str(enum ice_aq_err aq_err) 73680fee3577SLihong Yang { 73690fee3577SLihong Yang switch (aq_err) { 73700fee3577SLihong Yang case ICE_AQ_RC_OK: 73710fee3577SLihong Yang return "OK"; 73720fee3577SLihong Yang case ICE_AQ_RC_EPERM: 73730fee3577SLihong Yang return "ICE_AQ_RC_EPERM"; 73740fee3577SLihong Yang case ICE_AQ_RC_ENOENT: 73750fee3577SLihong Yang return "ICE_AQ_RC_ENOENT"; 73760fee3577SLihong Yang case ICE_AQ_RC_ENOMEM: 73770fee3577SLihong Yang return "ICE_AQ_RC_ENOMEM"; 73780fee3577SLihong Yang case ICE_AQ_RC_EBUSY: 73790fee3577SLihong Yang return "ICE_AQ_RC_EBUSY"; 73800fee3577SLihong Yang case ICE_AQ_RC_EEXIST: 73810fee3577SLihong Yang return "ICE_AQ_RC_EEXIST"; 73820fee3577SLihong Yang case ICE_AQ_RC_EINVAL: 73830fee3577SLihong Yang return "ICE_AQ_RC_EINVAL"; 73840fee3577SLihong Yang case ICE_AQ_RC_ENOSPC: 73850fee3577SLihong Yang return "ICE_AQ_RC_ENOSPC"; 73860fee3577SLihong Yang case ICE_AQ_RC_ENOSYS: 73870fee3577SLihong Yang return "ICE_AQ_RC_ENOSYS"; 7388b5e19a64SChinh T Cao case ICE_AQ_RC_EMODE: 7389b5e19a64SChinh T Cao return "ICE_AQ_RC_EMODE"; 73900fee3577SLihong Yang case ICE_AQ_RC_ENOSEC: 73910fee3577SLihong Yang return "ICE_AQ_RC_ENOSEC"; 73920fee3577SLihong Yang case ICE_AQ_RC_EBADSIG: 73930fee3577SLihong Yang return "ICE_AQ_RC_EBADSIG"; 73940fee3577SLihong Yang case ICE_AQ_RC_ESVN: 73950fee3577SLihong Yang return "ICE_AQ_RC_ESVN"; 73960fee3577SLihong Yang case ICE_AQ_RC_EBADMAN: 73970fee3577SLihong Yang return "ICE_AQ_RC_EBADMAN"; 73980fee3577SLihong Yang case ICE_AQ_RC_EBADBUF: 73990fee3577SLihong Yang return "ICE_AQ_RC_EBADBUF"; 74000fee3577SLihong Yang } 74010fee3577SLihong Yang 74020fee3577SLihong Yang return "ICE_AQ_RC_UNKNOWN"; 74030fee3577SLihong Yang } 74040fee3577SLihong Yang 74050fee3577SLihong Yang /** 7406b66a972aSBrett Creeley * ice_set_rss_lut - Set RSS LUT 7407d76a60baSAnirudh Venkataramanan * @vsi: Pointer to VSI structure 7408d76a60baSAnirudh Venkataramanan * @lut: Lookup table 7409d76a60baSAnirudh Venkataramanan * @lut_size: Lookup table size 7410d76a60baSAnirudh Venkataramanan * 7411d76a60baSAnirudh Venkataramanan * Returns 0 on success, negative on failure 7412d76a60baSAnirudh Venkataramanan */ 7413b66a972aSBrett Creeley int ice_set_rss_lut(struct ice_vsi *vsi, u8 *lut, u16 lut_size) 7414d76a60baSAnirudh Venkataramanan { 7415b66a972aSBrett Creeley struct ice_aq_get_set_rss_lut_params params = {}; 7416b66a972aSBrett Creeley struct ice_hw *hw = &vsi->back->hw; 74175e24d598STony Nguyen int status; 7418d76a60baSAnirudh Venkataramanan 7419b66a972aSBrett Creeley if (!lut) 7420b66a972aSBrett Creeley return -EINVAL; 7421d76a60baSAnirudh Venkataramanan 7422b66a972aSBrett Creeley params.vsi_handle = vsi->idx; 7423b66a972aSBrett Creeley params.lut_size = lut_size; 7424b66a972aSBrett Creeley params.lut_type = vsi->rss_lut_type; 7425b66a972aSBrett Creeley params.lut = lut; 7426d76a60baSAnirudh Venkataramanan 7427b66a972aSBrett Creeley status = ice_aq_set_rss_lut(hw, ¶ms); 7428c1484691STony Nguyen if (status) 74295f87ec48STony Nguyen dev_err(ice_pf_to_dev(vsi->back), "Cannot set RSS lut, err %d aq_err %s\n", 74305518ac2aSTony Nguyen status, ice_aq_str(hw->adminq.sq_last_status)); 7431d76a60baSAnirudh Venkataramanan 7432c1484691STony Nguyen return status; 7433d76a60baSAnirudh Venkataramanan } 7434d76a60baSAnirudh Venkataramanan 7435d76a60baSAnirudh Venkataramanan /** 7436b66a972aSBrett Creeley * ice_set_rss_key - Set RSS key 7437b66a972aSBrett Creeley * @vsi: Pointer to the VSI structure 7438b66a972aSBrett Creeley * @seed: RSS hash seed 7439b66a972aSBrett Creeley * 7440b66a972aSBrett Creeley * Returns 0 on success, negative on failure 7441b66a972aSBrett Creeley */ 7442b66a972aSBrett Creeley int ice_set_rss_key(struct ice_vsi *vsi, u8 *seed) 7443b66a972aSBrett Creeley { 7444b66a972aSBrett Creeley struct ice_hw *hw = &vsi->back->hw; 74455e24d598STony Nguyen int status; 7446b66a972aSBrett Creeley 7447b66a972aSBrett Creeley if (!seed) 7448b66a972aSBrett Creeley return -EINVAL; 7449b66a972aSBrett Creeley 7450b66a972aSBrett Creeley status = ice_aq_set_rss_key(hw, vsi->idx, (struct ice_aqc_get_set_rss_keys *)seed); 7451c1484691STony Nguyen if (status) 74525f87ec48STony Nguyen dev_err(ice_pf_to_dev(vsi->back), "Cannot set RSS key, err %d aq_err %s\n", 74535518ac2aSTony Nguyen status, ice_aq_str(hw->adminq.sq_last_status)); 7454b66a972aSBrett Creeley 7455c1484691STony Nguyen return status; 7456b66a972aSBrett Creeley } 7457b66a972aSBrett Creeley 7458b66a972aSBrett Creeley /** 7459b66a972aSBrett Creeley * ice_get_rss_lut - Get RSS LUT 7460d76a60baSAnirudh Venkataramanan * @vsi: Pointer to VSI structure 7461d76a60baSAnirudh Venkataramanan * @lut: Buffer to store the lookup table entries 7462d76a60baSAnirudh Venkataramanan * @lut_size: Size of buffer to store the lookup table entries 7463d76a60baSAnirudh Venkataramanan * 7464d76a60baSAnirudh Venkataramanan * Returns 0 on success, negative on failure 7465d76a60baSAnirudh Venkataramanan */ 7466b66a972aSBrett Creeley int ice_get_rss_lut(struct ice_vsi *vsi, u8 *lut, u16 lut_size) 7467d76a60baSAnirudh Venkataramanan { 7468b66a972aSBrett Creeley struct ice_aq_get_set_rss_lut_params params = {}; 7469b66a972aSBrett Creeley struct ice_hw *hw = &vsi->back->hw; 74705e24d598STony Nguyen int status; 7471d76a60baSAnirudh Venkataramanan 7472b66a972aSBrett Creeley if (!lut) 7473b66a972aSBrett Creeley return -EINVAL; 7474d76a60baSAnirudh Venkataramanan 7475b66a972aSBrett Creeley params.vsi_handle = vsi->idx; 7476b66a972aSBrett Creeley params.lut_size = lut_size; 7477b66a972aSBrett Creeley params.lut_type = vsi->rss_lut_type; 7478b66a972aSBrett Creeley params.lut = lut; 7479b66a972aSBrett Creeley 7480b66a972aSBrett Creeley status = ice_aq_get_rss_lut(hw, ¶ms); 7481c1484691STony Nguyen if (status) 74825f87ec48STony Nguyen dev_err(ice_pf_to_dev(vsi->back), "Cannot get RSS lut, err %d aq_err %s\n", 74835518ac2aSTony Nguyen status, ice_aq_str(hw->adminq.sq_last_status)); 7484b66a972aSBrett Creeley 7485c1484691STony Nguyen return status; 7486d76a60baSAnirudh Venkataramanan } 7487d76a60baSAnirudh Venkataramanan 7488b66a972aSBrett Creeley /** 7489b66a972aSBrett Creeley * ice_get_rss_key - Get RSS key 7490b66a972aSBrett Creeley * @vsi: Pointer to VSI structure 7491b66a972aSBrett Creeley * @seed: Buffer to store the key in 7492b66a972aSBrett Creeley * 7493b66a972aSBrett Creeley * Returns 0 on success, negative on failure 7494b66a972aSBrett Creeley */ 7495b66a972aSBrett Creeley int ice_get_rss_key(struct ice_vsi *vsi, u8 *seed) 7496b66a972aSBrett Creeley { 7497b66a972aSBrett Creeley struct ice_hw *hw = &vsi->back->hw; 74985e24d598STony Nguyen int status; 7499e3c53928SBrett Creeley 7500b66a972aSBrett Creeley if (!seed) 7501b66a972aSBrett Creeley return -EINVAL; 7502b66a972aSBrett Creeley 7503b66a972aSBrett Creeley status = ice_aq_get_rss_key(hw, vsi->idx, (struct ice_aqc_get_set_rss_keys *)seed); 7504c1484691STony Nguyen if (status) 75055f87ec48STony Nguyen dev_err(ice_pf_to_dev(vsi->back), "Cannot get RSS key, err %d aq_err %s\n", 75065518ac2aSTony Nguyen status, ice_aq_str(hw->adminq.sq_last_status)); 7507d76a60baSAnirudh Venkataramanan 7508c1484691STony Nguyen return status; 7509d76a60baSAnirudh Venkataramanan } 7510d76a60baSAnirudh Venkataramanan 7511d76a60baSAnirudh Venkataramanan /** 7512b1edc14aSMd Fahad Iqbal Polash * ice_bridge_getlink - Get the hardware bridge mode 7513b1edc14aSMd Fahad Iqbal Polash * @skb: skb buff 7514f9867df6SAnirudh Venkataramanan * @pid: process ID 7515b1edc14aSMd Fahad Iqbal Polash * @seq: RTNL message seq 7516b1edc14aSMd Fahad Iqbal Polash * @dev: the netdev being configured 7517b1edc14aSMd Fahad Iqbal Polash * @filter_mask: filter mask passed in 7518b1edc14aSMd Fahad Iqbal Polash * @nlflags: netlink flags passed in 7519b1edc14aSMd Fahad Iqbal Polash * 7520b1edc14aSMd Fahad Iqbal Polash * Return the bridge mode (VEB/VEPA) 7521b1edc14aSMd Fahad Iqbal Polash */ 7522b1edc14aSMd Fahad Iqbal Polash static int 7523b1edc14aSMd Fahad Iqbal Polash ice_bridge_getlink(struct sk_buff *skb, u32 pid, u32 seq, 7524b1edc14aSMd Fahad Iqbal Polash struct net_device *dev, u32 filter_mask, int nlflags) 7525b1edc14aSMd Fahad Iqbal Polash { 7526b1edc14aSMd Fahad Iqbal Polash struct ice_netdev_priv *np = netdev_priv(dev); 7527b1edc14aSMd Fahad Iqbal Polash struct ice_vsi *vsi = np->vsi; 7528b1edc14aSMd Fahad Iqbal Polash struct ice_pf *pf = vsi->back; 7529b1edc14aSMd Fahad Iqbal Polash u16 bmode; 7530b1edc14aSMd Fahad Iqbal Polash 7531b1edc14aSMd Fahad Iqbal Polash bmode = pf->first_sw->bridge_mode; 7532b1edc14aSMd Fahad Iqbal Polash 7533b1edc14aSMd Fahad Iqbal Polash return ndo_dflt_bridge_getlink(skb, pid, seq, dev, bmode, 0, 0, nlflags, 7534b1edc14aSMd Fahad Iqbal Polash filter_mask, NULL); 7535b1edc14aSMd Fahad Iqbal Polash } 7536b1edc14aSMd Fahad Iqbal Polash 7537b1edc14aSMd Fahad Iqbal Polash /** 7538b1edc14aSMd Fahad Iqbal Polash * ice_vsi_update_bridge_mode - Update VSI for switching bridge mode (VEB/VEPA) 7539b1edc14aSMd Fahad Iqbal Polash * @vsi: Pointer to VSI structure 7540b1edc14aSMd Fahad Iqbal Polash * @bmode: Hardware bridge mode (VEB/VEPA) 7541b1edc14aSMd Fahad Iqbal Polash * 7542b1edc14aSMd Fahad Iqbal Polash * Returns 0 on success, negative on failure 7543b1edc14aSMd Fahad Iqbal Polash */ 7544b1edc14aSMd Fahad Iqbal Polash static int ice_vsi_update_bridge_mode(struct ice_vsi *vsi, u16 bmode) 7545b1edc14aSMd Fahad Iqbal Polash { 7546b1edc14aSMd Fahad Iqbal Polash struct ice_aqc_vsi_props *vsi_props; 7547b1edc14aSMd Fahad Iqbal Polash struct ice_hw *hw = &vsi->back->hw; 7548198a666aSBruce Allan struct ice_vsi_ctx *ctxt; 75492ccc1c1cSTony Nguyen int ret; 7550b1edc14aSMd Fahad Iqbal Polash 7551b1edc14aSMd Fahad Iqbal Polash vsi_props = &vsi->info; 7552198a666aSBruce Allan 75539efe35d0STony Nguyen ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL); 7554198a666aSBruce Allan if (!ctxt) 7555198a666aSBruce Allan return -ENOMEM; 7556198a666aSBruce Allan 7557198a666aSBruce Allan ctxt->info = vsi->info; 7558b1edc14aSMd Fahad Iqbal Polash 7559b1edc14aSMd Fahad Iqbal Polash if (bmode == BRIDGE_MODE_VEB) 7560b1edc14aSMd Fahad Iqbal Polash /* change from VEPA to VEB mode */ 7561198a666aSBruce Allan ctxt->info.sw_flags |= ICE_AQ_VSI_SW_FLAG_ALLOW_LB; 7562b1edc14aSMd Fahad Iqbal Polash else 7563b1edc14aSMd Fahad Iqbal Polash /* change from VEB to VEPA mode */ 7564198a666aSBruce Allan ctxt->info.sw_flags &= ~ICE_AQ_VSI_SW_FLAG_ALLOW_LB; 7565198a666aSBruce Allan ctxt->info.valid_sections = cpu_to_le16(ICE_AQ_VSI_PROP_SW_VALID); 75665726ca0eSAnirudh Venkataramanan 75672ccc1c1cSTony Nguyen ret = ice_update_vsi(hw, vsi->idx, ctxt, NULL); 75682ccc1c1cSTony Nguyen if (ret) { 75695f87ec48STony Nguyen dev_err(ice_pf_to_dev(vsi->back), "update VSI for bridge mode failed, bmode = %d err %d aq_err %s\n", 75702ccc1c1cSTony Nguyen bmode, ret, ice_aq_str(hw->adminq.sq_last_status)); 7571198a666aSBruce Allan goto out; 7572b1edc14aSMd Fahad Iqbal Polash } 7573b1edc14aSMd Fahad Iqbal Polash /* Update sw flags for book keeping */ 7574198a666aSBruce Allan vsi_props->sw_flags = ctxt->info.sw_flags; 7575b1edc14aSMd Fahad Iqbal Polash 7576198a666aSBruce Allan out: 75779efe35d0STony Nguyen kfree(ctxt); 7578198a666aSBruce Allan return ret; 7579b1edc14aSMd Fahad Iqbal Polash } 7580b1edc14aSMd Fahad Iqbal Polash 7581b1edc14aSMd Fahad Iqbal Polash /** 7582b1edc14aSMd Fahad Iqbal Polash * ice_bridge_setlink - Set the hardware bridge mode 7583b1edc14aSMd Fahad Iqbal Polash * @dev: the netdev being configured 7584b1edc14aSMd Fahad Iqbal Polash * @nlh: RTNL message 7585b1edc14aSMd Fahad Iqbal Polash * @flags: bridge setlink flags 75862fd527b7SPetr Machata * @extack: netlink extended ack 7587b1edc14aSMd Fahad Iqbal Polash * 7588b1edc14aSMd Fahad Iqbal Polash * Sets the bridge mode (VEB/VEPA) of the switch to which the netdev (VSI) is 7589b1edc14aSMd Fahad Iqbal Polash * hooked up to. Iterates through the PF VSI list and sets the loopback mode (if 7590b1edc14aSMd Fahad Iqbal Polash * not already set for all VSIs connected to this switch. And also update the 7591b1edc14aSMd Fahad Iqbal Polash * unicast switch filter rules for the corresponding switch of the netdev. 7592b1edc14aSMd Fahad Iqbal Polash */ 7593b1edc14aSMd Fahad Iqbal Polash static int 7594b1edc14aSMd Fahad Iqbal Polash ice_bridge_setlink(struct net_device *dev, struct nlmsghdr *nlh, 75953d505147SBruce Allan u16 __always_unused flags, 75963d505147SBruce Allan struct netlink_ext_ack __always_unused *extack) 7597b1edc14aSMd Fahad Iqbal Polash { 7598b1edc14aSMd Fahad Iqbal Polash struct ice_netdev_priv *np = netdev_priv(dev); 7599b1edc14aSMd Fahad Iqbal Polash struct ice_pf *pf = np->vsi->back; 7600b1edc14aSMd Fahad Iqbal Polash struct nlattr *attr, *br_spec; 7601b1edc14aSMd Fahad Iqbal Polash struct ice_hw *hw = &pf->hw; 7602b1edc14aSMd Fahad Iqbal Polash struct ice_sw *pf_sw; 7603b1edc14aSMd Fahad Iqbal Polash int rem, v, err = 0; 7604b1edc14aSMd Fahad Iqbal Polash 7605b1edc14aSMd Fahad Iqbal Polash pf_sw = pf->first_sw; 7606b1edc14aSMd Fahad Iqbal Polash /* find the attribute in the netlink message */ 7607b1edc14aSMd Fahad Iqbal Polash br_spec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC); 7608b1edc14aSMd Fahad Iqbal Polash 7609b1edc14aSMd Fahad Iqbal Polash nla_for_each_nested(attr, br_spec, rem) { 7610b1edc14aSMd Fahad Iqbal Polash __u16 mode; 7611b1edc14aSMd Fahad Iqbal Polash 7612b1edc14aSMd Fahad Iqbal Polash if (nla_type(attr) != IFLA_BRIDGE_MODE) 7613b1edc14aSMd Fahad Iqbal Polash continue; 7614b1edc14aSMd Fahad Iqbal Polash mode = nla_get_u16(attr); 7615b1edc14aSMd Fahad Iqbal Polash if (mode != BRIDGE_MODE_VEPA && mode != BRIDGE_MODE_VEB) 7616b1edc14aSMd Fahad Iqbal Polash return -EINVAL; 7617b1edc14aSMd Fahad Iqbal Polash /* Continue if bridge mode is not being flipped */ 7618b1edc14aSMd Fahad Iqbal Polash if (mode == pf_sw->bridge_mode) 7619b1edc14aSMd Fahad Iqbal Polash continue; 7620b1edc14aSMd Fahad Iqbal Polash /* Iterates through the PF VSI list and update the loopback 7621b1edc14aSMd Fahad Iqbal Polash * mode of the VSI 7622b1edc14aSMd Fahad Iqbal Polash */ 7623b1edc14aSMd Fahad Iqbal Polash ice_for_each_vsi(pf, v) { 7624b1edc14aSMd Fahad Iqbal Polash if (!pf->vsi[v]) 7625b1edc14aSMd Fahad Iqbal Polash continue; 7626b1edc14aSMd Fahad Iqbal Polash err = ice_vsi_update_bridge_mode(pf->vsi[v], mode); 7627b1edc14aSMd Fahad Iqbal Polash if (err) 7628b1edc14aSMd Fahad Iqbal Polash return err; 7629b1edc14aSMd Fahad Iqbal Polash } 7630b1edc14aSMd Fahad Iqbal Polash 7631b1edc14aSMd Fahad Iqbal Polash hw->evb_veb = (mode == BRIDGE_MODE_VEB); 7632b1edc14aSMd Fahad Iqbal Polash /* Update the unicast switch filter rules for the corresponding 7633b1edc14aSMd Fahad Iqbal Polash * switch of the netdev 7634b1edc14aSMd Fahad Iqbal Polash */ 76352ccc1c1cSTony Nguyen err = ice_update_sw_rule_bridge_mode(hw); 76362ccc1c1cSTony Nguyen if (err) { 76375f87ec48STony Nguyen netdev_err(dev, "switch rule update failed, mode = %d err %d aq_err %s\n", 76382ccc1c1cSTony Nguyen mode, err, 76390fee3577SLihong Yang ice_aq_str(hw->adminq.sq_last_status)); 7640b1edc14aSMd Fahad Iqbal Polash /* revert hw->evb_veb */ 7641b1edc14aSMd Fahad Iqbal Polash hw->evb_veb = (pf_sw->bridge_mode == BRIDGE_MODE_VEB); 7642c1484691STony Nguyen return err; 7643b1edc14aSMd Fahad Iqbal Polash } 7644b1edc14aSMd Fahad Iqbal Polash 7645b1edc14aSMd Fahad Iqbal Polash pf_sw->bridge_mode = mode; 7646b1edc14aSMd Fahad Iqbal Polash } 7647b1edc14aSMd Fahad Iqbal Polash 7648b1edc14aSMd Fahad Iqbal Polash return 0; 7649b1edc14aSMd Fahad Iqbal Polash } 7650b1edc14aSMd Fahad Iqbal Polash 7651b1edc14aSMd Fahad Iqbal Polash /** 7652b3969fd7SSudheer Mogilappagari * ice_tx_timeout - Respond to a Tx Hang 7653b3969fd7SSudheer Mogilappagari * @netdev: network interface device structure 7654644f40eaSBruce Allan * @txqueue: Tx queue 7655b3969fd7SSudheer Mogilappagari */ 76560290bd29SMichael S. Tsirkin static void ice_tx_timeout(struct net_device *netdev, unsigned int txqueue) 7657b3969fd7SSudheer Mogilappagari { 7658b3969fd7SSudheer Mogilappagari struct ice_netdev_priv *np = netdev_priv(netdev); 7659e72bba21SMaciej Fijalkowski struct ice_tx_ring *tx_ring = NULL; 7660b3969fd7SSudheer Mogilappagari struct ice_vsi *vsi = np->vsi; 7661b3969fd7SSudheer Mogilappagari struct ice_pf *pf = vsi->back; 7662807bc98dSBrett Creeley u32 i; 7663b3969fd7SSudheer Mogilappagari 7664b3969fd7SSudheer Mogilappagari pf->tx_timeout_count++; 7665b3969fd7SSudheer Mogilappagari 7666610ed0e9SAvinash JD /* Check if PFC is enabled for the TC to which the queue belongs 7667610ed0e9SAvinash JD * to. If yes then Tx timeout is not caused by a hung queue, no 7668610ed0e9SAvinash JD * need to reset and rebuild 7669610ed0e9SAvinash JD */ 7670610ed0e9SAvinash JD if (ice_is_pfc_causing_hung_q(pf, txqueue)) { 7671610ed0e9SAvinash JD dev_info(ice_pf_to_dev(pf), "Fake Tx hang detected on queue %u, timeout caused by PFC storm\n", 7672610ed0e9SAvinash JD txqueue); 7673610ed0e9SAvinash JD return; 7674610ed0e9SAvinash JD } 7675610ed0e9SAvinash JD 7676b3969fd7SSudheer Mogilappagari /* now that we have an index, find the tx_ring struct */ 76772faf63b6SMaciej Fijalkowski ice_for_each_txq(vsi, i) 7678bc0c6fabSBruce Allan if (vsi->tx_rings[i] && vsi->tx_rings[i]->desc) 7679ed5a3f66SJulio Faracco if (txqueue == vsi->tx_rings[i]->q_index) { 7680b3969fd7SSudheer Mogilappagari tx_ring = vsi->tx_rings[i]; 7681b3969fd7SSudheer Mogilappagari break; 7682b3969fd7SSudheer Mogilappagari } 7683b3969fd7SSudheer Mogilappagari 7684b3969fd7SSudheer Mogilappagari /* Reset recovery level if enough time has elapsed after last timeout. 7685b3969fd7SSudheer Mogilappagari * Also ensure no new reset action happens before next timeout period. 7686b3969fd7SSudheer Mogilappagari */ 7687b3969fd7SSudheer Mogilappagari if (time_after(jiffies, (pf->tx_timeout_last_recovery + HZ * 20))) 7688b3969fd7SSudheer Mogilappagari pf->tx_timeout_recovery_level = 1; 7689b3969fd7SSudheer Mogilappagari else if (time_before(jiffies, (pf->tx_timeout_last_recovery + 7690b3969fd7SSudheer Mogilappagari netdev->watchdog_timeo))) 7691b3969fd7SSudheer Mogilappagari return; 7692b3969fd7SSudheer Mogilappagari 7693b3969fd7SSudheer Mogilappagari if (tx_ring) { 7694807bc98dSBrett Creeley struct ice_hw *hw = &pf->hw; 7695807bc98dSBrett Creeley u32 head, val = 0; 7696807bc98dSBrett Creeley 7697ed5a3f66SJulio Faracco head = (rd32(hw, QTX_COMM_HEAD(vsi->txq_map[txqueue])) & 7698807bc98dSBrett Creeley QTX_COMM_HEAD_HEAD_M) >> QTX_COMM_HEAD_HEAD_S; 7699b3969fd7SSudheer Mogilappagari /* Read interrupt register */ 7700ba880734SBrett Creeley val = rd32(hw, GLINT_DYN_CTL(tx_ring->q_vector->reg_idx)); 7701b3969fd7SSudheer Mogilappagari 770293ff4858STony Nguyen netdev_info(netdev, "tx_timeout: VSI_num: %d, Q %u, NTC: 0x%x, HW_HEAD: 0x%x, NTU: 0x%x, INT: 0x%x\n", 7703ed5a3f66SJulio Faracco vsi->vsi_num, txqueue, tx_ring->next_to_clean, 7704807bc98dSBrett Creeley head, tx_ring->next_to_use, val); 7705b3969fd7SSudheer Mogilappagari } 7706b3969fd7SSudheer Mogilappagari 7707b3969fd7SSudheer Mogilappagari pf->tx_timeout_last_recovery = jiffies; 770893ff4858STony Nguyen netdev_info(netdev, "tx_timeout recovery level %d, txqueue %u\n", 7709ed5a3f66SJulio Faracco pf->tx_timeout_recovery_level, txqueue); 7710b3969fd7SSudheer Mogilappagari 7711b3969fd7SSudheer Mogilappagari switch (pf->tx_timeout_recovery_level) { 7712b3969fd7SSudheer Mogilappagari case 1: 77137e408e07SAnirudh Venkataramanan set_bit(ICE_PFR_REQ, pf->state); 7714b3969fd7SSudheer Mogilappagari break; 7715b3969fd7SSudheer Mogilappagari case 2: 77167e408e07SAnirudh Venkataramanan set_bit(ICE_CORER_REQ, pf->state); 7717b3969fd7SSudheer Mogilappagari break; 7718b3969fd7SSudheer Mogilappagari case 3: 77197e408e07SAnirudh Venkataramanan set_bit(ICE_GLOBR_REQ, pf->state); 7720b3969fd7SSudheer Mogilappagari break; 7721b3969fd7SSudheer Mogilappagari default: 7722b3969fd7SSudheer Mogilappagari netdev_err(netdev, "tx_timeout recovery unsuccessful, device is in unrecoverable state.\n"); 77237e408e07SAnirudh Venkataramanan set_bit(ICE_DOWN, pf->state); 7724e97fb1aeSAnirudh Venkataramanan set_bit(ICE_VSI_NEEDS_RESTART, vsi->state); 77257e408e07SAnirudh Venkataramanan set_bit(ICE_SERVICE_DIS, pf->state); 7726b3969fd7SSudheer Mogilappagari break; 7727b3969fd7SSudheer Mogilappagari } 7728b3969fd7SSudheer Mogilappagari 7729b3969fd7SSudheer Mogilappagari ice_service_task_schedule(pf); 7730b3969fd7SSudheer Mogilappagari pf->tx_timeout_recovery_level++; 7731b3969fd7SSudheer Mogilappagari } 7732b3969fd7SSudheer Mogilappagari 7733b3969fd7SSudheer Mogilappagari /** 77340d08a441SKiran Patil * ice_setup_tc_cls_flower - flower classifier offloads 77350d08a441SKiran Patil * @np: net device to configure 77360d08a441SKiran Patil * @filter_dev: device on which filter is added 77370d08a441SKiran Patil * @cls_flower: offload data 77380d08a441SKiran Patil */ 77390d08a441SKiran Patil static int 77400d08a441SKiran Patil ice_setup_tc_cls_flower(struct ice_netdev_priv *np, 77410d08a441SKiran Patil struct net_device *filter_dev, 77420d08a441SKiran Patil struct flow_cls_offload *cls_flower) 77430d08a441SKiran Patil { 77440d08a441SKiran Patil struct ice_vsi *vsi = np->vsi; 77450d08a441SKiran Patil 77460d08a441SKiran Patil if (cls_flower->common.chain_index) 77470d08a441SKiran Patil return -EOPNOTSUPP; 77480d08a441SKiran Patil 77490d08a441SKiran Patil switch (cls_flower->command) { 77500d08a441SKiran Patil case FLOW_CLS_REPLACE: 77510d08a441SKiran Patil return ice_add_cls_flower(filter_dev, vsi, cls_flower); 77520d08a441SKiran Patil case FLOW_CLS_DESTROY: 77530d08a441SKiran Patil return ice_del_cls_flower(vsi, cls_flower); 77540d08a441SKiran Patil default: 77550d08a441SKiran Patil return -EINVAL; 77560d08a441SKiran Patil } 77570d08a441SKiran Patil } 77580d08a441SKiran Patil 77590d08a441SKiran Patil /** 77600d08a441SKiran Patil * ice_setup_tc_block_cb - callback handler registered for TC block 77610d08a441SKiran Patil * @type: TC SETUP type 77620d08a441SKiran Patil * @type_data: TC flower offload data that contains user input 77630d08a441SKiran Patil * @cb_priv: netdev private data 77640d08a441SKiran Patil */ 77650d08a441SKiran Patil static int 77660d08a441SKiran Patil ice_setup_tc_block_cb(enum tc_setup_type type, void *type_data, void *cb_priv) 77670d08a441SKiran Patil { 77680d08a441SKiran Patil struct ice_netdev_priv *np = cb_priv; 77690d08a441SKiran Patil 77700d08a441SKiran Patil switch (type) { 77710d08a441SKiran Patil case TC_SETUP_CLSFLOWER: 77720d08a441SKiran Patil return ice_setup_tc_cls_flower(np, np->vsi->netdev, 77730d08a441SKiran Patil type_data); 77740d08a441SKiran Patil default: 77750d08a441SKiran Patil return -EOPNOTSUPP; 77760d08a441SKiran Patil } 77770d08a441SKiran Patil } 77780d08a441SKiran Patil 7779fbc7b27aSKiran Patil /** 7780fbc7b27aSKiran Patil * ice_validate_mqprio_qopt - Validate TCF input parameters 7781fbc7b27aSKiran Patil * @vsi: Pointer to VSI 7782fbc7b27aSKiran Patil * @mqprio_qopt: input parameters for mqprio queue configuration 7783fbc7b27aSKiran Patil * 7784fbc7b27aSKiran Patil * This function validates MQPRIO params, such as qcount (power of 2 wherever 7785fbc7b27aSKiran Patil * needed), and make sure user doesn't specify qcount and BW rate limit 7786fbc7b27aSKiran Patil * for TCs, which are more than "num_tc" 7787fbc7b27aSKiran Patil */ 7788fbc7b27aSKiran Patil static int 7789fbc7b27aSKiran Patil ice_validate_mqprio_qopt(struct ice_vsi *vsi, 7790fbc7b27aSKiran Patil struct tc_mqprio_qopt_offload *mqprio_qopt) 7791fbc7b27aSKiran Patil { 7792fbc7b27aSKiran Patil u64 sum_max_rate = 0, sum_min_rate = 0; 7793fbc7b27aSKiran Patil int non_power_of_2_qcount = 0; 7794fbc7b27aSKiran Patil struct ice_pf *pf = vsi->back; 7795fbc7b27aSKiran Patil int max_rss_q_cnt = 0; 7796fbc7b27aSKiran Patil struct device *dev; 7797fbc7b27aSKiran Patil int i, speed; 7798fbc7b27aSKiran Patil u8 num_tc; 7799fbc7b27aSKiran Patil 7800fbc7b27aSKiran Patil if (vsi->type != ICE_VSI_PF) 7801fbc7b27aSKiran Patil return -EINVAL; 7802fbc7b27aSKiran Patil 7803fbc7b27aSKiran Patil if (mqprio_qopt->qopt.offset[0] != 0 || 7804fbc7b27aSKiran Patil mqprio_qopt->qopt.num_tc < 1 || 7805fbc7b27aSKiran Patil mqprio_qopt->qopt.num_tc > ICE_CHNL_MAX_TC) 7806fbc7b27aSKiran Patil return -EINVAL; 7807fbc7b27aSKiran Patil 7808fbc7b27aSKiran Patil dev = ice_pf_to_dev(pf); 7809fbc7b27aSKiran Patil vsi->ch_rss_size = 0; 7810fbc7b27aSKiran Patil num_tc = mqprio_qopt->qopt.num_tc; 7811fbc7b27aSKiran Patil 7812fbc7b27aSKiran Patil for (i = 0; num_tc; i++) { 7813fbc7b27aSKiran Patil int qcount = mqprio_qopt->qopt.count[i]; 7814fbc7b27aSKiran Patil u64 max_rate, min_rate, rem; 7815fbc7b27aSKiran Patil 7816fbc7b27aSKiran Patil if (!qcount) 7817fbc7b27aSKiran Patil return -EINVAL; 7818fbc7b27aSKiran Patil 7819fbc7b27aSKiran Patil if (is_power_of_2(qcount)) { 7820fbc7b27aSKiran Patil if (non_power_of_2_qcount && 7821fbc7b27aSKiran Patil qcount > non_power_of_2_qcount) { 7822fbc7b27aSKiran Patil dev_err(dev, "qcount[%d] cannot be greater than non power of 2 qcount[%d]\n", 7823fbc7b27aSKiran Patil qcount, non_power_of_2_qcount); 7824fbc7b27aSKiran Patil return -EINVAL; 7825fbc7b27aSKiran Patil } 7826fbc7b27aSKiran Patil if (qcount > max_rss_q_cnt) 7827fbc7b27aSKiran Patil max_rss_q_cnt = qcount; 7828fbc7b27aSKiran Patil } else { 7829fbc7b27aSKiran Patil if (non_power_of_2_qcount && 7830fbc7b27aSKiran Patil qcount != non_power_of_2_qcount) { 7831fbc7b27aSKiran Patil dev_err(dev, "Only one non power of 2 qcount allowed[%d,%d]\n", 7832fbc7b27aSKiran Patil qcount, non_power_of_2_qcount); 7833fbc7b27aSKiran Patil return -EINVAL; 7834fbc7b27aSKiran Patil } 7835fbc7b27aSKiran Patil if (qcount < max_rss_q_cnt) { 7836fbc7b27aSKiran Patil dev_err(dev, "non power of 2 qcount[%d] cannot be less than other qcount[%d]\n", 7837fbc7b27aSKiran Patil qcount, max_rss_q_cnt); 7838fbc7b27aSKiran Patil return -EINVAL; 7839fbc7b27aSKiran Patil } 7840fbc7b27aSKiran Patil max_rss_q_cnt = qcount; 7841fbc7b27aSKiran Patil non_power_of_2_qcount = qcount; 7842fbc7b27aSKiran Patil } 7843fbc7b27aSKiran Patil 7844fbc7b27aSKiran Patil /* TC command takes input in K/N/Gbps or K/M/Gbit etc but 7845fbc7b27aSKiran Patil * converts the bandwidth rate limit into Bytes/s when 7846fbc7b27aSKiran Patil * passing it down to the driver. So convert input bandwidth 7847fbc7b27aSKiran Patil * from Bytes/s to Kbps 7848fbc7b27aSKiran Patil */ 7849fbc7b27aSKiran Patil max_rate = mqprio_qopt->max_rate[i]; 7850fbc7b27aSKiran Patil max_rate = div_u64(max_rate, ICE_BW_KBPS_DIVISOR); 7851fbc7b27aSKiran Patil sum_max_rate += max_rate; 7852fbc7b27aSKiran Patil 7853fbc7b27aSKiran Patil /* min_rate is minimum guaranteed rate and it can't be zero */ 7854fbc7b27aSKiran Patil min_rate = mqprio_qopt->min_rate[i]; 7855fbc7b27aSKiran Patil min_rate = div_u64(min_rate, ICE_BW_KBPS_DIVISOR); 7856fbc7b27aSKiran Patil sum_min_rate += min_rate; 7857fbc7b27aSKiran Patil 7858fbc7b27aSKiran Patil if (min_rate && min_rate < ICE_MIN_BW_LIMIT) { 7859fbc7b27aSKiran Patil dev_err(dev, "TC%d: min_rate(%llu Kbps) < %u Kbps\n", i, 7860fbc7b27aSKiran Patil min_rate, ICE_MIN_BW_LIMIT); 7861fbc7b27aSKiran Patil return -EINVAL; 7862fbc7b27aSKiran Patil } 7863fbc7b27aSKiran Patil 7864fbc7b27aSKiran Patil iter_div_u64_rem(min_rate, ICE_MIN_BW_LIMIT, &rem); 7865fbc7b27aSKiran Patil if (rem) { 7866fbc7b27aSKiran Patil dev_err(dev, "TC%d: Min Rate not multiple of %u Kbps", 7867fbc7b27aSKiran Patil i, ICE_MIN_BW_LIMIT); 7868fbc7b27aSKiran Patil return -EINVAL; 7869fbc7b27aSKiran Patil } 7870fbc7b27aSKiran Patil 7871fbc7b27aSKiran Patil iter_div_u64_rem(max_rate, ICE_MIN_BW_LIMIT, &rem); 7872fbc7b27aSKiran Patil if (rem) { 7873fbc7b27aSKiran Patil dev_err(dev, "TC%d: Max Rate not multiple of %u Kbps", 7874fbc7b27aSKiran Patil i, ICE_MIN_BW_LIMIT); 7875fbc7b27aSKiran Patil return -EINVAL; 7876fbc7b27aSKiran Patil } 7877fbc7b27aSKiran Patil 7878fbc7b27aSKiran Patil /* min_rate can't be more than max_rate, except when max_rate 7879fbc7b27aSKiran Patil * is zero (implies max_rate sought is max line rate). In such 7880fbc7b27aSKiran Patil * a case min_rate can be more than max. 7881fbc7b27aSKiran Patil */ 7882fbc7b27aSKiran Patil if (max_rate && min_rate > max_rate) { 7883fbc7b27aSKiran Patil dev_err(dev, "min_rate %llu Kbps can't be more than max_rate %llu Kbps\n", 7884fbc7b27aSKiran Patil min_rate, max_rate); 7885fbc7b27aSKiran Patil return -EINVAL; 7886fbc7b27aSKiran Patil } 7887fbc7b27aSKiran Patil 7888fbc7b27aSKiran Patil if (i >= mqprio_qopt->qopt.num_tc - 1) 7889fbc7b27aSKiran Patil break; 7890fbc7b27aSKiran Patil if (mqprio_qopt->qopt.offset[i + 1] != 7891fbc7b27aSKiran Patil (mqprio_qopt->qopt.offset[i] + qcount)) 7892fbc7b27aSKiran Patil return -EINVAL; 7893fbc7b27aSKiran Patil } 7894fbc7b27aSKiran Patil if (vsi->num_rxq < 7895fbc7b27aSKiran Patil (mqprio_qopt->qopt.offset[i] + mqprio_qopt->qopt.count[i])) 7896fbc7b27aSKiran Patil return -EINVAL; 7897fbc7b27aSKiran Patil if (vsi->num_txq < 7898fbc7b27aSKiran Patil (mqprio_qopt->qopt.offset[i] + mqprio_qopt->qopt.count[i])) 7899fbc7b27aSKiran Patil return -EINVAL; 7900fbc7b27aSKiran Patil 7901fbc7b27aSKiran Patil speed = ice_get_link_speed_kbps(vsi); 7902fbc7b27aSKiran Patil if (sum_max_rate && sum_max_rate > (u64)speed) { 7903fbc7b27aSKiran Patil dev_err(dev, "Invalid max Tx rate(%llu) Kbps > speed(%u) Kbps specified\n", 7904fbc7b27aSKiran Patil sum_max_rate, speed); 7905fbc7b27aSKiran Patil return -EINVAL; 7906fbc7b27aSKiran Patil } 7907fbc7b27aSKiran Patil if (sum_min_rate && sum_min_rate > (u64)speed) { 7908fbc7b27aSKiran Patil dev_err(dev, "Invalid min Tx rate(%llu) Kbps > speed (%u) Kbps specified\n", 7909fbc7b27aSKiran Patil sum_min_rate, speed); 7910fbc7b27aSKiran Patil return -EINVAL; 7911fbc7b27aSKiran Patil } 7912fbc7b27aSKiran Patil 7913fbc7b27aSKiran Patil /* make sure vsi->ch_rss_size is set correctly based on TC's qcount */ 7914fbc7b27aSKiran Patil vsi->ch_rss_size = max_rss_q_cnt; 7915fbc7b27aSKiran Patil 7916fbc7b27aSKiran Patil return 0; 7917fbc7b27aSKiran Patil } 7918fbc7b27aSKiran Patil 7919fbc7b27aSKiran Patil /** 792040319796SKiran Patil * ice_add_vsi_to_fdir - add a VSI to the flow director group for PF 792140319796SKiran Patil * @pf: ptr to PF device 792240319796SKiran Patil * @vsi: ptr to VSI 792340319796SKiran Patil */ 792440319796SKiran Patil static int ice_add_vsi_to_fdir(struct ice_pf *pf, struct ice_vsi *vsi) 792540319796SKiran Patil { 792640319796SKiran Patil struct device *dev = ice_pf_to_dev(pf); 792740319796SKiran Patil bool added = false; 792840319796SKiran Patil struct ice_hw *hw; 792940319796SKiran Patil int flow; 793040319796SKiran Patil 793140319796SKiran Patil if (!(vsi->num_gfltr || vsi->num_bfltr)) 793240319796SKiran Patil return -EINVAL; 793340319796SKiran Patil 793440319796SKiran Patil hw = &pf->hw; 793540319796SKiran Patil for (flow = 0; flow < ICE_FLTR_PTYPE_MAX; flow++) { 793640319796SKiran Patil struct ice_fd_hw_prof *prof; 793740319796SKiran Patil int tun, status; 793840319796SKiran Patil u64 entry_h; 793940319796SKiran Patil 794040319796SKiran Patil if (!(hw->fdir_prof && hw->fdir_prof[flow] && 794140319796SKiran Patil hw->fdir_prof[flow]->cnt)) 794240319796SKiran Patil continue; 794340319796SKiran Patil 794440319796SKiran Patil for (tun = 0; tun < ICE_FD_HW_SEG_MAX; tun++) { 794540319796SKiran Patil enum ice_flow_priority prio; 794640319796SKiran Patil u64 prof_id; 794740319796SKiran Patil 794840319796SKiran Patil /* add this VSI to FDir profile for this flow */ 794940319796SKiran Patil prio = ICE_FLOW_PRIO_NORMAL; 795040319796SKiran Patil prof = hw->fdir_prof[flow]; 795140319796SKiran Patil prof_id = flow + tun * ICE_FLTR_PTYPE_MAX; 795240319796SKiran Patil status = ice_flow_add_entry(hw, ICE_BLK_FD, prof_id, 795340319796SKiran Patil prof->vsi_h[0], vsi->idx, 795440319796SKiran Patil prio, prof->fdir_seg[tun], 795540319796SKiran Patil &entry_h); 795640319796SKiran Patil if (status) { 795740319796SKiran Patil dev_err(dev, "channel VSI idx %d, not able to add to group %d\n", 795840319796SKiran Patil vsi->idx, flow); 795940319796SKiran Patil continue; 796040319796SKiran Patil } 796140319796SKiran Patil 796240319796SKiran Patil prof->entry_h[prof->cnt][tun] = entry_h; 796340319796SKiran Patil } 796440319796SKiran Patil 796540319796SKiran Patil /* store VSI for filter replay and delete */ 796640319796SKiran Patil prof->vsi_h[prof->cnt] = vsi->idx; 796740319796SKiran Patil prof->cnt++; 796840319796SKiran Patil 796940319796SKiran Patil added = true; 797040319796SKiran Patil dev_dbg(dev, "VSI idx %d added to fdir group %d\n", vsi->idx, 797140319796SKiran Patil flow); 797240319796SKiran Patil } 797340319796SKiran Patil 797440319796SKiran Patil if (!added) 797540319796SKiran Patil dev_dbg(dev, "VSI idx %d not added to fdir groups\n", vsi->idx); 797640319796SKiran Patil 797740319796SKiran Patil return 0; 797840319796SKiran Patil } 797940319796SKiran Patil 798040319796SKiran Patil /** 7981fbc7b27aSKiran Patil * ice_add_channel - add a channel by adding VSI 7982fbc7b27aSKiran Patil * @pf: ptr to PF device 7983fbc7b27aSKiran Patil * @sw_id: underlying HW switching element ID 7984fbc7b27aSKiran Patil * @ch: ptr to channel structure 7985fbc7b27aSKiran Patil * 7986fbc7b27aSKiran Patil * Add a channel (VSI) using add_vsi and queue_map 7987fbc7b27aSKiran Patil */ 7988fbc7b27aSKiran Patil static int ice_add_channel(struct ice_pf *pf, u16 sw_id, struct ice_channel *ch) 7989fbc7b27aSKiran Patil { 7990fbc7b27aSKiran Patil struct device *dev = ice_pf_to_dev(pf); 7991fbc7b27aSKiran Patil struct ice_vsi *vsi; 7992fbc7b27aSKiran Patil 7993fbc7b27aSKiran Patil if (ch->type != ICE_VSI_CHNL) { 7994fbc7b27aSKiran Patil dev_err(dev, "add new VSI failed, ch->type %d\n", ch->type); 7995fbc7b27aSKiran Patil return -EINVAL; 7996fbc7b27aSKiran Patil } 7997fbc7b27aSKiran Patil 7998fbc7b27aSKiran Patil vsi = ice_chnl_vsi_setup(pf, pf->hw.port_info, ch); 7999fbc7b27aSKiran Patil if (!vsi || vsi->type != ICE_VSI_CHNL) { 8000fbc7b27aSKiran Patil dev_err(dev, "create chnl VSI failure\n"); 8001fbc7b27aSKiran Patil return -EINVAL; 8002fbc7b27aSKiran Patil } 8003fbc7b27aSKiran Patil 800440319796SKiran Patil ice_add_vsi_to_fdir(pf, vsi); 800540319796SKiran Patil 8006fbc7b27aSKiran Patil ch->sw_id = sw_id; 8007fbc7b27aSKiran Patil ch->vsi_num = vsi->vsi_num; 8008fbc7b27aSKiran Patil ch->info.mapping_flags = vsi->info.mapping_flags; 8009fbc7b27aSKiran Patil ch->ch_vsi = vsi; 8010fbc7b27aSKiran Patil /* set the back pointer of channel for newly created VSI */ 8011fbc7b27aSKiran Patil vsi->ch = ch; 8012fbc7b27aSKiran Patil 8013fbc7b27aSKiran Patil memcpy(&ch->info.q_mapping, &vsi->info.q_mapping, 8014fbc7b27aSKiran Patil sizeof(vsi->info.q_mapping)); 8015fbc7b27aSKiran Patil memcpy(&ch->info.tc_mapping, vsi->info.tc_mapping, 8016fbc7b27aSKiran Patil sizeof(vsi->info.tc_mapping)); 8017fbc7b27aSKiran Patil 8018fbc7b27aSKiran Patil return 0; 8019fbc7b27aSKiran Patil } 8020fbc7b27aSKiran Patil 8021fbc7b27aSKiran Patil /** 8022fbc7b27aSKiran Patil * ice_chnl_cfg_res 8023fbc7b27aSKiran Patil * @vsi: the VSI being setup 8024fbc7b27aSKiran Patil * @ch: ptr to channel structure 8025fbc7b27aSKiran Patil * 8026fbc7b27aSKiran Patil * Configure channel specific resources such as rings, vector. 8027fbc7b27aSKiran Patil */ 8028fbc7b27aSKiran Patil static void ice_chnl_cfg_res(struct ice_vsi *vsi, struct ice_channel *ch) 8029fbc7b27aSKiran Patil { 8030fbc7b27aSKiran Patil int i; 8031fbc7b27aSKiran Patil 8032fbc7b27aSKiran Patil for (i = 0; i < ch->num_txq; i++) { 8033fbc7b27aSKiran Patil struct ice_q_vector *tx_q_vector, *rx_q_vector; 8034fbc7b27aSKiran Patil struct ice_ring_container *rc; 8035fbc7b27aSKiran Patil struct ice_tx_ring *tx_ring; 8036fbc7b27aSKiran Patil struct ice_rx_ring *rx_ring; 8037fbc7b27aSKiran Patil 8038fbc7b27aSKiran Patil tx_ring = vsi->tx_rings[ch->base_q + i]; 8039fbc7b27aSKiran Patil rx_ring = vsi->rx_rings[ch->base_q + i]; 8040fbc7b27aSKiran Patil if (!tx_ring || !rx_ring) 8041fbc7b27aSKiran Patil continue; 8042fbc7b27aSKiran Patil 8043fbc7b27aSKiran Patil /* setup ring being channel enabled */ 8044fbc7b27aSKiran Patil tx_ring->ch = ch; 8045fbc7b27aSKiran Patil rx_ring->ch = ch; 8046fbc7b27aSKiran Patil 8047fbc7b27aSKiran Patil /* following code block sets up vector specific attributes */ 8048fbc7b27aSKiran Patil tx_q_vector = tx_ring->q_vector; 8049fbc7b27aSKiran Patil rx_q_vector = rx_ring->q_vector; 8050fbc7b27aSKiran Patil if (!tx_q_vector && !rx_q_vector) 8051fbc7b27aSKiran Patil continue; 8052fbc7b27aSKiran Patil 8053fbc7b27aSKiran Patil if (tx_q_vector) { 8054fbc7b27aSKiran Patil tx_q_vector->ch = ch; 8055fbc7b27aSKiran Patil /* setup Tx and Rx ITR setting if DIM is off */ 8056fbc7b27aSKiran Patil rc = &tx_q_vector->tx; 8057fbc7b27aSKiran Patil if (!ITR_IS_DYNAMIC(rc)) 8058fbc7b27aSKiran Patil ice_write_itr(rc, rc->itr_setting); 8059fbc7b27aSKiran Patil } 8060fbc7b27aSKiran Patil if (rx_q_vector) { 8061fbc7b27aSKiran Patil rx_q_vector->ch = ch; 8062fbc7b27aSKiran Patil /* setup Tx and Rx ITR setting if DIM is off */ 8063fbc7b27aSKiran Patil rc = &rx_q_vector->rx; 8064fbc7b27aSKiran Patil if (!ITR_IS_DYNAMIC(rc)) 8065fbc7b27aSKiran Patil ice_write_itr(rc, rc->itr_setting); 8066fbc7b27aSKiran Patil } 8067fbc7b27aSKiran Patil } 8068fbc7b27aSKiran Patil 8069fbc7b27aSKiran Patil /* it is safe to assume that, if channel has non-zero num_t[r]xq, then 8070fbc7b27aSKiran Patil * GLINT_ITR register would have written to perform in-context 8071fbc7b27aSKiran Patil * update, hence perform flush 8072fbc7b27aSKiran Patil */ 8073fbc7b27aSKiran Patil if (ch->num_txq || ch->num_rxq) 8074fbc7b27aSKiran Patil ice_flush(&vsi->back->hw); 8075fbc7b27aSKiran Patil } 8076fbc7b27aSKiran Patil 8077fbc7b27aSKiran Patil /** 8078fbc7b27aSKiran Patil * ice_cfg_chnl_all_res - configure channel resources 8079fbc7b27aSKiran Patil * @vsi: pte to main_vsi 8080fbc7b27aSKiran Patil * @ch: ptr to channel structure 8081fbc7b27aSKiran Patil * 8082fbc7b27aSKiran Patil * This function configures channel specific resources such as flow-director 8083fbc7b27aSKiran Patil * counter index, and other resources such as queues, vectors, ITR settings 8084fbc7b27aSKiran Patil */ 8085fbc7b27aSKiran Patil static void 8086fbc7b27aSKiran Patil ice_cfg_chnl_all_res(struct ice_vsi *vsi, struct ice_channel *ch) 8087fbc7b27aSKiran Patil { 8088fbc7b27aSKiran Patil /* configure channel (aka ADQ) resources such as queues, vectors, 8089fbc7b27aSKiran Patil * ITR settings for channel specific vectors and anything else 8090fbc7b27aSKiran Patil */ 8091fbc7b27aSKiran Patil ice_chnl_cfg_res(vsi, ch); 8092fbc7b27aSKiran Patil } 8093fbc7b27aSKiran Patil 8094fbc7b27aSKiran Patil /** 8095fbc7b27aSKiran Patil * ice_setup_hw_channel - setup new channel 8096fbc7b27aSKiran Patil * @pf: ptr to PF device 8097fbc7b27aSKiran Patil * @vsi: the VSI being setup 8098fbc7b27aSKiran Patil * @ch: ptr to channel structure 8099fbc7b27aSKiran Patil * @sw_id: underlying HW switching element ID 8100fbc7b27aSKiran Patil * @type: type of channel to be created (VMDq2/VF) 8101fbc7b27aSKiran Patil * 8102fbc7b27aSKiran Patil * Setup new channel (VSI) based on specified type (VMDq2/VF) 8103fbc7b27aSKiran Patil * and configures Tx rings accordingly 8104fbc7b27aSKiran Patil */ 8105fbc7b27aSKiran Patil static int 8106fbc7b27aSKiran Patil ice_setup_hw_channel(struct ice_pf *pf, struct ice_vsi *vsi, 8107fbc7b27aSKiran Patil struct ice_channel *ch, u16 sw_id, u8 type) 8108fbc7b27aSKiran Patil { 8109fbc7b27aSKiran Patil struct device *dev = ice_pf_to_dev(pf); 8110fbc7b27aSKiran Patil int ret; 8111fbc7b27aSKiran Patil 8112fbc7b27aSKiran Patil ch->base_q = vsi->next_base_q; 8113fbc7b27aSKiran Patil ch->type = type; 8114fbc7b27aSKiran Patil 8115fbc7b27aSKiran Patil ret = ice_add_channel(pf, sw_id, ch); 8116fbc7b27aSKiran Patil if (ret) { 8117fbc7b27aSKiran Patil dev_err(dev, "failed to add_channel using sw_id %u\n", sw_id); 8118fbc7b27aSKiran Patil return ret; 8119fbc7b27aSKiran Patil } 8120fbc7b27aSKiran Patil 8121fbc7b27aSKiran Patil /* configure/setup ADQ specific resources */ 8122fbc7b27aSKiran Patil ice_cfg_chnl_all_res(vsi, ch); 8123fbc7b27aSKiran Patil 8124fbc7b27aSKiran Patil /* make sure to update the next_base_q so that subsequent channel's 8125fbc7b27aSKiran Patil * (aka ADQ) VSI queue map is correct 8126fbc7b27aSKiran Patil */ 8127fbc7b27aSKiran Patil vsi->next_base_q = vsi->next_base_q + ch->num_rxq; 8128fbc7b27aSKiran Patil dev_dbg(dev, "added channel: vsi_num %u, num_rxq %u\n", ch->vsi_num, 8129fbc7b27aSKiran Patil ch->num_rxq); 8130fbc7b27aSKiran Patil 8131fbc7b27aSKiran Patil return 0; 8132fbc7b27aSKiran Patil } 8133fbc7b27aSKiran Patil 8134fbc7b27aSKiran Patil /** 8135fbc7b27aSKiran Patil * ice_setup_channel - setup new channel using uplink element 8136fbc7b27aSKiran Patil * @pf: ptr to PF device 8137fbc7b27aSKiran Patil * @vsi: the VSI being setup 8138fbc7b27aSKiran Patil * @ch: ptr to channel structure 8139fbc7b27aSKiran Patil * 8140fbc7b27aSKiran Patil * Setup new channel (VSI) based on specified type (VMDq2/VF) 8141fbc7b27aSKiran Patil * and uplink switching element 8142fbc7b27aSKiran Patil */ 8143fbc7b27aSKiran Patil static bool 8144fbc7b27aSKiran Patil ice_setup_channel(struct ice_pf *pf, struct ice_vsi *vsi, 8145fbc7b27aSKiran Patil struct ice_channel *ch) 8146fbc7b27aSKiran Patil { 8147fbc7b27aSKiran Patil struct device *dev = ice_pf_to_dev(pf); 8148fbc7b27aSKiran Patil u16 sw_id; 8149fbc7b27aSKiran Patil int ret; 8150fbc7b27aSKiran Patil 8151fbc7b27aSKiran Patil if (vsi->type != ICE_VSI_PF) { 8152fbc7b27aSKiran Patil dev_err(dev, "unsupported parent VSI type(%d)\n", vsi->type); 8153fbc7b27aSKiran Patil return false; 8154fbc7b27aSKiran Patil } 8155fbc7b27aSKiran Patil 8156fbc7b27aSKiran Patil sw_id = pf->first_sw->sw_id; 8157fbc7b27aSKiran Patil 8158fbc7b27aSKiran Patil /* create channel (VSI) */ 8159fbc7b27aSKiran Patil ret = ice_setup_hw_channel(pf, vsi, ch, sw_id, ICE_VSI_CHNL); 8160fbc7b27aSKiran Patil if (ret) { 8161fbc7b27aSKiran Patil dev_err(dev, "failed to setup hw_channel\n"); 8162fbc7b27aSKiran Patil return false; 8163fbc7b27aSKiran Patil } 8164fbc7b27aSKiran Patil dev_dbg(dev, "successfully created channel()\n"); 8165fbc7b27aSKiran Patil 8166fbc7b27aSKiran Patil return ch->ch_vsi ? true : false; 8167fbc7b27aSKiran Patil } 8168fbc7b27aSKiran Patil 8169fbc7b27aSKiran Patil /** 8170fbc7b27aSKiran Patil * ice_set_bw_limit - setup BW limit for Tx traffic based on max_tx_rate 8171fbc7b27aSKiran Patil * @vsi: VSI to be configured 8172fbc7b27aSKiran Patil * @max_tx_rate: max Tx rate in Kbps to be configured as maximum BW limit 8173fbc7b27aSKiran Patil * @min_tx_rate: min Tx rate in Kbps to be configured as minimum BW limit 8174fbc7b27aSKiran Patil */ 8175fbc7b27aSKiran Patil static int 8176fbc7b27aSKiran Patil ice_set_bw_limit(struct ice_vsi *vsi, u64 max_tx_rate, u64 min_tx_rate) 8177fbc7b27aSKiran Patil { 8178fbc7b27aSKiran Patil int err; 8179fbc7b27aSKiran Patil 8180fbc7b27aSKiran Patil err = ice_set_min_bw_limit(vsi, min_tx_rate); 8181fbc7b27aSKiran Patil if (err) 8182fbc7b27aSKiran Patil return err; 8183fbc7b27aSKiran Patil 8184fbc7b27aSKiran Patil return ice_set_max_bw_limit(vsi, max_tx_rate); 8185fbc7b27aSKiran Patil } 8186fbc7b27aSKiran Patil 8187fbc7b27aSKiran Patil /** 8188fbc7b27aSKiran Patil * ice_create_q_channel - function to create channel 8189fbc7b27aSKiran Patil * @vsi: VSI to be configured 8190fbc7b27aSKiran Patil * @ch: ptr to channel (it contains channel specific params) 8191fbc7b27aSKiran Patil * 8192fbc7b27aSKiran Patil * This function creates channel (VSI) using num_queues specified by user, 8193fbc7b27aSKiran Patil * reconfigs RSS if needed. 8194fbc7b27aSKiran Patil */ 8195fbc7b27aSKiran Patil static int ice_create_q_channel(struct ice_vsi *vsi, struct ice_channel *ch) 8196fbc7b27aSKiran Patil { 8197fbc7b27aSKiran Patil struct ice_pf *pf = vsi->back; 8198fbc7b27aSKiran Patil struct device *dev; 8199fbc7b27aSKiran Patil 8200fbc7b27aSKiran Patil if (!ch) 8201fbc7b27aSKiran Patil return -EINVAL; 8202fbc7b27aSKiran Patil 8203fbc7b27aSKiran Patil dev = ice_pf_to_dev(pf); 8204fbc7b27aSKiran Patil if (!ch->num_txq || !ch->num_rxq) { 8205fbc7b27aSKiran Patil dev_err(dev, "Invalid num_queues requested: %d\n", ch->num_rxq); 8206fbc7b27aSKiran Patil return -EINVAL; 8207fbc7b27aSKiran Patil } 8208fbc7b27aSKiran Patil 8209fbc7b27aSKiran Patil if (!vsi->cnt_q_avail || vsi->cnt_q_avail < ch->num_txq) { 8210fbc7b27aSKiran Patil dev_err(dev, "cnt_q_avail (%u) less than num_queues %d\n", 8211fbc7b27aSKiran Patil vsi->cnt_q_avail, ch->num_txq); 8212fbc7b27aSKiran Patil return -EINVAL; 8213fbc7b27aSKiran Patil } 8214fbc7b27aSKiran Patil 8215fbc7b27aSKiran Patil if (!ice_setup_channel(pf, vsi, ch)) { 8216fbc7b27aSKiran Patil dev_info(dev, "Failed to setup channel\n"); 8217fbc7b27aSKiran Patil return -EINVAL; 8218fbc7b27aSKiran Patil } 8219fbc7b27aSKiran Patil /* configure BW rate limit */ 8220fbc7b27aSKiran Patil if (ch->ch_vsi && (ch->max_tx_rate || ch->min_tx_rate)) { 8221fbc7b27aSKiran Patil int ret; 8222fbc7b27aSKiran Patil 8223fbc7b27aSKiran Patil ret = ice_set_bw_limit(ch->ch_vsi, ch->max_tx_rate, 8224fbc7b27aSKiran Patil ch->min_tx_rate); 8225fbc7b27aSKiran Patil if (ret) 8226fbc7b27aSKiran Patil dev_err(dev, "failed to set Tx rate of %llu Kbps for VSI(%u)\n", 8227fbc7b27aSKiran Patil ch->max_tx_rate, ch->ch_vsi->vsi_num); 8228fbc7b27aSKiran Patil else 8229fbc7b27aSKiran Patil dev_dbg(dev, "set Tx rate of %llu Kbps for VSI(%u)\n", 8230fbc7b27aSKiran Patil ch->max_tx_rate, ch->ch_vsi->vsi_num); 8231fbc7b27aSKiran Patil } 8232fbc7b27aSKiran Patil 8233fbc7b27aSKiran Patil vsi->cnt_q_avail -= ch->num_txq; 8234fbc7b27aSKiran Patil 8235fbc7b27aSKiran Patil return 0; 8236fbc7b27aSKiran Patil } 8237fbc7b27aSKiran Patil 8238fbc7b27aSKiran Patil /** 82399fea7498SKiran Patil * ice_rem_all_chnl_fltrs - removes all channel filters 82409fea7498SKiran Patil * @pf: ptr to PF, TC-flower based filter are tracked at PF level 82419fea7498SKiran Patil * 82429fea7498SKiran Patil * Remove all advanced switch filters only if they are channel specific 82439fea7498SKiran Patil * tc-flower based filter 82449fea7498SKiran Patil */ 82459fea7498SKiran Patil static void ice_rem_all_chnl_fltrs(struct ice_pf *pf) 82469fea7498SKiran Patil { 82479fea7498SKiran Patil struct ice_tc_flower_fltr *fltr; 82489fea7498SKiran Patil struct hlist_node *node; 82499fea7498SKiran Patil 82509fea7498SKiran Patil /* to remove all channel filters, iterate an ordered list of filters */ 82519fea7498SKiran Patil hlist_for_each_entry_safe(fltr, node, 82529fea7498SKiran Patil &pf->tc_flower_fltr_list, 82539fea7498SKiran Patil tc_flower_node) { 82549fea7498SKiran Patil struct ice_rule_query_data rule; 82559fea7498SKiran Patil int status; 82569fea7498SKiran Patil 82579fea7498SKiran Patil /* for now process only channel specific filters */ 82589fea7498SKiran Patil if (!ice_is_chnl_fltr(fltr)) 82599fea7498SKiran Patil continue; 82609fea7498SKiran Patil 82619fea7498SKiran Patil rule.rid = fltr->rid; 82629fea7498SKiran Patil rule.rule_id = fltr->rule_id; 82639fea7498SKiran Patil rule.vsi_handle = fltr->dest_id; 82649fea7498SKiran Patil status = ice_rem_adv_rule_by_id(&pf->hw, &rule); 82659fea7498SKiran Patil if (status) { 82669fea7498SKiran Patil if (status == -ENOENT) 82679fea7498SKiran Patil dev_dbg(ice_pf_to_dev(pf), "TC flower filter (rule_id %u) does not exist\n", 82689fea7498SKiran Patil rule.rule_id); 82699fea7498SKiran Patil else 82709fea7498SKiran Patil dev_err(ice_pf_to_dev(pf), "failed to delete TC flower filter, status %d\n", 82719fea7498SKiran Patil status); 82729fea7498SKiran Patil } else if (fltr->dest_vsi) { 82739fea7498SKiran Patil /* update advanced switch filter count */ 82749fea7498SKiran Patil if (fltr->dest_vsi->type == ICE_VSI_CHNL) { 82759fea7498SKiran Patil u32 flags = fltr->flags; 82769fea7498SKiran Patil 82779fea7498SKiran Patil fltr->dest_vsi->num_chnl_fltr--; 82789fea7498SKiran Patil if (flags & (ICE_TC_FLWR_FIELD_DST_MAC | 82799fea7498SKiran Patil ICE_TC_FLWR_FIELD_ENC_DST_MAC)) 82809fea7498SKiran Patil pf->num_dmac_chnl_fltrs--; 82819fea7498SKiran Patil } 82829fea7498SKiran Patil } 82839fea7498SKiran Patil 82849fea7498SKiran Patil hlist_del(&fltr->tc_flower_node); 82859fea7498SKiran Patil kfree(fltr); 82869fea7498SKiran Patil } 82879fea7498SKiran Patil } 82889fea7498SKiran Patil 82899fea7498SKiran Patil /** 8290fbc7b27aSKiran Patil * ice_remove_q_channels - Remove queue channels for the TCs 8291fbc7b27aSKiran Patil * @vsi: VSI to be configured 8292fbc7b27aSKiran Patil * @rem_fltr: delete advanced switch filter or not 8293fbc7b27aSKiran Patil * 8294fbc7b27aSKiran Patil * Remove queue channels for the TCs 8295fbc7b27aSKiran Patil */ 82969fea7498SKiran Patil static void ice_remove_q_channels(struct ice_vsi *vsi, bool rem_fltr) 8297fbc7b27aSKiran Patil { 8298fbc7b27aSKiran Patil struct ice_channel *ch, *ch_tmp; 82999fea7498SKiran Patil struct ice_pf *pf = vsi->back; 8300fbc7b27aSKiran Patil int i; 8301fbc7b27aSKiran Patil 83029fea7498SKiran Patil /* remove all tc-flower based filter if they are channel filters only */ 83039fea7498SKiran Patil if (rem_fltr) 83049fea7498SKiran Patil ice_rem_all_chnl_fltrs(pf); 83059fea7498SKiran Patil 830640319796SKiran Patil /* remove ntuple filters since queue configuration is being changed */ 830740319796SKiran Patil if (vsi->netdev->features & NETIF_F_NTUPLE) { 830840319796SKiran Patil struct ice_hw *hw = &pf->hw; 830940319796SKiran Patil 831040319796SKiran Patil mutex_lock(&hw->fdir_fltr_lock); 831140319796SKiran Patil ice_fdir_del_all_fltrs(vsi); 831240319796SKiran Patil mutex_unlock(&hw->fdir_fltr_lock); 831340319796SKiran Patil } 831440319796SKiran Patil 8315fbc7b27aSKiran Patil /* perform cleanup for channels if they exist */ 8316fbc7b27aSKiran Patil list_for_each_entry_safe(ch, ch_tmp, &vsi->ch_list, list) { 8317fbc7b27aSKiran Patil struct ice_vsi *ch_vsi; 8318fbc7b27aSKiran Patil 8319fbc7b27aSKiran Patil list_del(&ch->list); 8320fbc7b27aSKiran Patil ch_vsi = ch->ch_vsi; 8321fbc7b27aSKiran Patil if (!ch_vsi) { 8322fbc7b27aSKiran Patil kfree(ch); 8323fbc7b27aSKiran Patil continue; 8324fbc7b27aSKiran Patil } 8325fbc7b27aSKiran Patil 8326fbc7b27aSKiran Patil /* Reset queue contexts */ 8327fbc7b27aSKiran Patil for (i = 0; i < ch->num_rxq; i++) { 8328fbc7b27aSKiran Patil struct ice_tx_ring *tx_ring; 8329fbc7b27aSKiran Patil struct ice_rx_ring *rx_ring; 8330fbc7b27aSKiran Patil 8331fbc7b27aSKiran Patil tx_ring = vsi->tx_rings[ch->base_q + i]; 8332fbc7b27aSKiran Patil rx_ring = vsi->rx_rings[ch->base_q + i]; 8333fbc7b27aSKiran Patil if (tx_ring) { 8334fbc7b27aSKiran Patil tx_ring->ch = NULL; 8335fbc7b27aSKiran Patil if (tx_ring->q_vector) 8336fbc7b27aSKiran Patil tx_ring->q_vector->ch = NULL; 8337fbc7b27aSKiran Patil } 8338fbc7b27aSKiran Patil if (rx_ring) { 8339fbc7b27aSKiran Patil rx_ring->ch = NULL; 8340fbc7b27aSKiran Patil if (rx_ring->q_vector) 8341fbc7b27aSKiran Patil rx_ring->q_vector->ch = NULL; 8342fbc7b27aSKiran Patil } 8343fbc7b27aSKiran Patil } 8344fbc7b27aSKiran Patil 834540319796SKiran Patil /* Release FD resources for the channel VSI */ 834640319796SKiran Patil ice_fdir_rem_adq_chnl(&pf->hw, ch->ch_vsi->idx); 834740319796SKiran Patil 8348fbc7b27aSKiran Patil /* clear the VSI from scheduler tree */ 8349fbc7b27aSKiran Patil ice_rm_vsi_lan_cfg(ch->ch_vsi->port_info, ch->ch_vsi->idx); 8350fbc7b27aSKiran Patil 8351fbc7b27aSKiran Patil /* Delete VSI from FW */ 8352fbc7b27aSKiran Patil ice_vsi_delete(ch->ch_vsi); 8353fbc7b27aSKiran Patil 8354fbc7b27aSKiran Patil /* Delete VSI from PF and HW VSI arrays */ 8355fbc7b27aSKiran Patil ice_vsi_clear(ch->ch_vsi); 8356fbc7b27aSKiran Patil 8357fbc7b27aSKiran Patil /* free the channel */ 8358fbc7b27aSKiran Patil kfree(ch); 8359fbc7b27aSKiran Patil } 8360fbc7b27aSKiran Patil 8361fbc7b27aSKiran Patil /* clear the channel VSI map which is stored in main VSI */ 8362fbc7b27aSKiran Patil ice_for_each_chnl_tc(i) 8363fbc7b27aSKiran Patil vsi->tc_map_vsi[i] = NULL; 8364fbc7b27aSKiran Patil 8365fbc7b27aSKiran Patil /* reset main VSI's all TC information */ 8366fbc7b27aSKiran Patil vsi->all_enatc = 0; 8367fbc7b27aSKiran Patil vsi->all_numtc = 0; 8368fbc7b27aSKiran Patil } 8369fbc7b27aSKiran Patil 8370fbc7b27aSKiran Patil /** 8371fbc7b27aSKiran Patil * ice_rebuild_channels - rebuild channel 8372fbc7b27aSKiran Patil * @pf: ptr to PF 8373fbc7b27aSKiran Patil * 8374fbc7b27aSKiran Patil * Recreate channel VSIs and replay filters 8375fbc7b27aSKiran Patil */ 8376fbc7b27aSKiran Patil static int ice_rebuild_channels(struct ice_pf *pf) 8377fbc7b27aSKiran Patil { 8378fbc7b27aSKiran Patil struct device *dev = ice_pf_to_dev(pf); 8379fbc7b27aSKiran Patil struct ice_vsi *main_vsi; 8380fbc7b27aSKiran Patil bool rem_adv_fltr = true; 8381fbc7b27aSKiran Patil struct ice_channel *ch; 8382fbc7b27aSKiran Patil struct ice_vsi *vsi; 8383fbc7b27aSKiran Patil int tc_idx = 1; 8384fbc7b27aSKiran Patil int i, err; 8385fbc7b27aSKiran Patil 8386fbc7b27aSKiran Patil main_vsi = ice_get_main_vsi(pf); 8387fbc7b27aSKiran Patil if (!main_vsi) 8388fbc7b27aSKiran Patil return 0; 8389fbc7b27aSKiran Patil 8390fbc7b27aSKiran Patil if (!test_bit(ICE_FLAG_TC_MQPRIO, pf->flags) || 8391fbc7b27aSKiran Patil main_vsi->old_numtc == 1) 8392fbc7b27aSKiran Patil return 0; /* nothing to be done */ 8393fbc7b27aSKiran Patil 8394fbc7b27aSKiran Patil /* reconfigure main VSI based on old value of TC and cached values 8395fbc7b27aSKiran Patil * for MQPRIO opts 8396fbc7b27aSKiran Patil */ 8397fbc7b27aSKiran Patil err = ice_vsi_cfg_tc(main_vsi, main_vsi->old_ena_tc); 8398fbc7b27aSKiran Patil if (err) { 8399fbc7b27aSKiran Patil dev_err(dev, "failed configuring TC(ena_tc:0x%02x) for HW VSI=%u\n", 8400fbc7b27aSKiran Patil main_vsi->old_ena_tc, main_vsi->vsi_num); 8401fbc7b27aSKiran Patil return err; 8402fbc7b27aSKiran Patil } 8403fbc7b27aSKiran Patil 8404fbc7b27aSKiran Patil /* rebuild ADQ VSIs */ 8405fbc7b27aSKiran Patil ice_for_each_vsi(pf, i) { 8406fbc7b27aSKiran Patil enum ice_vsi_type type; 8407fbc7b27aSKiran Patil 8408fbc7b27aSKiran Patil vsi = pf->vsi[i]; 8409fbc7b27aSKiran Patil if (!vsi || vsi->type != ICE_VSI_CHNL) 8410fbc7b27aSKiran Patil continue; 8411fbc7b27aSKiran Patil 8412fbc7b27aSKiran Patil type = vsi->type; 8413fbc7b27aSKiran Patil 8414fbc7b27aSKiran Patil /* rebuild ADQ VSI */ 8415fbc7b27aSKiran Patil err = ice_vsi_rebuild(vsi, true); 8416fbc7b27aSKiran Patil if (err) { 8417fbc7b27aSKiran Patil dev_err(dev, "VSI (type:%s) at index %d rebuild failed, err %d\n", 8418fbc7b27aSKiran Patil ice_vsi_type_str(type), vsi->idx, err); 8419fbc7b27aSKiran Patil goto cleanup; 8420fbc7b27aSKiran Patil } 8421fbc7b27aSKiran Patil 8422fbc7b27aSKiran Patil /* Re-map HW VSI number, using VSI handle that has been 8423fbc7b27aSKiran Patil * previously validated in ice_replay_vsi() call above 8424fbc7b27aSKiran Patil */ 8425fbc7b27aSKiran Patil vsi->vsi_num = ice_get_hw_vsi_num(&pf->hw, vsi->idx); 8426fbc7b27aSKiran Patil 8427fbc7b27aSKiran Patil /* replay filters for the VSI */ 8428fbc7b27aSKiran Patil err = ice_replay_vsi(&pf->hw, vsi->idx); 8429fbc7b27aSKiran Patil if (err) { 8430fbc7b27aSKiran Patil dev_err(dev, "VSI (type:%s) replay failed, err %d, VSI index %d\n", 8431fbc7b27aSKiran Patil ice_vsi_type_str(type), err, vsi->idx); 8432fbc7b27aSKiran Patil rem_adv_fltr = false; 8433fbc7b27aSKiran Patil goto cleanup; 8434fbc7b27aSKiran Patil } 8435fbc7b27aSKiran Patil dev_info(dev, "VSI (type:%s) at index %d rebuilt successfully\n", 8436fbc7b27aSKiran Patil ice_vsi_type_str(type), vsi->idx); 8437fbc7b27aSKiran Patil 8438fbc7b27aSKiran Patil /* store ADQ VSI at correct TC index in main VSI's 8439fbc7b27aSKiran Patil * map of TC to VSI 8440fbc7b27aSKiran Patil */ 8441fbc7b27aSKiran Patil main_vsi->tc_map_vsi[tc_idx++] = vsi; 8442fbc7b27aSKiran Patil } 8443fbc7b27aSKiran Patil 8444fbc7b27aSKiran Patil /* ADQ VSI(s) has been rebuilt successfully, so setup 8445fbc7b27aSKiran Patil * channel for main VSI's Tx and Rx rings 8446fbc7b27aSKiran Patil */ 8447fbc7b27aSKiran Patil list_for_each_entry(ch, &main_vsi->ch_list, list) { 8448fbc7b27aSKiran Patil struct ice_vsi *ch_vsi; 8449fbc7b27aSKiran Patil 8450fbc7b27aSKiran Patil ch_vsi = ch->ch_vsi; 8451fbc7b27aSKiran Patil if (!ch_vsi) 8452fbc7b27aSKiran Patil continue; 8453fbc7b27aSKiran Patil 8454fbc7b27aSKiran Patil /* reconfig channel resources */ 8455fbc7b27aSKiran Patil ice_cfg_chnl_all_res(main_vsi, ch); 8456fbc7b27aSKiran Patil 8457fbc7b27aSKiran Patil /* replay BW rate limit if it is non-zero */ 8458fbc7b27aSKiran Patil if (!ch->max_tx_rate && !ch->min_tx_rate) 8459fbc7b27aSKiran Patil continue; 8460fbc7b27aSKiran Patil 8461fbc7b27aSKiran Patil err = ice_set_bw_limit(ch_vsi, ch->max_tx_rate, 8462fbc7b27aSKiran Patil ch->min_tx_rate); 8463fbc7b27aSKiran Patil if (err) 8464fbc7b27aSKiran Patil dev_err(dev, "failed (err:%d) to rebuild BW rate limit, max_tx_rate: %llu Kbps, min_tx_rate: %llu Kbps for VSI(%u)\n", 8465fbc7b27aSKiran Patil err, ch->max_tx_rate, ch->min_tx_rate, 8466fbc7b27aSKiran Patil ch_vsi->vsi_num); 8467fbc7b27aSKiran Patil else 8468fbc7b27aSKiran Patil dev_dbg(dev, "successfully rebuild BW rate limit, max_tx_rate: %llu Kbps, min_tx_rate: %llu Kbps for VSI(%u)\n", 8469fbc7b27aSKiran Patil ch->max_tx_rate, ch->min_tx_rate, 8470fbc7b27aSKiran Patil ch_vsi->vsi_num); 8471fbc7b27aSKiran Patil } 8472fbc7b27aSKiran Patil 8473fbc7b27aSKiran Patil /* reconfig RSS for main VSI */ 8474fbc7b27aSKiran Patil if (main_vsi->ch_rss_size) 8475fbc7b27aSKiran Patil ice_vsi_cfg_rss_lut_key(main_vsi); 8476fbc7b27aSKiran Patil 8477fbc7b27aSKiran Patil return 0; 8478fbc7b27aSKiran Patil 8479fbc7b27aSKiran Patil cleanup: 8480fbc7b27aSKiran Patil ice_remove_q_channels(main_vsi, rem_adv_fltr); 8481fbc7b27aSKiran Patil return err; 8482fbc7b27aSKiran Patil } 8483fbc7b27aSKiran Patil 8484fbc7b27aSKiran Patil /** 8485fbc7b27aSKiran Patil * ice_create_q_channels - Add queue channel for the given TCs 8486fbc7b27aSKiran Patil * @vsi: VSI to be configured 8487fbc7b27aSKiran Patil * 8488fbc7b27aSKiran Patil * Configures queue channel mapping to the given TCs 8489fbc7b27aSKiran Patil */ 8490fbc7b27aSKiran Patil static int ice_create_q_channels(struct ice_vsi *vsi) 8491fbc7b27aSKiran Patil { 8492fbc7b27aSKiran Patil struct ice_pf *pf = vsi->back; 8493fbc7b27aSKiran Patil struct ice_channel *ch; 8494fbc7b27aSKiran Patil int ret = 0, i; 8495fbc7b27aSKiran Patil 8496fbc7b27aSKiran Patil ice_for_each_chnl_tc(i) { 8497fbc7b27aSKiran Patil if (!(vsi->all_enatc & BIT(i))) 8498fbc7b27aSKiran Patil continue; 8499fbc7b27aSKiran Patil 8500fbc7b27aSKiran Patil ch = kzalloc(sizeof(*ch), GFP_KERNEL); 8501fbc7b27aSKiran Patil if (!ch) { 8502fbc7b27aSKiran Patil ret = -ENOMEM; 8503fbc7b27aSKiran Patil goto err_free; 8504fbc7b27aSKiran Patil } 8505fbc7b27aSKiran Patil INIT_LIST_HEAD(&ch->list); 8506fbc7b27aSKiran Patil ch->num_rxq = vsi->mqprio_qopt.qopt.count[i]; 8507fbc7b27aSKiran Patil ch->num_txq = vsi->mqprio_qopt.qopt.count[i]; 8508fbc7b27aSKiran Patil ch->base_q = vsi->mqprio_qopt.qopt.offset[i]; 8509fbc7b27aSKiran Patil ch->max_tx_rate = vsi->mqprio_qopt.max_rate[i]; 8510fbc7b27aSKiran Patil ch->min_tx_rate = vsi->mqprio_qopt.min_rate[i]; 8511fbc7b27aSKiran Patil 8512fbc7b27aSKiran Patil /* convert to Kbits/s */ 8513fbc7b27aSKiran Patil if (ch->max_tx_rate) 8514fbc7b27aSKiran Patil ch->max_tx_rate = div_u64(ch->max_tx_rate, 8515fbc7b27aSKiran Patil ICE_BW_KBPS_DIVISOR); 8516fbc7b27aSKiran Patil if (ch->min_tx_rate) 8517fbc7b27aSKiran Patil ch->min_tx_rate = div_u64(ch->min_tx_rate, 8518fbc7b27aSKiran Patil ICE_BW_KBPS_DIVISOR); 8519fbc7b27aSKiran Patil 8520fbc7b27aSKiran Patil ret = ice_create_q_channel(vsi, ch); 8521fbc7b27aSKiran Patil if (ret) { 8522fbc7b27aSKiran Patil dev_err(ice_pf_to_dev(pf), 8523fbc7b27aSKiran Patil "failed creating channel TC:%d\n", i); 8524fbc7b27aSKiran Patil kfree(ch); 8525fbc7b27aSKiran Patil goto err_free; 8526fbc7b27aSKiran Patil } 8527fbc7b27aSKiran Patil list_add_tail(&ch->list, &vsi->ch_list); 8528fbc7b27aSKiran Patil vsi->tc_map_vsi[i] = ch->ch_vsi; 8529fbc7b27aSKiran Patil dev_dbg(ice_pf_to_dev(pf), 8530fbc7b27aSKiran Patil "successfully created channel: VSI %pK\n", ch->ch_vsi); 8531fbc7b27aSKiran Patil } 8532fbc7b27aSKiran Patil return 0; 8533fbc7b27aSKiran Patil 8534fbc7b27aSKiran Patil err_free: 8535fbc7b27aSKiran Patil ice_remove_q_channels(vsi, false); 8536fbc7b27aSKiran Patil 8537fbc7b27aSKiran Patil return ret; 8538fbc7b27aSKiran Patil } 8539fbc7b27aSKiran Patil 8540fbc7b27aSKiran Patil /** 8541fbc7b27aSKiran Patil * ice_setup_tc_mqprio_qdisc - configure multiple traffic classes 8542fbc7b27aSKiran Patil * @netdev: net device to configure 8543fbc7b27aSKiran Patil * @type_data: TC offload data 8544fbc7b27aSKiran Patil */ 8545fbc7b27aSKiran Patil static int ice_setup_tc_mqprio_qdisc(struct net_device *netdev, void *type_data) 8546fbc7b27aSKiran Patil { 8547fbc7b27aSKiran Patil struct tc_mqprio_qopt_offload *mqprio_qopt = type_data; 8548fbc7b27aSKiran Patil struct ice_netdev_priv *np = netdev_priv(netdev); 8549fbc7b27aSKiran Patil struct ice_vsi *vsi = np->vsi; 8550fbc7b27aSKiran Patil struct ice_pf *pf = vsi->back; 8551fbc7b27aSKiran Patil u16 mode, ena_tc_qdisc = 0; 8552fbc7b27aSKiran Patil int cur_txq, cur_rxq; 8553fbc7b27aSKiran Patil u8 hw = 0, num_tcf; 8554fbc7b27aSKiran Patil struct device *dev; 8555fbc7b27aSKiran Patil int ret, i; 8556fbc7b27aSKiran Patil 8557fbc7b27aSKiran Patil dev = ice_pf_to_dev(pf); 8558fbc7b27aSKiran Patil num_tcf = mqprio_qopt->qopt.num_tc; 8559fbc7b27aSKiran Patil hw = mqprio_qopt->qopt.hw; 8560fbc7b27aSKiran Patil mode = mqprio_qopt->mode; 8561fbc7b27aSKiran Patil if (!hw) { 8562fbc7b27aSKiran Patil clear_bit(ICE_FLAG_TC_MQPRIO, pf->flags); 8563fbc7b27aSKiran Patil vsi->ch_rss_size = 0; 8564fbc7b27aSKiran Patil memcpy(&vsi->mqprio_qopt, mqprio_qopt, sizeof(*mqprio_qopt)); 8565fbc7b27aSKiran Patil goto config_tcf; 8566fbc7b27aSKiran Patil } 8567fbc7b27aSKiran Patil 8568fbc7b27aSKiran Patil /* Generate queue region map for number of TCF requested */ 8569fbc7b27aSKiran Patil for (i = 0; i < num_tcf; i++) 8570fbc7b27aSKiran Patil ena_tc_qdisc |= BIT(i); 8571fbc7b27aSKiran Patil 8572fbc7b27aSKiran Patil switch (mode) { 8573fbc7b27aSKiran Patil case TC_MQPRIO_MODE_CHANNEL: 8574fbc7b27aSKiran Patil 8575fbc7b27aSKiran Patil ret = ice_validate_mqprio_qopt(vsi, mqprio_qopt); 8576fbc7b27aSKiran Patil if (ret) { 8577fbc7b27aSKiran Patil netdev_err(netdev, "failed to validate_mqprio_qopt(), ret %d\n", 8578fbc7b27aSKiran Patil ret); 8579fbc7b27aSKiran Patil return ret; 8580fbc7b27aSKiran Patil } 8581fbc7b27aSKiran Patil memcpy(&vsi->mqprio_qopt, mqprio_qopt, sizeof(*mqprio_qopt)); 8582fbc7b27aSKiran Patil set_bit(ICE_FLAG_TC_MQPRIO, pf->flags); 85839fea7498SKiran Patil /* don't assume state of hw_tc_offload during driver load 85849fea7498SKiran Patil * and set the flag for TC flower filter if hw_tc_offload 85859fea7498SKiran Patil * already ON 85869fea7498SKiran Patil */ 85879fea7498SKiran Patil if (vsi->netdev->features & NETIF_F_HW_TC) 85889fea7498SKiran Patil set_bit(ICE_FLAG_CLS_FLOWER, pf->flags); 8589fbc7b27aSKiran Patil break; 8590fbc7b27aSKiran Patil default: 8591fbc7b27aSKiran Patil return -EINVAL; 8592fbc7b27aSKiran Patil } 8593fbc7b27aSKiran Patil 8594fbc7b27aSKiran Patil config_tcf: 8595fbc7b27aSKiran Patil 8596fbc7b27aSKiran Patil /* Requesting same TCF configuration as already enabled */ 8597fbc7b27aSKiran Patil if (ena_tc_qdisc == vsi->tc_cfg.ena_tc && 8598fbc7b27aSKiran Patil mode != TC_MQPRIO_MODE_CHANNEL) 8599fbc7b27aSKiran Patil return 0; 8600fbc7b27aSKiran Patil 8601fbc7b27aSKiran Patil /* Pause VSI queues */ 8602fbc7b27aSKiran Patil ice_dis_vsi(vsi, true); 8603fbc7b27aSKiran Patil 8604fbc7b27aSKiran Patil if (!hw && !test_bit(ICE_FLAG_TC_MQPRIO, pf->flags)) 8605fbc7b27aSKiran Patil ice_remove_q_channels(vsi, true); 8606fbc7b27aSKiran Patil 8607fbc7b27aSKiran Patil if (!hw && !test_bit(ICE_FLAG_TC_MQPRIO, pf->flags)) { 8608fbc7b27aSKiran Patil vsi->req_txq = min_t(int, ice_get_avail_txq_count(pf), 8609fbc7b27aSKiran Patil num_online_cpus()); 8610fbc7b27aSKiran Patil vsi->req_rxq = min_t(int, ice_get_avail_rxq_count(pf), 8611fbc7b27aSKiran Patil num_online_cpus()); 8612fbc7b27aSKiran Patil } else { 8613fbc7b27aSKiran Patil /* logic to rebuild VSI, same like ethtool -L */ 8614fbc7b27aSKiran Patil u16 offset = 0, qcount_tx = 0, qcount_rx = 0; 8615fbc7b27aSKiran Patil 8616fbc7b27aSKiran Patil for (i = 0; i < num_tcf; i++) { 8617fbc7b27aSKiran Patil if (!(ena_tc_qdisc & BIT(i))) 8618fbc7b27aSKiran Patil continue; 8619fbc7b27aSKiran Patil 8620fbc7b27aSKiran Patil offset = vsi->mqprio_qopt.qopt.offset[i]; 8621fbc7b27aSKiran Patil qcount_rx = vsi->mqprio_qopt.qopt.count[i]; 8622fbc7b27aSKiran Patil qcount_tx = vsi->mqprio_qopt.qopt.count[i]; 8623fbc7b27aSKiran Patil } 8624fbc7b27aSKiran Patil vsi->req_txq = offset + qcount_tx; 8625fbc7b27aSKiran Patil vsi->req_rxq = offset + qcount_rx; 8626fbc7b27aSKiran Patil 8627fbc7b27aSKiran Patil /* store away original rss_size info, so that it gets reused 8628fbc7b27aSKiran Patil * form ice_vsi_rebuild during tc-qdisc delete stage - to 8629fbc7b27aSKiran Patil * determine, what should be the rss_sizefor main VSI 8630fbc7b27aSKiran Patil */ 8631fbc7b27aSKiran Patil vsi->orig_rss_size = vsi->rss_size; 8632fbc7b27aSKiran Patil } 8633fbc7b27aSKiran Patil 8634fbc7b27aSKiran Patil /* save current values of Tx and Rx queues before calling VSI rebuild 8635fbc7b27aSKiran Patil * for fallback option 8636fbc7b27aSKiran Patil */ 8637fbc7b27aSKiran Patil cur_txq = vsi->num_txq; 8638fbc7b27aSKiran Patil cur_rxq = vsi->num_rxq; 8639fbc7b27aSKiran Patil 8640fbc7b27aSKiran Patil /* proceed with rebuild main VSI using correct number of queues */ 8641fbc7b27aSKiran Patil ret = ice_vsi_rebuild(vsi, false); 8642fbc7b27aSKiran Patil if (ret) { 8643fbc7b27aSKiran Patil /* fallback to current number of queues */ 8644fbc7b27aSKiran Patil dev_info(dev, "Rebuild failed with new queues, try with current number of queues\n"); 8645fbc7b27aSKiran Patil vsi->req_txq = cur_txq; 8646fbc7b27aSKiran Patil vsi->req_rxq = cur_rxq; 8647fbc7b27aSKiran Patil clear_bit(ICE_RESET_FAILED, pf->state); 8648fbc7b27aSKiran Patil if (ice_vsi_rebuild(vsi, false)) { 8649fbc7b27aSKiran Patil dev_err(dev, "Rebuild of main VSI failed again\n"); 8650fbc7b27aSKiran Patil return ret; 8651fbc7b27aSKiran Patil } 8652fbc7b27aSKiran Patil } 8653fbc7b27aSKiran Patil 8654fbc7b27aSKiran Patil vsi->all_numtc = num_tcf; 8655fbc7b27aSKiran Patil vsi->all_enatc = ena_tc_qdisc; 8656fbc7b27aSKiran Patil ret = ice_vsi_cfg_tc(vsi, ena_tc_qdisc); 8657fbc7b27aSKiran Patil if (ret) { 8658fbc7b27aSKiran Patil netdev_err(netdev, "failed configuring TC for VSI id=%d\n", 8659fbc7b27aSKiran Patil vsi->vsi_num); 8660fbc7b27aSKiran Patil goto exit; 8661fbc7b27aSKiran Patil } 8662fbc7b27aSKiran Patil 8663fbc7b27aSKiran Patil if (test_bit(ICE_FLAG_TC_MQPRIO, pf->flags)) { 8664fbc7b27aSKiran Patil u64 max_tx_rate = vsi->mqprio_qopt.max_rate[0]; 8665fbc7b27aSKiran Patil u64 min_tx_rate = vsi->mqprio_qopt.min_rate[0]; 8666fbc7b27aSKiran Patil 8667fbc7b27aSKiran Patil /* set TC0 rate limit if specified */ 8668fbc7b27aSKiran Patil if (max_tx_rate || min_tx_rate) { 8669fbc7b27aSKiran Patil /* convert to Kbits/s */ 8670fbc7b27aSKiran Patil if (max_tx_rate) 8671fbc7b27aSKiran Patil max_tx_rate = div_u64(max_tx_rate, ICE_BW_KBPS_DIVISOR); 8672fbc7b27aSKiran Patil if (min_tx_rate) 8673fbc7b27aSKiran Patil min_tx_rate = div_u64(min_tx_rate, ICE_BW_KBPS_DIVISOR); 8674fbc7b27aSKiran Patil 8675fbc7b27aSKiran Patil ret = ice_set_bw_limit(vsi, max_tx_rate, min_tx_rate); 8676fbc7b27aSKiran Patil if (!ret) { 8677fbc7b27aSKiran Patil dev_dbg(dev, "set Tx rate max %llu min %llu for VSI(%u)\n", 8678fbc7b27aSKiran Patil max_tx_rate, min_tx_rate, vsi->vsi_num); 8679fbc7b27aSKiran Patil } else { 8680fbc7b27aSKiran Patil dev_err(dev, "failed to set Tx rate max %llu min %llu for VSI(%u)\n", 8681fbc7b27aSKiran Patil max_tx_rate, min_tx_rate, vsi->vsi_num); 8682fbc7b27aSKiran Patil goto exit; 8683fbc7b27aSKiran Patil } 8684fbc7b27aSKiran Patil } 8685fbc7b27aSKiran Patil ret = ice_create_q_channels(vsi); 8686fbc7b27aSKiran Patil if (ret) { 8687fbc7b27aSKiran Patil netdev_err(netdev, "failed configuring queue channels\n"); 8688fbc7b27aSKiran Patil goto exit; 8689fbc7b27aSKiran Patil } else { 8690fbc7b27aSKiran Patil netdev_dbg(netdev, "successfully configured channels\n"); 8691fbc7b27aSKiran Patil } 8692fbc7b27aSKiran Patil } 8693fbc7b27aSKiran Patil 8694fbc7b27aSKiran Patil if (vsi->ch_rss_size) 8695fbc7b27aSKiran Patil ice_vsi_cfg_rss_lut_key(vsi); 8696fbc7b27aSKiran Patil 8697fbc7b27aSKiran Patil exit: 8698fbc7b27aSKiran Patil /* if error, reset the all_numtc and all_enatc */ 8699fbc7b27aSKiran Patil if (ret) { 8700fbc7b27aSKiran Patil vsi->all_numtc = 0; 8701fbc7b27aSKiran Patil vsi->all_enatc = 0; 8702fbc7b27aSKiran Patil } 8703fbc7b27aSKiran Patil /* resume VSI */ 8704fbc7b27aSKiran Patil ice_ena_vsi(vsi, true); 8705fbc7b27aSKiran Patil 8706fbc7b27aSKiran Patil return ret; 8707fbc7b27aSKiran Patil } 8708fbc7b27aSKiran Patil 87090d08a441SKiran Patil static LIST_HEAD(ice_block_cb_list); 87100d08a441SKiran Patil 87110d08a441SKiran Patil static int 87120d08a441SKiran Patil ice_setup_tc(struct net_device *netdev, enum tc_setup_type type, 87130d08a441SKiran Patil void *type_data) 87140d08a441SKiran Patil { 87150d08a441SKiran Patil struct ice_netdev_priv *np = netdev_priv(netdev); 8716fbc7b27aSKiran Patil struct ice_pf *pf = np->vsi->back; 8717fbc7b27aSKiran Patil int err; 87180d08a441SKiran Patil 87190d08a441SKiran Patil switch (type) { 87200d08a441SKiran Patil case TC_SETUP_BLOCK: 87210d08a441SKiran Patil return flow_block_cb_setup_simple(type_data, 87220d08a441SKiran Patil &ice_block_cb_list, 87230d08a441SKiran Patil ice_setup_tc_block_cb, 87240d08a441SKiran Patil np, np, true); 8725fbc7b27aSKiran Patil case TC_SETUP_QDISC_MQPRIO: 8726fbc7b27aSKiran Patil /* setup traffic classifier for receive side */ 8727fbc7b27aSKiran Patil mutex_lock(&pf->tc_mutex); 8728fbc7b27aSKiran Patil err = ice_setup_tc_mqprio_qdisc(netdev, type_data); 8729fbc7b27aSKiran Patil mutex_unlock(&pf->tc_mutex); 8730fbc7b27aSKiran Patil return err; 87310d08a441SKiran Patil default: 87320d08a441SKiran Patil return -EOPNOTSUPP; 87330d08a441SKiran Patil } 87340d08a441SKiran Patil return -EOPNOTSUPP; 87350d08a441SKiran Patil } 87360d08a441SKiran Patil 8737195bb48fSMichal Swiatkowski static struct ice_indr_block_priv * 8738195bb48fSMichal Swiatkowski ice_indr_block_priv_lookup(struct ice_netdev_priv *np, 8739195bb48fSMichal Swiatkowski struct net_device *netdev) 8740195bb48fSMichal Swiatkowski { 8741195bb48fSMichal Swiatkowski struct ice_indr_block_priv *cb_priv; 8742195bb48fSMichal Swiatkowski 8743195bb48fSMichal Swiatkowski list_for_each_entry(cb_priv, &np->tc_indr_block_priv_list, list) { 8744195bb48fSMichal Swiatkowski if (!cb_priv->netdev) 8745195bb48fSMichal Swiatkowski return NULL; 8746195bb48fSMichal Swiatkowski if (cb_priv->netdev == netdev) 8747195bb48fSMichal Swiatkowski return cb_priv; 8748195bb48fSMichal Swiatkowski } 8749195bb48fSMichal Swiatkowski return NULL; 8750195bb48fSMichal Swiatkowski } 8751195bb48fSMichal Swiatkowski 8752195bb48fSMichal Swiatkowski static int 8753195bb48fSMichal Swiatkowski ice_indr_setup_block_cb(enum tc_setup_type type, void *type_data, 8754195bb48fSMichal Swiatkowski void *indr_priv) 8755195bb48fSMichal Swiatkowski { 8756195bb48fSMichal Swiatkowski struct ice_indr_block_priv *priv = indr_priv; 8757195bb48fSMichal Swiatkowski struct ice_netdev_priv *np = priv->np; 8758195bb48fSMichal Swiatkowski 8759195bb48fSMichal Swiatkowski switch (type) { 8760195bb48fSMichal Swiatkowski case TC_SETUP_CLSFLOWER: 8761195bb48fSMichal Swiatkowski return ice_setup_tc_cls_flower(np, priv->netdev, 8762195bb48fSMichal Swiatkowski (struct flow_cls_offload *) 8763195bb48fSMichal Swiatkowski type_data); 8764195bb48fSMichal Swiatkowski default: 8765195bb48fSMichal Swiatkowski return -EOPNOTSUPP; 8766195bb48fSMichal Swiatkowski } 8767195bb48fSMichal Swiatkowski } 8768195bb48fSMichal Swiatkowski 8769195bb48fSMichal Swiatkowski static int 8770195bb48fSMichal Swiatkowski ice_indr_setup_tc_block(struct net_device *netdev, struct Qdisc *sch, 8771195bb48fSMichal Swiatkowski struct ice_netdev_priv *np, 8772195bb48fSMichal Swiatkowski struct flow_block_offload *f, void *data, 8773195bb48fSMichal Swiatkowski void (*cleanup)(struct flow_block_cb *block_cb)) 8774195bb48fSMichal Swiatkowski { 8775195bb48fSMichal Swiatkowski struct ice_indr_block_priv *indr_priv; 8776195bb48fSMichal Swiatkowski struct flow_block_cb *block_cb; 8777195bb48fSMichal Swiatkowski 87789e300987SMichal Swiatkowski if (!ice_is_tunnel_supported(netdev) && 87799e300987SMichal Swiatkowski !(is_vlan_dev(netdev) && 87809e300987SMichal Swiatkowski vlan_dev_real_dev(netdev) == np->vsi->netdev)) 87819e300987SMichal Swiatkowski return -EOPNOTSUPP; 87829e300987SMichal Swiatkowski 8783195bb48fSMichal Swiatkowski if (f->binder_type != FLOW_BLOCK_BINDER_TYPE_CLSACT_INGRESS) 8784195bb48fSMichal Swiatkowski return -EOPNOTSUPP; 8785195bb48fSMichal Swiatkowski 8786195bb48fSMichal Swiatkowski switch (f->command) { 8787195bb48fSMichal Swiatkowski case FLOW_BLOCK_BIND: 8788195bb48fSMichal Swiatkowski indr_priv = ice_indr_block_priv_lookup(np, netdev); 8789195bb48fSMichal Swiatkowski if (indr_priv) 8790195bb48fSMichal Swiatkowski return -EEXIST; 8791195bb48fSMichal Swiatkowski 8792195bb48fSMichal Swiatkowski indr_priv = kzalloc(sizeof(*indr_priv), GFP_KERNEL); 8793195bb48fSMichal Swiatkowski if (!indr_priv) 8794195bb48fSMichal Swiatkowski return -ENOMEM; 8795195bb48fSMichal Swiatkowski 8796195bb48fSMichal Swiatkowski indr_priv->netdev = netdev; 8797195bb48fSMichal Swiatkowski indr_priv->np = np; 8798195bb48fSMichal Swiatkowski list_add(&indr_priv->list, &np->tc_indr_block_priv_list); 8799195bb48fSMichal Swiatkowski 8800195bb48fSMichal Swiatkowski block_cb = 8801195bb48fSMichal Swiatkowski flow_indr_block_cb_alloc(ice_indr_setup_block_cb, 8802195bb48fSMichal Swiatkowski indr_priv, indr_priv, 8803195bb48fSMichal Swiatkowski ice_rep_indr_tc_block_unbind, 8804195bb48fSMichal Swiatkowski f, netdev, sch, data, np, 8805195bb48fSMichal Swiatkowski cleanup); 8806195bb48fSMichal Swiatkowski 8807195bb48fSMichal Swiatkowski if (IS_ERR(block_cb)) { 8808195bb48fSMichal Swiatkowski list_del(&indr_priv->list); 8809195bb48fSMichal Swiatkowski kfree(indr_priv); 8810195bb48fSMichal Swiatkowski return PTR_ERR(block_cb); 8811195bb48fSMichal Swiatkowski } 8812195bb48fSMichal Swiatkowski flow_block_cb_add(block_cb, f); 8813195bb48fSMichal Swiatkowski list_add_tail(&block_cb->driver_list, &ice_block_cb_list); 8814195bb48fSMichal Swiatkowski break; 8815195bb48fSMichal Swiatkowski case FLOW_BLOCK_UNBIND: 8816195bb48fSMichal Swiatkowski indr_priv = ice_indr_block_priv_lookup(np, netdev); 8817195bb48fSMichal Swiatkowski if (!indr_priv) 8818195bb48fSMichal Swiatkowski return -ENOENT; 8819195bb48fSMichal Swiatkowski 8820195bb48fSMichal Swiatkowski block_cb = flow_block_cb_lookup(f->block, 8821195bb48fSMichal Swiatkowski ice_indr_setup_block_cb, 8822195bb48fSMichal Swiatkowski indr_priv); 8823195bb48fSMichal Swiatkowski if (!block_cb) 8824195bb48fSMichal Swiatkowski return -ENOENT; 8825195bb48fSMichal Swiatkowski 8826195bb48fSMichal Swiatkowski flow_indr_block_cb_remove(block_cb, f); 8827195bb48fSMichal Swiatkowski 8828195bb48fSMichal Swiatkowski list_del(&block_cb->driver_list); 8829195bb48fSMichal Swiatkowski break; 8830195bb48fSMichal Swiatkowski default: 8831195bb48fSMichal Swiatkowski return -EOPNOTSUPP; 8832195bb48fSMichal Swiatkowski } 8833195bb48fSMichal Swiatkowski return 0; 8834195bb48fSMichal Swiatkowski } 8835195bb48fSMichal Swiatkowski 8836195bb48fSMichal Swiatkowski static int 8837195bb48fSMichal Swiatkowski ice_indr_setup_tc_cb(struct net_device *netdev, struct Qdisc *sch, 8838195bb48fSMichal Swiatkowski void *cb_priv, enum tc_setup_type type, void *type_data, 8839195bb48fSMichal Swiatkowski void *data, 8840195bb48fSMichal Swiatkowski void (*cleanup)(struct flow_block_cb *block_cb)) 8841195bb48fSMichal Swiatkowski { 8842195bb48fSMichal Swiatkowski switch (type) { 8843195bb48fSMichal Swiatkowski case TC_SETUP_BLOCK: 8844195bb48fSMichal Swiatkowski return ice_indr_setup_tc_block(netdev, sch, cb_priv, type_data, 8845195bb48fSMichal Swiatkowski data, cleanup); 8846195bb48fSMichal Swiatkowski 8847195bb48fSMichal Swiatkowski default: 8848195bb48fSMichal Swiatkowski return -EOPNOTSUPP; 8849195bb48fSMichal Swiatkowski } 8850195bb48fSMichal Swiatkowski } 8851195bb48fSMichal Swiatkowski 88520d08a441SKiran Patil /** 8853cdedef59SAnirudh Venkataramanan * ice_open - Called when a network interface becomes active 8854cdedef59SAnirudh Venkataramanan * @netdev: network interface device structure 8855cdedef59SAnirudh Venkataramanan * 8856cdedef59SAnirudh Venkataramanan * The open entry point is called when a network interface is made 8857cdedef59SAnirudh Venkataramanan * active by the system (IFF_UP). At this point all resources needed 8858cdedef59SAnirudh Venkataramanan * for transmit and receive operations are allocated, the interrupt 8859cdedef59SAnirudh Venkataramanan * handler is registered with the OS, the netdev watchdog is enabled, 8860cdedef59SAnirudh Venkataramanan * and the stack is notified that the interface is ready. 8861cdedef59SAnirudh Venkataramanan * 8862cdedef59SAnirudh Venkataramanan * Returns 0 on success, negative value on failure 8863cdedef59SAnirudh Venkataramanan */ 88640e674aebSAnirudh Venkataramanan int ice_open(struct net_device *netdev) 8865cdedef59SAnirudh Venkataramanan { 8866cdedef59SAnirudh Venkataramanan struct ice_netdev_priv *np = netdev_priv(netdev); 8867e95fc857SKrzysztof Goreczny struct ice_pf *pf = np->vsi->back; 8868e95fc857SKrzysztof Goreczny 8869e95fc857SKrzysztof Goreczny if (ice_is_reset_in_progress(pf->state)) { 8870e95fc857SKrzysztof Goreczny netdev_err(netdev, "can't open net device while reset is in progress"); 8871e95fc857SKrzysztof Goreczny return -EBUSY; 8872e95fc857SKrzysztof Goreczny } 8873e95fc857SKrzysztof Goreczny 8874e95fc857SKrzysztof Goreczny return ice_open_internal(netdev); 8875e95fc857SKrzysztof Goreczny } 8876e95fc857SKrzysztof Goreczny 8877e95fc857SKrzysztof Goreczny /** 8878e95fc857SKrzysztof Goreczny * ice_open_internal - Called when a network interface becomes active 8879e95fc857SKrzysztof Goreczny * @netdev: network interface device structure 8880e95fc857SKrzysztof Goreczny * 8881e95fc857SKrzysztof Goreczny * Internal ice_open implementation. Should not be used directly except for ice_open and reset 8882e95fc857SKrzysztof Goreczny * handling routine 8883e95fc857SKrzysztof Goreczny * 8884e95fc857SKrzysztof Goreczny * Returns 0 on success, negative value on failure 8885e95fc857SKrzysztof Goreczny */ 8886e95fc857SKrzysztof Goreczny int ice_open_internal(struct net_device *netdev) 8887e95fc857SKrzysztof Goreczny { 8888e95fc857SKrzysztof Goreczny struct ice_netdev_priv *np = netdev_priv(netdev); 8889cdedef59SAnirudh Venkataramanan struct ice_vsi *vsi = np->vsi; 8890de75135bSAnirudh Venkataramanan struct ice_pf *pf = vsi->back; 88916d599946STony Nguyen struct ice_port_info *pi; 8892cdedef59SAnirudh Venkataramanan int err; 8893cdedef59SAnirudh Venkataramanan 88947e408e07SAnirudh Venkataramanan if (test_bit(ICE_NEEDS_RESTART, pf->state)) { 88950f9d5027SAnirudh Venkataramanan netdev_err(netdev, "driver needs to be unloaded and reloaded\n"); 88960f9d5027SAnirudh Venkataramanan return -EIO; 88970f9d5027SAnirudh Venkataramanan } 88980f9d5027SAnirudh Venkataramanan 8899cdedef59SAnirudh Venkataramanan netif_carrier_off(netdev); 8900cdedef59SAnirudh Venkataramanan 89016d599946STony Nguyen pi = vsi->port_info; 89022ccc1c1cSTony Nguyen err = ice_update_link_info(pi); 89032ccc1c1cSTony Nguyen if (err) { 89042ccc1c1cSTony Nguyen netdev_err(netdev, "Failed to get link info, error %d\n", err); 8905c1484691STony Nguyen return err; 89066d599946STony Nguyen } 89076d599946STony Nguyen 890899d40752SBrett Creeley ice_check_link_cfg_err(pf, pi->phy.link_info.link_cfg_err); 8909c77849f5SAnirudh Venkataramanan 89106d599946STony Nguyen /* Set PHY if there is media, otherwise, turn off PHY */ 89116d599946STony Nguyen if (pi->phy.link_info.link_info & ICE_AQ_MEDIA_AVAILABLE) { 89121a3571b5SPaul Greenwalt clear_bit(ICE_FLAG_NO_MEDIA, pf->flags); 89137e408e07SAnirudh Venkataramanan if (!test_bit(ICE_PHY_INIT_COMPLETE, pf->state)) { 89141a3571b5SPaul Greenwalt err = ice_init_phy_user_cfg(pi); 89151a3571b5SPaul Greenwalt if (err) { 89161a3571b5SPaul Greenwalt netdev_err(netdev, "Failed to initialize PHY settings, error %d\n", 89171a3571b5SPaul Greenwalt err); 89181a3571b5SPaul Greenwalt return err; 89191a3571b5SPaul Greenwalt } 89201a3571b5SPaul Greenwalt } 89211a3571b5SPaul Greenwalt 89221a3571b5SPaul Greenwalt err = ice_configure_phy(vsi); 8923b6f934f0SBrett Creeley if (err) { 892419cce2c6SAnirudh Venkataramanan netdev_err(netdev, "Failed to set physical link up, error %d\n", 89256d599946STony Nguyen err); 8926b6f934f0SBrett Creeley return err; 8927b6f934f0SBrett Creeley } 89286d599946STony Nguyen } else { 89291a3571b5SPaul Greenwalt set_bit(ICE_FLAG_NO_MEDIA, pf->flags); 8930d348d517SAnirudh Venkataramanan ice_set_link(vsi, false); 89316d599946STony Nguyen } 8932cdedef59SAnirudh Venkataramanan 8933b6f934f0SBrett Creeley err = ice_vsi_open(vsi); 8934cdedef59SAnirudh Venkataramanan if (err) 8935cdedef59SAnirudh Venkataramanan netdev_err(netdev, "Failed to open VSI 0x%04X on switch 0x%04X\n", 8936cdedef59SAnirudh Venkataramanan vsi->vsi_num, vsi->vsw->sw_id); 8937a4e82a81STony Nguyen 8938a4e82a81STony Nguyen /* Update existing tunnels information */ 8939a4e82a81STony Nguyen udp_tunnel_get_rx_info(netdev); 8940a4e82a81STony Nguyen 8941cdedef59SAnirudh Venkataramanan return err; 8942cdedef59SAnirudh Venkataramanan } 8943cdedef59SAnirudh Venkataramanan 8944cdedef59SAnirudh Venkataramanan /** 8945cdedef59SAnirudh Venkataramanan * ice_stop - Disables a network interface 8946cdedef59SAnirudh Venkataramanan * @netdev: network interface device structure 8947cdedef59SAnirudh Venkataramanan * 8948cdedef59SAnirudh Venkataramanan * The stop entry point is called when an interface is de-activated by the OS, 8949cdedef59SAnirudh Venkataramanan * and the netdevice enters the DOWN state. The hardware is still under the 8950cdedef59SAnirudh Venkataramanan * driver's control, but the netdev interface is disabled. 8951cdedef59SAnirudh Venkataramanan * 8952cdedef59SAnirudh Venkataramanan * Returns success only - not allowed to fail 8953cdedef59SAnirudh Venkataramanan */ 89540e674aebSAnirudh Venkataramanan int ice_stop(struct net_device *netdev) 8955cdedef59SAnirudh Venkataramanan { 8956cdedef59SAnirudh Venkataramanan struct ice_netdev_priv *np = netdev_priv(netdev); 8957cdedef59SAnirudh Venkataramanan struct ice_vsi *vsi = np->vsi; 8958e95fc857SKrzysztof Goreczny struct ice_pf *pf = vsi->back; 8959e95fc857SKrzysztof Goreczny 8960e95fc857SKrzysztof Goreczny if (ice_is_reset_in_progress(pf->state)) { 8961e95fc857SKrzysztof Goreczny netdev_err(netdev, "can't stop net device while reset is in progress"); 8962e95fc857SKrzysztof Goreczny return -EBUSY; 8963e95fc857SKrzysztof Goreczny } 8964cdedef59SAnirudh Venkataramanan 8965cdedef59SAnirudh Venkataramanan ice_vsi_close(vsi); 8966cdedef59SAnirudh Venkataramanan 8967cdedef59SAnirudh Venkataramanan return 0; 8968cdedef59SAnirudh Venkataramanan } 8969cdedef59SAnirudh Venkataramanan 8970e94d4478SAnirudh Venkataramanan /** 8971e94d4478SAnirudh Venkataramanan * ice_features_check - Validate encapsulated packet conforms to limits 8972e94d4478SAnirudh Venkataramanan * @skb: skb buffer 8973e94d4478SAnirudh Venkataramanan * @netdev: This port's netdev 8974e94d4478SAnirudh Venkataramanan * @features: Offload features that the stack believes apply 8975e94d4478SAnirudh Venkataramanan */ 8976e94d4478SAnirudh Venkataramanan static netdev_features_t 8977e94d4478SAnirudh Venkataramanan ice_features_check(struct sk_buff *skb, 8978e94d4478SAnirudh Venkataramanan struct net_device __always_unused *netdev, 8979e94d4478SAnirudh Venkataramanan netdev_features_t features) 8980e94d4478SAnirudh Venkataramanan { 898146b699c5SJesse Brandeburg bool gso = skb_is_gso(skb); 8982e94d4478SAnirudh Venkataramanan size_t len; 8983e94d4478SAnirudh Venkataramanan 8984e94d4478SAnirudh Venkataramanan /* No point in doing any of this if neither checksum nor GSO are 8985e94d4478SAnirudh Venkataramanan * being requested for this frame. We can rule out both by just 8986e94d4478SAnirudh Venkataramanan * checking for CHECKSUM_PARTIAL 8987e94d4478SAnirudh Venkataramanan */ 8988e94d4478SAnirudh Venkataramanan if (skb->ip_summed != CHECKSUM_PARTIAL) 8989e94d4478SAnirudh Venkataramanan return features; 8990e94d4478SAnirudh Venkataramanan 8991e94d4478SAnirudh Venkataramanan /* We cannot support GSO if the MSS is going to be less than 8992e94d4478SAnirudh Venkataramanan * 64 bytes. If it is then we need to drop support for GSO. 8993e94d4478SAnirudh Venkataramanan */ 899446b699c5SJesse Brandeburg if (gso && (skb_shinfo(skb)->gso_size < ICE_TXD_CTX_MIN_MSS)) 8995e94d4478SAnirudh Venkataramanan features &= ~NETIF_F_GSO_MASK; 8996e94d4478SAnirudh Venkataramanan 899746b699c5SJesse Brandeburg len = skb_network_offset(skb); 8998a4e82a81STony Nguyen if (len > ICE_TXD_MACLEN_MAX || len & 0x1) 8999e94d4478SAnirudh Venkataramanan goto out_rm_features; 9000e94d4478SAnirudh Venkataramanan 900146b699c5SJesse Brandeburg len = skb_network_header_len(skb); 9002a4e82a81STony Nguyen if (len > ICE_TXD_IPLEN_MAX || len & 0x1) 9003e94d4478SAnirudh Venkataramanan goto out_rm_features; 9004e94d4478SAnirudh Venkataramanan 9005e94d4478SAnirudh Venkataramanan if (skb->encapsulation) { 900646b699c5SJesse Brandeburg /* this must work for VXLAN frames AND IPIP/SIT frames, and in 900746b699c5SJesse Brandeburg * the case of IPIP frames, the transport header pointer is 900846b699c5SJesse Brandeburg * after the inner header! So check to make sure that this 900946b699c5SJesse Brandeburg * is a GRE or UDP_TUNNEL frame before doing that math. 901046b699c5SJesse Brandeburg */ 901146b699c5SJesse Brandeburg if (gso && (skb_shinfo(skb)->gso_type & 901246b699c5SJesse Brandeburg (SKB_GSO_GRE | SKB_GSO_UDP_TUNNEL))) { 901346b699c5SJesse Brandeburg len = skb_inner_network_header(skb) - 901446b699c5SJesse Brandeburg skb_transport_header(skb); 9015a4e82a81STony Nguyen if (len > ICE_TXD_L4LEN_MAX || len & 0x1) 9016e94d4478SAnirudh Venkataramanan goto out_rm_features; 901746b699c5SJesse Brandeburg } 9018e94d4478SAnirudh Venkataramanan 901946b699c5SJesse Brandeburg len = skb_inner_network_header_len(skb); 9020a4e82a81STony Nguyen if (len > ICE_TXD_IPLEN_MAX || len & 0x1) 9021e94d4478SAnirudh Venkataramanan goto out_rm_features; 9022e94d4478SAnirudh Venkataramanan } 9023e94d4478SAnirudh Venkataramanan 9024e94d4478SAnirudh Venkataramanan return features; 9025e94d4478SAnirudh Venkataramanan out_rm_features: 9026e94d4478SAnirudh Venkataramanan return features & ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK); 9027e94d4478SAnirudh Venkataramanan } 9028e94d4478SAnirudh Venkataramanan 9029462acf6aSTony Nguyen static const struct net_device_ops ice_netdev_safe_mode_ops = { 9030462acf6aSTony Nguyen .ndo_open = ice_open, 9031462acf6aSTony Nguyen .ndo_stop = ice_stop, 9032462acf6aSTony Nguyen .ndo_start_xmit = ice_start_xmit, 9033462acf6aSTony Nguyen .ndo_set_mac_address = ice_set_mac_address, 9034462acf6aSTony Nguyen .ndo_validate_addr = eth_validate_addr, 9035462acf6aSTony Nguyen .ndo_change_mtu = ice_change_mtu, 9036462acf6aSTony Nguyen .ndo_get_stats64 = ice_get_stats64, 9037462acf6aSTony Nguyen .ndo_tx_timeout = ice_tx_timeout, 9038ebc5399eSMaciej Fijalkowski .ndo_bpf = ice_xdp_safe_mode, 9039462acf6aSTony Nguyen }; 9040462acf6aSTony Nguyen 9041cdedef59SAnirudh Venkataramanan static const struct net_device_ops ice_netdev_ops = { 9042cdedef59SAnirudh Venkataramanan .ndo_open = ice_open, 9043cdedef59SAnirudh Venkataramanan .ndo_stop = ice_stop, 90442b245cb2SAnirudh Venkataramanan .ndo_start_xmit = ice_start_xmit, 90452a87bd73SDave Ertman .ndo_select_queue = ice_select_queue, 9046e94d4478SAnirudh Venkataramanan .ndo_features_check = ice_features_check, 90471babaf77SBrett Creeley .ndo_fix_features = ice_fix_features, 9048e94d4478SAnirudh Venkataramanan .ndo_set_rx_mode = ice_set_rx_mode, 9049e94d4478SAnirudh Venkataramanan .ndo_set_mac_address = ice_set_mac_address, 9050e94d4478SAnirudh Venkataramanan .ndo_validate_addr = eth_validate_addr, 9051e94d4478SAnirudh Venkataramanan .ndo_change_mtu = ice_change_mtu, 9052fcea6f3dSAnirudh Venkataramanan .ndo_get_stats64 = ice_get_stats64, 90531ddef455SUsha Ketineni .ndo_set_tx_maxrate = ice_set_tx_maxrate, 9054a7605370SArnd Bergmann .ndo_eth_ioctl = ice_eth_ioctl, 90557c710869SAnirudh Venkataramanan .ndo_set_vf_spoofchk = ice_set_vf_spoofchk, 90567c710869SAnirudh Venkataramanan .ndo_set_vf_mac = ice_set_vf_mac, 90577c710869SAnirudh Venkataramanan .ndo_get_vf_config = ice_get_vf_cfg, 90587c710869SAnirudh Venkataramanan .ndo_set_vf_trust = ice_set_vf_trust, 90597c710869SAnirudh Venkataramanan .ndo_set_vf_vlan = ice_set_vf_port_vlan, 90607c710869SAnirudh Venkataramanan .ndo_set_vf_link_state = ice_set_vf_link_state, 9061730fdea4SJesse Brandeburg .ndo_get_vf_stats = ice_get_vf_stats, 90624ecc8633SBrett Creeley .ndo_set_vf_rate = ice_set_vf_bw, 9063d76a60baSAnirudh Venkataramanan .ndo_vlan_rx_add_vid = ice_vlan_rx_add_vid, 9064d76a60baSAnirudh Venkataramanan .ndo_vlan_rx_kill_vid = ice_vlan_rx_kill_vid, 90650d08a441SKiran Patil .ndo_setup_tc = ice_setup_tc, 9066d76a60baSAnirudh Venkataramanan .ndo_set_features = ice_set_features, 9067b1edc14aSMd Fahad Iqbal Polash .ndo_bridge_getlink = ice_bridge_getlink, 9068b1edc14aSMd Fahad Iqbal Polash .ndo_bridge_setlink = ice_bridge_setlink, 9069e94d4478SAnirudh Venkataramanan .ndo_fdb_add = ice_fdb_add, 9070e94d4478SAnirudh Venkataramanan .ndo_fdb_del = ice_fdb_del, 907128bf2672SBrett Creeley #ifdef CONFIG_RFS_ACCEL 907228bf2672SBrett Creeley .ndo_rx_flow_steer = ice_rx_flow_steer, 907328bf2672SBrett Creeley #endif 9074b3969fd7SSudheer Mogilappagari .ndo_tx_timeout = ice_tx_timeout, 9075efc2214bSMaciej Fijalkowski .ndo_bpf = ice_xdp, 9076efc2214bSMaciej Fijalkowski .ndo_xdp_xmit = ice_xdp_xmit, 90772d4238f5SKrzysztof Kazimierczak .ndo_xsk_wakeup = ice_xsk_wakeup, 90784b889474SMichal Swiatkowski .ndo_get_devlink_port = ice_get_devlink_port, 9079cdedef59SAnirudh Venkataramanan }; 9080