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" 16837f08fdSAnirudh Venkataramanan 17837f08fdSAnirudh Venkataramanan #define DRV_SUMMARY "Intel(R) Ethernet Connection E800 Series Linux Driver" 18837f08fdSAnirudh Venkataramanan static const char ice_driver_string[] = DRV_SUMMARY; 19837f08fdSAnirudh Venkataramanan static const char ice_copyright[] = "Copyright (c) 2018, Intel Corporation."; 20837f08fdSAnirudh Venkataramanan 21462acf6aSTony Nguyen /* DDP Package file located in firmware search paths (e.g. /lib/firmware/) */ 22462acf6aSTony Nguyen #define ICE_DDP_PKG_PATH "intel/ice/ddp/" 23462acf6aSTony Nguyen #define ICE_DDP_PKG_FILE ICE_DDP_PKG_PATH "ice.pkg" 24462acf6aSTony Nguyen 25837f08fdSAnirudh Venkataramanan MODULE_AUTHOR("Intel Corporation, <linux.nics@intel.com>"); 26837f08fdSAnirudh Venkataramanan MODULE_DESCRIPTION(DRV_SUMMARY); 2798674ebeSJesse Brandeburg MODULE_LICENSE("GPL v2"); 28462acf6aSTony Nguyen MODULE_FIRMWARE(ICE_DDP_PKG_FILE); 29837f08fdSAnirudh Venkataramanan 30837f08fdSAnirudh Venkataramanan static int debug = -1; 31837f08fdSAnirudh Venkataramanan module_param(debug, int, 0644); 327ec59eeaSAnirudh Venkataramanan #ifndef CONFIG_DYNAMIC_DEBUG 337ec59eeaSAnirudh Venkataramanan MODULE_PARM_DESC(debug, "netif level (0=none,...,16=all), hw debug_mask (0x8XXXXXXX)"); 347ec59eeaSAnirudh Venkataramanan #else 357ec59eeaSAnirudh Venkataramanan MODULE_PARM_DESC(debug, "netif level (0=none,...,16=all)"); 367ec59eeaSAnirudh Venkataramanan #endif /* !CONFIG_DYNAMIC_DEBUG */ 37837f08fdSAnirudh Venkataramanan 38940b61afSAnirudh Venkataramanan static struct workqueue_struct *ice_wq; 39462acf6aSTony Nguyen static const struct net_device_ops ice_netdev_safe_mode_ops; 40cdedef59SAnirudh Venkataramanan static const struct net_device_ops ice_netdev_ops; 4187324e74SHenry Tieman static int ice_vsi_open(struct ice_vsi *vsi); 42940b61afSAnirudh Venkataramanan 43462acf6aSTony Nguyen static void ice_rebuild(struct ice_pf *pf, enum ice_reset_req reset_type); 4428c2a645SAnirudh Venkataramanan 450f9d5027SAnirudh Venkataramanan static void ice_vsi_release_all(struct ice_pf *pf); 463a858ba3SAnirudh Venkataramanan 47df006dd4SDave Ertman bool netif_is_ice(struct net_device *dev) 48df006dd4SDave Ertman { 49df006dd4SDave Ertman return dev && (dev->netdev_ops == &ice_netdev_ops); 50df006dd4SDave Ertman } 51df006dd4SDave Ertman 523a858ba3SAnirudh Venkataramanan /** 53b3969fd7SSudheer Mogilappagari * ice_get_tx_pending - returns number of Tx descriptors not processed 54b3969fd7SSudheer Mogilappagari * @ring: the ring of descriptors 55b3969fd7SSudheer Mogilappagari */ 56c1ddf1f5SBrett Creeley static u16 ice_get_tx_pending(struct ice_ring *ring) 57b3969fd7SSudheer Mogilappagari { 58c1ddf1f5SBrett Creeley u16 head, tail; 59b3969fd7SSudheer Mogilappagari 60b3969fd7SSudheer Mogilappagari head = ring->next_to_clean; 61c1ddf1f5SBrett Creeley tail = ring->next_to_use; 62b3969fd7SSudheer Mogilappagari 63b3969fd7SSudheer Mogilappagari if (head != tail) 64b3969fd7SSudheer Mogilappagari return (head < tail) ? 65b3969fd7SSudheer Mogilappagari tail - head : (tail + ring->count - head); 66b3969fd7SSudheer Mogilappagari return 0; 67b3969fd7SSudheer Mogilappagari } 68b3969fd7SSudheer Mogilappagari 69b3969fd7SSudheer Mogilappagari /** 70b3969fd7SSudheer Mogilappagari * ice_check_for_hang_subtask - check for and recover hung queues 71b3969fd7SSudheer Mogilappagari * @pf: pointer to PF struct 72b3969fd7SSudheer Mogilappagari */ 73b3969fd7SSudheer Mogilappagari static void ice_check_for_hang_subtask(struct ice_pf *pf) 74b3969fd7SSudheer Mogilappagari { 75b3969fd7SSudheer Mogilappagari struct ice_vsi *vsi = NULL; 76e89e899fSBrett Creeley struct ice_hw *hw; 77b3969fd7SSudheer Mogilappagari unsigned int i; 78b3969fd7SSudheer Mogilappagari int packets; 79e89e899fSBrett Creeley u32 v; 80b3969fd7SSudheer Mogilappagari 81b3969fd7SSudheer Mogilappagari ice_for_each_vsi(pf, v) 82b3969fd7SSudheer Mogilappagari if (pf->vsi[v] && pf->vsi[v]->type == ICE_VSI_PF) { 83b3969fd7SSudheer Mogilappagari vsi = pf->vsi[v]; 84b3969fd7SSudheer Mogilappagari break; 85b3969fd7SSudheer Mogilappagari } 86b3969fd7SSudheer Mogilappagari 87e97fb1aeSAnirudh Venkataramanan if (!vsi || test_bit(ICE_VSI_DOWN, vsi->state)) 88b3969fd7SSudheer Mogilappagari return; 89b3969fd7SSudheer Mogilappagari 90b3969fd7SSudheer Mogilappagari if (!(vsi->netdev && netif_carrier_ok(vsi->netdev))) 91b3969fd7SSudheer Mogilappagari return; 92b3969fd7SSudheer Mogilappagari 93e89e899fSBrett Creeley hw = &vsi->back->hw; 94e89e899fSBrett Creeley 95b3969fd7SSudheer Mogilappagari for (i = 0; i < vsi->num_txq; i++) { 96b3969fd7SSudheer Mogilappagari struct ice_ring *tx_ring = vsi->tx_rings[i]; 97b3969fd7SSudheer Mogilappagari 98b3969fd7SSudheer Mogilappagari if (tx_ring && tx_ring->desc) { 99b3969fd7SSudheer Mogilappagari /* If packet counter has not changed the queue is 100b3969fd7SSudheer Mogilappagari * likely stalled, so force an interrupt for this 101b3969fd7SSudheer Mogilappagari * queue. 102b3969fd7SSudheer Mogilappagari * 103b3969fd7SSudheer Mogilappagari * prev_pkt would be negative if there was no 104b3969fd7SSudheer Mogilappagari * pending work. 105b3969fd7SSudheer Mogilappagari */ 106b3969fd7SSudheer Mogilappagari packets = tx_ring->stats.pkts & INT_MAX; 107b3969fd7SSudheer Mogilappagari if (tx_ring->tx_stats.prev_pkt == packets) { 108b3969fd7SSudheer Mogilappagari /* Trigger sw interrupt to revive the queue */ 109e89e899fSBrett Creeley ice_trigger_sw_intr(hw, tx_ring->q_vector); 110b3969fd7SSudheer Mogilappagari continue; 111b3969fd7SSudheer Mogilappagari } 112b3969fd7SSudheer Mogilappagari 113b3969fd7SSudheer Mogilappagari /* Memory barrier between read of packet count and call 114b3969fd7SSudheer Mogilappagari * to ice_get_tx_pending() 115b3969fd7SSudheer Mogilappagari */ 116b3969fd7SSudheer Mogilappagari smp_rmb(); 117b3969fd7SSudheer Mogilappagari tx_ring->tx_stats.prev_pkt = 118b3969fd7SSudheer Mogilappagari ice_get_tx_pending(tx_ring) ? packets : -1; 119b3969fd7SSudheer Mogilappagari } 120b3969fd7SSudheer Mogilappagari } 121b3969fd7SSudheer Mogilappagari } 122b3969fd7SSudheer Mogilappagari 123b3969fd7SSudheer Mogilappagari /** 124561f4379STony Nguyen * ice_init_mac_fltr - Set initial MAC filters 125561f4379STony Nguyen * @pf: board private structure 126561f4379STony Nguyen * 1272f2da36eSAnirudh Venkataramanan * Set initial set of MAC filters for PF VSI; configure filters for permanent 128561f4379STony Nguyen * address and broadcast address. If an error is encountered, netdevice will be 129561f4379STony Nguyen * unregistered. 130561f4379STony Nguyen */ 131561f4379STony Nguyen static int ice_init_mac_fltr(struct ice_pf *pf) 132561f4379STony Nguyen { 133bbb968e8SAkeem G Abodunrin enum ice_status status; 134561f4379STony Nguyen struct ice_vsi *vsi; 1351b8f15b6SMichal Swiatkowski u8 *perm_addr; 136561f4379STony Nguyen 137208ff751SAnirudh Venkataramanan vsi = ice_get_main_vsi(pf); 138561f4379STony Nguyen if (!vsi) 139561f4379STony Nguyen return -EINVAL; 140561f4379STony Nguyen 1411b8f15b6SMichal Swiatkowski perm_addr = vsi->port_info->mac.perm_addr; 1421b8f15b6SMichal Swiatkowski status = ice_fltr_add_mac_and_broadcast(vsi, perm_addr, ICE_FWD_TO_VSI); 1431e23f076SAnirudh Venkataramanan if (status) 144bbb968e8SAkeem G Abodunrin return -EIO; 1451e23f076SAnirudh Venkataramanan 1461e23f076SAnirudh Venkataramanan return 0; 147561f4379STony Nguyen } 148561f4379STony Nguyen 149561f4379STony Nguyen /** 150f9867df6SAnirudh Venkataramanan * ice_add_mac_to_sync_list - creates list of MAC addresses to be synced 151e94d4478SAnirudh Venkataramanan * @netdev: the net device on which the sync is happening 152f9867df6SAnirudh Venkataramanan * @addr: MAC address to sync 153e94d4478SAnirudh Venkataramanan * 154e94d4478SAnirudh Venkataramanan * This is a callback function which is called by the in kernel device sync 155e94d4478SAnirudh Venkataramanan * functions (like __dev_uc_sync, __dev_mc_sync, etc). This function only 156e94d4478SAnirudh Venkataramanan * populates the tmp_sync_list, which is later used by ice_add_mac to add the 157f9867df6SAnirudh Venkataramanan * MAC filters from the hardware. 158e94d4478SAnirudh Venkataramanan */ 159e94d4478SAnirudh Venkataramanan static int ice_add_mac_to_sync_list(struct net_device *netdev, const u8 *addr) 160e94d4478SAnirudh Venkataramanan { 161e94d4478SAnirudh Venkataramanan struct ice_netdev_priv *np = netdev_priv(netdev); 162e94d4478SAnirudh Venkataramanan struct ice_vsi *vsi = np->vsi; 163e94d4478SAnirudh Venkataramanan 1641b8f15b6SMichal Swiatkowski if (ice_fltr_add_mac_to_list(vsi, &vsi->tmp_sync_list, addr, 1651b8f15b6SMichal Swiatkowski ICE_FWD_TO_VSI)) 166e94d4478SAnirudh Venkataramanan return -EINVAL; 167e94d4478SAnirudh Venkataramanan 168e94d4478SAnirudh Venkataramanan return 0; 169e94d4478SAnirudh Venkataramanan } 170e94d4478SAnirudh Venkataramanan 171e94d4478SAnirudh Venkataramanan /** 172f9867df6SAnirudh Venkataramanan * ice_add_mac_to_unsync_list - creates list of MAC addresses to be unsynced 173e94d4478SAnirudh Venkataramanan * @netdev: the net device on which the unsync is happening 174f9867df6SAnirudh Venkataramanan * @addr: MAC address to unsync 175e94d4478SAnirudh Venkataramanan * 176e94d4478SAnirudh Venkataramanan * This is a callback function which is called by the in kernel device unsync 177e94d4478SAnirudh Venkataramanan * functions (like __dev_uc_unsync, __dev_mc_unsync, etc). This function only 178e94d4478SAnirudh Venkataramanan * populates the tmp_unsync_list, which is later used by ice_remove_mac to 179f9867df6SAnirudh Venkataramanan * delete the MAC filters from the hardware. 180e94d4478SAnirudh Venkataramanan */ 181e94d4478SAnirudh Venkataramanan static int ice_add_mac_to_unsync_list(struct net_device *netdev, const u8 *addr) 182e94d4478SAnirudh Venkataramanan { 183e94d4478SAnirudh Venkataramanan struct ice_netdev_priv *np = netdev_priv(netdev); 184e94d4478SAnirudh Venkataramanan struct ice_vsi *vsi = np->vsi; 185e94d4478SAnirudh Venkataramanan 1861b8f15b6SMichal Swiatkowski if (ice_fltr_add_mac_to_list(vsi, &vsi->tmp_unsync_list, addr, 1871b8f15b6SMichal Swiatkowski ICE_FWD_TO_VSI)) 188e94d4478SAnirudh Venkataramanan return -EINVAL; 189e94d4478SAnirudh Venkataramanan 190e94d4478SAnirudh Venkataramanan return 0; 191e94d4478SAnirudh Venkataramanan } 192e94d4478SAnirudh Venkataramanan 193e94d4478SAnirudh Venkataramanan /** 194e94d4478SAnirudh Venkataramanan * ice_vsi_fltr_changed - check if filter state changed 195e94d4478SAnirudh Venkataramanan * @vsi: VSI to be checked 196e94d4478SAnirudh Venkataramanan * 197e94d4478SAnirudh Venkataramanan * returns true if filter state has changed, false otherwise. 198e94d4478SAnirudh Venkataramanan */ 199e94d4478SAnirudh Venkataramanan static bool ice_vsi_fltr_changed(struct ice_vsi *vsi) 200e94d4478SAnirudh Venkataramanan { 201e97fb1aeSAnirudh Venkataramanan return test_bit(ICE_VSI_UMAC_FLTR_CHANGED, vsi->state) || 202e97fb1aeSAnirudh Venkataramanan test_bit(ICE_VSI_MMAC_FLTR_CHANGED, vsi->state) || 203e97fb1aeSAnirudh Venkataramanan test_bit(ICE_VSI_VLAN_FLTR_CHANGED, vsi->state); 204e94d4478SAnirudh Venkataramanan } 205e94d4478SAnirudh Venkataramanan 206e94d4478SAnirudh Venkataramanan /** 2075eda8afdSAkeem G Abodunrin * ice_cfg_promisc - Enable or disable promiscuous mode for a given PF 2085eda8afdSAkeem G Abodunrin * @vsi: the VSI being configured 2095eda8afdSAkeem G Abodunrin * @promisc_m: mask of promiscuous config bits 2105eda8afdSAkeem G Abodunrin * @set_promisc: enable or disable promisc flag request 2115eda8afdSAkeem G Abodunrin * 2125eda8afdSAkeem G Abodunrin */ 2135eda8afdSAkeem G Abodunrin static int ice_cfg_promisc(struct ice_vsi *vsi, u8 promisc_m, bool set_promisc) 2145eda8afdSAkeem G Abodunrin { 2155eda8afdSAkeem G Abodunrin struct ice_hw *hw = &vsi->back->hw; 2165eda8afdSAkeem G Abodunrin enum ice_status status = 0; 2175eda8afdSAkeem G Abodunrin 2185eda8afdSAkeem G Abodunrin if (vsi->type != ICE_VSI_PF) 2195eda8afdSAkeem G Abodunrin return 0; 2205eda8afdSAkeem G Abodunrin 221bcf68ea1SNick Nunley if (vsi->num_vlan > 1) { 2225eda8afdSAkeem G Abodunrin status = ice_set_vlan_vsi_promisc(hw, vsi->idx, promisc_m, 2235eda8afdSAkeem G Abodunrin set_promisc); 2245eda8afdSAkeem G Abodunrin } else { 2255eda8afdSAkeem G Abodunrin if (set_promisc) 2265eda8afdSAkeem G Abodunrin status = ice_set_vsi_promisc(hw, vsi->idx, promisc_m, 2275eda8afdSAkeem G Abodunrin 0); 2285eda8afdSAkeem G Abodunrin else 2295eda8afdSAkeem G Abodunrin status = ice_clear_vsi_promisc(hw, vsi->idx, promisc_m, 2305eda8afdSAkeem G Abodunrin 0); 2315eda8afdSAkeem G Abodunrin } 2325eda8afdSAkeem G Abodunrin 2335eda8afdSAkeem G Abodunrin if (status) 2345eda8afdSAkeem G Abodunrin return -EIO; 2355eda8afdSAkeem G Abodunrin 2365eda8afdSAkeem G Abodunrin return 0; 2375eda8afdSAkeem G Abodunrin } 2385eda8afdSAkeem G Abodunrin 2395eda8afdSAkeem G Abodunrin /** 240e94d4478SAnirudh Venkataramanan * ice_vsi_sync_fltr - Update the VSI filter list to the HW 241e94d4478SAnirudh Venkataramanan * @vsi: ptr to the VSI 242e94d4478SAnirudh Venkataramanan * 243e94d4478SAnirudh Venkataramanan * Push any outstanding VSI filter changes through the AdminQ. 244e94d4478SAnirudh Venkataramanan */ 245e94d4478SAnirudh Venkataramanan static int ice_vsi_sync_fltr(struct ice_vsi *vsi) 246e94d4478SAnirudh Venkataramanan { 2479a946843SAnirudh Venkataramanan struct device *dev = ice_pf_to_dev(vsi->back); 248e94d4478SAnirudh Venkataramanan struct net_device *netdev = vsi->netdev; 249e94d4478SAnirudh Venkataramanan bool promisc_forced_on = false; 250e94d4478SAnirudh Venkataramanan struct ice_pf *pf = vsi->back; 251e94d4478SAnirudh Venkataramanan struct ice_hw *hw = &pf->hw; 252e94d4478SAnirudh Venkataramanan enum ice_status status = 0; 253e94d4478SAnirudh Venkataramanan u32 changed_flags = 0; 2545eda8afdSAkeem G Abodunrin u8 promisc_m; 255e94d4478SAnirudh Venkataramanan int err = 0; 256e94d4478SAnirudh Venkataramanan 257e94d4478SAnirudh Venkataramanan if (!vsi->netdev) 258e94d4478SAnirudh Venkataramanan return -EINVAL; 259e94d4478SAnirudh Venkataramanan 2607e408e07SAnirudh Venkataramanan while (test_and_set_bit(ICE_CFG_BUSY, vsi->state)) 261e94d4478SAnirudh Venkataramanan usleep_range(1000, 2000); 262e94d4478SAnirudh Venkataramanan 263e94d4478SAnirudh Venkataramanan changed_flags = vsi->current_netdev_flags ^ vsi->netdev->flags; 264e94d4478SAnirudh Venkataramanan vsi->current_netdev_flags = vsi->netdev->flags; 265e94d4478SAnirudh Venkataramanan 266e94d4478SAnirudh Venkataramanan INIT_LIST_HEAD(&vsi->tmp_sync_list); 267e94d4478SAnirudh Venkataramanan INIT_LIST_HEAD(&vsi->tmp_unsync_list); 268e94d4478SAnirudh Venkataramanan 269e94d4478SAnirudh Venkataramanan if (ice_vsi_fltr_changed(vsi)) { 270e97fb1aeSAnirudh Venkataramanan clear_bit(ICE_VSI_UMAC_FLTR_CHANGED, vsi->state); 271e97fb1aeSAnirudh Venkataramanan clear_bit(ICE_VSI_MMAC_FLTR_CHANGED, vsi->state); 272e97fb1aeSAnirudh Venkataramanan clear_bit(ICE_VSI_VLAN_FLTR_CHANGED, vsi->state); 273e94d4478SAnirudh Venkataramanan 274e94d4478SAnirudh Venkataramanan /* grab the netdev's addr_list_lock */ 275e94d4478SAnirudh Venkataramanan netif_addr_lock_bh(netdev); 276e94d4478SAnirudh Venkataramanan __dev_uc_sync(netdev, ice_add_mac_to_sync_list, 277e94d4478SAnirudh Venkataramanan ice_add_mac_to_unsync_list); 278e94d4478SAnirudh Venkataramanan __dev_mc_sync(netdev, ice_add_mac_to_sync_list, 279e94d4478SAnirudh Venkataramanan ice_add_mac_to_unsync_list); 280e94d4478SAnirudh Venkataramanan /* our temp lists are populated. release lock */ 281e94d4478SAnirudh Venkataramanan netif_addr_unlock_bh(netdev); 282e94d4478SAnirudh Venkataramanan } 283e94d4478SAnirudh Venkataramanan 284f9867df6SAnirudh Venkataramanan /* Remove MAC addresses in the unsync list */ 2851b8f15b6SMichal Swiatkowski status = ice_fltr_remove_mac_list(vsi, &vsi->tmp_unsync_list); 2861b8f15b6SMichal Swiatkowski ice_fltr_free_list(dev, &vsi->tmp_unsync_list); 287e94d4478SAnirudh Venkataramanan if (status) { 288e94d4478SAnirudh Venkataramanan netdev_err(netdev, "Failed to delete MAC filters\n"); 289e94d4478SAnirudh Venkataramanan /* if we failed because of alloc failures, just bail */ 290e94d4478SAnirudh Venkataramanan if (status == ICE_ERR_NO_MEMORY) { 291e94d4478SAnirudh Venkataramanan err = -ENOMEM; 292e94d4478SAnirudh Venkataramanan goto out; 293e94d4478SAnirudh Venkataramanan } 294e94d4478SAnirudh Venkataramanan } 295e94d4478SAnirudh Venkataramanan 296f9867df6SAnirudh Venkataramanan /* Add MAC addresses in the sync list */ 2971b8f15b6SMichal Swiatkowski status = ice_fltr_add_mac_list(vsi, &vsi->tmp_sync_list); 2981b8f15b6SMichal Swiatkowski ice_fltr_free_list(dev, &vsi->tmp_sync_list); 29989f3e4a5SPreethi Banala /* If filter is added successfully or already exists, do not go into 30089f3e4a5SPreethi Banala * 'if' condition and report it as error. Instead continue processing 30189f3e4a5SPreethi Banala * rest of the function. 30289f3e4a5SPreethi Banala */ 30389f3e4a5SPreethi Banala if (status && status != ICE_ERR_ALREADY_EXISTS) { 304e94d4478SAnirudh Venkataramanan netdev_err(netdev, "Failed to add MAC filters\n"); 305f9867df6SAnirudh Venkataramanan /* If there is no more space for new umac filters, VSI 306e94d4478SAnirudh Venkataramanan * should go into promiscuous mode. There should be some 307e94d4478SAnirudh Venkataramanan * space reserved for promiscuous filters. 308e94d4478SAnirudh Venkataramanan */ 309e94d4478SAnirudh Venkataramanan if (hw->adminq.sq_last_status == ICE_AQ_RC_ENOSPC && 3107e408e07SAnirudh Venkataramanan !test_and_set_bit(ICE_FLTR_OVERFLOW_PROMISC, 311e94d4478SAnirudh Venkataramanan vsi->state)) { 312e94d4478SAnirudh Venkataramanan promisc_forced_on = true; 31319cce2c6SAnirudh Venkataramanan netdev_warn(netdev, "Reached MAC filter limit, forcing promisc mode on VSI %d\n", 314e94d4478SAnirudh Venkataramanan vsi->vsi_num); 315e94d4478SAnirudh Venkataramanan } else { 316e94d4478SAnirudh Venkataramanan err = -EIO; 317e94d4478SAnirudh Venkataramanan goto out; 318e94d4478SAnirudh Venkataramanan } 319e94d4478SAnirudh Venkataramanan } 320e94d4478SAnirudh Venkataramanan /* check for changes in promiscuous modes */ 3215eda8afdSAkeem G Abodunrin if (changed_flags & IFF_ALLMULTI) { 3225eda8afdSAkeem G Abodunrin if (vsi->current_netdev_flags & IFF_ALLMULTI) { 323bcf68ea1SNick Nunley if (vsi->num_vlan > 1) 3245eda8afdSAkeem G Abodunrin promisc_m = ICE_MCAST_VLAN_PROMISC_BITS; 3255eda8afdSAkeem G Abodunrin else 3265eda8afdSAkeem G Abodunrin promisc_m = ICE_MCAST_PROMISC_BITS; 3275eda8afdSAkeem G Abodunrin 3285eda8afdSAkeem G Abodunrin err = ice_cfg_promisc(vsi, promisc_m, true); 3295eda8afdSAkeem G Abodunrin if (err) { 3305eda8afdSAkeem G Abodunrin netdev_err(netdev, "Error setting Multicast promiscuous mode on VSI %i\n", 3315eda8afdSAkeem G Abodunrin vsi->vsi_num); 3325eda8afdSAkeem G Abodunrin vsi->current_netdev_flags &= ~IFF_ALLMULTI; 3335eda8afdSAkeem G Abodunrin goto out_promisc; 3345eda8afdSAkeem G Abodunrin } 33592ace482SBruce Allan } else { 33692ace482SBruce Allan /* !(vsi->current_netdev_flags & IFF_ALLMULTI) */ 337bcf68ea1SNick Nunley if (vsi->num_vlan > 1) 3385eda8afdSAkeem G Abodunrin promisc_m = ICE_MCAST_VLAN_PROMISC_BITS; 3395eda8afdSAkeem G Abodunrin else 3405eda8afdSAkeem G Abodunrin promisc_m = ICE_MCAST_PROMISC_BITS; 3415eda8afdSAkeem G Abodunrin 3425eda8afdSAkeem G Abodunrin err = ice_cfg_promisc(vsi, promisc_m, false); 3435eda8afdSAkeem G Abodunrin if (err) { 3445eda8afdSAkeem G Abodunrin netdev_err(netdev, "Error clearing Multicast promiscuous mode on VSI %i\n", 3455eda8afdSAkeem G Abodunrin vsi->vsi_num); 3465eda8afdSAkeem G Abodunrin vsi->current_netdev_flags |= IFF_ALLMULTI; 3475eda8afdSAkeem G Abodunrin goto out_promisc; 3485eda8afdSAkeem G Abodunrin } 3495eda8afdSAkeem G Abodunrin } 3505eda8afdSAkeem G Abodunrin } 351e94d4478SAnirudh Venkataramanan 352e94d4478SAnirudh Venkataramanan if (((changed_flags & IFF_PROMISC) || promisc_forced_on) || 353e97fb1aeSAnirudh Venkataramanan test_bit(ICE_VSI_PROMISC_CHANGED, vsi->state)) { 354e97fb1aeSAnirudh Venkataramanan clear_bit(ICE_VSI_PROMISC_CHANGED, vsi->state); 355e94d4478SAnirudh Venkataramanan if (vsi->current_netdev_flags & IFF_PROMISC) { 356f9867df6SAnirudh Venkataramanan /* Apply Rx filter rule to get traffic from wire */ 357fc0f39bcSBrett Creeley if (!ice_is_dflt_vsi_in_use(pf->first_sw)) { 358fc0f39bcSBrett Creeley err = ice_set_dflt_vsi(pf->first_sw, vsi); 359fc0f39bcSBrett Creeley if (err && err != -EEXIST) { 36019cce2c6SAnirudh Venkataramanan netdev_err(netdev, "Error %d setting default VSI %i Rx rule\n", 361fc0f39bcSBrett Creeley err, vsi->vsi_num); 362fc0f39bcSBrett Creeley vsi->current_netdev_flags &= 363fc0f39bcSBrett Creeley ~IFF_PROMISC; 364e94d4478SAnirudh Venkataramanan goto out_promisc; 365e94d4478SAnirudh Venkataramanan } 36668d210a6SNick Nunley ice_cfg_vlan_pruning(vsi, false, false); 367fc0f39bcSBrett Creeley } 368e94d4478SAnirudh Venkataramanan } else { 369f9867df6SAnirudh Venkataramanan /* Clear Rx filter to remove traffic from wire */ 370fc0f39bcSBrett Creeley if (ice_is_vsi_dflt_vsi(pf->first_sw, vsi)) { 371fc0f39bcSBrett Creeley err = ice_clear_dflt_vsi(pf->first_sw); 372fc0f39bcSBrett Creeley if (err) { 37319cce2c6SAnirudh Venkataramanan netdev_err(netdev, "Error %d clearing default VSI %i Rx rule\n", 374fc0f39bcSBrett Creeley err, vsi->vsi_num); 375fc0f39bcSBrett Creeley vsi->current_netdev_flags |= 376fc0f39bcSBrett Creeley IFF_PROMISC; 377e94d4478SAnirudh Venkataramanan goto out_promisc; 378e94d4478SAnirudh Venkataramanan } 37968d210a6SNick Nunley if (vsi->num_vlan > 1) 38068d210a6SNick Nunley ice_cfg_vlan_pruning(vsi, true, false); 381e94d4478SAnirudh Venkataramanan } 382e94d4478SAnirudh Venkataramanan } 383fc0f39bcSBrett Creeley } 384e94d4478SAnirudh Venkataramanan goto exit; 385e94d4478SAnirudh Venkataramanan 386e94d4478SAnirudh Venkataramanan out_promisc: 387e97fb1aeSAnirudh Venkataramanan set_bit(ICE_VSI_PROMISC_CHANGED, vsi->state); 388e94d4478SAnirudh Venkataramanan goto exit; 389e94d4478SAnirudh Venkataramanan out: 390e94d4478SAnirudh Venkataramanan /* if something went wrong then set the changed flag so we try again */ 391e97fb1aeSAnirudh Venkataramanan set_bit(ICE_VSI_UMAC_FLTR_CHANGED, vsi->state); 392e97fb1aeSAnirudh Venkataramanan set_bit(ICE_VSI_MMAC_FLTR_CHANGED, vsi->state); 393e94d4478SAnirudh Venkataramanan exit: 3947e408e07SAnirudh Venkataramanan clear_bit(ICE_CFG_BUSY, vsi->state); 395e94d4478SAnirudh Venkataramanan return err; 396e94d4478SAnirudh Venkataramanan } 397e94d4478SAnirudh Venkataramanan 398e94d4478SAnirudh Venkataramanan /** 399e94d4478SAnirudh Venkataramanan * ice_sync_fltr_subtask - Sync the VSI filter list with HW 400e94d4478SAnirudh Venkataramanan * @pf: board private structure 401e94d4478SAnirudh Venkataramanan */ 402e94d4478SAnirudh Venkataramanan static void ice_sync_fltr_subtask(struct ice_pf *pf) 403e94d4478SAnirudh Venkataramanan { 404e94d4478SAnirudh Venkataramanan int v; 405e94d4478SAnirudh Venkataramanan 406e94d4478SAnirudh Venkataramanan if (!pf || !(test_bit(ICE_FLAG_FLTR_SYNC, pf->flags))) 407e94d4478SAnirudh Venkataramanan return; 408e94d4478SAnirudh Venkataramanan 409e94d4478SAnirudh Venkataramanan clear_bit(ICE_FLAG_FLTR_SYNC, pf->flags); 410e94d4478SAnirudh Venkataramanan 41180ed404aSBrett Creeley ice_for_each_vsi(pf, v) 412e94d4478SAnirudh Venkataramanan if (pf->vsi[v] && ice_vsi_fltr_changed(pf->vsi[v]) && 413e94d4478SAnirudh Venkataramanan ice_vsi_sync_fltr(pf->vsi[v])) { 414e94d4478SAnirudh Venkataramanan /* come back and try again later */ 415e94d4478SAnirudh Venkataramanan set_bit(ICE_FLAG_FLTR_SYNC, pf->flags); 416e94d4478SAnirudh Venkataramanan break; 417e94d4478SAnirudh Venkataramanan } 418e94d4478SAnirudh Venkataramanan } 419e94d4478SAnirudh Venkataramanan 420e94d4478SAnirudh Venkataramanan /** 4217b9ffc76SAnirudh Venkataramanan * ice_pf_dis_all_vsi - Pause all VSIs on a PF 4227b9ffc76SAnirudh Venkataramanan * @pf: the PF 4237b9ffc76SAnirudh Venkataramanan * @locked: is the rtnl_lock already held 4247b9ffc76SAnirudh Venkataramanan */ 4257b9ffc76SAnirudh Venkataramanan static void ice_pf_dis_all_vsi(struct ice_pf *pf, bool locked) 4267b9ffc76SAnirudh Venkataramanan { 427b126bd6bSKiran Patil int node; 4287b9ffc76SAnirudh Venkataramanan int v; 4297b9ffc76SAnirudh Venkataramanan 4307b9ffc76SAnirudh Venkataramanan ice_for_each_vsi(pf, v) 4317b9ffc76SAnirudh Venkataramanan if (pf->vsi[v]) 4327b9ffc76SAnirudh Venkataramanan ice_dis_vsi(pf->vsi[v], locked); 433b126bd6bSKiran Patil 434b126bd6bSKiran Patil for (node = 0; node < ICE_MAX_PF_AGG_NODES; node++) 435b126bd6bSKiran Patil pf->pf_agg_node[node].num_vsis = 0; 436b126bd6bSKiran Patil 437b126bd6bSKiran Patil for (node = 0; node < ICE_MAX_VF_AGG_NODES; node++) 438b126bd6bSKiran Patil pf->vf_agg_node[node].num_vsis = 0; 4397b9ffc76SAnirudh Venkataramanan } 4407b9ffc76SAnirudh Venkataramanan 4417b9ffc76SAnirudh Venkataramanan /** 4420b28b702SAnirudh Venkataramanan * ice_prepare_for_reset - prep for the core to reset 4430b28b702SAnirudh Venkataramanan * @pf: board private structure 4440b28b702SAnirudh Venkataramanan * 4450b28b702SAnirudh Venkataramanan * Inform or close all dependent features in prep for reset. 4460b28b702SAnirudh Venkataramanan */ 4470b28b702SAnirudh Venkataramanan static void 4480b28b702SAnirudh Venkataramanan ice_prepare_for_reset(struct ice_pf *pf) 4490b28b702SAnirudh Venkataramanan { 4500b28b702SAnirudh Venkataramanan struct ice_hw *hw = &pf->hw; 451c1e08830SJesse Brandeburg unsigned int i; 4520b28b702SAnirudh Venkataramanan 4535abac9d7SBrett Creeley /* already prepared for reset */ 4547e408e07SAnirudh Venkataramanan if (test_bit(ICE_PREPARED_FOR_RESET, pf->state)) 4555abac9d7SBrett Creeley return; 4565abac9d7SBrett Creeley 457007676b4SAnirudh Venkataramanan /* Notify VFs of impending reset */ 458007676b4SAnirudh Venkataramanan if (ice_check_sq_alive(hw, &hw->mailboxq)) 459007676b4SAnirudh Venkataramanan ice_vc_notify_reset(pf); 460007676b4SAnirudh Venkataramanan 461c7aeb4d1SAkeem G Abodunrin /* Disable VFs until reset is completed */ 462005881bcSBrett Creeley ice_for_each_vf(pf, i) 46377ca27c4SPaul Greenwalt ice_set_vf_state_qs_dis(&pf->vf[i]); 464c7aeb4d1SAkeem G Abodunrin 465462acf6aSTony Nguyen /* clear SW filtering DB */ 466462acf6aSTony Nguyen ice_clear_hw_tbls(hw); 4670b28b702SAnirudh Venkataramanan /* disable the VSIs and their queues that are not already DOWN */ 4687b9ffc76SAnirudh Venkataramanan ice_pf_dis_all_vsi(pf, false); 4690b28b702SAnirudh Venkataramanan 470c5a2a4a3SUsha Ketineni if (hw->port_info) 471c5a2a4a3SUsha Ketineni ice_sched_clear_port(hw->port_info); 472c5a2a4a3SUsha Ketineni 4730b28b702SAnirudh Venkataramanan ice_shutdown_all_ctrlq(hw); 4740f9d5027SAnirudh Venkataramanan 4757e408e07SAnirudh Venkataramanan set_bit(ICE_PREPARED_FOR_RESET, pf->state); 4760b28b702SAnirudh Venkataramanan } 4770b28b702SAnirudh Venkataramanan 4780b28b702SAnirudh Venkataramanan /** 4790b28b702SAnirudh Venkataramanan * ice_do_reset - Initiate one of many types of resets 4800b28b702SAnirudh Venkataramanan * @pf: board private structure 4810b28b702SAnirudh Venkataramanan * @reset_type: reset type requested 4820b28b702SAnirudh Venkataramanan * before this function was called. 4830b28b702SAnirudh Venkataramanan */ 4840b28b702SAnirudh Venkataramanan static void ice_do_reset(struct ice_pf *pf, enum ice_reset_req reset_type) 4850b28b702SAnirudh Venkataramanan { 4864015d11eSBrett Creeley struct device *dev = ice_pf_to_dev(pf); 4870b28b702SAnirudh Venkataramanan struct ice_hw *hw = &pf->hw; 4880b28b702SAnirudh Venkataramanan 4890b28b702SAnirudh Venkataramanan dev_dbg(dev, "reset_type 0x%x requested\n", reset_type); 4900b28b702SAnirudh Venkataramanan 4910b28b702SAnirudh Venkataramanan ice_prepare_for_reset(pf); 4920b28b702SAnirudh Venkataramanan 4930b28b702SAnirudh Venkataramanan /* trigger the reset */ 4940b28b702SAnirudh Venkataramanan if (ice_reset(hw, reset_type)) { 4950b28b702SAnirudh Venkataramanan dev_err(dev, "reset %d failed\n", reset_type); 4967e408e07SAnirudh Venkataramanan set_bit(ICE_RESET_FAILED, pf->state); 4977e408e07SAnirudh Venkataramanan clear_bit(ICE_RESET_OICR_RECV, pf->state); 4987e408e07SAnirudh Venkataramanan clear_bit(ICE_PREPARED_FOR_RESET, pf->state); 4997e408e07SAnirudh Venkataramanan clear_bit(ICE_PFR_REQ, pf->state); 5007e408e07SAnirudh Venkataramanan clear_bit(ICE_CORER_REQ, pf->state); 5017e408e07SAnirudh Venkataramanan clear_bit(ICE_GLOBR_REQ, pf->state); 5020b28b702SAnirudh Venkataramanan return; 5030b28b702SAnirudh Venkataramanan } 5040b28b702SAnirudh Venkataramanan 5050f9d5027SAnirudh Venkataramanan /* PFR is a bit of a special case because it doesn't result in an OICR 5060f9d5027SAnirudh Venkataramanan * interrupt. So for PFR, rebuild after the reset and clear the reset- 5070f9d5027SAnirudh Venkataramanan * associated state bits. 5080f9d5027SAnirudh Venkataramanan */ 5090b28b702SAnirudh Venkataramanan if (reset_type == ICE_RESET_PFR) { 5100b28b702SAnirudh Venkataramanan pf->pfr_count++; 511462acf6aSTony Nguyen ice_rebuild(pf, reset_type); 5127e408e07SAnirudh Venkataramanan clear_bit(ICE_PREPARED_FOR_RESET, pf->state); 5137e408e07SAnirudh Venkataramanan clear_bit(ICE_PFR_REQ, pf->state); 5141c44e3bcSAkeem G Abodunrin ice_reset_all_vfs(pf, true); 5150b28b702SAnirudh Venkataramanan } 5160b28b702SAnirudh Venkataramanan } 5170b28b702SAnirudh Venkataramanan 5180b28b702SAnirudh Venkataramanan /** 5190b28b702SAnirudh Venkataramanan * ice_reset_subtask - Set up for resetting the device and driver 5200b28b702SAnirudh Venkataramanan * @pf: board private structure 5210b28b702SAnirudh Venkataramanan */ 5220b28b702SAnirudh Venkataramanan static void ice_reset_subtask(struct ice_pf *pf) 5230b28b702SAnirudh Venkataramanan { 5240f9d5027SAnirudh Venkataramanan enum ice_reset_req reset_type = ICE_RESET_INVAL; 5250b28b702SAnirudh Venkataramanan 5260b28b702SAnirudh Venkataramanan /* When a CORER/GLOBR/EMPR is about to happen, the hardware triggers an 5270f9d5027SAnirudh Venkataramanan * OICR interrupt. The OICR handler (ice_misc_intr) determines what type 5280f9d5027SAnirudh Venkataramanan * of reset is pending and sets bits in pf->state indicating the reset 5297e408e07SAnirudh Venkataramanan * type and ICE_RESET_OICR_RECV. So, if the latter bit is set 5300f9d5027SAnirudh Venkataramanan * prepare for pending reset if not already (for PF software-initiated 5310f9d5027SAnirudh Venkataramanan * global resets the software should already be prepared for it as 5327e408e07SAnirudh Venkataramanan * indicated by ICE_PREPARED_FOR_RESET; for global resets initiated 5330f9d5027SAnirudh Venkataramanan * by firmware or software on other PFs, that bit is not set so prepare 5340f9d5027SAnirudh Venkataramanan * for the reset now), poll for reset done, rebuild and return. 5350b28b702SAnirudh Venkataramanan */ 5367e408e07SAnirudh Venkataramanan if (test_bit(ICE_RESET_OICR_RECV, pf->state)) { 5372ebd4428SDave Ertman /* Perform the largest reset requested */ 5387e408e07SAnirudh Venkataramanan if (test_and_clear_bit(ICE_CORER_RECV, pf->state)) 5392ebd4428SDave Ertman reset_type = ICE_RESET_CORER; 5407e408e07SAnirudh Venkataramanan if (test_and_clear_bit(ICE_GLOBR_RECV, pf->state)) 5412ebd4428SDave Ertman reset_type = ICE_RESET_GLOBR; 5427e408e07SAnirudh Venkataramanan if (test_and_clear_bit(ICE_EMPR_RECV, pf->state)) 54303af8406SAnirudh Venkataramanan reset_type = ICE_RESET_EMPR; 5442ebd4428SDave Ertman /* return if no valid reset type requested */ 5452ebd4428SDave Ertman if (reset_type == ICE_RESET_INVAL) 5462ebd4428SDave Ertman return; 5470b28b702SAnirudh Venkataramanan ice_prepare_for_reset(pf); 5480b28b702SAnirudh Venkataramanan 5490b28b702SAnirudh Venkataramanan /* make sure we are ready to rebuild */ 550fd2a9817SAnirudh Venkataramanan if (ice_check_reset(&pf->hw)) { 5517e408e07SAnirudh Venkataramanan set_bit(ICE_RESET_FAILED, pf->state); 552fd2a9817SAnirudh Venkataramanan } else { 553fd2a9817SAnirudh Venkataramanan /* done with reset. start rebuild */ 554fd2a9817SAnirudh Venkataramanan pf->hw.reset_ongoing = false; 555462acf6aSTony Nguyen ice_rebuild(pf, reset_type); 5560f9d5027SAnirudh Venkataramanan /* clear bit to resume normal operations, but 5570f9d5027SAnirudh Venkataramanan * ICE_NEEDS_RESTART bit is set in case rebuild failed 5580f9d5027SAnirudh Venkataramanan */ 5597e408e07SAnirudh Venkataramanan clear_bit(ICE_RESET_OICR_RECV, pf->state); 5607e408e07SAnirudh Venkataramanan clear_bit(ICE_PREPARED_FOR_RESET, pf->state); 5617e408e07SAnirudh Venkataramanan clear_bit(ICE_PFR_REQ, pf->state); 5627e408e07SAnirudh Venkataramanan clear_bit(ICE_CORER_REQ, pf->state); 5637e408e07SAnirudh Venkataramanan clear_bit(ICE_GLOBR_REQ, pf->state); 5641c44e3bcSAkeem G Abodunrin ice_reset_all_vfs(pf, true); 5650f9d5027SAnirudh Venkataramanan } 5660f9d5027SAnirudh Venkataramanan 5670f9d5027SAnirudh Venkataramanan return; 5680b28b702SAnirudh Venkataramanan } 5690b28b702SAnirudh Venkataramanan 5700b28b702SAnirudh Venkataramanan /* No pending resets to finish processing. Check for new resets */ 5717e408e07SAnirudh Venkataramanan if (test_bit(ICE_PFR_REQ, pf->state)) 5720f9d5027SAnirudh Venkataramanan reset_type = ICE_RESET_PFR; 5737e408e07SAnirudh Venkataramanan if (test_bit(ICE_CORER_REQ, pf->state)) 5740f9d5027SAnirudh Venkataramanan reset_type = ICE_RESET_CORER; 5757e408e07SAnirudh Venkataramanan if (test_bit(ICE_GLOBR_REQ, pf->state)) 5760b28b702SAnirudh Venkataramanan reset_type = ICE_RESET_GLOBR; 5770f9d5027SAnirudh Venkataramanan /* If no valid reset type requested just return */ 5780f9d5027SAnirudh Venkataramanan if (reset_type == ICE_RESET_INVAL) 5790f9d5027SAnirudh Venkataramanan return; 5800b28b702SAnirudh Venkataramanan 5810f9d5027SAnirudh Venkataramanan /* reset if not already down or busy */ 5827e408e07SAnirudh Venkataramanan if (!test_bit(ICE_DOWN, pf->state) && 5837e408e07SAnirudh Venkataramanan !test_bit(ICE_CFG_BUSY, pf->state)) { 5840b28b702SAnirudh Venkataramanan ice_do_reset(pf, reset_type); 5850b28b702SAnirudh Venkataramanan } 5860b28b702SAnirudh Venkataramanan } 5870b28b702SAnirudh Venkataramanan 5880b28b702SAnirudh Venkataramanan /** 5892e0ab37cSJesse Brandeburg * ice_print_topo_conflict - print topology conflict message 5902e0ab37cSJesse Brandeburg * @vsi: the VSI whose topology status is being checked 5912e0ab37cSJesse Brandeburg */ 5922e0ab37cSJesse Brandeburg static void ice_print_topo_conflict(struct ice_vsi *vsi) 5932e0ab37cSJesse Brandeburg { 5942e0ab37cSJesse Brandeburg switch (vsi->port_info->phy.link_info.topo_media_conflict) { 5952e0ab37cSJesse Brandeburg case ICE_AQ_LINK_TOPO_CONFLICT: 5962e0ab37cSJesse Brandeburg case ICE_AQ_LINK_MEDIA_CONFLICT: 5975878589dSPaul Greenwalt case ICE_AQ_LINK_TOPO_UNREACH_PRT: 5985878589dSPaul Greenwalt case ICE_AQ_LINK_TOPO_UNDRUTIL_PRT: 5995878589dSPaul Greenwalt case ICE_AQ_LINK_TOPO_UNDRUTIL_MEDIA: 6005c57145aSPaul 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"); 6012e0ab37cSJesse Brandeburg break; 6025878589dSPaul Greenwalt case ICE_AQ_LINK_TOPO_UNSUPP_MEDIA: 6035878589dSPaul Greenwalt netdev_info(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"); 6045878589dSPaul Greenwalt break; 6052e0ab37cSJesse Brandeburg default: 6062e0ab37cSJesse Brandeburg break; 6072e0ab37cSJesse Brandeburg } 6082e0ab37cSJesse Brandeburg } 6092e0ab37cSJesse Brandeburg 6102e0ab37cSJesse Brandeburg /** 611cdedef59SAnirudh Venkataramanan * ice_print_link_msg - print link up or down message 612cdedef59SAnirudh Venkataramanan * @vsi: the VSI whose link status is being queried 613cdedef59SAnirudh Venkataramanan * @isup: boolean for if the link is now up or down 614cdedef59SAnirudh Venkataramanan */ 615fcea6f3dSAnirudh Venkataramanan void ice_print_link_msg(struct ice_vsi *vsi, bool isup) 616cdedef59SAnirudh Venkataramanan { 617f776b3acSPaul Greenwalt struct ice_aqc_get_phy_caps_data *caps; 6185ee30564SPaul Greenwalt const char *an_advertised; 619f776b3acSPaul Greenwalt enum ice_status status; 620f776b3acSPaul Greenwalt const char *fec_req; 621cdedef59SAnirudh Venkataramanan const char *speed; 622f776b3acSPaul Greenwalt const char *fec; 623cdedef59SAnirudh Venkataramanan const char *fc; 62443260988SJesse Brandeburg const char *an; 625cdedef59SAnirudh Venkataramanan 626c2a23e00SBrett Creeley if (!vsi) 627c2a23e00SBrett Creeley return; 628c2a23e00SBrett Creeley 629cdedef59SAnirudh Venkataramanan if (vsi->current_isup == isup) 630cdedef59SAnirudh Venkataramanan return; 631cdedef59SAnirudh Venkataramanan 632cdedef59SAnirudh Venkataramanan vsi->current_isup = isup; 633cdedef59SAnirudh Venkataramanan 634cdedef59SAnirudh Venkataramanan if (!isup) { 635cdedef59SAnirudh Venkataramanan netdev_info(vsi->netdev, "NIC Link is Down\n"); 636cdedef59SAnirudh Venkataramanan return; 637cdedef59SAnirudh Venkataramanan } 638cdedef59SAnirudh Venkataramanan 639cdedef59SAnirudh Venkataramanan switch (vsi->port_info->phy.link_info.link_speed) { 640072efdf8SAnirudh Venkataramanan case ICE_AQ_LINK_SPEED_100GB: 641072efdf8SAnirudh Venkataramanan speed = "100 G"; 642072efdf8SAnirudh Venkataramanan break; 643072efdf8SAnirudh Venkataramanan case ICE_AQ_LINK_SPEED_50GB: 644072efdf8SAnirudh Venkataramanan speed = "50 G"; 645072efdf8SAnirudh Venkataramanan break; 646cdedef59SAnirudh Venkataramanan case ICE_AQ_LINK_SPEED_40GB: 647cdedef59SAnirudh Venkataramanan speed = "40 G"; 648cdedef59SAnirudh Venkataramanan break; 649cdedef59SAnirudh Venkataramanan case ICE_AQ_LINK_SPEED_25GB: 650cdedef59SAnirudh Venkataramanan speed = "25 G"; 651cdedef59SAnirudh Venkataramanan break; 652cdedef59SAnirudh Venkataramanan case ICE_AQ_LINK_SPEED_20GB: 653cdedef59SAnirudh Venkataramanan speed = "20 G"; 654cdedef59SAnirudh Venkataramanan break; 655cdedef59SAnirudh Venkataramanan case ICE_AQ_LINK_SPEED_10GB: 656cdedef59SAnirudh Venkataramanan speed = "10 G"; 657cdedef59SAnirudh Venkataramanan break; 658cdedef59SAnirudh Venkataramanan case ICE_AQ_LINK_SPEED_5GB: 659cdedef59SAnirudh Venkataramanan speed = "5 G"; 660cdedef59SAnirudh Venkataramanan break; 661cdedef59SAnirudh Venkataramanan case ICE_AQ_LINK_SPEED_2500MB: 662cdedef59SAnirudh Venkataramanan speed = "2.5 G"; 663cdedef59SAnirudh Venkataramanan break; 664cdedef59SAnirudh Venkataramanan case ICE_AQ_LINK_SPEED_1000MB: 665cdedef59SAnirudh Venkataramanan speed = "1 G"; 666cdedef59SAnirudh Venkataramanan break; 667cdedef59SAnirudh Venkataramanan case ICE_AQ_LINK_SPEED_100MB: 668cdedef59SAnirudh Venkataramanan speed = "100 M"; 669cdedef59SAnirudh Venkataramanan break; 670cdedef59SAnirudh Venkataramanan default: 671cdedef59SAnirudh Venkataramanan speed = "Unknown "; 672cdedef59SAnirudh Venkataramanan break; 673cdedef59SAnirudh Venkataramanan } 674cdedef59SAnirudh Venkataramanan 675cdedef59SAnirudh Venkataramanan switch (vsi->port_info->fc.current_mode) { 676cdedef59SAnirudh Venkataramanan case ICE_FC_FULL: 6772f2da36eSAnirudh Venkataramanan fc = "Rx/Tx"; 678cdedef59SAnirudh Venkataramanan break; 679cdedef59SAnirudh Venkataramanan case ICE_FC_TX_PAUSE: 6802f2da36eSAnirudh Venkataramanan fc = "Tx"; 681cdedef59SAnirudh Venkataramanan break; 682cdedef59SAnirudh Venkataramanan case ICE_FC_RX_PAUSE: 6832f2da36eSAnirudh Venkataramanan fc = "Rx"; 684cdedef59SAnirudh Venkataramanan break; 685203a068aSBrett Creeley case ICE_FC_NONE: 686203a068aSBrett Creeley fc = "None"; 687203a068aSBrett Creeley break; 688cdedef59SAnirudh Venkataramanan default: 689cdedef59SAnirudh Venkataramanan fc = "Unknown"; 690cdedef59SAnirudh Venkataramanan break; 691cdedef59SAnirudh Venkataramanan } 692cdedef59SAnirudh Venkataramanan 693f776b3acSPaul Greenwalt /* Get FEC mode based on negotiated link info */ 694f776b3acSPaul Greenwalt switch (vsi->port_info->phy.link_info.fec_info) { 695f776b3acSPaul Greenwalt case ICE_AQ_LINK_25G_RS_528_FEC_EN: 696f776b3acSPaul Greenwalt case ICE_AQ_LINK_25G_RS_544_FEC_EN: 697f776b3acSPaul Greenwalt fec = "RS-FEC"; 698f776b3acSPaul Greenwalt break; 699f776b3acSPaul Greenwalt case ICE_AQ_LINK_25G_KR_FEC_EN: 700f776b3acSPaul Greenwalt fec = "FC-FEC/BASE-R"; 701f776b3acSPaul Greenwalt break; 702f776b3acSPaul Greenwalt default: 703f776b3acSPaul Greenwalt fec = "NONE"; 704f776b3acSPaul Greenwalt break; 705f776b3acSPaul Greenwalt } 706f776b3acSPaul Greenwalt 70743260988SJesse Brandeburg /* check if autoneg completed, might be false due to not supported */ 70843260988SJesse Brandeburg if (vsi->port_info->phy.link_info.an_info & ICE_AQ_AN_COMPLETED) 70943260988SJesse Brandeburg an = "True"; 71043260988SJesse Brandeburg else 71143260988SJesse Brandeburg an = "False"; 71243260988SJesse Brandeburg 713f776b3acSPaul Greenwalt /* Get FEC mode requested based on PHY caps last SW configuration */ 7149efe35d0STony Nguyen caps = kzalloc(sizeof(*caps), GFP_KERNEL); 715f776b3acSPaul Greenwalt if (!caps) { 716f776b3acSPaul Greenwalt fec_req = "Unknown"; 7175ee30564SPaul Greenwalt an_advertised = "Unknown"; 718f776b3acSPaul Greenwalt goto done; 719f776b3acSPaul Greenwalt } 720f776b3acSPaul Greenwalt 721f776b3acSPaul Greenwalt status = ice_aq_get_phy_caps(vsi->port_info, false, 722d6730a87SAnirudh Venkataramanan ICE_AQC_REPORT_ACTIVE_CFG, caps, NULL); 723f776b3acSPaul Greenwalt if (status) 724f776b3acSPaul Greenwalt netdev_info(vsi->netdev, "Get phy capability failed.\n"); 725f776b3acSPaul Greenwalt 7265ee30564SPaul Greenwalt an_advertised = ice_is_phy_caps_an_enabled(caps) ? "On" : "Off"; 7275ee30564SPaul Greenwalt 728f776b3acSPaul Greenwalt if (caps->link_fec_options & ICE_AQC_PHY_FEC_25G_RS_528_REQ || 729f776b3acSPaul Greenwalt caps->link_fec_options & ICE_AQC_PHY_FEC_25G_RS_544_REQ) 730f776b3acSPaul Greenwalt fec_req = "RS-FEC"; 731f776b3acSPaul Greenwalt else if (caps->link_fec_options & ICE_AQC_PHY_FEC_10G_KR_40G_KR4_REQ || 732f776b3acSPaul Greenwalt caps->link_fec_options & ICE_AQC_PHY_FEC_25G_KR_REQ) 733f776b3acSPaul Greenwalt fec_req = "FC-FEC/BASE-R"; 734f776b3acSPaul Greenwalt else 735f776b3acSPaul Greenwalt fec_req = "NONE"; 736f776b3acSPaul Greenwalt 7379efe35d0STony Nguyen kfree(caps); 738f776b3acSPaul Greenwalt 739f776b3acSPaul Greenwalt done: 7405ee30564SPaul 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", 7415ee30564SPaul Greenwalt speed, fec_req, fec, an_advertised, an, fc); 7422e0ab37cSJesse Brandeburg ice_print_topo_conflict(vsi); 743cdedef59SAnirudh Venkataramanan } 744cdedef59SAnirudh Venkataramanan 745cdedef59SAnirudh Venkataramanan /** 746f9867df6SAnirudh Venkataramanan * ice_vsi_link_event - update the VSI's netdev 747f9867df6SAnirudh Venkataramanan * @vsi: the VSI on which the link event occurred 748f9867df6SAnirudh Venkataramanan * @link_up: whether or not the VSI needs to be set up or down 7490b28b702SAnirudh Venkataramanan */ 7500b28b702SAnirudh Venkataramanan static void ice_vsi_link_event(struct ice_vsi *vsi, bool link_up) 7510b28b702SAnirudh Venkataramanan { 752c2a23e00SBrett Creeley if (!vsi) 753c2a23e00SBrett Creeley return; 754c2a23e00SBrett Creeley 755e97fb1aeSAnirudh Venkataramanan if (test_bit(ICE_VSI_DOWN, vsi->state) || !vsi->netdev) 7560b28b702SAnirudh Venkataramanan return; 7570b28b702SAnirudh Venkataramanan 7580b28b702SAnirudh Venkataramanan if (vsi->type == ICE_VSI_PF) { 759c2a23e00SBrett Creeley if (link_up == netif_carrier_ok(vsi->netdev)) 7600b28b702SAnirudh Venkataramanan return; 761c2a23e00SBrett Creeley 7620b28b702SAnirudh Venkataramanan if (link_up) { 7630b28b702SAnirudh Venkataramanan netif_carrier_on(vsi->netdev); 7640b28b702SAnirudh Venkataramanan netif_tx_wake_all_queues(vsi->netdev); 7650b28b702SAnirudh Venkataramanan } else { 7660b28b702SAnirudh Venkataramanan netif_carrier_off(vsi->netdev); 7670b28b702SAnirudh Venkataramanan netif_tx_stop_all_queues(vsi->netdev); 7680b28b702SAnirudh Venkataramanan } 7690b28b702SAnirudh Venkataramanan } 7700b28b702SAnirudh Venkataramanan } 7710b28b702SAnirudh Venkataramanan 7720b28b702SAnirudh Venkataramanan /** 7737d9c9b79SDave Ertman * ice_set_dflt_mib - send a default config MIB to the FW 7747d9c9b79SDave Ertman * @pf: private PF struct 7757d9c9b79SDave Ertman * 7767d9c9b79SDave Ertman * This function sends a default configuration MIB to the FW. 7777d9c9b79SDave Ertman * 7787d9c9b79SDave Ertman * If this function errors out at any point, the driver is still able to 7797d9c9b79SDave Ertman * function. The main impact is that LFC may not operate as expected. 7807d9c9b79SDave Ertman * Therefore an error state in this function should be treated with a DBG 7817d9c9b79SDave Ertman * message and continue on with driver rebuild/reenable. 7827d9c9b79SDave Ertman */ 7837d9c9b79SDave Ertman static void ice_set_dflt_mib(struct ice_pf *pf) 7847d9c9b79SDave Ertman { 7857d9c9b79SDave Ertman struct device *dev = ice_pf_to_dev(pf); 7867d9c9b79SDave Ertman u8 mib_type, *buf, *lldpmib = NULL; 7877d9c9b79SDave Ertman u16 len, typelen, offset = 0; 7887d9c9b79SDave Ertman struct ice_lldp_org_tlv *tlv; 78912aae8f1SBruce Allan struct ice_hw *hw = &pf->hw; 7907d9c9b79SDave Ertman u32 ouisubtype; 7917d9c9b79SDave Ertman 7927d9c9b79SDave Ertman mib_type = SET_LOCAL_MIB_TYPE_LOCAL_MIB; 7937d9c9b79SDave Ertman lldpmib = kzalloc(ICE_LLDPDU_SIZE, GFP_KERNEL); 7947d9c9b79SDave Ertman if (!lldpmib) { 7957d9c9b79SDave Ertman dev_dbg(dev, "%s Failed to allocate MIB memory\n", 7967d9c9b79SDave Ertman __func__); 7977d9c9b79SDave Ertman return; 7987d9c9b79SDave Ertman } 7997d9c9b79SDave Ertman 8007d9c9b79SDave Ertman /* Add ETS CFG TLV */ 8017d9c9b79SDave Ertman tlv = (struct ice_lldp_org_tlv *)lldpmib; 8027d9c9b79SDave Ertman typelen = ((ICE_TLV_TYPE_ORG << ICE_LLDP_TLV_TYPE_S) | 8037d9c9b79SDave Ertman ICE_IEEE_ETS_TLV_LEN); 8047d9c9b79SDave Ertman tlv->typelen = htons(typelen); 8057d9c9b79SDave Ertman ouisubtype = ((ICE_IEEE_8021QAZ_OUI << ICE_LLDP_TLV_OUI_S) | 8067d9c9b79SDave Ertman ICE_IEEE_SUBTYPE_ETS_CFG); 8077d9c9b79SDave Ertman tlv->ouisubtype = htonl(ouisubtype); 8087d9c9b79SDave Ertman 8097d9c9b79SDave Ertman buf = tlv->tlvinfo; 8107d9c9b79SDave Ertman buf[0] = 0; 8117d9c9b79SDave Ertman 8127d9c9b79SDave Ertman /* ETS CFG all UPs map to TC 0. Next 4 (1 - 4) Octets = 0. 8137d9c9b79SDave Ertman * Octets 5 - 12 are BW values, set octet 5 to 100% BW. 8147d9c9b79SDave Ertman * Octets 13 - 20 are TSA values - leave as zeros 8157d9c9b79SDave Ertman */ 8167d9c9b79SDave Ertman buf[5] = 0x64; 8177d9c9b79SDave Ertman len = (typelen & ICE_LLDP_TLV_LEN_M) >> ICE_LLDP_TLV_LEN_S; 8187d9c9b79SDave Ertman offset += len + 2; 8197d9c9b79SDave Ertman tlv = (struct ice_lldp_org_tlv *) 8207d9c9b79SDave Ertman ((char *)tlv + sizeof(tlv->typelen) + len); 8217d9c9b79SDave Ertman 8227d9c9b79SDave Ertman /* Add ETS REC TLV */ 8237d9c9b79SDave Ertman buf = tlv->tlvinfo; 8247d9c9b79SDave Ertman tlv->typelen = htons(typelen); 8257d9c9b79SDave Ertman 8267d9c9b79SDave Ertman ouisubtype = ((ICE_IEEE_8021QAZ_OUI << ICE_LLDP_TLV_OUI_S) | 8277d9c9b79SDave Ertman ICE_IEEE_SUBTYPE_ETS_REC); 8287d9c9b79SDave Ertman tlv->ouisubtype = htonl(ouisubtype); 8297d9c9b79SDave Ertman 8307d9c9b79SDave Ertman /* First octet of buf is reserved 8317d9c9b79SDave Ertman * Octets 1 - 4 map UP to TC - all UPs map to zero 8327d9c9b79SDave Ertman * Octets 5 - 12 are BW values - set TC 0 to 100%. 8337d9c9b79SDave Ertman * Octets 13 - 20 are TSA value - leave as zeros 8347d9c9b79SDave Ertman */ 8357d9c9b79SDave Ertman buf[5] = 0x64; 8367d9c9b79SDave Ertman offset += len + 2; 8377d9c9b79SDave Ertman tlv = (struct ice_lldp_org_tlv *) 8387d9c9b79SDave Ertman ((char *)tlv + sizeof(tlv->typelen) + len); 8397d9c9b79SDave Ertman 8407d9c9b79SDave Ertman /* Add PFC CFG TLV */ 8417d9c9b79SDave Ertman typelen = ((ICE_TLV_TYPE_ORG << ICE_LLDP_TLV_TYPE_S) | 8427d9c9b79SDave Ertman ICE_IEEE_PFC_TLV_LEN); 8437d9c9b79SDave Ertman tlv->typelen = htons(typelen); 8447d9c9b79SDave Ertman 8457d9c9b79SDave Ertman ouisubtype = ((ICE_IEEE_8021QAZ_OUI << ICE_LLDP_TLV_OUI_S) | 8467d9c9b79SDave Ertman ICE_IEEE_SUBTYPE_PFC_CFG); 8477d9c9b79SDave Ertman tlv->ouisubtype = htonl(ouisubtype); 8487d9c9b79SDave Ertman 8497d9c9b79SDave Ertman /* Octet 1 left as all zeros - PFC disabled */ 8507d9c9b79SDave Ertman buf[0] = 0x08; 8517d9c9b79SDave Ertman len = (typelen & ICE_LLDP_TLV_LEN_M) >> ICE_LLDP_TLV_LEN_S; 8527d9c9b79SDave Ertman offset += len + 2; 8537d9c9b79SDave Ertman 8547d9c9b79SDave Ertman if (ice_aq_set_lldp_mib(hw, mib_type, (void *)lldpmib, offset, NULL)) 8557d9c9b79SDave Ertman dev_dbg(dev, "%s Failed to set default LLDP MIB\n", __func__); 8567d9c9b79SDave Ertman 8577d9c9b79SDave Ertman kfree(lldpmib); 8587d9c9b79SDave Ertman } 8597d9c9b79SDave Ertman 8607d9c9b79SDave Ertman /** 8610b28b702SAnirudh Venkataramanan * ice_link_event - process the link event 8622f2da36eSAnirudh Venkataramanan * @pf: PF that the link event is associated with 8630b28b702SAnirudh Venkataramanan * @pi: port_info for the port that the link event is associated with 864c2a23e00SBrett Creeley * @link_up: true if the physical link is up and false if it is down 865c2a23e00SBrett Creeley * @link_speed: current link speed received from the link event 8660b28b702SAnirudh Venkataramanan * 867c2a23e00SBrett Creeley * Returns 0 on success and negative on failure 8680b28b702SAnirudh Venkataramanan */ 8690b28b702SAnirudh Venkataramanan static int 870c2a23e00SBrett Creeley ice_link_event(struct ice_pf *pf, struct ice_port_info *pi, bool link_up, 871c2a23e00SBrett Creeley u16 link_speed) 8720b28b702SAnirudh Venkataramanan { 8734015d11eSBrett Creeley struct device *dev = ice_pf_to_dev(pf); 8740b28b702SAnirudh Venkataramanan struct ice_phy_info *phy_info; 875d348d517SAnirudh Venkataramanan enum ice_status status; 876c2a23e00SBrett Creeley struct ice_vsi *vsi; 877c2a23e00SBrett Creeley u16 old_link_speed; 878c2a23e00SBrett Creeley bool old_link; 8790b28b702SAnirudh Venkataramanan 8800b28b702SAnirudh Venkataramanan phy_info = &pi->phy; 8810b28b702SAnirudh Venkataramanan phy_info->link_info_old = phy_info->link_info; 8820b28b702SAnirudh Venkataramanan 883c2a23e00SBrett Creeley old_link = !!(phy_info->link_info_old.link_info & ICE_AQ_LINK_UP); 8840b28b702SAnirudh Venkataramanan old_link_speed = phy_info->link_info_old.link_speed; 8850b28b702SAnirudh Venkataramanan 886c2a23e00SBrett Creeley /* update the link info structures and re-enable link events, 887c2a23e00SBrett Creeley * don't bail on failure due to other book keeping needed 888c2a23e00SBrett Creeley */ 889d348d517SAnirudh Venkataramanan status = ice_update_link_info(pi); 890d348d517SAnirudh Venkataramanan if (status) 891d348d517SAnirudh Venkataramanan dev_dbg(dev, "Failed to update link status on port %d, err %s aq_err %s\n", 892d348d517SAnirudh Venkataramanan pi->lport, ice_stat_str(status), 893d348d517SAnirudh Venkataramanan ice_aq_str(pi->hw->adminq.sq_last_status)); 8940b28b702SAnirudh Venkataramanan 8950ce6c34aSDave Ertman /* Check if the link state is up after updating link info, and treat 8960ce6c34aSDave Ertman * this event as an UP event since the link is actually UP now. 8970ce6c34aSDave Ertman */ 8980ce6c34aSDave Ertman if (phy_info->link_info.link_info & ICE_AQ_LINK_UP) 8990ce6c34aSDave Ertman link_up = true; 9000ce6c34aSDave Ertman 901208ff751SAnirudh Venkataramanan vsi = ice_get_main_vsi(pf); 9020b28b702SAnirudh Venkataramanan if (!vsi || !vsi->port_info) 903c2a23e00SBrett Creeley return -EINVAL; 9040b28b702SAnirudh Venkataramanan 9056d599946STony Nguyen /* turn off PHY if media was removed */ 9066d599946STony Nguyen if (!test_bit(ICE_FLAG_NO_MEDIA, pf->flags) && 9076d599946STony Nguyen !(pi->phy.link_info.link_info & ICE_AQ_MEDIA_AVAILABLE)) { 9086d599946STony Nguyen set_bit(ICE_FLAG_NO_MEDIA, pf->flags); 909d348d517SAnirudh Venkataramanan ice_set_link(vsi, false); 9106d599946STony Nguyen } 9116d599946STony Nguyen 9121a3571b5SPaul Greenwalt /* if the old link up/down and speed is the same as the new */ 9131a3571b5SPaul Greenwalt if (link_up == old_link && link_speed == old_link_speed) 914d348d517SAnirudh Venkataramanan return 0; 9151a3571b5SPaul Greenwalt 9167d9c9b79SDave Ertman if (ice_is_dcb_active(pf)) { 9177d9c9b79SDave Ertman if (test_bit(ICE_FLAG_DCB_ENA, pf->flags)) 918242b5e06SDave Ertman ice_dcb_rebuild(pf); 9197d9c9b79SDave Ertman } else { 9207d9c9b79SDave Ertman if (link_up) 9217d9c9b79SDave Ertman ice_set_dflt_mib(pf); 9227d9c9b79SDave Ertman } 923c2a23e00SBrett Creeley ice_vsi_link_event(vsi, link_up); 924c2a23e00SBrett Creeley ice_print_link_msg(vsi, link_up); 9250b28b702SAnirudh Venkataramanan 92653b8decbSAnirudh Venkataramanan ice_vc_notify_link_state(pf); 92753b8decbSAnirudh Venkataramanan 928d348d517SAnirudh Venkataramanan return 0; 9290b28b702SAnirudh Venkataramanan } 9300b28b702SAnirudh Venkataramanan 9310b28b702SAnirudh Venkataramanan /** 9324f4be03bSAnirudh Venkataramanan * ice_watchdog_subtask - periodic tasks not using event driven scheduling 9334f4be03bSAnirudh Venkataramanan * @pf: board private structure 9340b28b702SAnirudh Venkataramanan */ 9354f4be03bSAnirudh Venkataramanan static void ice_watchdog_subtask(struct ice_pf *pf) 9360b28b702SAnirudh Venkataramanan { 9374f4be03bSAnirudh Venkataramanan int i; 9380b28b702SAnirudh Venkataramanan 9394f4be03bSAnirudh Venkataramanan /* if interface is down do nothing */ 9407e408e07SAnirudh Venkataramanan if (test_bit(ICE_DOWN, pf->state) || 9417e408e07SAnirudh Venkataramanan test_bit(ICE_CFG_BUSY, pf->state)) 9424f4be03bSAnirudh Venkataramanan return; 9430b28b702SAnirudh Venkataramanan 9444f4be03bSAnirudh Venkataramanan /* make sure we don't do these things too often */ 9454f4be03bSAnirudh Venkataramanan if (time_before(jiffies, 9464f4be03bSAnirudh Venkataramanan pf->serv_tmr_prev + pf->serv_tmr_period)) 9474f4be03bSAnirudh Venkataramanan return; 9480b28b702SAnirudh Venkataramanan 9494f4be03bSAnirudh Venkataramanan pf->serv_tmr_prev = jiffies; 9504f4be03bSAnirudh Venkataramanan 9514f4be03bSAnirudh Venkataramanan /* Update the stats for active netdevs so the network stack 9524f4be03bSAnirudh Venkataramanan * can look at updated numbers whenever it cares to 9534f4be03bSAnirudh Venkataramanan */ 9544f4be03bSAnirudh Venkataramanan ice_update_pf_stats(pf); 95580ed404aSBrett Creeley ice_for_each_vsi(pf, i) 9564f4be03bSAnirudh Venkataramanan if (pf->vsi[i] && pf->vsi[i]->netdev) 9574f4be03bSAnirudh Venkataramanan ice_update_vsi_stats(pf->vsi[i]); 9580b28b702SAnirudh Venkataramanan } 9590b28b702SAnirudh Venkataramanan 9600b28b702SAnirudh Venkataramanan /** 961250c3b3eSBrett Creeley * ice_init_link_events - enable/initialize link events 962250c3b3eSBrett Creeley * @pi: pointer to the port_info instance 963250c3b3eSBrett Creeley * 964250c3b3eSBrett Creeley * Returns -EIO on failure, 0 on success 965250c3b3eSBrett Creeley */ 966250c3b3eSBrett Creeley static int ice_init_link_events(struct ice_port_info *pi) 967250c3b3eSBrett Creeley { 968250c3b3eSBrett Creeley u16 mask; 969250c3b3eSBrett Creeley 970250c3b3eSBrett Creeley mask = ~((u16)(ICE_AQ_LINK_EVENT_UPDOWN | ICE_AQ_LINK_EVENT_MEDIA_NA | 971250c3b3eSBrett Creeley ICE_AQ_LINK_EVENT_MODULE_QUAL_FAIL)); 972250c3b3eSBrett Creeley 973250c3b3eSBrett Creeley if (ice_aq_set_event_mask(pi->hw, pi->lport, mask, NULL)) { 97419cce2c6SAnirudh Venkataramanan dev_dbg(ice_hw_to_dev(pi->hw), "Failed to set link event mask for port %d\n", 975250c3b3eSBrett Creeley pi->lport); 976250c3b3eSBrett Creeley return -EIO; 977250c3b3eSBrett Creeley } 978250c3b3eSBrett Creeley 979250c3b3eSBrett Creeley if (ice_aq_get_link_info(pi, true, NULL, NULL)) { 98019cce2c6SAnirudh Venkataramanan dev_dbg(ice_hw_to_dev(pi->hw), "Failed to enable link events for port %d\n", 981250c3b3eSBrett Creeley pi->lport); 982250c3b3eSBrett Creeley return -EIO; 983250c3b3eSBrett Creeley } 984250c3b3eSBrett Creeley 985250c3b3eSBrett Creeley return 0; 986250c3b3eSBrett Creeley } 987250c3b3eSBrett Creeley 988250c3b3eSBrett Creeley /** 989250c3b3eSBrett Creeley * ice_handle_link_event - handle link event via ARQ 9902f2da36eSAnirudh Venkataramanan * @pf: PF that the link event is associated with 991c2a23e00SBrett Creeley * @event: event structure containing link status info 992250c3b3eSBrett Creeley */ 993c2a23e00SBrett Creeley static int 994c2a23e00SBrett Creeley ice_handle_link_event(struct ice_pf *pf, struct ice_rq_event_info *event) 995250c3b3eSBrett Creeley { 996c2a23e00SBrett Creeley struct ice_aqc_get_link_status_data *link_data; 997250c3b3eSBrett Creeley struct ice_port_info *port_info; 998250c3b3eSBrett Creeley int status; 999250c3b3eSBrett Creeley 1000c2a23e00SBrett Creeley link_data = (struct ice_aqc_get_link_status_data *)event->msg_buf; 1001250c3b3eSBrett Creeley port_info = pf->hw.port_info; 1002250c3b3eSBrett Creeley if (!port_info) 1003250c3b3eSBrett Creeley return -EINVAL; 1004250c3b3eSBrett Creeley 1005c2a23e00SBrett Creeley status = ice_link_event(pf, port_info, 1006c2a23e00SBrett Creeley !!(link_data->link_info & ICE_AQ_LINK_UP), 1007c2a23e00SBrett Creeley le16_to_cpu(link_data->link_speed)); 1008250c3b3eSBrett Creeley if (status) 100919cce2c6SAnirudh Venkataramanan dev_dbg(ice_pf_to_dev(pf), "Could not process link event, error %d\n", 101019cce2c6SAnirudh Venkataramanan status); 1011250c3b3eSBrett Creeley 1012250c3b3eSBrett Creeley return status; 1013250c3b3eSBrett Creeley } 1014250c3b3eSBrett Creeley 1015d69ea414SJacob Keller enum ice_aq_task_state { 1016d69ea414SJacob Keller ICE_AQ_TASK_WAITING = 0, 1017d69ea414SJacob Keller ICE_AQ_TASK_COMPLETE, 1018d69ea414SJacob Keller ICE_AQ_TASK_CANCELED, 1019d69ea414SJacob Keller }; 1020d69ea414SJacob Keller 1021d69ea414SJacob Keller struct ice_aq_task { 1022d69ea414SJacob Keller struct hlist_node entry; 1023d69ea414SJacob Keller 1024d69ea414SJacob Keller u16 opcode; 1025d69ea414SJacob Keller struct ice_rq_event_info *event; 1026d69ea414SJacob Keller enum ice_aq_task_state state; 1027d69ea414SJacob Keller }; 1028d69ea414SJacob Keller 1029d69ea414SJacob Keller /** 1030ef860480STony Nguyen * ice_aq_wait_for_event - Wait for an AdminQ event from firmware 1031d69ea414SJacob Keller * @pf: pointer to the PF private structure 1032d69ea414SJacob Keller * @opcode: the opcode to wait for 1033d69ea414SJacob Keller * @timeout: how long to wait, in jiffies 1034d69ea414SJacob Keller * @event: storage for the event info 1035d69ea414SJacob Keller * 1036d69ea414SJacob Keller * Waits for a specific AdminQ completion event on the ARQ for a given PF. The 1037d69ea414SJacob Keller * current thread will be put to sleep until the specified event occurs or 1038d69ea414SJacob Keller * until the given timeout is reached. 1039d69ea414SJacob Keller * 1040d69ea414SJacob Keller * To obtain only the descriptor contents, pass an event without an allocated 1041d69ea414SJacob Keller * msg_buf. If the complete data buffer is desired, allocate the 1042d69ea414SJacob Keller * event->msg_buf with enough space ahead of time. 1043d69ea414SJacob Keller * 1044d69ea414SJacob Keller * Returns: zero on success, or a negative error code on failure. 1045d69ea414SJacob Keller */ 1046d69ea414SJacob Keller int ice_aq_wait_for_event(struct ice_pf *pf, u16 opcode, unsigned long timeout, 1047d69ea414SJacob Keller struct ice_rq_event_info *event) 1048d69ea414SJacob Keller { 10491e8249ccSJacob Keller struct device *dev = ice_pf_to_dev(pf); 1050d69ea414SJacob Keller struct ice_aq_task *task; 10511e8249ccSJacob Keller unsigned long start; 1052d69ea414SJacob Keller long ret; 1053d69ea414SJacob Keller int err; 1054d69ea414SJacob Keller 1055d69ea414SJacob Keller task = kzalloc(sizeof(*task), GFP_KERNEL); 1056d69ea414SJacob Keller if (!task) 1057d69ea414SJacob Keller return -ENOMEM; 1058d69ea414SJacob Keller 1059d69ea414SJacob Keller INIT_HLIST_NODE(&task->entry); 1060d69ea414SJacob Keller task->opcode = opcode; 1061d69ea414SJacob Keller task->event = event; 1062d69ea414SJacob Keller task->state = ICE_AQ_TASK_WAITING; 1063d69ea414SJacob Keller 1064d69ea414SJacob Keller spin_lock_bh(&pf->aq_wait_lock); 1065d69ea414SJacob Keller hlist_add_head(&task->entry, &pf->aq_wait_list); 1066d69ea414SJacob Keller spin_unlock_bh(&pf->aq_wait_lock); 1067d69ea414SJacob Keller 10681e8249ccSJacob Keller start = jiffies; 10691e8249ccSJacob Keller 1070d69ea414SJacob Keller ret = wait_event_interruptible_timeout(pf->aq_wait_queue, task->state, 1071d69ea414SJacob Keller timeout); 1072d69ea414SJacob Keller switch (task->state) { 1073d69ea414SJacob Keller case ICE_AQ_TASK_WAITING: 1074d69ea414SJacob Keller err = ret < 0 ? ret : -ETIMEDOUT; 1075d69ea414SJacob Keller break; 1076d69ea414SJacob Keller case ICE_AQ_TASK_CANCELED: 1077d69ea414SJacob Keller err = ret < 0 ? ret : -ECANCELED; 1078d69ea414SJacob Keller break; 1079d69ea414SJacob Keller case ICE_AQ_TASK_COMPLETE: 1080d69ea414SJacob Keller err = ret < 0 ? ret : 0; 1081d69ea414SJacob Keller break; 1082d69ea414SJacob Keller default: 1083d69ea414SJacob Keller WARN(1, "Unexpected AdminQ wait task state %u", task->state); 1084d69ea414SJacob Keller err = -EINVAL; 1085d69ea414SJacob Keller break; 1086d69ea414SJacob Keller } 1087d69ea414SJacob Keller 10881e8249ccSJacob Keller dev_dbg(dev, "Waited %u msecs (max %u msecs) for firmware response to op 0x%04x\n", 10891e8249ccSJacob Keller jiffies_to_msecs(jiffies - start), 10901e8249ccSJacob Keller jiffies_to_msecs(timeout), 10911e8249ccSJacob Keller opcode); 10921e8249ccSJacob Keller 1093d69ea414SJacob Keller spin_lock_bh(&pf->aq_wait_lock); 1094d69ea414SJacob Keller hlist_del(&task->entry); 1095d69ea414SJacob Keller spin_unlock_bh(&pf->aq_wait_lock); 1096d69ea414SJacob Keller kfree(task); 1097d69ea414SJacob Keller 1098d69ea414SJacob Keller return err; 1099d69ea414SJacob Keller } 1100d69ea414SJacob Keller 1101d69ea414SJacob Keller /** 1102d69ea414SJacob Keller * ice_aq_check_events - Check if any thread is waiting for an AdminQ event 1103d69ea414SJacob Keller * @pf: pointer to the PF private structure 1104d69ea414SJacob Keller * @opcode: the opcode of the event 1105d69ea414SJacob Keller * @event: the event to check 1106d69ea414SJacob Keller * 1107d69ea414SJacob Keller * Loops over the current list of pending threads waiting for an AdminQ event. 1108d69ea414SJacob Keller * For each matching task, copy the contents of the event into the task 1109d69ea414SJacob Keller * structure and wake up the thread. 1110d69ea414SJacob Keller * 1111d69ea414SJacob Keller * If multiple threads wait for the same opcode, they will all be woken up. 1112d69ea414SJacob Keller * 1113d69ea414SJacob Keller * Note that event->msg_buf will only be duplicated if the event has a buffer 1114d69ea414SJacob Keller * with enough space already allocated. Otherwise, only the descriptor and 1115d69ea414SJacob Keller * message length will be copied. 1116d69ea414SJacob Keller * 1117d69ea414SJacob Keller * Returns: true if an event was found, false otherwise 1118d69ea414SJacob Keller */ 1119d69ea414SJacob Keller static void ice_aq_check_events(struct ice_pf *pf, u16 opcode, 1120d69ea414SJacob Keller struct ice_rq_event_info *event) 1121d69ea414SJacob Keller { 1122d69ea414SJacob Keller struct ice_aq_task *task; 1123d69ea414SJacob Keller bool found = false; 1124d69ea414SJacob Keller 1125d69ea414SJacob Keller spin_lock_bh(&pf->aq_wait_lock); 1126d69ea414SJacob Keller hlist_for_each_entry(task, &pf->aq_wait_list, entry) { 1127d69ea414SJacob Keller if (task->state || task->opcode != opcode) 1128d69ea414SJacob Keller continue; 1129d69ea414SJacob Keller 1130d69ea414SJacob Keller memcpy(&task->event->desc, &event->desc, sizeof(event->desc)); 1131d69ea414SJacob Keller task->event->msg_len = event->msg_len; 1132d69ea414SJacob Keller 1133d69ea414SJacob Keller /* Only copy the data buffer if a destination was set */ 1134d69ea414SJacob Keller if (task->event->msg_buf && 1135d69ea414SJacob Keller task->event->buf_len > event->buf_len) { 1136d69ea414SJacob Keller memcpy(task->event->msg_buf, event->msg_buf, 1137d69ea414SJacob Keller event->buf_len); 1138d69ea414SJacob Keller task->event->buf_len = event->buf_len; 1139d69ea414SJacob Keller } 1140d69ea414SJacob Keller 1141d69ea414SJacob Keller task->state = ICE_AQ_TASK_COMPLETE; 1142d69ea414SJacob Keller found = true; 1143d69ea414SJacob Keller } 1144d69ea414SJacob Keller spin_unlock_bh(&pf->aq_wait_lock); 1145d69ea414SJacob Keller 1146d69ea414SJacob Keller if (found) 1147d69ea414SJacob Keller wake_up(&pf->aq_wait_queue); 1148d69ea414SJacob Keller } 1149d69ea414SJacob Keller 1150d69ea414SJacob Keller /** 1151d69ea414SJacob Keller * ice_aq_cancel_waiting_tasks - Immediately cancel all waiting tasks 1152d69ea414SJacob Keller * @pf: the PF private structure 1153d69ea414SJacob Keller * 1154d69ea414SJacob Keller * Set all waiting tasks to ICE_AQ_TASK_CANCELED, and wake up their threads. 1155d69ea414SJacob Keller * This will then cause ice_aq_wait_for_event to exit with -ECANCELED. 1156d69ea414SJacob Keller */ 1157d69ea414SJacob Keller static void ice_aq_cancel_waiting_tasks(struct ice_pf *pf) 1158d69ea414SJacob Keller { 1159d69ea414SJacob Keller struct ice_aq_task *task; 1160d69ea414SJacob Keller 1161d69ea414SJacob Keller spin_lock_bh(&pf->aq_wait_lock); 1162d69ea414SJacob Keller hlist_for_each_entry(task, &pf->aq_wait_list, entry) 1163d69ea414SJacob Keller task->state = ICE_AQ_TASK_CANCELED; 1164d69ea414SJacob Keller spin_unlock_bh(&pf->aq_wait_lock); 1165d69ea414SJacob Keller 1166d69ea414SJacob Keller wake_up(&pf->aq_wait_queue); 1167d69ea414SJacob Keller } 1168d69ea414SJacob Keller 1169250c3b3eSBrett Creeley /** 1170940b61afSAnirudh Venkataramanan * __ice_clean_ctrlq - helper function to clean controlq rings 1171940b61afSAnirudh Venkataramanan * @pf: ptr to struct ice_pf 1172940b61afSAnirudh Venkataramanan * @q_type: specific Control queue type 1173940b61afSAnirudh Venkataramanan */ 1174940b61afSAnirudh Venkataramanan static int __ice_clean_ctrlq(struct ice_pf *pf, enum ice_ctl_q q_type) 1175940b61afSAnirudh Venkataramanan { 11764015d11eSBrett Creeley struct device *dev = ice_pf_to_dev(pf); 1177940b61afSAnirudh Venkataramanan struct ice_rq_event_info event; 1178940b61afSAnirudh Venkataramanan struct ice_hw *hw = &pf->hw; 1179940b61afSAnirudh Venkataramanan struct ice_ctl_q_info *cq; 1180940b61afSAnirudh Venkataramanan u16 pending, i = 0; 1181940b61afSAnirudh Venkataramanan const char *qtype; 1182940b61afSAnirudh Venkataramanan u32 oldval, val; 1183940b61afSAnirudh Venkataramanan 11840b28b702SAnirudh Venkataramanan /* Do not clean control queue if/when PF reset fails */ 11857e408e07SAnirudh Venkataramanan if (test_bit(ICE_RESET_FAILED, pf->state)) 11860b28b702SAnirudh Venkataramanan return 0; 11870b28b702SAnirudh Venkataramanan 1188940b61afSAnirudh Venkataramanan switch (q_type) { 1189940b61afSAnirudh Venkataramanan case ICE_CTL_Q_ADMIN: 1190940b61afSAnirudh Venkataramanan cq = &hw->adminq; 1191940b61afSAnirudh Venkataramanan qtype = "Admin"; 1192940b61afSAnirudh Venkataramanan break; 119375d2b253SAnirudh Venkataramanan case ICE_CTL_Q_MAILBOX: 119475d2b253SAnirudh Venkataramanan cq = &hw->mailboxq; 119575d2b253SAnirudh Venkataramanan qtype = "Mailbox"; 119675d2b253SAnirudh Venkataramanan break; 1197940b61afSAnirudh Venkataramanan default: 11984015d11eSBrett Creeley dev_warn(dev, "Unknown control queue type 0x%x\n", q_type); 1199940b61afSAnirudh Venkataramanan return 0; 1200940b61afSAnirudh Venkataramanan } 1201940b61afSAnirudh Venkataramanan 1202940b61afSAnirudh Venkataramanan /* check for error indications - PF_xx_AxQLEN register layout for 1203940b61afSAnirudh Venkataramanan * FW/MBX/SB are identical so just use defines for PF_FW_AxQLEN. 1204940b61afSAnirudh Venkataramanan */ 1205940b61afSAnirudh Venkataramanan val = rd32(hw, cq->rq.len); 1206940b61afSAnirudh Venkataramanan if (val & (PF_FW_ARQLEN_ARQVFE_M | PF_FW_ARQLEN_ARQOVFL_M | 1207940b61afSAnirudh Venkataramanan PF_FW_ARQLEN_ARQCRIT_M)) { 1208940b61afSAnirudh Venkataramanan oldval = val; 1209940b61afSAnirudh Venkataramanan if (val & PF_FW_ARQLEN_ARQVFE_M) 12104015d11eSBrett Creeley dev_dbg(dev, "%s Receive Queue VF Error detected\n", 12114015d11eSBrett Creeley qtype); 1212940b61afSAnirudh Venkataramanan if (val & PF_FW_ARQLEN_ARQOVFL_M) { 121319cce2c6SAnirudh Venkataramanan dev_dbg(dev, "%s Receive Queue Overflow Error detected\n", 1214940b61afSAnirudh Venkataramanan qtype); 1215940b61afSAnirudh Venkataramanan } 1216940b61afSAnirudh Venkataramanan if (val & PF_FW_ARQLEN_ARQCRIT_M) 121719cce2c6SAnirudh Venkataramanan dev_dbg(dev, "%s Receive Queue Critical Error detected\n", 1218940b61afSAnirudh Venkataramanan qtype); 1219940b61afSAnirudh Venkataramanan val &= ~(PF_FW_ARQLEN_ARQVFE_M | PF_FW_ARQLEN_ARQOVFL_M | 1220940b61afSAnirudh Venkataramanan PF_FW_ARQLEN_ARQCRIT_M); 1221940b61afSAnirudh Venkataramanan if (oldval != val) 1222940b61afSAnirudh Venkataramanan wr32(hw, cq->rq.len, val); 1223940b61afSAnirudh Venkataramanan } 1224940b61afSAnirudh Venkataramanan 1225940b61afSAnirudh Venkataramanan val = rd32(hw, cq->sq.len); 1226940b61afSAnirudh Venkataramanan if (val & (PF_FW_ATQLEN_ATQVFE_M | PF_FW_ATQLEN_ATQOVFL_M | 1227940b61afSAnirudh Venkataramanan PF_FW_ATQLEN_ATQCRIT_M)) { 1228940b61afSAnirudh Venkataramanan oldval = val; 1229940b61afSAnirudh Venkataramanan if (val & PF_FW_ATQLEN_ATQVFE_M) 123019cce2c6SAnirudh Venkataramanan dev_dbg(dev, "%s Send Queue VF Error detected\n", 123119cce2c6SAnirudh Venkataramanan qtype); 1232940b61afSAnirudh Venkataramanan if (val & PF_FW_ATQLEN_ATQOVFL_M) { 12334015d11eSBrett Creeley dev_dbg(dev, "%s Send Queue Overflow Error detected\n", 1234940b61afSAnirudh Venkataramanan qtype); 1235940b61afSAnirudh Venkataramanan } 1236940b61afSAnirudh Venkataramanan if (val & PF_FW_ATQLEN_ATQCRIT_M) 12374015d11eSBrett Creeley dev_dbg(dev, "%s Send Queue Critical Error detected\n", 1238940b61afSAnirudh Venkataramanan qtype); 1239940b61afSAnirudh Venkataramanan val &= ~(PF_FW_ATQLEN_ATQVFE_M | PF_FW_ATQLEN_ATQOVFL_M | 1240940b61afSAnirudh Venkataramanan PF_FW_ATQLEN_ATQCRIT_M); 1241940b61afSAnirudh Venkataramanan if (oldval != val) 1242940b61afSAnirudh Venkataramanan wr32(hw, cq->sq.len, val); 1243940b61afSAnirudh Venkataramanan } 1244940b61afSAnirudh Venkataramanan 1245940b61afSAnirudh Venkataramanan event.buf_len = cq->rq_buf_size; 12469efe35d0STony Nguyen event.msg_buf = kzalloc(event.buf_len, GFP_KERNEL); 1247940b61afSAnirudh Venkataramanan if (!event.msg_buf) 1248940b61afSAnirudh Venkataramanan return 0; 1249940b61afSAnirudh Venkataramanan 1250940b61afSAnirudh Venkataramanan do { 1251940b61afSAnirudh Venkataramanan enum ice_status ret; 12520b28b702SAnirudh Venkataramanan u16 opcode; 1253940b61afSAnirudh Venkataramanan 1254940b61afSAnirudh Venkataramanan ret = ice_clean_rq_elem(hw, cq, &event, &pending); 1255940b61afSAnirudh Venkataramanan if (ret == ICE_ERR_AQ_NO_WORK) 1256940b61afSAnirudh Venkataramanan break; 1257940b61afSAnirudh Venkataramanan if (ret) { 12580fee3577SLihong Yang dev_err(dev, "%s Receive Queue event error %s\n", qtype, 12590fee3577SLihong Yang ice_stat_str(ret)); 1260940b61afSAnirudh Venkataramanan break; 1261940b61afSAnirudh Venkataramanan } 12620b28b702SAnirudh Venkataramanan 12630b28b702SAnirudh Venkataramanan opcode = le16_to_cpu(event.desc.opcode); 12640b28b702SAnirudh Venkataramanan 1265d69ea414SJacob Keller /* Notify any thread that might be waiting for this event */ 1266d69ea414SJacob Keller ice_aq_check_events(pf, opcode, &event); 1267d69ea414SJacob Keller 12680b28b702SAnirudh Venkataramanan switch (opcode) { 1269250c3b3eSBrett Creeley case ice_aqc_opc_get_link_status: 1270c2a23e00SBrett Creeley if (ice_handle_link_event(pf, &event)) 12714015d11eSBrett Creeley dev_err(dev, "Could not handle link event\n"); 1272250c3b3eSBrett Creeley break; 12732309ae38SBrett Creeley case ice_aqc_opc_event_lan_overflow: 12742309ae38SBrett Creeley ice_vf_lan_overflow_event(pf, &event); 12752309ae38SBrett Creeley break; 12761071a835SAnirudh Venkataramanan case ice_mbx_opc_send_msg_to_pf: 12771071a835SAnirudh Venkataramanan ice_vc_process_vf_msg(pf, &event); 12781071a835SAnirudh Venkataramanan break; 12798b97ceb1SHieu Tran case ice_aqc_opc_fw_logging: 12808b97ceb1SHieu Tran ice_output_fw_log(hw, &event.desc, event.msg_buf); 12818b97ceb1SHieu Tran break; 128200cc3f1bSAnirudh Venkataramanan case ice_aqc_opc_lldp_set_mib_change: 128300cc3f1bSAnirudh Venkataramanan ice_dcb_process_lldp_set_mib_change(pf, &event); 128400cc3f1bSAnirudh Venkataramanan break; 12850b28b702SAnirudh Venkataramanan default: 128619cce2c6SAnirudh Venkataramanan dev_dbg(dev, "%s Receive Queue unknown event 0x%04x ignored\n", 12870b28b702SAnirudh Venkataramanan qtype, opcode); 12880b28b702SAnirudh Venkataramanan break; 12890b28b702SAnirudh Venkataramanan } 1290940b61afSAnirudh Venkataramanan } while (pending && (i++ < ICE_DFLT_IRQ_WORK)); 1291940b61afSAnirudh Venkataramanan 12929efe35d0STony Nguyen kfree(event.msg_buf); 1293940b61afSAnirudh Venkataramanan 1294940b61afSAnirudh Venkataramanan return pending && (i == ICE_DFLT_IRQ_WORK); 1295940b61afSAnirudh Venkataramanan } 1296940b61afSAnirudh Venkataramanan 1297940b61afSAnirudh Venkataramanan /** 12983d6b640eSAnirudh Venkataramanan * ice_ctrlq_pending - check if there is a difference between ntc and ntu 12993d6b640eSAnirudh Venkataramanan * @hw: pointer to hardware info 13003d6b640eSAnirudh Venkataramanan * @cq: control queue information 13013d6b640eSAnirudh Venkataramanan * 13023d6b640eSAnirudh Venkataramanan * returns true if there are pending messages in a queue, false if there aren't 13033d6b640eSAnirudh Venkataramanan */ 13043d6b640eSAnirudh Venkataramanan static bool ice_ctrlq_pending(struct ice_hw *hw, struct ice_ctl_q_info *cq) 13053d6b640eSAnirudh Venkataramanan { 13063d6b640eSAnirudh Venkataramanan u16 ntu; 13073d6b640eSAnirudh Venkataramanan 13083d6b640eSAnirudh Venkataramanan ntu = (u16)(rd32(hw, cq->rq.head) & cq->rq.head_mask); 13093d6b640eSAnirudh Venkataramanan return cq->rq.next_to_clean != ntu; 13103d6b640eSAnirudh Venkataramanan } 13113d6b640eSAnirudh Venkataramanan 13123d6b640eSAnirudh Venkataramanan /** 1313940b61afSAnirudh Venkataramanan * ice_clean_adminq_subtask - clean the AdminQ rings 1314940b61afSAnirudh Venkataramanan * @pf: board private structure 1315940b61afSAnirudh Venkataramanan */ 1316940b61afSAnirudh Venkataramanan static void ice_clean_adminq_subtask(struct ice_pf *pf) 1317940b61afSAnirudh Venkataramanan { 1318940b61afSAnirudh Venkataramanan struct ice_hw *hw = &pf->hw; 1319940b61afSAnirudh Venkataramanan 13207e408e07SAnirudh Venkataramanan if (!test_bit(ICE_ADMINQ_EVENT_PENDING, pf->state)) 1321940b61afSAnirudh Venkataramanan return; 1322940b61afSAnirudh Venkataramanan 1323940b61afSAnirudh Venkataramanan if (__ice_clean_ctrlq(pf, ICE_CTL_Q_ADMIN)) 1324940b61afSAnirudh Venkataramanan return; 1325940b61afSAnirudh Venkataramanan 13267e408e07SAnirudh Venkataramanan clear_bit(ICE_ADMINQ_EVENT_PENDING, pf->state); 1327940b61afSAnirudh Venkataramanan 13283d6b640eSAnirudh Venkataramanan /* There might be a situation where new messages arrive to a control 13293d6b640eSAnirudh Venkataramanan * queue between processing the last message and clearing the 13303d6b640eSAnirudh Venkataramanan * EVENT_PENDING bit. So before exiting, check queue head again (using 13313d6b640eSAnirudh Venkataramanan * ice_ctrlq_pending) and process new messages if any. 13323d6b640eSAnirudh Venkataramanan */ 13333d6b640eSAnirudh Venkataramanan if (ice_ctrlq_pending(hw, &hw->adminq)) 13343d6b640eSAnirudh Venkataramanan __ice_clean_ctrlq(pf, ICE_CTL_Q_ADMIN); 1335940b61afSAnirudh Venkataramanan 1336940b61afSAnirudh Venkataramanan ice_flush(hw); 1337940b61afSAnirudh Venkataramanan } 1338940b61afSAnirudh Venkataramanan 1339940b61afSAnirudh Venkataramanan /** 134075d2b253SAnirudh Venkataramanan * ice_clean_mailboxq_subtask - clean the MailboxQ rings 134175d2b253SAnirudh Venkataramanan * @pf: board private structure 134275d2b253SAnirudh Venkataramanan */ 134375d2b253SAnirudh Venkataramanan static void ice_clean_mailboxq_subtask(struct ice_pf *pf) 134475d2b253SAnirudh Venkataramanan { 134575d2b253SAnirudh Venkataramanan struct ice_hw *hw = &pf->hw; 134675d2b253SAnirudh Venkataramanan 13477e408e07SAnirudh Venkataramanan if (!test_bit(ICE_MAILBOXQ_EVENT_PENDING, pf->state)) 134875d2b253SAnirudh Venkataramanan return; 134975d2b253SAnirudh Venkataramanan 135075d2b253SAnirudh Venkataramanan if (__ice_clean_ctrlq(pf, ICE_CTL_Q_MAILBOX)) 135175d2b253SAnirudh Venkataramanan return; 135275d2b253SAnirudh Venkataramanan 13537e408e07SAnirudh Venkataramanan clear_bit(ICE_MAILBOXQ_EVENT_PENDING, pf->state); 135475d2b253SAnirudh Venkataramanan 135575d2b253SAnirudh Venkataramanan if (ice_ctrlq_pending(hw, &hw->mailboxq)) 135675d2b253SAnirudh Venkataramanan __ice_clean_ctrlq(pf, ICE_CTL_Q_MAILBOX); 135775d2b253SAnirudh Venkataramanan 135875d2b253SAnirudh Venkataramanan ice_flush(hw); 135975d2b253SAnirudh Venkataramanan } 136075d2b253SAnirudh Venkataramanan 136175d2b253SAnirudh Venkataramanan /** 1362940b61afSAnirudh Venkataramanan * ice_service_task_schedule - schedule the service task to wake up 1363940b61afSAnirudh Venkataramanan * @pf: board private structure 1364940b61afSAnirudh Venkataramanan * 1365940b61afSAnirudh Venkataramanan * If not already scheduled, this puts the task into the work queue. 1366940b61afSAnirudh Venkataramanan */ 136728bf2672SBrett Creeley void ice_service_task_schedule(struct ice_pf *pf) 1368940b61afSAnirudh Venkataramanan { 13697e408e07SAnirudh Venkataramanan if (!test_bit(ICE_SERVICE_DIS, pf->state) && 13707e408e07SAnirudh Venkataramanan !test_and_set_bit(ICE_SERVICE_SCHED, pf->state) && 13717e408e07SAnirudh Venkataramanan !test_bit(ICE_NEEDS_RESTART, pf->state)) 1372940b61afSAnirudh Venkataramanan queue_work(ice_wq, &pf->serv_task); 1373940b61afSAnirudh Venkataramanan } 1374940b61afSAnirudh Venkataramanan 1375940b61afSAnirudh Venkataramanan /** 1376940b61afSAnirudh Venkataramanan * ice_service_task_complete - finish up the service task 1377940b61afSAnirudh Venkataramanan * @pf: board private structure 1378940b61afSAnirudh Venkataramanan */ 1379940b61afSAnirudh Venkataramanan static void ice_service_task_complete(struct ice_pf *pf) 1380940b61afSAnirudh Venkataramanan { 13817e408e07SAnirudh Venkataramanan WARN_ON(!test_bit(ICE_SERVICE_SCHED, pf->state)); 1382940b61afSAnirudh Venkataramanan 1383940b61afSAnirudh Venkataramanan /* force memory (pf->state) to sync before next service task */ 1384940b61afSAnirudh Venkataramanan smp_mb__before_atomic(); 13857e408e07SAnirudh Venkataramanan clear_bit(ICE_SERVICE_SCHED, pf->state); 1386940b61afSAnirudh Venkataramanan } 1387940b61afSAnirudh Venkataramanan 1388940b61afSAnirudh Venkataramanan /** 13898d81fa55SAkeem G Abodunrin * ice_service_task_stop - stop service task and cancel works 13908d81fa55SAkeem G Abodunrin * @pf: board private structure 1391769c500dSAkeem G Abodunrin * 13927e408e07SAnirudh Venkataramanan * Return 0 if the ICE_SERVICE_DIS bit was not already set, 1393769c500dSAkeem G Abodunrin * 1 otherwise. 13948d81fa55SAkeem G Abodunrin */ 1395769c500dSAkeem G Abodunrin static int ice_service_task_stop(struct ice_pf *pf) 13968d81fa55SAkeem G Abodunrin { 1397769c500dSAkeem G Abodunrin int ret; 1398769c500dSAkeem G Abodunrin 13997e408e07SAnirudh Venkataramanan ret = test_and_set_bit(ICE_SERVICE_DIS, pf->state); 14008d81fa55SAkeem G Abodunrin 14018d81fa55SAkeem G Abodunrin if (pf->serv_tmr.function) 14028d81fa55SAkeem G Abodunrin del_timer_sync(&pf->serv_tmr); 14038d81fa55SAkeem G Abodunrin if (pf->serv_task.func) 14048d81fa55SAkeem G Abodunrin cancel_work_sync(&pf->serv_task); 14058d81fa55SAkeem G Abodunrin 14067e408e07SAnirudh Venkataramanan clear_bit(ICE_SERVICE_SCHED, pf->state); 1407769c500dSAkeem G Abodunrin return ret; 14088d81fa55SAkeem G Abodunrin } 14098d81fa55SAkeem G Abodunrin 14108d81fa55SAkeem G Abodunrin /** 14115995b6d0SBrett Creeley * ice_service_task_restart - restart service task and schedule works 14125995b6d0SBrett Creeley * @pf: board private structure 14135995b6d0SBrett Creeley * 14145995b6d0SBrett Creeley * This function is needed for suspend and resume works (e.g WoL scenario) 14155995b6d0SBrett Creeley */ 14165995b6d0SBrett Creeley static void ice_service_task_restart(struct ice_pf *pf) 14175995b6d0SBrett Creeley { 14187e408e07SAnirudh Venkataramanan clear_bit(ICE_SERVICE_DIS, pf->state); 14195995b6d0SBrett Creeley ice_service_task_schedule(pf); 14205995b6d0SBrett Creeley } 14215995b6d0SBrett Creeley 14225995b6d0SBrett Creeley /** 1423940b61afSAnirudh Venkataramanan * ice_service_timer - timer callback to schedule service task 1424940b61afSAnirudh Venkataramanan * @t: pointer to timer_list 1425940b61afSAnirudh Venkataramanan */ 1426940b61afSAnirudh Venkataramanan static void ice_service_timer(struct timer_list *t) 1427940b61afSAnirudh Venkataramanan { 1428940b61afSAnirudh Venkataramanan struct ice_pf *pf = from_timer(pf, t, serv_tmr); 1429940b61afSAnirudh Venkataramanan 1430940b61afSAnirudh Venkataramanan mod_timer(&pf->serv_tmr, round_jiffies(pf->serv_tmr_period + jiffies)); 1431940b61afSAnirudh Venkataramanan ice_service_task_schedule(pf); 1432940b61afSAnirudh Venkataramanan } 1433940b61afSAnirudh Venkataramanan 1434940b61afSAnirudh Venkataramanan /** 1435b3969fd7SSudheer Mogilappagari * ice_handle_mdd_event - handle malicious driver detect event 1436b3969fd7SSudheer Mogilappagari * @pf: pointer to the PF structure 1437b3969fd7SSudheer Mogilappagari * 14389d5c5a52SPaul Greenwalt * Called from service task. OICR interrupt handler indicates MDD event. 14399d5c5a52SPaul Greenwalt * VF MDD logging is guarded by net_ratelimit. Additional PF and VF log 14409d5c5a52SPaul Greenwalt * messages are wrapped by netif_msg_[rx|tx]_err. Since VF Rx MDD events 14419d5c5a52SPaul Greenwalt * disable the queue, the PF can be configured to reset the VF using ethtool 14429d5c5a52SPaul Greenwalt * private flag mdd-auto-reset-vf. 1443b3969fd7SSudheer Mogilappagari */ 1444b3969fd7SSudheer Mogilappagari static void ice_handle_mdd_event(struct ice_pf *pf) 1445b3969fd7SSudheer Mogilappagari { 14464015d11eSBrett Creeley struct device *dev = ice_pf_to_dev(pf); 1447b3969fd7SSudheer Mogilappagari struct ice_hw *hw = &pf->hw; 1448c1e08830SJesse Brandeburg unsigned int i; 1449b3969fd7SSudheer Mogilappagari u32 reg; 1450b3969fd7SSudheer Mogilappagari 14517e408e07SAnirudh Venkataramanan if (!test_and_clear_bit(ICE_MDD_EVENT_PENDING, pf->state)) { 14529d5c5a52SPaul Greenwalt /* Since the VF MDD event logging is rate limited, check if 14539d5c5a52SPaul Greenwalt * there are pending MDD events. 14549d5c5a52SPaul Greenwalt */ 14559d5c5a52SPaul Greenwalt ice_print_vfs_mdd_events(pf); 1456b3969fd7SSudheer Mogilappagari return; 14579d5c5a52SPaul Greenwalt } 1458b3969fd7SSudheer Mogilappagari 14599d5c5a52SPaul Greenwalt /* find what triggered an MDD event */ 1460b3969fd7SSudheer Mogilappagari reg = rd32(hw, GL_MDET_TX_PQM); 1461b3969fd7SSudheer Mogilappagari if (reg & GL_MDET_TX_PQM_VALID_M) { 1462b3969fd7SSudheer Mogilappagari u8 pf_num = (reg & GL_MDET_TX_PQM_PF_NUM_M) >> 1463b3969fd7SSudheer Mogilappagari GL_MDET_TX_PQM_PF_NUM_S; 1464b3969fd7SSudheer Mogilappagari u16 vf_num = (reg & GL_MDET_TX_PQM_VF_NUM_M) >> 1465b3969fd7SSudheer Mogilappagari GL_MDET_TX_PQM_VF_NUM_S; 1466b3969fd7SSudheer Mogilappagari u8 event = (reg & GL_MDET_TX_PQM_MAL_TYPE_M) >> 1467b3969fd7SSudheer Mogilappagari GL_MDET_TX_PQM_MAL_TYPE_S; 1468b3969fd7SSudheer Mogilappagari u16 queue = ((reg & GL_MDET_TX_PQM_QNUM_M) >> 1469b3969fd7SSudheer Mogilappagari GL_MDET_TX_PQM_QNUM_S); 1470b3969fd7SSudheer Mogilappagari 1471b3969fd7SSudheer Mogilappagari if (netif_msg_tx_err(pf)) 14724015d11eSBrett Creeley dev_info(dev, "Malicious Driver Detection event %d on TX queue %d PF# %d VF# %d\n", 1473b3969fd7SSudheer Mogilappagari event, queue, pf_num, vf_num); 1474b3969fd7SSudheer Mogilappagari wr32(hw, GL_MDET_TX_PQM, 0xffffffff); 1475b3969fd7SSudheer Mogilappagari } 1476b3969fd7SSudheer Mogilappagari 1477b3969fd7SSudheer Mogilappagari reg = rd32(hw, GL_MDET_TX_TCLAN); 1478b3969fd7SSudheer Mogilappagari if (reg & GL_MDET_TX_TCLAN_VALID_M) { 1479b3969fd7SSudheer Mogilappagari u8 pf_num = (reg & GL_MDET_TX_TCLAN_PF_NUM_M) >> 1480b3969fd7SSudheer Mogilappagari GL_MDET_TX_TCLAN_PF_NUM_S; 1481b3969fd7SSudheer Mogilappagari u16 vf_num = (reg & GL_MDET_TX_TCLAN_VF_NUM_M) >> 1482b3969fd7SSudheer Mogilappagari GL_MDET_TX_TCLAN_VF_NUM_S; 1483b3969fd7SSudheer Mogilappagari u8 event = (reg & GL_MDET_TX_TCLAN_MAL_TYPE_M) >> 1484b3969fd7SSudheer Mogilappagari GL_MDET_TX_TCLAN_MAL_TYPE_S; 1485b3969fd7SSudheer Mogilappagari u16 queue = ((reg & GL_MDET_TX_TCLAN_QNUM_M) >> 1486b3969fd7SSudheer Mogilappagari GL_MDET_TX_TCLAN_QNUM_S); 1487b3969fd7SSudheer Mogilappagari 14881d8bd992SBen Shelton if (netif_msg_tx_err(pf)) 14894015d11eSBrett Creeley dev_info(dev, "Malicious Driver Detection event %d on TX queue %d PF# %d VF# %d\n", 1490b3969fd7SSudheer Mogilappagari event, queue, pf_num, vf_num); 1491b3969fd7SSudheer Mogilappagari wr32(hw, GL_MDET_TX_TCLAN, 0xffffffff); 1492b3969fd7SSudheer Mogilappagari } 1493b3969fd7SSudheer Mogilappagari 1494b3969fd7SSudheer Mogilappagari reg = rd32(hw, GL_MDET_RX); 1495b3969fd7SSudheer Mogilappagari if (reg & GL_MDET_RX_VALID_M) { 1496b3969fd7SSudheer Mogilappagari u8 pf_num = (reg & GL_MDET_RX_PF_NUM_M) >> 1497b3969fd7SSudheer Mogilappagari GL_MDET_RX_PF_NUM_S; 1498b3969fd7SSudheer Mogilappagari u16 vf_num = (reg & GL_MDET_RX_VF_NUM_M) >> 1499b3969fd7SSudheer Mogilappagari GL_MDET_RX_VF_NUM_S; 1500b3969fd7SSudheer Mogilappagari u8 event = (reg & GL_MDET_RX_MAL_TYPE_M) >> 1501b3969fd7SSudheer Mogilappagari GL_MDET_RX_MAL_TYPE_S; 1502b3969fd7SSudheer Mogilappagari u16 queue = ((reg & GL_MDET_RX_QNUM_M) >> 1503b3969fd7SSudheer Mogilappagari GL_MDET_RX_QNUM_S); 1504b3969fd7SSudheer Mogilappagari 1505b3969fd7SSudheer Mogilappagari if (netif_msg_rx_err(pf)) 15064015d11eSBrett Creeley dev_info(dev, "Malicious Driver Detection event %d on RX queue %d PF# %d VF# %d\n", 1507b3969fd7SSudheer Mogilappagari event, queue, pf_num, vf_num); 1508b3969fd7SSudheer Mogilappagari wr32(hw, GL_MDET_RX, 0xffffffff); 1509b3969fd7SSudheer Mogilappagari } 1510b3969fd7SSudheer Mogilappagari 15119d5c5a52SPaul Greenwalt /* check to see if this PF caused an MDD event */ 1512b3969fd7SSudheer Mogilappagari reg = rd32(hw, PF_MDET_TX_PQM); 1513b3969fd7SSudheer Mogilappagari if (reg & PF_MDET_TX_PQM_VALID_M) { 1514b3969fd7SSudheer Mogilappagari wr32(hw, PF_MDET_TX_PQM, 0xFFFF); 15159d5c5a52SPaul Greenwalt if (netif_msg_tx_err(pf)) 15169d5c5a52SPaul Greenwalt dev_info(dev, "Malicious Driver Detection event TX_PQM detected on PF\n"); 1517b3969fd7SSudheer Mogilappagari } 1518b3969fd7SSudheer Mogilappagari 1519b3969fd7SSudheer Mogilappagari reg = rd32(hw, PF_MDET_TX_TCLAN); 1520b3969fd7SSudheer Mogilappagari if (reg & PF_MDET_TX_TCLAN_VALID_M) { 1521b3969fd7SSudheer Mogilappagari wr32(hw, PF_MDET_TX_TCLAN, 0xFFFF); 15229d5c5a52SPaul Greenwalt if (netif_msg_tx_err(pf)) 15239d5c5a52SPaul Greenwalt dev_info(dev, "Malicious Driver Detection event TX_TCLAN detected on PF\n"); 1524b3969fd7SSudheer Mogilappagari } 1525b3969fd7SSudheer Mogilappagari 1526b3969fd7SSudheer Mogilappagari reg = rd32(hw, PF_MDET_RX); 1527b3969fd7SSudheer Mogilappagari if (reg & PF_MDET_RX_VALID_M) { 1528b3969fd7SSudheer Mogilappagari wr32(hw, PF_MDET_RX, 0xFFFF); 15299d5c5a52SPaul Greenwalt if (netif_msg_rx_err(pf)) 15309d5c5a52SPaul Greenwalt dev_info(dev, "Malicious Driver Detection event RX detected on PF\n"); 1531b3969fd7SSudheer Mogilappagari } 1532b3969fd7SSudheer Mogilappagari 15339d5c5a52SPaul Greenwalt /* Check to see if one of the VFs caused an MDD event, and then 15349d5c5a52SPaul Greenwalt * increment counters and set print pending 15359d5c5a52SPaul Greenwalt */ 1536005881bcSBrett Creeley ice_for_each_vf(pf, i) { 15377c4bc1f5SAnirudh Venkataramanan struct ice_vf *vf = &pf->vf[i]; 15387c4bc1f5SAnirudh Venkataramanan 15397c4bc1f5SAnirudh Venkataramanan reg = rd32(hw, VP_MDET_TX_PQM(i)); 15407c4bc1f5SAnirudh Venkataramanan if (reg & VP_MDET_TX_PQM_VALID_M) { 15417c4bc1f5SAnirudh Venkataramanan wr32(hw, VP_MDET_TX_PQM(i), 0xFFFF); 15429d5c5a52SPaul Greenwalt vf->mdd_tx_events.count++; 15437e408e07SAnirudh Venkataramanan set_bit(ICE_MDD_VF_PRINT_PENDING, pf->state); 15449d5c5a52SPaul Greenwalt if (netif_msg_tx_err(pf)) 15459d5c5a52SPaul Greenwalt dev_info(dev, "Malicious Driver Detection event TX_PQM detected on VF %d\n", 15467c4bc1f5SAnirudh Venkataramanan i); 15477c4bc1f5SAnirudh Venkataramanan } 15487c4bc1f5SAnirudh Venkataramanan 15497c4bc1f5SAnirudh Venkataramanan reg = rd32(hw, VP_MDET_TX_TCLAN(i)); 15507c4bc1f5SAnirudh Venkataramanan if (reg & VP_MDET_TX_TCLAN_VALID_M) { 15517c4bc1f5SAnirudh Venkataramanan wr32(hw, VP_MDET_TX_TCLAN(i), 0xFFFF); 15529d5c5a52SPaul Greenwalt vf->mdd_tx_events.count++; 15537e408e07SAnirudh Venkataramanan set_bit(ICE_MDD_VF_PRINT_PENDING, pf->state); 15549d5c5a52SPaul Greenwalt if (netif_msg_tx_err(pf)) 15559d5c5a52SPaul Greenwalt dev_info(dev, "Malicious Driver Detection event TX_TCLAN detected on VF %d\n", 15567c4bc1f5SAnirudh Venkataramanan i); 15577c4bc1f5SAnirudh Venkataramanan } 15587c4bc1f5SAnirudh Venkataramanan 15597c4bc1f5SAnirudh Venkataramanan reg = rd32(hw, VP_MDET_TX_TDPU(i)); 15607c4bc1f5SAnirudh Venkataramanan if (reg & VP_MDET_TX_TDPU_VALID_M) { 15617c4bc1f5SAnirudh Venkataramanan wr32(hw, VP_MDET_TX_TDPU(i), 0xFFFF); 15629d5c5a52SPaul Greenwalt vf->mdd_tx_events.count++; 15637e408e07SAnirudh Venkataramanan set_bit(ICE_MDD_VF_PRINT_PENDING, pf->state); 15649d5c5a52SPaul Greenwalt if (netif_msg_tx_err(pf)) 15659d5c5a52SPaul Greenwalt dev_info(dev, "Malicious Driver Detection event TX_TDPU detected on VF %d\n", 15667c4bc1f5SAnirudh Venkataramanan i); 15677c4bc1f5SAnirudh Venkataramanan } 15687c4bc1f5SAnirudh Venkataramanan 15697c4bc1f5SAnirudh Venkataramanan reg = rd32(hw, VP_MDET_RX(i)); 15707c4bc1f5SAnirudh Venkataramanan if (reg & VP_MDET_RX_VALID_M) { 15717c4bc1f5SAnirudh Venkataramanan wr32(hw, VP_MDET_RX(i), 0xFFFF); 15729d5c5a52SPaul Greenwalt vf->mdd_rx_events.count++; 15737e408e07SAnirudh Venkataramanan set_bit(ICE_MDD_VF_PRINT_PENDING, pf->state); 15749d5c5a52SPaul Greenwalt if (netif_msg_rx_err(pf)) 15759d5c5a52SPaul Greenwalt dev_info(dev, "Malicious Driver Detection event RX detected on VF %d\n", 15767c4bc1f5SAnirudh Venkataramanan i); 15779d5c5a52SPaul Greenwalt 15789d5c5a52SPaul Greenwalt /* Since the queue is disabled on VF Rx MDD events, the 15799d5c5a52SPaul Greenwalt * PF can be configured to reset the VF through ethtool 15809d5c5a52SPaul Greenwalt * private flag mdd-auto-reset-vf. 15819d5c5a52SPaul Greenwalt */ 15827438a3b0SPaul Greenwalt if (test_bit(ICE_FLAG_MDD_AUTO_RESET_VF, pf->flags)) { 15837438a3b0SPaul Greenwalt /* VF MDD event counters will be cleared by 15847438a3b0SPaul Greenwalt * reset, so print the event prior to reset. 15857438a3b0SPaul Greenwalt */ 15867438a3b0SPaul Greenwalt ice_print_vf_rx_mdd_event(vf); 15879d5c5a52SPaul Greenwalt ice_reset_vf(&pf->vf[i], false); 15889d5c5a52SPaul Greenwalt } 15897c4bc1f5SAnirudh Venkataramanan } 15907438a3b0SPaul Greenwalt } 15917c4bc1f5SAnirudh Venkataramanan 15929d5c5a52SPaul Greenwalt ice_print_vfs_mdd_events(pf); 1593b3969fd7SSudheer Mogilappagari } 1594b3969fd7SSudheer Mogilappagari 1595b3969fd7SSudheer Mogilappagari /** 15966d599946STony Nguyen * ice_force_phys_link_state - Force the physical link state 15976d599946STony Nguyen * @vsi: VSI to force the physical link state to up/down 15986d599946STony Nguyen * @link_up: true/false indicates to set the physical link to up/down 15996d599946STony Nguyen * 16006d599946STony Nguyen * Force the physical link state by getting the current PHY capabilities from 16016d599946STony Nguyen * hardware and setting the PHY config based on the determined capabilities. If 16026d599946STony Nguyen * link changes a link event will be triggered because both the Enable Automatic 16036d599946STony Nguyen * Link Update and LESM Enable bits are set when setting the PHY capabilities. 16046d599946STony Nguyen * 16056d599946STony Nguyen * Returns 0 on success, negative on failure 16066d599946STony Nguyen */ 16076d599946STony Nguyen static int ice_force_phys_link_state(struct ice_vsi *vsi, bool link_up) 16086d599946STony Nguyen { 16096d599946STony Nguyen struct ice_aqc_get_phy_caps_data *pcaps; 16106d599946STony Nguyen struct ice_aqc_set_phy_cfg_data *cfg; 16116d599946STony Nguyen struct ice_port_info *pi; 16126d599946STony Nguyen struct device *dev; 16136d599946STony Nguyen int retcode; 16146d599946STony Nguyen 16156d599946STony Nguyen if (!vsi || !vsi->port_info || !vsi->back) 16166d599946STony Nguyen return -EINVAL; 16176d599946STony Nguyen if (vsi->type != ICE_VSI_PF) 16186d599946STony Nguyen return 0; 16196d599946STony Nguyen 16209a946843SAnirudh Venkataramanan dev = ice_pf_to_dev(vsi->back); 16216d599946STony Nguyen 16226d599946STony Nguyen pi = vsi->port_info; 16236d599946STony Nguyen 16249efe35d0STony Nguyen pcaps = kzalloc(sizeof(*pcaps), GFP_KERNEL); 16256d599946STony Nguyen if (!pcaps) 16266d599946STony Nguyen return -ENOMEM; 16276d599946STony Nguyen 1628d6730a87SAnirudh Venkataramanan retcode = ice_aq_get_phy_caps(pi, false, ICE_AQC_REPORT_ACTIVE_CFG, pcaps, 16296d599946STony Nguyen NULL); 16306d599946STony Nguyen if (retcode) { 163119cce2c6SAnirudh Venkataramanan dev_err(dev, "Failed to get phy capabilities, VSI %d error %d\n", 16326d599946STony Nguyen vsi->vsi_num, retcode); 16336d599946STony Nguyen retcode = -EIO; 16346d599946STony Nguyen goto out; 16356d599946STony Nguyen } 16366d599946STony Nguyen 16376d599946STony Nguyen /* No change in link */ 16386d599946STony Nguyen if (link_up == !!(pcaps->caps & ICE_AQC_PHY_EN_LINK) && 16396d599946STony Nguyen link_up == !!(pi->phy.link_info.link_info & ICE_AQ_LINK_UP)) 16406d599946STony Nguyen goto out; 16416d599946STony Nguyen 16421a3571b5SPaul Greenwalt /* Use the current user PHY configuration. The current user PHY 16431a3571b5SPaul Greenwalt * configuration is initialized during probe from PHY capabilities 16441a3571b5SPaul Greenwalt * software mode, and updated on set PHY configuration. 16451a3571b5SPaul Greenwalt */ 16461a3571b5SPaul Greenwalt cfg = kmemdup(&pi->phy.curr_user_phy_cfg, sizeof(*cfg), GFP_KERNEL); 16476d599946STony Nguyen if (!cfg) { 16486d599946STony Nguyen retcode = -ENOMEM; 16496d599946STony Nguyen goto out; 16506d599946STony Nguyen } 16516d599946STony Nguyen 16521a3571b5SPaul Greenwalt cfg->caps |= ICE_AQ_PHY_ENA_AUTO_LINK_UPDT; 16536d599946STony Nguyen if (link_up) 16546d599946STony Nguyen cfg->caps |= ICE_AQ_PHY_ENA_LINK; 16556d599946STony Nguyen else 16566d599946STony Nguyen cfg->caps &= ~ICE_AQ_PHY_ENA_LINK; 16576d599946STony Nguyen 16581a3571b5SPaul Greenwalt retcode = ice_aq_set_phy_cfg(&vsi->back->hw, pi, cfg, NULL); 16596d599946STony Nguyen if (retcode) { 16606d599946STony Nguyen dev_err(dev, "Failed to set phy config, VSI %d error %d\n", 16616d599946STony Nguyen vsi->vsi_num, retcode); 16626d599946STony Nguyen retcode = -EIO; 16636d599946STony Nguyen } 16646d599946STony Nguyen 16659efe35d0STony Nguyen kfree(cfg); 16666d599946STony Nguyen out: 16679efe35d0STony Nguyen kfree(pcaps); 16686d599946STony Nguyen return retcode; 16696d599946STony Nguyen } 16706d599946STony Nguyen 16716d599946STony Nguyen /** 16721a3571b5SPaul Greenwalt * ice_init_nvm_phy_type - Initialize the NVM PHY type 16731a3571b5SPaul Greenwalt * @pi: port info structure 16741a3571b5SPaul Greenwalt * 1675ea78ce4dSPaul Greenwalt * Initialize nvm_phy_type_[low|high] for link lenient mode support 16761a3571b5SPaul Greenwalt */ 16771a3571b5SPaul Greenwalt static int ice_init_nvm_phy_type(struct ice_port_info *pi) 16781a3571b5SPaul Greenwalt { 16791a3571b5SPaul Greenwalt struct ice_aqc_get_phy_caps_data *pcaps; 16801a3571b5SPaul Greenwalt struct ice_pf *pf = pi->hw->back; 16811a3571b5SPaul Greenwalt enum ice_status status; 16821a3571b5SPaul Greenwalt int err = 0; 16831a3571b5SPaul Greenwalt 16841a3571b5SPaul Greenwalt pcaps = kzalloc(sizeof(*pcaps), GFP_KERNEL); 16851a3571b5SPaul Greenwalt if (!pcaps) 16861a3571b5SPaul Greenwalt return -ENOMEM; 16871a3571b5SPaul Greenwalt 1688d6730a87SAnirudh Venkataramanan status = ice_aq_get_phy_caps(pi, false, ICE_AQC_REPORT_TOPO_CAP_NO_MEDIA, pcaps, 16891a3571b5SPaul Greenwalt NULL); 16901a3571b5SPaul Greenwalt 16911a3571b5SPaul Greenwalt if (status) { 16921a3571b5SPaul Greenwalt dev_err(ice_pf_to_dev(pf), "Get PHY capability failed.\n"); 16931a3571b5SPaul Greenwalt err = -EIO; 16941a3571b5SPaul Greenwalt goto out; 16951a3571b5SPaul Greenwalt } 16961a3571b5SPaul Greenwalt 16971a3571b5SPaul Greenwalt pf->nvm_phy_type_hi = pcaps->phy_type_high; 16981a3571b5SPaul Greenwalt pf->nvm_phy_type_lo = pcaps->phy_type_low; 16991a3571b5SPaul Greenwalt 17001a3571b5SPaul Greenwalt out: 17011a3571b5SPaul Greenwalt kfree(pcaps); 17021a3571b5SPaul Greenwalt return err; 17031a3571b5SPaul Greenwalt } 17041a3571b5SPaul Greenwalt 17051a3571b5SPaul Greenwalt /** 1706ea78ce4dSPaul Greenwalt * ice_init_link_dflt_override - Initialize link default override 1707ea78ce4dSPaul Greenwalt * @pi: port info structure 1708b4e813ddSBruce Allan * 1709b4e813ddSBruce Allan * Initialize link default override and PHY total port shutdown during probe 1710ea78ce4dSPaul Greenwalt */ 1711ea78ce4dSPaul Greenwalt static void ice_init_link_dflt_override(struct ice_port_info *pi) 1712ea78ce4dSPaul Greenwalt { 1713ea78ce4dSPaul Greenwalt struct ice_link_default_override_tlv *ldo; 1714ea78ce4dSPaul Greenwalt struct ice_pf *pf = pi->hw->back; 1715ea78ce4dSPaul Greenwalt 1716ea78ce4dSPaul Greenwalt ldo = &pf->link_dflt_override; 1717b4e813ddSBruce Allan if (ice_get_link_default_override(ldo, pi)) 1718b4e813ddSBruce Allan return; 1719b4e813ddSBruce Allan 1720b4e813ddSBruce Allan if (!(ldo->options & ICE_LINK_OVERRIDE_PORT_DIS)) 1721b4e813ddSBruce Allan return; 1722b4e813ddSBruce Allan 1723b4e813ddSBruce Allan /* Enable Total Port Shutdown (override/replace link-down-on-close 1724b4e813ddSBruce Allan * ethtool private flag) for ports with Port Disable bit set. 1725b4e813ddSBruce Allan */ 1726b4e813ddSBruce Allan set_bit(ICE_FLAG_TOTAL_PORT_SHUTDOWN_ENA, pf->flags); 1727b4e813ddSBruce Allan set_bit(ICE_FLAG_LINK_DOWN_ON_CLOSE_ENA, pf->flags); 1728ea78ce4dSPaul Greenwalt } 1729ea78ce4dSPaul Greenwalt 1730ea78ce4dSPaul Greenwalt /** 1731ea78ce4dSPaul Greenwalt * ice_init_phy_cfg_dflt_override - Initialize PHY cfg default override settings 1732ea78ce4dSPaul Greenwalt * @pi: port info structure 1733ea78ce4dSPaul Greenwalt * 17340a02944fSAnirudh Venkataramanan * If default override is enabled, initialize the user PHY cfg speed and FEC 1735ea78ce4dSPaul Greenwalt * settings using the default override mask from the NVM. 1736ea78ce4dSPaul Greenwalt * 1737ea78ce4dSPaul Greenwalt * The PHY should only be configured with the default override settings the 17387e408e07SAnirudh Venkataramanan * first time media is available. The ICE_LINK_DEFAULT_OVERRIDE_PENDING state 1739ea78ce4dSPaul Greenwalt * is used to indicate that the user PHY cfg default override is initialized 1740ea78ce4dSPaul Greenwalt * and the PHY has not been configured with the default override settings. The 1741ea78ce4dSPaul Greenwalt * state is set here, and cleared in ice_configure_phy the first time the PHY is 1742ea78ce4dSPaul Greenwalt * configured. 17430a02944fSAnirudh Venkataramanan * 17440a02944fSAnirudh Venkataramanan * This function should be called only if the FW doesn't support default 17450a02944fSAnirudh Venkataramanan * configuration mode, as reported by ice_fw_supports_report_dflt_cfg. 1746ea78ce4dSPaul Greenwalt */ 1747ea78ce4dSPaul Greenwalt static void ice_init_phy_cfg_dflt_override(struct ice_port_info *pi) 1748ea78ce4dSPaul Greenwalt { 1749ea78ce4dSPaul Greenwalt struct ice_link_default_override_tlv *ldo; 1750ea78ce4dSPaul Greenwalt struct ice_aqc_set_phy_cfg_data *cfg; 1751ea78ce4dSPaul Greenwalt struct ice_phy_info *phy = &pi->phy; 1752ea78ce4dSPaul Greenwalt struct ice_pf *pf = pi->hw->back; 1753ea78ce4dSPaul Greenwalt 1754ea78ce4dSPaul Greenwalt ldo = &pf->link_dflt_override; 1755ea78ce4dSPaul Greenwalt 1756ea78ce4dSPaul Greenwalt /* If link default override is enabled, use to mask NVM PHY capabilities 1757ea78ce4dSPaul Greenwalt * for speed and FEC default configuration. 1758ea78ce4dSPaul Greenwalt */ 1759ea78ce4dSPaul Greenwalt cfg = &phy->curr_user_phy_cfg; 1760ea78ce4dSPaul Greenwalt 1761ea78ce4dSPaul Greenwalt if (ldo->phy_type_low || ldo->phy_type_high) { 1762ea78ce4dSPaul Greenwalt cfg->phy_type_low = pf->nvm_phy_type_lo & 1763ea78ce4dSPaul Greenwalt cpu_to_le64(ldo->phy_type_low); 1764ea78ce4dSPaul Greenwalt cfg->phy_type_high = pf->nvm_phy_type_hi & 1765ea78ce4dSPaul Greenwalt cpu_to_le64(ldo->phy_type_high); 1766ea78ce4dSPaul Greenwalt } 1767ea78ce4dSPaul Greenwalt cfg->link_fec_opt = ldo->fec_options; 1768ea78ce4dSPaul Greenwalt phy->curr_user_fec_req = ICE_FEC_AUTO; 1769ea78ce4dSPaul Greenwalt 17707e408e07SAnirudh Venkataramanan set_bit(ICE_LINK_DEFAULT_OVERRIDE_PENDING, pf->state); 1771ea78ce4dSPaul Greenwalt } 1772ea78ce4dSPaul Greenwalt 1773ea78ce4dSPaul Greenwalt /** 17741a3571b5SPaul Greenwalt * ice_init_phy_user_cfg - Initialize the PHY user configuration 17751a3571b5SPaul Greenwalt * @pi: port info structure 17761a3571b5SPaul Greenwalt * 17771a3571b5SPaul Greenwalt * Initialize the current user PHY configuration, speed, FEC, and FC requested 17781a3571b5SPaul Greenwalt * mode to default. The PHY defaults are from get PHY capabilities topology 17791a3571b5SPaul Greenwalt * with media so call when media is first available. An error is returned if 17801a3571b5SPaul Greenwalt * called when media is not available. The PHY initialization completed state is 17811a3571b5SPaul Greenwalt * set here. 17821a3571b5SPaul Greenwalt * 17831a3571b5SPaul Greenwalt * These configurations are used when setting PHY 17841a3571b5SPaul Greenwalt * configuration. The user PHY configuration is updated on set PHY 17851a3571b5SPaul Greenwalt * configuration. Returns 0 on success, negative on failure 17861a3571b5SPaul Greenwalt */ 17871a3571b5SPaul Greenwalt static int ice_init_phy_user_cfg(struct ice_port_info *pi) 17881a3571b5SPaul Greenwalt { 17891a3571b5SPaul Greenwalt struct ice_aqc_get_phy_caps_data *pcaps; 17901a3571b5SPaul Greenwalt struct ice_phy_info *phy = &pi->phy; 17911a3571b5SPaul Greenwalt struct ice_pf *pf = pi->hw->back; 17921a3571b5SPaul Greenwalt enum ice_status status; 17931a3571b5SPaul Greenwalt int err = 0; 17941a3571b5SPaul Greenwalt 17951a3571b5SPaul Greenwalt if (!(phy->link_info.link_info & ICE_AQ_MEDIA_AVAILABLE)) 17961a3571b5SPaul Greenwalt return -EIO; 17971a3571b5SPaul Greenwalt 17981a3571b5SPaul Greenwalt pcaps = kzalloc(sizeof(*pcaps), GFP_KERNEL); 17991a3571b5SPaul Greenwalt if (!pcaps) 18001a3571b5SPaul Greenwalt return -ENOMEM; 18011a3571b5SPaul Greenwalt 18020a02944fSAnirudh Venkataramanan if (ice_fw_supports_report_dflt_cfg(pi->hw)) 18030a02944fSAnirudh Venkataramanan status = ice_aq_get_phy_caps(pi, false, ICE_AQC_REPORT_DFLT_CFG, 18040a02944fSAnirudh Venkataramanan pcaps, NULL); 18050a02944fSAnirudh Venkataramanan else 18060a02944fSAnirudh Venkataramanan status = ice_aq_get_phy_caps(pi, false, ICE_AQC_REPORT_TOPO_CAP_MEDIA, 18070a02944fSAnirudh Venkataramanan pcaps, NULL); 18081a3571b5SPaul Greenwalt if (status) { 18091a3571b5SPaul Greenwalt dev_err(ice_pf_to_dev(pf), "Get PHY capability failed.\n"); 18101a3571b5SPaul Greenwalt err = -EIO; 18111a3571b5SPaul Greenwalt goto err_out; 18121a3571b5SPaul Greenwalt } 18131a3571b5SPaul Greenwalt 1814ea78ce4dSPaul Greenwalt ice_copy_phy_caps_to_cfg(pi, pcaps, &pi->phy.curr_user_phy_cfg); 1815ea78ce4dSPaul Greenwalt 1816ea78ce4dSPaul Greenwalt /* check if lenient mode is supported and enabled */ 1817dc6aaa13SAnirudh Venkataramanan if (ice_fw_supports_link_override(pi->hw) && 1818ea78ce4dSPaul Greenwalt !(pcaps->module_compliance_enforcement & 1819ea78ce4dSPaul Greenwalt ICE_AQC_MOD_ENFORCE_STRICT_MODE)) { 1820ea78ce4dSPaul Greenwalt set_bit(ICE_FLAG_LINK_LENIENT_MODE_ENA, pf->flags); 1821ea78ce4dSPaul Greenwalt 18220a02944fSAnirudh Venkataramanan /* if the FW supports default PHY configuration mode, then the driver 18230a02944fSAnirudh Venkataramanan * does not have to apply link override settings. If not, 18240a02944fSAnirudh Venkataramanan * initialize user PHY configuration with link override values 1825ea78ce4dSPaul Greenwalt */ 18260a02944fSAnirudh Venkataramanan if (!ice_fw_supports_report_dflt_cfg(pi->hw) && 18270a02944fSAnirudh Venkataramanan (pf->link_dflt_override.options & ICE_LINK_OVERRIDE_EN)) { 1828ea78ce4dSPaul Greenwalt ice_init_phy_cfg_dflt_override(pi); 1829ea78ce4dSPaul Greenwalt goto out; 1830ea78ce4dSPaul Greenwalt } 1831ea78ce4dSPaul Greenwalt } 1832ea78ce4dSPaul Greenwalt 18330a02944fSAnirudh Venkataramanan /* if link default override is not enabled, set user flow control and 18340a02944fSAnirudh Venkataramanan * FEC settings based on what get_phy_caps returned 1835ea78ce4dSPaul Greenwalt */ 18361a3571b5SPaul Greenwalt phy->curr_user_fec_req = ice_caps_to_fec_mode(pcaps->caps, 18371a3571b5SPaul Greenwalt pcaps->link_fec_options); 18381a3571b5SPaul Greenwalt phy->curr_user_fc_req = ice_caps_to_fc_mode(pcaps->caps); 18391a3571b5SPaul Greenwalt 1840ea78ce4dSPaul Greenwalt out: 18411a3571b5SPaul Greenwalt phy->curr_user_speed_req = ICE_AQ_LINK_SPEED_M; 18427e408e07SAnirudh Venkataramanan set_bit(ICE_PHY_INIT_COMPLETE, pf->state); 18431a3571b5SPaul Greenwalt err_out: 18441a3571b5SPaul Greenwalt kfree(pcaps); 18451a3571b5SPaul Greenwalt return err; 18461a3571b5SPaul Greenwalt } 18471a3571b5SPaul Greenwalt 18481a3571b5SPaul Greenwalt /** 18491a3571b5SPaul Greenwalt * ice_configure_phy - configure PHY 18501a3571b5SPaul Greenwalt * @vsi: VSI of PHY 18511a3571b5SPaul Greenwalt * 18521a3571b5SPaul Greenwalt * Set the PHY configuration. If the current PHY configuration is the same as 18531a3571b5SPaul Greenwalt * the curr_user_phy_cfg, then do nothing to avoid link flap. Otherwise 18541a3571b5SPaul Greenwalt * configure the based get PHY capabilities for topology with media. 18551a3571b5SPaul Greenwalt */ 18561a3571b5SPaul Greenwalt static int ice_configure_phy(struct ice_vsi *vsi) 18571a3571b5SPaul Greenwalt { 18581a3571b5SPaul Greenwalt struct device *dev = ice_pf_to_dev(vsi->back); 1859efc1eddbSAnirudh Venkataramanan struct ice_port_info *pi = vsi->port_info; 18601a3571b5SPaul Greenwalt struct ice_aqc_get_phy_caps_data *pcaps; 18611a3571b5SPaul Greenwalt struct ice_aqc_set_phy_cfg_data *cfg; 1862efc1eddbSAnirudh Venkataramanan struct ice_phy_info *phy = &pi->phy; 1863efc1eddbSAnirudh Venkataramanan struct ice_pf *pf = vsi->back; 18641a3571b5SPaul Greenwalt enum ice_status status; 18651a3571b5SPaul Greenwalt int err = 0; 18661a3571b5SPaul Greenwalt 18671a3571b5SPaul Greenwalt /* Ensure we have media as we cannot configure a medialess port */ 1868efc1eddbSAnirudh Venkataramanan if (!(phy->link_info.link_info & ICE_AQ_MEDIA_AVAILABLE)) 18691a3571b5SPaul Greenwalt return -EPERM; 18701a3571b5SPaul Greenwalt 18711a3571b5SPaul Greenwalt ice_print_topo_conflict(vsi); 18721a3571b5SPaul Greenwalt 1873efc1eddbSAnirudh Venkataramanan if (phy->link_info.topo_media_conflict == ICE_AQ_LINK_TOPO_UNSUPP_MEDIA) 18741a3571b5SPaul Greenwalt return -EPERM; 18751a3571b5SPaul Greenwalt 1876efc1eddbSAnirudh Venkataramanan if (test_bit(ICE_FLAG_LINK_DOWN_ON_CLOSE_ENA, pf->flags)) 18771a3571b5SPaul Greenwalt return ice_force_phys_link_state(vsi, true); 18781a3571b5SPaul Greenwalt 18791a3571b5SPaul Greenwalt pcaps = kzalloc(sizeof(*pcaps), GFP_KERNEL); 18801a3571b5SPaul Greenwalt if (!pcaps) 18811a3571b5SPaul Greenwalt return -ENOMEM; 18821a3571b5SPaul Greenwalt 18831a3571b5SPaul Greenwalt /* Get current PHY config */ 1884d6730a87SAnirudh Venkataramanan status = ice_aq_get_phy_caps(pi, false, ICE_AQC_REPORT_ACTIVE_CFG, pcaps, 18851a3571b5SPaul Greenwalt NULL); 18861a3571b5SPaul Greenwalt if (status) { 18871a3571b5SPaul Greenwalt dev_err(dev, "Failed to get PHY configuration, VSI %d error %s\n", 18881a3571b5SPaul Greenwalt vsi->vsi_num, ice_stat_str(status)); 18891a3571b5SPaul Greenwalt err = -EIO; 18901a3571b5SPaul Greenwalt goto done; 18911a3571b5SPaul Greenwalt } 18921a3571b5SPaul Greenwalt 18931a3571b5SPaul Greenwalt /* If PHY enable link is configured and configuration has not changed, 18941a3571b5SPaul Greenwalt * there's nothing to do 18951a3571b5SPaul Greenwalt */ 18961a3571b5SPaul Greenwalt if (pcaps->caps & ICE_AQC_PHY_EN_LINK && 1897efc1eddbSAnirudh Venkataramanan ice_phy_caps_equals_cfg(pcaps, &phy->curr_user_phy_cfg)) 18981a3571b5SPaul Greenwalt goto done; 18991a3571b5SPaul Greenwalt 19001a3571b5SPaul Greenwalt /* Use PHY topology as baseline for configuration */ 19011a3571b5SPaul Greenwalt memset(pcaps, 0, sizeof(*pcaps)); 19020a02944fSAnirudh Venkataramanan if (ice_fw_supports_report_dflt_cfg(pi->hw)) 19030a02944fSAnirudh Venkataramanan status = ice_aq_get_phy_caps(pi, false, ICE_AQC_REPORT_DFLT_CFG, 19040a02944fSAnirudh Venkataramanan pcaps, NULL); 19050a02944fSAnirudh Venkataramanan else 19060a02944fSAnirudh Venkataramanan status = ice_aq_get_phy_caps(pi, false, ICE_AQC_REPORT_TOPO_CAP_MEDIA, 19070a02944fSAnirudh Venkataramanan pcaps, NULL); 19081a3571b5SPaul Greenwalt if (status) { 19090a02944fSAnirudh Venkataramanan dev_err(dev, "Failed to get PHY caps, VSI %d error %s\n", 19101a3571b5SPaul Greenwalt vsi->vsi_num, ice_stat_str(status)); 19111a3571b5SPaul Greenwalt err = -EIO; 19121a3571b5SPaul Greenwalt goto done; 19131a3571b5SPaul Greenwalt } 19141a3571b5SPaul Greenwalt 19151a3571b5SPaul Greenwalt cfg = kzalloc(sizeof(*cfg), GFP_KERNEL); 19161a3571b5SPaul Greenwalt if (!cfg) { 19171a3571b5SPaul Greenwalt err = -ENOMEM; 19181a3571b5SPaul Greenwalt goto done; 19191a3571b5SPaul Greenwalt } 19201a3571b5SPaul Greenwalt 1921ea78ce4dSPaul Greenwalt ice_copy_phy_caps_to_cfg(pi, pcaps, cfg); 19221a3571b5SPaul Greenwalt 19231a3571b5SPaul Greenwalt /* Speed - If default override pending, use curr_user_phy_cfg set in 19241a3571b5SPaul Greenwalt * ice_init_phy_user_cfg_ldo. 19251a3571b5SPaul Greenwalt */ 19267e408e07SAnirudh Venkataramanan if (test_and_clear_bit(ICE_LINK_DEFAULT_OVERRIDE_PENDING, 1927ea78ce4dSPaul Greenwalt vsi->back->state)) { 1928efc1eddbSAnirudh Venkataramanan cfg->phy_type_low = phy->curr_user_phy_cfg.phy_type_low; 1929efc1eddbSAnirudh Venkataramanan cfg->phy_type_high = phy->curr_user_phy_cfg.phy_type_high; 1930ea78ce4dSPaul Greenwalt } else { 1931ea78ce4dSPaul Greenwalt u64 phy_low = 0, phy_high = 0; 1932ea78ce4dSPaul Greenwalt 1933ea78ce4dSPaul Greenwalt ice_update_phy_type(&phy_low, &phy_high, 1934ea78ce4dSPaul Greenwalt pi->phy.curr_user_speed_req); 19351a3571b5SPaul Greenwalt cfg->phy_type_low = pcaps->phy_type_low & cpu_to_le64(phy_low); 1936ea78ce4dSPaul Greenwalt cfg->phy_type_high = pcaps->phy_type_high & 1937ea78ce4dSPaul Greenwalt cpu_to_le64(phy_high); 1938ea78ce4dSPaul Greenwalt } 19391a3571b5SPaul Greenwalt 19401a3571b5SPaul Greenwalt /* Can't provide what was requested; use PHY capabilities */ 19411a3571b5SPaul Greenwalt if (!cfg->phy_type_low && !cfg->phy_type_high) { 19421a3571b5SPaul Greenwalt cfg->phy_type_low = pcaps->phy_type_low; 19431a3571b5SPaul Greenwalt cfg->phy_type_high = pcaps->phy_type_high; 19441a3571b5SPaul Greenwalt } 19451a3571b5SPaul Greenwalt 19461a3571b5SPaul Greenwalt /* FEC */ 1947efc1eddbSAnirudh Venkataramanan ice_cfg_phy_fec(pi, cfg, phy->curr_user_fec_req); 19481a3571b5SPaul Greenwalt 19491a3571b5SPaul Greenwalt /* Can't provide what was requested; use PHY capabilities */ 19501a3571b5SPaul Greenwalt if (cfg->link_fec_opt != 19511a3571b5SPaul Greenwalt (cfg->link_fec_opt & pcaps->link_fec_options)) { 19521a3571b5SPaul Greenwalt cfg->caps |= pcaps->caps & ICE_AQC_PHY_EN_AUTO_FEC; 19531a3571b5SPaul Greenwalt cfg->link_fec_opt = pcaps->link_fec_options; 19541a3571b5SPaul Greenwalt } 19551a3571b5SPaul Greenwalt 19561a3571b5SPaul Greenwalt /* Flow Control - always supported; no need to check against 19571a3571b5SPaul Greenwalt * capabilities 19581a3571b5SPaul Greenwalt */ 1959efc1eddbSAnirudh Venkataramanan ice_cfg_phy_fc(pi, cfg, phy->curr_user_fc_req); 19601a3571b5SPaul Greenwalt 19611a3571b5SPaul Greenwalt /* Enable link and link update */ 19621a3571b5SPaul Greenwalt cfg->caps |= ICE_AQ_PHY_ENA_AUTO_LINK_UPDT | ICE_AQ_PHY_ENA_LINK; 19631a3571b5SPaul Greenwalt 1964efc1eddbSAnirudh Venkataramanan status = ice_aq_set_phy_cfg(&pf->hw, pi, cfg, NULL); 19651a3571b5SPaul Greenwalt if (status) { 19661a3571b5SPaul Greenwalt dev_err(dev, "Failed to set phy config, VSI %d error %s\n", 19671a3571b5SPaul Greenwalt vsi->vsi_num, ice_stat_str(status)); 19681a3571b5SPaul Greenwalt err = -EIO; 19691a3571b5SPaul Greenwalt } 19701a3571b5SPaul Greenwalt 19711a3571b5SPaul Greenwalt kfree(cfg); 19721a3571b5SPaul Greenwalt done: 19731a3571b5SPaul Greenwalt kfree(pcaps); 19741a3571b5SPaul Greenwalt return err; 19751a3571b5SPaul Greenwalt } 19761a3571b5SPaul Greenwalt 19771a3571b5SPaul Greenwalt /** 19781a3571b5SPaul Greenwalt * ice_check_media_subtask - Check for media 19796d599946STony Nguyen * @pf: pointer to PF struct 19801a3571b5SPaul Greenwalt * 19811a3571b5SPaul Greenwalt * If media is available, then initialize PHY user configuration if it is not 19821a3571b5SPaul Greenwalt * been, and configure the PHY if the interface is up. 19836d599946STony Nguyen */ 19846d599946STony Nguyen static void ice_check_media_subtask(struct ice_pf *pf) 19856d599946STony Nguyen { 19866d599946STony Nguyen struct ice_port_info *pi; 19876d599946STony Nguyen struct ice_vsi *vsi; 19886d599946STony Nguyen int err; 19896d599946STony Nguyen 19901a3571b5SPaul Greenwalt /* No need to check for media if it's already present */ 19911a3571b5SPaul Greenwalt if (!test_bit(ICE_FLAG_NO_MEDIA, pf->flags)) 19926d599946STony Nguyen return; 19936d599946STony Nguyen 19941a3571b5SPaul Greenwalt vsi = ice_get_main_vsi(pf); 19951a3571b5SPaul Greenwalt if (!vsi) 19966d599946STony Nguyen return; 19976d599946STony Nguyen 19986d599946STony Nguyen /* Refresh link info and check if media is present */ 19996d599946STony Nguyen pi = vsi->port_info; 20006d599946STony Nguyen err = ice_update_link_info(pi); 20016d599946STony Nguyen if (err) 20026d599946STony Nguyen return; 20036d599946STony Nguyen 20046d599946STony Nguyen if (pi->phy.link_info.link_info & ICE_AQ_MEDIA_AVAILABLE) { 20057e408e07SAnirudh Venkataramanan if (!test_bit(ICE_PHY_INIT_COMPLETE, pf->state)) 20061a3571b5SPaul Greenwalt ice_init_phy_user_cfg(pi); 20071a3571b5SPaul Greenwalt 20081a3571b5SPaul Greenwalt /* PHY settings are reset on media insertion, reconfigure 20091a3571b5SPaul Greenwalt * PHY to preserve settings. 20101a3571b5SPaul Greenwalt */ 2011e97fb1aeSAnirudh Venkataramanan if (test_bit(ICE_VSI_DOWN, vsi->state) && 20121a3571b5SPaul Greenwalt test_bit(ICE_FLAG_LINK_DOWN_ON_CLOSE_ENA, vsi->back->flags)) 20136d599946STony Nguyen return; 20141a3571b5SPaul Greenwalt 20151a3571b5SPaul Greenwalt err = ice_configure_phy(vsi); 20161a3571b5SPaul Greenwalt if (!err) 20176d599946STony Nguyen clear_bit(ICE_FLAG_NO_MEDIA, pf->flags); 20186d599946STony Nguyen 20196d599946STony Nguyen /* A Link Status Event will be generated; the event handler 20206d599946STony Nguyen * will complete bringing the interface up 20216d599946STony Nguyen */ 20226d599946STony Nguyen } 20236d599946STony Nguyen } 20246d599946STony Nguyen 20256d599946STony Nguyen /** 2026940b61afSAnirudh Venkataramanan * ice_service_task - manage and run subtasks 2027940b61afSAnirudh Venkataramanan * @work: pointer to work_struct contained by the PF struct 2028940b61afSAnirudh Venkataramanan */ 2029940b61afSAnirudh Venkataramanan static void ice_service_task(struct work_struct *work) 2030940b61afSAnirudh Venkataramanan { 2031940b61afSAnirudh Venkataramanan struct ice_pf *pf = container_of(work, struct ice_pf, serv_task); 2032940b61afSAnirudh Venkataramanan unsigned long start_time = jiffies; 2033940b61afSAnirudh Venkataramanan 2034940b61afSAnirudh Venkataramanan /* subtasks */ 20350b28b702SAnirudh Venkataramanan 20360b28b702SAnirudh Venkataramanan /* process reset requests first */ 20370b28b702SAnirudh Venkataramanan ice_reset_subtask(pf); 20380b28b702SAnirudh Venkataramanan 20390f9d5027SAnirudh Venkataramanan /* bail if a reset/recovery cycle is pending or rebuild failed */ 20405df7e45dSDave Ertman if (ice_is_reset_in_progress(pf->state) || 20417e408e07SAnirudh Venkataramanan test_bit(ICE_SUSPENDED, pf->state) || 20427e408e07SAnirudh Venkataramanan test_bit(ICE_NEEDS_RESTART, pf->state)) { 20430b28b702SAnirudh Venkataramanan ice_service_task_complete(pf); 20440b28b702SAnirudh Venkataramanan return; 20450b28b702SAnirudh Venkataramanan } 20460b28b702SAnirudh Venkataramanan 2047462acf6aSTony Nguyen ice_clean_adminq_subtask(pf); 20486d599946STony Nguyen ice_check_media_subtask(pf); 2049b3969fd7SSudheer Mogilappagari ice_check_for_hang_subtask(pf); 2050e94d4478SAnirudh Venkataramanan ice_sync_fltr_subtask(pf); 2051b3969fd7SSudheer Mogilappagari ice_handle_mdd_event(pf); 2052fcea6f3dSAnirudh Venkataramanan ice_watchdog_subtask(pf); 2053462acf6aSTony Nguyen 2054462acf6aSTony Nguyen if (ice_is_safe_mode(pf)) { 2055462acf6aSTony Nguyen ice_service_task_complete(pf); 2056462acf6aSTony Nguyen return; 2057462acf6aSTony Nguyen } 2058462acf6aSTony Nguyen 2059462acf6aSTony Nguyen ice_process_vflr_event(pf); 206075d2b253SAnirudh Venkataramanan ice_clean_mailboxq_subtask(pf); 206128bf2672SBrett Creeley ice_sync_arfs_fltrs(pf); 2062d6218317SQi Zhang ice_flush_fdir_ctx(pf); 20637e408e07SAnirudh Venkataramanan 20647e408e07SAnirudh Venkataramanan /* Clear ICE_SERVICE_SCHED flag to allow scheduling next event */ 2065940b61afSAnirudh Venkataramanan ice_service_task_complete(pf); 2066940b61afSAnirudh Venkataramanan 2067940b61afSAnirudh Venkataramanan /* If the tasks have taken longer than one service timer period 2068940b61afSAnirudh Venkataramanan * or there is more work to be done, reset the service timer to 2069940b61afSAnirudh Venkataramanan * schedule the service task now. 2070940b61afSAnirudh Venkataramanan */ 2071940b61afSAnirudh Venkataramanan if (time_after(jiffies, (start_time + pf->serv_tmr_period)) || 20727e408e07SAnirudh Venkataramanan test_bit(ICE_MDD_EVENT_PENDING, pf->state) || 20737e408e07SAnirudh Venkataramanan test_bit(ICE_VFLR_EVENT_PENDING, pf->state) || 20747e408e07SAnirudh Venkataramanan test_bit(ICE_MAILBOXQ_EVENT_PENDING, pf->state) || 20757e408e07SAnirudh Venkataramanan test_bit(ICE_FD_VF_FLUSH_CTX, pf->state) || 20767e408e07SAnirudh Venkataramanan test_bit(ICE_ADMINQ_EVENT_PENDING, pf->state)) 2077940b61afSAnirudh Venkataramanan mod_timer(&pf->serv_tmr, jiffies); 2078940b61afSAnirudh Venkataramanan } 2079940b61afSAnirudh Venkataramanan 2080837f08fdSAnirudh Venkataramanan /** 2081f31e4b6fSAnirudh Venkataramanan * ice_set_ctrlq_len - helper function to set controlq length 2082f9867df6SAnirudh Venkataramanan * @hw: pointer to the HW instance 2083f31e4b6fSAnirudh Venkataramanan */ 2084f31e4b6fSAnirudh Venkataramanan static void ice_set_ctrlq_len(struct ice_hw *hw) 2085f31e4b6fSAnirudh Venkataramanan { 2086f31e4b6fSAnirudh Venkataramanan hw->adminq.num_rq_entries = ICE_AQ_LEN; 2087f31e4b6fSAnirudh Venkataramanan hw->adminq.num_sq_entries = ICE_AQ_LEN; 2088f31e4b6fSAnirudh Venkataramanan hw->adminq.rq_buf_size = ICE_AQ_MAX_BUF_LEN; 2089f31e4b6fSAnirudh Venkataramanan hw->adminq.sq_buf_size = ICE_AQ_MAX_BUF_LEN; 2090c8a1071dSLukasz Czapnik hw->mailboxq.num_rq_entries = PF_MBX_ARQLEN_ARQLEN_M; 209111836214SBrett Creeley hw->mailboxq.num_sq_entries = ICE_MBXSQ_LEN; 209275d2b253SAnirudh Venkataramanan hw->mailboxq.rq_buf_size = ICE_MBXQ_MAX_BUF_LEN; 209375d2b253SAnirudh Venkataramanan hw->mailboxq.sq_buf_size = ICE_MBXQ_MAX_BUF_LEN; 2094f31e4b6fSAnirudh Venkataramanan } 2095f31e4b6fSAnirudh Venkataramanan 2096f31e4b6fSAnirudh Venkataramanan /** 209787324e74SHenry Tieman * ice_schedule_reset - schedule a reset 209887324e74SHenry Tieman * @pf: board private structure 209987324e74SHenry Tieman * @reset: reset being requested 210087324e74SHenry Tieman */ 210187324e74SHenry Tieman int ice_schedule_reset(struct ice_pf *pf, enum ice_reset_req reset) 210287324e74SHenry Tieman { 210387324e74SHenry Tieman struct device *dev = ice_pf_to_dev(pf); 210487324e74SHenry Tieman 210587324e74SHenry Tieman /* bail out if earlier reset has failed */ 21067e408e07SAnirudh Venkataramanan if (test_bit(ICE_RESET_FAILED, pf->state)) { 210787324e74SHenry Tieman dev_dbg(dev, "earlier reset has failed\n"); 210887324e74SHenry Tieman return -EIO; 210987324e74SHenry Tieman } 211087324e74SHenry Tieman /* bail if reset/recovery already in progress */ 211187324e74SHenry Tieman if (ice_is_reset_in_progress(pf->state)) { 211287324e74SHenry Tieman dev_dbg(dev, "Reset already in progress\n"); 211387324e74SHenry Tieman return -EBUSY; 211487324e74SHenry Tieman } 211587324e74SHenry Tieman 211687324e74SHenry Tieman switch (reset) { 211787324e74SHenry Tieman case ICE_RESET_PFR: 21187e408e07SAnirudh Venkataramanan set_bit(ICE_PFR_REQ, pf->state); 211987324e74SHenry Tieman break; 212087324e74SHenry Tieman case ICE_RESET_CORER: 21217e408e07SAnirudh Venkataramanan set_bit(ICE_CORER_REQ, pf->state); 212287324e74SHenry Tieman break; 212387324e74SHenry Tieman case ICE_RESET_GLOBR: 21247e408e07SAnirudh Venkataramanan set_bit(ICE_GLOBR_REQ, pf->state); 212587324e74SHenry Tieman break; 212687324e74SHenry Tieman default: 212787324e74SHenry Tieman return -EINVAL; 212887324e74SHenry Tieman } 212987324e74SHenry Tieman 213087324e74SHenry Tieman ice_service_task_schedule(pf); 213187324e74SHenry Tieman return 0; 213287324e74SHenry Tieman } 213387324e74SHenry Tieman 213487324e74SHenry Tieman /** 2135cdedef59SAnirudh Venkataramanan * ice_irq_affinity_notify - Callback for affinity changes 2136cdedef59SAnirudh Venkataramanan * @notify: context as to what irq was changed 2137cdedef59SAnirudh Venkataramanan * @mask: the new affinity mask 2138cdedef59SAnirudh Venkataramanan * 2139cdedef59SAnirudh Venkataramanan * This is a callback function used by the irq_set_affinity_notifier function 2140cdedef59SAnirudh Venkataramanan * so that we may register to receive changes to the irq affinity masks. 2141cdedef59SAnirudh Venkataramanan */ 2142c8b7abddSBruce Allan static void 2143c8b7abddSBruce Allan ice_irq_affinity_notify(struct irq_affinity_notify *notify, 2144cdedef59SAnirudh Venkataramanan const cpumask_t *mask) 2145cdedef59SAnirudh Venkataramanan { 2146cdedef59SAnirudh Venkataramanan struct ice_q_vector *q_vector = 2147cdedef59SAnirudh Venkataramanan container_of(notify, struct ice_q_vector, affinity_notify); 2148cdedef59SAnirudh Venkataramanan 2149cdedef59SAnirudh Venkataramanan cpumask_copy(&q_vector->affinity_mask, mask); 2150cdedef59SAnirudh Venkataramanan } 2151cdedef59SAnirudh Venkataramanan 2152cdedef59SAnirudh Venkataramanan /** 2153cdedef59SAnirudh Venkataramanan * ice_irq_affinity_release - Callback for affinity notifier release 2154cdedef59SAnirudh Venkataramanan * @ref: internal core kernel usage 2155cdedef59SAnirudh Venkataramanan * 2156cdedef59SAnirudh Venkataramanan * This is a callback function used by the irq_set_affinity_notifier function 2157cdedef59SAnirudh Venkataramanan * to inform the current notification subscriber that they will no longer 2158cdedef59SAnirudh Venkataramanan * receive notifications. 2159cdedef59SAnirudh Venkataramanan */ 2160cdedef59SAnirudh Venkataramanan static void ice_irq_affinity_release(struct kref __always_unused *ref) {} 2161cdedef59SAnirudh Venkataramanan 2162cdedef59SAnirudh Venkataramanan /** 2163cdedef59SAnirudh Venkataramanan * ice_vsi_ena_irq - Enable IRQ for the given VSI 2164cdedef59SAnirudh Venkataramanan * @vsi: the VSI being configured 2165cdedef59SAnirudh Venkataramanan */ 2166cdedef59SAnirudh Venkataramanan static int ice_vsi_ena_irq(struct ice_vsi *vsi) 2167cdedef59SAnirudh Venkataramanan { 2168ba880734SBrett Creeley struct ice_hw *hw = &vsi->back->hw; 2169cdedef59SAnirudh Venkataramanan int i; 2170cdedef59SAnirudh Venkataramanan 21710c2561c8SBrett Creeley ice_for_each_q_vector(vsi, i) 2172cdedef59SAnirudh Venkataramanan ice_irq_dynamic_ena(hw, vsi, vsi->q_vectors[i]); 2173cdedef59SAnirudh Venkataramanan 2174cdedef59SAnirudh Venkataramanan ice_flush(hw); 2175cdedef59SAnirudh Venkataramanan return 0; 2176cdedef59SAnirudh Venkataramanan } 2177cdedef59SAnirudh Venkataramanan 2178cdedef59SAnirudh Venkataramanan /** 2179cdedef59SAnirudh Venkataramanan * ice_vsi_req_irq_msix - get MSI-X vectors from the OS for the VSI 2180cdedef59SAnirudh Venkataramanan * @vsi: the VSI being configured 2181cdedef59SAnirudh Venkataramanan * @basename: name for the vector 2182cdedef59SAnirudh Venkataramanan */ 2183cdedef59SAnirudh Venkataramanan static int ice_vsi_req_irq_msix(struct ice_vsi *vsi, char *basename) 2184cdedef59SAnirudh Venkataramanan { 2185cdedef59SAnirudh Venkataramanan int q_vectors = vsi->num_q_vectors; 2186cdedef59SAnirudh Venkataramanan struct ice_pf *pf = vsi->back; 2187cbe66bfeSBrett Creeley int base = vsi->base_vector; 21884015d11eSBrett Creeley struct device *dev; 2189cdedef59SAnirudh Venkataramanan int rx_int_idx = 0; 2190cdedef59SAnirudh Venkataramanan int tx_int_idx = 0; 2191cdedef59SAnirudh Venkataramanan int vector, err; 2192cdedef59SAnirudh Venkataramanan int irq_num; 2193cdedef59SAnirudh Venkataramanan 21944015d11eSBrett Creeley dev = ice_pf_to_dev(pf); 2195cdedef59SAnirudh Venkataramanan for (vector = 0; vector < q_vectors; vector++) { 2196cdedef59SAnirudh Venkataramanan struct ice_q_vector *q_vector = vsi->q_vectors[vector]; 2197cdedef59SAnirudh Venkataramanan 2198cdedef59SAnirudh Venkataramanan irq_num = pf->msix_entries[base + vector].vector; 2199cdedef59SAnirudh Venkataramanan 2200cdedef59SAnirudh Venkataramanan if (q_vector->tx.ring && q_vector->rx.ring) { 2201cdedef59SAnirudh Venkataramanan snprintf(q_vector->name, sizeof(q_vector->name) - 1, 2202cdedef59SAnirudh Venkataramanan "%s-%s-%d", basename, "TxRx", rx_int_idx++); 2203cdedef59SAnirudh Venkataramanan tx_int_idx++; 2204cdedef59SAnirudh Venkataramanan } else if (q_vector->rx.ring) { 2205cdedef59SAnirudh Venkataramanan snprintf(q_vector->name, sizeof(q_vector->name) - 1, 2206cdedef59SAnirudh Venkataramanan "%s-%s-%d", basename, "rx", rx_int_idx++); 2207cdedef59SAnirudh Venkataramanan } else if (q_vector->tx.ring) { 2208cdedef59SAnirudh Venkataramanan snprintf(q_vector->name, sizeof(q_vector->name) - 1, 2209cdedef59SAnirudh Venkataramanan "%s-%s-%d", basename, "tx", tx_int_idx++); 2210cdedef59SAnirudh Venkataramanan } else { 2211cdedef59SAnirudh Venkataramanan /* skip this unused q_vector */ 2212cdedef59SAnirudh Venkataramanan continue; 2213cdedef59SAnirudh Venkataramanan } 2214da62c5ffSQi Zhang if (vsi->type == ICE_VSI_CTRL && vsi->vf_id != ICE_INVAL_VFID) 2215da62c5ffSQi Zhang err = devm_request_irq(dev, irq_num, vsi->irq_handler, 2216da62c5ffSQi Zhang IRQF_SHARED, q_vector->name, 2217da62c5ffSQi Zhang q_vector); 2218da62c5ffSQi Zhang else 2219da62c5ffSQi Zhang err = devm_request_irq(dev, irq_num, vsi->irq_handler, 2220da62c5ffSQi Zhang 0, q_vector->name, q_vector); 2221cdedef59SAnirudh Venkataramanan if (err) { 222219cce2c6SAnirudh Venkataramanan netdev_err(vsi->netdev, "MSIX request_irq failed, error: %d\n", 222319cce2c6SAnirudh Venkataramanan err); 2224cdedef59SAnirudh Venkataramanan goto free_q_irqs; 2225cdedef59SAnirudh Venkataramanan } 2226cdedef59SAnirudh Venkataramanan 2227cdedef59SAnirudh Venkataramanan /* register for affinity change notifications */ 222828bf2672SBrett Creeley if (!IS_ENABLED(CONFIG_RFS_ACCEL)) { 222928bf2672SBrett Creeley struct irq_affinity_notify *affinity_notify; 223028bf2672SBrett Creeley 223128bf2672SBrett Creeley affinity_notify = &q_vector->affinity_notify; 223228bf2672SBrett Creeley affinity_notify->notify = ice_irq_affinity_notify; 223328bf2672SBrett Creeley affinity_notify->release = ice_irq_affinity_release; 223428bf2672SBrett Creeley irq_set_affinity_notifier(irq_num, affinity_notify); 223528bf2672SBrett Creeley } 2236cdedef59SAnirudh Venkataramanan 2237cdedef59SAnirudh Venkataramanan /* assign the mask for this irq */ 2238cdedef59SAnirudh Venkataramanan irq_set_affinity_hint(irq_num, &q_vector->affinity_mask); 2239cdedef59SAnirudh Venkataramanan } 2240cdedef59SAnirudh Venkataramanan 2241cdedef59SAnirudh Venkataramanan vsi->irqs_ready = true; 2242cdedef59SAnirudh Venkataramanan return 0; 2243cdedef59SAnirudh Venkataramanan 2244cdedef59SAnirudh Venkataramanan free_q_irqs: 2245cdedef59SAnirudh Venkataramanan while (vector) { 2246cdedef59SAnirudh Venkataramanan vector--; 224728bf2672SBrett Creeley irq_num = pf->msix_entries[base + vector].vector; 224828bf2672SBrett Creeley if (!IS_ENABLED(CONFIG_RFS_ACCEL)) 2249cdedef59SAnirudh Venkataramanan irq_set_affinity_notifier(irq_num, NULL); 2250cdedef59SAnirudh Venkataramanan irq_set_affinity_hint(irq_num, NULL); 22514015d11eSBrett Creeley devm_free_irq(dev, irq_num, &vsi->q_vectors[vector]); 2252cdedef59SAnirudh Venkataramanan } 2253cdedef59SAnirudh Venkataramanan return err; 2254cdedef59SAnirudh Venkataramanan } 2255cdedef59SAnirudh Venkataramanan 2256cdedef59SAnirudh Venkataramanan /** 2257efc2214bSMaciej Fijalkowski * ice_xdp_alloc_setup_rings - Allocate and setup Tx rings for XDP 2258efc2214bSMaciej Fijalkowski * @vsi: VSI to setup Tx rings used by XDP 2259efc2214bSMaciej Fijalkowski * 2260efc2214bSMaciej Fijalkowski * Return 0 on success and negative value on error 2261efc2214bSMaciej Fijalkowski */ 2262efc2214bSMaciej Fijalkowski static int ice_xdp_alloc_setup_rings(struct ice_vsi *vsi) 2263efc2214bSMaciej Fijalkowski { 22649a946843SAnirudh Venkataramanan struct device *dev = ice_pf_to_dev(vsi->back); 2265efc2214bSMaciej Fijalkowski int i; 2266efc2214bSMaciej Fijalkowski 2267efc2214bSMaciej Fijalkowski for (i = 0; i < vsi->num_xdp_txq; i++) { 2268efc2214bSMaciej Fijalkowski u16 xdp_q_idx = vsi->alloc_txq + i; 2269efc2214bSMaciej Fijalkowski struct ice_ring *xdp_ring; 2270efc2214bSMaciej Fijalkowski 2271efc2214bSMaciej Fijalkowski xdp_ring = kzalloc(sizeof(*xdp_ring), GFP_KERNEL); 2272efc2214bSMaciej Fijalkowski 2273efc2214bSMaciej Fijalkowski if (!xdp_ring) 2274efc2214bSMaciej Fijalkowski goto free_xdp_rings; 2275efc2214bSMaciej Fijalkowski 2276efc2214bSMaciej Fijalkowski xdp_ring->q_index = xdp_q_idx; 2277efc2214bSMaciej Fijalkowski xdp_ring->reg_idx = vsi->txq_map[xdp_q_idx]; 2278efc2214bSMaciej Fijalkowski xdp_ring->ring_active = false; 2279efc2214bSMaciej Fijalkowski xdp_ring->vsi = vsi; 2280efc2214bSMaciej Fijalkowski xdp_ring->netdev = NULL; 2281efc2214bSMaciej Fijalkowski xdp_ring->dev = dev; 2282efc2214bSMaciej Fijalkowski xdp_ring->count = vsi->num_tx_desc; 2283b1d95cc2SCiara Loftus WRITE_ONCE(vsi->xdp_rings[i], xdp_ring); 2284efc2214bSMaciej Fijalkowski if (ice_setup_tx_ring(xdp_ring)) 2285efc2214bSMaciej Fijalkowski goto free_xdp_rings; 2286efc2214bSMaciej Fijalkowski ice_set_ring_xdp(xdp_ring); 22871742b3d5SMagnus Karlsson xdp_ring->xsk_pool = ice_xsk_pool(xdp_ring); 2288efc2214bSMaciej Fijalkowski } 2289efc2214bSMaciej Fijalkowski 2290efc2214bSMaciej Fijalkowski return 0; 2291efc2214bSMaciej Fijalkowski 2292efc2214bSMaciej Fijalkowski free_xdp_rings: 2293efc2214bSMaciej Fijalkowski for (; i >= 0; i--) 2294efc2214bSMaciej Fijalkowski if (vsi->xdp_rings[i] && vsi->xdp_rings[i]->desc) 2295efc2214bSMaciej Fijalkowski ice_free_tx_ring(vsi->xdp_rings[i]); 2296efc2214bSMaciej Fijalkowski return -ENOMEM; 2297efc2214bSMaciej Fijalkowski } 2298efc2214bSMaciej Fijalkowski 2299efc2214bSMaciej Fijalkowski /** 2300efc2214bSMaciej Fijalkowski * ice_vsi_assign_bpf_prog - set or clear bpf prog pointer on VSI 2301efc2214bSMaciej Fijalkowski * @vsi: VSI to set the bpf prog on 2302efc2214bSMaciej Fijalkowski * @prog: the bpf prog pointer 2303efc2214bSMaciej Fijalkowski */ 2304efc2214bSMaciej Fijalkowski static void ice_vsi_assign_bpf_prog(struct ice_vsi *vsi, struct bpf_prog *prog) 2305efc2214bSMaciej Fijalkowski { 2306efc2214bSMaciej Fijalkowski struct bpf_prog *old_prog; 2307efc2214bSMaciej Fijalkowski int i; 2308efc2214bSMaciej Fijalkowski 2309efc2214bSMaciej Fijalkowski old_prog = xchg(&vsi->xdp_prog, prog); 2310efc2214bSMaciej Fijalkowski if (old_prog) 2311efc2214bSMaciej Fijalkowski bpf_prog_put(old_prog); 2312efc2214bSMaciej Fijalkowski 2313efc2214bSMaciej Fijalkowski ice_for_each_rxq(vsi, i) 2314efc2214bSMaciej Fijalkowski WRITE_ONCE(vsi->rx_rings[i]->xdp_prog, vsi->xdp_prog); 2315efc2214bSMaciej Fijalkowski } 2316efc2214bSMaciej Fijalkowski 2317efc2214bSMaciej Fijalkowski /** 2318efc2214bSMaciej Fijalkowski * ice_prepare_xdp_rings - Allocate, configure and setup Tx rings for XDP 2319efc2214bSMaciej Fijalkowski * @vsi: VSI to bring up Tx rings used by XDP 2320efc2214bSMaciej Fijalkowski * @prog: bpf program that will be assigned to VSI 2321efc2214bSMaciej Fijalkowski * 2322efc2214bSMaciej Fijalkowski * Return 0 on success and negative value on error 2323efc2214bSMaciej Fijalkowski */ 2324efc2214bSMaciej Fijalkowski int ice_prepare_xdp_rings(struct ice_vsi *vsi, struct bpf_prog *prog) 2325efc2214bSMaciej Fijalkowski { 2326efc2214bSMaciej Fijalkowski u16 max_txqs[ICE_MAX_TRAFFIC_CLASS] = { 0 }; 2327efc2214bSMaciej Fijalkowski int xdp_rings_rem = vsi->num_xdp_txq; 2328efc2214bSMaciej Fijalkowski struct ice_pf *pf = vsi->back; 2329efc2214bSMaciej Fijalkowski struct ice_qs_cfg xdp_qs_cfg = { 2330efc2214bSMaciej Fijalkowski .qs_mutex = &pf->avail_q_mutex, 2331efc2214bSMaciej Fijalkowski .pf_map = pf->avail_txqs, 2332efc2214bSMaciej Fijalkowski .pf_map_size = pf->max_pf_txqs, 2333efc2214bSMaciej Fijalkowski .q_count = vsi->num_xdp_txq, 2334efc2214bSMaciej Fijalkowski .scatter_count = ICE_MAX_SCATTER_TXQS, 2335efc2214bSMaciej Fijalkowski .vsi_map = vsi->txq_map, 2336efc2214bSMaciej Fijalkowski .vsi_map_offset = vsi->alloc_txq, 2337efc2214bSMaciej Fijalkowski .mapping_mode = ICE_VSI_MAP_CONTIG 2338efc2214bSMaciej Fijalkowski }; 2339efc2214bSMaciej Fijalkowski enum ice_status status; 23404015d11eSBrett Creeley struct device *dev; 2341efc2214bSMaciej Fijalkowski int i, v_idx; 2342efc2214bSMaciej Fijalkowski 23434015d11eSBrett Creeley dev = ice_pf_to_dev(pf); 23444015d11eSBrett Creeley vsi->xdp_rings = devm_kcalloc(dev, vsi->num_xdp_txq, 2345efc2214bSMaciej Fijalkowski sizeof(*vsi->xdp_rings), GFP_KERNEL); 2346efc2214bSMaciej Fijalkowski if (!vsi->xdp_rings) 2347efc2214bSMaciej Fijalkowski return -ENOMEM; 2348efc2214bSMaciej Fijalkowski 2349efc2214bSMaciej Fijalkowski vsi->xdp_mapping_mode = xdp_qs_cfg.mapping_mode; 2350efc2214bSMaciej Fijalkowski if (__ice_vsi_get_qs(&xdp_qs_cfg)) 2351efc2214bSMaciej Fijalkowski goto err_map_xdp; 2352efc2214bSMaciej Fijalkowski 2353efc2214bSMaciej Fijalkowski if (ice_xdp_alloc_setup_rings(vsi)) 2354efc2214bSMaciej Fijalkowski goto clear_xdp_rings; 2355efc2214bSMaciej Fijalkowski 2356efc2214bSMaciej Fijalkowski /* follow the logic from ice_vsi_map_rings_to_vectors */ 2357efc2214bSMaciej Fijalkowski ice_for_each_q_vector(vsi, v_idx) { 2358efc2214bSMaciej Fijalkowski struct ice_q_vector *q_vector = vsi->q_vectors[v_idx]; 2359efc2214bSMaciej Fijalkowski int xdp_rings_per_v, q_id, q_base; 2360efc2214bSMaciej Fijalkowski 2361efc2214bSMaciej Fijalkowski xdp_rings_per_v = DIV_ROUND_UP(xdp_rings_rem, 2362efc2214bSMaciej Fijalkowski vsi->num_q_vectors - v_idx); 2363efc2214bSMaciej Fijalkowski q_base = vsi->num_xdp_txq - xdp_rings_rem; 2364efc2214bSMaciej Fijalkowski 2365efc2214bSMaciej Fijalkowski for (q_id = q_base; q_id < (q_base + xdp_rings_per_v); q_id++) { 2366efc2214bSMaciej Fijalkowski struct ice_ring *xdp_ring = vsi->xdp_rings[q_id]; 2367efc2214bSMaciej Fijalkowski 2368efc2214bSMaciej Fijalkowski xdp_ring->q_vector = q_vector; 2369efc2214bSMaciej Fijalkowski xdp_ring->next = q_vector->tx.ring; 2370efc2214bSMaciej Fijalkowski q_vector->tx.ring = xdp_ring; 2371efc2214bSMaciej Fijalkowski } 2372efc2214bSMaciej Fijalkowski xdp_rings_rem -= xdp_rings_per_v; 2373efc2214bSMaciej Fijalkowski } 2374efc2214bSMaciej Fijalkowski 2375efc2214bSMaciej Fijalkowski /* omit the scheduler update if in reset path; XDP queues will be 2376efc2214bSMaciej Fijalkowski * taken into account at the end of ice_vsi_rebuild, where 2377efc2214bSMaciej Fijalkowski * ice_cfg_vsi_lan is being called 2378efc2214bSMaciej Fijalkowski */ 2379efc2214bSMaciej Fijalkowski if (ice_is_reset_in_progress(pf->state)) 2380efc2214bSMaciej Fijalkowski return 0; 2381efc2214bSMaciej Fijalkowski 2382efc2214bSMaciej Fijalkowski /* tell the Tx scheduler that right now we have 2383efc2214bSMaciej Fijalkowski * additional queues 2384efc2214bSMaciej Fijalkowski */ 2385efc2214bSMaciej Fijalkowski for (i = 0; i < vsi->tc_cfg.numtc; i++) 2386efc2214bSMaciej Fijalkowski max_txqs[i] = vsi->num_txq + vsi->num_xdp_txq; 2387efc2214bSMaciej Fijalkowski 2388efc2214bSMaciej Fijalkowski status = ice_cfg_vsi_lan(vsi->port_info, vsi->idx, vsi->tc_cfg.ena_tc, 2389efc2214bSMaciej Fijalkowski max_txqs); 2390efc2214bSMaciej Fijalkowski if (status) { 23910fee3577SLihong Yang dev_err(dev, "Failed VSI LAN queue config for XDP, error: %s\n", 23920fee3577SLihong Yang ice_stat_str(status)); 2393efc2214bSMaciej Fijalkowski goto clear_xdp_rings; 2394efc2214bSMaciej Fijalkowski } 2395efc2214bSMaciej Fijalkowski ice_vsi_assign_bpf_prog(vsi, prog); 2396efc2214bSMaciej Fijalkowski 2397efc2214bSMaciej Fijalkowski return 0; 2398efc2214bSMaciej Fijalkowski clear_xdp_rings: 2399efc2214bSMaciej Fijalkowski for (i = 0; i < vsi->num_xdp_txq; i++) 2400efc2214bSMaciej Fijalkowski if (vsi->xdp_rings[i]) { 2401efc2214bSMaciej Fijalkowski kfree_rcu(vsi->xdp_rings[i], rcu); 2402efc2214bSMaciej Fijalkowski vsi->xdp_rings[i] = NULL; 2403efc2214bSMaciej Fijalkowski } 2404efc2214bSMaciej Fijalkowski 2405efc2214bSMaciej Fijalkowski err_map_xdp: 2406efc2214bSMaciej Fijalkowski mutex_lock(&pf->avail_q_mutex); 2407efc2214bSMaciej Fijalkowski for (i = 0; i < vsi->num_xdp_txq; i++) { 2408efc2214bSMaciej Fijalkowski clear_bit(vsi->txq_map[i + vsi->alloc_txq], pf->avail_txqs); 2409efc2214bSMaciej Fijalkowski vsi->txq_map[i + vsi->alloc_txq] = ICE_INVAL_Q_INDEX; 2410efc2214bSMaciej Fijalkowski } 2411efc2214bSMaciej Fijalkowski mutex_unlock(&pf->avail_q_mutex); 2412efc2214bSMaciej Fijalkowski 24134015d11eSBrett Creeley devm_kfree(dev, vsi->xdp_rings); 2414efc2214bSMaciej Fijalkowski return -ENOMEM; 2415efc2214bSMaciej Fijalkowski } 2416efc2214bSMaciej Fijalkowski 2417efc2214bSMaciej Fijalkowski /** 2418efc2214bSMaciej Fijalkowski * ice_destroy_xdp_rings - undo the configuration made by ice_prepare_xdp_rings 2419efc2214bSMaciej Fijalkowski * @vsi: VSI to remove XDP rings 2420efc2214bSMaciej Fijalkowski * 2421efc2214bSMaciej Fijalkowski * Detach XDP rings from irq vectors, clean up the PF bitmap and free 2422efc2214bSMaciej Fijalkowski * resources 2423efc2214bSMaciej Fijalkowski */ 2424efc2214bSMaciej Fijalkowski int ice_destroy_xdp_rings(struct ice_vsi *vsi) 2425efc2214bSMaciej Fijalkowski { 2426efc2214bSMaciej Fijalkowski u16 max_txqs[ICE_MAX_TRAFFIC_CLASS] = { 0 }; 2427efc2214bSMaciej Fijalkowski struct ice_pf *pf = vsi->back; 2428efc2214bSMaciej Fijalkowski int i, v_idx; 2429efc2214bSMaciej Fijalkowski 2430efc2214bSMaciej Fijalkowski /* q_vectors are freed in reset path so there's no point in detaching 2431ac382a09SBruce Allan * rings; in case of rebuild being triggered not from reset bits 2432efc2214bSMaciej Fijalkowski * in pf->state won't be set, so additionally check first q_vector 2433efc2214bSMaciej Fijalkowski * against NULL 2434efc2214bSMaciej Fijalkowski */ 2435efc2214bSMaciej Fijalkowski if (ice_is_reset_in_progress(pf->state) || !vsi->q_vectors[0]) 2436efc2214bSMaciej Fijalkowski goto free_qmap; 2437efc2214bSMaciej Fijalkowski 2438efc2214bSMaciej Fijalkowski ice_for_each_q_vector(vsi, v_idx) { 2439efc2214bSMaciej Fijalkowski struct ice_q_vector *q_vector = vsi->q_vectors[v_idx]; 2440efc2214bSMaciej Fijalkowski struct ice_ring *ring; 2441efc2214bSMaciej Fijalkowski 2442efc2214bSMaciej Fijalkowski ice_for_each_ring(ring, q_vector->tx) 2443efc2214bSMaciej Fijalkowski if (!ring->tx_buf || !ice_ring_is_xdp(ring)) 2444efc2214bSMaciej Fijalkowski break; 2445efc2214bSMaciej Fijalkowski 2446efc2214bSMaciej Fijalkowski /* restore the value of last node prior to XDP setup */ 2447efc2214bSMaciej Fijalkowski q_vector->tx.ring = ring; 2448efc2214bSMaciej Fijalkowski } 2449efc2214bSMaciej Fijalkowski 2450efc2214bSMaciej Fijalkowski free_qmap: 2451efc2214bSMaciej Fijalkowski mutex_lock(&pf->avail_q_mutex); 2452efc2214bSMaciej Fijalkowski for (i = 0; i < vsi->num_xdp_txq; i++) { 2453efc2214bSMaciej Fijalkowski clear_bit(vsi->txq_map[i + vsi->alloc_txq], pf->avail_txqs); 2454efc2214bSMaciej Fijalkowski vsi->txq_map[i + vsi->alloc_txq] = ICE_INVAL_Q_INDEX; 2455efc2214bSMaciej Fijalkowski } 2456efc2214bSMaciej Fijalkowski mutex_unlock(&pf->avail_q_mutex); 2457efc2214bSMaciej Fijalkowski 2458efc2214bSMaciej Fijalkowski for (i = 0; i < vsi->num_xdp_txq; i++) 2459efc2214bSMaciej Fijalkowski if (vsi->xdp_rings[i]) { 2460efc2214bSMaciej Fijalkowski if (vsi->xdp_rings[i]->desc) 2461efc2214bSMaciej Fijalkowski ice_free_tx_ring(vsi->xdp_rings[i]); 2462efc2214bSMaciej Fijalkowski kfree_rcu(vsi->xdp_rings[i], rcu); 2463efc2214bSMaciej Fijalkowski vsi->xdp_rings[i] = NULL; 2464efc2214bSMaciej Fijalkowski } 2465efc2214bSMaciej Fijalkowski 24664015d11eSBrett Creeley devm_kfree(ice_pf_to_dev(pf), vsi->xdp_rings); 2467efc2214bSMaciej Fijalkowski vsi->xdp_rings = NULL; 2468efc2214bSMaciej Fijalkowski 2469efc2214bSMaciej Fijalkowski if (ice_is_reset_in_progress(pf->state) || !vsi->q_vectors[0]) 2470efc2214bSMaciej Fijalkowski return 0; 2471efc2214bSMaciej Fijalkowski 2472efc2214bSMaciej Fijalkowski ice_vsi_assign_bpf_prog(vsi, NULL); 2473efc2214bSMaciej Fijalkowski 2474efc2214bSMaciej Fijalkowski /* notify Tx scheduler that we destroyed XDP queues and bring 2475efc2214bSMaciej Fijalkowski * back the old number of child nodes 2476efc2214bSMaciej Fijalkowski */ 2477efc2214bSMaciej Fijalkowski for (i = 0; i < vsi->tc_cfg.numtc; i++) 2478efc2214bSMaciej Fijalkowski max_txqs[i] = vsi->num_txq; 2479efc2214bSMaciej Fijalkowski 2480c8f135c6SMarta Plantykow /* change number of XDP Tx queues to 0 */ 2481c8f135c6SMarta Plantykow vsi->num_xdp_txq = 0; 2482c8f135c6SMarta Plantykow 2483efc2214bSMaciej Fijalkowski return ice_cfg_vsi_lan(vsi->port_info, vsi->idx, vsi->tc_cfg.ena_tc, 2484efc2214bSMaciej Fijalkowski max_txqs); 2485efc2214bSMaciej Fijalkowski } 2486efc2214bSMaciej Fijalkowski 2487efc2214bSMaciej Fijalkowski /** 2488c7a21904SMichal Swiatkowski * ice_vsi_rx_napi_schedule - Schedule napi on RX queues from VSI 2489c7a21904SMichal Swiatkowski * @vsi: VSI to schedule napi on 2490c7a21904SMichal Swiatkowski */ 2491c7a21904SMichal Swiatkowski static void ice_vsi_rx_napi_schedule(struct ice_vsi *vsi) 2492c7a21904SMichal Swiatkowski { 2493c7a21904SMichal Swiatkowski int i; 2494c7a21904SMichal Swiatkowski 2495c7a21904SMichal Swiatkowski ice_for_each_rxq(vsi, i) { 2496c7a21904SMichal Swiatkowski struct ice_ring *rx_ring = vsi->rx_rings[i]; 2497c7a21904SMichal Swiatkowski 2498c7a21904SMichal Swiatkowski if (rx_ring->xsk_pool) 2499c7a21904SMichal Swiatkowski napi_schedule(&rx_ring->q_vector->napi); 2500c7a21904SMichal Swiatkowski } 2501c7a21904SMichal Swiatkowski } 2502c7a21904SMichal Swiatkowski 2503c7a21904SMichal Swiatkowski /** 2504efc2214bSMaciej Fijalkowski * ice_xdp_setup_prog - Add or remove XDP eBPF program 2505efc2214bSMaciej Fijalkowski * @vsi: VSI to setup XDP for 2506efc2214bSMaciej Fijalkowski * @prog: XDP program 2507efc2214bSMaciej Fijalkowski * @extack: netlink extended ack 2508efc2214bSMaciej Fijalkowski */ 2509efc2214bSMaciej Fijalkowski static int 2510efc2214bSMaciej Fijalkowski ice_xdp_setup_prog(struct ice_vsi *vsi, struct bpf_prog *prog, 2511efc2214bSMaciej Fijalkowski struct netlink_ext_ack *extack) 2512efc2214bSMaciej Fijalkowski { 2513efc2214bSMaciej Fijalkowski int frame_size = vsi->netdev->mtu + ICE_ETH_PKT_HDR_PAD; 2514efc2214bSMaciej Fijalkowski bool if_running = netif_running(vsi->netdev); 2515efc2214bSMaciej Fijalkowski int ret = 0, xdp_ring_err = 0; 2516efc2214bSMaciej Fijalkowski 2517efc2214bSMaciej Fijalkowski if (frame_size > vsi->rx_buf_len) { 2518efc2214bSMaciej Fijalkowski NL_SET_ERR_MSG_MOD(extack, "MTU too large for loading XDP"); 2519efc2214bSMaciej Fijalkowski return -EOPNOTSUPP; 2520efc2214bSMaciej Fijalkowski } 2521efc2214bSMaciej Fijalkowski 2522efc2214bSMaciej Fijalkowski /* need to stop netdev while setting up the program for Rx rings */ 2523e97fb1aeSAnirudh Venkataramanan if (if_running && !test_and_set_bit(ICE_VSI_DOWN, vsi->state)) { 2524efc2214bSMaciej Fijalkowski ret = ice_down(vsi); 2525efc2214bSMaciej Fijalkowski if (ret) { 2526af23635aSJesse Brandeburg NL_SET_ERR_MSG_MOD(extack, "Preparing device for XDP attach failed"); 2527efc2214bSMaciej Fijalkowski return ret; 2528efc2214bSMaciej Fijalkowski } 2529efc2214bSMaciej Fijalkowski } 2530efc2214bSMaciej Fijalkowski 2531efc2214bSMaciej Fijalkowski if (!ice_is_xdp_ena_vsi(vsi) && prog) { 2532ae15e0baSMarta Plantykow vsi->num_xdp_txq = vsi->alloc_rxq; 2533efc2214bSMaciej Fijalkowski xdp_ring_err = ice_prepare_xdp_rings(vsi, prog); 2534efc2214bSMaciej Fijalkowski if (xdp_ring_err) 2535af23635aSJesse Brandeburg NL_SET_ERR_MSG_MOD(extack, "Setting up XDP Tx resources failed"); 2536efc2214bSMaciej Fijalkowski } else if (ice_is_xdp_ena_vsi(vsi) && !prog) { 2537efc2214bSMaciej Fijalkowski xdp_ring_err = ice_destroy_xdp_rings(vsi); 2538efc2214bSMaciej Fijalkowski if (xdp_ring_err) 2539af23635aSJesse Brandeburg NL_SET_ERR_MSG_MOD(extack, "Freeing XDP Tx resources failed"); 2540efc2214bSMaciej Fijalkowski } else { 2541efc2214bSMaciej Fijalkowski ice_vsi_assign_bpf_prog(vsi, prog); 2542efc2214bSMaciej Fijalkowski } 2543efc2214bSMaciej Fijalkowski 2544efc2214bSMaciej Fijalkowski if (if_running) 2545efc2214bSMaciej Fijalkowski ret = ice_up(vsi); 2546efc2214bSMaciej Fijalkowski 2547c7a21904SMichal Swiatkowski if (!ret && prog) 2548c7a21904SMichal Swiatkowski ice_vsi_rx_napi_schedule(vsi); 25492d4238f5SKrzysztof Kazimierczak 2550efc2214bSMaciej Fijalkowski return (ret || xdp_ring_err) ? -ENOMEM : 0; 2551efc2214bSMaciej Fijalkowski } 2552efc2214bSMaciej Fijalkowski 2553efc2214bSMaciej Fijalkowski /** 2554efc2214bSMaciej Fijalkowski * ice_xdp - implements XDP handler 2555efc2214bSMaciej Fijalkowski * @dev: netdevice 2556efc2214bSMaciej Fijalkowski * @xdp: XDP command 2557efc2214bSMaciej Fijalkowski */ 2558efc2214bSMaciej Fijalkowski static int ice_xdp(struct net_device *dev, struct netdev_bpf *xdp) 2559efc2214bSMaciej Fijalkowski { 2560efc2214bSMaciej Fijalkowski struct ice_netdev_priv *np = netdev_priv(dev); 2561efc2214bSMaciej Fijalkowski struct ice_vsi *vsi = np->vsi; 2562efc2214bSMaciej Fijalkowski 2563efc2214bSMaciej Fijalkowski if (vsi->type != ICE_VSI_PF) { 2564af23635aSJesse Brandeburg NL_SET_ERR_MSG_MOD(xdp->extack, "XDP can be loaded only on PF VSI"); 2565efc2214bSMaciej Fijalkowski return -EINVAL; 2566efc2214bSMaciej Fijalkowski } 2567efc2214bSMaciej Fijalkowski 2568efc2214bSMaciej Fijalkowski switch (xdp->command) { 2569efc2214bSMaciej Fijalkowski case XDP_SETUP_PROG: 2570efc2214bSMaciej Fijalkowski return ice_xdp_setup_prog(vsi, xdp->prog, xdp->extack); 25711742b3d5SMagnus Karlsson case XDP_SETUP_XSK_POOL: 25721742b3d5SMagnus Karlsson return ice_xsk_pool_setup(vsi, xdp->xsk.pool, 25732d4238f5SKrzysztof Kazimierczak xdp->xsk.queue_id); 2574efc2214bSMaciej Fijalkowski default: 2575efc2214bSMaciej Fijalkowski return -EINVAL; 2576efc2214bSMaciej Fijalkowski } 2577efc2214bSMaciej Fijalkowski } 2578efc2214bSMaciej Fijalkowski 2579efc2214bSMaciej Fijalkowski /** 2580940b61afSAnirudh Venkataramanan * ice_ena_misc_vector - enable the non-queue interrupts 2581940b61afSAnirudh Venkataramanan * @pf: board private structure 2582940b61afSAnirudh Venkataramanan */ 2583940b61afSAnirudh Venkataramanan static void ice_ena_misc_vector(struct ice_pf *pf) 2584940b61afSAnirudh Venkataramanan { 2585940b61afSAnirudh Venkataramanan struct ice_hw *hw = &pf->hw; 2586940b61afSAnirudh Venkataramanan u32 val; 2587940b61afSAnirudh Venkataramanan 25889d5c5a52SPaul Greenwalt /* Disable anti-spoof detection interrupt to prevent spurious event 25899d5c5a52SPaul Greenwalt * interrupts during a function reset. Anti-spoof functionally is 25909d5c5a52SPaul Greenwalt * still supported. 25919d5c5a52SPaul Greenwalt */ 25929d5c5a52SPaul Greenwalt val = rd32(hw, GL_MDCK_TX_TDPU); 25939d5c5a52SPaul Greenwalt val |= GL_MDCK_TX_TDPU_RCU_ANTISPOOF_ITR_DIS_M; 25949d5c5a52SPaul Greenwalt wr32(hw, GL_MDCK_TX_TDPU, val); 25959d5c5a52SPaul Greenwalt 2596940b61afSAnirudh Venkataramanan /* clear things first */ 2597940b61afSAnirudh Venkataramanan wr32(hw, PFINT_OICR_ENA, 0); /* disable all */ 2598940b61afSAnirudh Venkataramanan rd32(hw, PFINT_OICR); /* read to clear */ 2599940b61afSAnirudh Venkataramanan 26003bcd7fa3SBruce Allan val = (PFINT_OICR_ECC_ERR_M | 2601940b61afSAnirudh Venkataramanan PFINT_OICR_MAL_DETECT_M | 2602940b61afSAnirudh Venkataramanan PFINT_OICR_GRST_M | 2603940b61afSAnirudh Venkataramanan PFINT_OICR_PCI_EXCEPTION_M | 2604007676b4SAnirudh Venkataramanan PFINT_OICR_VFLR_M | 26053bcd7fa3SBruce Allan PFINT_OICR_HMC_ERR_M | 26063bcd7fa3SBruce Allan PFINT_OICR_PE_CRITERR_M); 2607940b61afSAnirudh Venkataramanan 2608940b61afSAnirudh Venkataramanan wr32(hw, PFINT_OICR_ENA, val); 2609940b61afSAnirudh Venkataramanan 2610940b61afSAnirudh Venkataramanan /* SW_ITR_IDX = 0, but don't change INTENA */ 2611cbe66bfeSBrett Creeley wr32(hw, GLINT_DYN_CTL(pf->oicr_idx), 2612940b61afSAnirudh Venkataramanan GLINT_DYN_CTL_SW_ITR_INDX_M | GLINT_DYN_CTL_INTENA_MSK_M); 2613940b61afSAnirudh Venkataramanan } 2614940b61afSAnirudh Venkataramanan 2615940b61afSAnirudh Venkataramanan /** 2616940b61afSAnirudh Venkataramanan * ice_misc_intr - misc interrupt handler 2617940b61afSAnirudh Venkataramanan * @irq: interrupt number 2618940b61afSAnirudh Venkataramanan * @data: pointer to a q_vector 2619940b61afSAnirudh Venkataramanan */ 2620940b61afSAnirudh Venkataramanan static irqreturn_t ice_misc_intr(int __always_unused irq, void *data) 2621940b61afSAnirudh Venkataramanan { 2622940b61afSAnirudh Venkataramanan struct ice_pf *pf = (struct ice_pf *)data; 2623940b61afSAnirudh Venkataramanan struct ice_hw *hw = &pf->hw; 2624940b61afSAnirudh Venkataramanan irqreturn_t ret = IRQ_NONE; 26254015d11eSBrett Creeley struct device *dev; 2626940b61afSAnirudh Venkataramanan u32 oicr, ena_mask; 2627940b61afSAnirudh Venkataramanan 26284015d11eSBrett Creeley dev = ice_pf_to_dev(pf); 26297e408e07SAnirudh Venkataramanan set_bit(ICE_ADMINQ_EVENT_PENDING, pf->state); 26307e408e07SAnirudh Venkataramanan set_bit(ICE_MAILBOXQ_EVENT_PENDING, pf->state); 2631940b61afSAnirudh Venkataramanan 2632940b61afSAnirudh Venkataramanan oicr = rd32(hw, PFINT_OICR); 2633940b61afSAnirudh Venkataramanan ena_mask = rd32(hw, PFINT_OICR_ENA); 2634940b61afSAnirudh Venkataramanan 26350e674aebSAnirudh Venkataramanan if (oicr & PFINT_OICR_SWINT_M) { 26360e674aebSAnirudh Venkataramanan ena_mask &= ~PFINT_OICR_SWINT_M; 26370e674aebSAnirudh Venkataramanan pf->sw_int_count++; 26380e674aebSAnirudh Venkataramanan } 26390e674aebSAnirudh Venkataramanan 2640b3969fd7SSudheer Mogilappagari if (oicr & PFINT_OICR_MAL_DETECT_M) { 2641b3969fd7SSudheer Mogilappagari ena_mask &= ~PFINT_OICR_MAL_DETECT_M; 26427e408e07SAnirudh Venkataramanan set_bit(ICE_MDD_EVENT_PENDING, pf->state); 2643b3969fd7SSudheer Mogilappagari } 2644007676b4SAnirudh Venkataramanan if (oicr & PFINT_OICR_VFLR_M) { 2645f844d521SBrett Creeley /* disable any further VFLR event notifications */ 26467e408e07SAnirudh Venkataramanan if (test_bit(ICE_VF_RESETS_DISABLED, pf->state)) { 2647f844d521SBrett Creeley u32 reg = rd32(hw, PFINT_OICR_ENA); 2648f844d521SBrett Creeley 2649f844d521SBrett Creeley reg &= ~PFINT_OICR_VFLR_M; 2650f844d521SBrett Creeley wr32(hw, PFINT_OICR_ENA, reg); 2651f844d521SBrett Creeley } else { 2652007676b4SAnirudh Venkataramanan ena_mask &= ~PFINT_OICR_VFLR_M; 26537e408e07SAnirudh Venkataramanan set_bit(ICE_VFLR_EVENT_PENDING, pf->state); 2654007676b4SAnirudh Venkataramanan } 2655f844d521SBrett Creeley } 2656b3969fd7SSudheer Mogilappagari 26570b28b702SAnirudh Venkataramanan if (oicr & PFINT_OICR_GRST_M) { 26580b28b702SAnirudh Venkataramanan u32 reset; 2659b3969fd7SSudheer Mogilappagari 26600b28b702SAnirudh Venkataramanan /* we have a reset warning */ 26610b28b702SAnirudh Venkataramanan ena_mask &= ~PFINT_OICR_GRST_M; 26620b28b702SAnirudh Venkataramanan reset = (rd32(hw, GLGEN_RSTAT) & GLGEN_RSTAT_RESET_TYPE_M) >> 26630b28b702SAnirudh Venkataramanan GLGEN_RSTAT_RESET_TYPE_S; 26640b28b702SAnirudh Venkataramanan 26650b28b702SAnirudh Venkataramanan if (reset == ICE_RESET_CORER) 26660b28b702SAnirudh Venkataramanan pf->corer_count++; 26670b28b702SAnirudh Venkataramanan else if (reset == ICE_RESET_GLOBR) 26680b28b702SAnirudh Venkataramanan pf->globr_count++; 2669ca4929b6SBrett Creeley else if (reset == ICE_RESET_EMPR) 26700b28b702SAnirudh Venkataramanan pf->empr_count++; 2671ca4929b6SBrett Creeley else 26724015d11eSBrett Creeley dev_dbg(dev, "Invalid reset type %d\n", reset); 26730b28b702SAnirudh Venkataramanan 26740b28b702SAnirudh Venkataramanan /* If a reset cycle isn't already in progress, we set a bit in 26750b28b702SAnirudh Venkataramanan * pf->state so that the service task can start a reset/rebuild. 26760b28b702SAnirudh Venkataramanan * We also make note of which reset happened so that peer 26770b28b702SAnirudh Venkataramanan * devices/drivers can be informed. 26780b28b702SAnirudh Venkataramanan */ 26797e408e07SAnirudh Venkataramanan if (!test_and_set_bit(ICE_RESET_OICR_RECV, pf->state)) { 26800b28b702SAnirudh Venkataramanan if (reset == ICE_RESET_CORER) 26817e408e07SAnirudh Venkataramanan set_bit(ICE_CORER_RECV, pf->state); 26820b28b702SAnirudh Venkataramanan else if (reset == ICE_RESET_GLOBR) 26837e408e07SAnirudh Venkataramanan set_bit(ICE_GLOBR_RECV, pf->state); 26840b28b702SAnirudh Venkataramanan else 26857e408e07SAnirudh Venkataramanan set_bit(ICE_EMPR_RECV, pf->state); 26860b28b702SAnirudh Venkataramanan 2687fd2a9817SAnirudh Venkataramanan /* There are couple of different bits at play here. 2688fd2a9817SAnirudh Venkataramanan * hw->reset_ongoing indicates whether the hardware is 2689fd2a9817SAnirudh Venkataramanan * in reset. This is set to true when a reset interrupt 2690fd2a9817SAnirudh Venkataramanan * is received and set back to false after the driver 2691fd2a9817SAnirudh Venkataramanan * has determined that the hardware is out of reset. 2692fd2a9817SAnirudh Venkataramanan * 26937e408e07SAnirudh Venkataramanan * ICE_RESET_OICR_RECV in pf->state indicates 2694fd2a9817SAnirudh Venkataramanan * that a post reset rebuild is required before the 2695fd2a9817SAnirudh Venkataramanan * driver is operational again. This is set above. 2696fd2a9817SAnirudh Venkataramanan * 2697fd2a9817SAnirudh Venkataramanan * As this is the start of the reset/rebuild cycle, set 2698fd2a9817SAnirudh Venkataramanan * both to indicate that. 2699fd2a9817SAnirudh Venkataramanan */ 2700fd2a9817SAnirudh Venkataramanan hw->reset_ongoing = true; 27010b28b702SAnirudh Venkataramanan } 27020b28b702SAnirudh Venkataramanan } 27030b28b702SAnirudh Venkataramanan 2704940b61afSAnirudh Venkataramanan if (oicr & PFINT_OICR_HMC_ERR_M) { 2705940b61afSAnirudh Venkataramanan ena_mask &= ~PFINT_OICR_HMC_ERR_M; 27064015d11eSBrett Creeley dev_dbg(dev, "HMC Error interrupt - info 0x%x, data 0x%x\n", 2707940b61afSAnirudh Venkataramanan rd32(hw, PFHMC_ERRORINFO), 2708940b61afSAnirudh Venkataramanan rd32(hw, PFHMC_ERRORDATA)); 2709940b61afSAnirudh Venkataramanan } 2710940b61afSAnirudh Venkataramanan 27118d7189d2SMd Fahad Iqbal Polash /* Report any remaining unexpected interrupts */ 2712940b61afSAnirudh Venkataramanan oicr &= ena_mask; 2713940b61afSAnirudh Venkataramanan if (oicr) { 27144015d11eSBrett Creeley dev_dbg(dev, "unhandled interrupt oicr=0x%08x\n", oicr); 2715940b61afSAnirudh Venkataramanan /* If a critical error is pending there is no choice but to 2716940b61afSAnirudh Venkataramanan * reset the device. 2717940b61afSAnirudh Venkataramanan */ 2718940b61afSAnirudh Venkataramanan if (oicr & (PFINT_OICR_PE_CRITERR_M | 2719940b61afSAnirudh Venkataramanan PFINT_OICR_PCI_EXCEPTION_M | 27200b28b702SAnirudh Venkataramanan PFINT_OICR_ECC_ERR_M)) { 27217e408e07SAnirudh Venkataramanan set_bit(ICE_PFR_REQ, pf->state); 27220b28b702SAnirudh Venkataramanan ice_service_task_schedule(pf); 27230b28b702SAnirudh Venkataramanan } 2724940b61afSAnirudh Venkataramanan } 2725940b61afSAnirudh Venkataramanan ret = IRQ_HANDLED; 2726940b61afSAnirudh Venkataramanan 2727940b61afSAnirudh Venkataramanan ice_service_task_schedule(pf); 2728cdedef59SAnirudh Venkataramanan ice_irq_dynamic_ena(hw, NULL, NULL); 2729940b61afSAnirudh Venkataramanan 2730940b61afSAnirudh Venkataramanan return ret; 2731940b61afSAnirudh Venkataramanan } 2732940b61afSAnirudh Venkataramanan 2733940b61afSAnirudh Venkataramanan /** 27340e04e8e1SBrett Creeley * ice_dis_ctrlq_interrupts - disable control queue interrupts 27350e04e8e1SBrett Creeley * @hw: pointer to HW structure 27360e04e8e1SBrett Creeley */ 27370e04e8e1SBrett Creeley static void ice_dis_ctrlq_interrupts(struct ice_hw *hw) 27380e04e8e1SBrett Creeley { 27390e04e8e1SBrett Creeley /* disable Admin queue Interrupt causes */ 27400e04e8e1SBrett Creeley wr32(hw, PFINT_FW_CTL, 27410e04e8e1SBrett Creeley rd32(hw, PFINT_FW_CTL) & ~PFINT_FW_CTL_CAUSE_ENA_M); 27420e04e8e1SBrett Creeley 27430e04e8e1SBrett Creeley /* disable Mailbox queue Interrupt causes */ 27440e04e8e1SBrett Creeley wr32(hw, PFINT_MBX_CTL, 27450e04e8e1SBrett Creeley rd32(hw, PFINT_MBX_CTL) & ~PFINT_MBX_CTL_CAUSE_ENA_M); 27460e04e8e1SBrett Creeley 27470e04e8e1SBrett Creeley /* disable Control queue Interrupt causes */ 27480e04e8e1SBrett Creeley wr32(hw, PFINT_OICR_CTL, 27490e04e8e1SBrett Creeley rd32(hw, PFINT_OICR_CTL) & ~PFINT_OICR_CTL_CAUSE_ENA_M); 27500e04e8e1SBrett Creeley 27510e04e8e1SBrett Creeley ice_flush(hw); 27520e04e8e1SBrett Creeley } 27530e04e8e1SBrett Creeley 27540e04e8e1SBrett Creeley /** 2755940b61afSAnirudh Venkataramanan * ice_free_irq_msix_misc - Unroll misc vector setup 2756940b61afSAnirudh Venkataramanan * @pf: board private structure 2757940b61afSAnirudh Venkataramanan */ 2758940b61afSAnirudh Venkataramanan static void ice_free_irq_msix_misc(struct ice_pf *pf) 2759940b61afSAnirudh Venkataramanan { 27600e04e8e1SBrett Creeley struct ice_hw *hw = &pf->hw; 27610e04e8e1SBrett Creeley 27620e04e8e1SBrett Creeley ice_dis_ctrlq_interrupts(hw); 27630e04e8e1SBrett Creeley 2764940b61afSAnirudh Venkataramanan /* disable OICR interrupt */ 27650e04e8e1SBrett Creeley wr32(hw, PFINT_OICR_ENA, 0); 27660e04e8e1SBrett Creeley ice_flush(hw); 2767940b61afSAnirudh Venkataramanan 2768ba880734SBrett Creeley if (pf->msix_entries) { 2769cbe66bfeSBrett Creeley synchronize_irq(pf->msix_entries[pf->oicr_idx].vector); 27704015d11eSBrett Creeley devm_free_irq(ice_pf_to_dev(pf), 2771cbe66bfeSBrett Creeley pf->msix_entries[pf->oicr_idx].vector, pf); 2772940b61afSAnirudh Venkataramanan } 2773940b61afSAnirudh Venkataramanan 2774eb0208ecSPreethi Banala pf->num_avail_sw_msix += 1; 2775cbe66bfeSBrett Creeley ice_free_res(pf->irq_tracker, pf->oicr_idx, ICE_RES_MISC_VEC_ID); 2776940b61afSAnirudh Venkataramanan } 2777940b61afSAnirudh Venkataramanan 2778940b61afSAnirudh Venkataramanan /** 27790e04e8e1SBrett Creeley * ice_ena_ctrlq_interrupts - enable control queue interrupts 27800e04e8e1SBrett Creeley * @hw: pointer to HW structure 2781b07833a0SBrett Creeley * @reg_idx: HW vector index to associate the control queue interrupts with 27820e04e8e1SBrett Creeley */ 2783b07833a0SBrett Creeley static void ice_ena_ctrlq_interrupts(struct ice_hw *hw, u16 reg_idx) 27840e04e8e1SBrett Creeley { 27850e04e8e1SBrett Creeley u32 val; 27860e04e8e1SBrett Creeley 2787b07833a0SBrett Creeley val = ((reg_idx & PFINT_OICR_CTL_MSIX_INDX_M) | 27880e04e8e1SBrett Creeley PFINT_OICR_CTL_CAUSE_ENA_M); 27890e04e8e1SBrett Creeley wr32(hw, PFINT_OICR_CTL, val); 27900e04e8e1SBrett Creeley 27910e04e8e1SBrett Creeley /* enable Admin queue Interrupt causes */ 2792b07833a0SBrett Creeley val = ((reg_idx & PFINT_FW_CTL_MSIX_INDX_M) | 27930e04e8e1SBrett Creeley PFINT_FW_CTL_CAUSE_ENA_M); 27940e04e8e1SBrett Creeley wr32(hw, PFINT_FW_CTL, val); 27950e04e8e1SBrett Creeley 27960e04e8e1SBrett Creeley /* enable Mailbox queue Interrupt causes */ 2797b07833a0SBrett Creeley val = ((reg_idx & PFINT_MBX_CTL_MSIX_INDX_M) | 27980e04e8e1SBrett Creeley PFINT_MBX_CTL_CAUSE_ENA_M); 27990e04e8e1SBrett Creeley wr32(hw, PFINT_MBX_CTL, val); 28000e04e8e1SBrett Creeley 28010e04e8e1SBrett Creeley ice_flush(hw); 28020e04e8e1SBrett Creeley } 28030e04e8e1SBrett Creeley 28040e04e8e1SBrett Creeley /** 2805940b61afSAnirudh Venkataramanan * ice_req_irq_msix_misc - Setup the misc vector to handle non queue events 2806940b61afSAnirudh Venkataramanan * @pf: board private structure 2807940b61afSAnirudh Venkataramanan * 2808940b61afSAnirudh Venkataramanan * This sets up the handler for MSIX 0, which is used to manage the 2809940b61afSAnirudh Venkataramanan * non-queue interrupts, e.g. AdminQ and errors. This is not used 2810940b61afSAnirudh Venkataramanan * when in MSI or Legacy interrupt mode. 2811940b61afSAnirudh Venkataramanan */ 2812940b61afSAnirudh Venkataramanan static int ice_req_irq_msix_misc(struct ice_pf *pf) 2813940b61afSAnirudh Venkataramanan { 28144015d11eSBrett Creeley struct device *dev = ice_pf_to_dev(pf); 2815940b61afSAnirudh Venkataramanan struct ice_hw *hw = &pf->hw; 2816940b61afSAnirudh Venkataramanan int oicr_idx, err = 0; 2817940b61afSAnirudh Venkataramanan 2818940b61afSAnirudh Venkataramanan if (!pf->int_name[0]) 2819940b61afSAnirudh Venkataramanan snprintf(pf->int_name, sizeof(pf->int_name) - 1, "%s-%s:misc", 28204015d11eSBrett Creeley dev_driver_string(dev), dev_name(dev)); 2821940b61afSAnirudh Venkataramanan 28220b28b702SAnirudh Venkataramanan /* Do not request IRQ but do enable OICR interrupt since settings are 28230b28b702SAnirudh Venkataramanan * lost during reset. Note that this function is called only during 28240b28b702SAnirudh Venkataramanan * rebuild path and not while reset is in progress. 28250b28b702SAnirudh Venkataramanan */ 28265df7e45dSDave Ertman if (ice_is_reset_in_progress(pf->state)) 28270b28b702SAnirudh Venkataramanan goto skip_req_irq; 28280b28b702SAnirudh Venkataramanan 2829cbe66bfeSBrett Creeley /* reserve one vector in irq_tracker for misc interrupts */ 2830cbe66bfeSBrett Creeley oicr_idx = ice_get_res(pf, pf->irq_tracker, 1, ICE_RES_MISC_VEC_ID); 2831940b61afSAnirudh Venkataramanan if (oicr_idx < 0) 2832940b61afSAnirudh Venkataramanan return oicr_idx; 2833940b61afSAnirudh Venkataramanan 2834eb0208ecSPreethi Banala pf->num_avail_sw_msix -= 1; 283588865fc4SKarol Kolacinski pf->oicr_idx = (u16)oicr_idx; 2836940b61afSAnirudh Venkataramanan 28374015d11eSBrett Creeley err = devm_request_irq(dev, pf->msix_entries[pf->oicr_idx].vector, 2838940b61afSAnirudh Venkataramanan ice_misc_intr, 0, pf->int_name, pf); 2839940b61afSAnirudh Venkataramanan if (err) { 28404015d11eSBrett Creeley dev_err(dev, "devm_request_irq for %s failed: %d\n", 2841940b61afSAnirudh Venkataramanan pf->int_name, err); 2842cbe66bfeSBrett Creeley ice_free_res(pf->irq_tracker, 1, ICE_RES_MISC_VEC_ID); 2843eb0208ecSPreethi Banala pf->num_avail_sw_msix += 1; 2844940b61afSAnirudh Venkataramanan return err; 2845940b61afSAnirudh Venkataramanan } 2846940b61afSAnirudh Venkataramanan 28470b28b702SAnirudh Venkataramanan skip_req_irq: 2848940b61afSAnirudh Venkataramanan ice_ena_misc_vector(pf); 2849940b61afSAnirudh Venkataramanan 2850cbe66bfeSBrett Creeley ice_ena_ctrlq_interrupts(hw, pf->oicr_idx); 2851cbe66bfeSBrett Creeley wr32(hw, GLINT_ITR(ICE_RX_ITR, pf->oicr_idx), 285263f545edSBrett Creeley ITR_REG_ALIGN(ICE_ITR_8K) >> ICE_ITR_GRAN_S); 2853940b61afSAnirudh Venkataramanan 2854940b61afSAnirudh Venkataramanan ice_flush(hw); 2855cdedef59SAnirudh Venkataramanan ice_irq_dynamic_ena(hw, NULL, NULL); 2856940b61afSAnirudh Venkataramanan 2857940b61afSAnirudh Venkataramanan return 0; 2858940b61afSAnirudh Venkataramanan } 2859940b61afSAnirudh Venkataramanan 2860940b61afSAnirudh Venkataramanan /** 2861df0f8479SAnirudh Venkataramanan * ice_napi_add - register NAPI handler for the VSI 2862df0f8479SAnirudh Venkataramanan * @vsi: VSI for which NAPI handler is to be registered 2863df0f8479SAnirudh Venkataramanan * 2864df0f8479SAnirudh Venkataramanan * This function is only called in the driver's load path. Registering the NAPI 2865df0f8479SAnirudh Venkataramanan * handler is done in ice_vsi_alloc_q_vector() for all other cases (i.e. resume, 2866df0f8479SAnirudh Venkataramanan * reset/rebuild, etc.) 2867df0f8479SAnirudh Venkataramanan */ 2868df0f8479SAnirudh Venkataramanan static void ice_napi_add(struct ice_vsi *vsi) 2869df0f8479SAnirudh Venkataramanan { 2870df0f8479SAnirudh Venkataramanan int v_idx; 2871df0f8479SAnirudh Venkataramanan 2872df0f8479SAnirudh Venkataramanan if (!vsi->netdev) 2873df0f8479SAnirudh Venkataramanan return; 2874df0f8479SAnirudh Venkataramanan 28750c2561c8SBrett Creeley ice_for_each_q_vector(vsi, v_idx) 2876df0f8479SAnirudh Venkataramanan netif_napi_add(vsi->netdev, &vsi->q_vectors[v_idx]->napi, 2877df0f8479SAnirudh Venkataramanan ice_napi_poll, NAPI_POLL_WEIGHT); 2878df0f8479SAnirudh Venkataramanan } 2879df0f8479SAnirudh Venkataramanan 2880df0f8479SAnirudh Venkataramanan /** 2881462acf6aSTony Nguyen * ice_set_ops - set netdev and ethtools ops for the given netdev 2882462acf6aSTony Nguyen * @netdev: netdev instance 28833a858ba3SAnirudh Venkataramanan */ 2884462acf6aSTony Nguyen static void ice_set_ops(struct net_device *netdev) 28853a858ba3SAnirudh Venkataramanan { 2886462acf6aSTony Nguyen struct ice_pf *pf = ice_netdev_to_pf(netdev); 2887462acf6aSTony Nguyen 2888462acf6aSTony Nguyen if (ice_is_safe_mode(pf)) { 2889462acf6aSTony Nguyen netdev->netdev_ops = &ice_netdev_safe_mode_ops; 2890462acf6aSTony Nguyen ice_set_ethtool_safe_mode_ops(netdev); 2891462acf6aSTony Nguyen return; 2892462acf6aSTony Nguyen } 2893462acf6aSTony Nguyen 2894462acf6aSTony Nguyen netdev->netdev_ops = &ice_netdev_ops; 2895b20e6c17SJakub Kicinski netdev->udp_tunnel_nic_info = &pf->hw.udp_tunnel_nic; 2896462acf6aSTony Nguyen ice_set_ethtool_ops(netdev); 2897462acf6aSTony Nguyen } 2898462acf6aSTony Nguyen 2899462acf6aSTony Nguyen /** 2900462acf6aSTony Nguyen * ice_set_netdev_features - set features for the given netdev 2901462acf6aSTony Nguyen * @netdev: netdev instance 2902462acf6aSTony Nguyen */ 2903462acf6aSTony Nguyen static void ice_set_netdev_features(struct net_device *netdev) 2904462acf6aSTony Nguyen { 2905462acf6aSTony Nguyen struct ice_pf *pf = ice_netdev_to_pf(netdev); 2906d76a60baSAnirudh Venkataramanan netdev_features_t csumo_features; 2907d76a60baSAnirudh Venkataramanan netdev_features_t vlano_features; 2908d76a60baSAnirudh Venkataramanan netdev_features_t dflt_features; 2909d76a60baSAnirudh Venkataramanan netdev_features_t tso_features; 29103a858ba3SAnirudh Venkataramanan 2911462acf6aSTony Nguyen if (ice_is_safe_mode(pf)) { 2912462acf6aSTony Nguyen /* safe mode */ 2913462acf6aSTony Nguyen netdev->features = NETIF_F_SG | NETIF_F_HIGHDMA; 2914462acf6aSTony Nguyen netdev->hw_features = netdev->features; 2915462acf6aSTony Nguyen return; 2916462acf6aSTony Nguyen } 29173a858ba3SAnirudh Venkataramanan 2918d76a60baSAnirudh Venkataramanan dflt_features = NETIF_F_SG | 29193a858ba3SAnirudh Venkataramanan NETIF_F_HIGHDMA | 2920148beb61SHenry Tieman NETIF_F_NTUPLE | 29213a858ba3SAnirudh Venkataramanan NETIF_F_RXHASH; 29223a858ba3SAnirudh Venkataramanan 2923d76a60baSAnirudh Venkataramanan csumo_features = NETIF_F_RXCSUM | 2924d76a60baSAnirudh Venkataramanan NETIF_F_IP_CSUM | 2925cf909e19SAnirudh Venkataramanan NETIF_F_SCTP_CRC | 2926d76a60baSAnirudh Venkataramanan NETIF_F_IPV6_CSUM; 2927d76a60baSAnirudh Venkataramanan 2928d76a60baSAnirudh Venkataramanan vlano_features = NETIF_F_HW_VLAN_CTAG_FILTER | 2929d76a60baSAnirudh Venkataramanan NETIF_F_HW_VLAN_CTAG_TX | 2930d76a60baSAnirudh Venkataramanan NETIF_F_HW_VLAN_CTAG_RX; 2931d76a60baSAnirudh Venkataramanan 2932a54e3b8cSBrett Creeley tso_features = NETIF_F_TSO | 2933a4e82a81STony Nguyen NETIF_F_TSO_ECN | 2934a4e82a81STony Nguyen NETIF_F_TSO6 | 2935a4e82a81STony Nguyen NETIF_F_GSO_GRE | 2936a4e82a81STony Nguyen NETIF_F_GSO_UDP_TUNNEL | 2937a4e82a81STony Nguyen NETIF_F_GSO_GRE_CSUM | 2938a4e82a81STony Nguyen NETIF_F_GSO_UDP_TUNNEL_CSUM | 2939a4e82a81STony Nguyen NETIF_F_GSO_PARTIAL | 2940a4e82a81STony Nguyen NETIF_F_GSO_IPXIP4 | 2941a4e82a81STony Nguyen NETIF_F_GSO_IPXIP6 | 2942a54e3b8cSBrett Creeley NETIF_F_GSO_UDP_L4; 2943d76a60baSAnirudh Venkataramanan 2944a4e82a81STony Nguyen netdev->gso_partial_features |= NETIF_F_GSO_UDP_TUNNEL_CSUM | 2945a4e82a81STony Nguyen NETIF_F_GSO_GRE_CSUM; 2946d76a60baSAnirudh Venkataramanan /* set features that user can change */ 2947d76a60baSAnirudh Venkataramanan netdev->hw_features = dflt_features | csumo_features | 2948d76a60baSAnirudh Venkataramanan vlano_features | tso_features; 2949d76a60baSAnirudh Venkataramanan 2950a4e82a81STony Nguyen /* add support for HW_CSUM on packets with MPLS header */ 2951a4e82a81STony Nguyen netdev->mpls_features = NETIF_F_HW_CSUM; 2952a4e82a81STony Nguyen 29533a858ba3SAnirudh Venkataramanan /* enable features */ 29543a858ba3SAnirudh Venkataramanan netdev->features |= netdev->hw_features; 2955d76a60baSAnirudh Venkataramanan /* encap and VLAN devices inherit default, csumo and tso features */ 2956d76a60baSAnirudh Venkataramanan netdev->hw_enc_features |= dflt_features | csumo_features | 2957d76a60baSAnirudh Venkataramanan tso_features; 2958d76a60baSAnirudh Venkataramanan netdev->vlan_features |= dflt_features | csumo_features | 2959d76a60baSAnirudh Venkataramanan tso_features; 2960462acf6aSTony Nguyen } 2961462acf6aSTony Nguyen 2962462acf6aSTony Nguyen /** 2963462acf6aSTony Nguyen * ice_cfg_netdev - Allocate, configure and register a netdev 2964462acf6aSTony Nguyen * @vsi: the VSI associated with the new netdev 2965462acf6aSTony Nguyen * 2966462acf6aSTony Nguyen * Returns 0 on success, negative value on failure 2967462acf6aSTony Nguyen */ 2968462acf6aSTony Nguyen static int ice_cfg_netdev(struct ice_vsi *vsi) 2969462acf6aSTony Nguyen { 2970462acf6aSTony Nguyen struct ice_pf *pf = vsi->back; 2971462acf6aSTony Nguyen struct ice_netdev_priv *np; 2972462acf6aSTony Nguyen struct net_device *netdev; 2973462acf6aSTony Nguyen u8 mac_addr[ETH_ALEN]; 29741adf7eadSJacob Keller 2975462acf6aSTony Nguyen netdev = alloc_etherdev_mqs(sizeof(*np), vsi->alloc_txq, 2976462acf6aSTony Nguyen vsi->alloc_rxq); 29771e23f076SAnirudh Venkataramanan if (!netdev) 29781e23f076SAnirudh Venkataramanan return -ENOMEM; 2979462acf6aSTony Nguyen 2980a476d72aSAnirudh Venkataramanan set_bit(ICE_VSI_NETDEV_ALLOCD, vsi->state); 2981462acf6aSTony Nguyen vsi->netdev = netdev; 2982462acf6aSTony Nguyen np = netdev_priv(netdev); 2983462acf6aSTony Nguyen np->vsi = vsi; 2984462acf6aSTony Nguyen 2985462acf6aSTony Nguyen ice_set_netdev_features(netdev); 2986462acf6aSTony Nguyen 2987462acf6aSTony Nguyen ice_set_ops(netdev); 29883a858ba3SAnirudh Venkataramanan 29893a858ba3SAnirudh Venkataramanan if (vsi->type == ICE_VSI_PF) { 29904015d11eSBrett Creeley SET_NETDEV_DEV(netdev, ice_pf_to_dev(pf)); 29913a858ba3SAnirudh Venkataramanan ether_addr_copy(mac_addr, vsi->port_info->mac.perm_addr); 29923a858ba3SAnirudh Venkataramanan ether_addr_copy(netdev->dev_addr, mac_addr); 29933a858ba3SAnirudh Venkataramanan ether_addr_copy(netdev->perm_addr, mac_addr); 29943a858ba3SAnirudh Venkataramanan } 29953a858ba3SAnirudh Venkataramanan 29963a858ba3SAnirudh Venkataramanan netdev->priv_flags |= IFF_UNICAST_FLT; 29973a858ba3SAnirudh Venkataramanan 2998462acf6aSTony Nguyen /* Setup netdev TC information */ 2999462acf6aSTony Nguyen ice_vsi_cfg_netdev_tc(vsi, vsi->tc_cfg.ena_tc); 3000cdedef59SAnirudh Venkataramanan 30013a858ba3SAnirudh Venkataramanan /* setup watchdog timeout value to be 5 second */ 30023a858ba3SAnirudh Venkataramanan netdev->watchdog_timeo = 5 * HZ; 30033a858ba3SAnirudh Venkataramanan 30043a858ba3SAnirudh Venkataramanan netdev->min_mtu = ETH_MIN_MTU; 30053a858ba3SAnirudh Venkataramanan netdev->max_mtu = ICE_MAX_MTU; 30063a858ba3SAnirudh Venkataramanan 30073a858ba3SAnirudh Venkataramanan return 0; 30083a858ba3SAnirudh Venkataramanan } 30093a858ba3SAnirudh Venkataramanan 30103a858ba3SAnirudh Venkataramanan /** 3011d76a60baSAnirudh Venkataramanan * ice_fill_rss_lut - Fill the RSS lookup table with default values 3012d76a60baSAnirudh Venkataramanan * @lut: Lookup table 3013d76a60baSAnirudh Venkataramanan * @rss_table_size: Lookup table size 3014d76a60baSAnirudh Venkataramanan * @rss_size: Range of queue number for hashing 3015d76a60baSAnirudh Venkataramanan */ 3016d76a60baSAnirudh Venkataramanan void ice_fill_rss_lut(u8 *lut, u16 rss_table_size, u16 rss_size) 3017d76a60baSAnirudh Venkataramanan { 3018d76a60baSAnirudh Venkataramanan u16 i; 3019d76a60baSAnirudh Venkataramanan 3020d76a60baSAnirudh Venkataramanan for (i = 0; i < rss_table_size; i++) 3021d76a60baSAnirudh Venkataramanan lut[i] = i % rss_size; 3022d76a60baSAnirudh Venkataramanan } 3023d76a60baSAnirudh Venkataramanan 3024d76a60baSAnirudh Venkataramanan /** 30250f9d5027SAnirudh Venkataramanan * ice_pf_vsi_setup - Set up a PF VSI 30260f9d5027SAnirudh Venkataramanan * @pf: board private structure 30270f9d5027SAnirudh Venkataramanan * @pi: pointer to the port_info instance 30280f9d5027SAnirudh Venkataramanan * 30290e674aebSAnirudh Venkataramanan * Returns pointer to the successfully allocated VSI software struct 30300e674aebSAnirudh Venkataramanan * on success, otherwise returns NULL on failure. 30310f9d5027SAnirudh Venkataramanan */ 30320f9d5027SAnirudh Venkataramanan static struct ice_vsi * 30330f9d5027SAnirudh Venkataramanan ice_pf_vsi_setup(struct ice_pf *pf, struct ice_port_info *pi) 30340f9d5027SAnirudh Venkataramanan { 30350f9d5027SAnirudh Venkataramanan return ice_vsi_setup(pf, pi, ICE_VSI_PF, ICE_INVAL_VFID); 30360f9d5027SAnirudh Venkataramanan } 30370f9d5027SAnirudh Venkataramanan 30380f9d5027SAnirudh Venkataramanan /** 3039148beb61SHenry Tieman * ice_ctrl_vsi_setup - Set up a control VSI 3040148beb61SHenry Tieman * @pf: board private structure 3041148beb61SHenry Tieman * @pi: pointer to the port_info instance 3042148beb61SHenry Tieman * 3043148beb61SHenry Tieman * Returns pointer to the successfully allocated VSI software struct 3044148beb61SHenry Tieman * on success, otherwise returns NULL on failure. 3045148beb61SHenry Tieman */ 3046148beb61SHenry Tieman static struct ice_vsi * 3047148beb61SHenry Tieman ice_ctrl_vsi_setup(struct ice_pf *pf, struct ice_port_info *pi) 3048148beb61SHenry Tieman { 3049148beb61SHenry Tieman return ice_vsi_setup(pf, pi, ICE_VSI_CTRL, ICE_INVAL_VFID); 3050148beb61SHenry Tieman } 3051148beb61SHenry Tieman 3052148beb61SHenry Tieman /** 30530e674aebSAnirudh Venkataramanan * ice_lb_vsi_setup - Set up a loopback VSI 30540e674aebSAnirudh Venkataramanan * @pf: board private structure 30550e674aebSAnirudh Venkataramanan * @pi: pointer to the port_info instance 30560e674aebSAnirudh Venkataramanan * 30570e674aebSAnirudh Venkataramanan * Returns pointer to the successfully allocated VSI software struct 30580e674aebSAnirudh Venkataramanan * on success, otherwise returns NULL on failure. 30590e674aebSAnirudh Venkataramanan */ 30600e674aebSAnirudh Venkataramanan struct ice_vsi * 30610e674aebSAnirudh Venkataramanan ice_lb_vsi_setup(struct ice_pf *pf, struct ice_port_info *pi) 30620e674aebSAnirudh Venkataramanan { 30630e674aebSAnirudh Venkataramanan return ice_vsi_setup(pf, pi, ICE_VSI_LB, ICE_INVAL_VFID); 30640e674aebSAnirudh Venkataramanan } 30650e674aebSAnirudh Venkataramanan 30660e674aebSAnirudh Venkataramanan /** 3067f9867df6SAnirudh Venkataramanan * ice_vlan_rx_add_vid - Add a VLAN ID filter to HW offload 3068d76a60baSAnirudh Venkataramanan * @netdev: network interface to be adjusted 3069d76a60baSAnirudh Venkataramanan * @proto: unused protocol 3070f9867df6SAnirudh Venkataramanan * @vid: VLAN ID to be added 3071d76a60baSAnirudh Venkataramanan * 3072f9867df6SAnirudh Venkataramanan * net_device_ops implementation for adding VLAN IDs 3073d76a60baSAnirudh Venkataramanan */ 3074c8b7abddSBruce Allan static int 3075c8b7abddSBruce Allan ice_vlan_rx_add_vid(struct net_device *netdev, __always_unused __be16 proto, 3076c8b7abddSBruce Allan u16 vid) 3077d76a60baSAnirudh Venkataramanan { 3078d76a60baSAnirudh Venkataramanan struct ice_netdev_priv *np = netdev_priv(netdev); 3079d76a60baSAnirudh Venkataramanan struct ice_vsi *vsi = np->vsi; 30805eda8afdSAkeem G Abodunrin int ret; 3081d76a60baSAnirudh Venkataramanan 308242f3efefSBrett Creeley /* VLAN 0 is added by default during load/reset */ 308342f3efefSBrett Creeley if (!vid) 308442f3efefSBrett Creeley return 0; 308542f3efefSBrett Creeley 308642f3efefSBrett Creeley /* Enable VLAN pruning when a VLAN other than 0 is added */ 308742f3efefSBrett Creeley if (!ice_vsi_is_vlan_pruning_ena(vsi)) { 30885eda8afdSAkeem G Abodunrin ret = ice_cfg_vlan_pruning(vsi, true, false); 30894f74dcc1SBrett Creeley if (ret) 30904f74dcc1SBrett Creeley return ret; 30914f74dcc1SBrett Creeley } 30924f74dcc1SBrett Creeley 309342f3efefSBrett Creeley /* Add a switch rule for this VLAN ID so its corresponding VLAN tagged 309442f3efefSBrett Creeley * packets aren't pruned by the device's internal switch on Rx 3095d76a60baSAnirudh Venkataramanan */ 30961b8f15b6SMichal Swiatkowski ret = ice_vsi_add_vlan(vsi, vid, ICE_FWD_TO_VSI); 3097bcf68ea1SNick Nunley if (!ret) 3098e97fb1aeSAnirudh Venkataramanan set_bit(ICE_VSI_VLAN_FLTR_CHANGED, vsi->state); 30995eda8afdSAkeem G Abodunrin 31005eda8afdSAkeem G Abodunrin return ret; 3101d76a60baSAnirudh Venkataramanan } 3102d76a60baSAnirudh Venkataramanan 3103d76a60baSAnirudh Venkataramanan /** 3104f9867df6SAnirudh Venkataramanan * ice_vlan_rx_kill_vid - Remove a VLAN ID filter from HW offload 3105d76a60baSAnirudh Venkataramanan * @netdev: network interface to be adjusted 3106d76a60baSAnirudh Venkataramanan * @proto: unused protocol 3107f9867df6SAnirudh Venkataramanan * @vid: VLAN ID to be removed 3108d76a60baSAnirudh Venkataramanan * 3109f9867df6SAnirudh Venkataramanan * net_device_ops implementation for removing VLAN IDs 3110d76a60baSAnirudh Venkataramanan */ 3111c8b7abddSBruce Allan static int 3112c8b7abddSBruce Allan ice_vlan_rx_kill_vid(struct net_device *netdev, __always_unused __be16 proto, 3113c8b7abddSBruce Allan u16 vid) 3114d76a60baSAnirudh Venkataramanan { 3115d76a60baSAnirudh Venkataramanan struct ice_netdev_priv *np = netdev_priv(netdev); 3116d76a60baSAnirudh Venkataramanan struct ice_vsi *vsi = np->vsi; 31175eda8afdSAkeem G Abodunrin int ret; 3118d76a60baSAnirudh Venkataramanan 311942f3efefSBrett Creeley /* don't allow removal of VLAN 0 */ 312042f3efefSBrett Creeley if (!vid) 312142f3efefSBrett Creeley return 0; 312242f3efefSBrett Creeley 31234f74dcc1SBrett Creeley /* Make sure ice_vsi_kill_vlan is successful before updating VLAN 31244f74dcc1SBrett Creeley * information 3125d76a60baSAnirudh Venkataramanan */ 31265eda8afdSAkeem G Abodunrin ret = ice_vsi_kill_vlan(vsi, vid); 31275eda8afdSAkeem G Abodunrin if (ret) 31285eda8afdSAkeem G Abodunrin return ret; 3129d76a60baSAnirudh Venkataramanan 313042f3efefSBrett Creeley /* Disable pruning when VLAN 0 is the only VLAN rule */ 313142f3efefSBrett Creeley if (vsi->num_vlan == 1 && ice_vsi_is_vlan_pruning_ena(vsi)) 31325eda8afdSAkeem G Abodunrin ret = ice_cfg_vlan_pruning(vsi, false, false); 31334f74dcc1SBrett Creeley 3134e97fb1aeSAnirudh Venkataramanan set_bit(ICE_VSI_VLAN_FLTR_CHANGED, vsi->state); 31355eda8afdSAkeem G Abodunrin return ret; 3136d76a60baSAnirudh Venkataramanan } 3137d76a60baSAnirudh Venkataramanan 3138d76a60baSAnirudh Venkataramanan /** 31393a858ba3SAnirudh Venkataramanan * ice_setup_pf_sw - Setup the HW switch on startup or after reset 31403a858ba3SAnirudh Venkataramanan * @pf: board private structure 31413a858ba3SAnirudh Venkataramanan * 31423a858ba3SAnirudh Venkataramanan * Returns 0 on success, negative value on failure 31433a858ba3SAnirudh Venkataramanan */ 31443a858ba3SAnirudh Venkataramanan static int ice_setup_pf_sw(struct ice_pf *pf) 31453a858ba3SAnirudh Venkataramanan { 31463a858ba3SAnirudh Venkataramanan struct ice_vsi *vsi; 31473a858ba3SAnirudh Venkataramanan int status = 0; 31483a858ba3SAnirudh Venkataramanan 31495df7e45dSDave Ertman if (ice_is_reset_in_progress(pf->state)) 31500f9d5027SAnirudh Venkataramanan return -EBUSY; 31510f9d5027SAnirudh Venkataramanan 31520f9d5027SAnirudh Venkataramanan vsi = ice_pf_vsi_setup(pf, pf->hw.port_info); 3153135f4b9eSJacob Keller if (!vsi) 3154135f4b9eSJacob Keller return -ENOMEM; 31553a858ba3SAnirudh Venkataramanan 3156df0f8479SAnirudh Venkataramanan status = ice_cfg_netdev(vsi); 3157df0f8479SAnirudh Venkataramanan if (status) { 3158df0f8479SAnirudh Venkataramanan status = -ENODEV; 3159df0f8479SAnirudh Venkataramanan goto unroll_vsi_setup; 3160df0f8479SAnirudh Venkataramanan } 3161efc2214bSMaciej Fijalkowski /* netdev has to be configured before setting frame size */ 3162efc2214bSMaciej Fijalkowski ice_vsi_cfg_frame_size(vsi); 3163df0f8479SAnirudh Venkataramanan 3164b94b013eSDave Ertman /* Setup DCB netlink interface */ 3165b94b013eSDave Ertman ice_dcbnl_setup(vsi); 3166b94b013eSDave Ertman 3167df0f8479SAnirudh Venkataramanan /* registering the NAPI handler requires both the queues and 3168df0f8479SAnirudh Venkataramanan * netdev to be created, which are done in ice_pf_vsi_setup() 3169df0f8479SAnirudh Venkataramanan * and ice_cfg_netdev() respectively 3170df0f8479SAnirudh Venkataramanan */ 3171df0f8479SAnirudh Venkataramanan ice_napi_add(vsi); 3172df0f8479SAnirudh Venkataramanan 317328bf2672SBrett Creeley status = ice_set_cpu_rx_rmap(vsi); 317428bf2672SBrett Creeley if (status) { 317528bf2672SBrett Creeley dev_err(ice_pf_to_dev(pf), "Failed to set CPU Rx map VSI %d error %d\n", 317628bf2672SBrett Creeley vsi->vsi_num, status); 317728bf2672SBrett Creeley status = -EINVAL; 317828bf2672SBrett Creeley goto unroll_napi_add; 317928bf2672SBrett Creeley } 3180561f4379STony Nguyen status = ice_init_mac_fltr(pf); 31819daf8208SAnirudh Venkataramanan if (status) 318228bf2672SBrett Creeley goto free_cpu_rx_map; 31839daf8208SAnirudh Venkataramanan 31849daf8208SAnirudh Venkataramanan return status; 31859daf8208SAnirudh Venkataramanan 318628bf2672SBrett Creeley free_cpu_rx_map: 318728bf2672SBrett Creeley ice_free_cpu_rx_rmap(vsi); 318828bf2672SBrett Creeley 3189df0f8479SAnirudh Venkataramanan unroll_napi_add: 31903a858ba3SAnirudh Venkataramanan if (vsi) { 3191df0f8479SAnirudh Venkataramanan ice_napi_del(vsi); 31923a858ba3SAnirudh Venkataramanan if (vsi->netdev) { 3193a476d72aSAnirudh Venkataramanan clear_bit(ICE_VSI_NETDEV_ALLOCD, vsi->state); 31943a858ba3SAnirudh Venkataramanan free_netdev(vsi->netdev); 31953a858ba3SAnirudh Venkataramanan vsi->netdev = NULL; 31963a858ba3SAnirudh Venkataramanan } 3197df0f8479SAnirudh Venkataramanan } 31989daf8208SAnirudh Venkataramanan 3199df0f8479SAnirudh Venkataramanan unroll_vsi_setup: 3200135f4b9eSJacob Keller ice_vsi_release(vsi); 32013a858ba3SAnirudh Venkataramanan return status; 32023a858ba3SAnirudh Venkataramanan } 32033a858ba3SAnirudh Venkataramanan 32043a858ba3SAnirudh Venkataramanan /** 32058c243700SAnirudh Venkataramanan * ice_get_avail_q_count - Get count of queues in use 32068c243700SAnirudh Venkataramanan * @pf_qmap: bitmap to get queue use count from 32078c243700SAnirudh Venkataramanan * @lock: pointer to a mutex that protects access to pf_qmap 32088c243700SAnirudh Venkataramanan * @size: size of the bitmap 3209940b61afSAnirudh Venkataramanan */ 32108c243700SAnirudh Venkataramanan static u16 32118c243700SAnirudh Venkataramanan ice_get_avail_q_count(unsigned long *pf_qmap, struct mutex *lock, u16 size) 3212940b61afSAnirudh Venkataramanan { 321388865fc4SKarol Kolacinski unsigned long bit; 321488865fc4SKarol Kolacinski u16 count = 0; 3215940b61afSAnirudh Venkataramanan 32168c243700SAnirudh Venkataramanan mutex_lock(lock); 32178c243700SAnirudh Venkataramanan for_each_clear_bit(bit, pf_qmap, size) 32188c243700SAnirudh Venkataramanan count++; 32198c243700SAnirudh Venkataramanan mutex_unlock(lock); 3220940b61afSAnirudh Venkataramanan 32218c243700SAnirudh Venkataramanan return count; 32228c243700SAnirudh Venkataramanan } 3223d76a60baSAnirudh Venkataramanan 32248c243700SAnirudh Venkataramanan /** 32258c243700SAnirudh Venkataramanan * ice_get_avail_txq_count - Get count of Tx queues in use 32268c243700SAnirudh Venkataramanan * @pf: pointer to an ice_pf instance 32278c243700SAnirudh Venkataramanan */ 32288c243700SAnirudh Venkataramanan u16 ice_get_avail_txq_count(struct ice_pf *pf) 32298c243700SAnirudh Venkataramanan { 32308c243700SAnirudh Venkataramanan return ice_get_avail_q_count(pf->avail_txqs, &pf->avail_q_mutex, 32318c243700SAnirudh Venkataramanan pf->max_pf_txqs); 32328c243700SAnirudh Venkataramanan } 3233940b61afSAnirudh Venkataramanan 32348c243700SAnirudh Venkataramanan /** 32358c243700SAnirudh Venkataramanan * ice_get_avail_rxq_count - Get count of Rx queues in use 32368c243700SAnirudh Venkataramanan * @pf: pointer to an ice_pf instance 32378c243700SAnirudh Venkataramanan */ 32388c243700SAnirudh Venkataramanan u16 ice_get_avail_rxq_count(struct ice_pf *pf) 32398c243700SAnirudh Venkataramanan { 32408c243700SAnirudh Venkataramanan return ice_get_avail_q_count(pf->avail_rxqs, &pf->avail_q_mutex, 32418c243700SAnirudh Venkataramanan pf->max_pf_rxqs); 3242940b61afSAnirudh Venkataramanan } 3243940b61afSAnirudh Venkataramanan 3244940b61afSAnirudh Venkataramanan /** 3245940b61afSAnirudh Venkataramanan * ice_deinit_pf - Unrolls initialziations done by ice_init_pf 3246940b61afSAnirudh Venkataramanan * @pf: board private structure to initialize 3247940b61afSAnirudh Venkataramanan */ 3248940b61afSAnirudh Venkataramanan static void ice_deinit_pf(struct ice_pf *pf) 3249940b61afSAnirudh Venkataramanan { 32508d81fa55SAkeem G Abodunrin ice_service_task_stop(pf); 3251940b61afSAnirudh Venkataramanan mutex_destroy(&pf->sw_mutex); 3252b94b013eSDave Ertman mutex_destroy(&pf->tc_mutex); 3253940b61afSAnirudh Venkataramanan mutex_destroy(&pf->avail_q_mutex); 325478b5713aSAnirudh Venkataramanan 325578b5713aSAnirudh Venkataramanan if (pf->avail_txqs) { 325678b5713aSAnirudh Venkataramanan bitmap_free(pf->avail_txqs); 325778b5713aSAnirudh Venkataramanan pf->avail_txqs = NULL; 325878b5713aSAnirudh Venkataramanan } 325978b5713aSAnirudh Venkataramanan 326078b5713aSAnirudh Venkataramanan if (pf->avail_rxqs) { 326178b5713aSAnirudh Venkataramanan bitmap_free(pf->avail_rxqs); 326278b5713aSAnirudh Venkataramanan pf->avail_rxqs = NULL; 326378b5713aSAnirudh Venkataramanan } 3264940b61afSAnirudh Venkataramanan } 3265940b61afSAnirudh Venkataramanan 3266940b61afSAnirudh Venkataramanan /** 3267462acf6aSTony Nguyen * ice_set_pf_caps - set PFs capability flags 3268462acf6aSTony Nguyen * @pf: pointer to the PF instance 3269462acf6aSTony Nguyen */ 3270462acf6aSTony Nguyen static void ice_set_pf_caps(struct ice_pf *pf) 3271462acf6aSTony Nguyen { 3272462acf6aSTony Nguyen struct ice_hw_func_caps *func_caps = &pf->hw.func_caps; 3273462acf6aSTony Nguyen 3274462acf6aSTony Nguyen clear_bit(ICE_FLAG_DCB_CAPABLE, pf->flags); 3275462acf6aSTony Nguyen if (func_caps->common_cap.dcb) 3276462acf6aSTony Nguyen set_bit(ICE_FLAG_DCB_CAPABLE, pf->flags); 3277462acf6aSTony Nguyen clear_bit(ICE_FLAG_SRIOV_CAPABLE, pf->flags); 3278462acf6aSTony Nguyen if (func_caps->common_cap.sr_iov_1_1) { 3279462acf6aSTony Nguyen set_bit(ICE_FLAG_SRIOV_CAPABLE, pf->flags); 3280462acf6aSTony Nguyen pf->num_vfs_supported = min_t(int, func_caps->num_allocd_vfs, 3281462acf6aSTony Nguyen ICE_MAX_VF_COUNT); 3282462acf6aSTony Nguyen } 3283462acf6aSTony Nguyen clear_bit(ICE_FLAG_RSS_ENA, pf->flags); 3284462acf6aSTony Nguyen if (func_caps->common_cap.rss_table_size) 3285462acf6aSTony Nguyen set_bit(ICE_FLAG_RSS_ENA, pf->flags); 3286462acf6aSTony Nguyen 3287148beb61SHenry Tieman clear_bit(ICE_FLAG_FD_ENA, pf->flags); 3288148beb61SHenry Tieman if (func_caps->fd_fltr_guar > 0 || func_caps->fd_fltr_best_effort > 0) { 3289148beb61SHenry Tieman u16 unused; 3290148beb61SHenry Tieman 3291148beb61SHenry Tieman /* ctrl_vsi_idx will be set to a valid value when flow director 3292148beb61SHenry Tieman * is setup by ice_init_fdir 3293148beb61SHenry Tieman */ 3294148beb61SHenry Tieman pf->ctrl_vsi_idx = ICE_NO_VSI; 3295148beb61SHenry Tieman set_bit(ICE_FLAG_FD_ENA, pf->flags); 3296148beb61SHenry Tieman /* force guaranteed filter pool for PF */ 3297148beb61SHenry Tieman ice_alloc_fd_guar_item(&pf->hw, &unused, 3298148beb61SHenry Tieman func_caps->fd_fltr_guar); 3299148beb61SHenry Tieman /* force shared filter pool for PF */ 3300148beb61SHenry Tieman ice_alloc_fd_shrd_item(&pf->hw, &unused, 3301148beb61SHenry Tieman func_caps->fd_fltr_best_effort); 3302148beb61SHenry Tieman } 3303148beb61SHenry Tieman 3304462acf6aSTony Nguyen pf->max_pf_txqs = func_caps->common_cap.num_txq; 3305462acf6aSTony Nguyen pf->max_pf_rxqs = func_caps->common_cap.num_rxq; 3306462acf6aSTony Nguyen } 3307462acf6aSTony Nguyen 3308462acf6aSTony Nguyen /** 3309940b61afSAnirudh Venkataramanan * ice_init_pf - Initialize general software structures (struct ice_pf) 3310940b61afSAnirudh Venkataramanan * @pf: board private structure to initialize 3311940b61afSAnirudh Venkataramanan */ 331278b5713aSAnirudh Venkataramanan static int ice_init_pf(struct ice_pf *pf) 3313940b61afSAnirudh Venkataramanan { 3314462acf6aSTony Nguyen ice_set_pf_caps(pf); 3315940b61afSAnirudh Venkataramanan 3316940b61afSAnirudh Venkataramanan mutex_init(&pf->sw_mutex); 3317b94b013eSDave Ertman mutex_init(&pf->tc_mutex); 3318d76a60baSAnirudh Venkataramanan 3319d69ea414SJacob Keller INIT_HLIST_HEAD(&pf->aq_wait_list); 3320d69ea414SJacob Keller spin_lock_init(&pf->aq_wait_lock); 3321d69ea414SJacob Keller init_waitqueue_head(&pf->aq_wait_queue); 3322d69ea414SJacob Keller 3323940b61afSAnirudh Venkataramanan /* setup service timer and periodic service task */ 3324940b61afSAnirudh Venkataramanan timer_setup(&pf->serv_tmr, ice_service_timer, 0); 3325940b61afSAnirudh Venkataramanan pf->serv_tmr_period = HZ; 3326940b61afSAnirudh Venkataramanan INIT_WORK(&pf->serv_task, ice_service_task); 33277e408e07SAnirudh Venkataramanan clear_bit(ICE_SERVICE_SCHED, pf->state); 332878b5713aSAnirudh Venkataramanan 3329462acf6aSTony Nguyen mutex_init(&pf->avail_q_mutex); 333078b5713aSAnirudh Venkataramanan pf->avail_txqs = bitmap_zalloc(pf->max_pf_txqs, GFP_KERNEL); 333178b5713aSAnirudh Venkataramanan if (!pf->avail_txqs) 333278b5713aSAnirudh Venkataramanan return -ENOMEM; 333378b5713aSAnirudh Venkataramanan 333478b5713aSAnirudh Venkataramanan pf->avail_rxqs = bitmap_zalloc(pf->max_pf_rxqs, GFP_KERNEL); 333578b5713aSAnirudh Venkataramanan if (!pf->avail_rxqs) { 33364015d11eSBrett Creeley devm_kfree(ice_pf_to_dev(pf), pf->avail_txqs); 333778b5713aSAnirudh Venkataramanan pf->avail_txqs = NULL; 333878b5713aSAnirudh Venkataramanan return -ENOMEM; 333978b5713aSAnirudh Venkataramanan } 334078b5713aSAnirudh Venkataramanan 334178b5713aSAnirudh Venkataramanan return 0; 3342940b61afSAnirudh Venkataramanan } 3343940b61afSAnirudh Venkataramanan 3344940b61afSAnirudh Venkataramanan /** 3345940b61afSAnirudh Venkataramanan * ice_ena_msix_range - Request a range of MSIX vectors from the OS 3346940b61afSAnirudh Venkataramanan * @pf: board private structure 3347940b61afSAnirudh Venkataramanan * 3348940b61afSAnirudh Venkataramanan * compute the number of MSIX vectors required (v_budget) and request from 3349940b61afSAnirudh Venkataramanan * the OS. Return the number of vectors reserved or negative on failure 3350940b61afSAnirudh Venkataramanan */ 3351940b61afSAnirudh Venkataramanan static int ice_ena_msix_range(struct ice_pf *pf) 3352940b61afSAnirudh Venkataramanan { 3353741106f7STony Nguyen int v_left, v_actual, v_other, v_budget = 0; 33544015d11eSBrett Creeley struct device *dev = ice_pf_to_dev(pf); 3355940b61afSAnirudh Venkataramanan int needed, err, i; 3356940b61afSAnirudh Venkataramanan 3357940b61afSAnirudh Venkataramanan v_left = pf->hw.func_caps.common_cap.num_msix_vectors; 3358940b61afSAnirudh Venkataramanan 3359741106f7STony Nguyen /* reserve for LAN miscellaneous handler */ 3360741106f7STony Nguyen needed = ICE_MIN_LAN_OICR_MSIX; 3361152b978aSAnirudh Venkataramanan if (v_left < needed) 3362152b978aSAnirudh Venkataramanan goto no_hw_vecs_left_err; 3363940b61afSAnirudh Venkataramanan v_budget += needed; 3364940b61afSAnirudh Venkataramanan v_left -= needed; 3365940b61afSAnirudh Venkataramanan 3366741106f7STony Nguyen /* reserve for flow director */ 3367741106f7STony Nguyen if (test_bit(ICE_FLAG_FD_ENA, pf->flags)) { 3368741106f7STony Nguyen needed = ICE_FDIR_MSIX; 3369741106f7STony Nguyen if (v_left < needed) 3370741106f7STony Nguyen goto no_hw_vecs_left_err; 3371741106f7STony Nguyen v_budget += needed; 3372741106f7STony Nguyen v_left -= needed; 3373741106f7STony Nguyen } 3374741106f7STony Nguyen 3375741106f7STony Nguyen /* total used for non-traffic vectors */ 3376741106f7STony Nguyen v_other = v_budget; 3377741106f7STony Nguyen 3378940b61afSAnirudh Venkataramanan /* reserve vectors for LAN traffic */ 3379152b978aSAnirudh Venkataramanan needed = min_t(int, num_online_cpus(), v_left); 3380152b978aSAnirudh Venkataramanan if (v_left < needed) 3381152b978aSAnirudh Venkataramanan goto no_hw_vecs_left_err; 3382152b978aSAnirudh Venkataramanan pf->num_lan_msix = needed; 3383152b978aSAnirudh Venkataramanan v_budget += needed; 3384152b978aSAnirudh Venkataramanan v_left -= needed; 3385940b61afSAnirudh Venkataramanan 33864015d11eSBrett Creeley pf->msix_entries = devm_kcalloc(dev, v_budget, 3387c6dfd690SBruce Allan sizeof(*pf->msix_entries), GFP_KERNEL); 3388940b61afSAnirudh Venkataramanan if (!pf->msix_entries) { 3389940b61afSAnirudh Venkataramanan err = -ENOMEM; 3390940b61afSAnirudh Venkataramanan goto exit_err; 3391940b61afSAnirudh Venkataramanan } 3392940b61afSAnirudh Venkataramanan 3393940b61afSAnirudh Venkataramanan for (i = 0; i < v_budget; i++) 3394940b61afSAnirudh Venkataramanan pf->msix_entries[i].entry = i; 3395940b61afSAnirudh Venkataramanan 3396940b61afSAnirudh Venkataramanan /* actually reserve the vectors */ 3397940b61afSAnirudh Venkataramanan v_actual = pci_enable_msix_range(pf->pdev, pf->msix_entries, 3398940b61afSAnirudh Venkataramanan ICE_MIN_MSIX, v_budget); 3399940b61afSAnirudh Venkataramanan if (v_actual < 0) { 34004015d11eSBrett Creeley dev_err(dev, "unable to reserve MSI-X vectors\n"); 3401940b61afSAnirudh Venkataramanan err = v_actual; 3402940b61afSAnirudh Venkataramanan goto msix_err; 3403940b61afSAnirudh Venkataramanan } 3404940b61afSAnirudh Venkataramanan 3405940b61afSAnirudh Venkataramanan if (v_actual < v_budget) { 340619cce2c6SAnirudh Venkataramanan dev_warn(dev, "not enough OS MSI-X vectors. requested = %d, obtained = %d\n", 3407940b61afSAnirudh Venkataramanan v_budget, v_actual); 3408152b978aSAnirudh Venkataramanan 3409f3fe97f6SBrett Creeley if (v_actual < ICE_MIN_MSIX) { 3410152b978aSAnirudh Venkataramanan /* error if we can't get minimum vectors */ 3411940b61afSAnirudh Venkataramanan pci_disable_msix(pf->pdev); 3412940b61afSAnirudh Venkataramanan err = -ERANGE; 3413940b61afSAnirudh Venkataramanan goto msix_err; 3414152b978aSAnirudh Venkataramanan } else { 3415741106f7STony Nguyen int v_traffic = v_actual - v_other; 3416741106f7STony Nguyen 3417741106f7STony Nguyen if (v_actual == ICE_MIN_MSIX || 3418741106f7STony Nguyen v_traffic < ICE_MIN_LAN_TXRX_MSIX) 3419f3fe97f6SBrett Creeley pf->num_lan_msix = ICE_MIN_LAN_TXRX_MSIX; 3420741106f7STony Nguyen else 3421741106f7STony Nguyen pf->num_lan_msix = v_traffic; 3422741106f7STony Nguyen 3423741106f7STony Nguyen dev_notice(dev, "Enabled %d MSI-X vectors for LAN traffic.\n", 3424741106f7STony Nguyen pf->num_lan_msix); 3425940b61afSAnirudh Venkataramanan } 3426940b61afSAnirudh Venkataramanan } 3427940b61afSAnirudh Venkataramanan 3428940b61afSAnirudh Venkataramanan return v_actual; 3429940b61afSAnirudh Venkataramanan 3430940b61afSAnirudh Venkataramanan msix_err: 34314015d11eSBrett Creeley devm_kfree(dev, pf->msix_entries); 3432940b61afSAnirudh Venkataramanan goto exit_err; 3433940b61afSAnirudh Venkataramanan 3434152b978aSAnirudh Venkataramanan no_hw_vecs_left_err: 343519cce2c6SAnirudh Venkataramanan dev_err(dev, "not enough device MSI-X vectors. requested = %d, available = %d\n", 3436152b978aSAnirudh Venkataramanan needed, v_left); 3437152b978aSAnirudh Venkataramanan err = -ERANGE; 3438940b61afSAnirudh Venkataramanan exit_err: 3439940b61afSAnirudh Venkataramanan pf->num_lan_msix = 0; 3440940b61afSAnirudh Venkataramanan return err; 3441940b61afSAnirudh Venkataramanan } 3442940b61afSAnirudh Venkataramanan 3443940b61afSAnirudh Venkataramanan /** 3444940b61afSAnirudh Venkataramanan * ice_dis_msix - Disable MSI-X interrupt setup in OS 3445940b61afSAnirudh Venkataramanan * @pf: board private structure 3446940b61afSAnirudh Venkataramanan */ 3447940b61afSAnirudh Venkataramanan static void ice_dis_msix(struct ice_pf *pf) 3448940b61afSAnirudh Venkataramanan { 3449940b61afSAnirudh Venkataramanan pci_disable_msix(pf->pdev); 34504015d11eSBrett Creeley devm_kfree(ice_pf_to_dev(pf), pf->msix_entries); 3451940b61afSAnirudh Venkataramanan pf->msix_entries = NULL; 3452940b61afSAnirudh Venkataramanan } 3453940b61afSAnirudh Venkataramanan 3454940b61afSAnirudh Venkataramanan /** 3455eb0208ecSPreethi Banala * ice_clear_interrupt_scheme - Undo things done by ice_init_interrupt_scheme 3456eb0208ecSPreethi Banala * @pf: board private structure 3457eb0208ecSPreethi Banala */ 3458eb0208ecSPreethi Banala static void ice_clear_interrupt_scheme(struct ice_pf *pf) 3459eb0208ecSPreethi Banala { 3460eb0208ecSPreethi Banala ice_dis_msix(pf); 3461eb0208ecSPreethi Banala 3462cbe66bfeSBrett Creeley if (pf->irq_tracker) { 34634015d11eSBrett Creeley devm_kfree(ice_pf_to_dev(pf), pf->irq_tracker); 3464cbe66bfeSBrett Creeley pf->irq_tracker = NULL; 3465eb0208ecSPreethi Banala } 3466eb0208ecSPreethi Banala } 3467eb0208ecSPreethi Banala 3468eb0208ecSPreethi Banala /** 3469940b61afSAnirudh Venkataramanan * ice_init_interrupt_scheme - Determine proper interrupt scheme 3470940b61afSAnirudh Venkataramanan * @pf: board private structure to initialize 3471940b61afSAnirudh Venkataramanan */ 3472940b61afSAnirudh Venkataramanan static int ice_init_interrupt_scheme(struct ice_pf *pf) 3473940b61afSAnirudh Venkataramanan { 3474cbe66bfeSBrett Creeley int vectors; 3475940b61afSAnirudh Venkataramanan 3476940b61afSAnirudh Venkataramanan vectors = ice_ena_msix_range(pf); 3477940b61afSAnirudh Venkataramanan 3478940b61afSAnirudh Venkataramanan if (vectors < 0) 3479940b61afSAnirudh Venkataramanan return vectors; 3480940b61afSAnirudh Venkataramanan 3481940b61afSAnirudh Venkataramanan /* set up vector assignment tracking */ 3482e94c0df9SGustavo A. R. Silva pf->irq_tracker = devm_kzalloc(ice_pf_to_dev(pf), 3483e94c0df9SGustavo A. R. Silva struct_size(pf->irq_tracker, list, vectors), 3484e94c0df9SGustavo A. R. Silva GFP_KERNEL); 3485cbe66bfeSBrett Creeley if (!pf->irq_tracker) { 3486940b61afSAnirudh Venkataramanan ice_dis_msix(pf); 3487940b61afSAnirudh Venkataramanan return -ENOMEM; 3488940b61afSAnirudh Venkataramanan } 3489940b61afSAnirudh Venkataramanan 3490eb0208ecSPreethi Banala /* populate SW interrupts pool with number of OS granted IRQs. */ 349188865fc4SKarol Kolacinski pf->num_avail_sw_msix = (u16)vectors; 349288865fc4SKarol Kolacinski pf->irq_tracker->num_entries = (u16)vectors; 3493cbe66bfeSBrett Creeley pf->irq_tracker->end = pf->irq_tracker->num_entries; 3494940b61afSAnirudh Venkataramanan 3495940b61afSAnirudh Venkataramanan return 0; 3496940b61afSAnirudh Venkataramanan } 3497940b61afSAnirudh Venkataramanan 3498940b61afSAnirudh Venkataramanan /** 349931765519SAnirudh Venkataramanan * ice_is_wol_supported - check if WoL is supported 350031765519SAnirudh Venkataramanan * @hw: pointer to hardware info 3501769c500dSAkeem G Abodunrin * 3502769c500dSAkeem G Abodunrin * Check if WoL is supported based on the HW configuration. 3503769c500dSAkeem G Abodunrin * Returns true if NVM supports and enables WoL for this port, false otherwise 3504769c500dSAkeem G Abodunrin */ 350531765519SAnirudh Venkataramanan bool ice_is_wol_supported(struct ice_hw *hw) 3506769c500dSAkeem G Abodunrin { 3507769c500dSAkeem G Abodunrin u16 wol_ctrl; 3508769c500dSAkeem G Abodunrin 3509769c500dSAkeem G Abodunrin /* A bit set to 1 in the NVM Software Reserved Word 2 (WoL control 3510769c500dSAkeem G Abodunrin * word) indicates WoL is not supported on the corresponding PF ID. 3511769c500dSAkeem G Abodunrin */ 3512769c500dSAkeem G Abodunrin if (ice_read_sr_word(hw, ICE_SR_NVM_WOL_CFG, &wol_ctrl)) 3513769c500dSAkeem G Abodunrin return false; 3514769c500dSAkeem G Abodunrin 351531765519SAnirudh Venkataramanan return !(BIT(hw->port_info->lport) & wol_ctrl); 3516769c500dSAkeem G Abodunrin } 3517769c500dSAkeem G Abodunrin 3518769c500dSAkeem G Abodunrin /** 351987324e74SHenry Tieman * ice_vsi_recfg_qs - Change the number of queues on a VSI 352087324e74SHenry Tieman * @vsi: VSI being changed 352187324e74SHenry Tieman * @new_rx: new number of Rx queues 352287324e74SHenry Tieman * @new_tx: new number of Tx queues 352387324e74SHenry Tieman * 352487324e74SHenry Tieman * Only change the number of queues if new_tx, or new_rx is non-0. 352587324e74SHenry Tieman * 352687324e74SHenry Tieman * Returns 0 on success. 352787324e74SHenry Tieman */ 352887324e74SHenry Tieman int ice_vsi_recfg_qs(struct ice_vsi *vsi, int new_rx, int new_tx) 352987324e74SHenry Tieman { 353087324e74SHenry Tieman struct ice_pf *pf = vsi->back; 353187324e74SHenry Tieman int err = 0, timeout = 50; 353287324e74SHenry Tieman 353387324e74SHenry Tieman if (!new_rx && !new_tx) 353487324e74SHenry Tieman return -EINVAL; 353587324e74SHenry Tieman 35367e408e07SAnirudh Venkataramanan while (test_and_set_bit(ICE_CFG_BUSY, pf->state)) { 353787324e74SHenry Tieman timeout--; 353887324e74SHenry Tieman if (!timeout) 353987324e74SHenry Tieman return -EBUSY; 354087324e74SHenry Tieman usleep_range(1000, 2000); 354187324e74SHenry Tieman } 354287324e74SHenry Tieman 354387324e74SHenry Tieman if (new_tx) 354488865fc4SKarol Kolacinski vsi->req_txq = (u16)new_tx; 354587324e74SHenry Tieman if (new_rx) 354688865fc4SKarol Kolacinski vsi->req_rxq = (u16)new_rx; 354787324e74SHenry Tieman 354887324e74SHenry Tieman /* set for the next time the netdev is started */ 354987324e74SHenry Tieman if (!netif_running(vsi->netdev)) { 355087324e74SHenry Tieman ice_vsi_rebuild(vsi, false); 355187324e74SHenry Tieman dev_dbg(ice_pf_to_dev(pf), "Link is down, queue count change happens when link is brought up\n"); 355287324e74SHenry Tieman goto done; 355387324e74SHenry Tieman } 355487324e74SHenry Tieman 355587324e74SHenry Tieman ice_vsi_close(vsi); 355687324e74SHenry Tieman ice_vsi_rebuild(vsi, false); 355787324e74SHenry Tieman ice_pf_dcb_recfg(pf); 355887324e74SHenry Tieman ice_vsi_open(vsi); 355987324e74SHenry Tieman done: 35607e408e07SAnirudh Venkataramanan clear_bit(ICE_CFG_BUSY, pf->state); 356187324e74SHenry Tieman return err; 356287324e74SHenry Tieman } 356387324e74SHenry Tieman 356487324e74SHenry Tieman /** 3565cd1f56f4SBrett Creeley * ice_set_safe_mode_vlan_cfg - configure PF VSI to allow all VLANs in safe mode 3566cd1f56f4SBrett Creeley * @pf: PF to configure 3567cd1f56f4SBrett Creeley * 3568cd1f56f4SBrett Creeley * No VLAN offloads/filtering are advertised in safe mode so make sure the PF 3569cd1f56f4SBrett Creeley * VSI can still Tx/Rx VLAN tagged packets. 3570cd1f56f4SBrett Creeley */ 3571cd1f56f4SBrett Creeley static void ice_set_safe_mode_vlan_cfg(struct ice_pf *pf) 3572cd1f56f4SBrett Creeley { 3573cd1f56f4SBrett Creeley struct ice_vsi *vsi = ice_get_main_vsi(pf); 3574cd1f56f4SBrett Creeley struct ice_vsi_ctx *ctxt; 3575cd1f56f4SBrett Creeley enum ice_status status; 3576cd1f56f4SBrett Creeley struct ice_hw *hw; 3577cd1f56f4SBrett Creeley 3578cd1f56f4SBrett Creeley if (!vsi) 3579cd1f56f4SBrett Creeley return; 3580cd1f56f4SBrett Creeley 3581cd1f56f4SBrett Creeley ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL); 3582cd1f56f4SBrett Creeley if (!ctxt) 3583cd1f56f4SBrett Creeley return; 3584cd1f56f4SBrett Creeley 3585cd1f56f4SBrett Creeley hw = &pf->hw; 3586cd1f56f4SBrett Creeley ctxt->info = vsi->info; 3587cd1f56f4SBrett Creeley 3588cd1f56f4SBrett Creeley ctxt->info.valid_sections = 3589cd1f56f4SBrett Creeley cpu_to_le16(ICE_AQ_VSI_PROP_VLAN_VALID | 3590cd1f56f4SBrett Creeley ICE_AQ_VSI_PROP_SECURITY_VALID | 3591cd1f56f4SBrett Creeley ICE_AQ_VSI_PROP_SW_VALID); 3592cd1f56f4SBrett Creeley 3593cd1f56f4SBrett Creeley /* disable VLAN anti-spoof */ 3594cd1f56f4SBrett Creeley ctxt->info.sec_flags &= ~(ICE_AQ_VSI_SEC_TX_VLAN_PRUNE_ENA << 3595cd1f56f4SBrett Creeley ICE_AQ_VSI_SEC_TX_PRUNE_ENA_S); 3596cd1f56f4SBrett Creeley 3597cd1f56f4SBrett Creeley /* disable VLAN pruning and keep all other settings */ 3598cd1f56f4SBrett Creeley ctxt->info.sw_flags2 &= ~ICE_AQ_VSI_SW_FLAG_RX_VLAN_PRUNE_ENA; 3599cd1f56f4SBrett Creeley 3600cd1f56f4SBrett Creeley /* allow all VLANs on Tx and don't strip on Rx */ 3601cd1f56f4SBrett Creeley ctxt->info.vlan_flags = ICE_AQ_VSI_VLAN_MODE_ALL | 3602cd1f56f4SBrett Creeley ICE_AQ_VSI_VLAN_EMOD_NOTHING; 3603cd1f56f4SBrett Creeley 3604cd1f56f4SBrett Creeley status = ice_update_vsi(hw, vsi->idx, ctxt, NULL); 3605cd1f56f4SBrett Creeley if (status) { 3606cd1f56f4SBrett Creeley dev_err(ice_pf_to_dev(vsi->back), "Failed to update VSI for safe mode VLANs, err %s aq_err %s\n", 3607cd1f56f4SBrett Creeley ice_stat_str(status), 3608cd1f56f4SBrett Creeley ice_aq_str(hw->adminq.sq_last_status)); 3609cd1f56f4SBrett Creeley } else { 3610cd1f56f4SBrett Creeley vsi->info.sec_flags = ctxt->info.sec_flags; 3611cd1f56f4SBrett Creeley vsi->info.sw_flags2 = ctxt->info.sw_flags2; 3612cd1f56f4SBrett Creeley vsi->info.vlan_flags = ctxt->info.vlan_flags; 3613cd1f56f4SBrett Creeley } 3614cd1f56f4SBrett Creeley 3615cd1f56f4SBrett Creeley kfree(ctxt); 3616cd1f56f4SBrett Creeley } 3617cd1f56f4SBrett Creeley 3618cd1f56f4SBrett Creeley /** 3619462acf6aSTony Nguyen * ice_log_pkg_init - log result of DDP package load 3620462acf6aSTony Nguyen * @hw: pointer to hardware info 3621462acf6aSTony Nguyen * @status: status of package load 3622462acf6aSTony Nguyen */ 3623462acf6aSTony Nguyen static void 3624462acf6aSTony Nguyen ice_log_pkg_init(struct ice_hw *hw, enum ice_status *status) 3625462acf6aSTony Nguyen { 3626462acf6aSTony Nguyen struct ice_pf *pf = (struct ice_pf *)hw->back; 36274015d11eSBrett Creeley struct device *dev = ice_pf_to_dev(pf); 3628462acf6aSTony Nguyen 3629462acf6aSTony Nguyen switch (*status) { 3630462acf6aSTony Nguyen case ICE_SUCCESS: 3631462acf6aSTony Nguyen /* The package download AdminQ command returned success because 3632462acf6aSTony Nguyen * this download succeeded or ICE_ERR_AQ_NO_WORK since there is 3633462acf6aSTony Nguyen * already a package loaded on the device. 3634462acf6aSTony Nguyen */ 3635462acf6aSTony Nguyen if (hw->pkg_ver.major == hw->active_pkg_ver.major && 3636462acf6aSTony Nguyen hw->pkg_ver.minor == hw->active_pkg_ver.minor && 3637462acf6aSTony Nguyen hw->pkg_ver.update == hw->active_pkg_ver.update && 3638462acf6aSTony Nguyen hw->pkg_ver.draft == hw->active_pkg_ver.draft && 3639462acf6aSTony Nguyen !memcmp(hw->pkg_name, hw->active_pkg_name, 3640462acf6aSTony Nguyen sizeof(hw->pkg_name))) { 3641462acf6aSTony Nguyen if (hw->pkg_dwnld_status == ICE_AQ_RC_EEXIST) 364219cce2c6SAnirudh Venkataramanan dev_info(dev, "DDP package already present on device: %s version %d.%d.%d.%d\n", 3643462acf6aSTony Nguyen hw->active_pkg_name, 3644462acf6aSTony Nguyen hw->active_pkg_ver.major, 3645462acf6aSTony Nguyen hw->active_pkg_ver.minor, 3646462acf6aSTony Nguyen hw->active_pkg_ver.update, 3647462acf6aSTony Nguyen hw->active_pkg_ver.draft); 3648462acf6aSTony Nguyen else 364919cce2c6SAnirudh Venkataramanan dev_info(dev, "The DDP package was successfully loaded: %s version %d.%d.%d.%d\n", 3650462acf6aSTony Nguyen hw->active_pkg_name, 3651462acf6aSTony Nguyen hw->active_pkg_ver.major, 3652462acf6aSTony Nguyen hw->active_pkg_ver.minor, 3653462acf6aSTony Nguyen hw->active_pkg_ver.update, 3654462acf6aSTony Nguyen hw->active_pkg_ver.draft); 3655462acf6aSTony Nguyen } else if (hw->active_pkg_ver.major != ICE_PKG_SUPP_VER_MAJ || 3656462acf6aSTony Nguyen hw->active_pkg_ver.minor != ICE_PKG_SUPP_VER_MNR) { 365719cce2c6SAnirudh 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", 3658462acf6aSTony Nguyen hw->active_pkg_name, 3659462acf6aSTony Nguyen hw->active_pkg_ver.major, 3660462acf6aSTony Nguyen hw->active_pkg_ver.minor, 3661462acf6aSTony Nguyen ICE_PKG_SUPP_VER_MAJ, ICE_PKG_SUPP_VER_MNR); 3662462acf6aSTony Nguyen *status = ICE_ERR_NOT_SUPPORTED; 3663462acf6aSTony Nguyen } else if (hw->active_pkg_ver.major == ICE_PKG_SUPP_VER_MAJ && 3664462acf6aSTony Nguyen hw->active_pkg_ver.minor == ICE_PKG_SUPP_VER_MNR) { 366519cce2c6SAnirudh 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", 3666462acf6aSTony Nguyen hw->active_pkg_name, 3667462acf6aSTony Nguyen hw->active_pkg_ver.major, 3668462acf6aSTony Nguyen hw->active_pkg_ver.minor, 3669462acf6aSTony Nguyen hw->active_pkg_ver.update, 3670462acf6aSTony Nguyen hw->active_pkg_ver.draft, 3671462acf6aSTony Nguyen hw->pkg_name, 3672462acf6aSTony Nguyen hw->pkg_ver.major, 3673462acf6aSTony Nguyen hw->pkg_ver.minor, 3674462acf6aSTony Nguyen hw->pkg_ver.update, 3675462acf6aSTony Nguyen hw->pkg_ver.draft); 3676462acf6aSTony Nguyen } else { 367719cce2c6SAnirudh Venkataramanan dev_err(dev, "An unknown error occurred when loading the DDP package, please reboot the system. If the problem persists, update the NVM. Entering Safe Mode.\n"); 3678462acf6aSTony Nguyen *status = ICE_ERR_NOT_SUPPORTED; 3679462acf6aSTony Nguyen } 3680462acf6aSTony Nguyen break; 3681b8272919SVictor Raj case ICE_ERR_FW_DDP_MISMATCH: 3682b8272919SVictor 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"); 3683b8272919SVictor Raj break; 3684462acf6aSTony Nguyen case ICE_ERR_BUF_TOO_SHORT: 3685462acf6aSTony Nguyen case ICE_ERR_CFG: 368619cce2c6SAnirudh Venkataramanan dev_err(dev, "The DDP package file is invalid. Entering Safe Mode.\n"); 3687462acf6aSTony Nguyen break; 3688462acf6aSTony Nguyen case ICE_ERR_NOT_SUPPORTED: 3689462acf6aSTony Nguyen /* Package File version not supported */ 3690462acf6aSTony Nguyen if (hw->pkg_ver.major > ICE_PKG_SUPP_VER_MAJ || 3691462acf6aSTony Nguyen (hw->pkg_ver.major == ICE_PKG_SUPP_VER_MAJ && 3692462acf6aSTony Nguyen hw->pkg_ver.minor > ICE_PKG_SUPP_VER_MNR)) 369319cce2c6SAnirudh Venkataramanan dev_err(dev, "The DDP package file version is higher than the driver supports. Please use an updated driver. Entering Safe Mode.\n"); 3694462acf6aSTony Nguyen else if (hw->pkg_ver.major < ICE_PKG_SUPP_VER_MAJ || 3695462acf6aSTony Nguyen (hw->pkg_ver.major == ICE_PKG_SUPP_VER_MAJ && 3696462acf6aSTony Nguyen hw->pkg_ver.minor < ICE_PKG_SUPP_VER_MNR)) 369719cce2c6SAnirudh 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", 3698462acf6aSTony Nguyen ICE_PKG_SUPP_VER_MAJ, ICE_PKG_SUPP_VER_MNR); 3699462acf6aSTony Nguyen break; 3700462acf6aSTony Nguyen case ICE_ERR_AQ_ERROR: 3701e000248eSBruce Allan switch (hw->pkg_dwnld_status) { 3702462acf6aSTony Nguyen case ICE_AQ_RC_ENOSEC: 3703462acf6aSTony Nguyen case ICE_AQ_RC_EBADSIG: 370419cce2c6SAnirudh 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"); 3705462acf6aSTony Nguyen return; 3706462acf6aSTony Nguyen case ICE_AQ_RC_ESVN: 370719cce2c6SAnirudh 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"); 3708462acf6aSTony Nguyen return; 3709462acf6aSTony Nguyen case ICE_AQ_RC_EBADMAN: 3710462acf6aSTony Nguyen case ICE_AQ_RC_EBADBUF: 371119cce2c6SAnirudh Venkataramanan dev_err(dev, "An error occurred on the device while loading the DDP package. The device will be reset.\n"); 37129918f2d2SAnirudh Venkataramanan /* poll for reset to complete */ 37139918f2d2SAnirudh Venkataramanan if (ice_check_reset(hw)) 37149918f2d2SAnirudh Venkataramanan dev_err(dev, "Error resetting device. Please reload the driver\n"); 3715462acf6aSTony Nguyen return; 3716462acf6aSTony Nguyen default: 3717462acf6aSTony Nguyen break; 3718462acf6aSTony Nguyen } 37194e83fc93SBruce Allan fallthrough; 3720462acf6aSTony Nguyen default: 372119cce2c6SAnirudh Venkataramanan dev_err(dev, "An unknown error (%d) occurred when loading the DDP package. Entering Safe Mode.\n", 3722462acf6aSTony Nguyen *status); 3723462acf6aSTony Nguyen break; 3724462acf6aSTony Nguyen } 3725462acf6aSTony Nguyen } 3726462acf6aSTony Nguyen 3727462acf6aSTony Nguyen /** 3728462acf6aSTony Nguyen * ice_load_pkg - load/reload the DDP Package file 3729462acf6aSTony Nguyen * @firmware: firmware structure when firmware requested or NULL for reload 3730462acf6aSTony Nguyen * @pf: pointer to the PF instance 3731462acf6aSTony Nguyen * 3732462acf6aSTony Nguyen * Called on probe and post CORER/GLOBR rebuild to load DDP Package and 3733462acf6aSTony Nguyen * initialize HW tables. 3734462acf6aSTony Nguyen */ 3735462acf6aSTony Nguyen static void 3736462acf6aSTony Nguyen ice_load_pkg(const struct firmware *firmware, struct ice_pf *pf) 3737462acf6aSTony Nguyen { 3738462acf6aSTony Nguyen enum ice_status status = ICE_ERR_PARAM; 37394015d11eSBrett Creeley struct device *dev = ice_pf_to_dev(pf); 3740462acf6aSTony Nguyen struct ice_hw *hw = &pf->hw; 3741462acf6aSTony Nguyen 3742462acf6aSTony Nguyen /* Load DDP Package */ 3743462acf6aSTony Nguyen if (firmware && !hw->pkg_copy) { 3744462acf6aSTony Nguyen status = ice_copy_and_init_pkg(hw, firmware->data, 3745462acf6aSTony Nguyen firmware->size); 3746462acf6aSTony Nguyen ice_log_pkg_init(hw, &status); 3747462acf6aSTony Nguyen } else if (!firmware && hw->pkg_copy) { 3748462acf6aSTony Nguyen /* Reload package during rebuild after CORER/GLOBR reset */ 3749462acf6aSTony Nguyen status = ice_init_pkg(hw, hw->pkg_copy, hw->pkg_size); 3750462acf6aSTony Nguyen ice_log_pkg_init(hw, &status); 3751462acf6aSTony Nguyen } else { 375219cce2c6SAnirudh Venkataramanan dev_err(dev, "The DDP package file failed to load. Entering Safe Mode.\n"); 3753462acf6aSTony Nguyen } 3754462acf6aSTony Nguyen 3755462acf6aSTony Nguyen if (status) { 3756462acf6aSTony Nguyen /* Safe Mode */ 3757462acf6aSTony Nguyen clear_bit(ICE_FLAG_ADV_FEATURES, pf->flags); 3758462acf6aSTony Nguyen return; 3759462acf6aSTony Nguyen } 3760462acf6aSTony Nguyen 3761462acf6aSTony Nguyen /* Successful download package is the precondition for advanced 3762462acf6aSTony Nguyen * features, hence setting the ICE_FLAG_ADV_FEATURES flag 3763462acf6aSTony Nguyen */ 3764462acf6aSTony Nguyen set_bit(ICE_FLAG_ADV_FEATURES, pf->flags); 3765462acf6aSTony Nguyen } 3766462acf6aSTony Nguyen 3767462acf6aSTony Nguyen /** 3768c585ea42SBrett Creeley * ice_verify_cacheline_size - verify driver's assumption of 64 Byte cache lines 3769c585ea42SBrett Creeley * @pf: pointer to the PF structure 3770c585ea42SBrett Creeley * 3771c585ea42SBrett Creeley * There is no error returned here because the driver should be able to handle 3772c585ea42SBrett Creeley * 128 Byte cache lines, so we only print a warning in case issues are seen, 3773c585ea42SBrett Creeley * specifically with Tx. 3774c585ea42SBrett Creeley */ 3775c585ea42SBrett Creeley static void ice_verify_cacheline_size(struct ice_pf *pf) 3776c585ea42SBrett Creeley { 3777c585ea42SBrett Creeley if (rd32(&pf->hw, GLPCI_CNF2) & GLPCI_CNF2_CACHELINE_SIZE_M) 377819cce2c6SAnirudh Venkataramanan dev_warn(ice_pf_to_dev(pf), "%d Byte cache line assumption is invalid, driver may have Tx timeouts!\n", 3779c585ea42SBrett Creeley ICE_CACHE_LINE_BYTES); 3780c585ea42SBrett Creeley } 3781c585ea42SBrett Creeley 3782c585ea42SBrett Creeley /** 3783e3710a01SPaul M Stillwell Jr * ice_send_version - update firmware with driver version 3784e3710a01SPaul M Stillwell Jr * @pf: PF struct 3785e3710a01SPaul M Stillwell Jr * 3786e3710a01SPaul M Stillwell Jr * Returns ICE_SUCCESS on success, else error code 3787e3710a01SPaul M Stillwell Jr */ 3788e3710a01SPaul M Stillwell Jr static enum ice_status ice_send_version(struct ice_pf *pf) 3789e3710a01SPaul M Stillwell Jr { 3790e3710a01SPaul M Stillwell Jr struct ice_driver_ver dv; 3791e3710a01SPaul M Stillwell Jr 379234a2a3b8SJeff Kirsher dv.major_ver = 0xff; 379334a2a3b8SJeff Kirsher dv.minor_ver = 0xff; 379434a2a3b8SJeff Kirsher dv.build_ver = 0xff; 3795e3710a01SPaul M Stillwell Jr dv.subbuild_ver = 0; 379634a2a3b8SJeff Kirsher strscpy((char *)dv.driver_string, UTS_RELEASE, 3797e3710a01SPaul M Stillwell Jr sizeof(dv.driver_string)); 3798e3710a01SPaul M Stillwell Jr return ice_aq_send_driver_ver(&pf->hw, &dv, NULL); 3799e3710a01SPaul M Stillwell Jr } 3800e3710a01SPaul M Stillwell Jr 3801e3710a01SPaul M Stillwell Jr /** 3802148beb61SHenry Tieman * ice_init_fdir - Initialize flow director VSI and configuration 3803148beb61SHenry Tieman * @pf: pointer to the PF instance 3804148beb61SHenry Tieman * 3805148beb61SHenry Tieman * returns 0 on success, negative on error 3806148beb61SHenry Tieman */ 3807148beb61SHenry Tieman static int ice_init_fdir(struct ice_pf *pf) 3808148beb61SHenry Tieman { 3809148beb61SHenry Tieman struct device *dev = ice_pf_to_dev(pf); 3810148beb61SHenry Tieman struct ice_vsi *ctrl_vsi; 3811148beb61SHenry Tieman int err; 3812148beb61SHenry Tieman 3813148beb61SHenry Tieman /* Side Band Flow Director needs to have a control VSI. 3814148beb61SHenry Tieman * Allocate it and store it in the PF. 3815148beb61SHenry Tieman */ 3816148beb61SHenry Tieman ctrl_vsi = ice_ctrl_vsi_setup(pf, pf->hw.port_info); 3817148beb61SHenry Tieman if (!ctrl_vsi) { 3818148beb61SHenry Tieman dev_dbg(dev, "could not create control VSI\n"); 3819148beb61SHenry Tieman return -ENOMEM; 3820148beb61SHenry Tieman } 3821148beb61SHenry Tieman 3822148beb61SHenry Tieman err = ice_vsi_open_ctrl(ctrl_vsi); 3823148beb61SHenry Tieman if (err) { 3824148beb61SHenry Tieman dev_dbg(dev, "could not open control VSI\n"); 3825148beb61SHenry Tieman goto err_vsi_open; 3826148beb61SHenry Tieman } 3827148beb61SHenry Tieman 3828148beb61SHenry Tieman mutex_init(&pf->hw.fdir_fltr_lock); 3829148beb61SHenry Tieman 3830148beb61SHenry Tieman err = ice_fdir_create_dflt_rules(pf); 3831148beb61SHenry Tieman if (err) 3832148beb61SHenry Tieman goto err_fdir_rule; 3833148beb61SHenry Tieman 3834148beb61SHenry Tieman return 0; 3835148beb61SHenry Tieman 3836148beb61SHenry Tieman err_fdir_rule: 3837148beb61SHenry Tieman ice_fdir_release_flows(&pf->hw); 3838148beb61SHenry Tieman ice_vsi_close(ctrl_vsi); 3839148beb61SHenry Tieman err_vsi_open: 3840148beb61SHenry Tieman ice_vsi_release(ctrl_vsi); 3841148beb61SHenry Tieman if (pf->ctrl_vsi_idx != ICE_NO_VSI) { 3842148beb61SHenry Tieman pf->vsi[pf->ctrl_vsi_idx] = NULL; 3843148beb61SHenry Tieman pf->ctrl_vsi_idx = ICE_NO_VSI; 3844148beb61SHenry Tieman } 3845148beb61SHenry Tieman return err; 3846148beb61SHenry Tieman } 3847148beb61SHenry Tieman 3848148beb61SHenry Tieman /** 3849462acf6aSTony Nguyen * ice_get_opt_fw_name - return optional firmware file name or NULL 3850462acf6aSTony Nguyen * @pf: pointer to the PF instance 3851462acf6aSTony Nguyen */ 3852462acf6aSTony Nguyen static char *ice_get_opt_fw_name(struct ice_pf *pf) 3853462acf6aSTony Nguyen { 3854462acf6aSTony Nguyen /* Optional firmware name same as default with additional dash 3855462acf6aSTony Nguyen * followed by a EUI-64 identifier (PCIe Device Serial Number) 3856462acf6aSTony Nguyen */ 3857462acf6aSTony Nguyen struct pci_dev *pdev = pf->pdev; 3858ceb2f007SJacob Keller char *opt_fw_filename; 3859ceb2f007SJacob Keller u64 dsn; 3860462acf6aSTony Nguyen 3861462acf6aSTony Nguyen /* Determine the name of the optional file using the DSN (two 3862462acf6aSTony Nguyen * dwords following the start of the DSN Capability). 3863462acf6aSTony Nguyen */ 3864ceb2f007SJacob Keller dsn = pci_get_dsn(pdev); 3865ceb2f007SJacob Keller if (!dsn) 3866ceb2f007SJacob Keller return NULL; 3867ceb2f007SJacob Keller 3868462acf6aSTony Nguyen opt_fw_filename = kzalloc(NAME_MAX, GFP_KERNEL); 3869462acf6aSTony Nguyen if (!opt_fw_filename) 3870462acf6aSTony Nguyen return NULL; 3871462acf6aSTony Nguyen 38721a9c561aSPaul M Stillwell Jr snprintf(opt_fw_filename, NAME_MAX, "%sice-%016llx.pkg", 3873ceb2f007SJacob Keller ICE_DDP_PKG_PATH, dsn); 3874462acf6aSTony Nguyen 3875462acf6aSTony Nguyen return opt_fw_filename; 3876462acf6aSTony Nguyen } 3877462acf6aSTony Nguyen 3878462acf6aSTony Nguyen /** 3879462acf6aSTony Nguyen * ice_request_fw - Device initialization routine 3880462acf6aSTony Nguyen * @pf: pointer to the PF instance 3881462acf6aSTony Nguyen */ 3882462acf6aSTony Nguyen static void ice_request_fw(struct ice_pf *pf) 3883462acf6aSTony Nguyen { 3884462acf6aSTony Nguyen char *opt_fw_filename = ice_get_opt_fw_name(pf); 3885462acf6aSTony Nguyen const struct firmware *firmware = NULL; 38864015d11eSBrett Creeley struct device *dev = ice_pf_to_dev(pf); 3887462acf6aSTony Nguyen int err = 0; 3888462acf6aSTony Nguyen 3889462acf6aSTony Nguyen /* optional device-specific DDP (if present) overrides the default DDP 3890462acf6aSTony Nguyen * package file. kernel logs a debug message if the file doesn't exist, 3891462acf6aSTony Nguyen * and warning messages for other errors. 3892462acf6aSTony Nguyen */ 3893462acf6aSTony Nguyen if (opt_fw_filename) { 3894462acf6aSTony Nguyen err = firmware_request_nowarn(&firmware, opt_fw_filename, dev); 3895462acf6aSTony Nguyen if (err) { 3896462acf6aSTony Nguyen kfree(opt_fw_filename); 3897462acf6aSTony Nguyen goto dflt_pkg_load; 3898462acf6aSTony Nguyen } 3899462acf6aSTony Nguyen 3900462acf6aSTony Nguyen /* request for firmware was successful. Download to device */ 3901462acf6aSTony Nguyen ice_load_pkg(firmware, pf); 3902462acf6aSTony Nguyen kfree(opt_fw_filename); 3903462acf6aSTony Nguyen release_firmware(firmware); 3904462acf6aSTony Nguyen return; 3905462acf6aSTony Nguyen } 3906462acf6aSTony Nguyen 3907462acf6aSTony Nguyen dflt_pkg_load: 3908462acf6aSTony Nguyen err = request_firmware(&firmware, ICE_DDP_PKG_FILE, dev); 3909462acf6aSTony Nguyen if (err) { 391019cce2c6SAnirudh Venkataramanan dev_err(dev, "The DDP package file was not found or could not be read. Entering Safe Mode\n"); 3911462acf6aSTony Nguyen return; 3912462acf6aSTony Nguyen } 3913462acf6aSTony Nguyen 3914462acf6aSTony Nguyen /* request for firmware was successful. Download to device */ 3915462acf6aSTony Nguyen ice_load_pkg(firmware, pf); 3916462acf6aSTony Nguyen release_firmware(firmware); 3917462acf6aSTony Nguyen } 3918462acf6aSTony Nguyen 3919462acf6aSTony Nguyen /** 3920769c500dSAkeem G Abodunrin * ice_print_wake_reason - show the wake up cause in the log 3921769c500dSAkeem G Abodunrin * @pf: pointer to the PF struct 3922769c500dSAkeem G Abodunrin */ 3923769c500dSAkeem G Abodunrin static void ice_print_wake_reason(struct ice_pf *pf) 3924769c500dSAkeem G Abodunrin { 3925769c500dSAkeem G Abodunrin u32 wus = pf->wakeup_reason; 3926769c500dSAkeem G Abodunrin const char *wake_str; 3927769c500dSAkeem G Abodunrin 3928769c500dSAkeem G Abodunrin /* if no wake event, nothing to print */ 3929769c500dSAkeem G Abodunrin if (!wus) 3930769c500dSAkeem G Abodunrin return; 3931769c500dSAkeem G Abodunrin 3932769c500dSAkeem G Abodunrin if (wus & PFPM_WUS_LNKC_M) 3933769c500dSAkeem G Abodunrin wake_str = "Link\n"; 3934769c500dSAkeem G Abodunrin else if (wus & PFPM_WUS_MAG_M) 3935769c500dSAkeem G Abodunrin wake_str = "Magic Packet\n"; 3936769c500dSAkeem G Abodunrin else if (wus & PFPM_WUS_MNG_M) 3937769c500dSAkeem G Abodunrin wake_str = "Management\n"; 3938769c500dSAkeem G Abodunrin else if (wus & PFPM_WUS_FW_RST_WK_M) 3939769c500dSAkeem G Abodunrin wake_str = "Firmware Reset\n"; 3940769c500dSAkeem G Abodunrin else 3941769c500dSAkeem G Abodunrin wake_str = "Unknown\n"; 3942769c500dSAkeem G Abodunrin 3943769c500dSAkeem G Abodunrin dev_info(ice_pf_to_dev(pf), "Wake reason: %s", wake_str); 3944769c500dSAkeem G Abodunrin } 3945769c500dSAkeem G Abodunrin 3946769c500dSAkeem G Abodunrin /** 39471e23f076SAnirudh Venkataramanan * ice_register_netdev - register netdev and devlink port 39481e23f076SAnirudh Venkataramanan * @pf: pointer to the PF struct 39491e23f076SAnirudh Venkataramanan */ 39501e23f076SAnirudh Venkataramanan static int ice_register_netdev(struct ice_pf *pf) 39511e23f076SAnirudh Venkataramanan { 39521e23f076SAnirudh Venkataramanan struct ice_vsi *vsi; 39531e23f076SAnirudh Venkataramanan int err = 0; 39541e23f076SAnirudh Venkataramanan 39551e23f076SAnirudh Venkataramanan vsi = ice_get_main_vsi(pf); 39561e23f076SAnirudh Venkataramanan if (!vsi || !vsi->netdev) 39571e23f076SAnirudh Venkataramanan return -EIO; 39581e23f076SAnirudh Venkataramanan 39591e23f076SAnirudh Venkataramanan err = register_netdev(vsi->netdev); 39601e23f076SAnirudh Venkataramanan if (err) 39611e23f076SAnirudh Venkataramanan goto err_register_netdev; 39621e23f076SAnirudh Venkataramanan 3963a476d72aSAnirudh Venkataramanan set_bit(ICE_VSI_NETDEV_REGISTERED, vsi->state); 39641e23f076SAnirudh Venkataramanan netif_carrier_off(vsi->netdev); 39651e23f076SAnirudh Venkataramanan netif_tx_stop_all_queues(vsi->netdev); 39661e23f076SAnirudh Venkataramanan err = ice_devlink_create_port(vsi); 39671e23f076SAnirudh Venkataramanan if (err) 39681e23f076SAnirudh Venkataramanan goto err_devlink_create; 39691e23f076SAnirudh Venkataramanan 39701e23f076SAnirudh Venkataramanan devlink_port_type_eth_set(&vsi->devlink_port, vsi->netdev); 39711e23f076SAnirudh Venkataramanan 39721e23f076SAnirudh Venkataramanan return 0; 39731e23f076SAnirudh Venkataramanan err_devlink_create: 39741e23f076SAnirudh Venkataramanan unregister_netdev(vsi->netdev); 3975a476d72aSAnirudh Venkataramanan clear_bit(ICE_VSI_NETDEV_REGISTERED, vsi->state); 39761e23f076SAnirudh Venkataramanan err_register_netdev: 39771e23f076SAnirudh Venkataramanan free_netdev(vsi->netdev); 39781e23f076SAnirudh Venkataramanan vsi->netdev = NULL; 3979a476d72aSAnirudh Venkataramanan clear_bit(ICE_VSI_NETDEV_ALLOCD, vsi->state); 39801e23f076SAnirudh Venkataramanan return err; 39811e23f076SAnirudh Venkataramanan } 39821e23f076SAnirudh Venkataramanan 39831e23f076SAnirudh Venkataramanan /** 3984837f08fdSAnirudh Venkataramanan * ice_probe - Device initialization routine 3985837f08fdSAnirudh Venkataramanan * @pdev: PCI device information struct 3986837f08fdSAnirudh Venkataramanan * @ent: entry in ice_pci_tbl 3987837f08fdSAnirudh Venkataramanan * 3988837f08fdSAnirudh Venkataramanan * Returns 0 on success, negative on failure 3989837f08fdSAnirudh Venkataramanan */ 3990c8b7abddSBruce Allan static int 3991c8b7abddSBruce Allan ice_probe(struct pci_dev *pdev, const struct pci_device_id __always_unused *ent) 3992837f08fdSAnirudh Venkataramanan { 399377ed84f4SBruce Allan struct device *dev = &pdev->dev; 3994837f08fdSAnirudh Venkataramanan struct ice_pf *pf; 3995837f08fdSAnirudh Venkataramanan struct ice_hw *hw; 3996b20e6c17SJakub Kicinski int i, err; 3997837f08fdSAnirudh Venkataramanan 39984ee656bbSTony Nguyen /* this driver uses devres, see 39994ee656bbSTony Nguyen * Documentation/driver-api/driver-model/devres.rst 40004ee656bbSTony Nguyen */ 4001837f08fdSAnirudh Venkataramanan err = pcim_enable_device(pdev); 4002837f08fdSAnirudh Venkataramanan if (err) 4003837f08fdSAnirudh Venkataramanan return err; 4004837f08fdSAnirudh Venkataramanan 400580ad6ddeSJesse Brandeburg err = pcim_iomap_regions(pdev, BIT(ICE_BAR0), dev_driver_string(dev)); 4006837f08fdSAnirudh Venkataramanan if (err) { 400777ed84f4SBruce Allan dev_err(dev, "BAR0 I/O map error %d\n", err); 4008837f08fdSAnirudh Venkataramanan return err; 4009837f08fdSAnirudh Venkataramanan } 4010837f08fdSAnirudh Venkataramanan 40111adf7eadSJacob Keller pf = ice_allocate_pf(dev); 4012837f08fdSAnirudh Venkataramanan if (!pf) 4013837f08fdSAnirudh Venkataramanan return -ENOMEM; 4014837f08fdSAnirudh Venkataramanan 40152f2da36eSAnirudh Venkataramanan /* set up for high or low DMA */ 401677ed84f4SBruce Allan err = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(64)); 4017837f08fdSAnirudh Venkataramanan if (err) 401877ed84f4SBruce Allan err = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(32)); 4019837f08fdSAnirudh Venkataramanan if (err) { 402077ed84f4SBruce Allan dev_err(dev, "DMA configuration failed: 0x%x\n", err); 4021837f08fdSAnirudh Venkataramanan return err; 4022837f08fdSAnirudh Venkataramanan } 4023837f08fdSAnirudh Venkataramanan 4024837f08fdSAnirudh Venkataramanan pci_enable_pcie_error_reporting(pdev); 4025837f08fdSAnirudh Venkataramanan pci_set_master(pdev); 4026837f08fdSAnirudh Venkataramanan 4027837f08fdSAnirudh Venkataramanan pf->pdev = pdev; 4028837f08fdSAnirudh Venkataramanan pci_set_drvdata(pdev, pf); 40297e408e07SAnirudh Venkataramanan set_bit(ICE_DOWN, pf->state); 40308d81fa55SAkeem G Abodunrin /* Disable service task until DOWN bit is cleared */ 40317e408e07SAnirudh Venkataramanan set_bit(ICE_SERVICE_DIS, pf->state); 4032837f08fdSAnirudh Venkataramanan 4033837f08fdSAnirudh Venkataramanan hw = &pf->hw; 4034837f08fdSAnirudh Venkataramanan hw->hw_addr = pcim_iomap_table(pdev)[ICE_BAR0]; 40354e56802eSMichal Swiatkowski pci_save_state(pdev); 40364e56802eSMichal Swiatkowski 4037837f08fdSAnirudh Venkataramanan hw->back = pf; 4038837f08fdSAnirudh Venkataramanan hw->vendor_id = pdev->vendor; 4039837f08fdSAnirudh Venkataramanan hw->device_id = pdev->device; 4040837f08fdSAnirudh Venkataramanan pci_read_config_byte(pdev, PCI_REVISION_ID, &hw->revision_id); 4041837f08fdSAnirudh Venkataramanan hw->subsystem_vendor_id = pdev->subsystem_vendor; 4042837f08fdSAnirudh Venkataramanan hw->subsystem_device_id = pdev->subsystem_device; 4043837f08fdSAnirudh Venkataramanan hw->bus.device = PCI_SLOT(pdev->devfn); 4044837f08fdSAnirudh Venkataramanan hw->bus.func = PCI_FUNC(pdev->devfn); 4045f31e4b6fSAnirudh Venkataramanan ice_set_ctrlq_len(hw); 4046f31e4b6fSAnirudh Venkataramanan 4047837f08fdSAnirudh Venkataramanan pf->msg_enable = netif_msg_init(debug, ICE_DFLT_NETIF_M); 4048837f08fdSAnirudh Venkataramanan 40491adf7eadSJacob Keller err = ice_devlink_register(pf); 40501adf7eadSJacob Keller if (err) { 40511adf7eadSJacob Keller dev_err(dev, "ice_devlink_register failed: %d\n", err); 40521adf7eadSJacob Keller goto err_exit_unroll; 40531adf7eadSJacob Keller } 40541adf7eadSJacob Keller 40557ec59eeaSAnirudh Venkataramanan #ifndef CONFIG_DYNAMIC_DEBUG 40567ec59eeaSAnirudh Venkataramanan if (debug < -1) 40577ec59eeaSAnirudh Venkataramanan hw->debug_mask = debug; 40587ec59eeaSAnirudh Venkataramanan #endif 40597ec59eeaSAnirudh Venkataramanan 4060f31e4b6fSAnirudh Venkataramanan err = ice_init_hw(hw); 4061f31e4b6fSAnirudh Venkataramanan if (err) { 406277ed84f4SBruce Allan dev_err(dev, "ice_init_hw failed: %d\n", err); 4063f31e4b6fSAnirudh Venkataramanan err = -EIO; 4064f31e4b6fSAnirudh Venkataramanan goto err_exit_unroll; 4065f31e4b6fSAnirudh Venkataramanan } 4066f31e4b6fSAnirudh Venkataramanan 4067462acf6aSTony Nguyen ice_request_fw(pf); 4068462acf6aSTony Nguyen 4069462acf6aSTony Nguyen /* if ice_request_fw fails, ICE_FLAG_ADV_FEATURES bit won't be 4070462acf6aSTony Nguyen * set in pf->state, which will cause ice_is_safe_mode to return 4071462acf6aSTony Nguyen * true 4072462acf6aSTony Nguyen */ 4073462acf6aSTony Nguyen if (ice_is_safe_mode(pf)) { 407419cce2c6SAnirudh Venkataramanan dev_err(dev, "Package download failed. Advanced features disabled - Device now in Safe Mode\n"); 4075462acf6aSTony Nguyen /* we already got function/device capabilities but these don't 4076462acf6aSTony Nguyen * reflect what the driver needs to do in safe mode. Instead of 4077462acf6aSTony Nguyen * adding conditional logic everywhere to ignore these 4078462acf6aSTony Nguyen * device/function capabilities, override them. 4079462acf6aSTony Nguyen */ 4080462acf6aSTony Nguyen ice_set_safe_mode_caps(hw); 4081462acf6aSTony Nguyen } 4082462acf6aSTony Nguyen 408378b5713aSAnirudh Venkataramanan err = ice_init_pf(pf); 408478b5713aSAnirudh Venkataramanan if (err) { 408578b5713aSAnirudh Venkataramanan dev_err(dev, "ice_init_pf failed: %d\n", err); 408678b5713aSAnirudh Venkataramanan goto err_init_pf_unroll; 408778b5713aSAnirudh Venkataramanan } 4088940b61afSAnirudh Venkataramanan 4089dce730f1SJacob Keller ice_devlink_init_regions(pf); 4090dce730f1SJacob Keller 4091b20e6c17SJakub Kicinski pf->hw.udp_tunnel_nic.set_port = ice_udp_tunnel_set_port; 4092b20e6c17SJakub Kicinski pf->hw.udp_tunnel_nic.unset_port = ice_udp_tunnel_unset_port; 4093b20e6c17SJakub Kicinski pf->hw.udp_tunnel_nic.flags = UDP_TUNNEL_NIC_INFO_MAY_SLEEP; 4094b20e6c17SJakub Kicinski pf->hw.udp_tunnel_nic.shared = &pf->hw.udp_tunnel_shared; 4095b20e6c17SJakub Kicinski i = 0; 4096b20e6c17SJakub Kicinski if (pf->hw.tnl.valid_count[TNL_VXLAN]) { 4097b20e6c17SJakub Kicinski pf->hw.udp_tunnel_nic.tables[i].n_entries = 4098b20e6c17SJakub Kicinski pf->hw.tnl.valid_count[TNL_VXLAN]; 4099b20e6c17SJakub Kicinski pf->hw.udp_tunnel_nic.tables[i].tunnel_types = 4100b20e6c17SJakub Kicinski UDP_TUNNEL_TYPE_VXLAN; 4101b20e6c17SJakub Kicinski i++; 4102b20e6c17SJakub Kicinski } 4103b20e6c17SJakub Kicinski if (pf->hw.tnl.valid_count[TNL_GENEVE]) { 4104b20e6c17SJakub Kicinski pf->hw.udp_tunnel_nic.tables[i].n_entries = 4105b20e6c17SJakub Kicinski pf->hw.tnl.valid_count[TNL_GENEVE]; 4106b20e6c17SJakub Kicinski pf->hw.udp_tunnel_nic.tables[i].tunnel_types = 4107b20e6c17SJakub Kicinski UDP_TUNNEL_TYPE_GENEVE; 4108b20e6c17SJakub Kicinski i++; 4109b20e6c17SJakub Kicinski } 4110b20e6c17SJakub Kicinski 4111995c90f2SAnirudh Venkataramanan pf->num_alloc_vsi = hw->func_caps.guar_num_vsi; 4112940b61afSAnirudh Venkataramanan if (!pf->num_alloc_vsi) { 4113940b61afSAnirudh Venkataramanan err = -EIO; 4114940b61afSAnirudh Venkataramanan goto err_init_pf_unroll; 4115940b61afSAnirudh Venkataramanan } 4116b20e6c17SJakub Kicinski if (pf->num_alloc_vsi > UDP_TUNNEL_NIC_MAX_SHARING_DEVICES) { 4117b20e6c17SJakub Kicinski dev_warn(&pf->pdev->dev, 4118b20e6c17SJakub Kicinski "limiting the VSI count due to UDP tunnel limitation %d > %d\n", 4119b20e6c17SJakub Kicinski pf->num_alloc_vsi, UDP_TUNNEL_NIC_MAX_SHARING_DEVICES); 4120b20e6c17SJakub Kicinski pf->num_alloc_vsi = UDP_TUNNEL_NIC_MAX_SHARING_DEVICES; 4121b20e6c17SJakub Kicinski } 4122940b61afSAnirudh Venkataramanan 412377ed84f4SBruce Allan pf->vsi = devm_kcalloc(dev, pf->num_alloc_vsi, sizeof(*pf->vsi), 412477ed84f4SBruce Allan GFP_KERNEL); 4125940b61afSAnirudh Venkataramanan if (!pf->vsi) { 4126940b61afSAnirudh Venkataramanan err = -ENOMEM; 4127940b61afSAnirudh Venkataramanan goto err_init_pf_unroll; 4128940b61afSAnirudh Venkataramanan } 4129940b61afSAnirudh Venkataramanan 4130940b61afSAnirudh Venkataramanan err = ice_init_interrupt_scheme(pf); 4131940b61afSAnirudh Venkataramanan if (err) { 413277ed84f4SBruce Allan dev_err(dev, "ice_init_interrupt_scheme failed: %d\n", err); 4133940b61afSAnirudh Venkataramanan err = -EIO; 4134bc3a0241SJacob Keller goto err_init_vsi_unroll; 4135940b61afSAnirudh Venkataramanan } 4136940b61afSAnirudh Venkataramanan 4137940b61afSAnirudh Venkataramanan /* In case of MSIX we are going to setup the misc vector right here 4138940b61afSAnirudh Venkataramanan * to handle admin queue events etc. In case of legacy and MSI 4139940b61afSAnirudh Venkataramanan * the misc functionality and queue processing is combined in 4140940b61afSAnirudh Venkataramanan * the same vector and that gets setup at open. 4141940b61afSAnirudh Venkataramanan */ 4142940b61afSAnirudh Venkataramanan err = ice_req_irq_msix_misc(pf); 4143940b61afSAnirudh Venkataramanan if (err) { 414477ed84f4SBruce Allan dev_err(dev, "setup of misc vector failed: %d\n", err); 4145940b61afSAnirudh Venkataramanan goto err_init_interrupt_unroll; 4146940b61afSAnirudh Venkataramanan } 4147940b61afSAnirudh Venkataramanan 4148940b61afSAnirudh Venkataramanan /* create switch struct for the switch element created by FW on boot */ 414977ed84f4SBruce Allan pf->first_sw = devm_kzalloc(dev, sizeof(*pf->first_sw), GFP_KERNEL); 4150940b61afSAnirudh Venkataramanan if (!pf->first_sw) { 4151940b61afSAnirudh Venkataramanan err = -ENOMEM; 4152940b61afSAnirudh Venkataramanan goto err_msix_misc_unroll; 4153940b61afSAnirudh Venkataramanan } 4154940b61afSAnirudh Venkataramanan 4155b1edc14aSMd Fahad Iqbal Polash if (hw->evb_veb) 4156940b61afSAnirudh Venkataramanan pf->first_sw->bridge_mode = BRIDGE_MODE_VEB; 4157b1edc14aSMd Fahad Iqbal Polash else 4158b1edc14aSMd Fahad Iqbal Polash pf->first_sw->bridge_mode = BRIDGE_MODE_VEPA; 4159b1edc14aSMd Fahad Iqbal Polash 4160940b61afSAnirudh Venkataramanan pf->first_sw->pf = pf; 4161940b61afSAnirudh Venkataramanan 4162940b61afSAnirudh Venkataramanan /* record the sw_id available for later use */ 4163940b61afSAnirudh Venkataramanan pf->first_sw->sw_id = hw->port_info->sw_id; 4164940b61afSAnirudh Venkataramanan 41653a858ba3SAnirudh Venkataramanan err = ice_setup_pf_sw(pf); 41663a858ba3SAnirudh Venkataramanan if (err) { 41672f2da36eSAnirudh Venkataramanan dev_err(dev, "probe failed due to setup PF switch: %d\n", err); 41683a858ba3SAnirudh Venkataramanan goto err_alloc_sw_unroll; 41693a858ba3SAnirudh Venkataramanan } 41709daf8208SAnirudh Venkataramanan 41717e408e07SAnirudh Venkataramanan clear_bit(ICE_SERVICE_DIS, pf->state); 41729daf8208SAnirudh Venkataramanan 4173e3710a01SPaul M Stillwell Jr /* tell the firmware we are up */ 4174e3710a01SPaul M Stillwell Jr err = ice_send_version(pf); 4175e3710a01SPaul M Stillwell Jr if (err) { 417619cce2c6SAnirudh Venkataramanan dev_err(dev, "probe failed sending driver version %s. error: %d\n", 417734a2a3b8SJeff Kirsher UTS_RELEASE, err); 417878116e97SMarcin Szycik goto err_send_version_unroll; 4179e3710a01SPaul M Stillwell Jr } 4180e3710a01SPaul M Stillwell Jr 41819daf8208SAnirudh Venkataramanan /* since everything is good, start the service timer */ 41829daf8208SAnirudh Venkataramanan mod_timer(&pf->serv_tmr, round_jiffies(jiffies + pf->serv_tmr_period)); 41839daf8208SAnirudh Venkataramanan 4184250c3b3eSBrett Creeley err = ice_init_link_events(pf->hw.port_info); 4185250c3b3eSBrett Creeley if (err) { 4186250c3b3eSBrett Creeley dev_err(dev, "ice_init_link_events failed: %d\n", err); 418778116e97SMarcin Szycik goto err_send_version_unroll; 4188250c3b3eSBrett Creeley } 4189250c3b3eSBrett Creeley 419008771bceSAnirudh Venkataramanan /* not a fatal error if this fails */ 41911a3571b5SPaul Greenwalt err = ice_init_nvm_phy_type(pf->hw.port_info); 419208771bceSAnirudh Venkataramanan if (err) 41931a3571b5SPaul Greenwalt dev_err(dev, "ice_init_nvm_phy_type failed: %d\n", err); 41941a3571b5SPaul Greenwalt 419508771bceSAnirudh Venkataramanan /* not a fatal error if this fails */ 41961a3571b5SPaul Greenwalt err = ice_update_link_info(pf->hw.port_info); 419708771bceSAnirudh Venkataramanan if (err) 41981a3571b5SPaul Greenwalt dev_err(dev, "ice_update_link_info failed: %d\n", err); 41991a3571b5SPaul Greenwalt 4200ea78ce4dSPaul Greenwalt ice_init_link_dflt_override(pf->hw.port_info); 4201ea78ce4dSPaul Greenwalt 42021a3571b5SPaul Greenwalt /* if media available, initialize PHY settings */ 42031a3571b5SPaul Greenwalt if (pf->hw.port_info->phy.link_info.link_info & 42041a3571b5SPaul Greenwalt ICE_AQ_MEDIA_AVAILABLE) { 420508771bceSAnirudh Venkataramanan /* not a fatal error if this fails */ 42061a3571b5SPaul Greenwalt err = ice_init_phy_user_cfg(pf->hw.port_info); 420708771bceSAnirudh Venkataramanan if (err) 42081a3571b5SPaul Greenwalt dev_err(dev, "ice_init_phy_user_cfg failed: %d\n", err); 42091a3571b5SPaul Greenwalt 42101a3571b5SPaul Greenwalt if (!test_bit(ICE_FLAG_LINK_DOWN_ON_CLOSE_ENA, pf->flags)) { 42111a3571b5SPaul Greenwalt struct ice_vsi *vsi = ice_get_main_vsi(pf); 42121a3571b5SPaul Greenwalt 42131a3571b5SPaul Greenwalt if (vsi) 42141a3571b5SPaul Greenwalt ice_configure_phy(vsi); 42151a3571b5SPaul Greenwalt } 42161a3571b5SPaul Greenwalt } else { 42171a3571b5SPaul Greenwalt set_bit(ICE_FLAG_NO_MEDIA, pf->flags); 42181a3571b5SPaul Greenwalt } 42191a3571b5SPaul Greenwalt 4220c585ea42SBrett Creeley ice_verify_cacheline_size(pf); 4221c585ea42SBrett Creeley 4222769c500dSAkeem G Abodunrin /* Save wakeup reason register for later use */ 4223769c500dSAkeem G Abodunrin pf->wakeup_reason = rd32(hw, PFPM_WUS); 4224769c500dSAkeem G Abodunrin 4225769c500dSAkeem G Abodunrin /* check for a power management event */ 4226769c500dSAkeem G Abodunrin ice_print_wake_reason(pf); 4227769c500dSAkeem G Abodunrin 4228769c500dSAkeem G Abodunrin /* clear wake status, all bits */ 4229769c500dSAkeem G Abodunrin wr32(hw, PFPM_WUS, U32_MAX); 4230769c500dSAkeem G Abodunrin 4231769c500dSAkeem G Abodunrin /* Disable WoL at init, wait for user to enable */ 4232769c500dSAkeem G Abodunrin device_set_wakeup_enable(dev, false); 4233769c500dSAkeem G Abodunrin 4234cd1f56f4SBrett Creeley if (ice_is_safe_mode(pf)) { 4235cd1f56f4SBrett Creeley ice_set_safe_mode_vlan_cfg(pf); 4236de75135bSAnirudh Venkataramanan goto probe_done; 4237cd1f56f4SBrett Creeley } 4238462acf6aSTony Nguyen 4239462acf6aSTony Nguyen /* initialize DDP driven features */ 4240462acf6aSTony Nguyen 4241148beb61SHenry Tieman /* Note: Flow director init failure is non-fatal to load */ 4242148beb61SHenry Tieman if (ice_init_fdir(pf)) 4243148beb61SHenry Tieman dev_err(dev, "could not initialize flow director\n"); 4244148beb61SHenry Tieman 4245462acf6aSTony Nguyen /* Note: DCB init failure is non-fatal to load */ 4246462acf6aSTony Nguyen if (ice_init_pf_dcb(pf, false)) { 4247462acf6aSTony Nguyen clear_bit(ICE_FLAG_DCB_CAPABLE, pf->flags); 4248462acf6aSTony Nguyen clear_bit(ICE_FLAG_DCB_ENA, pf->flags); 4249462acf6aSTony Nguyen } else { 4250462acf6aSTony Nguyen ice_cfg_lldp_mib_change(&pf->hw, true); 4251462acf6aSTony Nguyen } 4252462acf6aSTony Nguyen 4253df006dd4SDave Ertman if (ice_init_lag(pf)) 4254df006dd4SDave Ertman dev_warn(dev, "Failed to init link aggregation support\n"); 4255df006dd4SDave Ertman 4256e18ff118SPaul Greenwalt /* print PCI link speed and width */ 4257e18ff118SPaul Greenwalt pcie_print_link_status(pf->pdev); 4258e18ff118SPaul Greenwalt 4259de75135bSAnirudh Venkataramanan probe_done: 42601e23f076SAnirudh Venkataramanan err = ice_register_netdev(pf); 42611e23f076SAnirudh Venkataramanan if (err) 42621e23f076SAnirudh Venkataramanan goto err_netdev_reg; 42631e23f076SAnirudh Venkataramanan 4264de75135bSAnirudh Venkataramanan /* ready to go, so clear down state bit */ 42657e408e07SAnirudh Venkataramanan clear_bit(ICE_DOWN, pf->state); 4266837f08fdSAnirudh Venkataramanan return 0; 4267f31e4b6fSAnirudh Venkataramanan 42681e23f076SAnirudh Venkataramanan err_netdev_reg: 426978116e97SMarcin Szycik err_send_version_unroll: 427078116e97SMarcin Szycik ice_vsi_release_all(pf); 42713a858ba3SAnirudh Venkataramanan err_alloc_sw_unroll: 42727e408e07SAnirudh Venkataramanan set_bit(ICE_SERVICE_DIS, pf->state); 42737e408e07SAnirudh Venkataramanan set_bit(ICE_DOWN, pf->state); 42744015d11eSBrett Creeley devm_kfree(dev, pf->first_sw); 4275940b61afSAnirudh Venkataramanan err_msix_misc_unroll: 4276940b61afSAnirudh Venkataramanan ice_free_irq_msix_misc(pf); 4277940b61afSAnirudh Venkataramanan err_init_interrupt_unroll: 4278940b61afSAnirudh Venkataramanan ice_clear_interrupt_scheme(pf); 4279bc3a0241SJacob Keller err_init_vsi_unroll: 428077ed84f4SBruce Allan devm_kfree(dev, pf->vsi); 4281940b61afSAnirudh Venkataramanan err_init_pf_unroll: 4282940b61afSAnirudh Venkataramanan ice_deinit_pf(pf); 4283dce730f1SJacob Keller ice_devlink_destroy_regions(pf); 4284940b61afSAnirudh Venkataramanan ice_deinit_hw(hw); 4285f31e4b6fSAnirudh Venkataramanan err_exit_unroll: 42861adf7eadSJacob Keller ice_devlink_unregister(pf); 4287f31e4b6fSAnirudh Venkataramanan pci_disable_pcie_error_reporting(pdev); 4288769c500dSAkeem G Abodunrin pci_disable_device(pdev); 4289f31e4b6fSAnirudh Venkataramanan return err; 4290837f08fdSAnirudh Venkataramanan } 4291837f08fdSAnirudh Venkataramanan 4292837f08fdSAnirudh Venkataramanan /** 4293769c500dSAkeem G Abodunrin * ice_set_wake - enable or disable Wake on LAN 4294769c500dSAkeem G Abodunrin * @pf: pointer to the PF struct 4295769c500dSAkeem G Abodunrin * 4296769c500dSAkeem G Abodunrin * Simple helper for WoL control 4297769c500dSAkeem G Abodunrin */ 4298769c500dSAkeem G Abodunrin static void ice_set_wake(struct ice_pf *pf) 4299769c500dSAkeem G Abodunrin { 4300769c500dSAkeem G Abodunrin struct ice_hw *hw = &pf->hw; 4301769c500dSAkeem G Abodunrin bool wol = pf->wol_ena; 4302769c500dSAkeem G Abodunrin 4303769c500dSAkeem G Abodunrin /* clear wake state, otherwise new wake events won't fire */ 4304769c500dSAkeem G Abodunrin wr32(hw, PFPM_WUS, U32_MAX); 4305769c500dSAkeem G Abodunrin 4306769c500dSAkeem G Abodunrin /* enable / disable APM wake up, no RMW needed */ 4307769c500dSAkeem G Abodunrin wr32(hw, PFPM_APM, wol ? PFPM_APM_APME_M : 0); 4308769c500dSAkeem G Abodunrin 4309769c500dSAkeem G Abodunrin /* set magic packet filter enabled */ 4310769c500dSAkeem G Abodunrin wr32(hw, PFPM_WUFC, wol ? PFPM_WUFC_MAG_M : 0); 4311769c500dSAkeem G Abodunrin } 4312769c500dSAkeem G Abodunrin 4313769c500dSAkeem G Abodunrin /** 4314ef860480STony Nguyen * ice_setup_mc_magic_wake - setup device to wake on multicast magic packet 4315769c500dSAkeem G Abodunrin * @pf: pointer to the PF struct 4316769c500dSAkeem G Abodunrin * 4317769c500dSAkeem G Abodunrin * Issue firmware command to enable multicast magic wake, making 4318769c500dSAkeem G Abodunrin * sure that any locally administered address (LAA) is used for 4319769c500dSAkeem G Abodunrin * wake, and that PF reset doesn't undo the LAA. 4320769c500dSAkeem G Abodunrin */ 4321769c500dSAkeem G Abodunrin static void ice_setup_mc_magic_wake(struct ice_pf *pf) 4322769c500dSAkeem G Abodunrin { 4323769c500dSAkeem G Abodunrin struct device *dev = ice_pf_to_dev(pf); 4324769c500dSAkeem G Abodunrin struct ice_hw *hw = &pf->hw; 4325769c500dSAkeem G Abodunrin enum ice_status status; 4326769c500dSAkeem G Abodunrin u8 mac_addr[ETH_ALEN]; 4327769c500dSAkeem G Abodunrin struct ice_vsi *vsi; 4328769c500dSAkeem G Abodunrin u8 flags; 4329769c500dSAkeem G Abodunrin 4330769c500dSAkeem G Abodunrin if (!pf->wol_ena) 4331769c500dSAkeem G Abodunrin return; 4332769c500dSAkeem G Abodunrin 4333769c500dSAkeem G Abodunrin vsi = ice_get_main_vsi(pf); 4334769c500dSAkeem G Abodunrin if (!vsi) 4335769c500dSAkeem G Abodunrin return; 4336769c500dSAkeem G Abodunrin 4337769c500dSAkeem G Abodunrin /* Get current MAC address in case it's an LAA */ 4338769c500dSAkeem G Abodunrin if (vsi->netdev) 4339769c500dSAkeem G Abodunrin ether_addr_copy(mac_addr, vsi->netdev->dev_addr); 4340769c500dSAkeem G Abodunrin else 4341769c500dSAkeem G Abodunrin ether_addr_copy(mac_addr, vsi->port_info->mac.perm_addr); 4342769c500dSAkeem G Abodunrin 4343769c500dSAkeem G Abodunrin flags = ICE_AQC_MAN_MAC_WR_MC_MAG_EN | 4344769c500dSAkeem G Abodunrin ICE_AQC_MAN_MAC_UPDATE_LAA_WOL | 4345769c500dSAkeem G Abodunrin ICE_AQC_MAN_MAC_WR_WOL_LAA_PFR_KEEP; 4346769c500dSAkeem G Abodunrin 4347769c500dSAkeem G Abodunrin status = ice_aq_manage_mac_write(hw, mac_addr, flags, NULL); 4348769c500dSAkeem G Abodunrin if (status) 4349769c500dSAkeem G Abodunrin dev_err(dev, "Failed to enable Multicast Magic Packet wake, err %s aq_err %s\n", 4350769c500dSAkeem G Abodunrin ice_stat_str(status), 4351769c500dSAkeem G Abodunrin ice_aq_str(hw->adminq.sq_last_status)); 4352769c500dSAkeem G Abodunrin } 4353769c500dSAkeem G Abodunrin 4354769c500dSAkeem G Abodunrin /** 4355837f08fdSAnirudh Venkataramanan * ice_remove - Device removal routine 4356837f08fdSAnirudh Venkataramanan * @pdev: PCI device information struct 4357837f08fdSAnirudh Venkataramanan */ 4358837f08fdSAnirudh Venkataramanan static void ice_remove(struct pci_dev *pdev) 4359837f08fdSAnirudh Venkataramanan { 4360837f08fdSAnirudh Venkataramanan struct ice_pf *pf = pci_get_drvdata(pdev); 436181b23589SDave Ertman int i; 4362837f08fdSAnirudh Venkataramanan 4363837f08fdSAnirudh Venkataramanan if (!pf) 4364837f08fdSAnirudh Venkataramanan return; 4365837f08fdSAnirudh Venkataramanan 4366afd9d4abSAnirudh Venkataramanan for (i = 0; i < ICE_MAX_RESET_WAIT; i++) { 4367afd9d4abSAnirudh Venkataramanan if (!ice_is_reset_in_progress(pf->state)) 4368afd9d4abSAnirudh Venkataramanan break; 4369afd9d4abSAnirudh Venkataramanan msleep(100); 4370afd9d4abSAnirudh Venkataramanan } 4371afd9d4abSAnirudh Venkataramanan 4372f844d521SBrett Creeley if (test_bit(ICE_FLAG_SRIOV_ENA, pf->flags)) { 43737e408e07SAnirudh Venkataramanan set_bit(ICE_VF_RESETS_DISABLED, pf->state); 4374f844d521SBrett Creeley ice_free_vfs(pf); 4375f844d521SBrett Creeley } 4376f844d521SBrett Creeley 43777e408e07SAnirudh Venkataramanan set_bit(ICE_DOWN, pf->state); 43788d81fa55SAkeem G Abodunrin ice_service_task_stop(pf); 4379f31e4b6fSAnirudh Venkataramanan 4380d69ea414SJacob Keller ice_aq_cancel_waiting_tasks(pf); 4381d69ea414SJacob Keller 4382148beb61SHenry Tieman mutex_destroy(&(&pf->hw)->fdir_fltr_lock); 4383df006dd4SDave Ertman ice_deinit_lag(pf); 438428bf2672SBrett Creeley if (!ice_is_safe_mode(pf)) 438528bf2672SBrett Creeley ice_remove_arfs(pf); 4386769c500dSAkeem G Abodunrin ice_setup_mc_magic_wake(pf); 43870f9d5027SAnirudh Venkataramanan ice_vsi_release_all(pf); 4388769c500dSAkeem G Abodunrin ice_set_wake(pf); 4389940b61afSAnirudh Venkataramanan ice_free_irq_msix_misc(pf); 439081b23589SDave Ertman ice_for_each_vsi(pf, i) { 439181b23589SDave Ertman if (!pf->vsi[i]) 439281b23589SDave Ertman continue; 439381b23589SDave Ertman ice_vsi_free_q_vectors(pf->vsi[i]); 439481b23589SDave Ertman } 4395940b61afSAnirudh Venkataramanan ice_deinit_pf(pf); 4396dce730f1SJacob Keller ice_devlink_destroy_regions(pf); 4397f31e4b6fSAnirudh Venkataramanan ice_deinit_hw(&pf->hw); 43981adf7eadSJacob Keller ice_devlink_unregister(pf); 43991adf7eadSJacob Keller 440018057cb3SBruce Allan /* Issue a PFR as part of the prescribed driver unload flow. Do not 440118057cb3SBruce Allan * do it via ice_schedule_reset() since there is no need to rebuild 440218057cb3SBruce Allan * and the service task is already stopped. 440318057cb3SBruce Allan */ 440418057cb3SBruce Allan ice_reset(&pf->hw, ICE_RESET_PFR); 4405c6012ac1SBruce Allan pci_wait_for_pending_transaction(pdev); 4406c6012ac1SBruce Allan ice_clear_interrupt_scheme(pf); 4407837f08fdSAnirudh Venkataramanan pci_disable_pcie_error_reporting(pdev); 4408769c500dSAkeem G Abodunrin pci_disable_device(pdev); 4409837f08fdSAnirudh Venkataramanan } 4410837f08fdSAnirudh Venkataramanan 44115995b6d0SBrett Creeley /** 4412769c500dSAkeem G Abodunrin * ice_shutdown - PCI callback for shutting down device 4413769c500dSAkeem G Abodunrin * @pdev: PCI device information struct 4414769c500dSAkeem G Abodunrin */ 4415769c500dSAkeem G Abodunrin static void ice_shutdown(struct pci_dev *pdev) 4416769c500dSAkeem G Abodunrin { 4417769c500dSAkeem G Abodunrin struct ice_pf *pf = pci_get_drvdata(pdev); 4418769c500dSAkeem G Abodunrin 4419769c500dSAkeem G Abodunrin ice_remove(pdev); 4420769c500dSAkeem G Abodunrin 4421769c500dSAkeem G Abodunrin if (system_state == SYSTEM_POWER_OFF) { 4422769c500dSAkeem G Abodunrin pci_wake_from_d3(pdev, pf->wol_ena); 4423769c500dSAkeem G Abodunrin pci_set_power_state(pdev, PCI_D3hot); 4424769c500dSAkeem G Abodunrin } 4425769c500dSAkeem G Abodunrin } 4426769c500dSAkeem G Abodunrin 4427769c500dSAkeem G Abodunrin #ifdef CONFIG_PM 4428769c500dSAkeem G Abodunrin /** 4429769c500dSAkeem G Abodunrin * ice_prepare_for_shutdown - prep for PCI shutdown 4430769c500dSAkeem G Abodunrin * @pf: board private structure 4431769c500dSAkeem G Abodunrin * 4432769c500dSAkeem G Abodunrin * Inform or close all dependent features in prep for PCI device shutdown 4433769c500dSAkeem G Abodunrin */ 4434769c500dSAkeem G Abodunrin static void ice_prepare_for_shutdown(struct ice_pf *pf) 4435769c500dSAkeem G Abodunrin { 4436769c500dSAkeem G Abodunrin struct ice_hw *hw = &pf->hw; 4437769c500dSAkeem G Abodunrin u32 v; 4438769c500dSAkeem G Abodunrin 4439769c500dSAkeem G Abodunrin /* Notify VFs of impending reset */ 4440769c500dSAkeem G Abodunrin if (ice_check_sq_alive(hw, &hw->mailboxq)) 4441769c500dSAkeem G Abodunrin ice_vc_notify_reset(pf); 4442769c500dSAkeem G Abodunrin 4443769c500dSAkeem G Abodunrin dev_dbg(ice_pf_to_dev(pf), "Tearing down internal switch for shutdown\n"); 4444769c500dSAkeem G Abodunrin 4445769c500dSAkeem G Abodunrin /* disable the VSIs and their queues that are not already DOWN */ 4446769c500dSAkeem G Abodunrin ice_pf_dis_all_vsi(pf, false); 4447769c500dSAkeem G Abodunrin 4448769c500dSAkeem G Abodunrin ice_for_each_vsi(pf, v) 4449769c500dSAkeem G Abodunrin if (pf->vsi[v]) 4450769c500dSAkeem G Abodunrin pf->vsi[v]->vsi_num = 0; 4451769c500dSAkeem G Abodunrin 4452769c500dSAkeem G Abodunrin ice_shutdown_all_ctrlq(hw); 4453769c500dSAkeem G Abodunrin } 4454769c500dSAkeem G Abodunrin 4455769c500dSAkeem G Abodunrin /** 4456769c500dSAkeem G Abodunrin * ice_reinit_interrupt_scheme - Reinitialize interrupt scheme 4457769c500dSAkeem G Abodunrin * @pf: board private structure to reinitialize 4458769c500dSAkeem G Abodunrin * 4459769c500dSAkeem G Abodunrin * This routine reinitialize interrupt scheme that was cleared during 4460769c500dSAkeem G Abodunrin * power management suspend callback. 4461769c500dSAkeem G Abodunrin * 4462769c500dSAkeem G Abodunrin * This should be called during resume routine to re-allocate the q_vectors 4463769c500dSAkeem G Abodunrin * and reacquire interrupts. 4464769c500dSAkeem G Abodunrin */ 4465769c500dSAkeem G Abodunrin static int ice_reinit_interrupt_scheme(struct ice_pf *pf) 4466769c500dSAkeem G Abodunrin { 4467769c500dSAkeem G Abodunrin struct device *dev = ice_pf_to_dev(pf); 4468769c500dSAkeem G Abodunrin int ret, v; 4469769c500dSAkeem G Abodunrin 4470769c500dSAkeem G Abodunrin /* Since we clear MSIX flag during suspend, we need to 4471769c500dSAkeem G Abodunrin * set it back during resume... 4472769c500dSAkeem G Abodunrin */ 4473769c500dSAkeem G Abodunrin 4474769c500dSAkeem G Abodunrin ret = ice_init_interrupt_scheme(pf); 4475769c500dSAkeem G Abodunrin if (ret) { 4476769c500dSAkeem G Abodunrin dev_err(dev, "Failed to re-initialize interrupt %d\n", ret); 4477769c500dSAkeem G Abodunrin return ret; 4478769c500dSAkeem G Abodunrin } 4479769c500dSAkeem G Abodunrin 4480769c500dSAkeem G Abodunrin /* Remap vectors and rings, after successful re-init interrupts */ 4481769c500dSAkeem G Abodunrin ice_for_each_vsi(pf, v) { 4482769c500dSAkeem G Abodunrin if (!pf->vsi[v]) 4483769c500dSAkeem G Abodunrin continue; 4484769c500dSAkeem G Abodunrin 4485769c500dSAkeem G Abodunrin ret = ice_vsi_alloc_q_vectors(pf->vsi[v]); 4486769c500dSAkeem G Abodunrin if (ret) 4487769c500dSAkeem G Abodunrin goto err_reinit; 4488769c500dSAkeem G Abodunrin ice_vsi_map_rings_to_vectors(pf->vsi[v]); 4489769c500dSAkeem G Abodunrin } 4490769c500dSAkeem G Abodunrin 4491769c500dSAkeem G Abodunrin ret = ice_req_irq_msix_misc(pf); 4492769c500dSAkeem G Abodunrin if (ret) { 4493769c500dSAkeem G Abodunrin dev_err(dev, "Setting up misc vector failed after device suspend %d\n", 4494769c500dSAkeem G Abodunrin ret); 4495769c500dSAkeem G Abodunrin goto err_reinit; 4496769c500dSAkeem G Abodunrin } 4497769c500dSAkeem G Abodunrin 4498769c500dSAkeem G Abodunrin return 0; 4499769c500dSAkeem G Abodunrin 4500769c500dSAkeem G Abodunrin err_reinit: 4501769c500dSAkeem G Abodunrin while (v--) 4502769c500dSAkeem G Abodunrin if (pf->vsi[v]) 4503769c500dSAkeem G Abodunrin ice_vsi_free_q_vectors(pf->vsi[v]); 4504769c500dSAkeem G Abodunrin 4505769c500dSAkeem G Abodunrin return ret; 4506769c500dSAkeem G Abodunrin } 4507769c500dSAkeem G Abodunrin 4508769c500dSAkeem G Abodunrin /** 4509769c500dSAkeem G Abodunrin * ice_suspend 4510769c500dSAkeem G Abodunrin * @dev: generic device information structure 4511769c500dSAkeem G Abodunrin * 4512769c500dSAkeem G Abodunrin * Power Management callback to quiesce the device and prepare 4513769c500dSAkeem G Abodunrin * for D3 transition. 4514769c500dSAkeem G Abodunrin */ 451565c72291SWei Yongjun static int __maybe_unused ice_suspend(struct device *dev) 4516769c500dSAkeem G Abodunrin { 4517769c500dSAkeem G Abodunrin struct pci_dev *pdev = to_pci_dev(dev); 4518769c500dSAkeem G Abodunrin struct ice_pf *pf; 4519769c500dSAkeem G Abodunrin int disabled, v; 4520769c500dSAkeem G Abodunrin 4521769c500dSAkeem G Abodunrin pf = pci_get_drvdata(pdev); 4522769c500dSAkeem G Abodunrin 4523769c500dSAkeem G Abodunrin if (!ice_pf_state_is_nominal(pf)) { 4524769c500dSAkeem G Abodunrin dev_err(dev, "Device is not ready, no need to suspend it\n"); 4525769c500dSAkeem G Abodunrin return -EBUSY; 4526769c500dSAkeem G Abodunrin } 4527769c500dSAkeem G Abodunrin 4528769c500dSAkeem G Abodunrin /* Stop watchdog tasks until resume completion. 4529769c500dSAkeem G Abodunrin * Even though it is most likely that the service task is 4530769c500dSAkeem G Abodunrin * disabled if the device is suspended or down, the service task's 4531769c500dSAkeem G Abodunrin * state is controlled by a different state bit, and we should 4532769c500dSAkeem G Abodunrin * store and honor whatever state that bit is in at this point. 4533769c500dSAkeem G Abodunrin */ 4534769c500dSAkeem G Abodunrin disabled = ice_service_task_stop(pf); 4535769c500dSAkeem G Abodunrin 4536769c500dSAkeem G Abodunrin /* Already suspended?, then there is nothing to do */ 45377e408e07SAnirudh Venkataramanan if (test_and_set_bit(ICE_SUSPENDED, pf->state)) { 4538769c500dSAkeem G Abodunrin if (!disabled) 4539769c500dSAkeem G Abodunrin ice_service_task_restart(pf); 4540769c500dSAkeem G Abodunrin return 0; 4541769c500dSAkeem G Abodunrin } 4542769c500dSAkeem G Abodunrin 45437e408e07SAnirudh Venkataramanan if (test_bit(ICE_DOWN, pf->state) || 4544769c500dSAkeem G Abodunrin ice_is_reset_in_progress(pf->state)) { 4545769c500dSAkeem G Abodunrin dev_err(dev, "can't suspend device in reset or already down\n"); 4546769c500dSAkeem G Abodunrin if (!disabled) 4547769c500dSAkeem G Abodunrin ice_service_task_restart(pf); 4548769c500dSAkeem G Abodunrin return 0; 4549769c500dSAkeem G Abodunrin } 4550769c500dSAkeem G Abodunrin 4551769c500dSAkeem G Abodunrin ice_setup_mc_magic_wake(pf); 4552769c500dSAkeem G Abodunrin 4553769c500dSAkeem G Abodunrin ice_prepare_for_shutdown(pf); 4554769c500dSAkeem G Abodunrin 4555769c500dSAkeem G Abodunrin ice_set_wake(pf); 4556769c500dSAkeem G Abodunrin 4557769c500dSAkeem G Abodunrin /* Free vectors, clear the interrupt scheme and release IRQs 4558769c500dSAkeem G Abodunrin * for proper hibernation, especially with large number of CPUs. 4559769c500dSAkeem G Abodunrin * Otherwise hibernation might fail when mapping all the vectors back 4560769c500dSAkeem G Abodunrin * to CPU0. 4561769c500dSAkeem G Abodunrin */ 4562769c500dSAkeem G Abodunrin ice_free_irq_msix_misc(pf); 4563769c500dSAkeem G Abodunrin ice_for_each_vsi(pf, v) { 4564769c500dSAkeem G Abodunrin if (!pf->vsi[v]) 4565769c500dSAkeem G Abodunrin continue; 4566769c500dSAkeem G Abodunrin ice_vsi_free_q_vectors(pf->vsi[v]); 4567769c500dSAkeem G Abodunrin } 45681831da7eSYongxin Liu ice_free_cpu_rx_rmap(ice_get_main_vsi(pf)); 4569769c500dSAkeem G Abodunrin ice_clear_interrupt_scheme(pf); 4570769c500dSAkeem G Abodunrin 4571466e4392SAnirudh Venkataramanan pci_save_state(pdev); 4572769c500dSAkeem G Abodunrin pci_wake_from_d3(pdev, pf->wol_ena); 4573769c500dSAkeem G Abodunrin pci_set_power_state(pdev, PCI_D3hot); 4574769c500dSAkeem G Abodunrin return 0; 4575769c500dSAkeem G Abodunrin } 4576769c500dSAkeem G Abodunrin 4577769c500dSAkeem G Abodunrin /** 4578769c500dSAkeem G Abodunrin * ice_resume - PM callback for waking up from D3 4579769c500dSAkeem G Abodunrin * @dev: generic device information structure 4580769c500dSAkeem G Abodunrin */ 458165c72291SWei Yongjun static int __maybe_unused ice_resume(struct device *dev) 4582769c500dSAkeem G Abodunrin { 4583769c500dSAkeem G Abodunrin struct pci_dev *pdev = to_pci_dev(dev); 4584769c500dSAkeem G Abodunrin enum ice_reset_req reset_type; 4585769c500dSAkeem G Abodunrin struct ice_pf *pf; 4586769c500dSAkeem G Abodunrin struct ice_hw *hw; 4587769c500dSAkeem G Abodunrin int ret; 4588769c500dSAkeem G Abodunrin 4589769c500dSAkeem G Abodunrin pci_set_power_state(pdev, PCI_D0); 4590769c500dSAkeem G Abodunrin pci_restore_state(pdev); 4591769c500dSAkeem G Abodunrin pci_save_state(pdev); 4592769c500dSAkeem G Abodunrin 4593769c500dSAkeem G Abodunrin if (!pci_device_is_present(pdev)) 4594769c500dSAkeem G Abodunrin return -ENODEV; 4595769c500dSAkeem G Abodunrin 4596769c500dSAkeem G Abodunrin ret = pci_enable_device_mem(pdev); 4597769c500dSAkeem G Abodunrin if (ret) { 4598769c500dSAkeem G Abodunrin dev_err(dev, "Cannot enable device after suspend\n"); 4599769c500dSAkeem G Abodunrin return ret; 4600769c500dSAkeem G Abodunrin } 4601769c500dSAkeem G Abodunrin 4602769c500dSAkeem G Abodunrin pf = pci_get_drvdata(pdev); 4603769c500dSAkeem G Abodunrin hw = &pf->hw; 4604769c500dSAkeem G Abodunrin 4605769c500dSAkeem G Abodunrin pf->wakeup_reason = rd32(hw, PFPM_WUS); 4606769c500dSAkeem G Abodunrin ice_print_wake_reason(pf); 4607769c500dSAkeem G Abodunrin 4608769c500dSAkeem G Abodunrin /* We cleared the interrupt scheme when we suspended, so we need to 4609769c500dSAkeem G Abodunrin * restore it now to resume device functionality. 4610769c500dSAkeem G Abodunrin */ 4611769c500dSAkeem G Abodunrin ret = ice_reinit_interrupt_scheme(pf); 4612769c500dSAkeem G Abodunrin if (ret) 4613769c500dSAkeem G Abodunrin dev_err(dev, "Cannot restore interrupt scheme: %d\n", ret); 4614769c500dSAkeem G Abodunrin 46157e408e07SAnirudh Venkataramanan clear_bit(ICE_DOWN, pf->state); 4616769c500dSAkeem G Abodunrin /* Now perform PF reset and rebuild */ 4617769c500dSAkeem G Abodunrin reset_type = ICE_RESET_PFR; 4618769c500dSAkeem G Abodunrin /* re-enable service task for reset, but allow reset to schedule it */ 46197e408e07SAnirudh Venkataramanan clear_bit(ICE_SERVICE_DIS, pf->state); 4620769c500dSAkeem G Abodunrin 4621769c500dSAkeem G Abodunrin if (ice_schedule_reset(pf, reset_type)) 4622769c500dSAkeem G Abodunrin dev_err(dev, "Reset during resume failed.\n"); 4623769c500dSAkeem G Abodunrin 46247e408e07SAnirudh Venkataramanan clear_bit(ICE_SUSPENDED, pf->state); 4625769c500dSAkeem G Abodunrin ice_service_task_restart(pf); 4626769c500dSAkeem G Abodunrin 4627769c500dSAkeem G Abodunrin /* Restart the service task */ 4628769c500dSAkeem G Abodunrin mod_timer(&pf->serv_tmr, round_jiffies(jiffies + pf->serv_tmr_period)); 4629769c500dSAkeem G Abodunrin 4630769c500dSAkeem G Abodunrin return 0; 4631769c500dSAkeem G Abodunrin } 4632769c500dSAkeem G Abodunrin #endif /* CONFIG_PM */ 4633769c500dSAkeem G Abodunrin 4634769c500dSAkeem G Abodunrin /** 46355995b6d0SBrett Creeley * ice_pci_err_detected - warning that PCI error has been detected 46365995b6d0SBrett Creeley * @pdev: PCI device information struct 46375995b6d0SBrett Creeley * @err: the type of PCI error 46385995b6d0SBrett Creeley * 46395995b6d0SBrett Creeley * Called to warn that something happened on the PCI bus and the error handling 46405995b6d0SBrett Creeley * is in progress. Allows the driver to gracefully prepare/handle PCI errors. 46415995b6d0SBrett Creeley */ 46425995b6d0SBrett Creeley static pci_ers_result_t 464316d79cd4SLuc Van Oostenryck ice_pci_err_detected(struct pci_dev *pdev, pci_channel_state_t err) 46445995b6d0SBrett Creeley { 46455995b6d0SBrett Creeley struct ice_pf *pf = pci_get_drvdata(pdev); 46465995b6d0SBrett Creeley 46475995b6d0SBrett Creeley if (!pf) { 46485995b6d0SBrett Creeley dev_err(&pdev->dev, "%s: unrecoverable device error %d\n", 46495995b6d0SBrett Creeley __func__, err); 46505995b6d0SBrett Creeley return PCI_ERS_RESULT_DISCONNECT; 46515995b6d0SBrett Creeley } 46525995b6d0SBrett Creeley 46537e408e07SAnirudh Venkataramanan if (!test_bit(ICE_SUSPENDED, pf->state)) { 46545995b6d0SBrett Creeley ice_service_task_stop(pf); 46555995b6d0SBrett Creeley 46567e408e07SAnirudh Venkataramanan if (!test_bit(ICE_PREPARED_FOR_RESET, pf->state)) { 46577e408e07SAnirudh Venkataramanan set_bit(ICE_PFR_REQ, pf->state); 46585995b6d0SBrett Creeley ice_prepare_for_reset(pf); 46595995b6d0SBrett Creeley } 46605995b6d0SBrett Creeley } 46615995b6d0SBrett Creeley 46625995b6d0SBrett Creeley return PCI_ERS_RESULT_NEED_RESET; 46635995b6d0SBrett Creeley } 46645995b6d0SBrett Creeley 46655995b6d0SBrett Creeley /** 46665995b6d0SBrett Creeley * ice_pci_err_slot_reset - a PCI slot reset has just happened 46675995b6d0SBrett Creeley * @pdev: PCI device information struct 46685995b6d0SBrett Creeley * 46695995b6d0SBrett Creeley * Called to determine if the driver can recover from the PCI slot reset by 46705995b6d0SBrett Creeley * using a register read to determine if the device is recoverable. 46715995b6d0SBrett Creeley */ 46725995b6d0SBrett Creeley static pci_ers_result_t ice_pci_err_slot_reset(struct pci_dev *pdev) 46735995b6d0SBrett Creeley { 46745995b6d0SBrett Creeley struct ice_pf *pf = pci_get_drvdata(pdev); 46755995b6d0SBrett Creeley pci_ers_result_t result; 46765995b6d0SBrett Creeley int err; 46775995b6d0SBrett Creeley u32 reg; 46785995b6d0SBrett Creeley 46795995b6d0SBrett Creeley err = pci_enable_device_mem(pdev); 46805995b6d0SBrett Creeley if (err) { 468119cce2c6SAnirudh Venkataramanan dev_err(&pdev->dev, "Cannot re-enable PCI device after reset, error %d\n", 46825995b6d0SBrett Creeley err); 46835995b6d0SBrett Creeley result = PCI_ERS_RESULT_DISCONNECT; 46845995b6d0SBrett Creeley } else { 46855995b6d0SBrett Creeley pci_set_master(pdev); 46865995b6d0SBrett Creeley pci_restore_state(pdev); 46875995b6d0SBrett Creeley pci_save_state(pdev); 46885995b6d0SBrett Creeley pci_wake_from_d3(pdev, false); 46895995b6d0SBrett Creeley 46905995b6d0SBrett Creeley /* Check for life */ 46915995b6d0SBrett Creeley reg = rd32(&pf->hw, GLGEN_RTRIG); 46925995b6d0SBrett Creeley if (!reg) 46935995b6d0SBrett Creeley result = PCI_ERS_RESULT_RECOVERED; 46945995b6d0SBrett Creeley else 46955995b6d0SBrett Creeley result = PCI_ERS_RESULT_DISCONNECT; 46965995b6d0SBrett Creeley } 46975995b6d0SBrett Creeley 4698894020fdSKuppuswamy Sathyanarayanan err = pci_aer_clear_nonfatal_status(pdev); 46995995b6d0SBrett Creeley if (err) 470086f26a77SLinus Torvalds dev_dbg(&pdev->dev, "pci_aer_clear_nonfatal_status() failed, error %d\n", 47015995b6d0SBrett Creeley err); 47025995b6d0SBrett Creeley /* non-fatal, continue */ 47035995b6d0SBrett Creeley 47045995b6d0SBrett Creeley return result; 47055995b6d0SBrett Creeley } 47065995b6d0SBrett Creeley 47075995b6d0SBrett Creeley /** 47085995b6d0SBrett Creeley * ice_pci_err_resume - restart operations after PCI error recovery 47095995b6d0SBrett Creeley * @pdev: PCI device information struct 47105995b6d0SBrett Creeley * 47115995b6d0SBrett Creeley * Called to allow the driver to bring things back up after PCI error and/or 47125995b6d0SBrett Creeley * reset recovery have finished 47135995b6d0SBrett Creeley */ 47145995b6d0SBrett Creeley static void ice_pci_err_resume(struct pci_dev *pdev) 47155995b6d0SBrett Creeley { 47165995b6d0SBrett Creeley struct ice_pf *pf = pci_get_drvdata(pdev); 47175995b6d0SBrett Creeley 47185995b6d0SBrett Creeley if (!pf) { 471919cce2c6SAnirudh Venkataramanan dev_err(&pdev->dev, "%s failed, device is unrecoverable\n", 472019cce2c6SAnirudh Venkataramanan __func__); 47215995b6d0SBrett Creeley return; 47225995b6d0SBrett Creeley } 47235995b6d0SBrett Creeley 47247e408e07SAnirudh Venkataramanan if (test_bit(ICE_SUSPENDED, pf->state)) { 47255995b6d0SBrett Creeley dev_dbg(&pdev->dev, "%s failed to resume normal operations!\n", 47265995b6d0SBrett Creeley __func__); 47275995b6d0SBrett Creeley return; 47285995b6d0SBrett Creeley } 47295995b6d0SBrett Creeley 4730a54a0b24SNick Nunley ice_restore_all_vfs_msi_state(pdev); 4731a54a0b24SNick Nunley 47325995b6d0SBrett Creeley ice_do_reset(pf, ICE_RESET_PFR); 47335995b6d0SBrett Creeley ice_service_task_restart(pf); 47345995b6d0SBrett Creeley mod_timer(&pf->serv_tmr, round_jiffies(jiffies + pf->serv_tmr_period)); 47355995b6d0SBrett Creeley } 47365995b6d0SBrett Creeley 47375995b6d0SBrett Creeley /** 47385995b6d0SBrett Creeley * ice_pci_err_reset_prepare - prepare device driver for PCI reset 47395995b6d0SBrett Creeley * @pdev: PCI device information struct 47405995b6d0SBrett Creeley */ 47415995b6d0SBrett Creeley static void ice_pci_err_reset_prepare(struct pci_dev *pdev) 47425995b6d0SBrett Creeley { 47435995b6d0SBrett Creeley struct ice_pf *pf = pci_get_drvdata(pdev); 47445995b6d0SBrett Creeley 47457e408e07SAnirudh Venkataramanan if (!test_bit(ICE_SUSPENDED, pf->state)) { 47465995b6d0SBrett Creeley ice_service_task_stop(pf); 47475995b6d0SBrett Creeley 47487e408e07SAnirudh Venkataramanan if (!test_bit(ICE_PREPARED_FOR_RESET, pf->state)) { 47497e408e07SAnirudh Venkataramanan set_bit(ICE_PFR_REQ, pf->state); 47505995b6d0SBrett Creeley ice_prepare_for_reset(pf); 47515995b6d0SBrett Creeley } 47525995b6d0SBrett Creeley } 47535995b6d0SBrett Creeley } 47545995b6d0SBrett Creeley 47555995b6d0SBrett Creeley /** 47565995b6d0SBrett Creeley * ice_pci_err_reset_done - PCI reset done, device driver reset can begin 47575995b6d0SBrett Creeley * @pdev: PCI device information struct 47585995b6d0SBrett Creeley */ 47595995b6d0SBrett Creeley static void ice_pci_err_reset_done(struct pci_dev *pdev) 47605995b6d0SBrett Creeley { 47615995b6d0SBrett Creeley ice_pci_err_resume(pdev); 47625995b6d0SBrett Creeley } 47635995b6d0SBrett Creeley 4764837f08fdSAnirudh Venkataramanan /* ice_pci_tbl - PCI Device ID Table 4765837f08fdSAnirudh Venkataramanan * 4766837f08fdSAnirudh Venkataramanan * Wildcard entries (PCI_ANY_ID) should come last 4767837f08fdSAnirudh Venkataramanan * Last entry must be all 0s 4768837f08fdSAnirudh Venkataramanan * 4769837f08fdSAnirudh Venkataramanan * { Vendor ID, Device ID, SubVendor ID, SubDevice ID, 4770837f08fdSAnirudh Venkataramanan * Class, Class Mask, private data (not used) } 4771837f08fdSAnirudh Venkataramanan */ 4772837f08fdSAnirudh Venkataramanan static const struct pci_device_id ice_pci_tbl[] = { 4773633d7449SAnirudh Venkataramanan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E810C_BACKPLANE), 0 }, 4774633d7449SAnirudh Venkataramanan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E810C_QSFP), 0 }, 4775633d7449SAnirudh Venkataramanan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E810C_SFP), 0 }, 4776195fb977SBruce Allan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E810_XXV_SFP), 0 }, 4777e36aeec0SBruce Allan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E823C_BACKPLANE), 0 }, 4778e36aeec0SBruce Allan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E823C_QSFP), 0 }, 4779e36aeec0SBruce Allan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E823C_SFP), 0 }, 4780e36aeec0SBruce Allan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E823C_10G_BASE_T), 0 }, 4781e36aeec0SBruce Allan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E823C_SGMII), 0 }, 47825d9e618cSJacob Keller { PCI_VDEVICE(INTEL, ICE_DEV_ID_E822C_BACKPLANE), 0 }, 47835d9e618cSJacob Keller { PCI_VDEVICE(INTEL, ICE_DEV_ID_E822C_QSFP), 0 }, 47845d9e618cSJacob Keller { PCI_VDEVICE(INTEL, ICE_DEV_ID_E822C_SFP), 0 }, 47855d9e618cSJacob Keller { PCI_VDEVICE(INTEL, ICE_DEV_ID_E822C_10G_BASE_T), 0 }, 47865d9e618cSJacob Keller { PCI_VDEVICE(INTEL, ICE_DEV_ID_E822C_SGMII), 0 }, 47872fbfa966SBruce Allan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E822L_BACKPLANE), 0 }, 47885d9e618cSJacob Keller { PCI_VDEVICE(INTEL, ICE_DEV_ID_E822L_SFP), 0 }, 47895d9e618cSJacob Keller { PCI_VDEVICE(INTEL, ICE_DEV_ID_E822L_10G_BASE_T), 0 }, 47905d9e618cSJacob Keller { PCI_VDEVICE(INTEL, ICE_DEV_ID_E822L_SGMII), 0 }, 4791e36aeec0SBruce Allan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E823L_BACKPLANE), 0 }, 4792e36aeec0SBruce Allan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E823L_SFP), 0 }, 4793e36aeec0SBruce Allan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E823L_10G_BASE_T), 0 }, 4794e36aeec0SBruce Allan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E823L_1GBE), 0 }, 4795e36aeec0SBruce Allan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E823L_QSFP), 0 }, 4796837f08fdSAnirudh Venkataramanan /* required last entry */ 4797837f08fdSAnirudh Venkataramanan { 0, } 4798837f08fdSAnirudh Venkataramanan }; 4799837f08fdSAnirudh Venkataramanan MODULE_DEVICE_TABLE(pci, ice_pci_tbl); 4800837f08fdSAnirudh Venkataramanan 4801769c500dSAkeem G Abodunrin static __maybe_unused SIMPLE_DEV_PM_OPS(ice_pm_ops, ice_suspend, ice_resume); 4802769c500dSAkeem G Abodunrin 48035995b6d0SBrett Creeley static const struct pci_error_handlers ice_pci_err_handler = { 48045995b6d0SBrett Creeley .error_detected = ice_pci_err_detected, 48055995b6d0SBrett Creeley .slot_reset = ice_pci_err_slot_reset, 48065995b6d0SBrett Creeley .reset_prepare = ice_pci_err_reset_prepare, 48075995b6d0SBrett Creeley .reset_done = ice_pci_err_reset_done, 48085995b6d0SBrett Creeley .resume = ice_pci_err_resume 48095995b6d0SBrett Creeley }; 48105995b6d0SBrett Creeley 4811837f08fdSAnirudh Venkataramanan static struct pci_driver ice_driver = { 4812837f08fdSAnirudh Venkataramanan .name = KBUILD_MODNAME, 4813837f08fdSAnirudh Venkataramanan .id_table = ice_pci_tbl, 4814837f08fdSAnirudh Venkataramanan .probe = ice_probe, 4815837f08fdSAnirudh Venkataramanan .remove = ice_remove, 4816769c500dSAkeem G Abodunrin #ifdef CONFIG_PM 4817769c500dSAkeem G Abodunrin .driver.pm = &ice_pm_ops, 4818769c500dSAkeem G Abodunrin #endif /* CONFIG_PM */ 4819769c500dSAkeem G Abodunrin .shutdown = ice_shutdown, 4820ddf30f7fSAnirudh Venkataramanan .sriov_configure = ice_sriov_configure, 48215995b6d0SBrett Creeley .err_handler = &ice_pci_err_handler 4822837f08fdSAnirudh Venkataramanan }; 4823837f08fdSAnirudh Venkataramanan 4824837f08fdSAnirudh Venkataramanan /** 4825837f08fdSAnirudh Venkataramanan * ice_module_init - Driver registration routine 4826837f08fdSAnirudh Venkataramanan * 4827837f08fdSAnirudh Venkataramanan * ice_module_init is the first routine called when the driver is 4828837f08fdSAnirudh Venkataramanan * loaded. All it does is register with the PCI subsystem. 4829837f08fdSAnirudh Venkataramanan */ 4830837f08fdSAnirudh Venkataramanan static int __init ice_module_init(void) 4831837f08fdSAnirudh Venkataramanan { 4832837f08fdSAnirudh Venkataramanan int status; 4833837f08fdSAnirudh Venkataramanan 483434a2a3b8SJeff Kirsher pr_info("%s\n", ice_driver_string); 4835837f08fdSAnirudh Venkataramanan pr_info("%s\n", ice_copyright); 4836837f08fdSAnirudh Venkataramanan 48370f9d5027SAnirudh Venkataramanan ice_wq = alloc_workqueue("%s", WQ_MEM_RECLAIM, 0, KBUILD_MODNAME); 4838940b61afSAnirudh Venkataramanan if (!ice_wq) { 4839940b61afSAnirudh Venkataramanan pr_err("Failed to create workqueue\n"); 4840940b61afSAnirudh Venkataramanan return -ENOMEM; 4841940b61afSAnirudh Venkataramanan } 4842940b61afSAnirudh Venkataramanan 4843837f08fdSAnirudh Venkataramanan status = pci_register_driver(&ice_driver); 4844940b61afSAnirudh Venkataramanan if (status) { 48452f2da36eSAnirudh Venkataramanan pr_err("failed to register PCI driver, err %d\n", status); 4846940b61afSAnirudh Venkataramanan destroy_workqueue(ice_wq); 4847940b61afSAnirudh Venkataramanan } 4848837f08fdSAnirudh Venkataramanan 4849837f08fdSAnirudh Venkataramanan return status; 4850837f08fdSAnirudh Venkataramanan } 4851837f08fdSAnirudh Venkataramanan module_init(ice_module_init); 4852837f08fdSAnirudh Venkataramanan 4853837f08fdSAnirudh Venkataramanan /** 4854837f08fdSAnirudh Venkataramanan * ice_module_exit - Driver exit cleanup routine 4855837f08fdSAnirudh Venkataramanan * 4856837f08fdSAnirudh Venkataramanan * ice_module_exit is called just before the driver is removed 4857837f08fdSAnirudh Venkataramanan * from memory. 4858837f08fdSAnirudh Venkataramanan */ 4859837f08fdSAnirudh Venkataramanan static void __exit ice_module_exit(void) 4860837f08fdSAnirudh Venkataramanan { 4861837f08fdSAnirudh Venkataramanan pci_unregister_driver(&ice_driver); 4862940b61afSAnirudh Venkataramanan destroy_workqueue(ice_wq); 4863837f08fdSAnirudh Venkataramanan pr_info("module unloaded\n"); 4864837f08fdSAnirudh Venkataramanan } 4865837f08fdSAnirudh Venkataramanan module_exit(ice_module_exit); 48663a858ba3SAnirudh Venkataramanan 48673a858ba3SAnirudh Venkataramanan /** 4868f9867df6SAnirudh Venkataramanan * ice_set_mac_address - NDO callback to set MAC address 4869e94d4478SAnirudh Venkataramanan * @netdev: network interface device structure 4870e94d4478SAnirudh Venkataramanan * @pi: pointer to an address structure 4871e94d4478SAnirudh Venkataramanan * 4872e94d4478SAnirudh Venkataramanan * Returns 0 on success, negative on failure 4873e94d4478SAnirudh Venkataramanan */ 4874e94d4478SAnirudh Venkataramanan static int ice_set_mac_address(struct net_device *netdev, void *pi) 4875e94d4478SAnirudh Venkataramanan { 4876e94d4478SAnirudh Venkataramanan struct ice_netdev_priv *np = netdev_priv(netdev); 4877e94d4478SAnirudh Venkataramanan struct ice_vsi *vsi = np->vsi; 4878e94d4478SAnirudh Venkataramanan struct ice_pf *pf = vsi->back; 4879e94d4478SAnirudh Venkataramanan struct ice_hw *hw = &pf->hw; 4880e94d4478SAnirudh Venkataramanan struct sockaddr *addr = pi; 4881e94d4478SAnirudh Venkataramanan enum ice_status status; 4882e94d4478SAnirudh Venkataramanan u8 flags = 0; 4883bbb968e8SAkeem G Abodunrin int err = 0; 4884e94d4478SAnirudh Venkataramanan u8 *mac; 4885e94d4478SAnirudh Venkataramanan 4886e94d4478SAnirudh Venkataramanan mac = (u8 *)addr->sa_data; 4887e94d4478SAnirudh Venkataramanan 4888e94d4478SAnirudh Venkataramanan if (!is_valid_ether_addr(mac)) 4889e94d4478SAnirudh Venkataramanan return -EADDRNOTAVAIL; 4890e94d4478SAnirudh Venkataramanan 4891e94d4478SAnirudh Venkataramanan if (ether_addr_equal(netdev->dev_addr, mac)) { 4892e94d4478SAnirudh Venkataramanan netdev_warn(netdev, "already using mac %pM\n", mac); 4893e94d4478SAnirudh Venkataramanan return 0; 4894e94d4478SAnirudh Venkataramanan } 4895e94d4478SAnirudh Venkataramanan 48967e408e07SAnirudh Venkataramanan if (test_bit(ICE_DOWN, pf->state) || 48975df7e45dSDave Ertman ice_is_reset_in_progress(pf->state)) { 4898e94d4478SAnirudh Venkataramanan netdev_err(netdev, "can't set mac %pM. device not ready\n", 4899e94d4478SAnirudh Venkataramanan mac); 4900e94d4478SAnirudh Venkataramanan return -EBUSY; 4901e94d4478SAnirudh Venkataramanan } 4902e94d4478SAnirudh Venkataramanan 4903757976abSLihong Yang /* Clean up old MAC filter. Not an error if old filter doesn't exist */ 49041b8f15b6SMichal Swiatkowski status = ice_fltr_remove_mac(vsi, netdev->dev_addr, ICE_FWD_TO_VSI); 4905757976abSLihong Yang if (status && status != ICE_ERR_DOES_NOT_EXIST) { 4906e94d4478SAnirudh Venkataramanan err = -EADDRNOTAVAIL; 4907bbb968e8SAkeem G Abodunrin goto err_update_filters; 4908e94d4478SAnirudh Venkataramanan } 4909e94d4478SAnirudh Venkataramanan 491013ed5e8aSNick Nunley /* Add filter for new MAC. If filter exists, return success */ 49111b8f15b6SMichal Swiatkowski status = ice_fltr_add_mac(vsi, mac, ICE_FWD_TO_VSI); 4912757976abSLihong Yang if (status == ICE_ERR_ALREADY_EXISTS) { 491313ed5e8aSNick Nunley /* Although this MAC filter is already present in hardware it's 491413ed5e8aSNick Nunley * possible in some cases (e.g. bonding) that dev_addr was 491513ed5e8aSNick Nunley * modified outside of the driver and needs to be restored back 491613ed5e8aSNick Nunley * to this value. 491713ed5e8aSNick Nunley */ 491813ed5e8aSNick Nunley memcpy(netdev->dev_addr, mac, netdev->addr_len); 4919757976abSLihong Yang netdev_dbg(netdev, "filter for MAC %pM already exists\n", mac); 4920757976abSLihong Yang return 0; 4921e94d4478SAnirudh Venkataramanan } 4922e94d4478SAnirudh Venkataramanan 4923757976abSLihong Yang /* error if the new filter addition failed */ 4924757976abSLihong Yang if (status) 4925757976abSLihong Yang err = -EADDRNOTAVAIL; 4926757976abSLihong Yang 4927bbb968e8SAkeem G Abodunrin err_update_filters: 4928e94d4478SAnirudh Venkataramanan if (err) { 49292f2da36eSAnirudh Venkataramanan netdev_err(netdev, "can't set MAC %pM. filter update failed\n", 4930e94d4478SAnirudh Venkataramanan mac); 4931e94d4478SAnirudh Venkataramanan return err; 4932e94d4478SAnirudh Venkataramanan } 4933e94d4478SAnirudh Venkataramanan 4934f9867df6SAnirudh Venkataramanan /* change the netdev's MAC address */ 4935e94d4478SAnirudh Venkataramanan memcpy(netdev->dev_addr, mac, netdev->addr_len); 49362f2da36eSAnirudh Venkataramanan netdev_dbg(vsi->netdev, "updated MAC address to %pM\n", 4937e94d4478SAnirudh Venkataramanan netdev->dev_addr); 4938e94d4478SAnirudh Venkataramanan 4939f9867df6SAnirudh Venkataramanan /* write new MAC address to the firmware */ 4940e94d4478SAnirudh Venkataramanan flags = ICE_AQC_MAN_MAC_UPDATE_LAA_WOL; 4941e94d4478SAnirudh Venkataramanan status = ice_aq_manage_mac_write(hw, mac, flags, NULL); 4942e94d4478SAnirudh Venkataramanan if (status) { 49430fee3577SLihong Yang netdev_err(netdev, "can't set MAC %pM. write to firmware failed error %s\n", 49440fee3577SLihong Yang mac, ice_stat_str(status)); 4945e94d4478SAnirudh Venkataramanan } 4946e94d4478SAnirudh Venkataramanan return 0; 4947e94d4478SAnirudh Venkataramanan } 4948e94d4478SAnirudh Venkataramanan 4949e94d4478SAnirudh Venkataramanan /** 4950e94d4478SAnirudh Venkataramanan * ice_set_rx_mode - NDO callback to set the netdev filters 4951e94d4478SAnirudh Venkataramanan * @netdev: network interface device structure 4952e94d4478SAnirudh Venkataramanan */ 4953e94d4478SAnirudh Venkataramanan static void ice_set_rx_mode(struct net_device *netdev) 4954e94d4478SAnirudh Venkataramanan { 4955e94d4478SAnirudh Venkataramanan struct ice_netdev_priv *np = netdev_priv(netdev); 4956e94d4478SAnirudh Venkataramanan struct ice_vsi *vsi = np->vsi; 4957e94d4478SAnirudh Venkataramanan 4958e94d4478SAnirudh Venkataramanan if (!vsi) 4959e94d4478SAnirudh Venkataramanan return; 4960e94d4478SAnirudh Venkataramanan 4961e94d4478SAnirudh Venkataramanan /* Set the flags to synchronize filters 4962e94d4478SAnirudh Venkataramanan * ndo_set_rx_mode may be triggered even without a change in netdev 4963e94d4478SAnirudh Venkataramanan * flags 4964e94d4478SAnirudh Venkataramanan */ 4965e97fb1aeSAnirudh Venkataramanan set_bit(ICE_VSI_UMAC_FLTR_CHANGED, vsi->state); 4966e97fb1aeSAnirudh Venkataramanan set_bit(ICE_VSI_MMAC_FLTR_CHANGED, vsi->state); 4967e94d4478SAnirudh Venkataramanan set_bit(ICE_FLAG_FLTR_SYNC, vsi->back->flags); 4968e94d4478SAnirudh Venkataramanan 4969e94d4478SAnirudh Venkataramanan /* schedule our worker thread which will take care of 4970e94d4478SAnirudh Venkataramanan * applying the new filter changes 4971e94d4478SAnirudh Venkataramanan */ 4972e94d4478SAnirudh Venkataramanan ice_service_task_schedule(vsi->back); 4973e94d4478SAnirudh Venkataramanan } 4974e94d4478SAnirudh Venkataramanan 4975e94d4478SAnirudh Venkataramanan /** 49761ddef455SUsha Ketineni * ice_set_tx_maxrate - NDO callback to set the maximum per-queue bitrate 49771ddef455SUsha Ketineni * @netdev: network interface device structure 49781ddef455SUsha Ketineni * @queue_index: Queue ID 49791ddef455SUsha Ketineni * @maxrate: maximum bandwidth in Mbps 49801ddef455SUsha Ketineni */ 49811ddef455SUsha Ketineni static int 49821ddef455SUsha Ketineni ice_set_tx_maxrate(struct net_device *netdev, int queue_index, u32 maxrate) 49831ddef455SUsha Ketineni { 49841ddef455SUsha Ketineni struct ice_netdev_priv *np = netdev_priv(netdev); 49851ddef455SUsha Ketineni struct ice_vsi *vsi = np->vsi; 49861ddef455SUsha Ketineni enum ice_status status; 49871ddef455SUsha Ketineni u16 q_handle; 49881ddef455SUsha Ketineni u8 tc; 49891ddef455SUsha Ketineni 49901ddef455SUsha Ketineni /* Validate maxrate requested is within permitted range */ 49911ddef455SUsha Ketineni if (maxrate && (maxrate > (ICE_SCHED_MAX_BW / 1000))) { 499219cce2c6SAnirudh Venkataramanan netdev_err(netdev, "Invalid max rate %d specified for the queue %d\n", 49931ddef455SUsha Ketineni maxrate, queue_index); 49941ddef455SUsha Ketineni return -EINVAL; 49951ddef455SUsha Ketineni } 49961ddef455SUsha Ketineni 49971ddef455SUsha Ketineni q_handle = vsi->tx_rings[queue_index]->q_handle; 49981ddef455SUsha Ketineni tc = ice_dcb_get_tc(vsi, queue_index); 49991ddef455SUsha Ketineni 50001ddef455SUsha Ketineni /* Set BW back to default, when user set maxrate to 0 */ 50011ddef455SUsha Ketineni if (!maxrate) 50021ddef455SUsha Ketineni status = ice_cfg_q_bw_dflt_lmt(vsi->port_info, vsi->idx, tc, 50031ddef455SUsha Ketineni q_handle, ICE_MAX_BW); 50041ddef455SUsha Ketineni else 50051ddef455SUsha Ketineni status = ice_cfg_q_bw_lmt(vsi->port_info, vsi->idx, tc, 50061ddef455SUsha Ketineni q_handle, ICE_MAX_BW, maxrate * 1000); 50071ddef455SUsha Ketineni if (status) { 50080fee3577SLihong Yang netdev_err(netdev, "Unable to set Tx max rate, error %s\n", 50090fee3577SLihong Yang ice_stat_str(status)); 50101ddef455SUsha Ketineni return -EIO; 50111ddef455SUsha Ketineni } 50121ddef455SUsha Ketineni 50131ddef455SUsha Ketineni return 0; 50141ddef455SUsha Ketineni } 50151ddef455SUsha Ketineni 50161ddef455SUsha Ketineni /** 5017e94d4478SAnirudh Venkataramanan * ice_fdb_add - add an entry to the hardware database 5018e94d4478SAnirudh Venkataramanan * @ndm: the input from the stack 5019e94d4478SAnirudh Venkataramanan * @tb: pointer to array of nladdr (unused) 5020e94d4478SAnirudh Venkataramanan * @dev: the net device pointer 5021e94d4478SAnirudh Venkataramanan * @addr: the MAC address entry being added 5022f9867df6SAnirudh Venkataramanan * @vid: VLAN ID 5023e94d4478SAnirudh Venkataramanan * @flags: instructions from stack about fdb operation 502499be37edSBruce Allan * @extack: netlink extended ack 5025e94d4478SAnirudh Venkataramanan */ 502699be37edSBruce Allan static int 502799be37edSBruce Allan ice_fdb_add(struct ndmsg *ndm, struct nlattr __always_unused *tb[], 502899be37edSBruce Allan struct net_device *dev, const unsigned char *addr, u16 vid, 502999be37edSBruce Allan u16 flags, struct netlink_ext_ack __always_unused *extack) 5030e94d4478SAnirudh Venkataramanan { 5031e94d4478SAnirudh Venkataramanan int err; 5032e94d4478SAnirudh Venkataramanan 5033e94d4478SAnirudh Venkataramanan if (vid) { 5034e94d4478SAnirudh Venkataramanan netdev_err(dev, "VLANs aren't supported yet for dev_uc|mc_add()\n"); 5035e94d4478SAnirudh Venkataramanan return -EINVAL; 5036e94d4478SAnirudh Venkataramanan } 5037e94d4478SAnirudh Venkataramanan if (ndm->ndm_state && !(ndm->ndm_state & NUD_PERMANENT)) { 5038e94d4478SAnirudh Venkataramanan netdev_err(dev, "FDB only supports static addresses\n"); 5039e94d4478SAnirudh Venkataramanan return -EINVAL; 5040e94d4478SAnirudh Venkataramanan } 5041e94d4478SAnirudh Venkataramanan 5042e94d4478SAnirudh Venkataramanan if (is_unicast_ether_addr(addr) || is_link_local_ether_addr(addr)) 5043e94d4478SAnirudh Venkataramanan err = dev_uc_add_excl(dev, addr); 5044e94d4478SAnirudh Venkataramanan else if (is_multicast_ether_addr(addr)) 5045e94d4478SAnirudh Venkataramanan err = dev_mc_add_excl(dev, addr); 5046e94d4478SAnirudh Venkataramanan else 5047e94d4478SAnirudh Venkataramanan err = -EINVAL; 5048e94d4478SAnirudh Venkataramanan 5049e94d4478SAnirudh Venkataramanan /* Only return duplicate errors if NLM_F_EXCL is set */ 5050e94d4478SAnirudh Venkataramanan if (err == -EEXIST && !(flags & NLM_F_EXCL)) 5051e94d4478SAnirudh Venkataramanan err = 0; 5052e94d4478SAnirudh Venkataramanan 5053e94d4478SAnirudh Venkataramanan return err; 5054e94d4478SAnirudh Venkataramanan } 5055e94d4478SAnirudh Venkataramanan 5056e94d4478SAnirudh Venkataramanan /** 5057e94d4478SAnirudh Venkataramanan * ice_fdb_del - delete an entry from the hardware database 5058e94d4478SAnirudh Venkataramanan * @ndm: the input from the stack 5059e94d4478SAnirudh Venkataramanan * @tb: pointer to array of nladdr (unused) 5060e94d4478SAnirudh Venkataramanan * @dev: the net device pointer 5061e94d4478SAnirudh Venkataramanan * @addr: the MAC address entry being added 5062f9867df6SAnirudh Venkataramanan * @vid: VLAN ID 5063e94d4478SAnirudh Venkataramanan */ 5064c8b7abddSBruce Allan static int 5065c8b7abddSBruce Allan ice_fdb_del(struct ndmsg *ndm, __always_unused struct nlattr *tb[], 5066e94d4478SAnirudh Venkataramanan struct net_device *dev, const unsigned char *addr, 5067e94d4478SAnirudh Venkataramanan __always_unused u16 vid) 5068e94d4478SAnirudh Venkataramanan { 5069e94d4478SAnirudh Venkataramanan int err; 5070e94d4478SAnirudh Venkataramanan 5071e94d4478SAnirudh Venkataramanan if (ndm->ndm_state & NUD_PERMANENT) { 5072e94d4478SAnirudh Venkataramanan netdev_err(dev, "FDB only supports static addresses\n"); 5073e94d4478SAnirudh Venkataramanan return -EINVAL; 5074e94d4478SAnirudh Venkataramanan } 5075e94d4478SAnirudh Venkataramanan 5076e94d4478SAnirudh Venkataramanan if (is_unicast_ether_addr(addr)) 5077e94d4478SAnirudh Venkataramanan err = dev_uc_del(dev, addr); 5078e94d4478SAnirudh Venkataramanan else if (is_multicast_ether_addr(addr)) 5079e94d4478SAnirudh Venkataramanan err = dev_mc_del(dev, addr); 5080e94d4478SAnirudh Venkataramanan else 5081e94d4478SAnirudh Venkataramanan err = -EINVAL; 5082e94d4478SAnirudh Venkataramanan 5083e94d4478SAnirudh Venkataramanan return err; 5084e94d4478SAnirudh Venkataramanan } 5085e94d4478SAnirudh Venkataramanan 5086e94d4478SAnirudh Venkataramanan /** 5087d76a60baSAnirudh Venkataramanan * ice_set_features - set the netdev feature flags 5088d76a60baSAnirudh Venkataramanan * @netdev: ptr to the netdev being adjusted 5089d76a60baSAnirudh Venkataramanan * @features: the feature set that the stack is suggesting 5090d76a60baSAnirudh Venkataramanan */ 5091c8b7abddSBruce Allan static int 5092c8b7abddSBruce Allan ice_set_features(struct net_device *netdev, netdev_features_t features) 5093d76a60baSAnirudh Venkataramanan { 5094d76a60baSAnirudh Venkataramanan struct ice_netdev_priv *np = netdev_priv(netdev); 5095d76a60baSAnirudh Venkataramanan struct ice_vsi *vsi = np->vsi; 50965f8cc355SHenry Tieman struct ice_pf *pf = vsi->back; 5097d76a60baSAnirudh Venkataramanan int ret = 0; 5098d76a60baSAnirudh Venkataramanan 5099462acf6aSTony Nguyen /* Don't set any netdev advanced features with device in Safe Mode */ 5100462acf6aSTony Nguyen if (ice_is_safe_mode(vsi->back)) { 510119cce2c6SAnirudh Venkataramanan dev_err(ice_pf_to_dev(vsi->back), "Device is in Safe Mode - not enabling advanced netdev features\n"); 5102462acf6aSTony Nguyen return ret; 5103462acf6aSTony Nguyen } 5104462acf6aSTony Nguyen 51055f8cc355SHenry Tieman /* Do not change setting during reset */ 51065f8cc355SHenry Tieman if (ice_is_reset_in_progress(pf->state)) { 510719cce2c6SAnirudh Venkataramanan dev_err(ice_pf_to_dev(vsi->back), "Device is resetting, changing advanced netdev features temporarily unavailable.\n"); 51085f8cc355SHenry Tieman return -EBUSY; 51095f8cc355SHenry Tieman } 51105f8cc355SHenry Tieman 51118f529ff9STony Nguyen /* Multiple features can be changed in one call so keep features in 51128f529ff9STony Nguyen * separate if/else statements to guarantee each feature is checked 51138f529ff9STony Nguyen */ 5114492af0abSMd Fahad Iqbal Polash if (features & NETIF_F_RXHASH && !(netdev->features & NETIF_F_RXHASH)) 5115*4fe36226SPaul M Stillwell Jr ice_vsi_manage_rss_lut(vsi, true); 5116492af0abSMd Fahad Iqbal Polash else if (!(features & NETIF_F_RXHASH) && 5117492af0abSMd Fahad Iqbal Polash netdev->features & NETIF_F_RXHASH) 5118*4fe36226SPaul M Stillwell Jr ice_vsi_manage_rss_lut(vsi, false); 5119492af0abSMd Fahad Iqbal Polash 5120d76a60baSAnirudh Venkataramanan if ((features & NETIF_F_HW_VLAN_CTAG_RX) && 5121d76a60baSAnirudh Venkataramanan !(netdev->features & NETIF_F_HW_VLAN_CTAG_RX)) 5122d76a60baSAnirudh Venkataramanan ret = ice_vsi_manage_vlan_stripping(vsi, true); 5123d76a60baSAnirudh Venkataramanan else if (!(features & NETIF_F_HW_VLAN_CTAG_RX) && 5124d76a60baSAnirudh Venkataramanan (netdev->features & NETIF_F_HW_VLAN_CTAG_RX)) 5125d76a60baSAnirudh Venkataramanan ret = ice_vsi_manage_vlan_stripping(vsi, false); 51268f529ff9STony Nguyen 51278f529ff9STony Nguyen if ((features & NETIF_F_HW_VLAN_CTAG_TX) && 5128d76a60baSAnirudh Venkataramanan !(netdev->features & NETIF_F_HW_VLAN_CTAG_TX)) 5129d76a60baSAnirudh Venkataramanan ret = ice_vsi_manage_vlan_insertion(vsi); 5130d76a60baSAnirudh Venkataramanan else if (!(features & NETIF_F_HW_VLAN_CTAG_TX) && 5131d76a60baSAnirudh Venkataramanan (netdev->features & NETIF_F_HW_VLAN_CTAG_TX)) 5132d76a60baSAnirudh Venkataramanan ret = ice_vsi_manage_vlan_insertion(vsi); 5133d76a60baSAnirudh Venkataramanan 51343171948eSTony Nguyen if ((features & NETIF_F_HW_VLAN_CTAG_FILTER) && 51353171948eSTony Nguyen !(netdev->features & NETIF_F_HW_VLAN_CTAG_FILTER)) 51363171948eSTony Nguyen ret = ice_cfg_vlan_pruning(vsi, true, false); 51373171948eSTony Nguyen else if (!(features & NETIF_F_HW_VLAN_CTAG_FILTER) && 51383171948eSTony Nguyen (netdev->features & NETIF_F_HW_VLAN_CTAG_FILTER)) 51393171948eSTony Nguyen ret = ice_cfg_vlan_pruning(vsi, false, false); 51403171948eSTony Nguyen 5141148beb61SHenry Tieman if ((features & NETIF_F_NTUPLE) && 514228bf2672SBrett Creeley !(netdev->features & NETIF_F_NTUPLE)) { 5143148beb61SHenry Tieman ice_vsi_manage_fdir(vsi, true); 514428bf2672SBrett Creeley ice_init_arfs(vsi); 514528bf2672SBrett Creeley } else if (!(features & NETIF_F_NTUPLE) && 514628bf2672SBrett Creeley (netdev->features & NETIF_F_NTUPLE)) { 5147148beb61SHenry Tieman ice_vsi_manage_fdir(vsi, false); 514828bf2672SBrett Creeley ice_clear_arfs(vsi); 514928bf2672SBrett Creeley } 5150148beb61SHenry Tieman 5151d76a60baSAnirudh Venkataramanan return ret; 5152d76a60baSAnirudh Venkataramanan } 5153d76a60baSAnirudh Venkataramanan 5154d76a60baSAnirudh Venkataramanan /** 5155f9867df6SAnirudh Venkataramanan * ice_vsi_vlan_setup - Setup VLAN offload properties on a VSI 5156f9867df6SAnirudh Venkataramanan * @vsi: VSI to setup VLAN properties for 5157d76a60baSAnirudh Venkataramanan */ 5158d76a60baSAnirudh Venkataramanan static int ice_vsi_vlan_setup(struct ice_vsi *vsi) 5159d76a60baSAnirudh Venkataramanan { 5160d76a60baSAnirudh Venkataramanan int ret = 0; 5161d76a60baSAnirudh Venkataramanan 5162d76a60baSAnirudh Venkataramanan if (vsi->netdev->features & NETIF_F_HW_VLAN_CTAG_RX) 5163d76a60baSAnirudh Venkataramanan ret = ice_vsi_manage_vlan_stripping(vsi, true); 5164d76a60baSAnirudh Venkataramanan if (vsi->netdev->features & NETIF_F_HW_VLAN_CTAG_TX) 5165d76a60baSAnirudh Venkataramanan ret = ice_vsi_manage_vlan_insertion(vsi); 5166d76a60baSAnirudh Venkataramanan 5167d76a60baSAnirudh Venkataramanan return ret; 5168d76a60baSAnirudh Venkataramanan } 5169d76a60baSAnirudh Venkataramanan 5170d76a60baSAnirudh Venkataramanan /** 5171cdedef59SAnirudh Venkataramanan * ice_vsi_cfg - Setup the VSI 5172cdedef59SAnirudh Venkataramanan * @vsi: the VSI being configured 5173cdedef59SAnirudh Venkataramanan * 5174cdedef59SAnirudh Venkataramanan * Return 0 on success and negative value on error 5175cdedef59SAnirudh Venkataramanan */ 51760e674aebSAnirudh Venkataramanan int ice_vsi_cfg(struct ice_vsi *vsi) 5177cdedef59SAnirudh Venkataramanan { 5178cdedef59SAnirudh Venkataramanan int err; 5179cdedef59SAnirudh Venkataramanan 5180c7f2c42bSAnirudh Venkataramanan if (vsi->netdev) { 5181e94d4478SAnirudh Venkataramanan ice_set_rx_mode(vsi->netdev); 51829ecd25c2SAnirudh Venkataramanan 51839ecd25c2SAnirudh Venkataramanan err = ice_vsi_vlan_setup(vsi); 51849ecd25c2SAnirudh Venkataramanan 5185d76a60baSAnirudh Venkataramanan if (err) 5186d76a60baSAnirudh Venkataramanan return err; 5187c7f2c42bSAnirudh Venkataramanan } 5188a629cf0aSAnirudh Venkataramanan ice_vsi_cfg_dcb_rings(vsi); 518903f7a986SAnirudh Venkataramanan 519003f7a986SAnirudh Venkataramanan err = ice_vsi_cfg_lan_txqs(vsi); 5191efc2214bSMaciej Fijalkowski if (!err && ice_is_xdp_ena_vsi(vsi)) 5192efc2214bSMaciej Fijalkowski err = ice_vsi_cfg_xdp_txqs(vsi); 5193cdedef59SAnirudh Venkataramanan if (!err) 5194cdedef59SAnirudh Venkataramanan err = ice_vsi_cfg_rxqs(vsi); 5195cdedef59SAnirudh Venkataramanan 5196cdedef59SAnirudh Venkataramanan return err; 5197cdedef59SAnirudh Venkataramanan } 5198cdedef59SAnirudh Venkataramanan 5199cdf1f1f1SJacob Keller /* THEORY OF MODERATION: 5200cdf1f1f1SJacob Keller * The below code creates custom DIM profiles for use by this driver, because 5201cdf1f1f1SJacob Keller * the ice driver hardware works differently than the hardware that DIMLIB was 5202cdf1f1f1SJacob Keller * originally made for. ice hardware doesn't have packet count limits that 5203cdf1f1f1SJacob Keller * can trigger an interrupt, but it *does* have interrupt rate limit support, 5204cdf1f1f1SJacob Keller * and this code adds that capability to be used by the driver when it's using 5205cdf1f1f1SJacob Keller * DIMLIB. The DIMLIB code was always designed to be a suggestion to the driver 5206cdf1f1f1SJacob Keller * for how to "respond" to traffic and interrupts, so this driver uses a 5207cdf1f1f1SJacob Keller * slightly different set of moderation parameters to get best performance. 5208cdf1f1f1SJacob Keller */ 5209cdf1f1f1SJacob Keller struct ice_dim { 5210cdf1f1f1SJacob Keller /* the throttle rate for interrupts, basically worst case delay before 5211cdf1f1f1SJacob Keller * an initial interrupt fires, value is stored in microseconds. 5212cdf1f1f1SJacob Keller */ 5213cdf1f1f1SJacob Keller u16 itr; 5214cdf1f1f1SJacob Keller /* the rate limit for interrupts, which can cap a delay from a small 5215cdf1f1f1SJacob Keller * ITR at a certain amount of interrupts per second. f.e. a 2us ITR 5216cdf1f1f1SJacob Keller * could yield as much as 500,000 interrupts per second, but with a 5217cdf1f1f1SJacob Keller * 10us rate limit, it limits to 100,000 interrupts per second. Value 5218cdf1f1f1SJacob Keller * is stored in microseconds. 5219cdf1f1f1SJacob Keller */ 5220cdf1f1f1SJacob Keller u16 intrl; 5221cdf1f1f1SJacob Keller }; 5222cdf1f1f1SJacob Keller 5223cdf1f1f1SJacob Keller /* Make a different profile for Rx that doesn't allow quite so aggressive 5224cdf1f1f1SJacob Keller * moderation at the high end (it maxes out at 128us or about 8k interrupts a 5225cdf1f1f1SJacob Keller * second. The INTRL/rate parameters here are only useful to cap small ITR 5226cdf1f1f1SJacob Keller * values, which is why for larger ITR's - like 128, which can only generate 5227cdf1f1f1SJacob Keller * 8k interrupts per second, there is no point to rate limit and the values 5228cdf1f1f1SJacob Keller * are set to zero. The rate limit values do affect latency, and so must 5229cdf1f1f1SJacob Keller * be reasonably small so to not impact latency sensitive tests. 5230cdf1f1f1SJacob Keller */ 5231cdf1f1f1SJacob Keller static const struct ice_dim rx_profile[] = { 5232cdf1f1f1SJacob Keller {2, 10}, 5233cdf1f1f1SJacob Keller {8, 16}, 5234cdf1f1f1SJacob Keller {32, 0}, 5235cdf1f1f1SJacob Keller {96, 0}, 5236cdf1f1f1SJacob Keller {128, 0} 5237cdf1f1f1SJacob Keller }; 5238cdf1f1f1SJacob Keller 5239cdf1f1f1SJacob Keller /* The transmit profile, which has the same sorts of values 5240cdf1f1f1SJacob Keller * as the previous struct 5241cdf1f1f1SJacob Keller */ 5242cdf1f1f1SJacob Keller static const struct ice_dim tx_profile[] = { 5243cdf1f1f1SJacob Keller {2, 10}, 5244cdf1f1f1SJacob Keller {8, 16}, 5245cdf1f1f1SJacob Keller {64, 0}, 5246cdf1f1f1SJacob Keller {128, 0}, 5247cdf1f1f1SJacob Keller {256, 0} 5248cdf1f1f1SJacob Keller }; 5249cdf1f1f1SJacob Keller 5250cdf1f1f1SJacob Keller static void ice_tx_dim_work(struct work_struct *work) 5251cdf1f1f1SJacob Keller { 5252cdf1f1f1SJacob Keller struct ice_ring_container *rc; 5253cdf1f1f1SJacob Keller struct ice_q_vector *q_vector; 5254cdf1f1f1SJacob Keller struct dim *dim; 5255cdf1f1f1SJacob Keller u16 itr, intrl; 5256cdf1f1f1SJacob Keller 5257cdf1f1f1SJacob Keller dim = container_of(work, struct dim, work); 5258cdf1f1f1SJacob Keller rc = container_of(dim, struct ice_ring_container, dim); 5259cdf1f1f1SJacob Keller q_vector = container_of(rc, struct ice_q_vector, tx); 5260cdf1f1f1SJacob Keller 5261cdf1f1f1SJacob Keller if (dim->profile_ix >= ARRAY_SIZE(tx_profile)) 5262cdf1f1f1SJacob Keller dim->profile_ix = ARRAY_SIZE(tx_profile) - 1; 5263cdf1f1f1SJacob Keller 5264cdf1f1f1SJacob Keller /* look up the values in our local table */ 5265cdf1f1f1SJacob Keller itr = tx_profile[dim->profile_ix].itr; 5266cdf1f1f1SJacob Keller intrl = tx_profile[dim->profile_ix].intrl; 5267cdf1f1f1SJacob Keller 5268cdf1f1f1SJacob Keller ice_write_itr(rc, itr); 5269cdf1f1f1SJacob Keller ice_write_intrl(q_vector, intrl); 5270cdf1f1f1SJacob Keller 5271cdf1f1f1SJacob Keller dim->state = DIM_START_MEASURE; 5272cdf1f1f1SJacob Keller } 5273cdf1f1f1SJacob Keller 5274cdf1f1f1SJacob Keller static void ice_rx_dim_work(struct work_struct *work) 5275cdf1f1f1SJacob Keller { 5276cdf1f1f1SJacob Keller struct ice_ring_container *rc; 5277cdf1f1f1SJacob Keller struct ice_q_vector *q_vector; 5278cdf1f1f1SJacob Keller struct dim *dim; 5279cdf1f1f1SJacob Keller u16 itr, intrl; 5280cdf1f1f1SJacob Keller 5281cdf1f1f1SJacob Keller dim = container_of(work, struct dim, work); 5282cdf1f1f1SJacob Keller rc = container_of(dim, struct ice_ring_container, dim); 5283cdf1f1f1SJacob Keller q_vector = container_of(rc, struct ice_q_vector, rx); 5284cdf1f1f1SJacob Keller 5285cdf1f1f1SJacob Keller if (dim->profile_ix >= ARRAY_SIZE(rx_profile)) 5286cdf1f1f1SJacob Keller dim->profile_ix = ARRAY_SIZE(rx_profile) - 1; 5287cdf1f1f1SJacob Keller 5288cdf1f1f1SJacob Keller /* look up the values in our local table */ 5289cdf1f1f1SJacob Keller itr = rx_profile[dim->profile_ix].itr; 5290cdf1f1f1SJacob Keller intrl = rx_profile[dim->profile_ix].intrl; 5291cdf1f1f1SJacob Keller 5292cdf1f1f1SJacob Keller ice_write_itr(rc, itr); 5293cdf1f1f1SJacob Keller ice_write_intrl(q_vector, intrl); 5294cdf1f1f1SJacob Keller 5295cdf1f1f1SJacob Keller dim->state = DIM_START_MEASURE; 5296cdf1f1f1SJacob Keller } 5297cdf1f1f1SJacob Keller 5298cdedef59SAnirudh Venkataramanan /** 52992b245cb2SAnirudh Venkataramanan * ice_napi_enable_all - Enable NAPI for all q_vectors in the VSI 53002b245cb2SAnirudh Venkataramanan * @vsi: the VSI being configured 53012b245cb2SAnirudh Venkataramanan */ 53022b245cb2SAnirudh Venkataramanan static void ice_napi_enable_all(struct ice_vsi *vsi) 53032b245cb2SAnirudh Venkataramanan { 53042b245cb2SAnirudh Venkataramanan int q_idx; 53052b245cb2SAnirudh Venkataramanan 53062b245cb2SAnirudh Venkataramanan if (!vsi->netdev) 53072b245cb2SAnirudh Venkataramanan return; 53082b245cb2SAnirudh Venkataramanan 53090c2561c8SBrett Creeley ice_for_each_q_vector(vsi, q_idx) { 5310eec90376SYoung Xiao struct ice_q_vector *q_vector = vsi->q_vectors[q_idx]; 5311eec90376SYoung Xiao 5312cdf1f1f1SJacob Keller INIT_WORK(&q_vector->tx.dim.work, ice_tx_dim_work); 5313cdf1f1f1SJacob Keller q_vector->tx.dim.mode = DIM_CQ_PERIOD_MODE_START_FROM_EQE; 5314cdf1f1f1SJacob Keller 5315cdf1f1f1SJacob Keller INIT_WORK(&q_vector->rx.dim.work, ice_rx_dim_work); 5316cdf1f1f1SJacob Keller q_vector->rx.dim.mode = DIM_CQ_PERIOD_MODE_START_FROM_EQE; 5317cdf1f1f1SJacob Keller 5318eec90376SYoung Xiao if (q_vector->rx.ring || q_vector->tx.ring) 5319eec90376SYoung Xiao napi_enable(&q_vector->napi); 5320eec90376SYoung Xiao } 53212b245cb2SAnirudh Venkataramanan } 53222b245cb2SAnirudh Venkataramanan 53232b245cb2SAnirudh Venkataramanan /** 5324cdedef59SAnirudh Venkataramanan * ice_up_complete - Finish the last steps of bringing up a connection 5325cdedef59SAnirudh Venkataramanan * @vsi: The VSI being configured 5326cdedef59SAnirudh Venkataramanan * 5327cdedef59SAnirudh Venkataramanan * Return 0 on success and negative value on error 5328cdedef59SAnirudh Venkataramanan */ 5329cdedef59SAnirudh Venkataramanan static int ice_up_complete(struct ice_vsi *vsi) 5330cdedef59SAnirudh Venkataramanan { 5331cdedef59SAnirudh Venkataramanan struct ice_pf *pf = vsi->back; 5332cdedef59SAnirudh Venkataramanan int err; 5333cdedef59SAnirudh Venkataramanan 5334cdedef59SAnirudh Venkataramanan ice_vsi_cfg_msix(vsi); 5335cdedef59SAnirudh Venkataramanan 5336cdedef59SAnirudh Venkataramanan /* Enable only Rx rings, Tx rings were enabled by the FW when the 5337cdedef59SAnirudh Venkataramanan * Tx queue group list was configured and the context bits were 5338cdedef59SAnirudh Venkataramanan * programmed using ice_vsi_cfg_txqs 5339cdedef59SAnirudh Venkataramanan */ 534013a6233bSBrett Creeley err = ice_vsi_start_all_rx_rings(vsi); 5341cdedef59SAnirudh Venkataramanan if (err) 5342cdedef59SAnirudh Venkataramanan return err; 5343cdedef59SAnirudh Venkataramanan 5344e97fb1aeSAnirudh Venkataramanan clear_bit(ICE_VSI_DOWN, vsi->state); 53452b245cb2SAnirudh Venkataramanan ice_napi_enable_all(vsi); 5346cdedef59SAnirudh Venkataramanan ice_vsi_ena_irq(vsi); 5347cdedef59SAnirudh Venkataramanan 5348cdedef59SAnirudh Venkataramanan if (vsi->port_info && 5349cdedef59SAnirudh Venkataramanan (vsi->port_info->phy.link_info.link_info & ICE_AQ_LINK_UP) && 5350cdedef59SAnirudh Venkataramanan vsi->netdev) { 5351cdedef59SAnirudh Venkataramanan ice_print_link_msg(vsi, true); 5352cdedef59SAnirudh Venkataramanan netif_tx_start_all_queues(vsi->netdev); 5353cdedef59SAnirudh Venkataramanan netif_carrier_on(vsi->netdev); 5354cdedef59SAnirudh Venkataramanan } 5355cdedef59SAnirudh Venkataramanan 5356cdedef59SAnirudh Venkataramanan ice_service_task_schedule(pf); 5357cdedef59SAnirudh Venkataramanan 53581b5c19c7SBruce Allan return 0; 5359cdedef59SAnirudh Venkataramanan } 5360cdedef59SAnirudh Venkataramanan 5361cdedef59SAnirudh Venkataramanan /** 5362fcea6f3dSAnirudh Venkataramanan * ice_up - Bring the connection back up after being down 5363fcea6f3dSAnirudh Venkataramanan * @vsi: VSI being configured 5364fcea6f3dSAnirudh Venkataramanan */ 5365fcea6f3dSAnirudh Venkataramanan int ice_up(struct ice_vsi *vsi) 5366fcea6f3dSAnirudh Venkataramanan { 5367fcea6f3dSAnirudh Venkataramanan int err; 5368fcea6f3dSAnirudh Venkataramanan 5369fcea6f3dSAnirudh Venkataramanan err = ice_vsi_cfg(vsi); 5370fcea6f3dSAnirudh Venkataramanan if (!err) 5371fcea6f3dSAnirudh Venkataramanan err = ice_up_complete(vsi); 5372fcea6f3dSAnirudh Venkataramanan 5373fcea6f3dSAnirudh Venkataramanan return err; 5374fcea6f3dSAnirudh Venkataramanan } 5375fcea6f3dSAnirudh Venkataramanan 5376fcea6f3dSAnirudh Venkataramanan /** 5377fcea6f3dSAnirudh Venkataramanan * ice_fetch_u64_stats_per_ring - get packets and bytes stats per ring 5378fcea6f3dSAnirudh Venkataramanan * @ring: Tx or Rx ring to read stats from 5379fcea6f3dSAnirudh Venkataramanan * @pkts: packets stats counter 5380fcea6f3dSAnirudh Venkataramanan * @bytes: bytes stats counter 5381fcea6f3dSAnirudh Venkataramanan * 5382fcea6f3dSAnirudh Venkataramanan * This function fetches stats from the ring considering the atomic operations 5383fcea6f3dSAnirudh Venkataramanan * that needs to be performed to read u64 values in 32 bit machine. 5384fcea6f3dSAnirudh Venkataramanan */ 5385c8b7abddSBruce Allan static void 5386c8b7abddSBruce Allan ice_fetch_u64_stats_per_ring(struct ice_ring *ring, u64 *pkts, u64 *bytes) 5387fcea6f3dSAnirudh Venkataramanan { 5388fcea6f3dSAnirudh Venkataramanan unsigned int start; 5389fcea6f3dSAnirudh Venkataramanan *pkts = 0; 5390fcea6f3dSAnirudh Venkataramanan *bytes = 0; 5391fcea6f3dSAnirudh Venkataramanan 5392fcea6f3dSAnirudh Venkataramanan if (!ring) 5393fcea6f3dSAnirudh Venkataramanan return; 5394fcea6f3dSAnirudh Venkataramanan do { 5395fcea6f3dSAnirudh Venkataramanan start = u64_stats_fetch_begin_irq(&ring->syncp); 5396fcea6f3dSAnirudh Venkataramanan *pkts = ring->stats.pkts; 5397fcea6f3dSAnirudh Venkataramanan *bytes = ring->stats.bytes; 5398fcea6f3dSAnirudh Venkataramanan } while (u64_stats_fetch_retry_irq(&ring->syncp, start)); 5399fcea6f3dSAnirudh Venkataramanan } 5400fcea6f3dSAnirudh Venkataramanan 5401fcea6f3dSAnirudh Venkataramanan /** 540249d358e0SMarta Plantykow * ice_update_vsi_tx_ring_stats - Update VSI Tx ring stats counters 540349d358e0SMarta Plantykow * @vsi: the VSI to be updated 540449d358e0SMarta Plantykow * @rings: rings to work on 540549d358e0SMarta Plantykow * @count: number of rings 540649d358e0SMarta Plantykow */ 540749d358e0SMarta Plantykow static void 540849d358e0SMarta Plantykow ice_update_vsi_tx_ring_stats(struct ice_vsi *vsi, struct ice_ring **rings, 540949d358e0SMarta Plantykow u16 count) 541049d358e0SMarta Plantykow { 541149d358e0SMarta Plantykow struct rtnl_link_stats64 *vsi_stats = &vsi->net_stats; 541249d358e0SMarta Plantykow u16 i; 541349d358e0SMarta Plantykow 541449d358e0SMarta Plantykow for (i = 0; i < count; i++) { 541549d358e0SMarta Plantykow struct ice_ring *ring; 541649d358e0SMarta Plantykow u64 pkts, bytes; 541749d358e0SMarta Plantykow 541849d358e0SMarta Plantykow ring = READ_ONCE(rings[i]); 541949d358e0SMarta Plantykow ice_fetch_u64_stats_per_ring(ring, &pkts, &bytes); 542049d358e0SMarta Plantykow vsi_stats->tx_packets += pkts; 542149d358e0SMarta Plantykow vsi_stats->tx_bytes += bytes; 542249d358e0SMarta Plantykow vsi->tx_restart += ring->tx_stats.restart_q; 542349d358e0SMarta Plantykow vsi->tx_busy += ring->tx_stats.tx_busy; 542449d358e0SMarta Plantykow vsi->tx_linearize += ring->tx_stats.tx_linearize; 542549d358e0SMarta Plantykow } 542649d358e0SMarta Plantykow } 542749d358e0SMarta Plantykow 542849d358e0SMarta Plantykow /** 5429fcea6f3dSAnirudh Venkataramanan * ice_update_vsi_ring_stats - Update VSI stats counters 5430fcea6f3dSAnirudh Venkataramanan * @vsi: the VSI to be updated 5431fcea6f3dSAnirudh Venkataramanan */ 5432fcea6f3dSAnirudh Venkataramanan static void ice_update_vsi_ring_stats(struct ice_vsi *vsi) 5433fcea6f3dSAnirudh Venkataramanan { 5434fcea6f3dSAnirudh Venkataramanan struct rtnl_link_stats64 *vsi_stats = &vsi->net_stats; 5435fcea6f3dSAnirudh Venkataramanan struct ice_ring *ring; 5436fcea6f3dSAnirudh Venkataramanan u64 pkts, bytes; 5437fcea6f3dSAnirudh Venkataramanan int i; 5438fcea6f3dSAnirudh Venkataramanan 5439fcea6f3dSAnirudh Venkataramanan /* reset netdev stats */ 5440fcea6f3dSAnirudh Venkataramanan vsi_stats->tx_packets = 0; 5441fcea6f3dSAnirudh Venkataramanan vsi_stats->tx_bytes = 0; 5442fcea6f3dSAnirudh Venkataramanan vsi_stats->rx_packets = 0; 5443fcea6f3dSAnirudh Venkataramanan vsi_stats->rx_bytes = 0; 5444fcea6f3dSAnirudh Venkataramanan 5445fcea6f3dSAnirudh Venkataramanan /* reset non-netdev (extended) stats */ 5446fcea6f3dSAnirudh Venkataramanan vsi->tx_restart = 0; 5447fcea6f3dSAnirudh Venkataramanan vsi->tx_busy = 0; 5448fcea6f3dSAnirudh Venkataramanan vsi->tx_linearize = 0; 5449fcea6f3dSAnirudh Venkataramanan vsi->rx_buf_failed = 0; 5450fcea6f3dSAnirudh Venkataramanan vsi->rx_page_failed = 0; 5451fcea6f3dSAnirudh Venkataramanan 5452fcea6f3dSAnirudh Venkataramanan rcu_read_lock(); 5453fcea6f3dSAnirudh Venkataramanan 5454fcea6f3dSAnirudh Venkataramanan /* update Tx rings counters */ 545549d358e0SMarta Plantykow ice_update_vsi_tx_ring_stats(vsi, vsi->tx_rings, vsi->num_txq); 5456fcea6f3dSAnirudh Venkataramanan 5457fcea6f3dSAnirudh Venkataramanan /* update Rx rings counters */ 5458fcea6f3dSAnirudh Venkataramanan ice_for_each_rxq(vsi, i) { 5459fcea6f3dSAnirudh Venkataramanan ring = READ_ONCE(vsi->rx_rings[i]); 5460fcea6f3dSAnirudh Venkataramanan ice_fetch_u64_stats_per_ring(ring, &pkts, &bytes); 5461fcea6f3dSAnirudh Venkataramanan vsi_stats->rx_packets += pkts; 5462fcea6f3dSAnirudh Venkataramanan vsi_stats->rx_bytes += bytes; 5463fcea6f3dSAnirudh Venkataramanan vsi->rx_buf_failed += ring->rx_stats.alloc_buf_failed; 5464fcea6f3dSAnirudh Venkataramanan vsi->rx_page_failed += ring->rx_stats.alloc_page_failed; 5465fcea6f3dSAnirudh Venkataramanan } 5466fcea6f3dSAnirudh Venkataramanan 546749d358e0SMarta Plantykow /* update XDP Tx rings counters */ 546849d358e0SMarta Plantykow if (ice_is_xdp_ena_vsi(vsi)) 546949d358e0SMarta Plantykow ice_update_vsi_tx_ring_stats(vsi, vsi->xdp_rings, 547049d358e0SMarta Plantykow vsi->num_xdp_txq); 547149d358e0SMarta Plantykow 5472fcea6f3dSAnirudh Venkataramanan rcu_read_unlock(); 5473fcea6f3dSAnirudh Venkataramanan } 5474fcea6f3dSAnirudh Venkataramanan 5475fcea6f3dSAnirudh Venkataramanan /** 5476fcea6f3dSAnirudh Venkataramanan * ice_update_vsi_stats - Update VSI stats counters 5477fcea6f3dSAnirudh Venkataramanan * @vsi: the VSI to be updated 5478fcea6f3dSAnirudh Venkataramanan */ 54795a4a8673SBruce Allan void ice_update_vsi_stats(struct ice_vsi *vsi) 5480fcea6f3dSAnirudh Venkataramanan { 5481fcea6f3dSAnirudh Venkataramanan struct rtnl_link_stats64 *cur_ns = &vsi->net_stats; 5482fcea6f3dSAnirudh Venkataramanan struct ice_eth_stats *cur_es = &vsi->eth_stats; 5483fcea6f3dSAnirudh Venkataramanan struct ice_pf *pf = vsi->back; 5484fcea6f3dSAnirudh Venkataramanan 5485e97fb1aeSAnirudh Venkataramanan if (test_bit(ICE_VSI_DOWN, vsi->state) || 54867e408e07SAnirudh Venkataramanan test_bit(ICE_CFG_BUSY, pf->state)) 5487fcea6f3dSAnirudh Venkataramanan return; 5488fcea6f3dSAnirudh Venkataramanan 5489fcea6f3dSAnirudh Venkataramanan /* get stats as recorded by Tx/Rx rings */ 5490fcea6f3dSAnirudh Venkataramanan ice_update_vsi_ring_stats(vsi); 5491fcea6f3dSAnirudh Venkataramanan 5492fcea6f3dSAnirudh Venkataramanan /* get VSI stats as recorded by the hardware */ 5493fcea6f3dSAnirudh Venkataramanan ice_update_eth_stats(vsi); 5494fcea6f3dSAnirudh Venkataramanan 5495fcea6f3dSAnirudh Venkataramanan cur_ns->tx_errors = cur_es->tx_errors; 549651fe27e1SAnirudh Venkataramanan cur_ns->rx_dropped = cur_es->rx_discards; 5497fcea6f3dSAnirudh Venkataramanan cur_ns->tx_dropped = cur_es->tx_discards; 5498fcea6f3dSAnirudh Venkataramanan cur_ns->multicast = cur_es->rx_multicast; 5499fcea6f3dSAnirudh Venkataramanan 5500fcea6f3dSAnirudh Venkataramanan /* update some more netdev stats if this is main VSI */ 5501fcea6f3dSAnirudh Venkataramanan if (vsi->type == ICE_VSI_PF) { 5502fcea6f3dSAnirudh Venkataramanan cur_ns->rx_crc_errors = pf->stats.crc_errors; 5503fcea6f3dSAnirudh Venkataramanan cur_ns->rx_errors = pf->stats.crc_errors + 55044f1fe43cSBrett Creeley pf->stats.illegal_bytes + 55054f1fe43cSBrett Creeley pf->stats.rx_len_errors + 55064f1fe43cSBrett Creeley pf->stats.rx_undersize + 55074f1fe43cSBrett Creeley pf->hw_csum_rx_error + 55084f1fe43cSBrett Creeley pf->stats.rx_jabber + 55094f1fe43cSBrett Creeley pf->stats.rx_fragments + 55104f1fe43cSBrett Creeley pf->stats.rx_oversize; 5511fcea6f3dSAnirudh Venkataramanan cur_ns->rx_length_errors = pf->stats.rx_len_errors; 551256923ab6SBrett Creeley /* record drops from the port level */ 551356923ab6SBrett Creeley cur_ns->rx_missed_errors = pf->stats.eth.rx_discards; 5514fcea6f3dSAnirudh Venkataramanan } 5515fcea6f3dSAnirudh Venkataramanan } 5516fcea6f3dSAnirudh Venkataramanan 5517fcea6f3dSAnirudh Venkataramanan /** 5518fcea6f3dSAnirudh Venkataramanan * ice_update_pf_stats - Update PF port stats counters 5519fcea6f3dSAnirudh Venkataramanan * @pf: PF whose stats needs to be updated 5520fcea6f3dSAnirudh Venkataramanan */ 55215a4a8673SBruce Allan void ice_update_pf_stats(struct ice_pf *pf) 5522fcea6f3dSAnirudh Venkataramanan { 5523fcea6f3dSAnirudh Venkataramanan struct ice_hw_port_stats *prev_ps, *cur_ps; 5524fcea6f3dSAnirudh Venkataramanan struct ice_hw *hw = &pf->hw; 55254ab95646SHenry Tieman u16 fd_ctr_base; 55269e7a5d17SUsha Ketineni u8 port; 5527fcea6f3dSAnirudh Venkataramanan 55289e7a5d17SUsha Ketineni port = hw->port_info->lport; 5529fcea6f3dSAnirudh Venkataramanan prev_ps = &pf->stats_prev; 5530fcea6f3dSAnirudh Venkataramanan cur_ps = &pf->stats; 5531fcea6f3dSAnirudh Venkataramanan 55329e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_GORCL(port), pf->stat_prev_loaded, 553336517fd3SJacob Keller &prev_ps->eth.rx_bytes, 5534fcea6f3dSAnirudh Venkataramanan &cur_ps->eth.rx_bytes); 5535fcea6f3dSAnirudh Venkataramanan 55369e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_UPRCL(port), pf->stat_prev_loaded, 553736517fd3SJacob Keller &prev_ps->eth.rx_unicast, 5538fcea6f3dSAnirudh Venkataramanan &cur_ps->eth.rx_unicast); 5539fcea6f3dSAnirudh Venkataramanan 55409e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_MPRCL(port), pf->stat_prev_loaded, 554136517fd3SJacob Keller &prev_ps->eth.rx_multicast, 5542fcea6f3dSAnirudh Venkataramanan &cur_ps->eth.rx_multicast); 5543fcea6f3dSAnirudh Venkataramanan 55449e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_BPRCL(port), pf->stat_prev_loaded, 554536517fd3SJacob Keller &prev_ps->eth.rx_broadcast, 5546fcea6f3dSAnirudh Venkataramanan &cur_ps->eth.rx_broadcast); 5547fcea6f3dSAnirudh Venkataramanan 554856923ab6SBrett Creeley ice_stat_update32(hw, PRTRPB_RDPC, pf->stat_prev_loaded, 554956923ab6SBrett Creeley &prev_ps->eth.rx_discards, 555056923ab6SBrett Creeley &cur_ps->eth.rx_discards); 555156923ab6SBrett Creeley 55529e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_GOTCL(port), pf->stat_prev_loaded, 555336517fd3SJacob Keller &prev_ps->eth.tx_bytes, 5554fcea6f3dSAnirudh Venkataramanan &cur_ps->eth.tx_bytes); 5555fcea6f3dSAnirudh Venkataramanan 55569e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_UPTCL(port), pf->stat_prev_loaded, 555736517fd3SJacob Keller &prev_ps->eth.tx_unicast, 5558fcea6f3dSAnirudh Venkataramanan &cur_ps->eth.tx_unicast); 5559fcea6f3dSAnirudh Venkataramanan 55609e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_MPTCL(port), pf->stat_prev_loaded, 556136517fd3SJacob Keller &prev_ps->eth.tx_multicast, 5562fcea6f3dSAnirudh Venkataramanan &cur_ps->eth.tx_multicast); 5563fcea6f3dSAnirudh Venkataramanan 55649e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_BPTCL(port), pf->stat_prev_loaded, 556536517fd3SJacob Keller &prev_ps->eth.tx_broadcast, 5566fcea6f3dSAnirudh Venkataramanan &cur_ps->eth.tx_broadcast); 5567fcea6f3dSAnirudh Venkataramanan 55689e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_TDOLD(port), pf->stat_prev_loaded, 5569fcea6f3dSAnirudh Venkataramanan &prev_ps->tx_dropped_link_down, 5570fcea6f3dSAnirudh Venkataramanan &cur_ps->tx_dropped_link_down); 5571fcea6f3dSAnirudh Venkataramanan 55729e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PRC64L(port), pf->stat_prev_loaded, 557336517fd3SJacob Keller &prev_ps->rx_size_64, &cur_ps->rx_size_64); 5574fcea6f3dSAnirudh Venkataramanan 55759e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PRC127L(port), pf->stat_prev_loaded, 557636517fd3SJacob Keller &prev_ps->rx_size_127, &cur_ps->rx_size_127); 5577fcea6f3dSAnirudh Venkataramanan 55789e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PRC255L(port), pf->stat_prev_loaded, 557936517fd3SJacob Keller &prev_ps->rx_size_255, &cur_ps->rx_size_255); 5580fcea6f3dSAnirudh Venkataramanan 55819e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PRC511L(port), pf->stat_prev_loaded, 558236517fd3SJacob Keller &prev_ps->rx_size_511, &cur_ps->rx_size_511); 5583fcea6f3dSAnirudh Venkataramanan 55849e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PRC1023L(port), pf->stat_prev_loaded, 5585fcea6f3dSAnirudh Venkataramanan &prev_ps->rx_size_1023, &cur_ps->rx_size_1023); 5586fcea6f3dSAnirudh Venkataramanan 55879e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PRC1522L(port), pf->stat_prev_loaded, 5588fcea6f3dSAnirudh Venkataramanan &prev_ps->rx_size_1522, &cur_ps->rx_size_1522); 5589fcea6f3dSAnirudh Venkataramanan 55909e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PRC9522L(port), pf->stat_prev_loaded, 5591fcea6f3dSAnirudh Venkataramanan &prev_ps->rx_size_big, &cur_ps->rx_size_big); 5592fcea6f3dSAnirudh Venkataramanan 55939e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PTC64L(port), pf->stat_prev_loaded, 559436517fd3SJacob Keller &prev_ps->tx_size_64, &cur_ps->tx_size_64); 5595fcea6f3dSAnirudh Venkataramanan 55969e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PTC127L(port), pf->stat_prev_loaded, 559736517fd3SJacob Keller &prev_ps->tx_size_127, &cur_ps->tx_size_127); 5598fcea6f3dSAnirudh Venkataramanan 55999e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PTC255L(port), pf->stat_prev_loaded, 560036517fd3SJacob Keller &prev_ps->tx_size_255, &cur_ps->tx_size_255); 5601fcea6f3dSAnirudh Venkataramanan 56029e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PTC511L(port), pf->stat_prev_loaded, 560336517fd3SJacob Keller &prev_ps->tx_size_511, &cur_ps->tx_size_511); 5604fcea6f3dSAnirudh Venkataramanan 56059e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PTC1023L(port), pf->stat_prev_loaded, 5606fcea6f3dSAnirudh Venkataramanan &prev_ps->tx_size_1023, &cur_ps->tx_size_1023); 5607fcea6f3dSAnirudh Venkataramanan 56089e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PTC1522L(port), pf->stat_prev_loaded, 5609fcea6f3dSAnirudh Venkataramanan &prev_ps->tx_size_1522, &cur_ps->tx_size_1522); 5610fcea6f3dSAnirudh Venkataramanan 56119e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PTC9522L(port), pf->stat_prev_loaded, 5612fcea6f3dSAnirudh Venkataramanan &prev_ps->tx_size_big, &cur_ps->tx_size_big); 5613fcea6f3dSAnirudh Venkataramanan 56144ab95646SHenry Tieman fd_ctr_base = hw->fd_ctr_base; 56154ab95646SHenry Tieman 56164ab95646SHenry Tieman ice_stat_update40(hw, 56174ab95646SHenry Tieman GLSTAT_FD_CNT0L(ICE_FD_SB_STAT_IDX(fd_ctr_base)), 56184ab95646SHenry Tieman pf->stat_prev_loaded, &prev_ps->fd_sb_match, 56194ab95646SHenry Tieman &cur_ps->fd_sb_match); 56209e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_LXONRXC(port), pf->stat_prev_loaded, 5621fcea6f3dSAnirudh Venkataramanan &prev_ps->link_xon_rx, &cur_ps->link_xon_rx); 5622fcea6f3dSAnirudh Venkataramanan 56239e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_LXOFFRXC(port), pf->stat_prev_loaded, 5624fcea6f3dSAnirudh Venkataramanan &prev_ps->link_xoff_rx, &cur_ps->link_xoff_rx); 5625fcea6f3dSAnirudh Venkataramanan 56269e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_LXONTXC(port), pf->stat_prev_loaded, 5627fcea6f3dSAnirudh Venkataramanan &prev_ps->link_xon_tx, &cur_ps->link_xon_tx); 5628fcea6f3dSAnirudh Venkataramanan 56299e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_LXOFFTXC(port), pf->stat_prev_loaded, 5630fcea6f3dSAnirudh Venkataramanan &prev_ps->link_xoff_tx, &cur_ps->link_xoff_tx); 5631fcea6f3dSAnirudh Venkataramanan 56324b0fdcebSAnirudh Venkataramanan ice_update_dcb_stats(pf); 56334b0fdcebSAnirudh Venkataramanan 56349e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_CRCERRS(port), pf->stat_prev_loaded, 5635fcea6f3dSAnirudh Venkataramanan &prev_ps->crc_errors, &cur_ps->crc_errors); 5636fcea6f3dSAnirudh Venkataramanan 56379e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_ILLERRC(port), pf->stat_prev_loaded, 5638fcea6f3dSAnirudh Venkataramanan &prev_ps->illegal_bytes, &cur_ps->illegal_bytes); 5639fcea6f3dSAnirudh Venkataramanan 56409e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_MLFC(port), pf->stat_prev_loaded, 5641fcea6f3dSAnirudh Venkataramanan &prev_ps->mac_local_faults, 5642fcea6f3dSAnirudh Venkataramanan &cur_ps->mac_local_faults); 5643fcea6f3dSAnirudh Venkataramanan 56449e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_MRFC(port), pf->stat_prev_loaded, 5645fcea6f3dSAnirudh Venkataramanan &prev_ps->mac_remote_faults, 5646fcea6f3dSAnirudh Venkataramanan &cur_ps->mac_remote_faults); 5647fcea6f3dSAnirudh Venkataramanan 56489e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_RLEC(port), pf->stat_prev_loaded, 5649fcea6f3dSAnirudh Venkataramanan &prev_ps->rx_len_errors, &cur_ps->rx_len_errors); 5650fcea6f3dSAnirudh Venkataramanan 56519e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_RUC(port), pf->stat_prev_loaded, 5652fcea6f3dSAnirudh Venkataramanan &prev_ps->rx_undersize, &cur_ps->rx_undersize); 5653fcea6f3dSAnirudh Venkataramanan 56549e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_RFC(port), pf->stat_prev_loaded, 5655fcea6f3dSAnirudh Venkataramanan &prev_ps->rx_fragments, &cur_ps->rx_fragments); 5656fcea6f3dSAnirudh Venkataramanan 56579e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_ROC(port), pf->stat_prev_loaded, 5658fcea6f3dSAnirudh Venkataramanan &prev_ps->rx_oversize, &cur_ps->rx_oversize); 5659fcea6f3dSAnirudh Venkataramanan 56609e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_RJC(port), pf->stat_prev_loaded, 5661fcea6f3dSAnirudh Venkataramanan &prev_ps->rx_jabber, &cur_ps->rx_jabber); 5662fcea6f3dSAnirudh Venkataramanan 56634ab95646SHenry Tieman cur_ps->fd_sb_status = test_bit(ICE_FLAG_FD_ENA, pf->flags) ? 1 : 0; 56644ab95646SHenry Tieman 5665fcea6f3dSAnirudh Venkataramanan pf->stat_prev_loaded = true; 5666fcea6f3dSAnirudh Venkataramanan } 5667fcea6f3dSAnirudh Venkataramanan 5668fcea6f3dSAnirudh Venkataramanan /** 5669fcea6f3dSAnirudh Venkataramanan * ice_get_stats64 - get statistics for network device structure 5670fcea6f3dSAnirudh Venkataramanan * @netdev: network interface device structure 5671fcea6f3dSAnirudh Venkataramanan * @stats: main device statistics structure 5672fcea6f3dSAnirudh Venkataramanan */ 5673fcea6f3dSAnirudh Venkataramanan static 5674fcea6f3dSAnirudh Venkataramanan void ice_get_stats64(struct net_device *netdev, struct rtnl_link_stats64 *stats) 5675fcea6f3dSAnirudh Venkataramanan { 5676fcea6f3dSAnirudh Venkataramanan struct ice_netdev_priv *np = netdev_priv(netdev); 5677fcea6f3dSAnirudh Venkataramanan struct rtnl_link_stats64 *vsi_stats; 5678fcea6f3dSAnirudh Venkataramanan struct ice_vsi *vsi = np->vsi; 5679fcea6f3dSAnirudh Venkataramanan 5680fcea6f3dSAnirudh Venkataramanan vsi_stats = &vsi->net_stats; 5681fcea6f3dSAnirudh Venkataramanan 56823d57fd10SDave Ertman if (!vsi->num_txq || !vsi->num_rxq) 5683fcea6f3dSAnirudh Venkataramanan return; 56843d57fd10SDave Ertman 5685fcea6f3dSAnirudh Venkataramanan /* netdev packet/byte stats come from ring counter. These are obtained 5686fcea6f3dSAnirudh Venkataramanan * by summing up ring counters (done by ice_update_vsi_ring_stats). 56873d57fd10SDave Ertman * But, only call the update routine and read the registers if VSI is 56883d57fd10SDave Ertman * not down. 5689fcea6f3dSAnirudh Venkataramanan */ 5690e97fb1aeSAnirudh Venkataramanan if (!test_bit(ICE_VSI_DOWN, vsi->state)) 5691fcea6f3dSAnirudh Venkataramanan ice_update_vsi_ring_stats(vsi); 5692fcea6f3dSAnirudh Venkataramanan stats->tx_packets = vsi_stats->tx_packets; 5693fcea6f3dSAnirudh Venkataramanan stats->tx_bytes = vsi_stats->tx_bytes; 5694fcea6f3dSAnirudh Venkataramanan stats->rx_packets = vsi_stats->rx_packets; 5695fcea6f3dSAnirudh Venkataramanan stats->rx_bytes = vsi_stats->rx_bytes; 5696fcea6f3dSAnirudh Venkataramanan 5697fcea6f3dSAnirudh Venkataramanan /* The rest of the stats can be read from the hardware but instead we 5698fcea6f3dSAnirudh Venkataramanan * just return values that the watchdog task has already obtained from 5699fcea6f3dSAnirudh Venkataramanan * the hardware. 5700fcea6f3dSAnirudh Venkataramanan */ 5701fcea6f3dSAnirudh Venkataramanan stats->multicast = vsi_stats->multicast; 5702fcea6f3dSAnirudh Venkataramanan stats->tx_errors = vsi_stats->tx_errors; 5703fcea6f3dSAnirudh Venkataramanan stats->tx_dropped = vsi_stats->tx_dropped; 5704fcea6f3dSAnirudh Venkataramanan stats->rx_errors = vsi_stats->rx_errors; 5705fcea6f3dSAnirudh Venkataramanan stats->rx_dropped = vsi_stats->rx_dropped; 5706fcea6f3dSAnirudh Venkataramanan stats->rx_crc_errors = vsi_stats->rx_crc_errors; 5707fcea6f3dSAnirudh Venkataramanan stats->rx_length_errors = vsi_stats->rx_length_errors; 5708fcea6f3dSAnirudh Venkataramanan } 5709fcea6f3dSAnirudh Venkataramanan 5710fcea6f3dSAnirudh Venkataramanan /** 57112b245cb2SAnirudh Venkataramanan * ice_napi_disable_all - Disable NAPI for all q_vectors in the VSI 57122b245cb2SAnirudh Venkataramanan * @vsi: VSI having NAPI disabled 57132b245cb2SAnirudh Venkataramanan */ 57142b245cb2SAnirudh Venkataramanan static void ice_napi_disable_all(struct ice_vsi *vsi) 57152b245cb2SAnirudh Venkataramanan { 57162b245cb2SAnirudh Venkataramanan int q_idx; 57172b245cb2SAnirudh Venkataramanan 57182b245cb2SAnirudh Venkataramanan if (!vsi->netdev) 57192b245cb2SAnirudh Venkataramanan return; 57202b245cb2SAnirudh Venkataramanan 57210c2561c8SBrett Creeley ice_for_each_q_vector(vsi, q_idx) { 5722eec90376SYoung Xiao struct ice_q_vector *q_vector = vsi->q_vectors[q_idx]; 5723eec90376SYoung Xiao 5724eec90376SYoung Xiao if (q_vector->rx.ring || q_vector->tx.ring) 5725eec90376SYoung Xiao napi_disable(&q_vector->napi); 5726cdf1f1f1SJacob Keller 5727cdf1f1f1SJacob Keller cancel_work_sync(&q_vector->tx.dim.work); 5728cdf1f1f1SJacob Keller cancel_work_sync(&q_vector->rx.dim.work); 5729eec90376SYoung Xiao } 57302b245cb2SAnirudh Venkataramanan } 57312b245cb2SAnirudh Venkataramanan 57322b245cb2SAnirudh Venkataramanan /** 5733cdedef59SAnirudh Venkataramanan * ice_down - Shutdown the connection 5734cdedef59SAnirudh Venkataramanan * @vsi: The VSI being stopped 5735cdedef59SAnirudh Venkataramanan */ 5736fcea6f3dSAnirudh Venkataramanan int ice_down(struct ice_vsi *vsi) 5737cdedef59SAnirudh Venkataramanan { 5738ab4ab73fSBruce Allan int i, tx_err, rx_err, link_err = 0; 5739cdedef59SAnirudh Venkataramanan 5740cdedef59SAnirudh Venkataramanan /* Caller of this function is expected to set the 57417e408e07SAnirudh Venkataramanan * vsi->state ICE_DOWN bit 5742cdedef59SAnirudh Venkataramanan */ 5743cdedef59SAnirudh Venkataramanan if (vsi->netdev) { 5744cdedef59SAnirudh Venkataramanan netif_carrier_off(vsi->netdev); 5745cdedef59SAnirudh Venkataramanan netif_tx_disable(vsi->netdev); 5746cdedef59SAnirudh Venkataramanan } 5747cdedef59SAnirudh Venkataramanan 5748cdedef59SAnirudh Venkataramanan ice_vsi_dis_irq(vsi); 574903f7a986SAnirudh Venkataramanan 575003f7a986SAnirudh Venkataramanan tx_err = ice_vsi_stop_lan_tx_rings(vsi, ICE_NO_RESET, 0); 575172adf242SAnirudh Venkataramanan if (tx_err) 575219cce2c6SAnirudh Venkataramanan netdev_err(vsi->netdev, "Failed stop Tx rings, VSI %d error %d\n", 575372adf242SAnirudh Venkataramanan vsi->vsi_num, tx_err); 5754efc2214bSMaciej Fijalkowski if (!tx_err && ice_is_xdp_ena_vsi(vsi)) { 5755efc2214bSMaciej Fijalkowski tx_err = ice_vsi_stop_xdp_tx_rings(vsi); 5756efc2214bSMaciej Fijalkowski if (tx_err) 575719cce2c6SAnirudh Venkataramanan netdev_err(vsi->netdev, "Failed stop XDP rings, VSI %d error %d\n", 5758efc2214bSMaciej Fijalkowski vsi->vsi_num, tx_err); 5759efc2214bSMaciej Fijalkowski } 576072adf242SAnirudh Venkataramanan 576113a6233bSBrett Creeley rx_err = ice_vsi_stop_all_rx_rings(vsi); 576272adf242SAnirudh Venkataramanan if (rx_err) 576319cce2c6SAnirudh Venkataramanan netdev_err(vsi->netdev, "Failed stop Rx rings, VSI %d error %d\n", 576472adf242SAnirudh Venkataramanan vsi->vsi_num, rx_err); 576572adf242SAnirudh Venkataramanan 57662b245cb2SAnirudh Venkataramanan ice_napi_disable_all(vsi); 5767cdedef59SAnirudh Venkataramanan 5768ab4ab73fSBruce Allan if (test_bit(ICE_FLAG_LINK_DOWN_ON_CLOSE_ENA, vsi->back->flags)) { 5769b6f934f0SBrett Creeley link_err = ice_force_phys_link_state(vsi, false); 5770b6f934f0SBrett Creeley if (link_err) 577119cce2c6SAnirudh Venkataramanan netdev_err(vsi->netdev, "Failed to set physical link down, VSI %d error %d\n", 5772b6f934f0SBrett Creeley vsi->vsi_num, link_err); 5773ab4ab73fSBruce Allan } 5774b6f934f0SBrett Creeley 5775cdedef59SAnirudh Venkataramanan ice_for_each_txq(vsi, i) 5776cdedef59SAnirudh Venkataramanan ice_clean_tx_ring(vsi->tx_rings[i]); 5777cdedef59SAnirudh Venkataramanan 5778cdedef59SAnirudh Venkataramanan ice_for_each_rxq(vsi, i) 5779cdedef59SAnirudh Venkataramanan ice_clean_rx_ring(vsi->rx_rings[i]); 5780cdedef59SAnirudh Venkataramanan 5781b6f934f0SBrett Creeley if (tx_err || rx_err || link_err) { 578219cce2c6SAnirudh Venkataramanan netdev_err(vsi->netdev, "Failed to close VSI 0x%04X on switch 0x%04X\n", 5783cdedef59SAnirudh Venkataramanan vsi->vsi_num, vsi->vsw->sw_id); 578472adf242SAnirudh Venkataramanan return -EIO; 578572adf242SAnirudh Venkataramanan } 578672adf242SAnirudh Venkataramanan 578772adf242SAnirudh Venkataramanan return 0; 5788cdedef59SAnirudh Venkataramanan } 5789cdedef59SAnirudh Venkataramanan 5790cdedef59SAnirudh Venkataramanan /** 5791cdedef59SAnirudh Venkataramanan * ice_vsi_setup_tx_rings - Allocate VSI Tx queue resources 5792cdedef59SAnirudh Venkataramanan * @vsi: VSI having resources allocated 5793cdedef59SAnirudh Venkataramanan * 5794cdedef59SAnirudh Venkataramanan * Return 0 on success, negative on failure 5795cdedef59SAnirudh Venkataramanan */ 57960e674aebSAnirudh Venkataramanan int ice_vsi_setup_tx_rings(struct ice_vsi *vsi) 5797cdedef59SAnirudh Venkataramanan { 5798dab0588fSJesse Brandeburg int i, err = 0; 5799cdedef59SAnirudh Venkataramanan 5800cdedef59SAnirudh Venkataramanan if (!vsi->num_txq) { 58019a946843SAnirudh Venkataramanan dev_err(ice_pf_to_dev(vsi->back), "VSI %d has 0 Tx queues\n", 5802cdedef59SAnirudh Venkataramanan vsi->vsi_num); 5803cdedef59SAnirudh Venkataramanan return -EINVAL; 5804cdedef59SAnirudh Venkataramanan } 5805cdedef59SAnirudh Venkataramanan 5806cdedef59SAnirudh Venkataramanan ice_for_each_txq(vsi, i) { 5807eb0ee8abSMichal Swiatkowski struct ice_ring *ring = vsi->tx_rings[i]; 5808eb0ee8abSMichal Swiatkowski 5809eb0ee8abSMichal Swiatkowski if (!ring) 5810eb0ee8abSMichal Swiatkowski return -EINVAL; 5811eb0ee8abSMichal Swiatkowski 5812eb0ee8abSMichal Swiatkowski ring->netdev = vsi->netdev; 5813eb0ee8abSMichal Swiatkowski err = ice_setup_tx_ring(ring); 5814cdedef59SAnirudh Venkataramanan if (err) 5815cdedef59SAnirudh Venkataramanan break; 5816cdedef59SAnirudh Venkataramanan } 5817cdedef59SAnirudh Venkataramanan 5818cdedef59SAnirudh Venkataramanan return err; 5819cdedef59SAnirudh Venkataramanan } 5820cdedef59SAnirudh Venkataramanan 5821cdedef59SAnirudh Venkataramanan /** 5822cdedef59SAnirudh Venkataramanan * ice_vsi_setup_rx_rings - Allocate VSI Rx queue resources 5823cdedef59SAnirudh Venkataramanan * @vsi: VSI having resources allocated 5824cdedef59SAnirudh Venkataramanan * 5825cdedef59SAnirudh Venkataramanan * Return 0 on success, negative on failure 5826cdedef59SAnirudh Venkataramanan */ 58270e674aebSAnirudh Venkataramanan int ice_vsi_setup_rx_rings(struct ice_vsi *vsi) 5828cdedef59SAnirudh Venkataramanan { 5829dab0588fSJesse Brandeburg int i, err = 0; 5830cdedef59SAnirudh Venkataramanan 5831cdedef59SAnirudh Venkataramanan if (!vsi->num_rxq) { 58329a946843SAnirudh Venkataramanan dev_err(ice_pf_to_dev(vsi->back), "VSI %d has 0 Rx queues\n", 5833cdedef59SAnirudh Venkataramanan vsi->vsi_num); 5834cdedef59SAnirudh Venkataramanan return -EINVAL; 5835cdedef59SAnirudh Venkataramanan } 5836cdedef59SAnirudh Venkataramanan 5837cdedef59SAnirudh Venkataramanan ice_for_each_rxq(vsi, i) { 5838eb0ee8abSMichal Swiatkowski struct ice_ring *ring = vsi->rx_rings[i]; 5839eb0ee8abSMichal Swiatkowski 5840eb0ee8abSMichal Swiatkowski if (!ring) 5841eb0ee8abSMichal Swiatkowski return -EINVAL; 5842eb0ee8abSMichal Swiatkowski 5843eb0ee8abSMichal Swiatkowski ring->netdev = vsi->netdev; 5844eb0ee8abSMichal Swiatkowski err = ice_setup_rx_ring(ring); 5845cdedef59SAnirudh Venkataramanan if (err) 5846cdedef59SAnirudh Venkataramanan break; 5847cdedef59SAnirudh Venkataramanan } 5848cdedef59SAnirudh Venkataramanan 5849cdedef59SAnirudh Venkataramanan return err; 5850cdedef59SAnirudh Venkataramanan } 5851cdedef59SAnirudh Venkataramanan 5852cdedef59SAnirudh Venkataramanan /** 5853148beb61SHenry Tieman * ice_vsi_open_ctrl - open control VSI for use 5854148beb61SHenry Tieman * @vsi: the VSI to open 5855148beb61SHenry Tieman * 5856148beb61SHenry Tieman * Initialization of the Control VSI 5857148beb61SHenry Tieman * 5858148beb61SHenry Tieman * Returns 0 on success, negative value on error 5859148beb61SHenry Tieman */ 5860148beb61SHenry Tieman int ice_vsi_open_ctrl(struct ice_vsi *vsi) 5861148beb61SHenry Tieman { 5862148beb61SHenry Tieman char int_name[ICE_INT_NAME_STR_LEN]; 5863148beb61SHenry Tieman struct ice_pf *pf = vsi->back; 5864148beb61SHenry Tieman struct device *dev; 5865148beb61SHenry Tieman int err; 5866148beb61SHenry Tieman 5867148beb61SHenry Tieman dev = ice_pf_to_dev(pf); 5868148beb61SHenry Tieman /* allocate descriptors */ 5869148beb61SHenry Tieman err = ice_vsi_setup_tx_rings(vsi); 5870148beb61SHenry Tieman if (err) 5871148beb61SHenry Tieman goto err_setup_tx; 5872148beb61SHenry Tieman 5873148beb61SHenry Tieman err = ice_vsi_setup_rx_rings(vsi); 5874148beb61SHenry Tieman if (err) 5875148beb61SHenry Tieman goto err_setup_rx; 5876148beb61SHenry Tieman 5877148beb61SHenry Tieman err = ice_vsi_cfg(vsi); 5878148beb61SHenry Tieman if (err) 5879148beb61SHenry Tieman goto err_setup_rx; 5880148beb61SHenry Tieman 5881148beb61SHenry Tieman snprintf(int_name, sizeof(int_name) - 1, "%s-%s:ctrl", 5882148beb61SHenry Tieman dev_driver_string(dev), dev_name(dev)); 5883148beb61SHenry Tieman err = ice_vsi_req_irq_msix(vsi, int_name); 5884148beb61SHenry Tieman if (err) 5885148beb61SHenry Tieman goto err_setup_rx; 5886148beb61SHenry Tieman 5887148beb61SHenry Tieman ice_vsi_cfg_msix(vsi); 5888148beb61SHenry Tieman 5889148beb61SHenry Tieman err = ice_vsi_start_all_rx_rings(vsi); 5890148beb61SHenry Tieman if (err) 5891148beb61SHenry Tieman goto err_up_complete; 5892148beb61SHenry Tieman 5893e97fb1aeSAnirudh Venkataramanan clear_bit(ICE_VSI_DOWN, vsi->state); 5894148beb61SHenry Tieman ice_vsi_ena_irq(vsi); 5895148beb61SHenry Tieman 5896148beb61SHenry Tieman return 0; 5897148beb61SHenry Tieman 5898148beb61SHenry Tieman err_up_complete: 5899148beb61SHenry Tieman ice_down(vsi); 5900148beb61SHenry Tieman err_setup_rx: 5901148beb61SHenry Tieman ice_vsi_free_rx_rings(vsi); 5902148beb61SHenry Tieman err_setup_tx: 5903148beb61SHenry Tieman ice_vsi_free_tx_rings(vsi); 5904148beb61SHenry Tieman 5905148beb61SHenry Tieman return err; 5906148beb61SHenry Tieman } 5907148beb61SHenry Tieman 5908148beb61SHenry Tieman /** 5909cdedef59SAnirudh Venkataramanan * ice_vsi_open - Called when a network interface is made active 5910cdedef59SAnirudh Venkataramanan * @vsi: the VSI to open 5911cdedef59SAnirudh Venkataramanan * 5912cdedef59SAnirudh Venkataramanan * Initialization of the VSI 5913cdedef59SAnirudh Venkataramanan * 5914cdedef59SAnirudh Venkataramanan * Returns 0 on success, negative value on error 5915cdedef59SAnirudh Venkataramanan */ 5916cdedef59SAnirudh Venkataramanan static int ice_vsi_open(struct ice_vsi *vsi) 5917cdedef59SAnirudh Venkataramanan { 5918cdedef59SAnirudh Venkataramanan char int_name[ICE_INT_NAME_STR_LEN]; 5919cdedef59SAnirudh Venkataramanan struct ice_pf *pf = vsi->back; 5920cdedef59SAnirudh Venkataramanan int err; 5921cdedef59SAnirudh Venkataramanan 5922cdedef59SAnirudh Venkataramanan /* allocate descriptors */ 5923cdedef59SAnirudh Venkataramanan err = ice_vsi_setup_tx_rings(vsi); 5924cdedef59SAnirudh Venkataramanan if (err) 5925cdedef59SAnirudh Venkataramanan goto err_setup_tx; 5926cdedef59SAnirudh Venkataramanan 5927cdedef59SAnirudh Venkataramanan err = ice_vsi_setup_rx_rings(vsi); 5928cdedef59SAnirudh Venkataramanan if (err) 5929cdedef59SAnirudh Venkataramanan goto err_setup_rx; 5930cdedef59SAnirudh Venkataramanan 5931cdedef59SAnirudh Venkataramanan err = ice_vsi_cfg(vsi); 5932cdedef59SAnirudh Venkataramanan if (err) 5933cdedef59SAnirudh Venkataramanan goto err_setup_rx; 5934cdedef59SAnirudh Venkataramanan 5935cdedef59SAnirudh Venkataramanan snprintf(int_name, sizeof(int_name) - 1, "%s-%s", 59364015d11eSBrett Creeley dev_driver_string(ice_pf_to_dev(pf)), vsi->netdev->name); 5937ba880734SBrett Creeley err = ice_vsi_req_irq_msix(vsi, int_name); 5938cdedef59SAnirudh Venkataramanan if (err) 5939cdedef59SAnirudh Venkataramanan goto err_setup_rx; 5940cdedef59SAnirudh Venkataramanan 5941cdedef59SAnirudh Venkataramanan /* Notify the stack of the actual queue counts. */ 5942cdedef59SAnirudh Venkataramanan err = netif_set_real_num_tx_queues(vsi->netdev, vsi->num_txq); 5943cdedef59SAnirudh Venkataramanan if (err) 5944cdedef59SAnirudh Venkataramanan goto err_set_qs; 5945cdedef59SAnirudh Venkataramanan 5946cdedef59SAnirudh Venkataramanan err = netif_set_real_num_rx_queues(vsi->netdev, vsi->num_rxq); 5947cdedef59SAnirudh Venkataramanan if (err) 5948cdedef59SAnirudh Venkataramanan goto err_set_qs; 5949cdedef59SAnirudh Venkataramanan 5950cdedef59SAnirudh Venkataramanan err = ice_up_complete(vsi); 5951cdedef59SAnirudh Venkataramanan if (err) 5952cdedef59SAnirudh Venkataramanan goto err_up_complete; 5953cdedef59SAnirudh Venkataramanan 5954cdedef59SAnirudh Venkataramanan return 0; 5955cdedef59SAnirudh Venkataramanan 5956cdedef59SAnirudh Venkataramanan err_up_complete: 5957cdedef59SAnirudh Venkataramanan ice_down(vsi); 5958cdedef59SAnirudh Venkataramanan err_set_qs: 5959cdedef59SAnirudh Venkataramanan ice_vsi_free_irq(vsi); 5960cdedef59SAnirudh Venkataramanan err_setup_rx: 5961cdedef59SAnirudh Venkataramanan ice_vsi_free_rx_rings(vsi); 5962cdedef59SAnirudh Venkataramanan err_setup_tx: 5963cdedef59SAnirudh Venkataramanan ice_vsi_free_tx_rings(vsi); 5964cdedef59SAnirudh Venkataramanan 5965cdedef59SAnirudh Venkataramanan return err; 5966cdedef59SAnirudh Venkataramanan } 5967cdedef59SAnirudh Venkataramanan 5968cdedef59SAnirudh Venkataramanan /** 59690f9d5027SAnirudh Venkataramanan * ice_vsi_release_all - Delete all VSIs 59700f9d5027SAnirudh Venkataramanan * @pf: PF from which all VSIs are being removed 59710f9d5027SAnirudh Venkataramanan */ 59720f9d5027SAnirudh Venkataramanan static void ice_vsi_release_all(struct ice_pf *pf) 59730f9d5027SAnirudh Venkataramanan { 59740f9d5027SAnirudh Venkataramanan int err, i; 59750f9d5027SAnirudh Venkataramanan 59760f9d5027SAnirudh Venkataramanan if (!pf->vsi) 59770f9d5027SAnirudh Venkataramanan return; 59780f9d5027SAnirudh Venkataramanan 597980ed404aSBrett Creeley ice_for_each_vsi(pf, i) { 59800f9d5027SAnirudh Venkataramanan if (!pf->vsi[i]) 59810f9d5027SAnirudh Venkataramanan continue; 59820f9d5027SAnirudh Venkataramanan 59830f9d5027SAnirudh Venkataramanan err = ice_vsi_release(pf->vsi[i]); 59840f9d5027SAnirudh Venkataramanan if (err) 598519cce2c6SAnirudh Venkataramanan dev_dbg(ice_pf_to_dev(pf), "Failed to release pf->vsi[%d], err %d, vsi_num = %d\n", 59860f9d5027SAnirudh Venkataramanan i, err, pf->vsi[i]->vsi_num); 59870f9d5027SAnirudh Venkataramanan } 59880f9d5027SAnirudh Venkataramanan } 59890f9d5027SAnirudh Venkataramanan 59900f9d5027SAnirudh Venkataramanan /** 5991462acf6aSTony Nguyen * ice_vsi_rebuild_by_type - Rebuild VSI of a given type 5992462acf6aSTony Nguyen * @pf: pointer to the PF instance 5993462acf6aSTony Nguyen * @type: VSI type to rebuild 5994462acf6aSTony Nguyen * 5995462acf6aSTony Nguyen * Iterates through the pf->vsi array and rebuilds VSIs of the requested type 59960f9d5027SAnirudh Venkataramanan */ 5997462acf6aSTony Nguyen static int ice_vsi_rebuild_by_type(struct ice_pf *pf, enum ice_vsi_type type) 59980f9d5027SAnirudh Venkataramanan { 59994015d11eSBrett Creeley struct device *dev = ice_pf_to_dev(pf); 6000462acf6aSTony Nguyen enum ice_status status; 6001462acf6aSTony Nguyen int i, err; 60020f9d5027SAnirudh Venkataramanan 600380ed404aSBrett Creeley ice_for_each_vsi(pf, i) { 60044425e053SKrzysztof Kazimierczak struct ice_vsi *vsi = pf->vsi[i]; 60050f9d5027SAnirudh Venkataramanan 6006462acf6aSTony Nguyen if (!vsi || vsi->type != type) 60070f9d5027SAnirudh Venkataramanan continue; 60080f9d5027SAnirudh Venkataramanan 6009462acf6aSTony Nguyen /* rebuild the VSI */ 601087324e74SHenry Tieman err = ice_vsi_rebuild(vsi, true); 60110f9d5027SAnirudh Venkataramanan if (err) { 601219cce2c6SAnirudh Venkataramanan dev_err(dev, "rebuild VSI failed, err %d, VSI index %d, type %s\n", 6013964674f1SAnirudh Venkataramanan err, vsi->idx, ice_vsi_type_str(type)); 60140f9d5027SAnirudh Venkataramanan return err; 60150f9d5027SAnirudh Venkataramanan } 60160f9d5027SAnirudh Venkataramanan 6017462acf6aSTony Nguyen /* replay filters for the VSI */ 6018462acf6aSTony Nguyen status = ice_replay_vsi(&pf->hw, vsi->idx); 6019462acf6aSTony Nguyen if (status) { 60200fee3577SLihong Yang dev_err(dev, "replay VSI failed, status %s, VSI index %d, type %s\n", 60210fee3577SLihong Yang ice_stat_str(status), vsi->idx, 60220fee3577SLihong Yang ice_vsi_type_str(type)); 6023334cb062SAnirudh Venkataramanan return -EIO; 6024334cb062SAnirudh Venkataramanan } 6025334cb062SAnirudh Venkataramanan 6026334cb062SAnirudh Venkataramanan /* Re-map HW VSI number, using VSI handle that has been 6027334cb062SAnirudh Venkataramanan * previously validated in ice_replay_vsi() call above 6028334cb062SAnirudh Venkataramanan */ 6029462acf6aSTony Nguyen vsi->vsi_num = ice_get_hw_vsi_num(&pf->hw, vsi->idx); 6030334cb062SAnirudh Venkataramanan 6031462acf6aSTony Nguyen /* enable the VSI */ 6032462acf6aSTony Nguyen err = ice_ena_vsi(vsi, false); 6033462acf6aSTony Nguyen if (err) { 603419cce2c6SAnirudh Venkataramanan dev_err(dev, "enable VSI failed, err %d, VSI index %d, type %s\n", 6035964674f1SAnirudh Venkataramanan err, vsi->idx, ice_vsi_type_str(type)); 6036462acf6aSTony Nguyen return err; 6037334cb062SAnirudh Venkataramanan } 6038334cb062SAnirudh Venkataramanan 60394015d11eSBrett Creeley dev_info(dev, "VSI rebuilt. VSI index %d, type %s\n", vsi->idx, 60404015d11eSBrett Creeley ice_vsi_type_str(type)); 6041462acf6aSTony Nguyen } 6042462acf6aSTony Nguyen 6043334cb062SAnirudh Venkataramanan return 0; 6044334cb062SAnirudh Venkataramanan } 6045334cb062SAnirudh Venkataramanan 6046334cb062SAnirudh Venkataramanan /** 6047462acf6aSTony Nguyen * ice_update_pf_netdev_link - Update PF netdev link status 6048462acf6aSTony Nguyen * @pf: pointer to the PF instance 6049462acf6aSTony Nguyen */ 6050462acf6aSTony Nguyen static void ice_update_pf_netdev_link(struct ice_pf *pf) 6051462acf6aSTony Nguyen { 6052462acf6aSTony Nguyen bool link_up; 6053462acf6aSTony Nguyen int i; 6054462acf6aSTony Nguyen 6055462acf6aSTony Nguyen ice_for_each_vsi(pf, i) { 6056462acf6aSTony Nguyen struct ice_vsi *vsi = pf->vsi[i]; 6057462acf6aSTony Nguyen 6058462acf6aSTony Nguyen if (!vsi || vsi->type != ICE_VSI_PF) 6059462acf6aSTony Nguyen return; 6060462acf6aSTony Nguyen 6061462acf6aSTony Nguyen ice_get_link_status(pf->vsi[i]->port_info, &link_up); 6062462acf6aSTony Nguyen if (link_up) { 6063462acf6aSTony Nguyen netif_carrier_on(pf->vsi[i]->netdev); 6064462acf6aSTony Nguyen netif_tx_wake_all_queues(pf->vsi[i]->netdev); 6065462acf6aSTony Nguyen } else { 6066462acf6aSTony Nguyen netif_carrier_off(pf->vsi[i]->netdev); 6067462acf6aSTony Nguyen netif_tx_stop_all_queues(pf->vsi[i]->netdev); 6068462acf6aSTony Nguyen } 6069462acf6aSTony Nguyen } 6070462acf6aSTony Nguyen } 6071462acf6aSTony Nguyen 6072462acf6aSTony Nguyen /** 60730b28b702SAnirudh Venkataramanan * ice_rebuild - rebuild after reset 60742f2da36eSAnirudh Venkataramanan * @pf: PF to rebuild 6075462acf6aSTony Nguyen * @reset_type: type of reset 607612bb018cSBrett Creeley * 607712bb018cSBrett Creeley * Do not rebuild VF VSI in this flow because that is already handled via 607812bb018cSBrett Creeley * ice_reset_all_vfs(). This is because requirements for resetting a VF after a 607912bb018cSBrett Creeley * PFR/CORER/GLOBER/etc. are different than the normal flow. Also, we don't want 608012bb018cSBrett Creeley * to reset/rebuild all the VF VSI twice. 60810b28b702SAnirudh Venkataramanan */ 6082462acf6aSTony Nguyen static void ice_rebuild(struct ice_pf *pf, enum ice_reset_req reset_type) 60830b28b702SAnirudh Venkataramanan { 60844015d11eSBrett Creeley struct device *dev = ice_pf_to_dev(pf); 60850b28b702SAnirudh Venkataramanan struct ice_hw *hw = &pf->hw; 60860b28b702SAnirudh Venkataramanan enum ice_status ret; 6087462acf6aSTony Nguyen int err; 60880b28b702SAnirudh Venkataramanan 60897e408e07SAnirudh Venkataramanan if (test_bit(ICE_DOWN, pf->state)) 60900b28b702SAnirudh Venkataramanan goto clear_recovery; 60910b28b702SAnirudh Venkataramanan 6092462acf6aSTony Nguyen dev_dbg(dev, "rebuilding PF after reset_type=%d\n", reset_type); 60930b28b702SAnirudh Venkataramanan 60940b28b702SAnirudh Venkataramanan ret = ice_init_all_ctrlq(hw); 60950b28b702SAnirudh Venkataramanan if (ret) { 60960fee3577SLihong Yang dev_err(dev, "control queues init failed %s\n", 60970fee3577SLihong Yang ice_stat_str(ret)); 60980f9d5027SAnirudh Venkataramanan goto err_init_ctrlq; 60990b28b702SAnirudh Venkataramanan } 61000b28b702SAnirudh Venkataramanan 6101462acf6aSTony Nguyen /* if DDP was previously loaded successfully */ 6102462acf6aSTony Nguyen if (!ice_is_safe_mode(pf)) { 6103462acf6aSTony Nguyen /* reload the SW DB of filter tables */ 6104462acf6aSTony Nguyen if (reset_type == ICE_RESET_PFR) 6105462acf6aSTony Nguyen ice_fill_blk_tbls(hw); 6106462acf6aSTony Nguyen else 6107462acf6aSTony Nguyen /* Reload DDP Package after CORER/GLOBR reset */ 6108462acf6aSTony Nguyen ice_load_pkg(NULL, pf); 6109462acf6aSTony Nguyen } 6110462acf6aSTony Nguyen 61110b28b702SAnirudh Venkataramanan ret = ice_clear_pf_cfg(hw); 61120b28b702SAnirudh Venkataramanan if (ret) { 61130fee3577SLihong Yang dev_err(dev, "clear PF configuration failed %s\n", 61140fee3577SLihong Yang ice_stat_str(ret)); 61150f9d5027SAnirudh Venkataramanan goto err_init_ctrlq; 61160b28b702SAnirudh Venkataramanan } 61170b28b702SAnirudh Venkataramanan 6118fc0f39bcSBrett Creeley if (pf->first_sw->dflt_vsi_ena) 611919cce2c6SAnirudh Venkataramanan dev_info(dev, "Clearing default VSI, re-enable after reset completes\n"); 6120fc0f39bcSBrett Creeley /* clear the default VSI configuration if it exists */ 6121fc0f39bcSBrett Creeley pf->first_sw->dflt_vsi = NULL; 6122fc0f39bcSBrett Creeley pf->first_sw->dflt_vsi_ena = false; 6123fc0f39bcSBrett Creeley 61240b28b702SAnirudh Venkataramanan ice_clear_pxe_mode(hw); 61250b28b702SAnirudh Venkataramanan 61260b28b702SAnirudh Venkataramanan ret = ice_get_caps(hw); 61270b28b702SAnirudh Venkataramanan if (ret) { 61280fee3577SLihong Yang dev_err(dev, "ice_get_caps failed %s\n", ice_stat_str(ret)); 61290f9d5027SAnirudh Venkataramanan goto err_init_ctrlq; 61300b28b702SAnirudh Venkataramanan } 61310b28b702SAnirudh Venkataramanan 613242449105SAnirudh Venkataramanan ret = ice_aq_set_mac_cfg(hw, ICE_AQ_SET_MAC_FRAME_SIZE_MAX, NULL); 613342449105SAnirudh Venkataramanan if (ret) { 613442449105SAnirudh Venkataramanan dev_err(dev, "set_mac_cfg failed %s\n", ice_stat_str(ret)); 613542449105SAnirudh Venkataramanan goto err_init_ctrlq; 613642449105SAnirudh Venkataramanan } 613742449105SAnirudh Venkataramanan 61380f9d5027SAnirudh Venkataramanan err = ice_sched_init_port(hw->port_info); 61390f9d5027SAnirudh Venkataramanan if (err) 61400f9d5027SAnirudh Venkataramanan goto err_sched_init_port; 61410f9d5027SAnirudh Venkataramanan 61420b28b702SAnirudh Venkataramanan /* start misc vector */ 61430b28b702SAnirudh Venkataramanan err = ice_req_irq_msix_misc(pf); 61440b28b702SAnirudh Venkataramanan if (err) { 61450b28b702SAnirudh Venkataramanan dev_err(dev, "misc vector setup failed: %d\n", err); 6146462acf6aSTony Nguyen goto err_sched_init_port; 61470b28b702SAnirudh Venkataramanan } 61480b28b702SAnirudh Venkataramanan 614983af0039SHenry Tieman if (test_bit(ICE_FLAG_FD_ENA, pf->flags)) { 615083af0039SHenry Tieman wr32(hw, PFQF_FD_ENA, PFQF_FD_ENA_FD_ENA_M); 615183af0039SHenry Tieman if (!rd32(hw, PFQF_FD_SIZE)) { 615283af0039SHenry Tieman u16 unused, guar, b_effort; 615383af0039SHenry Tieman 615483af0039SHenry Tieman guar = hw->func_caps.fd_fltr_guar; 615583af0039SHenry Tieman b_effort = hw->func_caps.fd_fltr_best_effort; 615683af0039SHenry Tieman 615783af0039SHenry Tieman /* force guaranteed filter pool for PF */ 615883af0039SHenry Tieman ice_alloc_fd_guar_item(hw, &unused, guar); 615983af0039SHenry Tieman /* force shared filter pool for PF */ 616083af0039SHenry Tieman ice_alloc_fd_shrd_item(hw, &unused, b_effort); 616183af0039SHenry Tieman } 616283af0039SHenry Tieman } 616383af0039SHenry Tieman 6164462acf6aSTony Nguyen if (test_bit(ICE_FLAG_DCB_ENA, pf->flags)) 6165462acf6aSTony Nguyen ice_dcb_rebuild(pf); 6166462acf6aSTony Nguyen 6167462acf6aSTony Nguyen /* rebuild PF VSI */ 6168462acf6aSTony Nguyen err = ice_vsi_rebuild_by_type(pf, ICE_VSI_PF); 61690f9d5027SAnirudh Venkataramanan if (err) { 6170462acf6aSTony Nguyen dev_err(dev, "PF VSI rebuild failed: %d\n", err); 61710f9d5027SAnirudh Venkataramanan goto err_vsi_rebuild; 61720f9d5027SAnirudh Venkataramanan } 61730b28b702SAnirudh Venkataramanan 617483af0039SHenry Tieman /* If Flow Director is active */ 617583af0039SHenry Tieman if (test_bit(ICE_FLAG_FD_ENA, pf->flags)) { 617683af0039SHenry Tieman err = ice_vsi_rebuild_by_type(pf, ICE_VSI_CTRL); 617783af0039SHenry Tieman if (err) { 617883af0039SHenry Tieman dev_err(dev, "control VSI rebuild failed: %d\n", err); 617983af0039SHenry Tieman goto err_vsi_rebuild; 618083af0039SHenry Tieman } 618183af0039SHenry Tieman 618283af0039SHenry Tieman /* replay HW Flow Director recipes */ 618383af0039SHenry Tieman if (hw->fdir_prof) 618483af0039SHenry Tieman ice_fdir_replay_flows(hw); 618583af0039SHenry Tieman 618683af0039SHenry Tieman /* replay Flow Director filters */ 618783af0039SHenry Tieman ice_fdir_replay_fltrs(pf); 618828bf2672SBrett Creeley 618928bf2672SBrett Creeley ice_rebuild_arfs(pf); 619083af0039SHenry Tieman } 619183af0039SHenry Tieman 6192462acf6aSTony Nguyen ice_update_pf_netdev_link(pf); 6193462acf6aSTony Nguyen 6194462acf6aSTony Nguyen /* tell the firmware we are up */ 6195462acf6aSTony Nguyen ret = ice_send_version(pf); 6196462acf6aSTony Nguyen if (ret) { 61970fee3577SLihong Yang dev_err(dev, "Rebuild failed due to error sending driver version: %s\n", 61980fee3577SLihong Yang ice_stat_str(ret)); 6199462acf6aSTony Nguyen goto err_vsi_rebuild; 6200ce317dd9SAnirudh Venkataramanan } 6201462acf6aSTony Nguyen 6202462acf6aSTony Nguyen ice_replay_post(hw); 6203ce317dd9SAnirudh Venkataramanan 62040f9d5027SAnirudh Venkataramanan /* if we get here, reset flow is successful */ 62057e408e07SAnirudh Venkataramanan clear_bit(ICE_RESET_FAILED, pf->state); 62060b28b702SAnirudh Venkataramanan return; 62070b28b702SAnirudh Venkataramanan 62080f9d5027SAnirudh Venkataramanan err_vsi_rebuild: 62090f9d5027SAnirudh Venkataramanan err_sched_init_port: 62100f9d5027SAnirudh Venkataramanan ice_sched_cleanup_all(hw); 62110f9d5027SAnirudh Venkataramanan err_init_ctrlq: 62120b28b702SAnirudh Venkataramanan ice_shutdown_all_ctrlq(hw); 62137e408e07SAnirudh Venkataramanan set_bit(ICE_RESET_FAILED, pf->state); 62140b28b702SAnirudh Venkataramanan clear_recovery: 62150f9d5027SAnirudh Venkataramanan /* set this bit in PF state to control service task scheduling */ 62167e408e07SAnirudh Venkataramanan set_bit(ICE_NEEDS_RESTART, pf->state); 62170f9d5027SAnirudh Venkataramanan dev_err(dev, "Rebuild failed, unload and reload driver\n"); 62180b28b702SAnirudh Venkataramanan } 62190b28b702SAnirudh Venkataramanan 62200b28b702SAnirudh Venkataramanan /** 622123b44513SMaciej Fijalkowski * ice_max_xdp_frame_size - returns the maximum allowed frame size for XDP 622223b44513SMaciej Fijalkowski * @vsi: Pointer to VSI structure 622323b44513SMaciej Fijalkowski */ 622423b44513SMaciej Fijalkowski static int ice_max_xdp_frame_size(struct ice_vsi *vsi) 622523b44513SMaciej Fijalkowski { 622623b44513SMaciej Fijalkowski if (PAGE_SIZE >= 8192 || test_bit(ICE_FLAG_LEGACY_RX, vsi->back->flags)) 622723b44513SMaciej Fijalkowski return ICE_RXBUF_2048 - XDP_PACKET_HEADROOM; 622823b44513SMaciej Fijalkowski else 622923b44513SMaciej Fijalkowski return ICE_RXBUF_3072; 623023b44513SMaciej Fijalkowski } 623123b44513SMaciej Fijalkowski 623223b44513SMaciej Fijalkowski /** 6233e94d4478SAnirudh Venkataramanan * ice_change_mtu - NDO callback to change the MTU 6234e94d4478SAnirudh Venkataramanan * @netdev: network interface device structure 6235e94d4478SAnirudh Venkataramanan * @new_mtu: new value for maximum frame size 6236e94d4478SAnirudh Venkataramanan * 6237e94d4478SAnirudh Venkataramanan * Returns 0 on success, negative on failure 6238e94d4478SAnirudh Venkataramanan */ 6239e94d4478SAnirudh Venkataramanan static int ice_change_mtu(struct net_device *netdev, int new_mtu) 6240e94d4478SAnirudh Venkataramanan { 6241e94d4478SAnirudh Venkataramanan struct ice_netdev_priv *np = netdev_priv(netdev); 6242e94d4478SAnirudh Venkataramanan struct ice_vsi *vsi = np->vsi; 6243e94d4478SAnirudh Venkataramanan struct ice_pf *pf = vsi->back; 6244e94d4478SAnirudh Venkataramanan u8 count = 0; 6245e94d4478SAnirudh Venkataramanan 624622bef5e7SJesse Brandeburg if (new_mtu == (int)netdev->mtu) { 62472f2da36eSAnirudh Venkataramanan netdev_warn(netdev, "MTU is already %u\n", netdev->mtu); 6248e94d4478SAnirudh Venkataramanan return 0; 6249e94d4478SAnirudh Venkataramanan } 6250e94d4478SAnirudh Venkataramanan 6251efc2214bSMaciej Fijalkowski if (ice_is_xdp_ena_vsi(vsi)) { 625223b44513SMaciej Fijalkowski int frame_size = ice_max_xdp_frame_size(vsi); 6253efc2214bSMaciej Fijalkowski 6254efc2214bSMaciej Fijalkowski if (new_mtu + ICE_ETH_PKT_HDR_PAD > frame_size) { 6255efc2214bSMaciej Fijalkowski netdev_err(netdev, "max MTU for XDP usage is %d\n", 625623b44513SMaciej Fijalkowski frame_size - ICE_ETH_PKT_HDR_PAD); 6257efc2214bSMaciej Fijalkowski return -EINVAL; 6258efc2214bSMaciej Fijalkowski } 6259efc2214bSMaciej Fijalkowski } 6260efc2214bSMaciej Fijalkowski 6261e94d4478SAnirudh Venkataramanan /* if a reset is in progress, wait for some time for it to complete */ 6262e94d4478SAnirudh Venkataramanan do { 62635df7e45dSDave Ertman if (ice_is_reset_in_progress(pf->state)) { 6264e94d4478SAnirudh Venkataramanan count++; 6265e94d4478SAnirudh Venkataramanan usleep_range(1000, 2000); 6266e94d4478SAnirudh Venkataramanan } else { 6267e94d4478SAnirudh Venkataramanan break; 6268e94d4478SAnirudh Venkataramanan } 6269e94d4478SAnirudh Venkataramanan 6270e94d4478SAnirudh Venkataramanan } while (count < 100); 6271e94d4478SAnirudh Venkataramanan 6272e94d4478SAnirudh Venkataramanan if (count == 100) { 62732f2da36eSAnirudh Venkataramanan netdev_err(netdev, "can't change MTU. Device is busy\n"); 6274e94d4478SAnirudh Venkataramanan return -EBUSY; 6275e94d4478SAnirudh Venkataramanan } 6276e94d4478SAnirudh Venkataramanan 627722bef5e7SJesse Brandeburg netdev->mtu = (unsigned int)new_mtu; 6278e94d4478SAnirudh Venkataramanan 6279e94d4478SAnirudh Venkataramanan /* if VSI is up, bring it down and then back up */ 6280e97fb1aeSAnirudh Venkataramanan if (!test_and_set_bit(ICE_VSI_DOWN, vsi->state)) { 6281e94d4478SAnirudh Venkataramanan int err; 6282e94d4478SAnirudh Venkataramanan 6283e94d4478SAnirudh Venkataramanan err = ice_down(vsi); 6284e94d4478SAnirudh Venkataramanan if (err) { 6285fe6cd890SMitch Williams netdev_err(netdev, "change MTU if_down err %d\n", err); 6286e94d4478SAnirudh Venkataramanan return err; 6287e94d4478SAnirudh Venkataramanan } 6288e94d4478SAnirudh Venkataramanan 6289e94d4478SAnirudh Venkataramanan err = ice_up(vsi); 6290e94d4478SAnirudh Venkataramanan if (err) { 62912f2da36eSAnirudh Venkataramanan netdev_err(netdev, "change MTU if_up err %d\n", err); 6292e94d4478SAnirudh Venkataramanan return err; 6293e94d4478SAnirudh Venkataramanan } 6294e94d4478SAnirudh Venkataramanan } 6295e94d4478SAnirudh Venkataramanan 6296bda5b7dbSTony Nguyen netdev_dbg(netdev, "changed MTU to %d\n", new_mtu); 6297e94d4478SAnirudh Venkataramanan return 0; 6298e94d4478SAnirudh Venkataramanan } 6299e94d4478SAnirudh Venkataramanan 6300e94d4478SAnirudh Venkataramanan /** 63010fee3577SLihong Yang * ice_aq_str - convert AQ err code to a string 63020fee3577SLihong Yang * @aq_err: the AQ error code to convert 63030fee3577SLihong Yang */ 63040fee3577SLihong Yang const char *ice_aq_str(enum ice_aq_err aq_err) 63050fee3577SLihong Yang { 63060fee3577SLihong Yang switch (aq_err) { 63070fee3577SLihong Yang case ICE_AQ_RC_OK: 63080fee3577SLihong Yang return "OK"; 63090fee3577SLihong Yang case ICE_AQ_RC_EPERM: 63100fee3577SLihong Yang return "ICE_AQ_RC_EPERM"; 63110fee3577SLihong Yang case ICE_AQ_RC_ENOENT: 63120fee3577SLihong Yang return "ICE_AQ_RC_ENOENT"; 63130fee3577SLihong Yang case ICE_AQ_RC_ENOMEM: 63140fee3577SLihong Yang return "ICE_AQ_RC_ENOMEM"; 63150fee3577SLihong Yang case ICE_AQ_RC_EBUSY: 63160fee3577SLihong Yang return "ICE_AQ_RC_EBUSY"; 63170fee3577SLihong Yang case ICE_AQ_RC_EEXIST: 63180fee3577SLihong Yang return "ICE_AQ_RC_EEXIST"; 63190fee3577SLihong Yang case ICE_AQ_RC_EINVAL: 63200fee3577SLihong Yang return "ICE_AQ_RC_EINVAL"; 63210fee3577SLihong Yang case ICE_AQ_RC_ENOSPC: 63220fee3577SLihong Yang return "ICE_AQ_RC_ENOSPC"; 63230fee3577SLihong Yang case ICE_AQ_RC_ENOSYS: 63240fee3577SLihong Yang return "ICE_AQ_RC_ENOSYS"; 6325b5e19a64SChinh T Cao case ICE_AQ_RC_EMODE: 6326b5e19a64SChinh T Cao return "ICE_AQ_RC_EMODE"; 63270fee3577SLihong Yang case ICE_AQ_RC_ENOSEC: 63280fee3577SLihong Yang return "ICE_AQ_RC_ENOSEC"; 63290fee3577SLihong Yang case ICE_AQ_RC_EBADSIG: 63300fee3577SLihong Yang return "ICE_AQ_RC_EBADSIG"; 63310fee3577SLihong Yang case ICE_AQ_RC_ESVN: 63320fee3577SLihong Yang return "ICE_AQ_RC_ESVN"; 63330fee3577SLihong Yang case ICE_AQ_RC_EBADMAN: 63340fee3577SLihong Yang return "ICE_AQ_RC_EBADMAN"; 63350fee3577SLihong Yang case ICE_AQ_RC_EBADBUF: 63360fee3577SLihong Yang return "ICE_AQ_RC_EBADBUF"; 63370fee3577SLihong Yang } 63380fee3577SLihong Yang 63390fee3577SLihong Yang return "ICE_AQ_RC_UNKNOWN"; 63400fee3577SLihong Yang } 63410fee3577SLihong Yang 63420fee3577SLihong Yang /** 63430fee3577SLihong Yang * ice_stat_str - convert status err code to a string 63440fee3577SLihong Yang * @stat_err: the status error code to convert 63450fee3577SLihong Yang */ 63460fee3577SLihong Yang const char *ice_stat_str(enum ice_status stat_err) 63470fee3577SLihong Yang { 63480fee3577SLihong Yang switch (stat_err) { 63490fee3577SLihong Yang case ICE_SUCCESS: 63500fee3577SLihong Yang return "OK"; 63510fee3577SLihong Yang case ICE_ERR_PARAM: 63520fee3577SLihong Yang return "ICE_ERR_PARAM"; 63530fee3577SLihong Yang case ICE_ERR_NOT_IMPL: 63540fee3577SLihong Yang return "ICE_ERR_NOT_IMPL"; 63550fee3577SLihong Yang case ICE_ERR_NOT_READY: 63560fee3577SLihong Yang return "ICE_ERR_NOT_READY"; 63570fee3577SLihong Yang case ICE_ERR_NOT_SUPPORTED: 63580fee3577SLihong Yang return "ICE_ERR_NOT_SUPPORTED"; 63590fee3577SLihong Yang case ICE_ERR_BAD_PTR: 63600fee3577SLihong Yang return "ICE_ERR_BAD_PTR"; 63610fee3577SLihong Yang case ICE_ERR_INVAL_SIZE: 63620fee3577SLihong Yang return "ICE_ERR_INVAL_SIZE"; 63630fee3577SLihong Yang case ICE_ERR_DEVICE_NOT_SUPPORTED: 63640fee3577SLihong Yang return "ICE_ERR_DEVICE_NOT_SUPPORTED"; 63650fee3577SLihong Yang case ICE_ERR_RESET_FAILED: 63660fee3577SLihong Yang return "ICE_ERR_RESET_FAILED"; 63670fee3577SLihong Yang case ICE_ERR_FW_API_VER: 63680fee3577SLihong Yang return "ICE_ERR_FW_API_VER"; 63690fee3577SLihong Yang case ICE_ERR_NO_MEMORY: 63700fee3577SLihong Yang return "ICE_ERR_NO_MEMORY"; 63710fee3577SLihong Yang case ICE_ERR_CFG: 63720fee3577SLihong Yang return "ICE_ERR_CFG"; 63730fee3577SLihong Yang case ICE_ERR_OUT_OF_RANGE: 63740fee3577SLihong Yang return "ICE_ERR_OUT_OF_RANGE"; 63750fee3577SLihong Yang case ICE_ERR_ALREADY_EXISTS: 63760fee3577SLihong Yang return "ICE_ERR_ALREADY_EXISTS"; 6377e120a9abSJacob Keller case ICE_ERR_NVM: 6378e120a9abSJacob Keller return "ICE_ERR_NVM"; 63790fee3577SLihong Yang case ICE_ERR_NVM_CHECKSUM: 63800fee3577SLihong Yang return "ICE_ERR_NVM_CHECKSUM"; 63810fee3577SLihong Yang case ICE_ERR_BUF_TOO_SHORT: 63820fee3577SLihong Yang return "ICE_ERR_BUF_TOO_SHORT"; 63830fee3577SLihong Yang case ICE_ERR_NVM_BLANK_MODE: 63840fee3577SLihong Yang return "ICE_ERR_NVM_BLANK_MODE"; 63850fee3577SLihong Yang case ICE_ERR_IN_USE: 63860fee3577SLihong Yang return "ICE_ERR_IN_USE"; 63870fee3577SLihong Yang case ICE_ERR_MAX_LIMIT: 63880fee3577SLihong Yang return "ICE_ERR_MAX_LIMIT"; 63890fee3577SLihong Yang case ICE_ERR_RESET_ONGOING: 63900fee3577SLihong Yang return "ICE_ERR_RESET_ONGOING"; 63910fee3577SLihong Yang case ICE_ERR_HW_TABLE: 63920fee3577SLihong Yang return "ICE_ERR_HW_TABLE"; 63930fee3577SLihong Yang case ICE_ERR_DOES_NOT_EXIST: 63940fee3577SLihong Yang return "ICE_ERR_DOES_NOT_EXIST"; 6395b8272919SVictor Raj case ICE_ERR_FW_DDP_MISMATCH: 6396b8272919SVictor Raj return "ICE_ERR_FW_DDP_MISMATCH"; 63970fee3577SLihong Yang case ICE_ERR_AQ_ERROR: 63980fee3577SLihong Yang return "ICE_ERR_AQ_ERROR"; 63990fee3577SLihong Yang case ICE_ERR_AQ_TIMEOUT: 64000fee3577SLihong Yang return "ICE_ERR_AQ_TIMEOUT"; 64010fee3577SLihong Yang case ICE_ERR_AQ_FULL: 64020fee3577SLihong Yang return "ICE_ERR_AQ_FULL"; 64030fee3577SLihong Yang case ICE_ERR_AQ_NO_WORK: 64040fee3577SLihong Yang return "ICE_ERR_AQ_NO_WORK"; 64050fee3577SLihong Yang case ICE_ERR_AQ_EMPTY: 64060fee3577SLihong Yang return "ICE_ERR_AQ_EMPTY"; 6407b5c7f857SEvan Swanson case ICE_ERR_AQ_FW_CRITICAL: 6408b5c7f857SEvan Swanson return "ICE_ERR_AQ_FW_CRITICAL"; 64090fee3577SLihong Yang } 64100fee3577SLihong Yang 64110fee3577SLihong Yang return "ICE_ERR_UNKNOWN"; 64120fee3577SLihong Yang } 64130fee3577SLihong Yang 64140fee3577SLihong Yang /** 6415b66a972aSBrett Creeley * ice_set_rss_lut - Set RSS LUT 6416d76a60baSAnirudh Venkataramanan * @vsi: Pointer to VSI structure 6417d76a60baSAnirudh Venkataramanan * @lut: Lookup table 6418d76a60baSAnirudh Venkataramanan * @lut_size: Lookup table size 6419d76a60baSAnirudh Venkataramanan * 6420d76a60baSAnirudh Venkataramanan * Returns 0 on success, negative on failure 6421d76a60baSAnirudh Venkataramanan */ 6422b66a972aSBrett Creeley int ice_set_rss_lut(struct ice_vsi *vsi, u8 *lut, u16 lut_size) 6423d76a60baSAnirudh Venkataramanan { 6424b66a972aSBrett Creeley struct ice_aq_get_set_rss_lut_params params = {}; 6425b66a972aSBrett Creeley struct ice_hw *hw = &vsi->back->hw; 6426d76a60baSAnirudh Venkataramanan enum ice_status status; 6427d76a60baSAnirudh Venkataramanan 6428b66a972aSBrett Creeley if (!lut) 6429b66a972aSBrett Creeley return -EINVAL; 6430d76a60baSAnirudh Venkataramanan 6431b66a972aSBrett Creeley params.vsi_handle = vsi->idx; 6432b66a972aSBrett Creeley params.lut_size = lut_size; 6433b66a972aSBrett Creeley params.lut_type = vsi->rss_lut_type; 6434b66a972aSBrett Creeley params.lut = lut; 6435d76a60baSAnirudh Venkataramanan 6436b66a972aSBrett Creeley status = ice_aq_set_rss_lut(hw, ¶ms); 6437d76a60baSAnirudh Venkataramanan if (status) { 6438b66a972aSBrett Creeley dev_err(ice_pf_to_dev(vsi->back), "Cannot set RSS lut, err %s aq_err %s\n", 64390fee3577SLihong Yang ice_stat_str(status), 64409d68a79cSJesse Brandeburg ice_aq_str(hw->adminq.sq_last_status)); 6441d76a60baSAnirudh Venkataramanan return -EIO; 6442d76a60baSAnirudh Venkataramanan } 6443d76a60baSAnirudh Venkataramanan 6444d76a60baSAnirudh Venkataramanan return 0; 6445d76a60baSAnirudh Venkataramanan } 6446d76a60baSAnirudh Venkataramanan 6447d76a60baSAnirudh Venkataramanan /** 6448b66a972aSBrett Creeley * ice_set_rss_key - Set RSS key 6449b66a972aSBrett Creeley * @vsi: Pointer to the VSI structure 6450b66a972aSBrett Creeley * @seed: RSS hash seed 6451b66a972aSBrett Creeley * 6452b66a972aSBrett Creeley * Returns 0 on success, negative on failure 6453b66a972aSBrett Creeley */ 6454b66a972aSBrett Creeley int ice_set_rss_key(struct ice_vsi *vsi, u8 *seed) 6455b66a972aSBrett Creeley { 6456b66a972aSBrett Creeley struct ice_hw *hw = &vsi->back->hw; 6457b66a972aSBrett Creeley enum ice_status status; 6458b66a972aSBrett Creeley 6459b66a972aSBrett Creeley if (!seed) 6460b66a972aSBrett Creeley return -EINVAL; 6461b66a972aSBrett Creeley 6462b66a972aSBrett Creeley status = ice_aq_set_rss_key(hw, vsi->idx, (struct ice_aqc_get_set_rss_keys *)seed); 6463b66a972aSBrett Creeley if (status) { 6464b66a972aSBrett Creeley dev_err(ice_pf_to_dev(vsi->back), "Cannot set RSS key, err %s aq_err %s\n", 6465b66a972aSBrett Creeley ice_stat_str(status), 6466b66a972aSBrett Creeley ice_aq_str(hw->adminq.sq_last_status)); 6467b66a972aSBrett Creeley return -EIO; 6468b66a972aSBrett Creeley } 6469b66a972aSBrett Creeley 6470b66a972aSBrett Creeley return 0; 6471b66a972aSBrett Creeley } 6472b66a972aSBrett Creeley 6473b66a972aSBrett Creeley /** 6474b66a972aSBrett Creeley * ice_get_rss_lut - Get RSS LUT 6475d76a60baSAnirudh Venkataramanan * @vsi: Pointer to VSI structure 6476d76a60baSAnirudh Venkataramanan * @lut: Buffer to store the lookup table entries 6477d76a60baSAnirudh Venkataramanan * @lut_size: Size of buffer to store the lookup table entries 6478d76a60baSAnirudh Venkataramanan * 6479d76a60baSAnirudh Venkataramanan * Returns 0 on success, negative on failure 6480d76a60baSAnirudh Venkataramanan */ 6481b66a972aSBrett Creeley int ice_get_rss_lut(struct ice_vsi *vsi, u8 *lut, u16 lut_size) 6482d76a60baSAnirudh Venkataramanan { 6483b66a972aSBrett Creeley struct ice_aq_get_set_rss_lut_params params = {}; 6484b66a972aSBrett Creeley struct ice_hw *hw = &vsi->back->hw; 6485d76a60baSAnirudh Venkataramanan enum ice_status status; 6486d76a60baSAnirudh Venkataramanan 6487b66a972aSBrett Creeley if (!lut) 6488b66a972aSBrett Creeley return -EINVAL; 6489d76a60baSAnirudh Venkataramanan 6490b66a972aSBrett Creeley params.vsi_handle = vsi->idx; 6491b66a972aSBrett Creeley params.lut_size = lut_size; 6492b66a972aSBrett Creeley params.lut_type = vsi->rss_lut_type; 6493b66a972aSBrett Creeley params.lut = lut; 6494b66a972aSBrett Creeley 6495b66a972aSBrett Creeley status = ice_aq_get_rss_lut(hw, ¶ms); 6496d76a60baSAnirudh Venkataramanan if (status) { 6497b66a972aSBrett Creeley dev_err(ice_pf_to_dev(vsi->back), "Cannot get RSS lut, err %s aq_err %s\n", 64980fee3577SLihong Yang ice_stat_str(status), 64999d68a79cSJesse Brandeburg ice_aq_str(hw->adminq.sq_last_status)); 6500d76a60baSAnirudh Venkataramanan return -EIO; 6501d76a60baSAnirudh Venkataramanan } 6502b66a972aSBrett Creeley 6503b66a972aSBrett Creeley return 0; 6504d76a60baSAnirudh Venkataramanan } 6505d76a60baSAnirudh Venkataramanan 6506b66a972aSBrett Creeley /** 6507b66a972aSBrett Creeley * ice_get_rss_key - Get RSS key 6508b66a972aSBrett Creeley * @vsi: Pointer to VSI structure 6509b66a972aSBrett Creeley * @seed: Buffer to store the key in 6510b66a972aSBrett Creeley * 6511b66a972aSBrett Creeley * Returns 0 on success, negative on failure 6512b66a972aSBrett Creeley */ 6513b66a972aSBrett Creeley int ice_get_rss_key(struct ice_vsi *vsi, u8 *seed) 6514b66a972aSBrett Creeley { 6515b66a972aSBrett Creeley struct ice_hw *hw = &vsi->back->hw; 6516b66a972aSBrett Creeley enum ice_status status; 6517e3c53928SBrett Creeley 6518b66a972aSBrett Creeley if (!seed) 6519b66a972aSBrett Creeley return -EINVAL; 6520b66a972aSBrett Creeley 6521b66a972aSBrett Creeley status = ice_aq_get_rss_key(hw, vsi->idx, (struct ice_aqc_get_set_rss_keys *)seed); 6522d76a60baSAnirudh Venkataramanan if (status) { 6523b66a972aSBrett Creeley dev_err(ice_pf_to_dev(vsi->back), "Cannot get RSS key, err %s aq_err %s\n", 65240fee3577SLihong Yang ice_stat_str(status), 65259d68a79cSJesse Brandeburg ice_aq_str(hw->adminq.sq_last_status)); 6526d76a60baSAnirudh Venkataramanan return -EIO; 6527d76a60baSAnirudh Venkataramanan } 6528d76a60baSAnirudh Venkataramanan 6529d76a60baSAnirudh Venkataramanan return 0; 6530d76a60baSAnirudh Venkataramanan } 6531d76a60baSAnirudh Venkataramanan 6532d76a60baSAnirudh Venkataramanan /** 6533b1edc14aSMd Fahad Iqbal Polash * ice_bridge_getlink - Get the hardware bridge mode 6534b1edc14aSMd Fahad Iqbal Polash * @skb: skb buff 6535f9867df6SAnirudh Venkataramanan * @pid: process ID 6536b1edc14aSMd Fahad Iqbal Polash * @seq: RTNL message seq 6537b1edc14aSMd Fahad Iqbal Polash * @dev: the netdev being configured 6538b1edc14aSMd Fahad Iqbal Polash * @filter_mask: filter mask passed in 6539b1edc14aSMd Fahad Iqbal Polash * @nlflags: netlink flags passed in 6540b1edc14aSMd Fahad Iqbal Polash * 6541b1edc14aSMd Fahad Iqbal Polash * Return the bridge mode (VEB/VEPA) 6542b1edc14aSMd Fahad Iqbal Polash */ 6543b1edc14aSMd Fahad Iqbal Polash static int 6544b1edc14aSMd Fahad Iqbal Polash ice_bridge_getlink(struct sk_buff *skb, u32 pid, u32 seq, 6545b1edc14aSMd Fahad Iqbal Polash struct net_device *dev, u32 filter_mask, int nlflags) 6546b1edc14aSMd Fahad Iqbal Polash { 6547b1edc14aSMd Fahad Iqbal Polash struct ice_netdev_priv *np = netdev_priv(dev); 6548b1edc14aSMd Fahad Iqbal Polash struct ice_vsi *vsi = np->vsi; 6549b1edc14aSMd Fahad Iqbal Polash struct ice_pf *pf = vsi->back; 6550b1edc14aSMd Fahad Iqbal Polash u16 bmode; 6551b1edc14aSMd Fahad Iqbal Polash 6552b1edc14aSMd Fahad Iqbal Polash bmode = pf->first_sw->bridge_mode; 6553b1edc14aSMd Fahad Iqbal Polash 6554b1edc14aSMd Fahad Iqbal Polash return ndo_dflt_bridge_getlink(skb, pid, seq, dev, bmode, 0, 0, nlflags, 6555b1edc14aSMd Fahad Iqbal Polash filter_mask, NULL); 6556b1edc14aSMd Fahad Iqbal Polash } 6557b1edc14aSMd Fahad Iqbal Polash 6558b1edc14aSMd Fahad Iqbal Polash /** 6559b1edc14aSMd Fahad Iqbal Polash * ice_vsi_update_bridge_mode - Update VSI for switching bridge mode (VEB/VEPA) 6560b1edc14aSMd Fahad Iqbal Polash * @vsi: Pointer to VSI structure 6561b1edc14aSMd Fahad Iqbal Polash * @bmode: Hardware bridge mode (VEB/VEPA) 6562b1edc14aSMd Fahad Iqbal Polash * 6563b1edc14aSMd Fahad Iqbal Polash * Returns 0 on success, negative on failure 6564b1edc14aSMd Fahad Iqbal Polash */ 6565b1edc14aSMd Fahad Iqbal Polash static int ice_vsi_update_bridge_mode(struct ice_vsi *vsi, u16 bmode) 6566b1edc14aSMd Fahad Iqbal Polash { 6567b1edc14aSMd Fahad Iqbal Polash struct ice_aqc_vsi_props *vsi_props; 6568b1edc14aSMd Fahad Iqbal Polash struct ice_hw *hw = &vsi->back->hw; 6569198a666aSBruce Allan struct ice_vsi_ctx *ctxt; 6570b1edc14aSMd Fahad Iqbal Polash enum ice_status status; 6571198a666aSBruce Allan int ret = 0; 6572b1edc14aSMd Fahad Iqbal Polash 6573b1edc14aSMd Fahad Iqbal Polash vsi_props = &vsi->info; 6574198a666aSBruce Allan 65759efe35d0STony Nguyen ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL); 6576198a666aSBruce Allan if (!ctxt) 6577198a666aSBruce Allan return -ENOMEM; 6578198a666aSBruce Allan 6579198a666aSBruce Allan ctxt->info = vsi->info; 6580b1edc14aSMd Fahad Iqbal Polash 6581b1edc14aSMd Fahad Iqbal Polash if (bmode == BRIDGE_MODE_VEB) 6582b1edc14aSMd Fahad Iqbal Polash /* change from VEPA to VEB mode */ 6583198a666aSBruce Allan ctxt->info.sw_flags |= ICE_AQ_VSI_SW_FLAG_ALLOW_LB; 6584b1edc14aSMd Fahad Iqbal Polash else 6585b1edc14aSMd Fahad Iqbal Polash /* change from VEB to VEPA mode */ 6586198a666aSBruce Allan ctxt->info.sw_flags &= ~ICE_AQ_VSI_SW_FLAG_ALLOW_LB; 6587198a666aSBruce Allan ctxt->info.valid_sections = cpu_to_le16(ICE_AQ_VSI_PROP_SW_VALID); 65885726ca0eSAnirudh Venkataramanan 6589198a666aSBruce Allan status = ice_update_vsi(hw, vsi->idx, ctxt, NULL); 6590b1edc14aSMd Fahad Iqbal Polash if (status) { 65910fee3577SLihong Yang dev_err(ice_pf_to_dev(vsi->back), "update VSI for bridge mode failed, bmode = %d err %s aq_err %s\n", 65920fee3577SLihong Yang bmode, ice_stat_str(status), 65930fee3577SLihong Yang ice_aq_str(hw->adminq.sq_last_status)); 6594198a666aSBruce Allan ret = -EIO; 6595198a666aSBruce Allan goto out; 6596b1edc14aSMd Fahad Iqbal Polash } 6597b1edc14aSMd Fahad Iqbal Polash /* Update sw flags for book keeping */ 6598198a666aSBruce Allan vsi_props->sw_flags = ctxt->info.sw_flags; 6599b1edc14aSMd Fahad Iqbal Polash 6600198a666aSBruce Allan out: 66019efe35d0STony Nguyen kfree(ctxt); 6602198a666aSBruce Allan return ret; 6603b1edc14aSMd Fahad Iqbal Polash } 6604b1edc14aSMd Fahad Iqbal Polash 6605b1edc14aSMd Fahad Iqbal Polash /** 6606b1edc14aSMd Fahad Iqbal Polash * ice_bridge_setlink - Set the hardware bridge mode 6607b1edc14aSMd Fahad Iqbal Polash * @dev: the netdev being configured 6608b1edc14aSMd Fahad Iqbal Polash * @nlh: RTNL message 6609b1edc14aSMd Fahad Iqbal Polash * @flags: bridge setlink flags 66102fd527b7SPetr Machata * @extack: netlink extended ack 6611b1edc14aSMd Fahad Iqbal Polash * 6612b1edc14aSMd Fahad Iqbal Polash * Sets the bridge mode (VEB/VEPA) of the switch to which the netdev (VSI) is 6613b1edc14aSMd Fahad Iqbal Polash * hooked up to. Iterates through the PF VSI list and sets the loopback mode (if 6614b1edc14aSMd Fahad Iqbal Polash * not already set for all VSIs connected to this switch. And also update the 6615b1edc14aSMd Fahad Iqbal Polash * unicast switch filter rules for the corresponding switch of the netdev. 6616b1edc14aSMd Fahad Iqbal Polash */ 6617b1edc14aSMd Fahad Iqbal Polash static int 6618b1edc14aSMd Fahad Iqbal Polash ice_bridge_setlink(struct net_device *dev, struct nlmsghdr *nlh, 66193d505147SBruce Allan u16 __always_unused flags, 66203d505147SBruce Allan struct netlink_ext_ack __always_unused *extack) 6621b1edc14aSMd Fahad Iqbal Polash { 6622b1edc14aSMd Fahad Iqbal Polash struct ice_netdev_priv *np = netdev_priv(dev); 6623b1edc14aSMd Fahad Iqbal Polash struct ice_pf *pf = np->vsi->back; 6624b1edc14aSMd Fahad Iqbal Polash struct nlattr *attr, *br_spec; 6625b1edc14aSMd Fahad Iqbal Polash struct ice_hw *hw = &pf->hw; 6626b1edc14aSMd Fahad Iqbal Polash enum ice_status status; 6627b1edc14aSMd Fahad Iqbal Polash struct ice_sw *pf_sw; 6628b1edc14aSMd Fahad Iqbal Polash int rem, v, err = 0; 6629b1edc14aSMd Fahad Iqbal Polash 6630b1edc14aSMd Fahad Iqbal Polash pf_sw = pf->first_sw; 6631b1edc14aSMd Fahad Iqbal Polash /* find the attribute in the netlink message */ 6632b1edc14aSMd Fahad Iqbal Polash br_spec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC); 6633b1edc14aSMd Fahad Iqbal Polash 6634b1edc14aSMd Fahad Iqbal Polash nla_for_each_nested(attr, br_spec, rem) { 6635b1edc14aSMd Fahad Iqbal Polash __u16 mode; 6636b1edc14aSMd Fahad Iqbal Polash 6637b1edc14aSMd Fahad Iqbal Polash if (nla_type(attr) != IFLA_BRIDGE_MODE) 6638b1edc14aSMd Fahad Iqbal Polash continue; 6639b1edc14aSMd Fahad Iqbal Polash mode = nla_get_u16(attr); 6640b1edc14aSMd Fahad Iqbal Polash if (mode != BRIDGE_MODE_VEPA && mode != BRIDGE_MODE_VEB) 6641b1edc14aSMd Fahad Iqbal Polash return -EINVAL; 6642b1edc14aSMd Fahad Iqbal Polash /* Continue if bridge mode is not being flipped */ 6643b1edc14aSMd Fahad Iqbal Polash if (mode == pf_sw->bridge_mode) 6644b1edc14aSMd Fahad Iqbal Polash continue; 6645b1edc14aSMd Fahad Iqbal Polash /* Iterates through the PF VSI list and update the loopback 6646b1edc14aSMd Fahad Iqbal Polash * mode of the VSI 6647b1edc14aSMd Fahad Iqbal Polash */ 6648b1edc14aSMd Fahad Iqbal Polash ice_for_each_vsi(pf, v) { 6649b1edc14aSMd Fahad Iqbal Polash if (!pf->vsi[v]) 6650b1edc14aSMd Fahad Iqbal Polash continue; 6651b1edc14aSMd Fahad Iqbal Polash err = ice_vsi_update_bridge_mode(pf->vsi[v], mode); 6652b1edc14aSMd Fahad Iqbal Polash if (err) 6653b1edc14aSMd Fahad Iqbal Polash return err; 6654b1edc14aSMd Fahad Iqbal Polash } 6655b1edc14aSMd Fahad Iqbal Polash 6656b1edc14aSMd Fahad Iqbal Polash hw->evb_veb = (mode == BRIDGE_MODE_VEB); 6657b1edc14aSMd Fahad Iqbal Polash /* Update the unicast switch filter rules for the corresponding 6658b1edc14aSMd Fahad Iqbal Polash * switch of the netdev 6659b1edc14aSMd Fahad Iqbal Polash */ 6660b1edc14aSMd Fahad Iqbal Polash status = ice_update_sw_rule_bridge_mode(hw); 6661b1edc14aSMd Fahad Iqbal Polash if (status) { 66620fee3577SLihong Yang netdev_err(dev, "switch rule update failed, mode = %d err %s aq_err %s\n", 66630fee3577SLihong Yang mode, ice_stat_str(status), 66640fee3577SLihong Yang ice_aq_str(hw->adminq.sq_last_status)); 6665b1edc14aSMd Fahad Iqbal Polash /* revert hw->evb_veb */ 6666b1edc14aSMd Fahad Iqbal Polash hw->evb_veb = (pf_sw->bridge_mode == BRIDGE_MODE_VEB); 6667b1edc14aSMd Fahad Iqbal Polash return -EIO; 6668b1edc14aSMd Fahad Iqbal Polash } 6669b1edc14aSMd Fahad Iqbal Polash 6670b1edc14aSMd Fahad Iqbal Polash pf_sw->bridge_mode = mode; 6671b1edc14aSMd Fahad Iqbal Polash } 6672b1edc14aSMd Fahad Iqbal Polash 6673b1edc14aSMd Fahad Iqbal Polash return 0; 6674b1edc14aSMd Fahad Iqbal Polash } 6675b1edc14aSMd Fahad Iqbal Polash 6676b1edc14aSMd Fahad Iqbal Polash /** 6677b3969fd7SSudheer Mogilappagari * ice_tx_timeout - Respond to a Tx Hang 6678b3969fd7SSudheer Mogilappagari * @netdev: network interface device structure 6679644f40eaSBruce Allan * @txqueue: Tx queue 6680b3969fd7SSudheer Mogilappagari */ 66810290bd29SMichael S. Tsirkin static void ice_tx_timeout(struct net_device *netdev, unsigned int txqueue) 6682b3969fd7SSudheer Mogilappagari { 6683b3969fd7SSudheer Mogilappagari struct ice_netdev_priv *np = netdev_priv(netdev); 6684b3969fd7SSudheer Mogilappagari struct ice_ring *tx_ring = NULL; 6685b3969fd7SSudheer Mogilappagari struct ice_vsi *vsi = np->vsi; 6686b3969fd7SSudheer Mogilappagari struct ice_pf *pf = vsi->back; 6687807bc98dSBrett Creeley u32 i; 6688b3969fd7SSudheer Mogilappagari 6689b3969fd7SSudheer Mogilappagari pf->tx_timeout_count++; 6690b3969fd7SSudheer Mogilappagari 6691610ed0e9SAvinash JD /* Check if PFC is enabled for the TC to which the queue belongs 6692610ed0e9SAvinash JD * to. If yes then Tx timeout is not caused by a hung queue, no 6693610ed0e9SAvinash JD * need to reset and rebuild 6694610ed0e9SAvinash JD */ 6695610ed0e9SAvinash JD if (ice_is_pfc_causing_hung_q(pf, txqueue)) { 6696610ed0e9SAvinash JD dev_info(ice_pf_to_dev(pf), "Fake Tx hang detected on queue %u, timeout caused by PFC storm\n", 6697610ed0e9SAvinash JD txqueue); 6698610ed0e9SAvinash JD return; 6699610ed0e9SAvinash JD } 6700610ed0e9SAvinash JD 6701b3969fd7SSudheer Mogilappagari /* now that we have an index, find the tx_ring struct */ 6702bc0c6fabSBruce Allan for (i = 0; i < vsi->num_txq; i++) 6703bc0c6fabSBruce Allan if (vsi->tx_rings[i] && vsi->tx_rings[i]->desc) 6704ed5a3f66SJulio Faracco if (txqueue == vsi->tx_rings[i]->q_index) { 6705b3969fd7SSudheer Mogilappagari tx_ring = vsi->tx_rings[i]; 6706b3969fd7SSudheer Mogilappagari break; 6707b3969fd7SSudheer Mogilappagari } 6708b3969fd7SSudheer Mogilappagari 6709b3969fd7SSudheer Mogilappagari /* Reset recovery level if enough time has elapsed after last timeout. 6710b3969fd7SSudheer Mogilappagari * Also ensure no new reset action happens before next timeout period. 6711b3969fd7SSudheer Mogilappagari */ 6712b3969fd7SSudheer Mogilappagari if (time_after(jiffies, (pf->tx_timeout_last_recovery + HZ * 20))) 6713b3969fd7SSudheer Mogilappagari pf->tx_timeout_recovery_level = 1; 6714b3969fd7SSudheer Mogilappagari else if (time_before(jiffies, (pf->tx_timeout_last_recovery + 6715b3969fd7SSudheer Mogilappagari netdev->watchdog_timeo))) 6716b3969fd7SSudheer Mogilappagari return; 6717b3969fd7SSudheer Mogilappagari 6718b3969fd7SSudheer Mogilappagari if (tx_ring) { 6719807bc98dSBrett Creeley struct ice_hw *hw = &pf->hw; 6720807bc98dSBrett Creeley u32 head, val = 0; 6721807bc98dSBrett Creeley 6722ed5a3f66SJulio Faracco head = (rd32(hw, QTX_COMM_HEAD(vsi->txq_map[txqueue])) & 6723807bc98dSBrett Creeley QTX_COMM_HEAD_HEAD_M) >> QTX_COMM_HEAD_HEAD_S; 6724b3969fd7SSudheer Mogilappagari /* Read interrupt register */ 6725ba880734SBrett Creeley val = rd32(hw, GLINT_DYN_CTL(tx_ring->q_vector->reg_idx)); 6726b3969fd7SSudheer Mogilappagari 672793ff4858STony 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", 6728ed5a3f66SJulio Faracco vsi->vsi_num, txqueue, tx_ring->next_to_clean, 6729807bc98dSBrett Creeley head, tx_ring->next_to_use, val); 6730b3969fd7SSudheer Mogilappagari } 6731b3969fd7SSudheer Mogilappagari 6732b3969fd7SSudheer Mogilappagari pf->tx_timeout_last_recovery = jiffies; 673393ff4858STony Nguyen netdev_info(netdev, "tx_timeout recovery level %d, txqueue %u\n", 6734ed5a3f66SJulio Faracco pf->tx_timeout_recovery_level, txqueue); 6735b3969fd7SSudheer Mogilappagari 6736b3969fd7SSudheer Mogilappagari switch (pf->tx_timeout_recovery_level) { 6737b3969fd7SSudheer Mogilappagari case 1: 67387e408e07SAnirudh Venkataramanan set_bit(ICE_PFR_REQ, pf->state); 6739b3969fd7SSudheer Mogilappagari break; 6740b3969fd7SSudheer Mogilappagari case 2: 67417e408e07SAnirudh Venkataramanan set_bit(ICE_CORER_REQ, pf->state); 6742b3969fd7SSudheer Mogilappagari break; 6743b3969fd7SSudheer Mogilappagari case 3: 67447e408e07SAnirudh Venkataramanan set_bit(ICE_GLOBR_REQ, pf->state); 6745b3969fd7SSudheer Mogilappagari break; 6746b3969fd7SSudheer Mogilappagari default: 6747b3969fd7SSudheer Mogilappagari netdev_err(netdev, "tx_timeout recovery unsuccessful, device is in unrecoverable state.\n"); 67487e408e07SAnirudh Venkataramanan set_bit(ICE_DOWN, pf->state); 6749e97fb1aeSAnirudh Venkataramanan set_bit(ICE_VSI_NEEDS_RESTART, vsi->state); 67507e408e07SAnirudh Venkataramanan set_bit(ICE_SERVICE_DIS, pf->state); 6751b3969fd7SSudheer Mogilappagari break; 6752b3969fd7SSudheer Mogilappagari } 6753b3969fd7SSudheer Mogilappagari 6754b3969fd7SSudheer Mogilappagari ice_service_task_schedule(pf); 6755b3969fd7SSudheer Mogilappagari pf->tx_timeout_recovery_level++; 6756b3969fd7SSudheer Mogilappagari } 6757b3969fd7SSudheer Mogilappagari 6758b3969fd7SSudheer Mogilappagari /** 6759cdedef59SAnirudh Venkataramanan * ice_open - Called when a network interface becomes active 6760cdedef59SAnirudh Venkataramanan * @netdev: network interface device structure 6761cdedef59SAnirudh Venkataramanan * 6762cdedef59SAnirudh Venkataramanan * The open entry point is called when a network interface is made 6763cdedef59SAnirudh Venkataramanan * active by the system (IFF_UP). At this point all resources needed 6764cdedef59SAnirudh Venkataramanan * for transmit and receive operations are allocated, the interrupt 6765cdedef59SAnirudh Venkataramanan * handler is registered with the OS, the netdev watchdog is enabled, 6766cdedef59SAnirudh Venkataramanan * and the stack is notified that the interface is ready. 6767cdedef59SAnirudh Venkataramanan * 6768cdedef59SAnirudh Venkataramanan * Returns 0 on success, negative value on failure 6769cdedef59SAnirudh Venkataramanan */ 67700e674aebSAnirudh Venkataramanan int ice_open(struct net_device *netdev) 6771cdedef59SAnirudh Venkataramanan { 6772cdedef59SAnirudh Venkataramanan struct ice_netdev_priv *np = netdev_priv(netdev); 6773e95fc857SKrzysztof Goreczny struct ice_pf *pf = np->vsi->back; 6774e95fc857SKrzysztof Goreczny 6775e95fc857SKrzysztof Goreczny if (ice_is_reset_in_progress(pf->state)) { 6776e95fc857SKrzysztof Goreczny netdev_err(netdev, "can't open net device while reset is in progress"); 6777e95fc857SKrzysztof Goreczny return -EBUSY; 6778e95fc857SKrzysztof Goreczny } 6779e95fc857SKrzysztof Goreczny 6780e95fc857SKrzysztof Goreczny return ice_open_internal(netdev); 6781e95fc857SKrzysztof Goreczny } 6782e95fc857SKrzysztof Goreczny 6783e95fc857SKrzysztof Goreczny /** 6784e95fc857SKrzysztof Goreczny * ice_open_internal - Called when a network interface becomes active 6785e95fc857SKrzysztof Goreczny * @netdev: network interface device structure 6786e95fc857SKrzysztof Goreczny * 6787e95fc857SKrzysztof Goreczny * Internal ice_open implementation. Should not be used directly except for ice_open and reset 6788e95fc857SKrzysztof Goreczny * handling routine 6789e95fc857SKrzysztof Goreczny * 6790e95fc857SKrzysztof Goreczny * Returns 0 on success, negative value on failure 6791e95fc857SKrzysztof Goreczny */ 6792e95fc857SKrzysztof Goreczny int ice_open_internal(struct net_device *netdev) 6793e95fc857SKrzysztof Goreczny { 6794e95fc857SKrzysztof Goreczny struct ice_netdev_priv *np = netdev_priv(netdev); 6795cdedef59SAnirudh Venkataramanan struct ice_vsi *vsi = np->vsi; 6796de75135bSAnirudh Venkataramanan struct ice_pf *pf = vsi->back; 67976d599946STony Nguyen struct ice_port_info *pi; 6798d348d517SAnirudh Venkataramanan enum ice_status status; 6799cdedef59SAnirudh Venkataramanan int err; 6800cdedef59SAnirudh Venkataramanan 68017e408e07SAnirudh Venkataramanan if (test_bit(ICE_NEEDS_RESTART, pf->state)) { 68020f9d5027SAnirudh Venkataramanan netdev_err(netdev, "driver needs to be unloaded and reloaded\n"); 68030f9d5027SAnirudh Venkataramanan return -EIO; 68040f9d5027SAnirudh Venkataramanan } 68050f9d5027SAnirudh Venkataramanan 6806cdedef59SAnirudh Venkataramanan netif_carrier_off(netdev); 6807cdedef59SAnirudh Venkataramanan 68086d599946STony Nguyen pi = vsi->port_info; 6809d348d517SAnirudh Venkataramanan status = ice_update_link_info(pi); 6810d348d517SAnirudh Venkataramanan if (status) { 6811d348d517SAnirudh Venkataramanan netdev_err(netdev, "Failed to get link info, error %s\n", 6812d348d517SAnirudh Venkataramanan ice_stat_str(status)); 6813d348d517SAnirudh Venkataramanan return -EIO; 68146d599946STony Nguyen } 68156d599946STony Nguyen 68166d599946STony Nguyen /* Set PHY if there is media, otherwise, turn off PHY */ 68176d599946STony Nguyen if (pi->phy.link_info.link_info & ICE_AQ_MEDIA_AVAILABLE) { 68181a3571b5SPaul Greenwalt clear_bit(ICE_FLAG_NO_MEDIA, pf->flags); 68197e408e07SAnirudh Venkataramanan if (!test_bit(ICE_PHY_INIT_COMPLETE, pf->state)) { 68201a3571b5SPaul Greenwalt err = ice_init_phy_user_cfg(pi); 68211a3571b5SPaul Greenwalt if (err) { 68221a3571b5SPaul Greenwalt netdev_err(netdev, "Failed to initialize PHY settings, error %d\n", 68231a3571b5SPaul Greenwalt err); 68241a3571b5SPaul Greenwalt return err; 68251a3571b5SPaul Greenwalt } 68261a3571b5SPaul Greenwalt } 68271a3571b5SPaul Greenwalt 68281a3571b5SPaul Greenwalt err = ice_configure_phy(vsi); 6829b6f934f0SBrett Creeley if (err) { 683019cce2c6SAnirudh Venkataramanan netdev_err(netdev, "Failed to set physical link up, error %d\n", 68316d599946STony Nguyen err); 6832b6f934f0SBrett Creeley return err; 6833b6f934f0SBrett Creeley } 68346d599946STony Nguyen } else { 68351a3571b5SPaul Greenwalt set_bit(ICE_FLAG_NO_MEDIA, pf->flags); 6836d348d517SAnirudh Venkataramanan ice_set_link(vsi, false); 68376d599946STony Nguyen } 6838cdedef59SAnirudh Venkataramanan 6839b6f934f0SBrett Creeley err = ice_vsi_open(vsi); 6840cdedef59SAnirudh Venkataramanan if (err) 6841cdedef59SAnirudh Venkataramanan netdev_err(netdev, "Failed to open VSI 0x%04X on switch 0x%04X\n", 6842cdedef59SAnirudh Venkataramanan vsi->vsi_num, vsi->vsw->sw_id); 6843a4e82a81STony Nguyen 6844a4e82a81STony Nguyen /* Update existing tunnels information */ 6845a4e82a81STony Nguyen udp_tunnel_get_rx_info(netdev); 6846a4e82a81STony Nguyen 6847cdedef59SAnirudh Venkataramanan return err; 6848cdedef59SAnirudh Venkataramanan } 6849cdedef59SAnirudh Venkataramanan 6850cdedef59SAnirudh Venkataramanan /** 6851cdedef59SAnirudh Venkataramanan * ice_stop - Disables a network interface 6852cdedef59SAnirudh Venkataramanan * @netdev: network interface device structure 6853cdedef59SAnirudh Venkataramanan * 6854cdedef59SAnirudh Venkataramanan * The stop entry point is called when an interface is de-activated by the OS, 6855cdedef59SAnirudh Venkataramanan * and the netdevice enters the DOWN state. The hardware is still under the 6856cdedef59SAnirudh Venkataramanan * driver's control, but the netdev interface is disabled. 6857cdedef59SAnirudh Venkataramanan * 6858cdedef59SAnirudh Venkataramanan * Returns success only - not allowed to fail 6859cdedef59SAnirudh Venkataramanan */ 68600e674aebSAnirudh Venkataramanan int ice_stop(struct net_device *netdev) 6861cdedef59SAnirudh Venkataramanan { 6862cdedef59SAnirudh Venkataramanan struct ice_netdev_priv *np = netdev_priv(netdev); 6863cdedef59SAnirudh Venkataramanan struct ice_vsi *vsi = np->vsi; 6864e95fc857SKrzysztof Goreczny struct ice_pf *pf = vsi->back; 6865e95fc857SKrzysztof Goreczny 6866e95fc857SKrzysztof Goreczny if (ice_is_reset_in_progress(pf->state)) { 6867e95fc857SKrzysztof Goreczny netdev_err(netdev, "can't stop net device while reset is in progress"); 6868e95fc857SKrzysztof Goreczny return -EBUSY; 6869e95fc857SKrzysztof Goreczny } 6870cdedef59SAnirudh Venkataramanan 6871cdedef59SAnirudh Venkataramanan ice_vsi_close(vsi); 6872cdedef59SAnirudh Venkataramanan 6873cdedef59SAnirudh Venkataramanan return 0; 6874cdedef59SAnirudh Venkataramanan } 6875cdedef59SAnirudh Venkataramanan 6876e94d4478SAnirudh Venkataramanan /** 6877e94d4478SAnirudh Venkataramanan * ice_features_check - Validate encapsulated packet conforms to limits 6878e94d4478SAnirudh Venkataramanan * @skb: skb buffer 6879e94d4478SAnirudh Venkataramanan * @netdev: This port's netdev 6880e94d4478SAnirudh Venkataramanan * @features: Offload features that the stack believes apply 6881e94d4478SAnirudh Venkataramanan */ 6882e94d4478SAnirudh Venkataramanan static netdev_features_t 6883e94d4478SAnirudh Venkataramanan ice_features_check(struct sk_buff *skb, 6884e94d4478SAnirudh Venkataramanan struct net_device __always_unused *netdev, 6885e94d4478SAnirudh Venkataramanan netdev_features_t features) 6886e94d4478SAnirudh Venkataramanan { 6887e94d4478SAnirudh Venkataramanan size_t len; 6888e94d4478SAnirudh Venkataramanan 6889e94d4478SAnirudh Venkataramanan /* No point in doing any of this if neither checksum nor GSO are 6890e94d4478SAnirudh Venkataramanan * being requested for this frame. We can rule out both by just 6891e94d4478SAnirudh Venkataramanan * checking for CHECKSUM_PARTIAL 6892e94d4478SAnirudh Venkataramanan */ 6893e94d4478SAnirudh Venkataramanan if (skb->ip_summed != CHECKSUM_PARTIAL) 6894e94d4478SAnirudh Venkataramanan return features; 6895e94d4478SAnirudh Venkataramanan 6896e94d4478SAnirudh Venkataramanan /* We cannot support GSO if the MSS is going to be less than 6897e94d4478SAnirudh Venkataramanan * 64 bytes. If it is then we need to drop support for GSO. 6898e94d4478SAnirudh Venkataramanan */ 6899e94d4478SAnirudh Venkataramanan if (skb_is_gso(skb) && (skb_shinfo(skb)->gso_size < 64)) 6900e94d4478SAnirudh Venkataramanan features &= ~NETIF_F_GSO_MASK; 6901e94d4478SAnirudh Venkataramanan 6902e94d4478SAnirudh Venkataramanan len = skb_network_header(skb) - skb->data; 6903a4e82a81STony Nguyen if (len > ICE_TXD_MACLEN_MAX || len & 0x1) 6904e94d4478SAnirudh Venkataramanan goto out_rm_features; 6905e94d4478SAnirudh Venkataramanan 6906e94d4478SAnirudh Venkataramanan len = skb_transport_header(skb) - skb_network_header(skb); 6907a4e82a81STony Nguyen if (len > ICE_TXD_IPLEN_MAX || len & 0x1) 6908e94d4478SAnirudh Venkataramanan goto out_rm_features; 6909e94d4478SAnirudh Venkataramanan 6910e94d4478SAnirudh Venkataramanan if (skb->encapsulation) { 6911e94d4478SAnirudh Venkataramanan len = skb_inner_network_header(skb) - skb_transport_header(skb); 6912a4e82a81STony Nguyen if (len > ICE_TXD_L4LEN_MAX || len & 0x1) 6913e94d4478SAnirudh Venkataramanan goto out_rm_features; 6914e94d4478SAnirudh Venkataramanan 6915e94d4478SAnirudh Venkataramanan len = skb_inner_transport_header(skb) - 6916e94d4478SAnirudh Venkataramanan skb_inner_network_header(skb); 6917a4e82a81STony Nguyen if (len > ICE_TXD_IPLEN_MAX || len & 0x1) 6918e94d4478SAnirudh Venkataramanan goto out_rm_features; 6919e94d4478SAnirudh Venkataramanan } 6920e94d4478SAnirudh Venkataramanan 6921e94d4478SAnirudh Venkataramanan return features; 6922e94d4478SAnirudh Venkataramanan out_rm_features: 6923e94d4478SAnirudh Venkataramanan return features & ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK); 6924e94d4478SAnirudh Venkataramanan } 6925e94d4478SAnirudh Venkataramanan 6926462acf6aSTony Nguyen static const struct net_device_ops ice_netdev_safe_mode_ops = { 6927462acf6aSTony Nguyen .ndo_open = ice_open, 6928462acf6aSTony Nguyen .ndo_stop = ice_stop, 6929462acf6aSTony Nguyen .ndo_start_xmit = ice_start_xmit, 6930462acf6aSTony Nguyen .ndo_set_mac_address = ice_set_mac_address, 6931462acf6aSTony Nguyen .ndo_validate_addr = eth_validate_addr, 6932462acf6aSTony Nguyen .ndo_change_mtu = ice_change_mtu, 6933462acf6aSTony Nguyen .ndo_get_stats64 = ice_get_stats64, 6934462acf6aSTony Nguyen .ndo_tx_timeout = ice_tx_timeout, 6935462acf6aSTony Nguyen }; 6936462acf6aSTony Nguyen 6937cdedef59SAnirudh Venkataramanan static const struct net_device_ops ice_netdev_ops = { 6938cdedef59SAnirudh Venkataramanan .ndo_open = ice_open, 6939cdedef59SAnirudh Venkataramanan .ndo_stop = ice_stop, 69402b245cb2SAnirudh Venkataramanan .ndo_start_xmit = ice_start_xmit, 6941e94d4478SAnirudh Venkataramanan .ndo_features_check = ice_features_check, 6942e94d4478SAnirudh Venkataramanan .ndo_set_rx_mode = ice_set_rx_mode, 6943e94d4478SAnirudh Venkataramanan .ndo_set_mac_address = ice_set_mac_address, 6944e94d4478SAnirudh Venkataramanan .ndo_validate_addr = eth_validate_addr, 6945e94d4478SAnirudh Venkataramanan .ndo_change_mtu = ice_change_mtu, 6946fcea6f3dSAnirudh Venkataramanan .ndo_get_stats64 = ice_get_stats64, 69471ddef455SUsha Ketineni .ndo_set_tx_maxrate = ice_set_tx_maxrate, 69487c710869SAnirudh Venkataramanan .ndo_set_vf_spoofchk = ice_set_vf_spoofchk, 69497c710869SAnirudh Venkataramanan .ndo_set_vf_mac = ice_set_vf_mac, 69507c710869SAnirudh Venkataramanan .ndo_get_vf_config = ice_get_vf_cfg, 69517c710869SAnirudh Venkataramanan .ndo_set_vf_trust = ice_set_vf_trust, 69527c710869SAnirudh Venkataramanan .ndo_set_vf_vlan = ice_set_vf_port_vlan, 69537c710869SAnirudh Venkataramanan .ndo_set_vf_link_state = ice_set_vf_link_state, 6954730fdea4SJesse Brandeburg .ndo_get_vf_stats = ice_get_vf_stats, 6955d76a60baSAnirudh Venkataramanan .ndo_vlan_rx_add_vid = ice_vlan_rx_add_vid, 6956d76a60baSAnirudh Venkataramanan .ndo_vlan_rx_kill_vid = ice_vlan_rx_kill_vid, 6957d76a60baSAnirudh Venkataramanan .ndo_set_features = ice_set_features, 6958b1edc14aSMd Fahad Iqbal Polash .ndo_bridge_getlink = ice_bridge_getlink, 6959b1edc14aSMd Fahad Iqbal Polash .ndo_bridge_setlink = ice_bridge_setlink, 6960e94d4478SAnirudh Venkataramanan .ndo_fdb_add = ice_fdb_add, 6961e94d4478SAnirudh Venkataramanan .ndo_fdb_del = ice_fdb_del, 696228bf2672SBrett Creeley #ifdef CONFIG_RFS_ACCEL 696328bf2672SBrett Creeley .ndo_rx_flow_steer = ice_rx_flow_steer, 696428bf2672SBrett Creeley #endif 6965b3969fd7SSudheer Mogilappagari .ndo_tx_timeout = ice_tx_timeout, 6966efc2214bSMaciej Fijalkowski .ndo_bpf = ice_xdp, 6967efc2214bSMaciej Fijalkowski .ndo_xdp_xmit = ice_xdp_xmit, 69682d4238f5SKrzysztof Kazimierczak .ndo_xsk_wakeup = ice_xsk_wakeup, 6969cdedef59SAnirudh Venkataramanan }; 6970