1837f08fdSAnirudh Venkataramanan // SPDX-License-Identifier: GPL-2.0 2837f08fdSAnirudh Venkataramanan /* Copyright (c) 2018, Intel Corporation. */ 3837f08fdSAnirudh Venkataramanan 4837f08fdSAnirudh Venkataramanan /* Intel(R) Ethernet Connection E800 Series Linux Driver */ 5837f08fdSAnirudh Venkataramanan 6837f08fdSAnirudh Venkataramanan #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 7837f08fdSAnirudh Venkataramanan 834a2a3b8SJeff Kirsher #include <generated/utsrelease.h> 9837f08fdSAnirudh Venkataramanan #include "ice.h" 10eff380aaSAnirudh Venkataramanan #include "ice_base.h" 1145d3d428SAnirudh Venkataramanan #include "ice_lib.h" 121b8f15b6SMichal Swiatkowski #include "ice_fltr.h" 1337b6f646SAnirudh Venkataramanan #include "ice_dcb_lib.h" 14b94b013eSDave Ertman #include "ice_dcb_nl.h" 151adf7eadSJacob Keller #include "ice_devlink.h" 163089cf6dSJesse Brandeburg /* Including ice_trace.h with CREATE_TRACE_POINTS defined will generate the 173089cf6dSJesse Brandeburg * ice tracepoint functions. This must be done exactly once across the 183089cf6dSJesse Brandeburg * ice driver. 193089cf6dSJesse Brandeburg */ 203089cf6dSJesse Brandeburg #define CREATE_TRACE_POINTS 213089cf6dSJesse Brandeburg #include "ice_trace.h" 22b3be918dSGrzegorz Nitka #include "ice_eswitch.h" 230d08a441SKiran Patil #include "ice_tc_lib.h" 24837f08fdSAnirudh Venkataramanan 25837f08fdSAnirudh Venkataramanan #define DRV_SUMMARY "Intel(R) Ethernet Connection E800 Series Linux Driver" 26837f08fdSAnirudh Venkataramanan static const char ice_driver_string[] = DRV_SUMMARY; 27837f08fdSAnirudh Venkataramanan static const char ice_copyright[] = "Copyright (c) 2018, Intel Corporation."; 28837f08fdSAnirudh Venkataramanan 29462acf6aSTony Nguyen /* DDP Package file located in firmware search paths (e.g. /lib/firmware/) */ 30462acf6aSTony Nguyen #define ICE_DDP_PKG_PATH "intel/ice/ddp/" 31462acf6aSTony Nguyen #define ICE_DDP_PKG_FILE ICE_DDP_PKG_PATH "ice.pkg" 32462acf6aSTony Nguyen 33837f08fdSAnirudh Venkataramanan MODULE_AUTHOR("Intel Corporation, <linux.nics@intel.com>"); 34837f08fdSAnirudh Venkataramanan MODULE_DESCRIPTION(DRV_SUMMARY); 3598674ebeSJesse Brandeburg MODULE_LICENSE("GPL v2"); 36462acf6aSTony Nguyen MODULE_FIRMWARE(ICE_DDP_PKG_FILE); 37837f08fdSAnirudh Venkataramanan 38837f08fdSAnirudh Venkataramanan static int debug = -1; 39837f08fdSAnirudh Venkataramanan module_param(debug, int, 0644); 407ec59eeaSAnirudh Venkataramanan #ifndef CONFIG_DYNAMIC_DEBUG 417ec59eeaSAnirudh Venkataramanan MODULE_PARM_DESC(debug, "netif level (0=none,...,16=all), hw debug_mask (0x8XXXXXXX)"); 427ec59eeaSAnirudh Venkataramanan #else 437ec59eeaSAnirudh Venkataramanan MODULE_PARM_DESC(debug, "netif level (0=none,...,16=all)"); 447ec59eeaSAnirudh Venkataramanan #endif /* !CONFIG_DYNAMIC_DEBUG */ 45837f08fdSAnirudh Venkataramanan 46d25a0fc4SDave Ertman static DEFINE_IDA(ice_aux_ida); 4722bf877eSMaciej Fijalkowski DEFINE_STATIC_KEY_FALSE(ice_xdp_locking_key); 4822bf877eSMaciej Fijalkowski EXPORT_SYMBOL(ice_xdp_locking_key); 49d25a0fc4SDave Ertman 50940b61afSAnirudh Venkataramanan static struct workqueue_struct *ice_wq; 51462acf6aSTony Nguyen static const struct net_device_ops ice_netdev_safe_mode_ops; 52cdedef59SAnirudh Venkataramanan static const struct net_device_ops ice_netdev_ops; 53940b61afSAnirudh Venkataramanan 54462acf6aSTony Nguyen static void ice_rebuild(struct ice_pf *pf, enum ice_reset_req reset_type); 5528c2a645SAnirudh Venkataramanan 560f9d5027SAnirudh Venkataramanan static void ice_vsi_release_all(struct ice_pf *pf); 573a858ba3SAnirudh Venkataramanan 58df006dd4SDave Ertman bool netif_is_ice(struct net_device *dev) 59df006dd4SDave Ertman { 60df006dd4SDave Ertman return dev && (dev->netdev_ops == &ice_netdev_ops); 61df006dd4SDave Ertman } 62df006dd4SDave Ertman 633a858ba3SAnirudh Venkataramanan /** 64b3969fd7SSudheer Mogilappagari * ice_get_tx_pending - returns number of Tx descriptors not processed 65b3969fd7SSudheer Mogilappagari * @ring: the ring of descriptors 66b3969fd7SSudheer Mogilappagari */ 67e72bba21SMaciej Fijalkowski static u16 ice_get_tx_pending(struct ice_tx_ring *ring) 68b3969fd7SSudheer Mogilappagari { 69c1ddf1f5SBrett Creeley u16 head, tail; 70b3969fd7SSudheer Mogilappagari 71b3969fd7SSudheer Mogilappagari head = ring->next_to_clean; 72c1ddf1f5SBrett Creeley tail = ring->next_to_use; 73b3969fd7SSudheer Mogilappagari 74b3969fd7SSudheer Mogilappagari if (head != tail) 75b3969fd7SSudheer Mogilappagari return (head < tail) ? 76b3969fd7SSudheer Mogilappagari tail - head : (tail + ring->count - head); 77b3969fd7SSudheer Mogilappagari return 0; 78b3969fd7SSudheer Mogilappagari } 79b3969fd7SSudheer Mogilappagari 80b3969fd7SSudheer Mogilappagari /** 81b3969fd7SSudheer Mogilappagari * ice_check_for_hang_subtask - check for and recover hung queues 82b3969fd7SSudheer Mogilappagari * @pf: pointer to PF struct 83b3969fd7SSudheer Mogilappagari */ 84b3969fd7SSudheer Mogilappagari static void ice_check_for_hang_subtask(struct ice_pf *pf) 85b3969fd7SSudheer Mogilappagari { 86b3969fd7SSudheer Mogilappagari struct ice_vsi *vsi = NULL; 87e89e899fSBrett Creeley struct ice_hw *hw; 88b3969fd7SSudheer Mogilappagari unsigned int i; 89b3969fd7SSudheer Mogilappagari int packets; 90e89e899fSBrett Creeley u32 v; 91b3969fd7SSudheer Mogilappagari 92b3969fd7SSudheer Mogilappagari ice_for_each_vsi(pf, v) 93b3969fd7SSudheer Mogilappagari if (pf->vsi[v] && pf->vsi[v]->type == ICE_VSI_PF) { 94b3969fd7SSudheer Mogilappagari vsi = pf->vsi[v]; 95b3969fd7SSudheer Mogilappagari break; 96b3969fd7SSudheer Mogilappagari } 97b3969fd7SSudheer Mogilappagari 98e97fb1aeSAnirudh Venkataramanan if (!vsi || test_bit(ICE_VSI_DOWN, vsi->state)) 99b3969fd7SSudheer Mogilappagari return; 100b3969fd7SSudheer Mogilappagari 101b3969fd7SSudheer Mogilappagari if (!(vsi->netdev && netif_carrier_ok(vsi->netdev))) 102b3969fd7SSudheer Mogilappagari return; 103b3969fd7SSudheer Mogilappagari 104e89e899fSBrett Creeley hw = &vsi->back->hw; 105e89e899fSBrett Creeley 1062faf63b6SMaciej Fijalkowski ice_for_each_txq(vsi, i) { 107e72bba21SMaciej Fijalkowski struct ice_tx_ring *tx_ring = vsi->tx_rings[i]; 108b3969fd7SSudheer Mogilappagari 109b3969fd7SSudheer Mogilappagari if (tx_ring && tx_ring->desc) { 110b3969fd7SSudheer Mogilappagari /* If packet counter has not changed the queue is 111b3969fd7SSudheer Mogilappagari * likely stalled, so force an interrupt for this 112b3969fd7SSudheer Mogilappagari * queue. 113b3969fd7SSudheer Mogilappagari * 114b3969fd7SSudheer Mogilappagari * prev_pkt would be negative if there was no 115b3969fd7SSudheer Mogilappagari * pending work. 116b3969fd7SSudheer Mogilappagari */ 117b3969fd7SSudheer Mogilappagari packets = tx_ring->stats.pkts & INT_MAX; 118b3969fd7SSudheer Mogilappagari if (tx_ring->tx_stats.prev_pkt == packets) { 119b3969fd7SSudheer Mogilappagari /* Trigger sw interrupt to revive the queue */ 120e89e899fSBrett Creeley ice_trigger_sw_intr(hw, tx_ring->q_vector); 121b3969fd7SSudheer Mogilappagari continue; 122b3969fd7SSudheer Mogilappagari } 123b3969fd7SSudheer Mogilappagari 124b3969fd7SSudheer Mogilappagari /* Memory barrier between read of packet count and call 125b3969fd7SSudheer Mogilappagari * to ice_get_tx_pending() 126b3969fd7SSudheer Mogilappagari */ 127b3969fd7SSudheer Mogilappagari smp_rmb(); 128b3969fd7SSudheer Mogilappagari tx_ring->tx_stats.prev_pkt = 129b3969fd7SSudheer Mogilappagari ice_get_tx_pending(tx_ring) ? packets : -1; 130b3969fd7SSudheer Mogilappagari } 131b3969fd7SSudheer Mogilappagari } 132b3969fd7SSudheer Mogilappagari } 133b3969fd7SSudheer Mogilappagari 134b3969fd7SSudheer Mogilappagari /** 135561f4379STony Nguyen * ice_init_mac_fltr - Set initial MAC filters 136561f4379STony Nguyen * @pf: board private structure 137561f4379STony Nguyen * 1382f2da36eSAnirudh Venkataramanan * Set initial set of MAC filters for PF VSI; configure filters for permanent 139561f4379STony Nguyen * address and broadcast address. If an error is encountered, netdevice will be 140561f4379STony Nguyen * unregistered. 141561f4379STony Nguyen */ 142561f4379STony Nguyen static int ice_init_mac_fltr(struct ice_pf *pf) 143561f4379STony Nguyen { 144bbb968e8SAkeem G Abodunrin enum ice_status status; 145561f4379STony Nguyen struct ice_vsi *vsi; 1461b8f15b6SMichal Swiatkowski u8 *perm_addr; 147561f4379STony Nguyen 148208ff751SAnirudh Venkataramanan vsi = ice_get_main_vsi(pf); 149561f4379STony Nguyen if (!vsi) 150561f4379STony Nguyen return -EINVAL; 151561f4379STony Nguyen 1521b8f15b6SMichal Swiatkowski perm_addr = vsi->port_info->mac.perm_addr; 1531b8f15b6SMichal Swiatkowski status = ice_fltr_add_mac_and_broadcast(vsi, perm_addr, ICE_FWD_TO_VSI); 1541e23f076SAnirudh Venkataramanan if (status) 155bbb968e8SAkeem G Abodunrin return -EIO; 1561e23f076SAnirudh Venkataramanan 1571e23f076SAnirudh Venkataramanan return 0; 158561f4379STony Nguyen } 159561f4379STony Nguyen 160561f4379STony Nguyen /** 161f9867df6SAnirudh Venkataramanan * ice_add_mac_to_sync_list - creates list of MAC addresses to be synced 162e94d4478SAnirudh Venkataramanan * @netdev: the net device on which the sync is happening 163f9867df6SAnirudh Venkataramanan * @addr: MAC address to sync 164e94d4478SAnirudh Venkataramanan * 165e94d4478SAnirudh Venkataramanan * This is a callback function which is called by the in kernel device sync 166e94d4478SAnirudh Venkataramanan * functions (like __dev_uc_sync, __dev_mc_sync, etc). This function only 167e94d4478SAnirudh Venkataramanan * populates the tmp_sync_list, which is later used by ice_add_mac to add the 168f9867df6SAnirudh Venkataramanan * MAC filters from the hardware. 169e94d4478SAnirudh Venkataramanan */ 170e94d4478SAnirudh Venkataramanan static int ice_add_mac_to_sync_list(struct net_device *netdev, const u8 *addr) 171e94d4478SAnirudh Venkataramanan { 172e94d4478SAnirudh Venkataramanan struct ice_netdev_priv *np = netdev_priv(netdev); 173e94d4478SAnirudh Venkataramanan struct ice_vsi *vsi = np->vsi; 174e94d4478SAnirudh Venkataramanan 1751b8f15b6SMichal Swiatkowski if (ice_fltr_add_mac_to_list(vsi, &vsi->tmp_sync_list, addr, 1761b8f15b6SMichal Swiatkowski ICE_FWD_TO_VSI)) 177e94d4478SAnirudh Venkataramanan return -EINVAL; 178e94d4478SAnirudh Venkataramanan 179e94d4478SAnirudh Venkataramanan return 0; 180e94d4478SAnirudh Venkataramanan } 181e94d4478SAnirudh Venkataramanan 182e94d4478SAnirudh Venkataramanan /** 183f9867df6SAnirudh Venkataramanan * ice_add_mac_to_unsync_list - creates list of MAC addresses to be unsynced 184e94d4478SAnirudh Venkataramanan * @netdev: the net device on which the unsync is happening 185f9867df6SAnirudh Venkataramanan * @addr: MAC address to unsync 186e94d4478SAnirudh Venkataramanan * 187e94d4478SAnirudh Venkataramanan * This is a callback function which is called by the in kernel device unsync 188e94d4478SAnirudh Venkataramanan * functions (like __dev_uc_unsync, __dev_mc_unsync, etc). This function only 189e94d4478SAnirudh Venkataramanan * populates the tmp_unsync_list, which is later used by ice_remove_mac to 190f9867df6SAnirudh Venkataramanan * delete the MAC filters from the hardware. 191e94d4478SAnirudh Venkataramanan */ 192e94d4478SAnirudh Venkataramanan static int ice_add_mac_to_unsync_list(struct net_device *netdev, const u8 *addr) 193e94d4478SAnirudh Venkataramanan { 194e94d4478SAnirudh Venkataramanan struct ice_netdev_priv *np = netdev_priv(netdev); 195e94d4478SAnirudh Venkataramanan struct ice_vsi *vsi = np->vsi; 196e94d4478SAnirudh Venkataramanan 1973ba7f53fSBrett Creeley /* Under some circumstances, we might receive a request to delete our 1983ba7f53fSBrett Creeley * own device address from our uc list. Because we store the device 1993ba7f53fSBrett Creeley * address in the VSI's MAC filter list, we need to ignore such 2003ba7f53fSBrett Creeley * requests and not delete our device address from this list. 2013ba7f53fSBrett Creeley */ 2023ba7f53fSBrett Creeley if (ether_addr_equal(addr, netdev->dev_addr)) 2033ba7f53fSBrett Creeley return 0; 2043ba7f53fSBrett Creeley 2051b8f15b6SMichal Swiatkowski if (ice_fltr_add_mac_to_list(vsi, &vsi->tmp_unsync_list, addr, 2061b8f15b6SMichal Swiatkowski ICE_FWD_TO_VSI)) 207e94d4478SAnirudh Venkataramanan return -EINVAL; 208e94d4478SAnirudh Venkataramanan 209e94d4478SAnirudh Venkataramanan return 0; 210e94d4478SAnirudh Venkataramanan } 211e94d4478SAnirudh Venkataramanan 212e94d4478SAnirudh Venkataramanan /** 213e94d4478SAnirudh Venkataramanan * ice_vsi_fltr_changed - check if filter state changed 214e94d4478SAnirudh Venkataramanan * @vsi: VSI to be checked 215e94d4478SAnirudh Venkataramanan * 216e94d4478SAnirudh Venkataramanan * returns true if filter state has changed, false otherwise. 217e94d4478SAnirudh Venkataramanan */ 218e94d4478SAnirudh Venkataramanan static bool ice_vsi_fltr_changed(struct ice_vsi *vsi) 219e94d4478SAnirudh Venkataramanan { 220e97fb1aeSAnirudh Venkataramanan return test_bit(ICE_VSI_UMAC_FLTR_CHANGED, vsi->state) || 221e97fb1aeSAnirudh Venkataramanan test_bit(ICE_VSI_MMAC_FLTR_CHANGED, vsi->state) || 222e97fb1aeSAnirudh Venkataramanan test_bit(ICE_VSI_VLAN_FLTR_CHANGED, vsi->state); 223e94d4478SAnirudh Venkataramanan } 224e94d4478SAnirudh Venkataramanan 225e94d4478SAnirudh Venkataramanan /** 2265eda8afdSAkeem G Abodunrin * ice_cfg_promisc - Enable or disable promiscuous mode for a given PF 2275eda8afdSAkeem G Abodunrin * @vsi: the VSI being configured 2285eda8afdSAkeem G Abodunrin * @promisc_m: mask of promiscuous config bits 2295eda8afdSAkeem G Abodunrin * @set_promisc: enable or disable promisc flag request 2305eda8afdSAkeem G Abodunrin * 2315eda8afdSAkeem G Abodunrin */ 2325eda8afdSAkeem G Abodunrin static int ice_cfg_promisc(struct ice_vsi *vsi, u8 promisc_m, bool set_promisc) 2335eda8afdSAkeem G Abodunrin { 2345eda8afdSAkeem G Abodunrin struct ice_hw *hw = &vsi->back->hw; 2355eda8afdSAkeem G Abodunrin enum ice_status status = 0; 2365eda8afdSAkeem G Abodunrin 2375eda8afdSAkeem G Abodunrin if (vsi->type != ICE_VSI_PF) 2385eda8afdSAkeem G Abodunrin return 0; 2395eda8afdSAkeem G Abodunrin 240bcf68ea1SNick Nunley if (vsi->num_vlan > 1) { 2415eda8afdSAkeem G Abodunrin status = ice_set_vlan_vsi_promisc(hw, vsi->idx, promisc_m, 2425eda8afdSAkeem G Abodunrin set_promisc); 2435eda8afdSAkeem G Abodunrin } else { 2445eda8afdSAkeem G Abodunrin if (set_promisc) 2455eda8afdSAkeem G Abodunrin status = ice_set_vsi_promisc(hw, vsi->idx, promisc_m, 2465eda8afdSAkeem G Abodunrin 0); 2475eda8afdSAkeem G Abodunrin else 2485eda8afdSAkeem G Abodunrin status = ice_clear_vsi_promisc(hw, vsi->idx, promisc_m, 2495eda8afdSAkeem G Abodunrin 0); 2505eda8afdSAkeem G Abodunrin } 2515eda8afdSAkeem G Abodunrin 2525eda8afdSAkeem G Abodunrin if (status) 2535eda8afdSAkeem G Abodunrin return -EIO; 2545eda8afdSAkeem G Abodunrin 2555eda8afdSAkeem G Abodunrin return 0; 2565eda8afdSAkeem G Abodunrin } 2575eda8afdSAkeem G Abodunrin 2585eda8afdSAkeem G Abodunrin /** 259e94d4478SAnirudh Venkataramanan * ice_vsi_sync_fltr - Update the VSI filter list to the HW 260e94d4478SAnirudh Venkataramanan * @vsi: ptr to the VSI 261e94d4478SAnirudh Venkataramanan * 262e94d4478SAnirudh Venkataramanan * Push any outstanding VSI filter changes through the AdminQ. 263e94d4478SAnirudh Venkataramanan */ 264e94d4478SAnirudh Venkataramanan static int ice_vsi_sync_fltr(struct ice_vsi *vsi) 265e94d4478SAnirudh Venkataramanan { 2669a946843SAnirudh Venkataramanan struct device *dev = ice_pf_to_dev(vsi->back); 267e94d4478SAnirudh Venkataramanan struct net_device *netdev = vsi->netdev; 268e94d4478SAnirudh Venkataramanan bool promisc_forced_on = false; 269e94d4478SAnirudh Venkataramanan struct ice_pf *pf = vsi->back; 270e94d4478SAnirudh Venkataramanan struct ice_hw *hw = &pf->hw; 271e94d4478SAnirudh Venkataramanan enum ice_status status = 0; 272e94d4478SAnirudh Venkataramanan u32 changed_flags = 0; 2735eda8afdSAkeem G Abodunrin u8 promisc_m; 274e94d4478SAnirudh Venkataramanan int err = 0; 275e94d4478SAnirudh Venkataramanan 276e94d4478SAnirudh Venkataramanan if (!vsi->netdev) 277e94d4478SAnirudh Venkataramanan return -EINVAL; 278e94d4478SAnirudh Venkataramanan 2797e408e07SAnirudh Venkataramanan while (test_and_set_bit(ICE_CFG_BUSY, vsi->state)) 280e94d4478SAnirudh Venkataramanan usleep_range(1000, 2000); 281e94d4478SAnirudh Venkataramanan 282e94d4478SAnirudh Venkataramanan changed_flags = vsi->current_netdev_flags ^ vsi->netdev->flags; 283e94d4478SAnirudh Venkataramanan vsi->current_netdev_flags = vsi->netdev->flags; 284e94d4478SAnirudh Venkataramanan 285e94d4478SAnirudh Venkataramanan INIT_LIST_HEAD(&vsi->tmp_sync_list); 286e94d4478SAnirudh Venkataramanan INIT_LIST_HEAD(&vsi->tmp_unsync_list); 287e94d4478SAnirudh Venkataramanan 288e94d4478SAnirudh Venkataramanan if (ice_vsi_fltr_changed(vsi)) { 289e97fb1aeSAnirudh Venkataramanan clear_bit(ICE_VSI_UMAC_FLTR_CHANGED, vsi->state); 290e97fb1aeSAnirudh Venkataramanan clear_bit(ICE_VSI_MMAC_FLTR_CHANGED, vsi->state); 291e97fb1aeSAnirudh Venkataramanan clear_bit(ICE_VSI_VLAN_FLTR_CHANGED, vsi->state); 292e94d4478SAnirudh Venkataramanan 293e94d4478SAnirudh Venkataramanan /* grab the netdev's addr_list_lock */ 294e94d4478SAnirudh Venkataramanan netif_addr_lock_bh(netdev); 295e94d4478SAnirudh Venkataramanan __dev_uc_sync(netdev, ice_add_mac_to_sync_list, 296e94d4478SAnirudh Venkataramanan ice_add_mac_to_unsync_list); 297e94d4478SAnirudh Venkataramanan __dev_mc_sync(netdev, ice_add_mac_to_sync_list, 298e94d4478SAnirudh Venkataramanan ice_add_mac_to_unsync_list); 299e94d4478SAnirudh Venkataramanan /* our temp lists are populated. release lock */ 300e94d4478SAnirudh Venkataramanan netif_addr_unlock_bh(netdev); 301e94d4478SAnirudh Venkataramanan } 302e94d4478SAnirudh Venkataramanan 303f9867df6SAnirudh Venkataramanan /* Remove MAC addresses in the unsync list */ 3041b8f15b6SMichal Swiatkowski status = ice_fltr_remove_mac_list(vsi, &vsi->tmp_unsync_list); 3051b8f15b6SMichal Swiatkowski ice_fltr_free_list(dev, &vsi->tmp_unsync_list); 306e94d4478SAnirudh Venkataramanan if (status) { 307e94d4478SAnirudh Venkataramanan netdev_err(netdev, "Failed to delete MAC filters\n"); 308e94d4478SAnirudh Venkataramanan /* if we failed because of alloc failures, just bail */ 309e94d4478SAnirudh Venkataramanan if (status == ICE_ERR_NO_MEMORY) { 310e94d4478SAnirudh Venkataramanan err = -ENOMEM; 311e94d4478SAnirudh Venkataramanan goto out; 312e94d4478SAnirudh Venkataramanan } 313e94d4478SAnirudh Venkataramanan } 314e94d4478SAnirudh Venkataramanan 315f9867df6SAnirudh Venkataramanan /* Add MAC addresses in the sync list */ 3161b8f15b6SMichal Swiatkowski status = ice_fltr_add_mac_list(vsi, &vsi->tmp_sync_list); 3171b8f15b6SMichal Swiatkowski ice_fltr_free_list(dev, &vsi->tmp_sync_list); 31889f3e4a5SPreethi Banala /* If filter is added successfully or already exists, do not go into 31989f3e4a5SPreethi Banala * 'if' condition and report it as error. Instead continue processing 32089f3e4a5SPreethi Banala * rest of the function. 32189f3e4a5SPreethi Banala */ 32289f3e4a5SPreethi Banala if (status && status != ICE_ERR_ALREADY_EXISTS) { 323e94d4478SAnirudh Venkataramanan netdev_err(netdev, "Failed to add MAC filters\n"); 324f9867df6SAnirudh Venkataramanan /* If there is no more space for new umac filters, VSI 325e94d4478SAnirudh Venkataramanan * should go into promiscuous mode. There should be some 326e94d4478SAnirudh Venkataramanan * space reserved for promiscuous filters. 327e94d4478SAnirudh Venkataramanan */ 328e94d4478SAnirudh Venkataramanan if (hw->adminq.sq_last_status == ICE_AQ_RC_ENOSPC && 3297e408e07SAnirudh Venkataramanan !test_and_set_bit(ICE_FLTR_OVERFLOW_PROMISC, 330e94d4478SAnirudh Venkataramanan vsi->state)) { 331e94d4478SAnirudh Venkataramanan promisc_forced_on = true; 33219cce2c6SAnirudh Venkataramanan netdev_warn(netdev, "Reached MAC filter limit, forcing promisc mode on VSI %d\n", 333e94d4478SAnirudh Venkataramanan vsi->vsi_num); 334e94d4478SAnirudh Venkataramanan } else { 335e94d4478SAnirudh Venkataramanan err = -EIO; 336e94d4478SAnirudh Venkataramanan goto out; 337e94d4478SAnirudh Venkataramanan } 338e94d4478SAnirudh Venkataramanan } 339e94d4478SAnirudh Venkataramanan /* check for changes in promiscuous modes */ 3405eda8afdSAkeem G Abodunrin if (changed_flags & IFF_ALLMULTI) { 3415eda8afdSAkeem G Abodunrin if (vsi->current_netdev_flags & IFF_ALLMULTI) { 342bcf68ea1SNick Nunley if (vsi->num_vlan > 1) 3435eda8afdSAkeem G Abodunrin promisc_m = ICE_MCAST_VLAN_PROMISC_BITS; 3445eda8afdSAkeem G Abodunrin else 3455eda8afdSAkeem G Abodunrin promisc_m = ICE_MCAST_PROMISC_BITS; 3465eda8afdSAkeem G Abodunrin 3475eda8afdSAkeem G Abodunrin err = ice_cfg_promisc(vsi, promisc_m, true); 3485eda8afdSAkeem G Abodunrin if (err) { 3495eda8afdSAkeem G Abodunrin netdev_err(netdev, "Error setting Multicast promiscuous mode on VSI %i\n", 3505eda8afdSAkeem G Abodunrin vsi->vsi_num); 3515eda8afdSAkeem G Abodunrin vsi->current_netdev_flags &= ~IFF_ALLMULTI; 3525eda8afdSAkeem G Abodunrin goto out_promisc; 3535eda8afdSAkeem G Abodunrin } 35492ace482SBruce Allan } else { 35592ace482SBruce Allan /* !(vsi->current_netdev_flags & IFF_ALLMULTI) */ 356bcf68ea1SNick Nunley if (vsi->num_vlan > 1) 3575eda8afdSAkeem G Abodunrin promisc_m = ICE_MCAST_VLAN_PROMISC_BITS; 3585eda8afdSAkeem G Abodunrin else 3595eda8afdSAkeem G Abodunrin promisc_m = ICE_MCAST_PROMISC_BITS; 3605eda8afdSAkeem G Abodunrin 3615eda8afdSAkeem G Abodunrin err = ice_cfg_promisc(vsi, promisc_m, false); 3625eda8afdSAkeem G Abodunrin if (err) { 3635eda8afdSAkeem G Abodunrin netdev_err(netdev, "Error clearing Multicast promiscuous mode on VSI %i\n", 3645eda8afdSAkeem G Abodunrin vsi->vsi_num); 3655eda8afdSAkeem G Abodunrin vsi->current_netdev_flags |= IFF_ALLMULTI; 3665eda8afdSAkeem G Abodunrin goto out_promisc; 3675eda8afdSAkeem G Abodunrin } 3685eda8afdSAkeem G Abodunrin } 3695eda8afdSAkeem G Abodunrin } 370e94d4478SAnirudh Venkataramanan 371e94d4478SAnirudh Venkataramanan if (((changed_flags & IFF_PROMISC) || promisc_forced_on) || 372e97fb1aeSAnirudh Venkataramanan test_bit(ICE_VSI_PROMISC_CHANGED, vsi->state)) { 373e97fb1aeSAnirudh Venkataramanan clear_bit(ICE_VSI_PROMISC_CHANGED, vsi->state); 374e94d4478SAnirudh Venkataramanan if (vsi->current_netdev_flags & IFF_PROMISC) { 375f9867df6SAnirudh Venkataramanan /* Apply Rx filter rule to get traffic from wire */ 376fc0f39bcSBrett Creeley if (!ice_is_dflt_vsi_in_use(pf->first_sw)) { 377fc0f39bcSBrett Creeley err = ice_set_dflt_vsi(pf->first_sw, vsi); 378fc0f39bcSBrett Creeley if (err && err != -EEXIST) { 37919cce2c6SAnirudh Venkataramanan netdev_err(netdev, "Error %d setting default VSI %i Rx rule\n", 380fc0f39bcSBrett Creeley err, vsi->vsi_num); 381fc0f39bcSBrett Creeley vsi->current_netdev_flags &= 382fc0f39bcSBrett Creeley ~IFF_PROMISC; 383e94d4478SAnirudh Venkataramanan goto out_promisc; 384e94d4478SAnirudh Venkataramanan } 38568d210a6SNick Nunley ice_cfg_vlan_pruning(vsi, false, false); 386fc0f39bcSBrett Creeley } 387e94d4478SAnirudh Venkataramanan } else { 388f9867df6SAnirudh Venkataramanan /* Clear Rx filter to remove traffic from wire */ 389fc0f39bcSBrett Creeley if (ice_is_vsi_dflt_vsi(pf->first_sw, vsi)) { 390fc0f39bcSBrett Creeley err = ice_clear_dflt_vsi(pf->first_sw); 391fc0f39bcSBrett Creeley if (err) { 39219cce2c6SAnirudh Venkataramanan netdev_err(netdev, "Error %d clearing default VSI %i Rx rule\n", 393fc0f39bcSBrett Creeley err, vsi->vsi_num); 394fc0f39bcSBrett Creeley vsi->current_netdev_flags |= 395fc0f39bcSBrett Creeley IFF_PROMISC; 396e94d4478SAnirudh Venkataramanan goto out_promisc; 397e94d4478SAnirudh Venkataramanan } 39868d210a6SNick Nunley if (vsi->num_vlan > 1) 39968d210a6SNick Nunley ice_cfg_vlan_pruning(vsi, true, false); 400e94d4478SAnirudh Venkataramanan } 401e94d4478SAnirudh Venkataramanan } 402fc0f39bcSBrett Creeley } 403e94d4478SAnirudh Venkataramanan goto exit; 404e94d4478SAnirudh Venkataramanan 405e94d4478SAnirudh Venkataramanan out_promisc: 406e97fb1aeSAnirudh Venkataramanan set_bit(ICE_VSI_PROMISC_CHANGED, vsi->state); 407e94d4478SAnirudh Venkataramanan goto exit; 408e94d4478SAnirudh Venkataramanan out: 409e94d4478SAnirudh Venkataramanan /* if something went wrong then set the changed flag so we try again */ 410e97fb1aeSAnirudh Venkataramanan set_bit(ICE_VSI_UMAC_FLTR_CHANGED, vsi->state); 411e97fb1aeSAnirudh Venkataramanan set_bit(ICE_VSI_MMAC_FLTR_CHANGED, vsi->state); 412e94d4478SAnirudh Venkataramanan exit: 4137e408e07SAnirudh Venkataramanan clear_bit(ICE_CFG_BUSY, vsi->state); 414e94d4478SAnirudh Venkataramanan return err; 415e94d4478SAnirudh Venkataramanan } 416e94d4478SAnirudh Venkataramanan 417e94d4478SAnirudh Venkataramanan /** 418e94d4478SAnirudh Venkataramanan * ice_sync_fltr_subtask - Sync the VSI filter list with HW 419e94d4478SAnirudh Venkataramanan * @pf: board private structure 420e94d4478SAnirudh Venkataramanan */ 421e94d4478SAnirudh Venkataramanan static void ice_sync_fltr_subtask(struct ice_pf *pf) 422e94d4478SAnirudh Venkataramanan { 423e94d4478SAnirudh Venkataramanan int v; 424e94d4478SAnirudh Venkataramanan 425e94d4478SAnirudh Venkataramanan if (!pf || !(test_bit(ICE_FLAG_FLTR_SYNC, pf->flags))) 426e94d4478SAnirudh Venkataramanan return; 427e94d4478SAnirudh Venkataramanan 428e94d4478SAnirudh Venkataramanan clear_bit(ICE_FLAG_FLTR_SYNC, pf->flags); 429e94d4478SAnirudh Venkataramanan 43080ed404aSBrett Creeley ice_for_each_vsi(pf, v) 431e94d4478SAnirudh Venkataramanan if (pf->vsi[v] && ice_vsi_fltr_changed(pf->vsi[v]) && 432e94d4478SAnirudh Venkataramanan ice_vsi_sync_fltr(pf->vsi[v])) { 433e94d4478SAnirudh Venkataramanan /* come back and try again later */ 434e94d4478SAnirudh Venkataramanan set_bit(ICE_FLAG_FLTR_SYNC, pf->flags); 435e94d4478SAnirudh Venkataramanan break; 436e94d4478SAnirudh Venkataramanan } 437e94d4478SAnirudh Venkataramanan } 438e94d4478SAnirudh Venkataramanan 439e94d4478SAnirudh Venkataramanan /** 4407b9ffc76SAnirudh Venkataramanan * ice_pf_dis_all_vsi - Pause all VSIs on a PF 4417b9ffc76SAnirudh Venkataramanan * @pf: the PF 4427b9ffc76SAnirudh Venkataramanan * @locked: is the rtnl_lock already held 4437b9ffc76SAnirudh Venkataramanan */ 4447b9ffc76SAnirudh Venkataramanan static void ice_pf_dis_all_vsi(struct ice_pf *pf, bool locked) 4457b9ffc76SAnirudh Venkataramanan { 446b126bd6bSKiran Patil int node; 4477b9ffc76SAnirudh Venkataramanan int v; 4487b9ffc76SAnirudh Venkataramanan 4497b9ffc76SAnirudh Venkataramanan ice_for_each_vsi(pf, v) 4507b9ffc76SAnirudh Venkataramanan if (pf->vsi[v]) 4517b9ffc76SAnirudh Venkataramanan ice_dis_vsi(pf->vsi[v], locked); 452b126bd6bSKiran Patil 453b126bd6bSKiran Patil for (node = 0; node < ICE_MAX_PF_AGG_NODES; node++) 454b126bd6bSKiran Patil pf->pf_agg_node[node].num_vsis = 0; 455b126bd6bSKiran Patil 456b126bd6bSKiran Patil for (node = 0; node < ICE_MAX_VF_AGG_NODES; node++) 457b126bd6bSKiran Patil pf->vf_agg_node[node].num_vsis = 0; 4587b9ffc76SAnirudh Venkataramanan } 4597b9ffc76SAnirudh Venkataramanan 4607b9ffc76SAnirudh Venkataramanan /** 4610b28b702SAnirudh Venkataramanan * ice_prepare_for_reset - prep for the core to reset 4620b28b702SAnirudh Venkataramanan * @pf: board private structure 4630b28b702SAnirudh Venkataramanan * 4640b28b702SAnirudh Venkataramanan * Inform or close all dependent features in prep for reset. 4650b28b702SAnirudh Venkataramanan */ 4660b28b702SAnirudh Venkataramanan static void 4670b28b702SAnirudh Venkataramanan ice_prepare_for_reset(struct ice_pf *pf) 4680b28b702SAnirudh Venkataramanan { 4690b28b702SAnirudh Venkataramanan struct ice_hw *hw = &pf->hw; 470c1e08830SJesse Brandeburg unsigned int i; 4710b28b702SAnirudh Venkataramanan 4725abac9d7SBrett Creeley /* already prepared for reset */ 4737e408e07SAnirudh Venkataramanan if (test_bit(ICE_PREPARED_FOR_RESET, pf->state)) 4745abac9d7SBrett Creeley return; 4755abac9d7SBrett Creeley 476f9f5301eSDave Ertman ice_unplug_aux_dev(pf); 477f9f5301eSDave Ertman 478007676b4SAnirudh Venkataramanan /* Notify VFs of impending reset */ 479007676b4SAnirudh Venkataramanan if (ice_check_sq_alive(hw, &hw->mailboxq)) 480007676b4SAnirudh Venkataramanan ice_vc_notify_reset(pf); 481007676b4SAnirudh Venkataramanan 482c7aeb4d1SAkeem G Abodunrin /* Disable VFs until reset is completed */ 483005881bcSBrett Creeley ice_for_each_vf(pf, i) 48477ca27c4SPaul Greenwalt ice_set_vf_state_qs_dis(&pf->vf[i]); 485c7aeb4d1SAkeem G Abodunrin 486462acf6aSTony Nguyen /* clear SW filtering DB */ 487462acf6aSTony Nguyen ice_clear_hw_tbls(hw); 4880b28b702SAnirudh Venkataramanan /* disable the VSIs and their queues that are not already DOWN */ 4897b9ffc76SAnirudh Venkataramanan ice_pf_dis_all_vsi(pf, false); 4900b28b702SAnirudh Venkataramanan 49106c16d89SJacob Keller if (test_bit(ICE_FLAG_PTP_SUPPORTED, pf->flags)) 49206c16d89SJacob Keller ice_ptp_release(pf); 49306c16d89SJacob Keller 494c5a2a4a3SUsha Ketineni if (hw->port_info) 495c5a2a4a3SUsha Ketineni ice_sched_clear_port(hw->port_info); 496c5a2a4a3SUsha Ketineni 4970b28b702SAnirudh Venkataramanan ice_shutdown_all_ctrlq(hw); 4980f9d5027SAnirudh Venkataramanan 4997e408e07SAnirudh Venkataramanan set_bit(ICE_PREPARED_FOR_RESET, pf->state); 5000b28b702SAnirudh Venkataramanan } 5010b28b702SAnirudh Venkataramanan 5020b28b702SAnirudh Venkataramanan /** 5030b28b702SAnirudh Venkataramanan * ice_do_reset - Initiate one of many types of resets 5040b28b702SAnirudh Venkataramanan * @pf: board private structure 5050b28b702SAnirudh Venkataramanan * @reset_type: reset type requested 5060b28b702SAnirudh Venkataramanan * before this function was called. 5070b28b702SAnirudh Venkataramanan */ 5080b28b702SAnirudh Venkataramanan static void ice_do_reset(struct ice_pf *pf, enum ice_reset_req reset_type) 5090b28b702SAnirudh Venkataramanan { 5104015d11eSBrett Creeley struct device *dev = ice_pf_to_dev(pf); 5110b28b702SAnirudh Venkataramanan struct ice_hw *hw = &pf->hw; 5120b28b702SAnirudh Venkataramanan 5130b28b702SAnirudh Venkataramanan dev_dbg(dev, "reset_type 0x%x requested\n", reset_type); 5140b28b702SAnirudh Venkataramanan 5150b28b702SAnirudh Venkataramanan ice_prepare_for_reset(pf); 5160b28b702SAnirudh Venkataramanan 5170b28b702SAnirudh Venkataramanan /* trigger the reset */ 5180b28b702SAnirudh Venkataramanan if (ice_reset(hw, reset_type)) { 5190b28b702SAnirudh Venkataramanan dev_err(dev, "reset %d failed\n", reset_type); 5207e408e07SAnirudh Venkataramanan set_bit(ICE_RESET_FAILED, pf->state); 5217e408e07SAnirudh Venkataramanan clear_bit(ICE_RESET_OICR_RECV, pf->state); 5227e408e07SAnirudh Venkataramanan clear_bit(ICE_PREPARED_FOR_RESET, pf->state); 5237e408e07SAnirudh Venkataramanan clear_bit(ICE_PFR_REQ, pf->state); 5247e408e07SAnirudh Venkataramanan clear_bit(ICE_CORER_REQ, pf->state); 5257e408e07SAnirudh Venkataramanan clear_bit(ICE_GLOBR_REQ, pf->state); 5261c08052eSJacob Keller wake_up(&pf->reset_wait_queue); 5270b28b702SAnirudh Venkataramanan return; 5280b28b702SAnirudh Venkataramanan } 5290b28b702SAnirudh Venkataramanan 5300f9d5027SAnirudh Venkataramanan /* PFR is a bit of a special case because it doesn't result in an OICR 5310f9d5027SAnirudh Venkataramanan * interrupt. So for PFR, rebuild after the reset and clear the reset- 5320f9d5027SAnirudh Venkataramanan * associated state bits. 5330f9d5027SAnirudh Venkataramanan */ 5340b28b702SAnirudh Venkataramanan if (reset_type == ICE_RESET_PFR) { 5350b28b702SAnirudh Venkataramanan pf->pfr_count++; 536462acf6aSTony Nguyen ice_rebuild(pf, reset_type); 5377e408e07SAnirudh Venkataramanan clear_bit(ICE_PREPARED_FOR_RESET, pf->state); 5387e408e07SAnirudh Venkataramanan clear_bit(ICE_PFR_REQ, pf->state); 5391c08052eSJacob Keller wake_up(&pf->reset_wait_queue); 5401c44e3bcSAkeem G Abodunrin ice_reset_all_vfs(pf, true); 5410b28b702SAnirudh Venkataramanan } 5420b28b702SAnirudh Venkataramanan } 5430b28b702SAnirudh Venkataramanan 5440b28b702SAnirudh Venkataramanan /** 5450b28b702SAnirudh Venkataramanan * ice_reset_subtask - Set up for resetting the device and driver 5460b28b702SAnirudh Venkataramanan * @pf: board private structure 5470b28b702SAnirudh Venkataramanan */ 5480b28b702SAnirudh Venkataramanan static void ice_reset_subtask(struct ice_pf *pf) 5490b28b702SAnirudh Venkataramanan { 5500f9d5027SAnirudh Venkataramanan enum ice_reset_req reset_type = ICE_RESET_INVAL; 5510b28b702SAnirudh Venkataramanan 5520b28b702SAnirudh Venkataramanan /* When a CORER/GLOBR/EMPR is about to happen, the hardware triggers an 5530f9d5027SAnirudh Venkataramanan * OICR interrupt. The OICR handler (ice_misc_intr) determines what type 5540f9d5027SAnirudh Venkataramanan * of reset is pending and sets bits in pf->state indicating the reset 5557e408e07SAnirudh Venkataramanan * type and ICE_RESET_OICR_RECV. So, if the latter bit is set 5560f9d5027SAnirudh Venkataramanan * prepare for pending reset if not already (for PF software-initiated 5570f9d5027SAnirudh Venkataramanan * global resets the software should already be prepared for it as 5587e408e07SAnirudh Venkataramanan * indicated by ICE_PREPARED_FOR_RESET; for global resets initiated 5590f9d5027SAnirudh Venkataramanan * by firmware or software on other PFs, that bit is not set so prepare 5600f9d5027SAnirudh Venkataramanan * for the reset now), poll for reset done, rebuild and return. 5610b28b702SAnirudh Venkataramanan */ 5627e408e07SAnirudh Venkataramanan if (test_bit(ICE_RESET_OICR_RECV, pf->state)) { 5632ebd4428SDave Ertman /* Perform the largest reset requested */ 5647e408e07SAnirudh Venkataramanan if (test_and_clear_bit(ICE_CORER_RECV, pf->state)) 5652ebd4428SDave Ertman reset_type = ICE_RESET_CORER; 5667e408e07SAnirudh Venkataramanan if (test_and_clear_bit(ICE_GLOBR_RECV, pf->state)) 5672ebd4428SDave Ertman reset_type = ICE_RESET_GLOBR; 5687e408e07SAnirudh Venkataramanan if (test_and_clear_bit(ICE_EMPR_RECV, pf->state)) 56903af8406SAnirudh Venkataramanan reset_type = ICE_RESET_EMPR; 5702ebd4428SDave Ertman /* return if no valid reset type requested */ 5712ebd4428SDave Ertman if (reset_type == ICE_RESET_INVAL) 5722ebd4428SDave Ertman return; 5730b28b702SAnirudh Venkataramanan ice_prepare_for_reset(pf); 5740b28b702SAnirudh Venkataramanan 5750b28b702SAnirudh Venkataramanan /* make sure we are ready to rebuild */ 576fd2a9817SAnirudh Venkataramanan if (ice_check_reset(&pf->hw)) { 5777e408e07SAnirudh Venkataramanan set_bit(ICE_RESET_FAILED, pf->state); 578fd2a9817SAnirudh Venkataramanan } else { 579fd2a9817SAnirudh Venkataramanan /* done with reset. start rebuild */ 580fd2a9817SAnirudh Venkataramanan pf->hw.reset_ongoing = false; 581462acf6aSTony Nguyen ice_rebuild(pf, reset_type); 5820f9d5027SAnirudh Venkataramanan /* clear bit to resume normal operations, but 5830f9d5027SAnirudh Venkataramanan * ICE_NEEDS_RESTART bit is set in case rebuild failed 5840f9d5027SAnirudh Venkataramanan */ 5857e408e07SAnirudh Venkataramanan clear_bit(ICE_RESET_OICR_RECV, pf->state); 5867e408e07SAnirudh Venkataramanan clear_bit(ICE_PREPARED_FOR_RESET, pf->state); 5877e408e07SAnirudh Venkataramanan clear_bit(ICE_PFR_REQ, pf->state); 5887e408e07SAnirudh Venkataramanan clear_bit(ICE_CORER_REQ, pf->state); 5897e408e07SAnirudh Venkataramanan clear_bit(ICE_GLOBR_REQ, pf->state); 5901c08052eSJacob Keller wake_up(&pf->reset_wait_queue); 5911c44e3bcSAkeem G Abodunrin ice_reset_all_vfs(pf, true); 5920f9d5027SAnirudh Venkataramanan } 5930f9d5027SAnirudh Venkataramanan 5940f9d5027SAnirudh Venkataramanan return; 5950b28b702SAnirudh Venkataramanan } 5960b28b702SAnirudh Venkataramanan 5970b28b702SAnirudh Venkataramanan /* No pending resets to finish processing. Check for new resets */ 5987e408e07SAnirudh Venkataramanan if (test_bit(ICE_PFR_REQ, pf->state)) 5990f9d5027SAnirudh Venkataramanan reset_type = ICE_RESET_PFR; 6007e408e07SAnirudh Venkataramanan if (test_bit(ICE_CORER_REQ, pf->state)) 6010f9d5027SAnirudh Venkataramanan reset_type = ICE_RESET_CORER; 6027e408e07SAnirudh Venkataramanan if (test_bit(ICE_GLOBR_REQ, pf->state)) 6030b28b702SAnirudh Venkataramanan reset_type = ICE_RESET_GLOBR; 6040f9d5027SAnirudh Venkataramanan /* If no valid reset type requested just return */ 6050f9d5027SAnirudh Venkataramanan if (reset_type == ICE_RESET_INVAL) 6060f9d5027SAnirudh Venkataramanan return; 6070b28b702SAnirudh Venkataramanan 6080f9d5027SAnirudh Venkataramanan /* reset if not already down or busy */ 6097e408e07SAnirudh Venkataramanan if (!test_bit(ICE_DOWN, pf->state) && 6107e408e07SAnirudh Venkataramanan !test_bit(ICE_CFG_BUSY, pf->state)) { 6110b28b702SAnirudh Venkataramanan ice_do_reset(pf, reset_type); 6120b28b702SAnirudh Venkataramanan } 6130b28b702SAnirudh Venkataramanan } 6140b28b702SAnirudh Venkataramanan 6150b28b702SAnirudh Venkataramanan /** 6162e0ab37cSJesse Brandeburg * ice_print_topo_conflict - print topology conflict message 6172e0ab37cSJesse Brandeburg * @vsi: the VSI whose topology status is being checked 6182e0ab37cSJesse Brandeburg */ 6192e0ab37cSJesse Brandeburg static void ice_print_topo_conflict(struct ice_vsi *vsi) 6202e0ab37cSJesse Brandeburg { 6212e0ab37cSJesse Brandeburg switch (vsi->port_info->phy.link_info.topo_media_conflict) { 6222e0ab37cSJesse Brandeburg case ICE_AQ_LINK_TOPO_CONFLICT: 6232e0ab37cSJesse Brandeburg case ICE_AQ_LINK_MEDIA_CONFLICT: 6245878589dSPaul Greenwalt case ICE_AQ_LINK_TOPO_UNREACH_PRT: 6255878589dSPaul Greenwalt case ICE_AQ_LINK_TOPO_UNDRUTIL_PRT: 6265878589dSPaul Greenwalt case ICE_AQ_LINK_TOPO_UNDRUTIL_MEDIA: 6275c57145aSPaul 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"); 6282e0ab37cSJesse Brandeburg break; 6295878589dSPaul Greenwalt case ICE_AQ_LINK_TOPO_UNSUPP_MEDIA: 6304fc5fbeeSAnirudh Venkataramanan if (test_bit(ICE_FLAG_LINK_LENIENT_MODE_ENA, vsi->back->flags)) 6314fc5fbeeSAnirudh Venkataramanan netdev_warn(vsi->netdev, "An unsupported module type was detected. Refer to the Intel(R) Ethernet Adapters and Devices User Guide for a list of supported modules\n"); 6324fc5fbeeSAnirudh Venkataramanan else 6334fc5fbeeSAnirudh Venkataramanan netdev_err(vsi->netdev, "Rx/Tx is disabled on this device because an unsupported module type was detected. Refer to the Intel(R) Ethernet Adapters and Devices User Guide for a list of supported modules.\n"); 6345878589dSPaul Greenwalt break; 6352e0ab37cSJesse Brandeburg default: 6362e0ab37cSJesse Brandeburg break; 6372e0ab37cSJesse Brandeburg } 6382e0ab37cSJesse Brandeburg } 6392e0ab37cSJesse Brandeburg 6402e0ab37cSJesse Brandeburg /** 641cdedef59SAnirudh Venkataramanan * ice_print_link_msg - print link up or down message 642cdedef59SAnirudh Venkataramanan * @vsi: the VSI whose link status is being queried 643cdedef59SAnirudh Venkataramanan * @isup: boolean for if the link is now up or down 644cdedef59SAnirudh Venkataramanan */ 645fcea6f3dSAnirudh Venkataramanan void ice_print_link_msg(struct ice_vsi *vsi, bool isup) 646cdedef59SAnirudh Venkataramanan { 647f776b3acSPaul Greenwalt struct ice_aqc_get_phy_caps_data *caps; 6485ee30564SPaul Greenwalt const char *an_advertised; 649f776b3acSPaul Greenwalt enum ice_status status; 650f776b3acSPaul Greenwalt const char *fec_req; 651cdedef59SAnirudh Venkataramanan const char *speed; 652f776b3acSPaul Greenwalt const char *fec; 653cdedef59SAnirudh Venkataramanan const char *fc; 65443260988SJesse Brandeburg const char *an; 655cdedef59SAnirudh Venkataramanan 656c2a23e00SBrett Creeley if (!vsi) 657c2a23e00SBrett Creeley return; 658c2a23e00SBrett Creeley 659cdedef59SAnirudh Venkataramanan if (vsi->current_isup == isup) 660cdedef59SAnirudh Venkataramanan return; 661cdedef59SAnirudh Venkataramanan 662cdedef59SAnirudh Venkataramanan vsi->current_isup = isup; 663cdedef59SAnirudh Venkataramanan 664cdedef59SAnirudh Venkataramanan if (!isup) { 665cdedef59SAnirudh Venkataramanan netdev_info(vsi->netdev, "NIC Link is Down\n"); 666cdedef59SAnirudh Venkataramanan return; 667cdedef59SAnirudh Venkataramanan } 668cdedef59SAnirudh Venkataramanan 669cdedef59SAnirudh Venkataramanan switch (vsi->port_info->phy.link_info.link_speed) { 670072efdf8SAnirudh Venkataramanan case ICE_AQ_LINK_SPEED_100GB: 671072efdf8SAnirudh Venkataramanan speed = "100 G"; 672072efdf8SAnirudh Venkataramanan break; 673072efdf8SAnirudh Venkataramanan case ICE_AQ_LINK_SPEED_50GB: 674072efdf8SAnirudh Venkataramanan speed = "50 G"; 675072efdf8SAnirudh Venkataramanan break; 676cdedef59SAnirudh Venkataramanan case ICE_AQ_LINK_SPEED_40GB: 677cdedef59SAnirudh Venkataramanan speed = "40 G"; 678cdedef59SAnirudh Venkataramanan break; 679cdedef59SAnirudh Venkataramanan case ICE_AQ_LINK_SPEED_25GB: 680cdedef59SAnirudh Venkataramanan speed = "25 G"; 681cdedef59SAnirudh Venkataramanan break; 682cdedef59SAnirudh Venkataramanan case ICE_AQ_LINK_SPEED_20GB: 683cdedef59SAnirudh Venkataramanan speed = "20 G"; 684cdedef59SAnirudh Venkataramanan break; 685cdedef59SAnirudh Venkataramanan case ICE_AQ_LINK_SPEED_10GB: 686cdedef59SAnirudh Venkataramanan speed = "10 G"; 687cdedef59SAnirudh Venkataramanan break; 688cdedef59SAnirudh Venkataramanan case ICE_AQ_LINK_SPEED_5GB: 689cdedef59SAnirudh Venkataramanan speed = "5 G"; 690cdedef59SAnirudh Venkataramanan break; 691cdedef59SAnirudh Venkataramanan case ICE_AQ_LINK_SPEED_2500MB: 692cdedef59SAnirudh Venkataramanan speed = "2.5 G"; 693cdedef59SAnirudh Venkataramanan break; 694cdedef59SAnirudh Venkataramanan case ICE_AQ_LINK_SPEED_1000MB: 695cdedef59SAnirudh Venkataramanan speed = "1 G"; 696cdedef59SAnirudh Venkataramanan break; 697cdedef59SAnirudh Venkataramanan case ICE_AQ_LINK_SPEED_100MB: 698cdedef59SAnirudh Venkataramanan speed = "100 M"; 699cdedef59SAnirudh Venkataramanan break; 700cdedef59SAnirudh Venkataramanan default: 701cdedef59SAnirudh Venkataramanan speed = "Unknown "; 702cdedef59SAnirudh Venkataramanan break; 703cdedef59SAnirudh Venkataramanan } 704cdedef59SAnirudh Venkataramanan 705cdedef59SAnirudh Venkataramanan switch (vsi->port_info->fc.current_mode) { 706cdedef59SAnirudh Venkataramanan case ICE_FC_FULL: 7072f2da36eSAnirudh Venkataramanan fc = "Rx/Tx"; 708cdedef59SAnirudh Venkataramanan break; 709cdedef59SAnirudh Venkataramanan case ICE_FC_TX_PAUSE: 7102f2da36eSAnirudh Venkataramanan fc = "Tx"; 711cdedef59SAnirudh Venkataramanan break; 712cdedef59SAnirudh Venkataramanan case ICE_FC_RX_PAUSE: 7132f2da36eSAnirudh Venkataramanan fc = "Rx"; 714cdedef59SAnirudh Venkataramanan break; 715203a068aSBrett Creeley case ICE_FC_NONE: 716203a068aSBrett Creeley fc = "None"; 717203a068aSBrett Creeley break; 718cdedef59SAnirudh Venkataramanan default: 719cdedef59SAnirudh Venkataramanan fc = "Unknown"; 720cdedef59SAnirudh Venkataramanan break; 721cdedef59SAnirudh Venkataramanan } 722cdedef59SAnirudh Venkataramanan 723f776b3acSPaul Greenwalt /* Get FEC mode based on negotiated link info */ 724f776b3acSPaul Greenwalt switch (vsi->port_info->phy.link_info.fec_info) { 725f776b3acSPaul Greenwalt case ICE_AQ_LINK_25G_RS_528_FEC_EN: 726f776b3acSPaul Greenwalt case ICE_AQ_LINK_25G_RS_544_FEC_EN: 727f776b3acSPaul Greenwalt fec = "RS-FEC"; 728f776b3acSPaul Greenwalt break; 729f776b3acSPaul Greenwalt case ICE_AQ_LINK_25G_KR_FEC_EN: 730f776b3acSPaul Greenwalt fec = "FC-FEC/BASE-R"; 731f776b3acSPaul Greenwalt break; 732f776b3acSPaul Greenwalt default: 733f776b3acSPaul Greenwalt fec = "NONE"; 734f776b3acSPaul Greenwalt break; 735f776b3acSPaul Greenwalt } 736f776b3acSPaul Greenwalt 73743260988SJesse Brandeburg /* check if autoneg completed, might be false due to not supported */ 73843260988SJesse Brandeburg if (vsi->port_info->phy.link_info.an_info & ICE_AQ_AN_COMPLETED) 73943260988SJesse Brandeburg an = "True"; 74043260988SJesse Brandeburg else 74143260988SJesse Brandeburg an = "False"; 74243260988SJesse Brandeburg 743f776b3acSPaul Greenwalt /* Get FEC mode requested based on PHY caps last SW configuration */ 7449efe35d0STony Nguyen caps = kzalloc(sizeof(*caps), GFP_KERNEL); 745f776b3acSPaul Greenwalt if (!caps) { 746f776b3acSPaul Greenwalt fec_req = "Unknown"; 7475ee30564SPaul Greenwalt an_advertised = "Unknown"; 748f776b3acSPaul Greenwalt goto done; 749f776b3acSPaul Greenwalt } 750f776b3acSPaul Greenwalt 751f776b3acSPaul Greenwalt status = ice_aq_get_phy_caps(vsi->port_info, false, 752d6730a87SAnirudh Venkataramanan ICE_AQC_REPORT_ACTIVE_CFG, caps, NULL); 753f776b3acSPaul Greenwalt if (status) 754f776b3acSPaul Greenwalt netdev_info(vsi->netdev, "Get phy capability failed.\n"); 755f776b3acSPaul Greenwalt 7565ee30564SPaul Greenwalt an_advertised = ice_is_phy_caps_an_enabled(caps) ? "On" : "Off"; 7575ee30564SPaul Greenwalt 758f776b3acSPaul Greenwalt if (caps->link_fec_options & ICE_AQC_PHY_FEC_25G_RS_528_REQ || 759f776b3acSPaul Greenwalt caps->link_fec_options & ICE_AQC_PHY_FEC_25G_RS_544_REQ) 760f776b3acSPaul Greenwalt fec_req = "RS-FEC"; 761f776b3acSPaul Greenwalt else if (caps->link_fec_options & ICE_AQC_PHY_FEC_10G_KR_40G_KR4_REQ || 762f776b3acSPaul Greenwalt caps->link_fec_options & ICE_AQC_PHY_FEC_25G_KR_REQ) 763f776b3acSPaul Greenwalt fec_req = "FC-FEC/BASE-R"; 764f776b3acSPaul Greenwalt else 765f776b3acSPaul Greenwalt fec_req = "NONE"; 766f776b3acSPaul Greenwalt 7679efe35d0STony Nguyen kfree(caps); 768f776b3acSPaul Greenwalt 769f776b3acSPaul Greenwalt done: 7705ee30564SPaul 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", 7715ee30564SPaul Greenwalt speed, fec_req, fec, an_advertised, an, fc); 7722e0ab37cSJesse Brandeburg ice_print_topo_conflict(vsi); 773cdedef59SAnirudh Venkataramanan } 774cdedef59SAnirudh Venkataramanan 775cdedef59SAnirudh Venkataramanan /** 776f9867df6SAnirudh Venkataramanan * ice_vsi_link_event - update the VSI's netdev 777f9867df6SAnirudh Venkataramanan * @vsi: the VSI on which the link event occurred 778f9867df6SAnirudh Venkataramanan * @link_up: whether or not the VSI needs to be set up or down 7790b28b702SAnirudh Venkataramanan */ 7800b28b702SAnirudh Venkataramanan static void ice_vsi_link_event(struct ice_vsi *vsi, bool link_up) 7810b28b702SAnirudh Venkataramanan { 782c2a23e00SBrett Creeley if (!vsi) 783c2a23e00SBrett Creeley return; 784c2a23e00SBrett Creeley 785e97fb1aeSAnirudh Venkataramanan if (test_bit(ICE_VSI_DOWN, vsi->state) || !vsi->netdev) 7860b28b702SAnirudh Venkataramanan return; 7870b28b702SAnirudh Venkataramanan 7880b28b702SAnirudh Venkataramanan if (vsi->type == ICE_VSI_PF) { 789c2a23e00SBrett Creeley if (link_up == netif_carrier_ok(vsi->netdev)) 7900b28b702SAnirudh Venkataramanan return; 791c2a23e00SBrett Creeley 7920b28b702SAnirudh Venkataramanan if (link_up) { 7930b28b702SAnirudh Venkataramanan netif_carrier_on(vsi->netdev); 7940b28b702SAnirudh Venkataramanan netif_tx_wake_all_queues(vsi->netdev); 7950b28b702SAnirudh Venkataramanan } else { 7960b28b702SAnirudh Venkataramanan netif_carrier_off(vsi->netdev); 7970b28b702SAnirudh Venkataramanan netif_tx_stop_all_queues(vsi->netdev); 7980b28b702SAnirudh Venkataramanan } 7990b28b702SAnirudh Venkataramanan } 8000b28b702SAnirudh Venkataramanan } 8010b28b702SAnirudh Venkataramanan 8020b28b702SAnirudh Venkataramanan /** 8037d9c9b79SDave Ertman * ice_set_dflt_mib - send a default config MIB to the FW 8047d9c9b79SDave Ertman * @pf: private PF struct 8057d9c9b79SDave Ertman * 8067d9c9b79SDave Ertman * This function sends a default configuration MIB to the FW. 8077d9c9b79SDave Ertman * 8087d9c9b79SDave Ertman * If this function errors out at any point, the driver is still able to 8097d9c9b79SDave Ertman * function. The main impact is that LFC may not operate as expected. 8107d9c9b79SDave Ertman * Therefore an error state in this function should be treated with a DBG 8117d9c9b79SDave Ertman * message and continue on with driver rebuild/reenable. 8127d9c9b79SDave Ertman */ 8137d9c9b79SDave Ertman static void ice_set_dflt_mib(struct ice_pf *pf) 8147d9c9b79SDave Ertman { 8157d9c9b79SDave Ertman struct device *dev = ice_pf_to_dev(pf); 8167d9c9b79SDave Ertman u8 mib_type, *buf, *lldpmib = NULL; 8177d9c9b79SDave Ertman u16 len, typelen, offset = 0; 8187d9c9b79SDave Ertman struct ice_lldp_org_tlv *tlv; 81912aae8f1SBruce Allan struct ice_hw *hw = &pf->hw; 8207d9c9b79SDave Ertman u32 ouisubtype; 8217d9c9b79SDave Ertman 8227d9c9b79SDave Ertman mib_type = SET_LOCAL_MIB_TYPE_LOCAL_MIB; 8237d9c9b79SDave Ertman lldpmib = kzalloc(ICE_LLDPDU_SIZE, GFP_KERNEL); 8247d9c9b79SDave Ertman if (!lldpmib) { 8257d9c9b79SDave Ertman dev_dbg(dev, "%s Failed to allocate MIB memory\n", 8267d9c9b79SDave Ertman __func__); 8277d9c9b79SDave Ertman return; 8287d9c9b79SDave Ertman } 8297d9c9b79SDave Ertman 8307d9c9b79SDave Ertman /* Add ETS CFG TLV */ 8317d9c9b79SDave Ertman tlv = (struct ice_lldp_org_tlv *)lldpmib; 8327d9c9b79SDave Ertman typelen = ((ICE_TLV_TYPE_ORG << ICE_LLDP_TLV_TYPE_S) | 8337d9c9b79SDave Ertman ICE_IEEE_ETS_TLV_LEN); 8347d9c9b79SDave Ertman tlv->typelen = htons(typelen); 8357d9c9b79SDave Ertman ouisubtype = ((ICE_IEEE_8021QAZ_OUI << ICE_LLDP_TLV_OUI_S) | 8367d9c9b79SDave Ertman ICE_IEEE_SUBTYPE_ETS_CFG); 8377d9c9b79SDave Ertman tlv->ouisubtype = htonl(ouisubtype); 8387d9c9b79SDave Ertman 8397d9c9b79SDave Ertman buf = tlv->tlvinfo; 8407d9c9b79SDave Ertman buf[0] = 0; 8417d9c9b79SDave Ertman 8427d9c9b79SDave Ertman /* ETS CFG all UPs map to TC 0. Next 4 (1 - 4) Octets = 0. 8437d9c9b79SDave Ertman * Octets 5 - 12 are BW values, set octet 5 to 100% BW. 8447d9c9b79SDave Ertman * Octets 13 - 20 are TSA values - leave as zeros 8457d9c9b79SDave Ertman */ 8467d9c9b79SDave Ertman buf[5] = 0x64; 8477d9c9b79SDave Ertman len = (typelen & ICE_LLDP_TLV_LEN_M) >> ICE_LLDP_TLV_LEN_S; 8487d9c9b79SDave Ertman offset += len + 2; 8497d9c9b79SDave Ertman tlv = (struct ice_lldp_org_tlv *) 8507d9c9b79SDave Ertman ((char *)tlv + sizeof(tlv->typelen) + len); 8517d9c9b79SDave Ertman 8527d9c9b79SDave Ertman /* Add ETS REC TLV */ 8537d9c9b79SDave Ertman buf = tlv->tlvinfo; 8547d9c9b79SDave Ertman tlv->typelen = htons(typelen); 8557d9c9b79SDave Ertman 8567d9c9b79SDave Ertman ouisubtype = ((ICE_IEEE_8021QAZ_OUI << ICE_LLDP_TLV_OUI_S) | 8577d9c9b79SDave Ertman ICE_IEEE_SUBTYPE_ETS_REC); 8587d9c9b79SDave Ertman tlv->ouisubtype = htonl(ouisubtype); 8597d9c9b79SDave Ertman 8607d9c9b79SDave Ertman /* First octet of buf is reserved 8617d9c9b79SDave Ertman * Octets 1 - 4 map UP to TC - all UPs map to zero 8627d9c9b79SDave Ertman * Octets 5 - 12 are BW values - set TC 0 to 100%. 8637d9c9b79SDave Ertman * Octets 13 - 20 are TSA value - leave as zeros 8647d9c9b79SDave Ertman */ 8657d9c9b79SDave Ertman buf[5] = 0x64; 8667d9c9b79SDave Ertman offset += len + 2; 8677d9c9b79SDave Ertman tlv = (struct ice_lldp_org_tlv *) 8687d9c9b79SDave Ertman ((char *)tlv + sizeof(tlv->typelen) + len); 8697d9c9b79SDave Ertman 8707d9c9b79SDave Ertman /* Add PFC CFG TLV */ 8717d9c9b79SDave Ertman typelen = ((ICE_TLV_TYPE_ORG << ICE_LLDP_TLV_TYPE_S) | 8727d9c9b79SDave Ertman ICE_IEEE_PFC_TLV_LEN); 8737d9c9b79SDave Ertman tlv->typelen = htons(typelen); 8747d9c9b79SDave Ertman 8757d9c9b79SDave Ertman ouisubtype = ((ICE_IEEE_8021QAZ_OUI << ICE_LLDP_TLV_OUI_S) | 8767d9c9b79SDave Ertman ICE_IEEE_SUBTYPE_PFC_CFG); 8777d9c9b79SDave Ertman tlv->ouisubtype = htonl(ouisubtype); 8787d9c9b79SDave Ertman 8797d9c9b79SDave Ertman /* Octet 1 left as all zeros - PFC disabled */ 8807d9c9b79SDave Ertman buf[0] = 0x08; 8817d9c9b79SDave Ertman len = (typelen & ICE_LLDP_TLV_LEN_M) >> ICE_LLDP_TLV_LEN_S; 8827d9c9b79SDave Ertman offset += len + 2; 8837d9c9b79SDave Ertman 8847d9c9b79SDave Ertman if (ice_aq_set_lldp_mib(hw, mib_type, (void *)lldpmib, offset, NULL)) 8857d9c9b79SDave Ertman dev_dbg(dev, "%s Failed to set default LLDP MIB\n", __func__); 8867d9c9b79SDave Ertman 8877d9c9b79SDave Ertman kfree(lldpmib); 8887d9c9b79SDave Ertman } 8897d9c9b79SDave Ertman 8907d9c9b79SDave Ertman /** 891c77849f5SAnirudh Venkataramanan * ice_check_module_power 892c77849f5SAnirudh Venkataramanan * @pf: pointer to PF struct 893c77849f5SAnirudh Venkataramanan * @link_cfg_err: bitmap from the link info structure 894c77849f5SAnirudh Venkataramanan * 895c77849f5SAnirudh Venkataramanan * check module power level returned by a previous call to aq_get_link_info 896c77849f5SAnirudh Venkataramanan * and print error messages if module power level is not supported 897c77849f5SAnirudh Venkataramanan */ 898c77849f5SAnirudh Venkataramanan static void ice_check_module_power(struct ice_pf *pf, u8 link_cfg_err) 899c77849f5SAnirudh Venkataramanan { 900c77849f5SAnirudh Venkataramanan /* if module power level is supported, clear the flag */ 901c77849f5SAnirudh Venkataramanan if (!(link_cfg_err & (ICE_AQ_LINK_INVAL_MAX_POWER_LIMIT | 902c77849f5SAnirudh Venkataramanan ICE_AQ_LINK_MODULE_POWER_UNSUPPORTED))) { 903c77849f5SAnirudh Venkataramanan clear_bit(ICE_FLAG_MOD_POWER_UNSUPPORTED, pf->flags); 904c77849f5SAnirudh Venkataramanan return; 905c77849f5SAnirudh Venkataramanan } 906c77849f5SAnirudh Venkataramanan 907c77849f5SAnirudh Venkataramanan /* if ICE_FLAG_MOD_POWER_UNSUPPORTED was previously set and the 908c77849f5SAnirudh Venkataramanan * above block didn't clear this bit, there's nothing to do 909c77849f5SAnirudh Venkataramanan */ 910c77849f5SAnirudh Venkataramanan if (test_bit(ICE_FLAG_MOD_POWER_UNSUPPORTED, pf->flags)) 911c77849f5SAnirudh Venkataramanan return; 912c77849f5SAnirudh Venkataramanan 913c77849f5SAnirudh Venkataramanan if (link_cfg_err & ICE_AQ_LINK_INVAL_MAX_POWER_LIMIT) { 914c77849f5SAnirudh Venkataramanan dev_err(ice_pf_to_dev(pf), "The installed module is incompatible with the device's NVM image. Cannot start link\n"); 915c77849f5SAnirudh Venkataramanan set_bit(ICE_FLAG_MOD_POWER_UNSUPPORTED, pf->flags); 916c77849f5SAnirudh Venkataramanan } else if (link_cfg_err & ICE_AQ_LINK_MODULE_POWER_UNSUPPORTED) { 917c77849f5SAnirudh Venkataramanan dev_err(ice_pf_to_dev(pf), "The module's power requirements exceed the device's power supply. Cannot start link\n"); 918c77849f5SAnirudh Venkataramanan set_bit(ICE_FLAG_MOD_POWER_UNSUPPORTED, pf->flags); 919c77849f5SAnirudh Venkataramanan } 920c77849f5SAnirudh Venkataramanan } 921c77849f5SAnirudh Venkataramanan 922c77849f5SAnirudh Venkataramanan /** 9230b28b702SAnirudh Venkataramanan * ice_link_event - process the link event 9242f2da36eSAnirudh Venkataramanan * @pf: PF that the link event is associated with 9250b28b702SAnirudh Venkataramanan * @pi: port_info for the port that the link event is associated with 926c2a23e00SBrett Creeley * @link_up: true if the physical link is up and false if it is down 927c2a23e00SBrett Creeley * @link_speed: current link speed received from the link event 9280b28b702SAnirudh Venkataramanan * 929c2a23e00SBrett Creeley * Returns 0 on success and negative on failure 9300b28b702SAnirudh Venkataramanan */ 9310b28b702SAnirudh Venkataramanan static int 932c2a23e00SBrett Creeley ice_link_event(struct ice_pf *pf, struct ice_port_info *pi, bool link_up, 933c2a23e00SBrett Creeley u16 link_speed) 9340b28b702SAnirudh Venkataramanan { 9354015d11eSBrett Creeley struct device *dev = ice_pf_to_dev(pf); 9360b28b702SAnirudh Venkataramanan struct ice_phy_info *phy_info; 937d348d517SAnirudh Venkataramanan enum ice_status status; 938c2a23e00SBrett Creeley struct ice_vsi *vsi; 939c2a23e00SBrett Creeley u16 old_link_speed; 940c2a23e00SBrett Creeley bool old_link; 9410b28b702SAnirudh Venkataramanan 9420b28b702SAnirudh Venkataramanan phy_info = &pi->phy; 9430b28b702SAnirudh Venkataramanan phy_info->link_info_old = phy_info->link_info; 9440b28b702SAnirudh Venkataramanan 945c2a23e00SBrett Creeley old_link = !!(phy_info->link_info_old.link_info & ICE_AQ_LINK_UP); 9460b28b702SAnirudh Venkataramanan old_link_speed = phy_info->link_info_old.link_speed; 9470b28b702SAnirudh Venkataramanan 948c2a23e00SBrett Creeley /* update the link info structures and re-enable link events, 949c2a23e00SBrett Creeley * don't bail on failure due to other book keeping needed 950c2a23e00SBrett Creeley */ 951d348d517SAnirudh Venkataramanan status = ice_update_link_info(pi); 952d348d517SAnirudh Venkataramanan if (status) 953d348d517SAnirudh Venkataramanan dev_dbg(dev, "Failed to update link status on port %d, err %s aq_err %s\n", 954d348d517SAnirudh Venkataramanan pi->lport, ice_stat_str(status), 955d348d517SAnirudh Venkataramanan ice_aq_str(pi->hw->adminq.sq_last_status)); 9560b28b702SAnirudh Venkataramanan 957c77849f5SAnirudh Venkataramanan ice_check_module_power(pf, pi->phy.link_info.link_cfg_err); 958c77849f5SAnirudh Venkataramanan 9590ce6c34aSDave Ertman /* Check if the link state is up after updating link info, and treat 9600ce6c34aSDave Ertman * this event as an UP event since the link is actually UP now. 9610ce6c34aSDave Ertman */ 9620ce6c34aSDave Ertman if (phy_info->link_info.link_info & ICE_AQ_LINK_UP) 9630ce6c34aSDave Ertman link_up = true; 9640ce6c34aSDave Ertman 965208ff751SAnirudh Venkataramanan vsi = ice_get_main_vsi(pf); 9660b28b702SAnirudh Venkataramanan if (!vsi || !vsi->port_info) 967c2a23e00SBrett Creeley return -EINVAL; 9680b28b702SAnirudh Venkataramanan 9696d599946STony Nguyen /* turn off PHY if media was removed */ 9706d599946STony Nguyen if (!test_bit(ICE_FLAG_NO_MEDIA, pf->flags) && 9716d599946STony Nguyen !(pi->phy.link_info.link_info & ICE_AQ_MEDIA_AVAILABLE)) { 9726d599946STony Nguyen set_bit(ICE_FLAG_NO_MEDIA, pf->flags); 973d348d517SAnirudh Venkataramanan ice_set_link(vsi, false); 9746d599946STony Nguyen } 9756d599946STony Nguyen 9761a3571b5SPaul Greenwalt /* if the old link up/down and speed is the same as the new */ 9771a3571b5SPaul Greenwalt if (link_up == old_link && link_speed == old_link_speed) 978d348d517SAnirudh Venkataramanan return 0; 9791a3571b5SPaul Greenwalt 9807d9c9b79SDave Ertman if (ice_is_dcb_active(pf)) { 9817d9c9b79SDave Ertman if (test_bit(ICE_FLAG_DCB_ENA, pf->flags)) 982242b5e06SDave Ertman ice_dcb_rebuild(pf); 9837d9c9b79SDave Ertman } else { 9847d9c9b79SDave Ertman if (link_up) 9857d9c9b79SDave Ertman ice_set_dflt_mib(pf); 9867d9c9b79SDave Ertman } 987c2a23e00SBrett Creeley ice_vsi_link_event(vsi, link_up); 988c2a23e00SBrett Creeley ice_print_link_msg(vsi, link_up); 9890b28b702SAnirudh Venkataramanan 99053b8decbSAnirudh Venkataramanan ice_vc_notify_link_state(pf); 99153b8decbSAnirudh Venkataramanan 992d348d517SAnirudh Venkataramanan return 0; 9930b28b702SAnirudh Venkataramanan } 9940b28b702SAnirudh Venkataramanan 9950b28b702SAnirudh Venkataramanan /** 9964f4be03bSAnirudh Venkataramanan * ice_watchdog_subtask - periodic tasks not using event driven scheduling 9974f4be03bSAnirudh Venkataramanan * @pf: board private structure 9980b28b702SAnirudh Venkataramanan */ 9994f4be03bSAnirudh Venkataramanan static void ice_watchdog_subtask(struct ice_pf *pf) 10000b28b702SAnirudh Venkataramanan { 10014f4be03bSAnirudh Venkataramanan int i; 10020b28b702SAnirudh Venkataramanan 10034f4be03bSAnirudh Venkataramanan /* if interface is down do nothing */ 10047e408e07SAnirudh Venkataramanan if (test_bit(ICE_DOWN, pf->state) || 10057e408e07SAnirudh Venkataramanan test_bit(ICE_CFG_BUSY, pf->state)) 10064f4be03bSAnirudh Venkataramanan return; 10070b28b702SAnirudh Venkataramanan 10084f4be03bSAnirudh Venkataramanan /* make sure we don't do these things too often */ 10094f4be03bSAnirudh Venkataramanan if (time_before(jiffies, 10104f4be03bSAnirudh Venkataramanan pf->serv_tmr_prev + pf->serv_tmr_period)) 10114f4be03bSAnirudh Venkataramanan return; 10120b28b702SAnirudh Venkataramanan 10134f4be03bSAnirudh Venkataramanan pf->serv_tmr_prev = jiffies; 10144f4be03bSAnirudh Venkataramanan 10154f4be03bSAnirudh Venkataramanan /* Update the stats for active netdevs so the network stack 10164f4be03bSAnirudh Venkataramanan * can look at updated numbers whenever it cares to 10174f4be03bSAnirudh Venkataramanan */ 10184f4be03bSAnirudh Venkataramanan ice_update_pf_stats(pf); 101980ed404aSBrett Creeley ice_for_each_vsi(pf, i) 10204f4be03bSAnirudh Venkataramanan if (pf->vsi[i] && pf->vsi[i]->netdev) 10214f4be03bSAnirudh Venkataramanan ice_update_vsi_stats(pf->vsi[i]); 10220b28b702SAnirudh Venkataramanan } 10230b28b702SAnirudh Venkataramanan 10240b28b702SAnirudh Venkataramanan /** 1025250c3b3eSBrett Creeley * ice_init_link_events - enable/initialize link events 1026250c3b3eSBrett Creeley * @pi: pointer to the port_info instance 1027250c3b3eSBrett Creeley * 1028250c3b3eSBrett Creeley * Returns -EIO on failure, 0 on success 1029250c3b3eSBrett Creeley */ 1030250c3b3eSBrett Creeley static int ice_init_link_events(struct ice_port_info *pi) 1031250c3b3eSBrett Creeley { 1032250c3b3eSBrett Creeley u16 mask; 1033250c3b3eSBrett Creeley 1034250c3b3eSBrett Creeley mask = ~((u16)(ICE_AQ_LINK_EVENT_UPDOWN | ICE_AQ_LINK_EVENT_MEDIA_NA | 1035250c3b3eSBrett Creeley ICE_AQ_LINK_EVENT_MODULE_QUAL_FAIL)); 1036250c3b3eSBrett Creeley 1037250c3b3eSBrett Creeley if (ice_aq_set_event_mask(pi->hw, pi->lport, mask, NULL)) { 103819cce2c6SAnirudh Venkataramanan dev_dbg(ice_hw_to_dev(pi->hw), "Failed to set link event mask for port %d\n", 1039250c3b3eSBrett Creeley pi->lport); 1040250c3b3eSBrett Creeley return -EIO; 1041250c3b3eSBrett Creeley } 1042250c3b3eSBrett Creeley 1043250c3b3eSBrett Creeley if (ice_aq_get_link_info(pi, true, NULL, NULL)) { 104419cce2c6SAnirudh Venkataramanan dev_dbg(ice_hw_to_dev(pi->hw), "Failed to enable link events for port %d\n", 1045250c3b3eSBrett Creeley pi->lport); 1046250c3b3eSBrett Creeley return -EIO; 1047250c3b3eSBrett Creeley } 1048250c3b3eSBrett Creeley 1049250c3b3eSBrett Creeley return 0; 1050250c3b3eSBrett Creeley } 1051250c3b3eSBrett Creeley 1052250c3b3eSBrett Creeley /** 1053250c3b3eSBrett Creeley * ice_handle_link_event - handle link event via ARQ 10542f2da36eSAnirudh Venkataramanan * @pf: PF that the link event is associated with 1055c2a23e00SBrett Creeley * @event: event structure containing link status info 1056250c3b3eSBrett Creeley */ 1057c2a23e00SBrett Creeley static int 1058c2a23e00SBrett Creeley ice_handle_link_event(struct ice_pf *pf, struct ice_rq_event_info *event) 1059250c3b3eSBrett Creeley { 1060c2a23e00SBrett Creeley struct ice_aqc_get_link_status_data *link_data; 1061250c3b3eSBrett Creeley struct ice_port_info *port_info; 1062250c3b3eSBrett Creeley int status; 1063250c3b3eSBrett Creeley 1064c2a23e00SBrett Creeley link_data = (struct ice_aqc_get_link_status_data *)event->msg_buf; 1065250c3b3eSBrett Creeley port_info = pf->hw.port_info; 1066250c3b3eSBrett Creeley if (!port_info) 1067250c3b3eSBrett Creeley return -EINVAL; 1068250c3b3eSBrett Creeley 1069c2a23e00SBrett Creeley status = ice_link_event(pf, port_info, 1070c2a23e00SBrett Creeley !!(link_data->link_info & ICE_AQ_LINK_UP), 1071c2a23e00SBrett Creeley le16_to_cpu(link_data->link_speed)); 1072250c3b3eSBrett Creeley if (status) 107319cce2c6SAnirudh Venkataramanan dev_dbg(ice_pf_to_dev(pf), "Could not process link event, error %d\n", 107419cce2c6SAnirudh Venkataramanan status); 1075250c3b3eSBrett Creeley 1076250c3b3eSBrett Creeley return status; 1077250c3b3eSBrett Creeley } 1078250c3b3eSBrett Creeley 1079d69ea414SJacob Keller enum ice_aq_task_state { 1080d69ea414SJacob Keller ICE_AQ_TASK_WAITING = 0, 1081d69ea414SJacob Keller ICE_AQ_TASK_COMPLETE, 1082d69ea414SJacob Keller ICE_AQ_TASK_CANCELED, 1083d69ea414SJacob Keller }; 1084d69ea414SJacob Keller 1085d69ea414SJacob Keller struct ice_aq_task { 1086d69ea414SJacob Keller struct hlist_node entry; 1087d69ea414SJacob Keller 1088d69ea414SJacob Keller u16 opcode; 1089d69ea414SJacob Keller struct ice_rq_event_info *event; 1090d69ea414SJacob Keller enum ice_aq_task_state state; 1091d69ea414SJacob Keller }; 1092d69ea414SJacob Keller 1093d69ea414SJacob Keller /** 1094ef860480STony Nguyen * ice_aq_wait_for_event - Wait for an AdminQ event from firmware 1095d69ea414SJacob Keller * @pf: pointer to the PF private structure 1096d69ea414SJacob Keller * @opcode: the opcode to wait for 1097d69ea414SJacob Keller * @timeout: how long to wait, in jiffies 1098d69ea414SJacob Keller * @event: storage for the event info 1099d69ea414SJacob Keller * 1100d69ea414SJacob Keller * Waits for a specific AdminQ completion event on the ARQ for a given PF. The 1101d69ea414SJacob Keller * current thread will be put to sleep until the specified event occurs or 1102d69ea414SJacob Keller * until the given timeout is reached. 1103d69ea414SJacob Keller * 1104d69ea414SJacob Keller * To obtain only the descriptor contents, pass an event without an allocated 1105d69ea414SJacob Keller * msg_buf. If the complete data buffer is desired, allocate the 1106d69ea414SJacob Keller * event->msg_buf with enough space ahead of time. 1107d69ea414SJacob Keller * 1108d69ea414SJacob Keller * Returns: zero on success, or a negative error code on failure. 1109d69ea414SJacob Keller */ 1110d69ea414SJacob Keller int ice_aq_wait_for_event(struct ice_pf *pf, u16 opcode, unsigned long timeout, 1111d69ea414SJacob Keller struct ice_rq_event_info *event) 1112d69ea414SJacob Keller { 11131e8249ccSJacob Keller struct device *dev = ice_pf_to_dev(pf); 1114d69ea414SJacob Keller struct ice_aq_task *task; 11151e8249ccSJacob Keller unsigned long start; 1116d69ea414SJacob Keller long ret; 1117d69ea414SJacob Keller int err; 1118d69ea414SJacob Keller 1119d69ea414SJacob Keller task = kzalloc(sizeof(*task), GFP_KERNEL); 1120d69ea414SJacob Keller if (!task) 1121d69ea414SJacob Keller return -ENOMEM; 1122d69ea414SJacob Keller 1123d69ea414SJacob Keller INIT_HLIST_NODE(&task->entry); 1124d69ea414SJacob Keller task->opcode = opcode; 1125d69ea414SJacob Keller task->event = event; 1126d69ea414SJacob Keller task->state = ICE_AQ_TASK_WAITING; 1127d69ea414SJacob Keller 1128d69ea414SJacob Keller spin_lock_bh(&pf->aq_wait_lock); 1129d69ea414SJacob Keller hlist_add_head(&task->entry, &pf->aq_wait_list); 1130d69ea414SJacob Keller spin_unlock_bh(&pf->aq_wait_lock); 1131d69ea414SJacob Keller 11321e8249ccSJacob Keller start = jiffies; 11331e8249ccSJacob Keller 1134d69ea414SJacob Keller ret = wait_event_interruptible_timeout(pf->aq_wait_queue, task->state, 1135d69ea414SJacob Keller timeout); 1136d69ea414SJacob Keller switch (task->state) { 1137d69ea414SJacob Keller case ICE_AQ_TASK_WAITING: 1138d69ea414SJacob Keller err = ret < 0 ? ret : -ETIMEDOUT; 1139d69ea414SJacob Keller break; 1140d69ea414SJacob Keller case ICE_AQ_TASK_CANCELED: 1141d69ea414SJacob Keller err = ret < 0 ? ret : -ECANCELED; 1142d69ea414SJacob Keller break; 1143d69ea414SJacob Keller case ICE_AQ_TASK_COMPLETE: 1144d69ea414SJacob Keller err = ret < 0 ? ret : 0; 1145d69ea414SJacob Keller break; 1146d69ea414SJacob Keller default: 1147d69ea414SJacob Keller WARN(1, "Unexpected AdminQ wait task state %u", task->state); 1148d69ea414SJacob Keller err = -EINVAL; 1149d69ea414SJacob Keller break; 1150d69ea414SJacob Keller } 1151d69ea414SJacob Keller 11521e8249ccSJacob Keller dev_dbg(dev, "Waited %u msecs (max %u msecs) for firmware response to op 0x%04x\n", 11531e8249ccSJacob Keller jiffies_to_msecs(jiffies - start), 11541e8249ccSJacob Keller jiffies_to_msecs(timeout), 11551e8249ccSJacob Keller opcode); 11561e8249ccSJacob Keller 1157d69ea414SJacob Keller spin_lock_bh(&pf->aq_wait_lock); 1158d69ea414SJacob Keller hlist_del(&task->entry); 1159d69ea414SJacob Keller spin_unlock_bh(&pf->aq_wait_lock); 1160d69ea414SJacob Keller kfree(task); 1161d69ea414SJacob Keller 1162d69ea414SJacob Keller return err; 1163d69ea414SJacob Keller } 1164d69ea414SJacob Keller 1165d69ea414SJacob Keller /** 1166d69ea414SJacob Keller * ice_aq_check_events - Check if any thread is waiting for an AdminQ event 1167d69ea414SJacob Keller * @pf: pointer to the PF private structure 1168d69ea414SJacob Keller * @opcode: the opcode of the event 1169d69ea414SJacob Keller * @event: the event to check 1170d69ea414SJacob Keller * 1171d69ea414SJacob Keller * Loops over the current list of pending threads waiting for an AdminQ event. 1172d69ea414SJacob Keller * For each matching task, copy the contents of the event into the task 1173d69ea414SJacob Keller * structure and wake up the thread. 1174d69ea414SJacob Keller * 1175d69ea414SJacob Keller * If multiple threads wait for the same opcode, they will all be woken up. 1176d69ea414SJacob Keller * 1177d69ea414SJacob Keller * Note that event->msg_buf will only be duplicated if the event has a buffer 1178d69ea414SJacob Keller * with enough space already allocated. Otherwise, only the descriptor and 1179d69ea414SJacob Keller * message length will be copied. 1180d69ea414SJacob Keller * 1181d69ea414SJacob Keller * Returns: true if an event was found, false otherwise 1182d69ea414SJacob Keller */ 1183d69ea414SJacob Keller static void ice_aq_check_events(struct ice_pf *pf, u16 opcode, 1184d69ea414SJacob Keller struct ice_rq_event_info *event) 1185d69ea414SJacob Keller { 1186d69ea414SJacob Keller struct ice_aq_task *task; 1187d69ea414SJacob Keller bool found = false; 1188d69ea414SJacob Keller 1189d69ea414SJacob Keller spin_lock_bh(&pf->aq_wait_lock); 1190d69ea414SJacob Keller hlist_for_each_entry(task, &pf->aq_wait_list, entry) { 1191d69ea414SJacob Keller if (task->state || task->opcode != opcode) 1192d69ea414SJacob Keller continue; 1193d69ea414SJacob Keller 1194d69ea414SJacob Keller memcpy(&task->event->desc, &event->desc, sizeof(event->desc)); 1195d69ea414SJacob Keller task->event->msg_len = event->msg_len; 1196d69ea414SJacob Keller 1197d69ea414SJacob Keller /* Only copy the data buffer if a destination was set */ 1198d69ea414SJacob Keller if (task->event->msg_buf && 1199d69ea414SJacob Keller task->event->buf_len > event->buf_len) { 1200d69ea414SJacob Keller memcpy(task->event->msg_buf, event->msg_buf, 1201d69ea414SJacob Keller event->buf_len); 1202d69ea414SJacob Keller task->event->buf_len = event->buf_len; 1203d69ea414SJacob Keller } 1204d69ea414SJacob Keller 1205d69ea414SJacob Keller task->state = ICE_AQ_TASK_COMPLETE; 1206d69ea414SJacob Keller found = true; 1207d69ea414SJacob Keller } 1208d69ea414SJacob Keller spin_unlock_bh(&pf->aq_wait_lock); 1209d69ea414SJacob Keller 1210d69ea414SJacob Keller if (found) 1211d69ea414SJacob Keller wake_up(&pf->aq_wait_queue); 1212d69ea414SJacob Keller } 1213d69ea414SJacob Keller 1214d69ea414SJacob Keller /** 1215d69ea414SJacob Keller * ice_aq_cancel_waiting_tasks - Immediately cancel all waiting tasks 1216d69ea414SJacob Keller * @pf: the PF private structure 1217d69ea414SJacob Keller * 1218d69ea414SJacob Keller * Set all waiting tasks to ICE_AQ_TASK_CANCELED, and wake up their threads. 1219d69ea414SJacob Keller * This will then cause ice_aq_wait_for_event to exit with -ECANCELED. 1220d69ea414SJacob Keller */ 1221d69ea414SJacob Keller static void ice_aq_cancel_waiting_tasks(struct ice_pf *pf) 1222d69ea414SJacob Keller { 1223d69ea414SJacob Keller struct ice_aq_task *task; 1224d69ea414SJacob Keller 1225d69ea414SJacob Keller spin_lock_bh(&pf->aq_wait_lock); 1226d69ea414SJacob Keller hlist_for_each_entry(task, &pf->aq_wait_list, entry) 1227d69ea414SJacob Keller task->state = ICE_AQ_TASK_CANCELED; 1228d69ea414SJacob Keller spin_unlock_bh(&pf->aq_wait_lock); 1229d69ea414SJacob Keller 1230d69ea414SJacob Keller wake_up(&pf->aq_wait_queue); 1231d69ea414SJacob Keller } 1232d69ea414SJacob Keller 1233250c3b3eSBrett Creeley /** 1234940b61afSAnirudh Venkataramanan * __ice_clean_ctrlq - helper function to clean controlq rings 1235940b61afSAnirudh Venkataramanan * @pf: ptr to struct ice_pf 1236940b61afSAnirudh Venkataramanan * @q_type: specific Control queue type 1237940b61afSAnirudh Venkataramanan */ 1238940b61afSAnirudh Venkataramanan static int __ice_clean_ctrlq(struct ice_pf *pf, enum ice_ctl_q q_type) 1239940b61afSAnirudh Venkataramanan { 12404015d11eSBrett Creeley struct device *dev = ice_pf_to_dev(pf); 1241940b61afSAnirudh Venkataramanan struct ice_rq_event_info event; 1242940b61afSAnirudh Venkataramanan struct ice_hw *hw = &pf->hw; 1243940b61afSAnirudh Venkataramanan struct ice_ctl_q_info *cq; 1244940b61afSAnirudh Venkataramanan u16 pending, i = 0; 1245940b61afSAnirudh Venkataramanan const char *qtype; 1246940b61afSAnirudh Venkataramanan u32 oldval, val; 1247940b61afSAnirudh Venkataramanan 12480b28b702SAnirudh Venkataramanan /* Do not clean control queue if/when PF reset fails */ 12497e408e07SAnirudh Venkataramanan if (test_bit(ICE_RESET_FAILED, pf->state)) 12500b28b702SAnirudh Venkataramanan return 0; 12510b28b702SAnirudh Venkataramanan 1252940b61afSAnirudh Venkataramanan switch (q_type) { 1253940b61afSAnirudh Venkataramanan case ICE_CTL_Q_ADMIN: 1254940b61afSAnirudh Venkataramanan cq = &hw->adminq; 1255940b61afSAnirudh Venkataramanan qtype = "Admin"; 1256940b61afSAnirudh Venkataramanan break; 12578f5ee3c4SJacob Keller case ICE_CTL_Q_SB: 12588f5ee3c4SJacob Keller cq = &hw->sbq; 12598f5ee3c4SJacob Keller qtype = "Sideband"; 12608f5ee3c4SJacob Keller break; 126175d2b253SAnirudh Venkataramanan case ICE_CTL_Q_MAILBOX: 126275d2b253SAnirudh Venkataramanan cq = &hw->mailboxq; 126375d2b253SAnirudh Venkataramanan qtype = "Mailbox"; 12640891c896SVignesh Sridhar /* we are going to try to detect a malicious VF, so set the 12650891c896SVignesh Sridhar * state to begin detection 12660891c896SVignesh Sridhar */ 12670891c896SVignesh Sridhar hw->mbx_snapshot.mbx_buf.state = ICE_MAL_VF_DETECT_STATE_NEW_SNAPSHOT; 126875d2b253SAnirudh Venkataramanan break; 1269940b61afSAnirudh Venkataramanan default: 12704015d11eSBrett Creeley dev_warn(dev, "Unknown control queue type 0x%x\n", q_type); 1271940b61afSAnirudh Venkataramanan return 0; 1272940b61afSAnirudh Venkataramanan } 1273940b61afSAnirudh Venkataramanan 1274940b61afSAnirudh Venkataramanan /* check for error indications - PF_xx_AxQLEN register layout for 1275940b61afSAnirudh Venkataramanan * FW/MBX/SB are identical so just use defines for PF_FW_AxQLEN. 1276940b61afSAnirudh Venkataramanan */ 1277940b61afSAnirudh Venkataramanan val = rd32(hw, cq->rq.len); 1278940b61afSAnirudh Venkataramanan if (val & (PF_FW_ARQLEN_ARQVFE_M | PF_FW_ARQLEN_ARQOVFL_M | 1279940b61afSAnirudh Venkataramanan PF_FW_ARQLEN_ARQCRIT_M)) { 1280940b61afSAnirudh Venkataramanan oldval = val; 1281940b61afSAnirudh Venkataramanan if (val & PF_FW_ARQLEN_ARQVFE_M) 12824015d11eSBrett Creeley dev_dbg(dev, "%s Receive Queue VF Error detected\n", 12834015d11eSBrett Creeley qtype); 1284940b61afSAnirudh Venkataramanan if (val & PF_FW_ARQLEN_ARQOVFL_M) { 128519cce2c6SAnirudh Venkataramanan dev_dbg(dev, "%s Receive Queue Overflow Error detected\n", 1286940b61afSAnirudh Venkataramanan qtype); 1287940b61afSAnirudh Venkataramanan } 1288940b61afSAnirudh Venkataramanan if (val & PF_FW_ARQLEN_ARQCRIT_M) 128919cce2c6SAnirudh Venkataramanan dev_dbg(dev, "%s Receive Queue Critical Error detected\n", 1290940b61afSAnirudh Venkataramanan qtype); 1291940b61afSAnirudh Venkataramanan val &= ~(PF_FW_ARQLEN_ARQVFE_M | PF_FW_ARQLEN_ARQOVFL_M | 1292940b61afSAnirudh Venkataramanan PF_FW_ARQLEN_ARQCRIT_M); 1293940b61afSAnirudh Venkataramanan if (oldval != val) 1294940b61afSAnirudh Venkataramanan wr32(hw, cq->rq.len, val); 1295940b61afSAnirudh Venkataramanan } 1296940b61afSAnirudh Venkataramanan 1297940b61afSAnirudh Venkataramanan val = rd32(hw, cq->sq.len); 1298940b61afSAnirudh Venkataramanan if (val & (PF_FW_ATQLEN_ATQVFE_M | PF_FW_ATQLEN_ATQOVFL_M | 1299940b61afSAnirudh Venkataramanan PF_FW_ATQLEN_ATQCRIT_M)) { 1300940b61afSAnirudh Venkataramanan oldval = val; 1301940b61afSAnirudh Venkataramanan if (val & PF_FW_ATQLEN_ATQVFE_M) 130219cce2c6SAnirudh Venkataramanan dev_dbg(dev, "%s Send Queue VF Error detected\n", 130319cce2c6SAnirudh Venkataramanan qtype); 1304940b61afSAnirudh Venkataramanan if (val & PF_FW_ATQLEN_ATQOVFL_M) { 13054015d11eSBrett Creeley dev_dbg(dev, "%s Send Queue Overflow Error detected\n", 1306940b61afSAnirudh Venkataramanan qtype); 1307940b61afSAnirudh Venkataramanan } 1308940b61afSAnirudh Venkataramanan if (val & PF_FW_ATQLEN_ATQCRIT_M) 13094015d11eSBrett Creeley dev_dbg(dev, "%s Send Queue Critical Error detected\n", 1310940b61afSAnirudh Venkataramanan qtype); 1311940b61afSAnirudh Venkataramanan val &= ~(PF_FW_ATQLEN_ATQVFE_M | PF_FW_ATQLEN_ATQOVFL_M | 1312940b61afSAnirudh Venkataramanan PF_FW_ATQLEN_ATQCRIT_M); 1313940b61afSAnirudh Venkataramanan if (oldval != val) 1314940b61afSAnirudh Venkataramanan wr32(hw, cq->sq.len, val); 1315940b61afSAnirudh Venkataramanan } 1316940b61afSAnirudh Venkataramanan 1317940b61afSAnirudh Venkataramanan event.buf_len = cq->rq_buf_size; 13189efe35d0STony Nguyen event.msg_buf = kzalloc(event.buf_len, GFP_KERNEL); 1319940b61afSAnirudh Venkataramanan if (!event.msg_buf) 1320940b61afSAnirudh Venkataramanan return 0; 1321940b61afSAnirudh Venkataramanan 1322940b61afSAnirudh Venkataramanan do { 1323940b61afSAnirudh Venkataramanan enum ice_status ret; 13240b28b702SAnirudh Venkataramanan u16 opcode; 1325940b61afSAnirudh Venkataramanan 1326940b61afSAnirudh Venkataramanan ret = ice_clean_rq_elem(hw, cq, &event, &pending); 1327940b61afSAnirudh Venkataramanan if (ret == ICE_ERR_AQ_NO_WORK) 1328940b61afSAnirudh Venkataramanan break; 1329940b61afSAnirudh Venkataramanan if (ret) { 13300fee3577SLihong Yang dev_err(dev, "%s Receive Queue event error %s\n", qtype, 13310fee3577SLihong Yang ice_stat_str(ret)); 1332940b61afSAnirudh Venkataramanan break; 1333940b61afSAnirudh Venkataramanan } 13340b28b702SAnirudh Venkataramanan 13350b28b702SAnirudh Venkataramanan opcode = le16_to_cpu(event.desc.opcode); 13360b28b702SAnirudh Venkataramanan 1337d69ea414SJacob Keller /* Notify any thread that might be waiting for this event */ 1338d69ea414SJacob Keller ice_aq_check_events(pf, opcode, &event); 1339d69ea414SJacob Keller 13400b28b702SAnirudh Venkataramanan switch (opcode) { 1341250c3b3eSBrett Creeley case ice_aqc_opc_get_link_status: 1342c2a23e00SBrett Creeley if (ice_handle_link_event(pf, &event)) 13434015d11eSBrett Creeley dev_err(dev, "Could not handle link event\n"); 1344250c3b3eSBrett Creeley break; 13452309ae38SBrett Creeley case ice_aqc_opc_event_lan_overflow: 13462309ae38SBrett Creeley ice_vf_lan_overflow_event(pf, &event); 13472309ae38SBrett Creeley break; 13481071a835SAnirudh Venkataramanan case ice_mbx_opc_send_msg_to_pf: 13490891c896SVignesh Sridhar if (!ice_is_malicious_vf(pf, &event, i, pending)) 13501071a835SAnirudh Venkataramanan ice_vc_process_vf_msg(pf, &event); 13511071a835SAnirudh Venkataramanan break; 13528b97ceb1SHieu Tran case ice_aqc_opc_fw_logging: 13538b97ceb1SHieu Tran ice_output_fw_log(hw, &event.desc, event.msg_buf); 13548b97ceb1SHieu Tran break; 135500cc3f1bSAnirudh Venkataramanan case ice_aqc_opc_lldp_set_mib_change: 135600cc3f1bSAnirudh Venkataramanan ice_dcb_process_lldp_set_mib_change(pf, &event); 135700cc3f1bSAnirudh Venkataramanan break; 13580b28b702SAnirudh Venkataramanan default: 135919cce2c6SAnirudh Venkataramanan dev_dbg(dev, "%s Receive Queue unknown event 0x%04x ignored\n", 13600b28b702SAnirudh Venkataramanan qtype, opcode); 13610b28b702SAnirudh Venkataramanan break; 13620b28b702SAnirudh Venkataramanan } 1363940b61afSAnirudh Venkataramanan } while (pending && (i++ < ICE_DFLT_IRQ_WORK)); 1364940b61afSAnirudh Venkataramanan 13659efe35d0STony Nguyen kfree(event.msg_buf); 1366940b61afSAnirudh Venkataramanan 1367940b61afSAnirudh Venkataramanan return pending && (i == ICE_DFLT_IRQ_WORK); 1368940b61afSAnirudh Venkataramanan } 1369940b61afSAnirudh Venkataramanan 1370940b61afSAnirudh Venkataramanan /** 13713d6b640eSAnirudh Venkataramanan * ice_ctrlq_pending - check if there is a difference between ntc and ntu 13723d6b640eSAnirudh Venkataramanan * @hw: pointer to hardware info 13733d6b640eSAnirudh Venkataramanan * @cq: control queue information 13743d6b640eSAnirudh Venkataramanan * 13753d6b640eSAnirudh Venkataramanan * returns true if there are pending messages in a queue, false if there aren't 13763d6b640eSAnirudh Venkataramanan */ 13773d6b640eSAnirudh Venkataramanan static bool ice_ctrlq_pending(struct ice_hw *hw, struct ice_ctl_q_info *cq) 13783d6b640eSAnirudh Venkataramanan { 13793d6b640eSAnirudh Venkataramanan u16 ntu; 13803d6b640eSAnirudh Venkataramanan 13813d6b640eSAnirudh Venkataramanan ntu = (u16)(rd32(hw, cq->rq.head) & cq->rq.head_mask); 13823d6b640eSAnirudh Venkataramanan return cq->rq.next_to_clean != ntu; 13833d6b640eSAnirudh Venkataramanan } 13843d6b640eSAnirudh Venkataramanan 13853d6b640eSAnirudh Venkataramanan /** 1386940b61afSAnirudh Venkataramanan * ice_clean_adminq_subtask - clean the AdminQ rings 1387940b61afSAnirudh Venkataramanan * @pf: board private structure 1388940b61afSAnirudh Venkataramanan */ 1389940b61afSAnirudh Venkataramanan static void ice_clean_adminq_subtask(struct ice_pf *pf) 1390940b61afSAnirudh Venkataramanan { 1391940b61afSAnirudh Venkataramanan struct ice_hw *hw = &pf->hw; 1392940b61afSAnirudh Venkataramanan 13937e408e07SAnirudh Venkataramanan if (!test_bit(ICE_ADMINQ_EVENT_PENDING, pf->state)) 1394940b61afSAnirudh Venkataramanan return; 1395940b61afSAnirudh Venkataramanan 1396940b61afSAnirudh Venkataramanan if (__ice_clean_ctrlq(pf, ICE_CTL_Q_ADMIN)) 1397940b61afSAnirudh Venkataramanan return; 1398940b61afSAnirudh Venkataramanan 13997e408e07SAnirudh Venkataramanan clear_bit(ICE_ADMINQ_EVENT_PENDING, pf->state); 1400940b61afSAnirudh Venkataramanan 14013d6b640eSAnirudh Venkataramanan /* There might be a situation where new messages arrive to a control 14023d6b640eSAnirudh Venkataramanan * queue between processing the last message and clearing the 14033d6b640eSAnirudh Venkataramanan * EVENT_PENDING bit. So before exiting, check queue head again (using 14043d6b640eSAnirudh Venkataramanan * ice_ctrlq_pending) and process new messages if any. 14053d6b640eSAnirudh Venkataramanan */ 14063d6b640eSAnirudh Venkataramanan if (ice_ctrlq_pending(hw, &hw->adminq)) 14073d6b640eSAnirudh Venkataramanan __ice_clean_ctrlq(pf, ICE_CTL_Q_ADMIN); 1408940b61afSAnirudh Venkataramanan 1409940b61afSAnirudh Venkataramanan ice_flush(hw); 1410940b61afSAnirudh Venkataramanan } 1411940b61afSAnirudh Venkataramanan 1412940b61afSAnirudh Venkataramanan /** 141375d2b253SAnirudh Venkataramanan * ice_clean_mailboxq_subtask - clean the MailboxQ rings 141475d2b253SAnirudh Venkataramanan * @pf: board private structure 141575d2b253SAnirudh Venkataramanan */ 141675d2b253SAnirudh Venkataramanan static void ice_clean_mailboxq_subtask(struct ice_pf *pf) 141775d2b253SAnirudh Venkataramanan { 141875d2b253SAnirudh Venkataramanan struct ice_hw *hw = &pf->hw; 141975d2b253SAnirudh Venkataramanan 14207e408e07SAnirudh Venkataramanan if (!test_bit(ICE_MAILBOXQ_EVENT_PENDING, pf->state)) 142175d2b253SAnirudh Venkataramanan return; 142275d2b253SAnirudh Venkataramanan 142375d2b253SAnirudh Venkataramanan if (__ice_clean_ctrlq(pf, ICE_CTL_Q_MAILBOX)) 142475d2b253SAnirudh Venkataramanan return; 142575d2b253SAnirudh Venkataramanan 14267e408e07SAnirudh Venkataramanan clear_bit(ICE_MAILBOXQ_EVENT_PENDING, pf->state); 142775d2b253SAnirudh Venkataramanan 142875d2b253SAnirudh Venkataramanan if (ice_ctrlq_pending(hw, &hw->mailboxq)) 142975d2b253SAnirudh Venkataramanan __ice_clean_ctrlq(pf, ICE_CTL_Q_MAILBOX); 143075d2b253SAnirudh Venkataramanan 143175d2b253SAnirudh Venkataramanan ice_flush(hw); 143275d2b253SAnirudh Venkataramanan } 143375d2b253SAnirudh Venkataramanan 143475d2b253SAnirudh Venkataramanan /** 14358f5ee3c4SJacob Keller * ice_clean_sbq_subtask - clean the Sideband Queue rings 14368f5ee3c4SJacob Keller * @pf: board private structure 14378f5ee3c4SJacob Keller */ 14388f5ee3c4SJacob Keller static void ice_clean_sbq_subtask(struct ice_pf *pf) 14398f5ee3c4SJacob Keller { 14408f5ee3c4SJacob Keller struct ice_hw *hw = &pf->hw; 14418f5ee3c4SJacob Keller 14428f5ee3c4SJacob Keller /* Nothing to do here if sideband queue is not supported */ 14438f5ee3c4SJacob Keller if (!ice_is_sbq_supported(hw)) { 14448f5ee3c4SJacob Keller clear_bit(ICE_SIDEBANDQ_EVENT_PENDING, pf->state); 14458f5ee3c4SJacob Keller return; 14468f5ee3c4SJacob Keller } 14478f5ee3c4SJacob Keller 14488f5ee3c4SJacob Keller if (!test_bit(ICE_SIDEBANDQ_EVENT_PENDING, pf->state)) 14498f5ee3c4SJacob Keller return; 14508f5ee3c4SJacob Keller 14518f5ee3c4SJacob Keller if (__ice_clean_ctrlq(pf, ICE_CTL_Q_SB)) 14528f5ee3c4SJacob Keller return; 14538f5ee3c4SJacob Keller 14548f5ee3c4SJacob Keller clear_bit(ICE_SIDEBANDQ_EVENT_PENDING, pf->state); 14558f5ee3c4SJacob Keller 14568f5ee3c4SJacob Keller if (ice_ctrlq_pending(hw, &hw->sbq)) 14578f5ee3c4SJacob Keller __ice_clean_ctrlq(pf, ICE_CTL_Q_SB); 14588f5ee3c4SJacob Keller 14598f5ee3c4SJacob Keller ice_flush(hw); 14608f5ee3c4SJacob Keller } 14618f5ee3c4SJacob Keller 14628f5ee3c4SJacob Keller /** 1463940b61afSAnirudh Venkataramanan * ice_service_task_schedule - schedule the service task to wake up 1464940b61afSAnirudh Venkataramanan * @pf: board private structure 1465940b61afSAnirudh Venkataramanan * 1466940b61afSAnirudh Venkataramanan * If not already scheduled, this puts the task into the work queue. 1467940b61afSAnirudh Venkataramanan */ 146828bf2672SBrett Creeley void ice_service_task_schedule(struct ice_pf *pf) 1469940b61afSAnirudh Venkataramanan { 14707e408e07SAnirudh Venkataramanan if (!test_bit(ICE_SERVICE_DIS, pf->state) && 14717e408e07SAnirudh Venkataramanan !test_and_set_bit(ICE_SERVICE_SCHED, pf->state) && 14727e408e07SAnirudh Venkataramanan !test_bit(ICE_NEEDS_RESTART, pf->state)) 1473940b61afSAnirudh Venkataramanan queue_work(ice_wq, &pf->serv_task); 1474940b61afSAnirudh Venkataramanan } 1475940b61afSAnirudh Venkataramanan 1476940b61afSAnirudh Venkataramanan /** 1477940b61afSAnirudh Venkataramanan * ice_service_task_complete - finish up the service task 1478940b61afSAnirudh Venkataramanan * @pf: board private structure 1479940b61afSAnirudh Venkataramanan */ 1480940b61afSAnirudh Venkataramanan static void ice_service_task_complete(struct ice_pf *pf) 1481940b61afSAnirudh Venkataramanan { 14827e408e07SAnirudh Venkataramanan WARN_ON(!test_bit(ICE_SERVICE_SCHED, pf->state)); 1483940b61afSAnirudh Venkataramanan 1484940b61afSAnirudh Venkataramanan /* force memory (pf->state) to sync before next service task */ 1485940b61afSAnirudh Venkataramanan smp_mb__before_atomic(); 14867e408e07SAnirudh Venkataramanan clear_bit(ICE_SERVICE_SCHED, pf->state); 1487940b61afSAnirudh Venkataramanan } 1488940b61afSAnirudh Venkataramanan 1489940b61afSAnirudh Venkataramanan /** 14908d81fa55SAkeem G Abodunrin * ice_service_task_stop - stop service task and cancel works 14918d81fa55SAkeem G Abodunrin * @pf: board private structure 1492769c500dSAkeem G Abodunrin * 14937e408e07SAnirudh Venkataramanan * Return 0 if the ICE_SERVICE_DIS bit was not already set, 1494769c500dSAkeem G Abodunrin * 1 otherwise. 14958d81fa55SAkeem G Abodunrin */ 1496769c500dSAkeem G Abodunrin static int ice_service_task_stop(struct ice_pf *pf) 14978d81fa55SAkeem G Abodunrin { 1498769c500dSAkeem G Abodunrin int ret; 1499769c500dSAkeem G Abodunrin 15007e408e07SAnirudh Venkataramanan ret = test_and_set_bit(ICE_SERVICE_DIS, pf->state); 15018d81fa55SAkeem G Abodunrin 15028d81fa55SAkeem G Abodunrin if (pf->serv_tmr.function) 15038d81fa55SAkeem G Abodunrin del_timer_sync(&pf->serv_tmr); 15048d81fa55SAkeem G Abodunrin if (pf->serv_task.func) 15058d81fa55SAkeem G Abodunrin cancel_work_sync(&pf->serv_task); 15068d81fa55SAkeem G Abodunrin 15077e408e07SAnirudh Venkataramanan clear_bit(ICE_SERVICE_SCHED, pf->state); 1508769c500dSAkeem G Abodunrin return ret; 15098d81fa55SAkeem G Abodunrin } 15108d81fa55SAkeem G Abodunrin 15118d81fa55SAkeem G Abodunrin /** 15125995b6d0SBrett Creeley * ice_service_task_restart - restart service task and schedule works 15135995b6d0SBrett Creeley * @pf: board private structure 15145995b6d0SBrett Creeley * 15155995b6d0SBrett Creeley * This function is needed for suspend and resume works (e.g WoL scenario) 15165995b6d0SBrett Creeley */ 15175995b6d0SBrett Creeley static void ice_service_task_restart(struct ice_pf *pf) 15185995b6d0SBrett Creeley { 15197e408e07SAnirudh Venkataramanan clear_bit(ICE_SERVICE_DIS, pf->state); 15205995b6d0SBrett Creeley ice_service_task_schedule(pf); 15215995b6d0SBrett Creeley } 15225995b6d0SBrett Creeley 15235995b6d0SBrett Creeley /** 1524940b61afSAnirudh Venkataramanan * ice_service_timer - timer callback to schedule service task 1525940b61afSAnirudh Venkataramanan * @t: pointer to timer_list 1526940b61afSAnirudh Venkataramanan */ 1527940b61afSAnirudh Venkataramanan static void ice_service_timer(struct timer_list *t) 1528940b61afSAnirudh Venkataramanan { 1529940b61afSAnirudh Venkataramanan struct ice_pf *pf = from_timer(pf, t, serv_tmr); 1530940b61afSAnirudh Venkataramanan 1531940b61afSAnirudh Venkataramanan mod_timer(&pf->serv_tmr, round_jiffies(pf->serv_tmr_period + jiffies)); 1532940b61afSAnirudh Venkataramanan ice_service_task_schedule(pf); 1533940b61afSAnirudh Venkataramanan } 1534940b61afSAnirudh Venkataramanan 1535940b61afSAnirudh Venkataramanan /** 1536b3969fd7SSudheer Mogilappagari * ice_handle_mdd_event - handle malicious driver detect event 1537b3969fd7SSudheer Mogilappagari * @pf: pointer to the PF structure 1538b3969fd7SSudheer Mogilappagari * 15399d5c5a52SPaul Greenwalt * Called from service task. OICR interrupt handler indicates MDD event. 15409d5c5a52SPaul Greenwalt * VF MDD logging is guarded by net_ratelimit. Additional PF and VF log 15419d5c5a52SPaul Greenwalt * messages are wrapped by netif_msg_[rx|tx]_err. Since VF Rx MDD events 15429d5c5a52SPaul Greenwalt * disable the queue, the PF can be configured to reset the VF using ethtool 15439d5c5a52SPaul Greenwalt * private flag mdd-auto-reset-vf. 1544b3969fd7SSudheer Mogilappagari */ 1545b3969fd7SSudheer Mogilappagari static void ice_handle_mdd_event(struct ice_pf *pf) 1546b3969fd7SSudheer Mogilappagari { 15474015d11eSBrett Creeley struct device *dev = ice_pf_to_dev(pf); 1548b3969fd7SSudheer Mogilappagari struct ice_hw *hw = &pf->hw; 1549c1e08830SJesse Brandeburg unsigned int i; 1550b3969fd7SSudheer Mogilappagari u32 reg; 1551b3969fd7SSudheer Mogilappagari 15527e408e07SAnirudh Venkataramanan if (!test_and_clear_bit(ICE_MDD_EVENT_PENDING, pf->state)) { 15539d5c5a52SPaul Greenwalt /* Since the VF MDD event logging is rate limited, check if 15549d5c5a52SPaul Greenwalt * there are pending MDD events. 15559d5c5a52SPaul Greenwalt */ 15569d5c5a52SPaul Greenwalt ice_print_vfs_mdd_events(pf); 1557b3969fd7SSudheer Mogilappagari return; 15589d5c5a52SPaul Greenwalt } 1559b3969fd7SSudheer Mogilappagari 15609d5c5a52SPaul Greenwalt /* find what triggered an MDD event */ 1561b3969fd7SSudheer Mogilappagari reg = rd32(hw, GL_MDET_TX_PQM); 1562b3969fd7SSudheer Mogilappagari if (reg & GL_MDET_TX_PQM_VALID_M) { 1563b3969fd7SSudheer Mogilappagari u8 pf_num = (reg & GL_MDET_TX_PQM_PF_NUM_M) >> 1564b3969fd7SSudheer Mogilappagari GL_MDET_TX_PQM_PF_NUM_S; 1565b3969fd7SSudheer Mogilappagari u16 vf_num = (reg & GL_MDET_TX_PQM_VF_NUM_M) >> 1566b3969fd7SSudheer Mogilappagari GL_MDET_TX_PQM_VF_NUM_S; 1567b3969fd7SSudheer Mogilappagari u8 event = (reg & GL_MDET_TX_PQM_MAL_TYPE_M) >> 1568b3969fd7SSudheer Mogilappagari GL_MDET_TX_PQM_MAL_TYPE_S; 1569b3969fd7SSudheer Mogilappagari u16 queue = ((reg & GL_MDET_TX_PQM_QNUM_M) >> 1570b3969fd7SSudheer Mogilappagari GL_MDET_TX_PQM_QNUM_S); 1571b3969fd7SSudheer Mogilappagari 1572b3969fd7SSudheer Mogilappagari if (netif_msg_tx_err(pf)) 15734015d11eSBrett Creeley dev_info(dev, "Malicious Driver Detection event %d on TX queue %d PF# %d VF# %d\n", 1574b3969fd7SSudheer Mogilappagari event, queue, pf_num, vf_num); 1575b3969fd7SSudheer Mogilappagari wr32(hw, GL_MDET_TX_PQM, 0xffffffff); 1576b3969fd7SSudheer Mogilappagari } 1577b3969fd7SSudheer Mogilappagari 1578b3969fd7SSudheer Mogilappagari reg = rd32(hw, GL_MDET_TX_TCLAN); 1579b3969fd7SSudheer Mogilappagari if (reg & GL_MDET_TX_TCLAN_VALID_M) { 1580b3969fd7SSudheer Mogilappagari u8 pf_num = (reg & GL_MDET_TX_TCLAN_PF_NUM_M) >> 1581b3969fd7SSudheer Mogilappagari GL_MDET_TX_TCLAN_PF_NUM_S; 1582b3969fd7SSudheer Mogilappagari u16 vf_num = (reg & GL_MDET_TX_TCLAN_VF_NUM_M) >> 1583b3969fd7SSudheer Mogilappagari GL_MDET_TX_TCLAN_VF_NUM_S; 1584b3969fd7SSudheer Mogilappagari u8 event = (reg & GL_MDET_TX_TCLAN_MAL_TYPE_M) >> 1585b3969fd7SSudheer Mogilappagari GL_MDET_TX_TCLAN_MAL_TYPE_S; 1586b3969fd7SSudheer Mogilappagari u16 queue = ((reg & GL_MDET_TX_TCLAN_QNUM_M) >> 1587b3969fd7SSudheer Mogilappagari GL_MDET_TX_TCLAN_QNUM_S); 1588b3969fd7SSudheer Mogilappagari 15891d8bd992SBen Shelton if (netif_msg_tx_err(pf)) 15904015d11eSBrett Creeley dev_info(dev, "Malicious Driver Detection event %d on TX queue %d PF# %d VF# %d\n", 1591b3969fd7SSudheer Mogilappagari event, queue, pf_num, vf_num); 1592b3969fd7SSudheer Mogilappagari wr32(hw, GL_MDET_TX_TCLAN, 0xffffffff); 1593b3969fd7SSudheer Mogilappagari } 1594b3969fd7SSudheer Mogilappagari 1595b3969fd7SSudheer Mogilappagari reg = rd32(hw, GL_MDET_RX); 1596b3969fd7SSudheer Mogilappagari if (reg & GL_MDET_RX_VALID_M) { 1597b3969fd7SSudheer Mogilappagari u8 pf_num = (reg & GL_MDET_RX_PF_NUM_M) >> 1598b3969fd7SSudheer Mogilappagari GL_MDET_RX_PF_NUM_S; 1599b3969fd7SSudheer Mogilappagari u16 vf_num = (reg & GL_MDET_RX_VF_NUM_M) >> 1600b3969fd7SSudheer Mogilappagari GL_MDET_RX_VF_NUM_S; 1601b3969fd7SSudheer Mogilappagari u8 event = (reg & GL_MDET_RX_MAL_TYPE_M) >> 1602b3969fd7SSudheer Mogilappagari GL_MDET_RX_MAL_TYPE_S; 1603b3969fd7SSudheer Mogilappagari u16 queue = ((reg & GL_MDET_RX_QNUM_M) >> 1604b3969fd7SSudheer Mogilappagari GL_MDET_RX_QNUM_S); 1605b3969fd7SSudheer Mogilappagari 1606b3969fd7SSudheer Mogilappagari if (netif_msg_rx_err(pf)) 16074015d11eSBrett Creeley dev_info(dev, "Malicious Driver Detection event %d on RX queue %d PF# %d VF# %d\n", 1608b3969fd7SSudheer Mogilappagari event, queue, pf_num, vf_num); 1609b3969fd7SSudheer Mogilappagari wr32(hw, GL_MDET_RX, 0xffffffff); 1610b3969fd7SSudheer Mogilappagari } 1611b3969fd7SSudheer Mogilappagari 16129d5c5a52SPaul Greenwalt /* check to see if this PF caused an MDD event */ 1613b3969fd7SSudheer Mogilappagari reg = rd32(hw, PF_MDET_TX_PQM); 1614b3969fd7SSudheer Mogilappagari if (reg & PF_MDET_TX_PQM_VALID_M) { 1615b3969fd7SSudheer Mogilappagari wr32(hw, PF_MDET_TX_PQM, 0xFFFF); 16169d5c5a52SPaul Greenwalt if (netif_msg_tx_err(pf)) 16179d5c5a52SPaul Greenwalt dev_info(dev, "Malicious Driver Detection event TX_PQM detected on PF\n"); 1618b3969fd7SSudheer Mogilappagari } 1619b3969fd7SSudheer Mogilappagari 1620b3969fd7SSudheer Mogilappagari reg = rd32(hw, PF_MDET_TX_TCLAN); 1621b3969fd7SSudheer Mogilappagari if (reg & PF_MDET_TX_TCLAN_VALID_M) { 1622b3969fd7SSudheer Mogilappagari wr32(hw, PF_MDET_TX_TCLAN, 0xFFFF); 16239d5c5a52SPaul Greenwalt if (netif_msg_tx_err(pf)) 16249d5c5a52SPaul Greenwalt dev_info(dev, "Malicious Driver Detection event TX_TCLAN detected on PF\n"); 1625b3969fd7SSudheer Mogilappagari } 1626b3969fd7SSudheer Mogilappagari 1627b3969fd7SSudheer Mogilappagari reg = rd32(hw, PF_MDET_RX); 1628b3969fd7SSudheer Mogilappagari if (reg & PF_MDET_RX_VALID_M) { 1629b3969fd7SSudheer Mogilappagari wr32(hw, PF_MDET_RX, 0xFFFF); 16309d5c5a52SPaul Greenwalt if (netif_msg_rx_err(pf)) 16319d5c5a52SPaul Greenwalt dev_info(dev, "Malicious Driver Detection event RX detected on PF\n"); 1632b3969fd7SSudheer Mogilappagari } 1633b3969fd7SSudheer Mogilappagari 16349d5c5a52SPaul Greenwalt /* Check to see if one of the VFs caused an MDD event, and then 16359d5c5a52SPaul Greenwalt * increment counters and set print pending 16369d5c5a52SPaul Greenwalt */ 1637005881bcSBrett Creeley ice_for_each_vf(pf, i) { 16387c4bc1f5SAnirudh Venkataramanan struct ice_vf *vf = &pf->vf[i]; 16397c4bc1f5SAnirudh Venkataramanan 16407c4bc1f5SAnirudh Venkataramanan reg = rd32(hw, VP_MDET_TX_PQM(i)); 16417c4bc1f5SAnirudh Venkataramanan if (reg & VP_MDET_TX_PQM_VALID_M) { 16427c4bc1f5SAnirudh Venkataramanan wr32(hw, VP_MDET_TX_PQM(i), 0xFFFF); 16439d5c5a52SPaul Greenwalt vf->mdd_tx_events.count++; 16447e408e07SAnirudh Venkataramanan set_bit(ICE_MDD_VF_PRINT_PENDING, pf->state); 16459d5c5a52SPaul Greenwalt if (netif_msg_tx_err(pf)) 16469d5c5a52SPaul Greenwalt dev_info(dev, "Malicious Driver Detection event TX_PQM detected on VF %d\n", 16477c4bc1f5SAnirudh Venkataramanan i); 16487c4bc1f5SAnirudh Venkataramanan } 16497c4bc1f5SAnirudh Venkataramanan 16507c4bc1f5SAnirudh Venkataramanan reg = rd32(hw, VP_MDET_TX_TCLAN(i)); 16517c4bc1f5SAnirudh Venkataramanan if (reg & VP_MDET_TX_TCLAN_VALID_M) { 16527c4bc1f5SAnirudh Venkataramanan wr32(hw, VP_MDET_TX_TCLAN(i), 0xFFFF); 16539d5c5a52SPaul Greenwalt vf->mdd_tx_events.count++; 16547e408e07SAnirudh Venkataramanan set_bit(ICE_MDD_VF_PRINT_PENDING, pf->state); 16559d5c5a52SPaul Greenwalt if (netif_msg_tx_err(pf)) 16569d5c5a52SPaul Greenwalt dev_info(dev, "Malicious Driver Detection event TX_TCLAN detected on VF %d\n", 16577c4bc1f5SAnirudh Venkataramanan i); 16587c4bc1f5SAnirudh Venkataramanan } 16597c4bc1f5SAnirudh Venkataramanan 16607c4bc1f5SAnirudh Venkataramanan reg = rd32(hw, VP_MDET_TX_TDPU(i)); 16617c4bc1f5SAnirudh Venkataramanan if (reg & VP_MDET_TX_TDPU_VALID_M) { 16627c4bc1f5SAnirudh Venkataramanan wr32(hw, VP_MDET_TX_TDPU(i), 0xFFFF); 16639d5c5a52SPaul Greenwalt vf->mdd_tx_events.count++; 16647e408e07SAnirudh Venkataramanan set_bit(ICE_MDD_VF_PRINT_PENDING, pf->state); 16659d5c5a52SPaul Greenwalt if (netif_msg_tx_err(pf)) 16669d5c5a52SPaul Greenwalt dev_info(dev, "Malicious Driver Detection event TX_TDPU detected on VF %d\n", 16677c4bc1f5SAnirudh Venkataramanan i); 16687c4bc1f5SAnirudh Venkataramanan } 16697c4bc1f5SAnirudh Venkataramanan 16707c4bc1f5SAnirudh Venkataramanan reg = rd32(hw, VP_MDET_RX(i)); 16717c4bc1f5SAnirudh Venkataramanan if (reg & VP_MDET_RX_VALID_M) { 16727c4bc1f5SAnirudh Venkataramanan wr32(hw, VP_MDET_RX(i), 0xFFFF); 16739d5c5a52SPaul Greenwalt vf->mdd_rx_events.count++; 16747e408e07SAnirudh Venkataramanan set_bit(ICE_MDD_VF_PRINT_PENDING, pf->state); 16759d5c5a52SPaul Greenwalt if (netif_msg_rx_err(pf)) 16769d5c5a52SPaul Greenwalt dev_info(dev, "Malicious Driver Detection event RX detected on VF %d\n", 16777c4bc1f5SAnirudh Venkataramanan i); 16789d5c5a52SPaul Greenwalt 16799d5c5a52SPaul Greenwalt /* Since the queue is disabled on VF Rx MDD events, the 16809d5c5a52SPaul Greenwalt * PF can be configured to reset the VF through ethtool 16819d5c5a52SPaul Greenwalt * private flag mdd-auto-reset-vf. 16829d5c5a52SPaul Greenwalt */ 16837438a3b0SPaul Greenwalt if (test_bit(ICE_FLAG_MDD_AUTO_RESET_VF, pf->flags)) { 16847438a3b0SPaul Greenwalt /* VF MDD event counters will be cleared by 16857438a3b0SPaul Greenwalt * reset, so print the event prior to reset. 16867438a3b0SPaul Greenwalt */ 16877438a3b0SPaul Greenwalt ice_print_vf_rx_mdd_event(vf); 16889d5c5a52SPaul Greenwalt ice_reset_vf(&pf->vf[i], false); 16899d5c5a52SPaul Greenwalt } 16907c4bc1f5SAnirudh Venkataramanan } 16917438a3b0SPaul Greenwalt } 16927c4bc1f5SAnirudh Venkataramanan 16939d5c5a52SPaul Greenwalt ice_print_vfs_mdd_events(pf); 1694b3969fd7SSudheer Mogilappagari } 1695b3969fd7SSudheer Mogilappagari 1696b3969fd7SSudheer Mogilappagari /** 16976d599946STony Nguyen * ice_force_phys_link_state - Force the physical link state 16986d599946STony Nguyen * @vsi: VSI to force the physical link state to up/down 16996d599946STony Nguyen * @link_up: true/false indicates to set the physical link to up/down 17006d599946STony Nguyen * 17016d599946STony Nguyen * Force the physical link state by getting the current PHY capabilities from 17026d599946STony Nguyen * hardware and setting the PHY config based on the determined capabilities. If 17036d599946STony Nguyen * link changes a link event will be triggered because both the Enable Automatic 17046d599946STony Nguyen * Link Update and LESM Enable bits are set when setting the PHY capabilities. 17056d599946STony Nguyen * 17066d599946STony Nguyen * Returns 0 on success, negative on failure 17076d599946STony Nguyen */ 17086d599946STony Nguyen static int ice_force_phys_link_state(struct ice_vsi *vsi, bool link_up) 17096d599946STony Nguyen { 17106d599946STony Nguyen struct ice_aqc_get_phy_caps_data *pcaps; 17116d599946STony Nguyen struct ice_aqc_set_phy_cfg_data *cfg; 17126d599946STony Nguyen struct ice_port_info *pi; 17136d599946STony Nguyen struct device *dev; 17146d599946STony Nguyen int retcode; 17156d599946STony Nguyen 17166d599946STony Nguyen if (!vsi || !vsi->port_info || !vsi->back) 17176d599946STony Nguyen return -EINVAL; 17186d599946STony Nguyen if (vsi->type != ICE_VSI_PF) 17196d599946STony Nguyen return 0; 17206d599946STony Nguyen 17219a946843SAnirudh Venkataramanan dev = ice_pf_to_dev(vsi->back); 17226d599946STony Nguyen 17236d599946STony Nguyen pi = vsi->port_info; 17246d599946STony Nguyen 17259efe35d0STony Nguyen pcaps = kzalloc(sizeof(*pcaps), GFP_KERNEL); 17266d599946STony Nguyen if (!pcaps) 17276d599946STony Nguyen return -ENOMEM; 17286d599946STony Nguyen 1729d6730a87SAnirudh Venkataramanan retcode = ice_aq_get_phy_caps(pi, false, ICE_AQC_REPORT_ACTIVE_CFG, pcaps, 17306d599946STony Nguyen NULL); 17316d599946STony Nguyen if (retcode) { 173219cce2c6SAnirudh Venkataramanan dev_err(dev, "Failed to get phy capabilities, VSI %d error %d\n", 17336d599946STony Nguyen vsi->vsi_num, retcode); 17346d599946STony Nguyen retcode = -EIO; 17356d599946STony Nguyen goto out; 17366d599946STony Nguyen } 17376d599946STony Nguyen 17386d599946STony Nguyen /* No change in link */ 17396d599946STony Nguyen if (link_up == !!(pcaps->caps & ICE_AQC_PHY_EN_LINK) && 17406d599946STony Nguyen link_up == !!(pi->phy.link_info.link_info & ICE_AQ_LINK_UP)) 17416d599946STony Nguyen goto out; 17426d599946STony Nguyen 17431a3571b5SPaul Greenwalt /* Use the current user PHY configuration. The current user PHY 17441a3571b5SPaul Greenwalt * configuration is initialized during probe from PHY capabilities 17451a3571b5SPaul Greenwalt * software mode, and updated on set PHY configuration. 17461a3571b5SPaul Greenwalt */ 17471a3571b5SPaul Greenwalt cfg = kmemdup(&pi->phy.curr_user_phy_cfg, sizeof(*cfg), GFP_KERNEL); 17486d599946STony Nguyen if (!cfg) { 17496d599946STony Nguyen retcode = -ENOMEM; 17506d599946STony Nguyen goto out; 17516d599946STony Nguyen } 17526d599946STony Nguyen 17531a3571b5SPaul Greenwalt cfg->caps |= ICE_AQ_PHY_ENA_AUTO_LINK_UPDT; 17546d599946STony Nguyen if (link_up) 17556d599946STony Nguyen cfg->caps |= ICE_AQ_PHY_ENA_LINK; 17566d599946STony Nguyen else 17576d599946STony Nguyen cfg->caps &= ~ICE_AQ_PHY_ENA_LINK; 17586d599946STony Nguyen 17591a3571b5SPaul Greenwalt retcode = ice_aq_set_phy_cfg(&vsi->back->hw, pi, cfg, NULL); 17606d599946STony Nguyen if (retcode) { 17616d599946STony Nguyen dev_err(dev, "Failed to set phy config, VSI %d error %d\n", 17626d599946STony Nguyen vsi->vsi_num, retcode); 17636d599946STony Nguyen retcode = -EIO; 17646d599946STony Nguyen } 17656d599946STony Nguyen 17669efe35d0STony Nguyen kfree(cfg); 17676d599946STony Nguyen out: 17689efe35d0STony Nguyen kfree(pcaps); 17696d599946STony Nguyen return retcode; 17706d599946STony Nguyen } 17716d599946STony Nguyen 17726d599946STony Nguyen /** 17731a3571b5SPaul Greenwalt * ice_init_nvm_phy_type - Initialize the NVM PHY type 17741a3571b5SPaul Greenwalt * @pi: port info structure 17751a3571b5SPaul Greenwalt * 1776ea78ce4dSPaul Greenwalt * Initialize nvm_phy_type_[low|high] for link lenient mode support 17771a3571b5SPaul Greenwalt */ 17781a3571b5SPaul Greenwalt static int ice_init_nvm_phy_type(struct ice_port_info *pi) 17791a3571b5SPaul Greenwalt { 17801a3571b5SPaul Greenwalt struct ice_aqc_get_phy_caps_data *pcaps; 17811a3571b5SPaul Greenwalt struct ice_pf *pf = pi->hw->back; 17821a3571b5SPaul Greenwalt enum ice_status status; 17831a3571b5SPaul Greenwalt int err = 0; 17841a3571b5SPaul Greenwalt 17851a3571b5SPaul Greenwalt pcaps = kzalloc(sizeof(*pcaps), GFP_KERNEL); 17861a3571b5SPaul Greenwalt if (!pcaps) 17871a3571b5SPaul Greenwalt return -ENOMEM; 17881a3571b5SPaul Greenwalt 1789d6730a87SAnirudh Venkataramanan status = ice_aq_get_phy_caps(pi, false, ICE_AQC_REPORT_TOPO_CAP_NO_MEDIA, pcaps, 17901a3571b5SPaul Greenwalt NULL); 17911a3571b5SPaul Greenwalt 17921a3571b5SPaul Greenwalt if (status) { 17931a3571b5SPaul Greenwalt dev_err(ice_pf_to_dev(pf), "Get PHY capability failed.\n"); 17941a3571b5SPaul Greenwalt err = -EIO; 17951a3571b5SPaul Greenwalt goto out; 17961a3571b5SPaul Greenwalt } 17971a3571b5SPaul Greenwalt 17981a3571b5SPaul Greenwalt pf->nvm_phy_type_hi = pcaps->phy_type_high; 17991a3571b5SPaul Greenwalt pf->nvm_phy_type_lo = pcaps->phy_type_low; 18001a3571b5SPaul Greenwalt 18011a3571b5SPaul Greenwalt out: 18021a3571b5SPaul Greenwalt kfree(pcaps); 18031a3571b5SPaul Greenwalt return err; 18041a3571b5SPaul Greenwalt } 18051a3571b5SPaul Greenwalt 18061a3571b5SPaul Greenwalt /** 1807ea78ce4dSPaul Greenwalt * ice_init_link_dflt_override - Initialize link default override 1808ea78ce4dSPaul Greenwalt * @pi: port info structure 1809b4e813ddSBruce Allan * 1810b4e813ddSBruce Allan * Initialize link default override and PHY total port shutdown during probe 1811ea78ce4dSPaul Greenwalt */ 1812ea78ce4dSPaul Greenwalt static void ice_init_link_dflt_override(struct ice_port_info *pi) 1813ea78ce4dSPaul Greenwalt { 1814ea78ce4dSPaul Greenwalt struct ice_link_default_override_tlv *ldo; 1815ea78ce4dSPaul Greenwalt struct ice_pf *pf = pi->hw->back; 1816ea78ce4dSPaul Greenwalt 1817ea78ce4dSPaul Greenwalt ldo = &pf->link_dflt_override; 1818b4e813ddSBruce Allan if (ice_get_link_default_override(ldo, pi)) 1819b4e813ddSBruce Allan return; 1820b4e813ddSBruce Allan 1821b4e813ddSBruce Allan if (!(ldo->options & ICE_LINK_OVERRIDE_PORT_DIS)) 1822b4e813ddSBruce Allan return; 1823b4e813ddSBruce Allan 1824b4e813ddSBruce Allan /* Enable Total Port Shutdown (override/replace link-down-on-close 1825b4e813ddSBruce Allan * ethtool private flag) for ports with Port Disable bit set. 1826b4e813ddSBruce Allan */ 1827b4e813ddSBruce Allan set_bit(ICE_FLAG_TOTAL_PORT_SHUTDOWN_ENA, pf->flags); 1828b4e813ddSBruce Allan set_bit(ICE_FLAG_LINK_DOWN_ON_CLOSE_ENA, pf->flags); 1829ea78ce4dSPaul Greenwalt } 1830ea78ce4dSPaul Greenwalt 1831ea78ce4dSPaul Greenwalt /** 1832ea78ce4dSPaul Greenwalt * ice_init_phy_cfg_dflt_override - Initialize PHY cfg default override settings 1833ea78ce4dSPaul Greenwalt * @pi: port info structure 1834ea78ce4dSPaul Greenwalt * 18350a02944fSAnirudh Venkataramanan * If default override is enabled, initialize the user PHY cfg speed and FEC 1836ea78ce4dSPaul Greenwalt * settings using the default override mask from the NVM. 1837ea78ce4dSPaul Greenwalt * 1838ea78ce4dSPaul Greenwalt * The PHY should only be configured with the default override settings the 18397e408e07SAnirudh Venkataramanan * first time media is available. The ICE_LINK_DEFAULT_OVERRIDE_PENDING state 1840ea78ce4dSPaul Greenwalt * is used to indicate that the user PHY cfg default override is initialized 1841ea78ce4dSPaul Greenwalt * and the PHY has not been configured with the default override settings. The 1842ea78ce4dSPaul Greenwalt * state is set here, and cleared in ice_configure_phy the first time the PHY is 1843ea78ce4dSPaul Greenwalt * configured. 18440a02944fSAnirudh Venkataramanan * 18450a02944fSAnirudh Venkataramanan * This function should be called only if the FW doesn't support default 18460a02944fSAnirudh Venkataramanan * configuration mode, as reported by ice_fw_supports_report_dflt_cfg. 1847ea78ce4dSPaul Greenwalt */ 1848ea78ce4dSPaul Greenwalt static void ice_init_phy_cfg_dflt_override(struct ice_port_info *pi) 1849ea78ce4dSPaul Greenwalt { 1850ea78ce4dSPaul Greenwalt struct ice_link_default_override_tlv *ldo; 1851ea78ce4dSPaul Greenwalt struct ice_aqc_set_phy_cfg_data *cfg; 1852ea78ce4dSPaul Greenwalt struct ice_phy_info *phy = &pi->phy; 1853ea78ce4dSPaul Greenwalt struct ice_pf *pf = pi->hw->back; 1854ea78ce4dSPaul Greenwalt 1855ea78ce4dSPaul Greenwalt ldo = &pf->link_dflt_override; 1856ea78ce4dSPaul Greenwalt 1857ea78ce4dSPaul Greenwalt /* If link default override is enabled, use to mask NVM PHY capabilities 1858ea78ce4dSPaul Greenwalt * for speed and FEC default configuration. 1859ea78ce4dSPaul Greenwalt */ 1860ea78ce4dSPaul Greenwalt cfg = &phy->curr_user_phy_cfg; 1861ea78ce4dSPaul Greenwalt 1862ea78ce4dSPaul Greenwalt if (ldo->phy_type_low || ldo->phy_type_high) { 1863ea78ce4dSPaul Greenwalt cfg->phy_type_low = pf->nvm_phy_type_lo & 1864ea78ce4dSPaul Greenwalt cpu_to_le64(ldo->phy_type_low); 1865ea78ce4dSPaul Greenwalt cfg->phy_type_high = pf->nvm_phy_type_hi & 1866ea78ce4dSPaul Greenwalt cpu_to_le64(ldo->phy_type_high); 1867ea78ce4dSPaul Greenwalt } 1868ea78ce4dSPaul Greenwalt cfg->link_fec_opt = ldo->fec_options; 1869ea78ce4dSPaul Greenwalt phy->curr_user_fec_req = ICE_FEC_AUTO; 1870ea78ce4dSPaul Greenwalt 18717e408e07SAnirudh Venkataramanan set_bit(ICE_LINK_DEFAULT_OVERRIDE_PENDING, pf->state); 1872ea78ce4dSPaul Greenwalt } 1873ea78ce4dSPaul Greenwalt 1874ea78ce4dSPaul Greenwalt /** 18751a3571b5SPaul Greenwalt * ice_init_phy_user_cfg - Initialize the PHY user configuration 18761a3571b5SPaul Greenwalt * @pi: port info structure 18771a3571b5SPaul Greenwalt * 18781a3571b5SPaul Greenwalt * Initialize the current user PHY configuration, speed, FEC, and FC requested 18791a3571b5SPaul Greenwalt * mode to default. The PHY defaults are from get PHY capabilities topology 18801a3571b5SPaul Greenwalt * with media so call when media is first available. An error is returned if 18811a3571b5SPaul Greenwalt * called when media is not available. The PHY initialization completed state is 18821a3571b5SPaul Greenwalt * set here. 18831a3571b5SPaul Greenwalt * 18841a3571b5SPaul Greenwalt * These configurations are used when setting PHY 18851a3571b5SPaul Greenwalt * configuration. The user PHY configuration is updated on set PHY 18861a3571b5SPaul Greenwalt * configuration. Returns 0 on success, negative on failure 18871a3571b5SPaul Greenwalt */ 18881a3571b5SPaul Greenwalt static int ice_init_phy_user_cfg(struct ice_port_info *pi) 18891a3571b5SPaul Greenwalt { 18901a3571b5SPaul Greenwalt struct ice_aqc_get_phy_caps_data *pcaps; 18911a3571b5SPaul Greenwalt struct ice_phy_info *phy = &pi->phy; 18921a3571b5SPaul Greenwalt struct ice_pf *pf = pi->hw->back; 18931a3571b5SPaul Greenwalt enum ice_status status; 18941a3571b5SPaul Greenwalt int err = 0; 18951a3571b5SPaul Greenwalt 18961a3571b5SPaul Greenwalt if (!(phy->link_info.link_info & ICE_AQ_MEDIA_AVAILABLE)) 18971a3571b5SPaul Greenwalt return -EIO; 18981a3571b5SPaul Greenwalt 18991a3571b5SPaul Greenwalt pcaps = kzalloc(sizeof(*pcaps), GFP_KERNEL); 19001a3571b5SPaul Greenwalt if (!pcaps) 19011a3571b5SPaul Greenwalt return -ENOMEM; 19021a3571b5SPaul Greenwalt 19030a02944fSAnirudh Venkataramanan if (ice_fw_supports_report_dflt_cfg(pi->hw)) 19040a02944fSAnirudh Venkataramanan status = ice_aq_get_phy_caps(pi, false, ICE_AQC_REPORT_DFLT_CFG, 19050a02944fSAnirudh Venkataramanan pcaps, NULL); 19060a02944fSAnirudh Venkataramanan else 19070a02944fSAnirudh Venkataramanan status = ice_aq_get_phy_caps(pi, false, ICE_AQC_REPORT_TOPO_CAP_MEDIA, 19080a02944fSAnirudh Venkataramanan pcaps, NULL); 19091a3571b5SPaul Greenwalt if (status) { 19101a3571b5SPaul Greenwalt dev_err(ice_pf_to_dev(pf), "Get PHY capability failed.\n"); 19111a3571b5SPaul Greenwalt err = -EIO; 19121a3571b5SPaul Greenwalt goto err_out; 19131a3571b5SPaul Greenwalt } 19141a3571b5SPaul Greenwalt 1915ea78ce4dSPaul Greenwalt ice_copy_phy_caps_to_cfg(pi, pcaps, &pi->phy.curr_user_phy_cfg); 1916ea78ce4dSPaul Greenwalt 1917ea78ce4dSPaul Greenwalt /* check if lenient mode is supported and enabled */ 1918dc6aaa13SAnirudh Venkataramanan if (ice_fw_supports_link_override(pi->hw) && 1919ea78ce4dSPaul Greenwalt !(pcaps->module_compliance_enforcement & 1920ea78ce4dSPaul Greenwalt ICE_AQC_MOD_ENFORCE_STRICT_MODE)) { 1921ea78ce4dSPaul Greenwalt set_bit(ICE_FLAG_LINK_LENIENT_MODE_ENA, pf->flags); 1922ea78ce4dSPaul Greenwalt 19230a02944fSAnirudh Venkataramanan /* if the FW supports default PHY configuration mode, then the driver 19240a02944fSAnirudh Venkataramanan * does not have to apply link override settings. If not, 19250a02944fSAnirudh Venkataramanan * initialize user PHY configuration with link override values 1926ea78ce4dSPaul Greenwalt */ 19270a02944fSAnirudh Venkataramanan if (!ice_fw_supports_report_dflt_cfg(pi->hw) && 19280a02944fSAnirudh Venkataramanan (pf->link_dflt_override.options & ICE_LINK_OVERRIDE_EN)) { 1929ea78ce4dSPaul Greenwalt ice_init_phy_cfg_dflt_override(pi); 1930ea78ce4dSPaul Greenwalt goto out; 1931ea78ce4dSPaul Greenwalt } 1932ea78ce4dSPaul Greenwalt } 1933ea78ce4dSPaul Greenwalt 19340a02944fSAnirudh Venkataramanan /* if link default override is not enabled, set user flow control and 19350a02944fSAnirudh Venkataramanan * FEC settings based on what get_phy_caps returned 1936ea78ce4dSPaul Greenwalt */ 19371a3571b5SPaul Greenwalt phy->curr_user_fec_req = ice_caps_to_fec_mode(pcaps->caps, 19381a3571b5SPaul Greenwalt pcaps->link_fec_options); 19391a3571b5SPaul Greenwalt phy->curr_user_fc_req = ice_caps_to_fc_mode(pcaps->caps); 19401a3571b5SPaul Greenwalt 1941ea78ce4dSPaul Greenwalt out: 19421a3571b5SPaul Greenwalt phy->curr_user_speed_req = ICE_AQ_LINK_SPEED_M; 19437e408e07SAnirudh Venkataramanan set_bit(ICE_PHY_INIT_COMPLETE, pf->state); 19441a3571b5SPaul Greenwalt err_out: 19451a3571b5SPaul Greenwalt kfree(pcaps); 19461a3571b5SPaul Greenwalt return err; 19471a3571b5SPaul Greenwalt } 19481a3571b5SPaul Greenwalt 19491a3571b5SPaul Greenwalt /** 19501a3571b5SPaul Greenwalt * ice_configure_phy - configure PHY 19511a3571b5SPaul Greenwalt * @vsi: VSI of PHY 19521a3571b5SPaul Greenwalt * 19531a3571b5SPaul Greenwalt * Set the PHY configuration. If the current PHY configuration is the same as 19541a3571b5SPaul Greenwalt * the curr_user_phy_cfg, then do nothing to avoid link flap. Otherwise 19551a3571b5SPaul Greenwalt * configure the based get PHY capabilities for topology with media. 19561a3571b5SPaul Greenwalt */ 19571a3571b5SPaul Greenwalt static int ice_configure_phy(struct ice_vsi *vsi) 19581a3571b5SPaul Greenwalt { 19591a3571b5SPaul Greenwalt struct device *dev = ice_pf_to_dev(vsi->back); 1960efc1eddbSAnirudh Venkataramanan struct ice_port_info *pi = vsi->port_info; 19611a3571b5SPaul Greenwalt struct ice_aqc_get_phy_caps_data *pcaps; 19621a3571b5SPaul Greenwalt struct ice_aqc_set_phy_cfg_data *cfg; 1963efc1eddbSAnirudh Venkataramanan struct ice_phy_info *phy = &pi->phy; 1964efc1eddbSAnirudh Venkataramanan struct ice_pf *pf = vsi->back; 19651a3571b5SPaul Greenwalt enum ice_status status; 19661a3571b5SPaul Greenwalt int err = 0; 19671a3571b5SPaul Greenwalt 19681a3571b5SPaul Greenwalt /* Ensure we have media as we cannot configure a medialess port */ 1969efc1eddbSAnirudh Venkataramanan if (!(phy->link_info.link_info & ICE_AQ_MEDIA_AVAILABLE)) 19701a3571b5SPaul Greenwalt return -EPERM; 19711a3571b5SPaul Greenwalt 19721a3571b5SPaul Greenwalt ice_print_topo_conflict(vsi); 19731a3571b5SPaul Greenwalt 19744fc5fbeeSAnirudh Venkataramanan if (!test_bit(ICE_FLAG_LINK_LENIENT_MODE_ENA, pf->flags) && 19754fc5fbeeSAnirudh Venkataramanan phy->link_info.topo_media_conflict == ICE_AQ_LINK_TOPO_UNSUPP_MEDIA) 19761a3571b5SPaul Greenwalt return -EPERM; 19771a3571b5SPaul Greenwalt 1978efc1eddbSAnirudh Venkataramanan if (test_bit(ICE_FLAG_LINK_DOWN_ON_CLOSE_ENA, pf->flags)) 19791a3571b5SPaul Greenwalt return ice_force_phys_link_state(vsi, true); 19801a3571b5SPaul Greenwalt 19811a3571b5SPaul Greenwalt pcaps = kzalloc(sizeof(*pcaps), GFP_KERNEL); 19821a3571b5SPaul Greenwalt if (!pcaps) 19831a3571b5SPaul Greenwalt return -ENOMEM; 19841a3571b5SPaul Greenwalt 19851a3571b5SPaul Greenwalt /* Get current PHY config */ 1986d6730a87SAnirudh Venkataramanan status = ice_aq_get_phy_caps(pi, false, ICE_AQC_REPORT_ACTIVE_CFG, pcaps, 19871a3571b5SPaul Greenwalt NULL); 19881a3571b5SPaul Greenwalt if (status) { 19891a3571b5SPaul Greenwalt dev_err(dev, "Failed to get PHY configuration, VSI %d error %s\n", 19901a3571b5SPaul Greenwalt vsi->vsi_num, ice_stat_str(status)); 19911a3571b5SPaul Greenwalt err = -EIO; 19921a3571b5SPaul Greenwalt goto done; 19931a3571b5SPaul Greenwalt } 19941a3571b5SPaul Greenwalt 19951a3571b5SPaul Greenwalt /* If PHY enable link is configured and configuration has not changed, 19961a3571b5SPaul Greenwalt * there's nothing to do 19971a3571b5SPaul Greenwalt */ 19981a3571b5SPaul Greenwalt if (pcaps->caps & ICE_AQC_PHY_EN_LINK && 1999efc1eddbSAnirudh Venkataramanan ice_phy_caps_equals_cfg(pcaps, &phy->curr_user_phy_cfg)) 20001a3571b5SPaul Greenwalt goto done; 20011a3571b5SPaul Greenwalt 20021a3571b5SPaul Greenwalt /* Use PHY topology as baseline for configuration */ 20031a3571b5SPaul Greenwalt memset(pcaps, 0, sizeof(*pcaps)); 20040a02944fSAnirudh Venkataramanan if (ice_fw_supports_report_dflt_cfg(pi->hw)) 20050a02944fSAnirudh Venkataramanan status = ice_aq_get_phy_caps(pi, false, ICE_AQC_REPORT_DFLT_CFG, 20060a02944fSAnirudh Venkataramanan pcaps, NULL); 20070a02944fSAnirudh Venkataramanan else 20080a02944fSAnirudh Venkataramanan status = ice_aq_get_phy_caps(pi, false, ICE_AQC_REPORT_TOPO_CAP_MEDIA, 20090a02944fSAnirudh Venkataramanan pcaps, NULL); 20101a3571b5SPaul Greenwalt if (status) { 20110a02944fSAnirudh Venkataramanan dev_err(dev, "Failed to get PHY caps, VSI %d error %s\n", 20121a3571b5SPaul Greenwalt vsi->vsi_num, ice_stat_str(status)); 20131a3571b5SPaul Greenwalt err = -EIO; 20141a3571b5SPaul Greenwalt goto done; 20151a3571b5SPaul Greenwalt } 20161a3571b5SPaul Greenwalt 20171a3571b5SPaul Greenwalt cfg = kzalloc(sizeof(*cfg), GFP_KERNEL); 20181a3571b5SPaul Greenwalt if (!cfg) { 20191a3571b5SPaul Greenwalt err = -ENOMEM; 20201a3571b5SPaul Greenwalt goto done; 20211a3571b5SPaul Greenwalt } 20221a3571b5SPaul Greenwalt 2023ea78ce4dSPaul Greenwalt ice_copy_phy_caps_to_cfg(pi, pcaps, cfg); 20241a3571b5SPaul Greenwalt 20251a3571b5SPaul Greenwalt /* Speed - If default override pending, use curr_user_phy_cfg set in 20261a3571b5SPaul Greenwalt * ice_init_phy_user_cfg_ldo. 20271a3571b5SPaul Greenwalt */ 20287e408e07SAnirudh Venkataramanan if (test_and_clear_bit(ICE_LINK_DEFAULT_OVERRIDE_PENDING, 2029ea78ce4dSPaul Greenwalt vsi->back->state)) { 2030efc1eddbSAnirudh Venkataramanan cfg->phy_type_low = phy->curr_user_phy_cfg.phy_type_low; 2031efc1eddbSAnirudh Venkataramanan cfg->phy_type_high = phy->curr_user_phy_cfg.phy_type_high; 2032ea78ce4dSPaul Greenwalt } else { 2033ea78ce4dSPaul Greenwalt u64 phy_low = 0, phy_high = 0; 2034ea78ce4dSPaul Greenwalt 2035ea78ce4dSPaul Greenwalt ice_update_phy_type(&phy_low, &phy_high, 2036ea78ce4dSPaul Greenwalt pi->phy.curr_user_speed_req); 20371a3571b5SPaul Greenwalt cfg->phy_type_low = pcaps->phy_type_low & cpu_to_le64(phy_low); 2038ea78ce4dSPaul Greenwalt cfg->phy_type_high = pcaps->phy_type_high & 2039ea78ce4dSPaul Greenwalt cpu_to_le64(phy_high); 2040ea78ce4dSPaul Greenwalt } 20411a3571b5SPaul Greenwalt 20421a3571b5SPaul Greenwalt /* Can't provide what was requested; use PHY capabilities */ 20431a3571b5SPaul Greenwalt if (!cfg->phy_type_low && !cfg->phy_type_high) { 20441a3571b5SPaul Greenwalt cfg->phy_type_low = pcaps->phy_type_low; 20451a3571b5SPaul Greenwalt cfg->phy_type_high = pcaps->phy_type_high; 20461a3571b5SPaul Greenwalt } 20471a3571b5SPaul Greenwalt 20481a3571b5SPaul Greenwalt /* FEC */ 2049efc1eddbSAnirudh Venkataramanan ice_cfg_phy_fec(pi, cfg, phy->curr_user_fec_req); 20501a3571b5SPaul Greenwalt 20511a3571b5SPaul Greenwalt /* Can't provide what was requested; use PHY capabilities */ 20521a3571b5SPaul Greenwalt if (cfg->link_fec_opt != 20531a3571b5SPaul Greenwalt (cfg->link_fec_opt & pcaps->link_fec_options)) { 20541a3571b5SPaul Greenwalt cfg->caps |= pcaps->caps & ICE_AQC_PHY_EN_AUTO_FEC; 20551a3571b5SPaul Greenwalt cfg->link_fec_opt = pcaps->link_fec_options; 20561a3571b5SPaul Greenwalt } 20571a3571b5SPaul Greenwalt 20581a3571b5SPaul Greenwalt /* Flow Control - always supported; no need to check against 20591a3571b5SPaul Greenwalt * capabilities 20601a3571b5SPaul Greenwalt */ 2061efc1eddbSAnirudh Venkataramanan ice_cfg_phy_fc(pi, cfg, phy->curr_user_fc_req); 20621a3571b5SPaul Greenwalt 20631a3571b5SPaul Greenwalt /* Enable link and link update */ 20641a3571b5SPaul Greenwalt cfg->caps |= ICE_AQ_PHY_ENA_AUTO_LINK_UPDT | ICE_AQ_PHY_ENA_LINK; 20651a3571b5SPaul Greenwalt 2066efc1eddbSAnirudh Venkataramanan status = ice_aq_set_phy_cfg(&pf->hw, pi, cfg, NULL); 20671a3571b5SPaul Greenwalt if (status) { 20681a3571b5SPaul Greenwalt dev_err(dev, "Failed to set phy config, VSI %d error %s\n", 20691a3571b5SPaul Greenwalt vsi->vsi_num, ice_stat_str(status)); 20701a3571b5SPaul Greenwalt err = -EIO; 20711a3571b5SPaul Greenwalt } 20721a3571b5SPaul Greenwalt 20731a3571b5SPaul Greenwalt kfree(cfg); 20741a3571b5SPaul Greenwalt done: 20751a3571b5SPaul Greenwalt kfree(pcaps); 20761a3571b5SPaul Greenwalt return err; 20771a3571b5SPaul Greenwalt } 20781a3571b5SPaul Greenwalt 20791a3571b5SPaul Greenwalt /** 20801a3571b5SPaul Greenwalt * ice_check_media_subtask - Check for media 20816d599946STony Nguyen * @pf: pointer to PF struct 20821a3571b5SPaul Greenwalt * 20831a3571b5SPaul Greenwalt * If media is available, then initialize PHY user configuration if it is not 20841a3571b5SPaul Greenwalt * been, and configure the PHY if the interface is up. 20856d599946STony Nguyen */ 20866d599946STony Nguyen static void ice_check_media_subtask(struct ice_pf *pf) 20876d599946STony Nguyen { 20886d599946STony Nguyen struct ice_port_info *pi; 20896d599946STony Nguyen struct ice_vsi *vsi; 20906d599946STony Nguyen int err; 20916d599946STony Nguyen 20921a3571b5SPaul Greenwalt /* No need to check for media if it's already present */ 20931a3571b5SPaul Greenwalt if (!test_bit(ICE_FLAG_NO_MEDIA, pf->flags)) 20946d599946STony Nguyen return; 20956d599946STony Nguyen 20961a3571b5SPaul Greenwalt vsi = ice_get_main_vsi(pf); 20971a3571b5SPaul Greenwalt if (!vsi) 20986d599946STony Nguyen return; 20996d599946STony Nguyen 21006d599946STony Nguyen /* Refresh link info and check if media is present */ 21016d599946STony Nguyen pi = vsi->port_info; 21026d599946STony Nguyen err = ice_update_link_info(pi); 21036d599946STony Nguyen if (err) 21046d599946STony Nguyen return; 21056d599946STony Nguyen 2106c77849f5SAnirudh Venkataramanan ice_check_module_power(pf, pi->phy.link_info.link_cfg_err); 2107c77849f5SAnirudh Venkataramanan 21086d599946STony Nguyen if (pi->phy.link_info.link_info & ICE_AQ_MEDIA_AVAILABLE) { 21097e408e07SAnirudh Venkataramanan if (!test_bit(ICE_PHY_INIT_COMPLETE, pf->state)) 21101a3571b5SPaul Greenwalt ice_init_phy_user_cfg(pi); 21111a3571b5SPaul Greenwalt 21121a3571b5SPaul Greenwalt /* PHY settings are reset on media insertion, reconfigure 21131a3571b5SPaul Greenwalt * PHY to preserve settings. 21141a3571b5SPaul Greenwalt */ 2115e97fb1aeSAnirudh Venkataramanan if (test_bit(ICE_VSI_DOWN, vsi->state) && 21161a3571b5SPaul Greenwalt test_bit(ICE_FLAG_LINK_DOWN_ON_CLOSE_ENA, vsi->back->flags)) 21176d599946STony Nguyen return; 21181a3571b5SPaul Greenwalt 21191a3571b5SPaul Greenwalt err = ice_configure_phy(vsi); 21201a3571b5SPaul Greenwalt if (!err) 21216d599946STony Nguyen clear_bit(ICE_FLAG_NO_MEDIA, pf->flags); 21226d599946STony Nguyen 21236d599946STony Nguyen /* A Link Status Event will be generated; the event handler 21246d599946STony Nguyen * will complete bringing the interface up 21256d599946STony Nguyen */ 21266d599946STony Nguyen } 21276d599946STony Nguyen } 21286d599946STony Nguyen 21296d599946STony Nguyen /** 2130940b61afSAnirudh Venkataramanan * ice_service_task - manage and run subtasks 2131940b61afSAnirudh Venkataramanan * @work: pointer to work_struct contained by the PF struct 2132940b61afSAnirudh Venkataramanan */ 2133940b61afSAnirudh Venkataramanan static void ice_service_task(struct work_struct *work) 2134940b61afSAnirudh Venkataramanan { 2135940b61afSAnirudh Venkataramanan struct ice_pf *pf = container_of(work, struct ice_pf, serv_task); 2136940b61afSAnirudh Venkataramanan unsigned long start_time = jiffies; 2137940b61afSAnirudh Venkataramanan 2138940b61afSAnirudh Venkataramanan /* subtasks */ 21390b28b702SAnirudh Venkataramanan 21400b28b702SAnirudh Venkataramanan /* process reset requests first */ 21410b28b702SAnirudh Venkataramanan ice_reset_subtask(pf); 21420b28b702SAnirudh Venkataramanan 21430f9d5027SAnirudh Venkataramanan /* bail if a reset/recovery cycle is pending or rebuild failed */ 21445df7e45dSDave Ertman if (ice_is_reset_in_progress(pf->state) || 21457e408e07SAnirudh Venkataramanan test_bit(ICE_SUSPENDED, pf->state) || 21467e408e07SAnirudh Venkataramanan test_bit(ICE_NEEDS_RESTART, pf->state)) { 21470b28b702SAnirudh Venkataramanan ice_service_task_complete(pf); 21480b28b702SAnirudh Venkataramanan return; 21490b28b702SAnirudh Venkataramanan } 21500b28b702SAnirudh Venkataramanan 2151462acf6aSTony Nguyen ice_clean_adminq_subtask(pf); 21526d599946STony Nguyen ice_check_media_subtask(pf); 2153b3969fd7SSudheer Mogilappagari ice_check_for_hang_subtask(pf); 2154e94d4478SAnirudh Venkataramanan ice_sync_fltr_subtask(pf); 2155b3969fd7SSudheer Mogilappagari ice_handle_mdd_event(pf); 2156fcea6f3dSAnirudh Venkataramanan ice_watchdog_subtask(pf); 2157462acf6aSTony Nguyen 2158462acf6aSTony Nguyen if (ice_is_safe_mode(pf)) { 2159462acf6aSTony Nguyen ice_service_task_complete(pf); 2160462acf6aSTony Nguyen return; 2161462acf6aSTony Nguyen } 2162462acf6aSTony Nguyen 2163462acf6aSTony Nguyen ice_process_vflr_event(pf); 216475d2b253SAnirudh Venkataramanan ice_clean_mailboxq_subtask(pf); 21658f5ee3c4SJacob Keller ice_clean_sbq_subtask(pf); 216628bf2672SBrett Creeley ice_sync_arfs_fltrs(pf); 2167d6218317SQi Zhang ice_flush_fdir_ctx(pf); 21687e408e07SAnirudh Venkataramanan 21697e408e07SAnirudh Venkataramanan /* Clear ICE_SERVICE_SCHED flag to allow scheduling next event */ 2170940b61afSAnirudh Venkataramanan ice_service_task_complete(pf); 2171940b61afSAnirudh Venkataramanan 2172940b61afSAnirudh Venkataramanan /* If the tasks have taken longer than one service timer period 2173940b61afSAnirudh Venkataramanan * or there is more work to be done, reset the service timer to 2174940b61afSAnirudh Venkataramanan * schedule the service task now. 2175940b61afSAnirudh Venkataramanan */ 2176940b61afSAnirudh Venkataramanan if (time_after(jiffies, (start_time + pf->serv_tmr_period)) || 21777e408e07SAnirudh Venkataramanan test_bit(ICE_MDD_EVENT_PENDING, pf->state) || 21787e408e07SAnirudh Venkataramanan test_bit(ICE_VFLR_EVENT_PENDING, pf->state) || 21797e408e07SAnirudh Venkataramanan test_bit(ICE_MAILBOXQ_EVENT_PENDING, pf->state) || 21807e408e07SAnirudh Venkataramanan test_bit(ICE_FD_VF_FLUSH_CTX, pf->state) || 21818f5ee3c4SJacob Keller test_bit(ICE_SIDEBANDQ_EVENT_PENDING, pf->state) || 21827e408e07SAnirudh Venkataramanan test_bit(ICE_ADMINQ_EVENT_PENDING, pf->state)) 2183940b61afSAnirudh Venkataramanan mod_timer(&pf->serv_tmr, jiffies); 2184940b61afSAnirudh Venkataramanan } 2185940b61afSAnirudh Venkataramanan 2186837f08fdSAnirudh Venkataramanan /** 2187f31e4b6fSAnirudh Venkataramanan * ice_set_ctrlq_len - helper function to set controlq length 2188f9867df6SAnirudh Venkataramanan * @hw: pointer to the HW instance 2189f31e4b6fSAnirudh Venkataramanan */ 2190f31e4b6fSAnirudh Venkataramanan static void ice_set_ctrlq_len(struct ice_hw *hw) 2191f31e4b6fSAnirudh Venkataramanan { 2192f31e4b6fSAnirudh Venkataramanan hw->adminq.num_rq_entries = ICE_AQ_LEN; 2193f31e4b6fSAnirudh Venkataramanan hw->adminq.num_sq_entries = ICE_AQ_LEN; 2194f31e4b6fSAnirudh Venkataramanan hw->adminq.rq_buf_size = ICE_AQ_MAX_BUF_LEN; 2195f31e4b6fSAnirudh Venkataramanan hw->adminq.sq_buf_size = ICE_AQ_MAX_BUF_LEN; 2196c8a1071dSLukasz Czapnik hw->mailboxq.num_rq_entries = PF_MBX_ARQLEN_ARQLEN_M; 219711836214SBrett Creeley hw->mailboxq.num_sq_entries = ICE_MBXSQ_LEN; 219875d2b253SAnirudh Venkataramanan hw->mailboxq.rq_buf_size = ICE_MBXQ_MAX_BUF_LEN; 219975d2b253SAnirudh Venkataramanan hw->mailboxq.sq_buf_size = ICE_MBXQ_MAX_BUF_LEN; 22008f5ee3c4SJacob Keller hw->sbq.num_rq_entries = ICE_SBQ_LEN; 22018f5ee3c4SJacob Keller hw->sbq.num_sq_entries = ICE_SBQ_LEN; 22028f5ee3c4SJacob Keller hw->sbq.rq_buf_size = ICE_SBQ_MAX_BUF_LEN; 22038f5ee3c4SJacob Keller hw->sbq.sq_buf_size = ICE_SBQ_MAX_BUF_LEN; 2204f31e4b6fSAnirudh Venkataramanan } 2205f31e4b6fSAnirudh Venkataramanan 2206f31e4b6fSAnirudh Venkataramanan /** 220787324e74SHenry Tieman * ice_schedule_reset - schedule a reset 220887324e74SHenry Tieman * @pf: board private structure 220987324e74SHenry Tieman * @reset: reset being requested 221087324e74SHenry Tieman */ 221187324e74SHenry Tieman int ice_schedule_reset(struct ice_pf *pf, enum ice_reset_req reset) 221287324e74SHenry Tieman { 221387324e74SHenry Tieman struct device *dev = ice_pf_to_dev(pf); 221487324e74SHenry Tieman 221587324e74SHenry Tieman /* bail out if earlier reset has failed */ 22167e408e07SAnirudh Venkataramanan if (test_bit(ICE_RESET_FAILED, pf->state)) { 221787324e74SHenry Tieman dev_dbg(dev, "earlier reset has failed\n"); 221887324e74SHenry Tieman return -EIO; 221987324e74SHenry Tieman } 222087324e74SHenry Tieman /* bail if reset/recovery already in progress */ 222187324e74SHenry Tieman if (ice_is_reset_in_progress(pf->state)) { 222287324e74SHenry Tieman dev_dbg(dev, "Reset already in progress\n"); 222387324e74SHenry Tieman return -EBUSY; 222487324e74SHenry Tieman } 222587324e74SHenry Tieman 2226f9f5301eSDave Ertman ice_unplug_aux_dev(pf); 2227f9f5301eSDave Ertman 222887324e74SHenry Tieman switch (reset) { 222987324e74SHenry Tieman case ICE_RESET_PFR: 22307e408e07SAnirudh Venkataramanan set_bit(ICE_PFR_REQ, pf->state); 223187324e74SHenry Tieman break; 223287324e74SHenry Tieman case ICE_RESET_CORER: 22337e408e07SAnirudh Venkataramanan set_bit(ICE_CORER_REQ, pf->state); 223487324e74SHenry Tieman break; 223587324e74SHenry Tieman case ICE_RESET_GLOBR: 22367e408e07SAnirudh Venkataramanan set_bit(ICE_GLOBR_REQ, pf->state); 223787324e74SHenry Tieman break; 223887324e74SHenry Tieman default: 223987324e74SHenry Tieman return -EINVAL; 224087324e74SHenry Tieman } 224187324e74SHenry Tieman 224287324e74SHenry Tieman ice_service_task_schedule(pf); 224387324e74SHenry Tieman return 0; 224487324e74SHenry Tieman } 224587324e74SHenry Tieman 224687324e74SHenry Tieman /** 2247cdedef59SAnirudh Venkataramanan * ice_irq_affinity_notify - Callback for affinity changes 2248cdedef59SAnirudh Venkataramanan * @notify: context as to what irq was changed 2249cdedef59SAnirudh Venkataramanan * @mask: the new affinity mask 2250cdedef59SAnirudh Venkataramanan * 2251cdedef59SAnirudh Venkataramanan * This is a callback function used by the irq_set_affinity_notifier function 2252cdedef59SAnirudh Venkataramanan * so that we may register to receive changes to the irq affinity masks. 2253cdedef59SAnirudh Venkataramanan */ 2254c8b7abddSBruce Allan static void 2255c8b7abddSBruce Allan ice_irq_affinity_notify(struct irq_affinity_notify *notify, 2256cdedef59SAnirudh Venkataramanan const cpumask_t *mask) 2257cdedef59SAnirudh Venkataramanan { 2258cdedef59SAnirudh Venkataramanan struct ice_q_vector *q_vector = 2259cdedef59SAnirudh Venkataramanan container_of(notify, struct ice_q_vector, affinity_notify); 2260cdedef59SAnirudh Venkataramanan 2261cdedef59SAnirudh Venkataramanan cpumask_copy(&q_vector->affinity_mask, mask); 2262cdedef59SAnirudh Venkataramanan } 2263cdedef59SAnirudh Venkataramanan 2264cdedef59SAnirudh Venkataramanan /** 2265cdedef59SAnirudh Venkataramanan * ice_irq_affinity_release - Callback for affinity notifier release 2266cdedef59SAnirudh Venkataramanan * @ref: internal core kernel usage 2267cdedef59SAnirudh Venkataramanan * 2268cdedef59SAnirudh Venkataramanan * This is a callback function used by the irq_set_affinity_notifier function 2269cdedef59SAnirudh Venkataramanan * to inform the current notification subscriber that they will no longer 2270cdedef59SAnirudh Venkataramanan * receive notifications. 2271cdedef59SAnirudh Venkataramanan */ 2272cdedef59SAnirudh Venkataramanan static void ice_irq_affinity_release(struct kref __always_unused *ref) {} 2273cdedef59SAnirudh Venkataramanan 2274cdedef59SAnirudh Venkataramanan /** 2275cdedef59SAnirudh Venkataramanan * ice_vsi_ena_irq - Enable IRQ for the given VSI 2276cdedef59SAnirudh Venkataramanan * @vsi: the VSI being configured 2277cdedef59SAnirudh Venkataramanan */ 2278cdedef59SAnirudh Venkataramanan static int ice_vsi_ena_irq(struct ice_vsi *vsi) 2279cdedef59SAnirudh Venkataramanan { 2280ba880734SBrett Creeley struct ice_hw *hw = &vsi->back->hw; 2281cdedef59SAnirudh Venkataramanan int i; 2282cdedef59SAnirudh Venkataramanan 22830c2561c8SBrett Creeley ice_for_each_q_vector(vsi, i) 2284cdedef59SAnirudh Venkataramanan ice_irq_dynamic_ena(hw, vsi, vsi->q_vectors[i]); 2285cdedef59SAnirudh Venkataramanan 2286cdedef59SAnirudh Venkataramanan ice_flush(hw); 2287cdedef59SAnirudh Venkataramanan return 0; 2288cdedef59SAnirudh Venkataramanan } 2289cdedef59SAnirudh Venkataramanan 2290cdedef59SAnirudh Venkataramanan /** 2291cdedef59SAnirudh Venkataramanan * ice_vsi_req_irq_msix - get MSI-X vectors from the OS for the VSI 2292cdedef59SAnirudh Venkataramanan * @vsi: the VSI being configured 2293cdedef59SAnirudh Venkataramanan * @basename: name for the vector 2294cdedef59SAnirudh Venkataramanan */ 2295cdedef59SAnirudh Venkataramanan static int ice_vsi_req_irq_msix(struct ice_vsi *vsi, char *basename) 2296cdedef59SAnirudh Venkataramanan { 2297cdedef59SAnirudh Venkataramanan int q_vectors = vsi->num_q_vectors; 2298cdedef59SAnirudh Venkataramanan struct ice_pf *pf = vsi->back; 2299cbe66bfeSBrett Creeley int base = vsi->base_vector; 23004015d11eSBrett Creeley struct device *dev; 2301cdedef59SAnirudh Venkataramanan int rx_int_idx = 0; 2302cdedef59SAnirudh Venkataramanan int tx_int_idx = 0; 2303cdedef59SAnirudh Venkataramanan int vector, err; 2304cdedef59SAnirudh Venkataramanan int irq_num; 2305cdedef59SAnirudh Venkataramanan 23064015d11eSBrett Creeley dev = ice_pf_to_dev(pf); 2307cdedef59SAnirudh Venkataramanan for (vector = 0; vector < q_vectors; vector++) { 2308cdedef59SAnirudh Venkataramanan struct ice_q_vector *q_vector = vsi->q_vectors[vector]; 2309cdedef59SAnirudh Venkataramanan 2310cdedef59SAnirudh Venkataramanan irq_num = pf->msix_entries[base + vector].vector; 2311cdedef59SAnirudh Venkataramanan 2312e72bba21SMaciej Fijalkowski if (q_vector->tx.tx_ring && q_vector->rx.rx_ring) { 2313cdedef59SAnirudh Venkataramanan snprintf(q_vector->name, sizeof(q_vector->name) - 1, 2314cdedef59SAnirudh Venkataramanan "%s-%s-%d", basename, "TxRx", rx_int_idx++); 2315cdedef59SAnirudh Venkataramanan tx_int_idx++; 2316e72bba21SMaciej Fijalkowski } else if (q_vector->rx.rx_ring) { 2317cdedef59SAnirudh Venkataramanan snprintf(q_vector->name, sizeof(q_vector->name) - 1, 2318cdedef59SAnirudh Venkataramanan "%s-%s-%d", basename, "rx", rx_int_idx++); 2319e72bba21SMaciej Fijalkowski } else if (q_vector->tx.tx_ring) { 2320cdedef59SAnirudh Venkataramanan snprintf(q_vector->name, sizeof(q_vector->name) - 1, 2321cdedef59SAnirudh Venkataramanan "%s-%s-%d", basename, "tx", tx_int_idx++); 2322cdedef59SAnirudh Venkataramanan } else { 2323cdedef59SAnirudh Venkataramanan /* skip this unused q_vector */ 2324cdedef59SAnirudh Venkataramanan continue; 2325cdedef59SAnirudh Venkataramanan } 2326da62c5ffSQi Zhang if (vsi->type == ICE_VSI_CTRL && vsi->vf_id != ICE_INVAL_VFID) 2327da62c5ffSQi Zhang err = devm_request_irq(dev, irq_num, vsi->irq_handler, 2328da62c5ffSQi Zhang IRQF_SHARED, q_vector->name, 2329da62c5ffSQi Zhang q_vector); 2330da62c5ffSQi Zhang else 2331da62c5ffSQi Zhang err = devm_request_irq(dev, irq_num, vsi->irq_handler, 2332da62c5ffSQi Zhang 0, q_vector->name, q_vector); 2333cdedef59SAnirudh Venkataramanan if (err) { 233419cce2c6SAnirudh Venkataramanan netdev_err(vsi->netdev, "MSIX request_irq failed, error: %d\n", 233519cce2c6SAnirudh Venkataramanan err); 2336cdedef59SAnirudh Venkataramanan goto free_q_irqs; 2337cdedef59SAnirudh Venkataramanan } 2338cdedef59SAnirudh Venkataramanan 2339cdedef59SAnirudh Venkataramanan /* register for affinity change notifications */ 234028bf2672SBrett Creeley if (!IS_ENABLED(CONFIG_RFS_ACCEL)) { 234128bf2672SBrett Creeley struct irq_affinity_notify *affinity_notify; 234228bf2672SBrett Creeley 234328bf2672SBrett Creeley affinity_notify = &q_vector->affinity_notify; 234428bf2672SBrett Creeley affinity_notify->notify = ice_irq_affinity_notify; 234528bf2672SBrett Creeley affinity_notify->release = ice_irq_affinity_release; 234628bf2672SBrett Creeley irq_set_affinity_notifier(irq_num, affinity_notify); 234728bf2672SBrett Creeley } 2348cdedef59SAnirudh Venkataramanan 2349cdedef59SAnirudh Venkataramanan /* assign the mask for this irq */ 2350cdedef59SAnirudh Venkataramanan irq_set_affinity_hint(irq_num, &q_vector->affinity_mask); 2351cdedef59SAnirudh Venkataramanan } 2352cdedef59SAnirudh Venkataramanan 2353cdedef59SAnirudh Venkataramanan vsi->irqs_ready = true; 2354cdedef59SAnirudh Venkataramanan return 0; 2355cdedef59SAnirudh Venkataramanan 2356cdedef59SAnirudh Venkataramanan free_q_irqs: 2357cdedef59SAnirudh Venkataramanan while (vector) { 2358cdedef59SAnirudh Venkataramanan vector--; 235928bf2672SBrett Creeley irq_num = pf->msix_entries[base + vector].vector; 236028bf2672SBrett Creeley if (!IS_ENABLED(CONFIG_RFS_ACCEL)) 2361cdedef59SAnirudh Venkataramanan irq_set_affinity_notifier(irq_num, NULL); 2362cdedef59SAnirudh Venkataramanan irq_set_affinity_hint(irq_num, NULL); 23634015d11eSBrett Creeley devm_free_irq(dev, irq_num, &vsi->q_vectors[vector]); 2364cdedef59SAnirudh Venkataramanan } 2365cdedef59SAnirudh Venkataramanan return err; 2366cdedef59SAnirudh Venkataramanan } 2367cdedef59SAnirudh Venkataramanan 2368cdedef59SAnirudh Venkataramanan /** 2369efc2214bSMaciej Fijalkowski * ice_xdp_alloc_setup_rings - Allocate and setup Tx rings for XDP 2370efc2214bSMaciej Fijalkowski * @vsi: VSI to setup Tx rings used by XDP 2371efc2214bSMaciej Fijalkowski * 2372efc2214bSMaciej Fijalkowski * Return 0 on success and negative value on error 2373efc2214bSMaciej Fijalkowski */ 2374efc2214bSMaciej Fijalkowski static int ice_xdp_alloc_setup_rings(struct ice_vsi *vsi) 2375efc2214bSMaciej Fijalkowski { 23769a946843SAnirudh Venkataramanan struct device *dev = ice_pf_to_dev(vsi->back); 23779610bd98SMaciej Fijalkowski struct ice_tx_desc *tx_desc; 23789610bd98SMaciej Fijalkowski int i, j; 2379efc2214bSMaciej Fijalkowski 23802faf63b6SMaciej Fijalkowski ice_for_each_xdp_txq(vsi, i) { 2381efc2214bSMaciej Fijalkowski u16 xdp_q_idx = vsi->alloc_txq + i; 2382e72bba21SMaciej Fijalkowski struct ice_tx_ring *xdp_ring; 2383efc2214bSMaciej Fijalkowski 2384efc2214bSMaciej Fijalkowski xdp_ring = kzalloc(sizeof(*xdp_ring), GFP_KERNEL); 2385efc2214bSMaciej Fijalkowski 2386efc2214bSMaciej Fijalkowski if (!xdp_ring) 2387efc2214bSMaciej Fijalkowski goto free_xdp_rings; 2388efc2214bSMaciej Fijalkowski 2389efc2214bSMaciej Fijalkowski xdp_ring->q_index = xdp_q_idx; 2390efc2214bSMaciej Fijalkowski xdp_ring->reg_idx = vsi->txq_map[xdp_q_idx]; 2391efc2214bSMaciej Fijalkowski xdp_ring->vsi = vsi; 2392efc2214bSMaciej Fijalkowski xdp_ring->netdev = NULL; 23939610bd98SMaciej Fijalkowski xdp_ring->next_dd = ICE_TX_THRESH - 1; 23949610bd98SMaciej Fijalkowski xdp_ring->next_rs = ICE_TX_THRESH - 1; 2395efc2214bSMaciej Fijalkowski xdp_ring->dev = dev; 2396efc2214bSMaciej Fijalkowski xdp_ring->count = vsi->num_tx_desc; 2397b1d95cc2SCiara Loftus WRITE_ONCE(vsi->xdp_rings[i], xdp_ring); 2398efc2214bSMaciej Fijalkowski if (ice_setup_tx_ring(xdp_ring)) 2399efc2214bSMaciej Fijalkowski goto free_xdp_rings; 2400efc2214bSMaciej Fijalkowski ice_set_ring_xdp(xdp_ring); 2401e72bba21SMaciej Fijalkowski xdp_ring->xsk_pool = ice_tx_xsk_pool(xdp_ring); 240222bf877eSMaciej Fijalkowski spin_lock_init(&xdp_ring->tx_lock); 24039610bd98SMaciej Fijalkowski for (j = 0; j < xdp_ring->count; j++) { 24049610bd98SMaciej Fijalkowski tx_desc = ICE_TX_DESC(xdp_ring, j); 24059610bd98SMaciej Fijalkowski tx_desc->cmd_type_offset_bsz = cpu_to_le64(ICE_TX_DESC_DTYPE_DESC_DONE); 24069610bd98SMaciej Fijalkowski } 2407efc2214bSMaciej Fijalkowski } 2408efc2214bSMaciej Fijalkowski 240922bf877eSMaciej Fijalkowski ice_for_each_rxq(vsi, i) { 241022bf877eSMaciej Fijalkowski if (static_key_enabled(&ice_xdp_locking_key)) 241122bf877eSMaciej Fijalkowski vsi->rx_rings[i]->xdp_ring = vsi->xdp_rings[i % vsi->num_xdp_txq]; 241222bf877eSMaciej Fijalkowski else 2413eb087cd8SMaciej Fijalkowski vsi->rx_rings[i]->xdp_ring = vsi->xdp_rings[i]; 241422bf877eSMaciej Fijalkowski } 2415eb087cd8SMaciej Fijalkowski 2416efc2214bSMaciej Fijalkowski return 0; 2417efc2214bSMaciej Fijalkowski 2418efc2214bSMaciej Fijalkowski free_xdp_rings: 2419efc2214bSMaciej Fijalkowski for (; i >= 0; i--) 2420efc2214bSMaciej Fijalkowski if (vsi->xdp_rings[i] && vsi->xdp_rings[i]->desc) 2421efc2214bSMaciej Fijalkowski ice_free_tx_ring(vsi->xdp_rings[i]); 2422efc2214bSMaciej Fijalkowski return -ENOMEM; 2423efc2214bSMaciej Fijalkowski } 2424efc2214bSMaciej Fijalkowski 2425efc2214bSMaciej Fijalkowski /** 2426efc2214bSMaciej Fijalkowski * ice_vsi_assign_bpf_prog - set or clear bpf prog pointer on VSI 2427efc2214bSMaciej Fijalkowski * @vsi: VSI to set the bpf prog on 2428efc2214bSMaciej Fijalkowski * @prog: the bpf prog pointer 2429efc2214bSMaciej Fijalkowski */ 2430efc2214bSMaciej Fijalkowski static void ice_vsi_assign_bpf_prog(struct ice_vsi *vsi, struct bpf_prog *prog) 2431efc2214bSMaciej Fijalkowski { 2432efc2214bSMaciej Fijalkowski struct bpf_prog *old_prog; 2433efc2214bSMaciej Fijalkowski int i; 2434efc2214bSMaciej Fijalkowski 2435efc2214bSMaciej Fijalkowski old_prog = xchg(&vsi->xdp_prog, prog); 2436efc2214bSMaciej Fijalkowski if (old_prog) 2437efc2214bSMaciej Fijalkowski bpf_prog_put(old_prog); 2438efc2214bSMaciej Fijalkowski 2439efc2214bSMaciej Fijalkowski ice_for_each_rxq(vsi, i) 2440efc2214bSMaciej Fijalkowski WRITE_ONCE(vsi->rx_rings[i]->xdp_prog, vsi->xdp_prog); 2441efc2214bSMaciej Fijalkowski } 2442efc2214bSMaciej Fijalkowski 2443efc2214bSMaciej Fijalkowski /** 2444efc2214bSMaciej Fijalkowski * ice_prepare_xdp_rings - Allocate, configure and setup Tx rings for XDP 2445efc2214bSMaciej Fijalkowski * @vsi: VSI to bring up Tx rings used by XDP 2446efc2214bSMaciej Fijalkowski * @prog: bpf program that will be assigned to VSI 2447efc2214bSMaciej Fijalkowski * 2448efc2214bSMaciej Fijalkowski * Return 0 on success and negative value on error 2449efc2214bSMaciej Fijalkowski */ 2450efc2214bSMaciej Fijalkowski int ice_prepare_xdp_rings(struct ice_vsi *vsi, struct bpf_prog *prog) 2451efc2214bSMaciej Fijalkowski { 2452efc2214bSMaciej Fijalkowski u16 max_txqs[ICE_MAX_TRAFFIC_CLASS] = { 0 }; 2453efc2214bSMaciej Fijalkowski int xdp_rings_rem = vsi->num_xdp_txq; 2454efc2214bSMaciej Fijalkowski struct ice_pf *pf = vsi->back; 2455efc2214bSMaciej Fijalkowski struct ice_qs_cfg xdp_qs_cfg = { 2456efc2214bSMaciej Fijalkowski .qs_mutex = &pf->avail_q_mutex, 2457efc2214bSMaciej Fijalkowski .pf_map = pf->avail_txqs, 2458efc2214bSMaciej Fijalkowski .pf_map_size = pf->max_pf_txqs, 2459efc2214bSMaciej Fijalkowski .q_count = vsi->num_xdp_txq, 2460efc2214bSMaciej Fijalkowski .scatter_count = ICE_MAX_SCATTER_TXQS, 2461efc2214bSMaciej Fijalkowski .vsi_map = vsi->txq_map, 2462efc2214bSMaciej Fijalkowski .vsi_map_offset = vsi->alloc_txq, 2463efc2214bSMaciej Fijalkowski .mapping_mode = ICE_VSI_MAP_CONTIG 2464efc2214bSMaciej Fijalkowski }; 2465efc2214bSMaciej Fijalkowski enum ice_status status; 24664015d11eSBrett Creeley struct device *dev; 2467efc2214bSMaciej Fijalkowski int i, v_idx; 2468efc2214bSMaciej Fijalkowski 24694015d11eSBrett Creeley dev = ice_pf_to_dev(pf); 24704015d11eSBrett Creeley vsi->xdp_rings = devm_kcalloc(dev, vsi->num_xdp_txq, 2471efc2214bSMaciej Fijalkowski sizeof(*vsi->xdp_rings), GFP_KERNEL); 2472efc2214bSMaciej Fijalkowski if (!vsi->xdp_rings) 2473efc2214bSMaciej Fijalkowski return -ENOMEM; 2474efc2214bSMaciej Fijalkowski 2475efc2214bSMaciej Fijalkowski vsi->xdp_mapping_mode = xdp_qs_cfg.mapping_mode; 2476efc2214bSMaciej Fijalkowski if (__ice_vsi_get_qs(&xdp_qs_cfg)) 2477efc2214bSMaciej Fijalkowski goto err_map_xdp; 2478efc2214bSMaciej Fijalkowski 247922bf877eSMaciej Fijalkowski if (static_key_enabled(&ice_xdp_locking_key)) 248022bf877eSMaciej Fijalkowski netdev_warn(vsi->netdev, 248122bf877eSMaciej Fijalkowski "Could not allocate one XDP Tx ring per CPU, XDP_TX/XDP_REDIRECT actions will be slower\n"); 248222bf877eSMaciej Fijalkowski 2483efc2214bSMaciej Fijalkowski if (ice_xdp_alloc_setup_rings(vsi)) 2484efc2214bSMaciej Fijalkowski goto clear_xdp_rings; 2485efc2214bSMaciej Fijalkowski 2486efc2214bSMaciej Fijalkowski /* follow the logic from ice_vsi_map_rings_to_vectors */ 2487efc2214bSMaciej Fijalkowski ice_for_each_q_vector(vsi, v_idx) { 2488efc2214bSMaciej Fijalkowski struct ice_q_vector *q_vector = vsi->q_vectors[v_idx]; 2489efc2214bSMaciej Fijalkowski int xdp_rings_per_v, q_id, q_base; 2490efc2214bSMaciej Fijalkowski 2491efc2214bSMaciej Fijalkowski xdp_rings_per_v = DIV_ROUND_UP(xdp_rings_rem, 2492efc2214bSMaciej Fijalkowski vsi->num_q_vectors - v_idx); 2493efc2214bSMaciej Fijalkowski q_base = vsi->num_xdp_txq - xdp_rings_rem; 2494efc2214bSMaciej Fijalkowski 2495efc2214bSMaciej Fijalkowski for (q_id = q_base; q_id < (q_base + xdp_rings_per_v); q_id++) { 2496e72bba21SMaciej Fijalkowski struct ice_tx_ring *xdp_ring = vsi->xdp_rings[q_id]; 2497efc2214bSMaciej Fijalkowski 2498efc2214bSMaciej Fijalkowski xdp_ring->q_vector = q_vector; 2499e72bba21SMaciej Fijalkowski xdp_ring->next = q_vector->tx.tx_ring; 2500e72bba21SMaciej Fijalkowski q_vector->tx.tx_ring = xdp_ring; 2501efc2214bSMaciej Fijalkowski } 2502efc2214bSMaciej Fijalkowski xdp_rings_rem -= xdp_rings_per_v; 2503efc2214bSMaciej Fijalkowski } 2504efc2214bSMaciej Fijalkowski 2505efc2214bSMaciej Fijalkowski /* omit the scheduler update if in reset path; XDP queues will be 2506efc2214bSMaciej Fijalkowski * taken into account at the end of ice_vsi_rebuild, where 2507efc2214bSMaciej Fijalkowski * ice_cfg_vsi_lan is being called 2508efc2214bSMaciej Fijalkowski */ 2509efc2214bSMaciej Fijalkowski if (ice_is_reset_in_progress(pf->state)) 2510efc2214bSMaciej Fijalkowski return 0; 2511efc2214bSMaciej Fijalkowski 2512efc2214bSMaciej Fijalkowski /* tell the Tx scheduler that right now we have 2513efc2214bSMaciej Fijalkowski * additional queues 2514efc2214bSMaciej Fijalkowski */ 2515efc2214bSMaciej Fijalkowski for (i = 0; i < vsi->tc_cfg.numtc; i++) 2516efc2214bSMaciej Fijalkowski max_txqs[i] = vsi->num_txq + vsi->num_xdp_txq; 2517efc2214bSMaciej Fijalkowski 2518efc2214bSMaciej Fijalkowski status = ice_cfg_vsi_lan(vsi->port_info, vsi->idx, vsi->tc_cfg.ena_tc, 2519efc2214bSMaciej Fijalkowski max_txqs); 2520efc2214bSMaciej Fijalkowski if (status) { 25210fee3577SLihong Yang dev_err(dev, "Failed VSI LAN queue config for XDP, error: %s\n", 25220fee3577SLihong Yang ice_stat_str(status)); 2523efc2214bSMaciej Fijalkowski goto clear_xdp_rings; 2524efc2214bSMaciej Fijalkowski } 2525efc2214bSMaciej Fijalkowski ice_vsi_assign_bpf_prog(vsi, prog); 2526efc2214bSMaciej Fijalkowski 2527efc2214bSMaciej Fijalkowski return 0; 2528efc2214bSMaciej Fijalkowski clear_xdp_rings: 25292faf63b6SMaciej Fijalkowski ice_for_each_xdp_txq(vsi, i) 2530efc2214bSMaciej Fijalkowski if (vsi->xdp_rings[i]) { 2531efc2214bSMaciej Fijalkowski kfree_rcu(vsi->xdp_rings[i], rcu); 2532efc2214bSMaciej Fijalkowski vsi->xdp_rings[i] = NULL; 2533efc2214bSMaciej Fijalkowski } 2534efc2214bSMaciej Fijalkowski 2535efc2214bSMaciej Fijalkowski err_map_xdp: 2536efc2214bSMaciej Fijalkowski mutex_lock(&pf->avail_q_mutex); 25372faf63b6SMaciej Fijalkowski ice_for_each_xdp_txq(vsi, i) { 2538efc2214bSMaciej Fijalkowski clear_bit(vsi->txq_map[i + vsi->alloc_txq], pf->avail_txqs); 2539efc2214bSMaciej Fijalkowski vsi->txq_map[i + vsi->alloc_txq] = ICE_INVAL_Q_INDEX; 2540efc2214bSMaciej Fijalkowski } 2541efc2214bSMaciej Fijalkowski mutex_unlock(&pf->avail_q_mutex); 2542efc2214bSMaciej Fijalkowski 25434015d11eSBrett Creeley devm_kfree(dev, vsi->xdp_rings); 2544efc2214bSMaciej Fijalkowski return -ENOMEM; 2545efc2214bSMaciej Fijalkowski } 2546efc2214bSMaciej Fijalkowski 2547efc2214bSMaciej Fijalkowski /** 2548efc2214bSMaciej Fijalkowski * ice_destroy_xdp_rings - undo the configuration made by ice_prepare_xdp_rings 2549efc2214bSMaciej Fijalkowski * @vsi: VSI to remove XDP rings 2550efc2214bSMaciej Fijalkowski * 2551efc2214bSMaciej Fijalkowski * Detach XDP rings from irq vectors, clean up the PF bitmap and free 2552efc2214bSMaciej Fijalkowski * resources 2553efc2214bSMaciej Fijalkowski */ 2554efc2214bSMaciej Fijalkowski int ice_destroy_xdp_rings(struct ice_vsi *vsi) 2555efc2214bSMaciej Fijalkowski { 2556efc2214bSMaciej Fijalkowski u16 max_txqs[ICE_MAX_TRAFFIC_CLASS] = { 0 }; 2557efc2214bSMaciej Fijalkowski struct ice_pf *pf = vsi->back; 2558efc2214bSMaciej Fijalkowski int i, v_idx; 2559efc2214bSMaciej Fijalkowski 2560efc2214bSMaciej Fijalkowski /* q_vectors are freed in reset path so there's no point in detaching 2561ac382a09SBruce Allan * rings; in case of rebuild being triggered not from reset bits 2562efc2214bSMaciej Fijalkowski * in pf->state won't be set, so additionally check first q_vector 2563efc2214bSMaciej Fijalkowski * against NULL 2564efc2214bSMaciej Fijalkowski */ 2565efc2214bSMaciej Fijalkowski if (ice_is_reset_in_progress(pf->state) || !vsi->q_vectors[0]) 2566efc2214bSMaciej Fijalkowski goto free_qmap; 2567efc2214bSMaciej Fijalkowski 2568efc2214bSMaciej Fijalkowski ice_for_each_q_vector(vsi, v_idx) { 2569efc2214bSMaciej Fijalkowski struct ice_q_vector *q_vector = vsi->q_vectors[v_idx]; 2570e72bba21SMaciej Fijalkowski struct ice_tx_ring *ring; 2571efc2214bSMaciej Fijalkowski 2572e72bba21SMaciej Fijalkowski ice_for_each_tx_ring(ring, q_vector->tx) 2573efc2214bSMaciej Fijalkowski if (!ring->tx_buf || !ice_ring_is_xdp(ring)) 2574efc2214bSMaciej Fijalkowski break; 2575efc2214bSMaciej Fijalkowski 2576efc2214bSMaciej Fijalkowski /* restore the value of last node prior to XDP setup */ 2577e72bba21SMaciej Fijalkowski q_vector->tx.tx_ring = ring; 2578efc2214bSMaciej Fijalkowski } 2579efc2214bSMaciej Fijalkowski 2580efc2214bSMaciej Fijalkowski free_qmap: 2581efc2214bSMaciej Fijalkowski mutex_lock(&pf->avail_q_mutex); 25822faf63b6SMaciej Fijalkowski ice_for_each_xdp_txq(vsi, i) { 2583efc2214bSMaciej Fijalkowski clear_bit(vsi->txq_map[i + vsi->alloc_txq], pf->avail_txqs); 2584efc2214bSMaciej Fijalkowski vsi->txq_map[i + vsi->alloc_txq] = ICE_INVAL_Q_INDEX; 2585efc2214bSMaciej Fijalkowski } 2586efc2214bSMaciej Fijalkowski mutex_unlock(&pf->avail_q_mutex); 2587efc2214bSMaciej Fijalkowski 25882faf63b6SMaciej Fijalkowski ice_for_each_xdp_txq(vsi, i) 2589efc2214bSMaciej Fijalkowski if (vsi->xdp_rings[i]) { 2590efc2214bSMaciej Fijalkowski if (vsi->xdp_rings[i]->desc) 2591efc2214bSMaciej Fijalkowski ice_free_tx_ring(vsi->xdp_rings[i]); 2592efc2214bSMaciej Fijalkowski kfree_rcu(vsi->xdp_rings[i], rcu); 2593efc2214bSMaciej Fijalkowski vsi->xdp_rings[i] = NULL; 2594efc2214bSMaciej Fijalkowski } 2595efc2214bSMaciej Fijalkowski 25964015d11eSBrett Creeley devm_kfree(ice_pf_to_dev(pf), vsi->xdp_rings); 2597efc2214bSMaciej Fijalkowski vsi->xdp_rings = NULL; 2598efc2214bSMaciej Fijalkowski 259922bf877eSMaciej Fijalkowski if (static_key_enabled(&ice_xdp_locking_key)) 260022bf877eSMaciej Fijalkowski static_branch_dec(&ice_xdp_locking_key); 260122bf877eSMaciej Fijalkowski 2602efc2214bSMaciej Fijalkowski if (ice_is_reset_in_progress(pf->state) || !vsi->q_vectors[0]) 2603efc2214bSMaciej Fijalkowski return 0; 2604efc2214bSMaciej Fijalkowski 2605efc2214bSMaciej Fijalkowski ice_vsi_assign_bpf_prog(vsi, NULL); 2606efc2214bSMaciej Fijalkowski 2607efc2214bSMaciej Fijalkowski /* notify Tx scheduler that we destroyed XDP queues and bring 2608efc2214bSMaciej Fijalkowski * back the old number of child nodes 2609efc2214bSMaciej Fijalkowski */ 2610efc2214bSMaciej Fijalkowski for (i = 0; i < vsi->tc_cfg.numtc; i++) 2611efc2214bSMaciej Fijalkowski max_txqs[i] = vsi->num_txq; 2612efc2214bSMaciej Fijalkowski 2613c8f135c6SMarta Plantykow /* change number of XDP Tx queues to 0 */ 2614c8f135c6SMarta Plantykow vsi->num_xdp_txq = 0; 2615c8f135c6SMarta Plantykow 2616efc2214bSMaciej Fijalkowski return ice_cfg_vsi_lan(vsi->port_info, vsi->idx, vsi->tc_cfg.ena_tc, 2617efc2214bSMaciej Fijalkowski max_txqs); 2618efc2214bSMaciej Fijalkowski } 2619efc2214bSMaciej Fijalkowski 2620efc2214bSMaciej Fijalkowski /** 2621c7a21904SMichal Swiatkowski * ice_vsi_rx_napi_schedule - Schedule napi on RX queues from VSI 2622c7a21904SMichal Swiatkowski * @vsi: VSI to schedule napi on 2623c7a21904SMichal Swiatkowski */ 2624c7a21904SMichal Swiatkowski static void ice_vsi_rx_napi_schedule(struct ice_vsi *vsi) 2625c7a21904SMichal Swiatkowski { 2626c7a21904SMichal Swiatkowski int i; 2627c7a21904SMichal Swiatkowski 2628c7a21904SMichal Swiatkowski ice_for_each_rxq(vsi, i) { 2629e72bba21SMaciej Fijalkowski struct ice_rx_ring *rx_ring = vsi->rx_rings[i]; 2630c7a21904SMichal Swiatkowski 2631c7a21904SMichal Swiatkowski if (rx_ring->xsk_pool) 2632c7a21904SMichal Swiatkowski napi_schedule(&rx_ring->q_vector->napi); 2633c7a21904SMichal Swiatkowski } 2634c7a21904SMichal Swiatkowski } 2635c7a21904SMichal Swiatkowski 2636c7a21904SMichal Swiatkowski /** 263722bf877eSMaciej Fijalkowski * ice_vsi_determine_xdp_res - figure out how many Tx qs can XDP have 263822bf877eSMaciej Fijalkowski * @vsi: VSI to determine the count of XDP Tx qs 263922bf877eSMaciej Fijalkowski * 264022bf877eSMaciej Fijalkowski * returns 0 if Tx qs count is higher than at least half of CPU count, 264122bf877eSMaciej Fijalkowski * -ENOMEM otherwise 264222bf877eSMaciej Fijalkowski */ 264322bf877eSMaciej Fijalkowski int ice_vsi_determine_xdp_res(struct ice_vsi *vsi) 264422bf877eSMaciej Fijalkowski { 264522bf877eSMaciej Fijalkowski u16 avail = ice_get_avail_txq_count(vsi->back); 264622bf877eSMaciej Fijalkowski u16 cpus = num_possible_cpus(); 264722bf877eSMaciej Fijalkowski 264822bf877eSMaciej Fijalkowski if (avail < cpus / 2) 264922bf877eSMaciej Fijalkowski return -ENOMEM; 265022bf877eSMaciej Fijalkowski 265122bf877eSMaciej Fijalkowski vsi->num_xdp_txq = min_t(u16, avail, cpus); 265222bf877eSMaciej Fijalkowski 265322bf877eSMaciej Fijalkowski if (vsi->num_xdp_txq < cpus) 265422bf877eSMaciej Fijalkowski static_branch_inc(&ice_xdp_locking_key); 265522bf877eSMaciej Fijalkowski 265622bf877eSMaciej Fijalkowski return 0; 265722bf877eSMaciej Fijalkowski } 265822bf877eSMaciej Fijalkowski 265922bf877eSMaciej Fijalkowski /** 2660efc2214bSMaciej Fijalkowski * ice_xdp_setup_prog - Add or remove XDP eBPF program 2661efc2214bSMaciej Fijalkowski * @vsi: VSI to setup XDP for 2662efc2214bSMaciej Fijalkowski * @prog: XDP program 2663efc2214bSMaciej Fijalkowski * @extack: netlink extended ack 2664efc2214bSMaciej Fijalkowski */ 2665efc2214bSMaciej Fijalkowski static int 2666efc2214bSMaciej Fijalkowski ice_xdp_setup_prog(struct ice_vsi *vsi, struct bpf_prog *prog, 2667efc2214bSMaciej Fijalkowski struct netlink_ext_ack *extack) 2668efc2214bSMaciej Fijalkowski { 2669efc2214bSMaciej Fijalkowski int frame_size = vsi->netdev->mtu + ICE_ETH_PKT_HDR_PAD; 2670efc2214bSMaciej Fijalkowski bool if_running = netif_running(vsi->netdev); 2671efc2214bSMaciej Fijalkowski int ret = 0, xdp_ring_err = 0; 2672efc2214bSMaciej Fijalkowski 2673efc2214bSMaciej Fijalkowski if (frame_size > vsi->rx_buf_len) { 2674efc2214bSMaciej Fijalkowski NL_SET_ERR_MSG_MOD(extack, "MTU too large for loading XDP"); 2675efc2214bSMaciej Fijalkowski return -EOPNOTSUPP; 2676efc2214bSMaciej Fijalkowski } 2677efc2214bSMaciej Fijalkowski 2678efc2214bSMaciej Fijalkowski /* need to stop netdev while setting up the program for Rx rings */ 2679e97fb1aeSAnirudh Venkataramanan if (if_running && !test_and_set_bit(ICE_VSI_DOWN, vsi->state)) { 2680efc2214bSMaciej Fijalkowski ret = ice_down(vsi); 2681efc2214bSMaciej Fijalkowski if (ret) { 2682af23635aSJesse Brandeburg NL_SET_ERR_MSG_MOD(extack, "Preparing device for XDP attach failed"); 2683efc2214bSMaciej Fijalkowski return ret; 2684efc2214bSMaciej Fijalkowski } 2685efc2214bSMaciej Fijalkowski } 2686efc2214bSMaciej Fijalkowski 2687efc2214bSMaciej Fijalkowski if (!ice_is_xdp_ena_vsi(vsi) && prog) { 268822bf877eSMaciej Fijalkowski xdp_ring_err = ice_vsi_determine_xdp_res(vsi); 268922bf877eSMaciej Fijalkowski if (xdp_ring_err) { 269022bf877eSMaciej Fijalkowski NL_SET_ERR_MSG_MOD(extack, "Not enough Tx resources for XDP"); 269122bf877eSMaciej Fijalkowski } else { 2692efc2214bSMaciej Fijalkowski xdp_ring_err = ice_prepare_xdp_rings(vsi, prog); 2693efc2214bSMaciej Fijalkowski if (xdp_ring_err) 2694af23635aSJesse Brandeburg NL_SET_ERR_MSG_MOD(extack, "Setting up XDP Tx resources failed"); 269522bf877eSMaciej Fijalkowski } 2696efc2214bSMaciej Fijalkowski } else if (ice_is_xdp_ena_vsi(vsi) && !prog) { 2697efc2214bSMaciej Fijalkowski xdp_ring_err = ice_destroy_xdp_rings(vsi); 2698efc2214bSMaciej Fijalkowski if (xdp_ring_err) 2699af23635aSJesse Brandeburg NL_SET_ERR_MSG_MOD(extack, "Freeing XDP Tx resources failed"); 2700efc2214bSMaciej Fijalkowski } else { 2701efc2214bSMaciej Fijalkowski ice_vsi_assign_bpf_prog(vsi, prog); 2702efc2214bSMaciej Fijalkowski } 2703efc2214bSMaciej Fijalkowski 2704efc2214bSMaciej Fijalkowski if (if_running) 2705efc2214bSMaciej Fijalkowski ret = ice_up(vsi); 2706efc2214bSMaciej Fijalkowski 2707c7a21904SMichal Swiatkowski if (!ret && prog) 2708c7a21904SMichal Swiatkowski ice_vsi_rx_napi_schedule(vsi); 27092d4238f5SKrzysztof Kazimierczak 2710efc2214bSMaciej Fijalkowski return (ret || xdp_ring_err) ? -ENOMEM : 0; 2711efc2214bSMaciej Fijalkowski } 2712efc2214bSMaciej Fijalkowski 2713efc2214bSMaciej Fijalkowski /** 2714ebc5399eSMaciej Fijalkowski * ice_xdp_safe_mode - XDP handler for safe mode 2715ebc5399eSMaciej Fijalkowski * @dev: netdevice 2716ebc5399eSMaciej Fijalkowski * @xdp: XDP command 2717ebc5399eSMaciej Fijalkowski */ 2718ebc5399eSMaciej Fijalkowski static int ice_xdp_safe_mode(struct net_device __always_unused *dev, 2719ebc5399eSMaciej Fijalkowski struct netdev_bpf *xdp) 2720ebc5399eSMaciej Fijalkowski { 2721ebc5399eSMaciej Fijalkowski NL_SET_ERR_MSG_MOD(xdp->extack, 2722ebc5399eSMaciej Fijalkowski "Please provide working DDP firmware package in order to use XDP\n" 2723ebc5399eSMaciej Fijalkowski "Refer to Documentation/networking/device_drivers/ethernet/intel/ice.rst"); 2724ebc5399eSMaciej Fijalkowski return -EOPNOTSUPP; 2725ebc5399eSMaciej Fijalkowski } 2726ebc5399eSMaciej Fijalkowski 2727ebc5399eSMaciej Fijalkowski /** 2728efc2214bSMaciej Fijalkowski * ice_xdp - implements XDP handler 2729efc2214bSMaciej Fijalkowski * @dev: netdevice 2730efc2214bSMaciej Fijalkowski * @xdp: XDP command 2731efc2214bSMaciej Fijalkowski */ 2732efc2214bSMaciej Fijalkowski static int ice_xdp(struct net_device *dev, struct netdev_bpf *xdp) 2733efc2214bSMaciej Fijalkowski { 2734efc2214bSMaciej Fijalkowski struct ice_netdev_priv *np = netdev_priv(dev); 2735efc2214bSMaciej Fijalkowski struct ice_vsi *vsi = np->vsi; 2736efc2214bSMaciej Fijalkowski 2737efc2214bSMaciej Fijalkowski if (vsi->type != ICE_VSI_PF) { 2738af23635aSJesse Brandeburg NL_SET_ERR_MSG_MOD(xdp->extack, "XDP can be loaded only on PF VSI"); 2739efc2214bSMaciej Fijalkowski return -EINVAL; 2740efc2214bSMaciej Fijalkowski } 2741efc2214bSMaciej Fijalkowski 2742efc2214bSMaciej Fijalkowski switch (xdp->command) { 2743efc2214bSMaciej Fijalkowski case XDP_SETUP_PROG: 2744efc2214bSMaciej Fijalkowski return ice_xdp_setup_prog(vsi, xdp->prog, xdp->extack); 27451742b3d5SMagnus Karlsson case XDP_SETUP_XSK_POOL: 27461742b3d5SMagnus Karlsson return ice_xsk_pool_setup(vsi, xdp->xsk.pool, 27472d4238f5SKrzysztof Kazimierczak xdp->xsk.queue_id); 2748efc2214bSMaciej Fijalkowski default: 2749efc2214bSMaciej Fijalkowski return -EINVAL; 2750efc2214bSMaciej Fijalkowski } 2751efc2214bSMaciej Fijalkowski } 2752efc2214bSMaciej Fijalkowski 2753efc2214bSMaciej Fijalkowski /** 2754940b61afSAnirudh Venkataramanan * ice_ena_misc_vector - enable the non-queue interrupts 2755940b61afSAnirudh Venkataramanan * @pf: board private structure 2756940b61afSAnirudh Venkataramanan */ 2757940b61afSAnirudh Venkataramanan static void ice_ena_misc_vector(struct ice_pf *pf) 2758940b61afSAnirudh Venkataramanan { 2759940b61afSAnirudh Venkataramanan struct ice_hw *hw = &pf->hw; 2760940b61afSAnirudh Venkataramanan u32 val; 2761940b61afSAnirudh Venkataramanan 27629d5c5a52SPaul Greenwalt /* Disable anti-spoof detection interrupt to prevent spurious event 27639d5c5a52SPaul Greenwalt * interrupts during a function reset. Anti-spoof functionally is 27649d5c5a52SPaul Greenwalt * still supported. 27659d5c5a52SPaul Greenwalt */ 27669d5c5a52SPaul Greenwalt val = rd32(hw, GL_MDCK_TX_TDPU); 27679d5c5a52SPaul Greenwalt val |= GL_MDCK_TX_TDPU_RCU_ANTISPOOF_ITR_DIS_M; 27689d5c5a52SPaul Greenwalt wr32(hw, GL_MDCK_TX_TDPU, val); 27699d5c5a52SPaul Greenwalt 2770940b61afSAnirudh Venkataramanan /* clear things first */ 2771940b61afSAnirudh Venkataramanan wr32(hw, PFINT_OICR_ENA, 0); /* disable all */ 2772940b61afSAnirudh Venkataramanan rd32(hw, PFINT_OICR); /* read to clear */ 2773940b61afSAnirudh Venkataramanan 27743bcd7fa3SBruce Allan val = (PFINT_OICR_ECC_ERR_M | 2775940b61afSAnirudh Venkataramanan PFINT_OICR_MAL_DETECT_M | 2776940b61afSAnirudh Venkataramanan PFINT_OICR_GRST_M | 2777940b61afSAnirudh Venkataramanan PFINT_OICR_PCI_EXCEPTION_M | 2778007676b4SAnirudh Venkataramanan PFINT_OICR_VFLR_M | 27793bcd7fa3SBruce Allan PFINT_OICR_HMC_ERR_M | 2780348048e7SDave Ertman PFINT_OICR_PE_PUSH_M | 27813bcd7fa3SBruce Allan PFINT_OICR_PE_CRITERR_M); 2782940b61afSAnirudh Venkataramanan 2783940b61afSAnirudh Venkataramanan wr32(hw, PFINT_OICR_ENA, val); 2784940b61afSAnirudh Venkataramanan 2785940b61afSAnirudh Venkataramanan /* SW_ITR_IDX = 0, but don't change INTENA */ 2786cbe66bfeSBrett Creeley wr32(hw, GLINT_DYN_CTL(pf->oicr_idx), 2787940b61afSAnirudh Venkataramanan GLINT_DYN_CTL_SW_ITR_INDX_M | GLINT_DYN_CTL_INTENA_MSK_M); 2788940b61afSAnirudh Venkataramanan } 2789940b61afSAnirudh Venkataramanan 2790940b61afSAnirudh Venkataramanan /** 2791940b61afSAnirudh Venkataramanan * ice_misc_intr - misc interrupt handler 2792940b61afSAnirudh Venkataramanan * @irq: interrupt number 2793940b61afSAnirudh Venkataramanan * @data: pointer to a q_vector 2794940b61afSAnirudh Venkataramanan */ 2795940b61afSAnirudh Venkataramanan static irqreturn_t ice_misc_intr(int __always_unused irq, void *data) 2796940b61afSAnirudh Venkataramanan { 2797940b61afSAnirudh Venkataramanan struct ice_pf *pf = (struct ice_pf *)data; 2798940b61afSAnirudh Venkataramanan struct ice_hw *hw = &pf->hw; 2799940b61afSAnirudh Venkataramanan irqreturn_t ret = IRQ_NONE; 28004015d11eSBrett Creeley struct device *dev; 2801940b61afSAnirudh Venkataramanan u32 oicr, ena_mask; 2802940b61afSAnirudh Venkataramanan 28034015d11eSBrett Creeley dev = ice_pf_to_dev(pf); 28047e408e07SAnirudh Venkataramanan set_bit(ICE_ADMINQ_EVENT_PENDING, pf->state); 28057e408e07SAnirudh Venkataramanan set_bit(ICE_MAILBOXQ_EVENT_PENDING, pf->state); 28068f5ee3c4SJacob Keller set_bit(ICE_SIDEBANDQ_EVENT_PENDING, pf->state); 2807940b61afSAnirudh Venkataramanan 2808940b61afSAnirudh Venkataramanan oicr = rd32(hw, PFINT_OICR); 2809940b61afSAnirudh Venkataramanan ena_mask = rd32(hw, PFINT_OICR_ENA); 2810940b61afSAnirudh Venkataramanan 28110e674aebSAnirudh Venkataramanan if (oicr & PFINT_OICR_SWINT_M) { 28120e674aebSAnirudh Venkataramanan ena_mask &= ~PFINT_OICR_SWINT_M; 28130e674aebSAnirudh Venkataramanan pf->sw_int_count++; 28140e674aebSAnirudh Venkataramanan } 28150e674aebSAnirudh Venkataramanan 2816b3969fd7SSudheer Mogilappagari if (oicr & PFINT_OICR_MAL_DETECT_M) { 2817b3969fd7SSudheer Mogilappagari ena_mask &= ~PFINT_OICR_MAL_DETECT_M; 28187e408e07SAnirudh Venkataramanan set_bit(ICE_MDD_EVENT_PENDING, pf->state); 2819b3969fd7SSudheer Mogilappagari } 2820007676b4SAnirudh Venkataramanan if (oicr & PFINT_OICR_VFLR_M) { 2821f844d521SBrett Creeley /* disable any further VFLR event notifications */ 28227e408e07SAnirudh Venkataramanan if (test_bit(ICE_VF_RESETS_DISABLED, pf->state)) { 2823f844d521SBrett Creeley u32 reg = rd32(hw, PFINT_OICR_ENA); 2824f844d521SBrett Creeley 2825f844d521SBrett Creeley reg &= ~PFINT_OICR_VFLR_M; 2826f844d521SBrett Creeley wr32(hw, PFINT_OICR_ENA, reg); 2827f844d521SBrett Creeley } else { 2828007676b4SAnirudh Venkataramanan ena_mask &= ~PFINT_OICR_VFLR_M; 28297e408e07SAnirudh Venkataramanan set_bit(ICE_VFLR_EVENT_PENDING, pf->state); 2830007676b4SAnirudh Venkataramanan } 2831f844d521SBrett Creeley } 2832b3969fd7SSudheer Mogilappagari 28330b28b702SAnirudh Venkataramanan if (oicr & PFINT_OICR_GRST_M) { 28340b28b702SAnirudh Venkataramanan u32 reset; 2835b3969fd7SSudheer Mogilappagari 28360b28b702SAnirudh Venkataramanan /* we have a reset warning */ 28370b28b702SAnirudh Venkataramanan ena_mask &= ~PFINT_OICR_GRST_M; 28380b28b702SAnirudh Venkataramanan reset = (rd32(hw, GLGEN_RSTAT) & GLGEN_RSTAT_RESET_TYPE_M) >> 28390b28b702SAnirudh Venkataramanan GLGEN_RSTAT_RESET_TYPE_S; 28400b28b702SAnirudh Venkataramanan 28410b28b702SAnirudh Venkataramanan if (reset == ICE_RESET_CORER) 28420b28b702SAnirudh Venkataramanan pf->corer_count++; 28430b28b702SAnirudh Venkataramanan else if (reset == ICE_RESET_GLOBR) 28440b28b702SAnirudh Venkataramanan pf->globr_count++; 2845ca4929b6SBrett Creeley else if (reset == ICE_RESET_EMPR) 28460b28b702SAnirudh Venkataramanan pf->empr_count++; 2847ca4929b6SBrett Creeley else 28484015d11eSBrett Creeley dev_dbg(dev, "Invalid reset type %d\n", reset); 28490b28b702SAnirudh Venkataramanan 28500b28b702SAnirudh Venkataramanan /* If a reset cycle isn't already in progress, we set a bit in 28510b28b702SAnirudh Venkataramanan * pf->state so that the service task can start a reset/rebuild. 28520b28b702SAnirudh Venkataramanan */ 28537e408e07SAnirudh Venkataramanan if (!test_and_set_bit(ICE_RESET_OICR_RECV, pf->state)) { 28540b28b702SAnirudh Venkataramanan if (reset == ICE_RESET_CORER) 28557e408e07SAnirudh Venkataramanan set_bit(ICE_CORER_RECV, pf->state); 28560b28b702SAnirudh Venkataramanan else if (reset == ICE_RESET_GLOBR) 28577e408e07SAnirudh Venkataramanan set_bit(ICE_GLOBR_RECV, pf->state); 28580b28b702SAnirudh Venkataramanan else 28597e408e07SAnirudh Venkataramanan set_bit(ICE_EMPR_RECV, pf->state); 28600b28b702SAnirudh Venkataramanan 2861fd2a9817SAnirudh Venkataramanan /* There are couple of different bits at play here. 2862fd2a9817SAnirudh Venkataramanan * hw->reset_ongoing indicates whether the hardware is 2863fd2a9817SAnirudh Venkataramanan * in reset. This is set to true when a reset interrupt 2864fd2a9817SAnirudh Venkataramanan * is received and set back to false after the driver 2865fd2a9817SAnirudh Venkataramanan * has determined that the hardware is out of reset. 2866fd2a9817SAnirudh Venkataramanan * 28677e408e07SAnirudh Venkataramanan * ICE_RESET_OICR_RECV in pf->state indicates 2868fd2a9817SAnirudh Venkataramanan * that a post reset rebuild is required before the 2869fd2a9817SAnirudh Venkataramanan * driver is operational again. This is set above. 2870fd2a9817SAnirudh Venkataramanan * 2871fd2a9817SAnirudh Venkataramanan * As this is the start of the reset/rebuild cycle, set 2872fd2a9817SAnirudh Venkataramanan * both to indicate that. 2873fd2a9817SAnirudh Venkataramanan */ 2874fd2a9817SAnirudh Venkataramanan hw->reset_ongoing = true; 28750b28b702SAnirudh Venkataramanan } 28760b28b702SAnirudh Venkataramanan } 28770b28b702SAnirudh Venkataramanan 2878ea9b847cSJacob Keller if (oicr & PFINT_OICR_TSYN_TX_M) { 2879ea9b847cSJacob Keller ena_mask &= ~PFINT_OICR_TSYN_TX_M; 2880ea9b847cSJacob Keller ice_ptp_process_ts(pf); 2881ea9b847cSJacob Keller } 2882ea9b847cSJacob Keller 2883172db5f9SMaciej Machnikowski if (oicr & PFINT_OICR_TSYN_EVNT_M) { 2884172db5f9SMaciej Machnikowski u8 tmr_idx = hw->func_caps.ts_func_info.tmr_index_owned; 2885172db5f9SMaciej Machnikowski u32 gltsyn_stat = rd32(hw, GLTSYN_STAT(tmr_idx)); 2886172db5f9SMaciej Machnikowski 2887172db5f9SMaciej Machnikowski /* Save EVENTs from GTSYN register */ 2888172db5f9SMaciej Machnikowski pf->ptp.ext_ts_irq |= gltsyn_stat & (GLTSYN_STAT_EVENT0_M | 2889172db5f9SMaciej Machnikowski GLTSYN_STAT_EVENT1_M | 2890172db5f9SMaciej Machnikowski GLTSYN_STAT_EVENT2_M); 2891172db5f9SMaciej Machnikowski ena_mask &= ~PFINT_OICR_TSYN_EVNT_M; 2892172db5f9SMaciej Machnikowski kthread_queue_work(pf->ptp.kworker, &pf->ptp.extts_work); 2893172db5f9SMaciej Machnikowski } 2894172db5f9SMaciej Machnikowski 2895348048e7SDave Ertman #define ICE_AUX_CRIT_ERR (PFINT_OICR_PE_CRITERR_M | PFINT_OICR_HMC_ERR_M | PFINT_OICR_PE_PUSH_M) 2896348048e7SDave Ertman if (oicr & ICE_AUX_CRIT_ERR) { 2897348048e7SDave Ertman struct iidc_event *event; 2898348048e7SDave Ertman 2899348048e7SDave Ertman ena_mask &= ~ICE_AUX_CRIT_ERR; 2900348048e7SDave Ertman event = kzalloc(sizeof(*event), GFP_KERNEL); 2901348048e7SDave Ertman if (event) { 2902348048e7SDave Ertman set_bit(IIDC_EVENT_CRIT_ERR, event->type); 2903348048e7SDave Ertman /* report the entire OICR value to AUX driver */ 2904348048e7SDave Ertman event->reg = oicr; 2905348048e7SDave Ertman ice_send_event_to_aux(pf, event); 2906348048e7SDave Ertman kfree(event); 2907348048e7SDave Ertman } 2908940b61afSAnirudh Venkataramanan } 2909940b61afSAnirudh Venkataramanan 29108d7189d2SMd Fahad Iqbal Polash /* Report any remaining unexpected interrupts */ 2911940b61afSAnirudh Venkataramanan oicr &= ena_mask; 2912940b61afSAnirudh Venkataramanan if (oicr) { 29134015d11eSBrett Creeley dev_dbg(dev, "unhandled interrupt oicr=0x%08x\n", oicr); 2914940b61afSAnirudh Venkataramanan /* If a critical error is pending there is no choice but to 2915940b61afSAnirudh Venkataramanan * reset the device. 2916940b61afSAnirudh Venkataramanan */ 2917348048e7SDave Ertman if (oicr & (PFINT_OICR_PCI_EXCEPTION_M | 29180b28b702SAnirudh Venkataramanan PFINT_OICR_ECC_ERR_M)) { 29197e408e07SAnirudh Venkataramanan set_bit(ICE_PFR_REQ, pf->state); 29200b28b702SAnirudh Venkataramanan ice_service_task_schedule(pf); 29210b28b702SAnirudh Venkataramanan } 2922940b61afSAnirudh Venkataramanan } 2923940b61afSAnirudh Venkataramanan ret = IRQ_HANDLED; 2924940b61afSAnirudh Venkataramanan 2925940b61afSAnirudh Venkataramanan ice_service_task_schedule(pf); 2926cdedef59SAnirudh Venkataramanan ice_irq_dynamic_ena(hw, NULL, NULL); 2927940b61afSAnirudh Venkataramanan 2928940b61afSAnirudh Venkataramanan return ret; 2929940b61afSAnirudh Venkataramanan } 2930940b61afSAnirudh Venkataramanan 2931940b61afSAnirudh Venkataramanan /** 29320e04e8e1SBrett Creeley * ice_dis_ctrlq_interrupts - disable control queue interrupts 29330e04e8e1SBrett Creeley * @hw: pointer to HW structure 29340e04e8e1SBrett Creeley */ 29350e04e8e1SBrett Creeley static void ice_dis_ctrlq_interrupts(struct ice_hw *hw) 29360e04e8e1SBrett Creeley { 29370e04e8e1SBrett Creeley /* disable Admin queue Interrupt causes */ 29380e04e8e1SBrett Creeley wr32(hw, PFINT_FW_CTL, 29390e04e8e1SBrett Creeley rd32(hw, PFINT_FW_CTL) & ~PFINT_FW_CTL_CAUSE_ENA_M); 29400e04e8e1SBrett Creeley 29410e04e8e1SBrett Creeley /* disable Mailbox queue Interrupt causes */ 29420e04e8e1SBrett Creeley wr32(hw, PFINT_MBX_CTL, 29430e04e8e1SBrett Creeley rd32(hw, PFINT_MBX_CTL) & ~PFINT_MBX_CTL_CAUSE_ENA_M); 29440e04e8e1SBrett Creeley 29458f5ee3c4SJacob Keller wr32(hw, PFINT_SB_CTL, 29468f5ee3c4SJacob Keller rd32(hw, PFINT_SB_CTL) & ~PFINT_SB_CTL_CAUSE_ENA_M); 29478f5ee3c4SJacob Keller 29480e04e8e1SBrett Creeley /* disable Control queue Interrupt causes */ 29490e04e8e1SBrett Creeley wr32(hw, PFINT_OICR_CTL, 29500e04e8e1SBrett Creeley rd32(hw, PFINT_OICR_CTL) & ~PFINT_OICR_CTL_CAUSE_ENA_M); 29510e04e8e1SBrett Creeley 29520e04e8e1SBrett Creeley ice_flush(hw); 29530e04e8e1SBrett Creeley } 29540e04e8e1SBrett Creeley 29550e04e8e1SBrett Creeley /** 2956940b61afSAnirudh Venkataramanan * ice_free_irq_msix_misc - Unroll misc vector setup 2957940b61afSAnirudh Venkataramanan * @pf: board private structure 2958940b61afSAnirudh Venkataramanan */ 2959940b61afSAnirudh Venkataramanan static void ice_free_irq_msix_misc(struct ice_pf *pf) 2960940b61afSAnirudh Venkataramanan { 29610e04e8e1SBrett Creeley struct ice_hw *hw = &pf->hw; 29620e04e8e1SBrett Creeley 29630e04e8e1SBrett Creeley ice_dis_ctrlq_interrupts(hw); 29640e04e8e1SBrett Creeley 2965940b61afSAnirudh Venkataramanan /* disable OICR interrupt */ 29660e04e8e1SBrett Creeley wr32(hw, PFINT_OICR_ENA, 0); 29670e04e8e1SBrett Creeley ice_flush(hw); 2968940b61afSAnirudh Venkataramanan 2969ba880734SBrett Creeley if (pf->msix_entries) { 2970cbe66bfeSBrett Creeley synchronize_irq(pf->msix_entries[pf->oicr_idx].vector); 29714015d11eSBrett Creeley devm_free_irq(ice_pf_to_dev(pf), 2972cbe66bfeSBrett Creeley pf->msix_entries[pf->oicr_idx].vector, pf); 2973940b61afSAnirudh Venkataramanan } 2974940b61afSAnirudh Venkataramanan 2975eb0208ecSPreethi Banala pf->num_avail_sw_msix += 1; 2976cbe66bfeSBrett Creeley ice_free_res(pf->irq_tracker, pf->oicr_idx, ICE_RES_MISC_VEC_ID); 2977940b61afSAnirudh Venkataramanan } 2978940b61afSAnirudh Venkataramanan 2979940b61afSAnirudh Venkataramanan /** 29800e04e8e1SBrett Creeley * ice_ena_ctrlq_interrupts - enable control queue interrupts 29810e04e8e1SBrett Creeley * @hw: pointer to HW structure 2982b07833a0SBrett Creeley * @reg_idx: HW vector index to associate the control queue interrupts with 29830e04e8e1SBrett Creeley */ 2984b07833a0SBrett Creeley static void ice_ena_ctrlq_interrupts(struct ice_hw *hw, u16 reg_idx) 29850e04e8e1SBrett Creeley { 29860e04e8e1SBrett Creeley u32 val; 29870e04e8e1SBrett Creeley 2988b07833a0SBrett Creeley val = ((reg_idx & PFINT_OICR_CTL_MSIX_INDX_M) | 29890e04e8e1SBrett Creeley PFINT_OICR_CTL_CAUSE_ENA_M); 29900e04e8e1SBrett Creeley wr32(hw, PFINT_OICR_CTL, val); 29910e04e8e1SBrett Creeley 29920e04e8e1SBrett Creeley /* enable Admin queue Interrupt causes */ 2993b07833a0SBrett Creeley val = ((reg_idx & PFINT_FW_CTL_MSIX_INDX_M) | 29940e04e8e1SBrett Creeley PFINT_FW_CTL_CAUSE_ENA_M); 29950e04e8e1SBrett Creeley wr32(hw, PFINT_FW_CTL, val); 29960e04e8e1SBrett Creeley 29970e04e8e1SBrett Creeley /* enable Mailbox queue Interrupt causes */ 2998b07833a0SBrett Creeley val = ((reg_idx & PFINT_MBX_CTL_MSIX_INDX_M) | 29990e04e8e1SBrett Creeley PFINT_MBX_CTL_CAUSE_ENA_M); 30000e04e8e1SBrett Creeley wr32(hw, PFINT_MBX_CTL, val); 30010e04e8e1SBrett Creeley 30028f5ee3c4SJacob Keller /* This enables Sideband queue Interrupt causes */ 30038f5ee3c4SJacob Keller val = ((reg_idx & PFINT_SB_CTL_MSIX_INDX_M) | 30048f5ee3c4SJacob Keller PFINT_SB_CTL_CAUSE_ENA_M); 30058f5ee3c4SJacob Keller wr32(hw, PFINT_SB_CTL, val); 30068f5ee3c4SJacob Keller 30070e04e8e1SBrett Creeley ice_flush(hw); 30080e04e8e1SBrett Creeley } 30090e04e8e1SBrett Creeley 30100e04e8e1SBrett Creeley /** 3011940b61afSAnirudh Venkataramanan * ice_req_irq_msix_misc - Setup the misc vector to handle non queue events 3012940b61afSAnirudh Venkataramanan * @pf: board private structure 3013940b61afSAnirudh Venkataramanan * 3014940b61afSAnirudh Venkataramanan * This sets up the handler for MSIX 0, which is used to manage the 3015940b61afSAnirudh Venkataramanan * non-queue interrupts, e.g. AdminQ and errors. This is not used 3016940b61afSAnirudh Venkataramanan * when in MSI or Legacy interrupt mode. 3017940b61afSAnirudh Venkataramanan */ 3018940b61afSAnirudh Venkataramanan static int ice_req_irq_msix_misc(struct ice_pf *pf) 3019940b61afSAnirudh Venkataramanan { 30204015d11eSBrett Creeley struct device *dev = ice_pf_to_dev(pf); 3021940b61afSAnirudh Venkataramanan struct ice_hw *hw = &pf->hw; 3022940b61afSAnirudh Venkataramanan int oicr_idx, err = 0; 3023940b61afSAnirudh Venkataramanan 3024940b61afSAnirudh Venkataramanan if (!pf->int_name[0]) 3025940b61afSAnirudh Venkataramanan snprintf(pf->int_name, sizeof(pf->int_name) - 1, "%s-%s:misc", 30264015d11eSBrett Creeley dev_driver_string(dev), dev_name(dev)); 3027940b61afSAnirudh Venkataramanan 30280b28b702SAnirudh Venkataramanan /* Do not request IRQ but do enable OICR interrupt since settings are 30290b28b702SAnirudh Venkataramanan * lost during reset. Note that this function is called only during 30300b28b702SAnirudh Venkataramanan * rebuild path and not while reset is in progress. 30310b28b702SAnirudh Venkataramanan */ 30325df7e45dSDave Ertman if (ice_is_reset_in_progress(pf->state)) 30330b28b702SAnirudh Venkataramanan goto skip_req_irq; 30340b28b702SAnirudh Venkataramanan 3035cbe66bfeSBrett Creeley /* reserve one vector in irq_tracker for misc interrupts */ 3036cbe66bfeSBrett Creeley oicr_idx = ice_get_res(pf, pf->irq_tracker, 1, ICE_RES_MISC_VEC_ID); 3037940b61afSAnirudh Venkataramanan if (oicr_idx < 0) 3038940b61afSAnirudh Venkataramanan return oicr_idx; 3039940b61afSAnirudh Venkataramanan 3040eb0208ecSPreethi Banala pf->num_avail_sw_msix -= 1; 304188865fc4SKarol Kolacinski pf->oicr_idx = (u16)oicr_idx; 3042940b61afSAnirudh Venkataramanan 30434015d11eSBrett Creeley err = devm_request_irq(dev, pf->msix_entries[pf->oicr_idx].vector, 3044940b61afSAnirudh Venkataramanan ice_misc_intr, 0, pf->int_name, pf); 3045940b61afSAnirudh Venkataramanan if (err) { 30464015d11eSBrett Creeley dev_err(dev, "devm_request_irq for %s failed: %d\n", 3047940b61afSAnirudh Venkataramanan pf->int_name, err); 3048cbe66bfeSBrett Creeley ice_free_res(pf->irq_tracker, 1, ICE_RES_MISC_VEC_ID); 3049eb0208ecSPreethi Banala pf->num_avail_sw_msix += 1; 3050940b61afSAnirudh Venkataramanan return err; 3051940b61afSAnirudh Venkataramanan } 3052940b61afSAnirudh Venkataramanan 30530b28b702SAnirudh Venkataramanan skip_req_irq: 3054940b61afSAnirudh Venkataramanan ice_ena_misc_vector(pf); 3055940b61afSAnirudh Venkataramanan 3056cbe66bfeSBrett Creeley ice_ena_ctrlq_interrupts(hw, pf->oicr_idx); 3057cbe66bfeSBrett Creeley wr32(hw, GLINT_ITR(ICE_RX_ITR, pf->oicr_idx), 305863f545edSBrett Creeley ITR_REG_ALIGN(ICE_ITR_8K) >> ICE_ITR_GRAN_S); 3059940b61afSAnirudh Venkataramanan 3060940b61afSAnirudh Venkataramanan ice_flush(hw); 3061cdedef59SAnirudh Venkataramanan ice_irq_dynamic_ena(hw, NULL, NULL); 3062940b61afSAnirudh Venkataramanan 3063940b61afSAnirudh Venkataramanan return 0; 3064940b61afSAnirudh Venkataramanan } 3065940b61afSAnirudh Venkataramanan 3066940b61afSAnirudh Venkataramanan /** 3067df0f8479SAnirudh Venkataramanan * ice_napi_add - register NAPI handler for the VSI 3068df0f8479SAnirudh Venkataramanan * @vsi: VSI for which NAPI handler is to be registered 3069df0f8479SAnirudh Venkataramanan * 3070df0f8479SAnirudh Venkataramanan * This function is only called in the driver's load path. Registering the NAPI 3071df0f8479SAnirudh Venkataramanan * handler is done in ice_vsi_alloc_q_vector() for all other cases (i.e. resume, 3072df0f8479SAnirudh Venkataramanan * reset/rebuild, etc.) 3073df0f8479SAnirudh Venkataramanan */ 3074df0f8479SAnirudh Venkataramanan static void ice_napi_add(struct ice_vsi *vsi) 3075df0f8479SAnirudh Venkataramanan { 3076df0f8479SAnirudh Venkataramanan int v_idx; 3077df0f8479SAnirudh Venkataramanan 3078df0f8479SAnirudh Venkataramanan if (!vsi->netdev) 3079df0f8479SAnirudh Venkataramanan return; 3080df0f8479SAnirudh Venkataramanan 30810c2561c8SBrett Creeley ice_for_each_q_vector(vsi, v_idx) 3082df0f8479SAnirudh Venkataramanan netif_napi_add(vsi->netdev, &vsi->q_vectors[v_idx]->napi, 3083df0f8479SAnirudh Venkataramanan ice_napi_poll, NAPI_POLL_WEIGHT); 3084df0f8479SAnirudh Venkataramanan } 3085df0f8479SAnirudh Venkataramanan 3086df0f8479SAnirudh Venkataramanan /** 3087462acf6aSTony Nguyen * ice_set_ops - set netdev and ethtools ops for the given netdev 3088462acf6aSTony Nguyen * @netdev: netdev instance 30893a858ba3SAnirudh Venkataramanan */ 3090462acf6aSTony Nguyen static void ice_set_ops(struct net_device *netdev) 30913a858ba3SAnirudh Venkataramanan { 3092462acf6aSTony Nguyen struct ice_pf *pf = ice_netdev_to_pf(netdev); 3093462acf6aSTony Nguyen 3094462acf6aSTony Nguyen if (ice_is_safe_mode(pf)) { 3095462acf6aSTony Nguyen netdev->netdev_ops = &ice_netdev_safe_mode_ops; 3096462acf6aSTony Nguyen ice_set_ethtool_safe_mode_ops(netdev); 3097462acf6aSTony Nguyen return; 3098462acf6aSTony Nguyen } 3099462acf6aSTony Nguyen 3100462acf6aSTony Nguyen netdev->netdev_ops = &ice_netdev_ops; 3101b20e6c17SJakub Kicinski netdev->udp_tunnel_nic_info = &pf->hw.udp_tunnel_nic; 3102462acf6aSTony Nguyen ice_set_ethtool_ops(netdev); 3103462acf6aSTony Nguyen } 3104462acf6aSTony Nguyen 3105462acf6aSTony Nguyen /** 3106462acf6aSTony Nguyen * ice_set_netdev_features - set features for the given netdev 3107462acf6aSTony Nguyen * @netdev: netdev instance 3108462acf6aSTony Nguyen */ 3109462acf6aSTony Nguyen static void ice_set_netdev_features(struct net_device *netdev) 3110462acf6aSTony Nguyen { 3111462acf6aSTony Nguyen struct ice_pf *pf = ice_netdev_to_pf(netdev); 3112d76a60baSAnirudh Venkataramanan netdev_features_t csumo_features; 3113d76a60baSAnirudh Venkataramanan netdev_features_t vlano_features; 3114d76a60baSAnirudh Venkataramanan netdev_features_t dflt_features; 3115d76a60baSAnirudh Venkataramanan netdev_features_t tso_features; 31163a858ba3SAnirudh Venkataramanan 3117462acf6aSTony Nguyen if (ice_is_safe_mode(pf)) { 3118462acf6aSTony Nguyen /* safe mode */ 3119462acf6aSTony Nguyen netdev->features = NETIF_F_SG | NETIF_F_HIGHDMA; 3120462acf6aSTony Nguyen netdev->hw_features = netdev->features; 3121462acf6aSTony Nguyen return; 3122462acf6aSTony Nguyen } 31233a858ba3SAnirudh Venkataramanan 3124d76a60baSAnirudh Venkataramanan dflt_features = NETIF_F_SG | 31253a858ba3SAnirudh Venkataramanan NETIF_F_HIGHDMA | 3126148beb61SHenry Tieman NETIF_F_NTUPLE | 31273a858ba3SAnirudh Venkataramanan NETIF_F_RXHASH; 31283a858ba3SAnirudh Venkataramanan 3129d76a60baSAnirudh Venkataramanan csumo_features = NETIF_F_RXCSUM | 3130d76a60baSAnirudh Venkataramanan NETIF_F_IP_CSUM | 3131cf909e19SAnirudh Venkataramanan NETIF_F_SCTP_CRC | 3132d76a60baSAnirudh Venkataramanan NETIF_F_IPV6_CSUM; 3133d76a60baSAnirudh Venkataramanan 3134d76a60baSAnirudh Venkataramanan vlano_features = NETIF_F_HW_VLAN_CTAG_FILTER | 3135d76a60baSAnirudh Venkataramanan NETIF_F_HW_VLAN_CTAG_TX | 3136d76a60baSAnirudh Venkataramanan NETIF_F_HW_VLAN_CTAG_RX; 3137d76a60baSAnirudh Venkataramanan 3138a54e3b8cSBrett Creeley tso_features = NETIF_F_TSO | 3139a4e82a81STony Nguyen NETIF_F_TSO_ECN | 3140a4e82a81STony Nguyen NETIF_F_TSO6 | 3141a4e82a81STony Nguyen NETIF_F_GSO_GRE | 3142a4e82a81STony Nguyen NETIF_F_GSO_UDP_TUNNEL | 3143a4e82a81STony Nguyen NETIF_F_GSO_GRE_CSUM | 3144a4e82a81STony Nguyen NETIF_F_GSO_UDP_TUNNEL_CSUM | 3145a4e82a81STony Nguyen NETIF_F_GSO_PARTIAL | 3146a4e82a81STony Nguyen NETIF_F_GSO_IPXIP4 | 3147a4e82a81STony Nguyen NETIF_F_GSO_IPXIP6 | 3148a54e3b8cSBrett Creeley NETIF_F_GSO_UDP_L4; 3149d76a60baSAnirudh Venkataramanan 3150a4e82a81STony Nguyen netdev->gso_partial_features |= NETIF_F_GSO_UDP_TUNNEL_CSUM | 3151a4e82a81STony Nguyen NETIF_F_GSO_GRE_CSUM; 3152d76a60baSAnirudh Venkataramanan /* set features that user can change */ 3153d76a60baSAnirudh Venkataramanan netdev->hw_features = dflt_features | csumo_features | 3154d76a60baSAnirudh Venkataramanan vlano_features | tso_features; 3155d76a60baSAnirudh Venkataramanan 3156a4e82a81STony Nguyen /* add support for HW_CSUM on packets with MPLS header */ 3157a4e82a81STony Nguyen netdev->mpls_features = NETIF_F_HW_CSUM; 3158a4e82a81STony Nguyen 31593a858ba3SAnirudh Venkataramanan /* enable features */ 31603a858ba3SAnirudh Venkataramanan netdev->features |= netdev->hw_features; 31610d08a441SKiran Patil 31620d08a441SKiran Patil netdev->hw_features |= NETIF_F_HW_TC; 31630d08a441SKiran Patil 3164d76a60baSAnirudh Venkataramanan /* encap and VLAN devices inherit default, csumo and tso features */ 3165d76a60baSAnirudh Venkataramanan netdev->hw_enc_features |= dflt_features | csumo_features | 3166d76a60baSAnirudh Venkataramanan tso_features; 3167d76a60baSAnirudh Venkataramanan netdev->vlan_features |= dflt_features | csumo_features | 3168d76a60baSAnirudh Venkataramanan tso_features; 3169462acf6aSTony Nguyen } 3170462acf6aSTony Nguyen 3171462acf6aSTony Nguyen /** 3172462acf6aSTony Nguyen * ice_cfg_netdev - Allocate, configure and register a netdev 3173462acf6aSTony Nguyen * @vsi: the VSI associated with the new netdev 3174462acf6aSTony Nguyen * 3175462acf6aSTony Nguyen * Returns 0 on success, negative value on failure 3176462acf6aSTony Nguyen */ 3177462acf6aSTony Nguyen static int ice_cfg_netdev(struct ice_vsi *vsi) 3178462acf6aSTony Nguyen { 3179462acf6aSTony Nguyen struct ice_netdev_priv *np; 3180462acf6aSTony Nguyen struct net_device *netdev; 3181462acf6aSTony Nguyen u8 mac_addr[ETH_ALEN]; 31821adf7eadSJacob Keller 3183462acf6aSTony Nguyen netdev = alloc_etherdev_mqs(sizeof(*np), vsi->alloc_txq, 3184462acf6aSTony Nguyen vsi->alloc_rxq); 31851e23f076SAnirudh Venkataramanan if (!netdev) 31861e23f076SAnirudh Venkataramanan return -ENOMEM; 3187462acf6aSTony Nguyen 3188a476d72aSAnirudh Venkataramanan set_bit(ICE_VSI_NETDEV_ALLOCD, vsi->state); 3189462acf6aSTony Nguyen vsi->netdev = netdev; 3190462acf6aSTony Nguyen np = netdev_priv(netdev); 3191462acf6aSTony Nguyen np->vsi = vsi; 3192462acf6aSTony Nguyen 3193462acf6aSTony Nguyen ice_set_netdev_features(netdev); 3194462acf6aSTony Nguyen 3195462acf6aSTony Nguyen ice_set_ops(netdev); 31963a858ba3SAnirudh Venkataramanan 31973a858ba3SAnirudh Venkataramanan if (vsi->type == ICE_VSI_PF) { 3198c73bf3bdSPaul M Stillwell Jr SET_NETDEV_DEV(netdev, ice_pf_to_dev(vsi->back)); 31993a858ba3SAnirudh Venkataramanan ether_addr_copy(mac_addr, vsi->port_info->mac.perm_addr); 3200f3956ebbSJakub Kicinski eth_hw_addr_set(netdev, mac_addr); 32013a858ba3SAnirudh Venkataramanan ether_addr_copy(netdev->perm_addr, mac_addr); 32023a858ba3SAnirudh Venkataramanan } 32033a858ba3SAnirudh Venkataramanan 32043a858ba3SAnirudh Venkataramanan netdev->priv_flags |= IFF_UNICAST_FLT; 32053a858ba3SAnirudh Venkataramanan 3206462acf6aSTony Nguyen /* Setup netdev TC information */ 3207462acf6aSTony Nguyen ice_vsi_cfg_netdev_tc(vsi, vsi->tc_cfg.ena_tc); 3208cdedef59SAnirudh Venkataramanan 32093a858ba3SAnirudh Venkataramanan /* setup watchdog timeout value to be 5 second */ 32103a858ba3SAnirudh Venkataramanan netdev->watchdog_timeo = 5 * HZ; 32113a858ba3SAnirudh Venkataramanan 32123a858ba3SAnirudh Venkataramanan netdev->min_mtu = ETH_MIN_MTU; 32133a858ba3SAnirudh Venkataramanan netdev->max_mtu = ICE_MAX_MTU; 32143a858ba3SAnirudh Venkataramanan 32153a858ba3SAnirudh Venkataramanan return 0; 32163a858ba3SAnirudh Venkataramanan } 32173a858ba3SAnirudh Venkataramanan 32183a858ba3SAnirudh Venkataramanan /** 3219d76a60baSAnirudh Venkataramanan * ice_fill_rss_lut - Fill the RSS lookup table with default values 3220d76a60baSAnirudh Venkataramanan * @lut: Lookup table 3221d76a60baSAnirudh Venkataramanan * @rss_table_size: Lookup table size 3222d76a60baSAnirudh Venkataramanan * @rss_size: Range of queue number for hashing 3223d76a60baSAnirudh Venkataramanan */ 3224d76a60baSAnirudh Venkataramanan void ice_fill_rss_lut(u8 *lut, u16 rss_table_size, u16 rss_size) 3225d76a60baSAnirudh Venkataramanan { 3226d76a60baSAnirudh Venkataramanan u16 i; 3227d76a60baSAnirudh Venkataramanan 3228d76a60baSAnirudh Venkataramanan for (i = 0; i < rss_table_size; i++) 3229d76a60baSAnirudh Venkataramanan lut[i] = i % rss_size; 3230d76a60baSAnirudh Venkataramanan } 3231d76a60baSAnirudh Venkataramanan 3232d76a60baSAnirudh Venkataramanan /** 32330f9d5027SAnirudh Venkataramanan * ice_pf_vsi_setup - Set up a PF VSI 32340f9d5027SAnirudh Venkataramanan * @pf: board private structure 32350f9d5027SAnirudh Venkataramanan * @pi: pointer to the port_info instance 32360f9d5027SAnirudh Venkataramanan * 32370e674aebSAnirudh Venkataramanan * Returns pointer to the successfully allocated VSI software struct 32380e674aebSAnirudh Venkataramanan * on success, otherwise returns NULL on failure. 32390f9d5027SAnirudh Venkataramanan */ 32400f9d5027SAnirudh Venkataramanan static struct ice_vsi * 32410f9d5027SAnirudh Venkataramanan ice_pf_vsi_setup(struct ice_pf *pf, struct ice_port_info *pi) 32420f9d5027SAnirudh Venkataramanan { 3243*0754d65bSKiran Patil return ice_vsi_setup(pf, pi, ICE_VSI_PF, ICE_INVAL_VFID, NULL); 32440f9d5027SAnirudh Venkataramanan } 32450f9d5027SAnirudh Venkataramanan 32460f9d5027SAnirudh Venkataramanan /** 3247148beb61SHenry Tieman * ice_ctrl_vsi_setup - Set up a control VSI 3248148beb61SHenry Tieman * @pf: board private structure 3249148beb61SHenry Tieman * @pi: pointer to the port_info instance 3250148beb61SHenry Tieman * 3251148beb61SHenry Tieman * Returns pointer to the successfully allocated VSI software struct 3252148beb61SHenry Tieman * on success, otherwise returns NULL on failure. 3253148beb61SHenry Tieman */ 3254148beb61SHenry Tieman static struct ice_vsi * 3255148beb61SHenry Tieman ice_ctrl_vsi_setup(struct ice_pf *pf, struct ice_port_info *pi) 3256148beb61SHenry Tieman { 3257*0754d65bSKiran Patil return ice_vsi_setup(pf, pi, ICE_VSI_CTRL, ICE_INVAL_VFID, NULL); 3258148beb61SHenry Tieman } 3259148beb61SHenry Tieman 3260148beb61SHenry Tieman /** 32610e674aebSAnirudh Venkataramanan * ice_lb_vsi_setup - Set up a loopback VSI 32620e674aebSAnirudh Venkataramanan * @pf: board private structure 32630e674aebSAnirudh Venkataramanan * @pi: pointer to the port_info instance 32640e674aebSAnirudh Venkataramanan * 32650e674aebSAnirudh Venkataramanan * Returns pointer to the successfully allocated VSI software struct 32660e674aebSAnirudh Venkataramanan * on success, otherwise returns NULL on failure. 32670e674aebSAnirudh Venkataramanan */ 32680e674aebSAnirudh Venkataramanan struct ice_vsi * 32690e674aebSAnirudh Venkataramanan ice_lb_vsi_setup(struct ice_pf *pf, struct ice_port_info *pi) 32700e674aebSAnirudh Venkataramanan { 3271*0754d65bSKiran Patil return ice_vsi_setup(pf, pi, ICE_VSI_LB, ICE_INVAL_VFID, NULL); 32720e674aebSAnirudh Venkataramanan } 32730e674aebSAnirudh Venkataramanan 32740e674aebSAnirudh Venkataramanan /** 3275f9867df6SAnirudh Venkataramanan * ice_vlan_rx_add_vid - Add a VLAN ID filter to HW offload 3276d76a60baSAnirudh Venkataramanan * @netdev: network interface to be adjusted 3277d76a60baSAnirudh Venkataramanan * @proto: unused protocol 3278f9867df6SAnirudh Venkataramanan * @vid: VLAN ID to be added 3279d76a60baSAnirudh Venkataramanan * 3280f9867df6SAnirudh Venkataramanan * net_device_ops implementation for adding VLAN IDs 3281d76a60baSAnirudh Venkataramanan */ 3282c8b7abddSBruce Allan static int 3283c8b7abddSBruce Allan ice_vlan_rx_add_vid(struct net_device *netdev, __always_unused __be16 proto, 3284c8b7abddSBruce Allan u16 vid) 3285d76a60baSAnirudh Venkataramanan { 3286d76a60baSAnirudh Venkataramanan struct ice_netdev_priv *np = netdev_priv(netdev); 3287d76a60baSAnirudh Venkataramanan struct ice_vsi *vsi = np->vsi; 32885eda8afdSAkeem G Abodunrin int ret; 3289d76a60baSAnirudh Venkataramanan 329042f3efefSBrett Creeley /* VLAN 0 is added by default during load/reset */ 329142f3efefSBrett Creeley if (!vid) 329242f3efefSBrett Creeley return 0; 329342f3efefSBrett Creeley 329442f3efefSBrett Creeley /* Enable VLAN pruning when a VLAN other than 0 is added */ 329542f3efefSBrett Creeley if (!ice_vsi_is_vlan_pruning_ena(vsi)) { 32965eda8afdSAkeem G Abodunrin ret = ice_cfg_vlan_pruning(vsi, true, false); 32974f74dcc1SBrett Creeley if (ret) 32984f74dcc1SBrett Creeley return ret; 32994f74dcc1SBrett Creeley } 33004f74dcc1SBrett Creeley 330142f3efefSBrett Creeley /* Add a switch rule for this VLAN ID so its corresponding VLAN tagged 330242f3efefSBrett Creeley * packets aren't pruned by the device's internal switch on Rx 3303d76a60baSAnirudh Venkataramanan */ 33041b8f15b6SMichal Swiatkowski ret = ice_vsi_add_vlan(vsi, vid, ICE_FWD_TO_VSI); 3305bcf68ea1SNick Nunley if (!ret) 3306e97fb1aeSAnirudh Venkataramanan set_bit(ICE_VSI_VLAN_FLTR_CHANGED, vsi->state); 33075eda8afdSAkeem G Abodunrin 33085eda8afdSAkeem G Abodunrin return ret; 3309d76a60baSAnirudh Venkataramanan } 3310d76a60baSAnirudh Venkataramanan 3311d76a60baSAnirudh Venkataramanan /** 3312f9867df6SAnirudh Venkataramanan * ice_vlan_rx_kill_vid - Remove a VLAN ID filter from HW offload 3313d76a60baSAnirudh Venkataramanan * @netdev: network interface to be adjusted 3314d76a60baSAnirudh Venkataramanan * @proto: unused protocol 3315f9867df6SAnirudh Venkataramanan * @vid: VLAN ID to be removed 3316d76a60baSAnirudh Venkataramanan * 3317f9867df6SAnirudh Venkataramanan * net_device_ops implementation for removing VLAN IDs 3318d76a60baSAnirudh Venkataramanan */ 3319c8b7abddSBruce Allan static int 3320c8b7abddSBruce Allan ice_vlan_rx_kill_vid(struct net_device *netdev, __always_unused __be16 proto, 3321c8b7abddSBruce Allan u16 vid) 3322d76a60baSAnirudh Venkataramanan { 3323d76a60baSAnirudh Venkataramanan struct ice_netdev_priv *np = netdev_priv(netdev); 3324d76a60baSAnirudh Venkataramanan struct ice_vsi *vsi = np->vsi; 33255eda8afdSAkeem G Abodunrin int ret; 3326d76a60baSAnirudh Venkataramanan 332742f3efefSBrett Creeley /* don't allow removal of VLAN 0 */ 332842f3efefSBrett Creeley if (!vid) 332942f3efefSBrett Creeley return 0; 333042f3efefSBrett Creeley 33314f74dcc1SBrett Creeley /* Make sure ice_vsi_kill_vlan is successful before updating VLAN 33324f74dcc1SBrett Creeley * information 3333d76a60baSAnirudh Venkataramanan */ 33345eda8afdSAkeem G Abodunrin ret = ice_vsi_kill_vlan(vsi, vid); 33355eda8afdSAkeem G Abodunrin if (ret) 33365eda8afdSAkeem G Abodunrin return ret; 3337d76a60baSAnirudh Venkataramanan 333842f3efefSBrett Creeley /* Disable pruning when VLAN 0 is the only VLAN rule */ 333942f3efefSBrett Creeley if (vsi->num_vlan == 1 && ice_vsi_is_vlan_pruning_ena(vsi)) 33405eda8afdSAkeem G Abodunrin ret = ice_cfg_vlan_pruning(vsi, false, false); 33414f74dcc1SBrett Creeley 3342e97fb1aeSAnirudh Venkataramanan set_bit(ICE_VSI_VLAN_FLTR_CHANGED, vsi->state); 33435eda8afdSAkeem G Abodunrin return ret; 3344d76a60baSAnirudh Venkataramanan } 3345d76a60baSAnirudh Venkataramanan 3346d76a60baSAnirudh Venkataramanan /** 33473a858ba3SAnirudh Venkataramanan * ice_setup_pf_sw - Setup the HW switch on startup or after reset 33483a858ba3SAnirudh Venkataramanan * @pf: board private structure 33493a858ba3SAnirudh Venkataramanan * 33503a858ba3SAnirudh Venkataramanan * Returns 0 on success, negative value on failure 33513a858ba3SAnirudh Venkataramanan */ 33523a858ba3SAnirudh Venkataramanan static int ice_setup_pf_sw(struct ice_pf *pf) 33533a858ba3SAnirudh Venkataramanan { 33543a858ba3SAnirudh Venkataramanan struct ice_vsi *vsi; 33553a858ba3SAnirudh Venkataramanan int status = 0; 33563a858ba3SAnirudh Venkataramanan 33575df7e45dSDave Ertman if (ice_is_reset_in_progress(pf->state)) 33580f9d5027SAnirudh Venkataramanan return -EBUSY; 33590f9d5027SAnirudh Venkataramanan 33600f9d5027SAnirudh Venkataramanan vsi = ice_pf_vsi_setup(pf, pf->hw.port_info); 3361135f4b9eSJacob Keller if (!vsi) 3362135f4b9eSJacob Keller return -ENOMEM; 33633a858ba3SAnirudh Venkataramanan 3364df0f8479SAnirudh Venkataramanan status = ice_cfg_netdev(vsi); 3365df0f8479SAnirudh Venkataramanan if (status) { 3366df0f8479SAnirudh Venkataramanan status = -ENODEV; 3367df0f8479SAnirudh Venkataramanan goto unroll_vsi_setup; 3368df0f8479SAnirudh Venkataramanan } 3369efc2214bSMaciej Fijalkowski /* netdev has to be configured before setting frame size */ 3370efc2214bSMaciej Fijalkowski ice_vsi_cfg_frame_size(vsi); 3371df0f8479SAnirudh Venkataramanan 3372b94b013eSDave Ertman /* Setup DCB netlink interface */ 3373b94b013eSDave Ertman ice_dcbnl_setup(vsi); 3374b94b013eSDave Ertman 3375df0f8479SAnirudh Venkataramanan /* registering the NAPI handler requires both the queues and 3376df0f8479SAnirudh Venkataramanan * netdev to be created, which are done in ice_pf_vsi_setup() 3377df0f8479SAnirudh Venkataramanan * and ice_cfg_netdev() respectively 3378df0f8479SAnirudh Venkataramanan */ 3379df0f8479SAnirudh Venkataramanan ice_napi_add(vsi); 3380df0f8479SAnirudh Venkataramanan 338128bf2672SBrett Creeley status = ice_set_cpu_rx_rmap(vsi); 338228bf2672SBrett Creeley if (status) { 338328bf2672SBrett Creeley dev_err(ice_pf_to_dev(pf), "Failed to set CPU Rx map VSI %d error %d\n", 338428bf2672SBrett Creeley vsi->vsi_num, status); 338528bf2672SBrett Creeley status = -EINVAL; 338628bf2672SBrett Creeley goto unroll_napi_add; 338728bf2672SBrett Creeley } 3388561f4379STony Nguyen status = ice_init_mac_fltr(pf); 33899daf8208SAnirudh Venkataramanan if (status) 339028bf2672SBrett Creeley goto free_cpu_rx_map; 33919daf8208SAnirudh Venkataramanan 33929daf8208SAnirudh Venkataramanan return status; 33939daf8208SAnirudh Venkataramanan 339428bf2672SBrett Creeley free_cpu_rx_map: 339528bf2672SBrett Creeley ice_free_cpu_rx_rmap(vsi); 339628bf2672SBrett Creeley 3397df0f8479SAnirudh Venkataramanan unroll_napi_add: 33983a858ba3SAnirudh Venkataramanan if (vsi) { 3399df0f8479SAnirudh Venkataramanan ice_napi_del(vsi); 34003a858ba3SAnirudh Venkataramanan if (vsi->netdev) { 3401a476d72aSAnirudh Venkataramanan clear_bit(ICE_VSI_NETDEV_ALLOCD, vsi->state); 34023a858ba3SAnirudh Venkataramanan free_netdev(vsi->netdev); 34033a858ba3SAnirudh Venkataramanan vsi->netdev = NULL; 34043a858ba3SAnirudh Venkataramanan } 3405df0f8479SAnirudh Venkataramanan } 34069daf8208SAnirudh Venkataramanan 3407df0f8479SAnirudh Venkataramanan unroll_vsi_setup: 3408135f4b9eSJacob Keller ice_vsi_release(vsi); 34093a858ba3SAnirudh Venkataramanan return status; 34103a858ba3SAnirudh Venkataramanan } 34113a858ba3SAnirudh Venkataramanan 34123a858ba3SAnirudh Venkataramanan /** 34138c243700SAnirudh Venkataramanan * ice_get_avail_q_count - Get count of queues in use 34148c243700SAnirudh Venkataramanan * @pf_qmap: bitmap to get queue use count from 34158c243700SAnirudh Venkataramanan * @lock: pointer to a mutex that protects access to pf_qmap 34168c243700SAnirudh Venkataramanan * @size: size of the bitmap 3417940b61afSAnirudh Venkataramanan */ 34188c243700SAnirudh Venkataramanan static u16 34198c243700SAnirudh Venkataramanan ice_get_avail_q_count(unsigned long *pf_qmap, struct mutex *lock, u16 size) 3420940b61afSAnirudh Venkataramanan { 342188865fc4SKarol Kolacinski unsigned long bit; 342288865fc4SKarol Kolacinski u16 count = 0; 3423940b61afSAnirudh Venkataramanan 34248c243700SAnirudh Venkataramanan mutex_lock(lock); 34258c243700SAnirudh Venkataramanan for_each_clear_bit(bit, pf_qmap, size) 34268c243700SAnirudh Venkataramanan count++; 34278c243700SAnirudh Venkataramanan mutex_unlock(lock); 3428940b61afSAnirudh Venkataramanan 34298c243700SAnirudh Venkataramanan return count; 34308c243700SAnirudh Venkataramanan } 3431d76a60baSAnirudh Venkataramanan 34328c243700SAnirudh Venkataramanan /** 34338c243700SAnirudh Venkataramanan * ice_get_avail_txq_count - Get count of Tx queues in use 34348c243700SAnirudh Venkataramanan * @pf: pointer to an ice_pf instance 34358c243700SAnirudh Venkataramanan */ 34368c243700SAnirudh Venkataramanan u16 ice_get_avail_txq_count(struct ice_pf *pf) 34378c243700SAnirudh Venkataramanan { 34388c243700SAnirudh Venkataramanan return ice_get_avail_q_count(pf->avail_txqs, &pf->avail_q_mutex, 34398c243700SAnirudh Venkataramanan pf->max_pf_txqs); 34408c243700SAnirudh Venkataramanan } 3441940b61afSAnirudh Venkataramanan 34428c243700SAnirudh Venkataramanan /** 34438c243700SAnirudh Venkataramanan * ice_get_avail_rxq_count - Get count of Rx queues in use 34448c243700SAnirudh Venkataramanan * @pf: pointer to an ice_pf instance 34458c243700SAnirudh Venkataramanan */ 34468c243700SAnirudh Venkataramanan u16 ice_get_avail_rxq_count(struct ice_pf *pf) 34478c243700SAnirudh Venkataramanan { 34488c243700SAnirudh Venkataramanan return ice_get_avail_q_count(pf->avail_rxqs, &pf->avail_q_mutex, 34498c243700SAnirudh Venkataramanan pf->max_pf_rxqs); 3450940b61afSAnirudh Venkataramanan } 3451940b61afSAnirudh Venkataramanan 3452940b61afSAnirudh Venkataramanan /** 3453940b61afSAnirudh Venkataramanan * ice_deinit_pf - Unrolls initialziations done by ice_init_pf 3454940b61afSAnirudh Venkataramanan * @pf: board private structure to initialize 3455940b61afSAnirudh Venkataramanan */ 3456940b61afSAnirudh Venkataramanan static void ice_deinit_pf(struct ice_pf *pf) 3457940b61afSAnirudh Venkataramanan { 34588d81fa55SAkeem G Abodunrin ice_service_task_stop(pf); 3459940b61afSAnirudh Venkataramanan mutex_destroy(&pf->sw_mutex); 3460b94b013eSDave Ertman mutex_destroy(&pf->tc_mutex); 3461940b61afSAnirudh Venkataramanan mutex_destroy(&pf->avail_q_mutex); 346278b5713aSAnirudh Venkataramanan 346378b5713aSAnirudh Venkataramanan if (pf->avail_txqs) { 346478b5713aSAnirudh Venkataramanan bitmap_free(pf->avail_txqs); 346578b5713aSAnirudh Venkataramanan pf->avail_txqs = NULL; 346678b5713aSAnirudh Venkataramanan } 346778b5713aSAnirudh Venkataramanan 346878b5713aSAnirudh Venkataramanan if (pf->avail_rxqs) { 346978b5713aSAnirudh Venkataramanan bitmap_free(pf->avail_rxqs); 347078b5713aSAnirudh Venkataramanan pf->avail_rxqs = NULL; 347178b5713aSAnirudh Venkataramanan } 347206c16d89SJacob Keller 347306c16d89SJacob Keller if (pf->ptp.clock) 347406c16d89SJacob Keller ptp_clock_unregister(pf->ptp.clock); 3475940b61afSAnirudh Venkataramanan } 3476940b61afSAnirudh Venkataramanan 3477940b61afSAnirudh Venkataramanan /** 3478462acf6aSTony Nguyen * ice_set_pf_caps - set PFs capability flags 3479462acf6aSTony Nguyen * @pf: pointer to the PF instance 3480462acf6aSTony Nguyen */ 3481462acf6aSTony Nguyen static void ice_set_pf_caps(struct ice_pf *pf) 3482462acf6aSTony Nguyen { 3483462acf6aSTony Nguyen struct ice_hw_func_caps *func_caps = &pf->hw.func_caps; 3484462acf6aSTony Nguyen 3485d25a0fc4SDave Ertman clear_bit(ICE_FLAG_RDMA_ENA, pf->flags); 3486d25a0fc4SDave Ertman clear_bit(ICE_FLAG_AUX_ENA, pf->flags); 3487d25a0fc4SDave Ertman if (func_caps->common_cap.rdma) { 3488d25a0fc4SDave Ertman set_bit(ICE_FLAG_RDMA_ENA, pf->flags); 3489d25a0fc4SDave Ertman set_bit(ICE_FLAG_AUX_ENA, pf->flags); 3490d25a0fc4SDave Ertman } 3491462acf6aSTony Nguyen clear_bit(ICE_FLAG_DCB_CAPABLE, pf->flags); 3492462acf6aSTony Nguyen if (func_caps->common_cap.dcb) 3493462acf6aSTony Nguyen set_bit(ICE_FLAG_DCB_CAPABLE, pf->flags); 3494462acf6aSTony Nguyen clear_bit(ICE_FLAG_SRIOV_CAPABLE, pf->flags); 3495462acf6aSTony Nguyen if (func_caps->common_cap.sr_iov_1_1) { 3496462acf6aSTony Nguyen set_bit(ICE_FLAG_SRIOV_CAPABLE, pf->flags); 3497462acf6aSTony Nguyen pf->num_vfs_supported = min_t(int, func_caps->num_allocd_vfs, 3498462acf6aSTony Nguyen ICE_MAX_VF_COUNT); 3499462acf6aSTony Nguyen } 3500462acf6aSTony Nguyen clear_bit(ICE_FLAG_RSS_ENA, pf->flags); 3501462acf6aSTony Nguyen if (func_caps->common_cap.rss_table_size) 3502462acf6aSTony Nguyen set_bit(ICE_FLAG_RSS_ENA, pf->flags); 3503462acf6aSTony Nguyen 3504148beb61SHenry Tieman clear_bit(ICE_FLAG_FD_ENA, pf->flags); 3505148beb61SHenry Tieman if (func_caps->fd_fltr_guar > 0 || func_caps->fd_fltr_best_effort > 0) { 3506148beb61SHenry Tieman u16 unused; 3507148beb61SHenry Tieman 3508148beb61SHenry Tieman /* ctrl_vsi_idx will be set to a valid value when flow director 3509148beb61SHenry Tieman * is setup by ice_init_fdir 3510148beb61SHenry Tieman */ 3511148beb61SHenry Tieman pf->ctrl_vsi_idx = ICE_NO_VSI; 3512148beb61SHenry Tieman set_bit(ICE_FLAG_FD_ENA, pf->flags); 3513148beb61SHenry Tieman /* force guaranteed filter pool for PF */ 3514148beb61SHenry Tieman ice_alloc_fd_guar_item(&pf->hw, &unused, 3515148beb61SHenry Tieman func_caps->fd_fltr_guar); 3516148beb61SHenry Tieman /* force shared filter pool for PF */ 3517148beb61SHenry Tieman ice_alloc_fd_shrd_item(&pf->hw, &unused, 3518148beb61SHenry Tieman func_caps->fd_fltr_best_effort); 3519148beb61SHenry Tieman } 3520148beb61SHenry Tieman 352106c16d89SJacob Keller clear_bit(ICE_FLAG_PTP_SUPPORTED, pf->flags); 352206c16d89SJacob Keller if (func_caps->common_cap.ieee_1588) 352306c16d89SJacob Keller set_bit(ICE_FLAG_PTP_SUPPORTED, pf->flags); 352406c16d89SJacob Keller 3525462acf6aSTony Nguyen pf->max_pf_txqs = func_caps->common_cap.num_txq; 3526462acf6aSTony Nguyen pf->max_pf_rxqs = func_caps->common_cap.num_rxq; 3527462acf6aSTony Nguyen } 3528462acf6aSTony Nguyen 3529462acf6aSTony Nguyen /** 3530940b61afSAnirudh Venkataramanan * ice_init_pf - Initialize general software structures (struct ice_pf) 3531940b61afSAnirudh Venkataramanan * @pf: board private structure to initialize 3532940b61afSAnirudh Venkataramanan */ 353378b5713aSAnirudh Venkataramanan static int ice_init_pf(struct ice_pf *pf) 3534940b61afSAnirudh Venkataramanan { 3535462acf6aSTony Nguyen ice_set_pf_caps(pf); 3536940b61afSAnirudh Venkataramanan 3537940b61afSAnirudh Venkataramanan mutex_init(&pf->sw_mutex); 3538b94b013eSDave Ertman mutex_init(&pf->tc_mutex); 3539d76a60baSAnirudh Venkataramanan 3540d69ea414SJacob Keller INIT_HLIST_HEAD(&pf->aq_wait_list); 3541d69ea414SJacob Keller spin_lock_init(&pf->aq_wait_lock); 3542d69ea414SJacob Keller init_waitqueue_head(&pf->aq_wait_queue); 3543d69ea414SJacob Keller 35441c08052eSJacob Keller init_waitqueue_head(&pf->reset_wait_queue); 35451c08052eSJacob Keller 3546940b61afSAnirudh Venkataramanan /* setup service timer and periodic service task */ 3547940b61afSAnirudh Venkataramanan timer_setup(&pf->serv_tmr, ice_service_timer, 0); 3548940b61afSAnirudh Venkataramanan pf->serv_tmr_period = HZ; 3549940b61afSAnirudh Venkataramanan INIT_WORK(&pf->serv_task, ice_service_task); 35507e408e07SAnirudh Venkataramanan clear_bit(ICE_SERVICE_SCHED, pf->state); 355178b5713aSAnirudh Venkataramanan 3552462acf6aSTony Nguyen mutex_init(&pf->avail_q_mutex); 355378b5713aSAnirudh Venkataramanan pf->avail_txqs = bitmap_zalloc(pf->max_pf_txqs, GFP_KERNEL); 355478b5713aSAnirudh Venkataramanan if (!pf->avail_txqs) 355578b5713aSAnirudh Venkataramanan return -ENOMEM; 355678b5713aSAnirudh Venkataramanan 355778b5713aSAnirudh Venkataramanan pf->avail_rxqs = bitmap_zalloc(pf->max_pf_rxqs, GFP_KERNEL); 355878b5713aSAnirudh Venkataramanan if (!pf->avail_rxqs) { 35594015d11eSBrett Creeley devm_kfree(ice_pf_to_dev(pf), pf->avail_txqs); 356078b5713aSAnirudh Venkataramanan pf->avail_txqs = NULL; 356178b5713aSAnirudh Venkataramanan return -ENOMEM; 356278b5713aSAnirudh Venkataramanan } 356378b5713aSAnirudh Venkataramanan 356478b5713aSAnirudh Venkataramanan return 0; 3565940b61afSAnirudh Venkataramanan } 3566940b61afSAnirudh Venkataramanan 3567940b61afSAnirudh Venkataramanan /** 3568940b61afSAnirudh Venkataramanan * ice_ena_msix_range - Request a range of MSIX vectors from the OS 3569940b61afSAnirudh Venkataramanan * @pf: board private structure 3570940b61afSAnirudh Venkataramanan * 3571940b61afSAnirudh Venkataramanan * compute the number of MSIX vectors required (v_budget) and request from 3572940b61afSAnirudh Venkataramanan * the OS. Return the number of vectors reserved or negative on failure 3573940b61afSAnirudh Venkataramanan */ 3574940b61afSAnirudh Venkataramanan static int ice_ena_msix_range(struct ice_pf *pf) 3575940b61afSAnirudh Venkataramanan { 3576d25a0fc4SDave Ertman int num_cpus, v_left, v_actual, v_other, v_budget = 0; 35774015d11eSBrett Creeley struct device *dev = ice_pf_to_dev(pf); 3578940b61afSAnirudh Venkataramanan int needed, err, i; 3579940b61afSAnirudh Venkataramanan 3580940b61afSAnirudh Venkataramanan v_left = pf->hw.func_caps.common_cap.num_msix_vectors; 3581d25a0fc4SDave Ertman num_cpus = num_online_cpus(); 3582940b61afSAnirudh Venkataramanan 3583741106f7STony Nguyen /* reserve for LAN miscellaneous handler */ 3584741106f7STony Nguyen needed = ICE_MIN_LAN_OICR_MSIX; 3585152b978aSAnirudh Venkataramanan if (v_left < needed) 3586152b978aSAnirudh Venkataramanan goto no_hw_vecs_left_err; 3587940b61afSAnirudh Venkataramanan v_budget += needed; 3588940b61afSAnirudh Venkataramanan v_left -= needed; 3589940b61afSAnirudh Venkataramanan 3590741106f7STony Nguyen /* reserve for flow director */ 3591741106f7STony Nguyen if (test_bit(ICE_FLAG_FD_ENA, pf->flags)) { 3592741106f7STony Nguyen needed = ICE_FDIR_MSIX; 3593741106f7STony Nguyen if (v_left < needed) 3594741106f7STony Nguyen goto no_hw_vecs_left_err; 3595741106f7STony Nguyen v_budget += needed; 3596741106f7STony Nguyen v_left -= needed; 3597741106f7STony Nguyen } 3598741106f7STony Nguyen 3599f66756e0SGrzegorz Nitka /* reserve for switchdev */ 3600f66756e0SGrzegorz Nitka needed = ICE_ESWITCH_MSIX; 3601f66756e0SGrzegorz Nitka if (v_left < needed) 3602f66756e0SGrzegorz Nitka goto no_hw_vecs_left_err; 3603f66756e0SGrzegorz Nitka v_budget += needed; 3604f66756e0SGrzegorz Nitka v_left -= needed; 3605f66756e0SGrzegorz Nitka 3606741106f7STony Nguyen /* total used for non-traffic vectors */ 3607741106f7STony Nguyen v_other = v_budget; 3608741106f7STony Nguyen 3609940b61afSAnirudh Venkataramanan /* reserve vectors for LAN traffic */ 3610d25a0fc4SDave Ertman needed = num_cpus; 3611152b978aSAnirudh Venkataramanan if (v_left < needed) 3612152b978aSAnirudh Venkataramanan goto no_hw_vecs_left_err; 3613152b978aSAnirudh Venkataramanan pf->num_lan_msix = needed; 3614152b978aSAnirudh Venkataramanan v_budget += needed; 3615152b978aSAnirudh Venkataramanan v_left -= needed; 3616940b61afSAnirudh Venkataramanan 3617d25a0fc4SDave Ertman /* reserve vectors for RDMA auxiliary driver */ 3618d25a0fc4SDave Ertman if (test_bit(ICE_FLAG_RDMA_ENA, pf->flags)) { 3619d25a0fc4SDave Ertman needed = num_cpus + ICE_RDMA_NUM_AEQ_MSIX; 3620d25a0fc4SDave Ertman if (v_left < needed) 3621d25a0fc4SDave Ertman goto no_hw_vecs_left_err; 3622d25a0fc4SDave Ertman pf->num_rdma_msix = needed; 3623d25a0fc4SDave Ertman v_budget += needed; 3624d25a0fc4SDave Ertman v_left -= needed; 3625d25a0fc4SDave Ertman } 3626d25a0fc4SDave Ertman 36274015d11eSBrett Creeley pf->msix_entries = devm_kcalloc(dev, v_budget, 3628c6dfd690SBruce Allan sizeof(*pf->msix_entries), GFP_KERNEL); 3629940b61afSAnirudh Venkataramanan if (!pf->msix_entries) { 3630940b61afSAnirudh Venkataramanan err = -ENOMEM; 3631940b61afSAnirudh Venkataramanan goto exit_err; 3632940b61afSAnirudh Venkataramanan } 3633940b61afSAnirudh Venkataramanan 3634940b61afSAnirudh Venkataramanan for (i = 0; i < v_budget; i++) 3635940b61afSAnirudh Venkataramanan pf->msix_entries[i].entry = i; 3636940b61afSAnirudh Venkataramanan 3637940b61afSAnirudh Venkataramanan /* actually reserve the vectors */ 3638940b61afSAnirudh Venkataramanan v_actual = pci_enable_msix_range(pf->pdev, pf->msix_entries, 3639940b61afSAnirudh Venkataramanan ICE_MIN_MSIX, v_budget); 3640940b61afSAnirudh Venkataramanan if (v_actual < 0) { 36414015d11eSBrett Creeley dev_err(dev, "unable to reserve MSI-X vectors\n"); 3642940b61afSAnirudh Venkataramanan err = v_actual; 3643940b61afSAnirudh Venkataramanan goto msix_err; 3644940b61afSAnirudh Venkataramanan } 3645940b61afSAnirudh Venkataramanan 3646940b61afSAnirudh Venkataramanan if (v_actual < v_budget) { 364719cce2c6SAnirudh Venkataramanan dev_warn(dev, "not enough OS MSI-X vectors. requested = %d, obtained = %d\n", 3648940b61afSAnirudh Venkataramanan v_budget, v_actual); 3649152b978aSAnirudh Venkataramanan 3650f3fe97f6SBrett Creeley if (v_actual < ICE_MIN_MSIX) { 3651152b978aSAnirudh Venkataramanan /* error if we can't get minimum vectors */ 3652940b61afSAnirudh Venkataramanan pci_disable_msix(pf->pdev); 3653940b61afSAnirudh Venkataramanan err = -ERANGE; 3654940b61afSAnirudh Venkataramanan goto msix_err; 3655152b978aSAnirudh Venkataramanan } else { 3656d25a0fc4SDave Ertman int v_remain = v_actual - v_other; 3657d25a0fc4SDave Ertman int v_rdma = 0, v_min_rdma = 0; 3658d25a0fc4SDave Ertman 3659d25a0fc4SDave Ertman if (test_bit(ICE_FLAG_RDMA_ENA, pf->flags)) { 3660d25a0fc4SDave Ertman /* Need at least 1 interrupt in addition to 3661d25a0fc4SDave Ertman * AEQ MSIX 3662d25a0fc4SDave Ertman */ 3663d25a0fc4SDave Ertman v_rdma = ICE_RDMA_NUM_AEQ_MSIX + 1; 3664d25a0fc4SDave Ertman v_min_rdma = ICE_MIN_RDMA_MSIX; 3665d25a0fc4SDave Ertman } 3666741106f7STony Nguyen 3667741106f7STony Nguyen if (v_actual == ICE_MIN_MSIX || 3668d25a0fc4SDave Ertman v_remain < ICE_MIN_LAN_TXRX_MSIX + v_min_rdma) { 3669d25a0fc4SDave Ertman dev_warn(dev, "Not enough MSI-X vectors to support RDMA.\n"); 3670d25a0fc4SDave Ertman clear_bit(ICE_FLAG_RDMA_ENA, pf->flags); 3671d25a0fc4SDave Ertman 3672d25a0fc4SDave Ertman pf->num_rdma_msix = 0; 3673f3fe97f6SBrett Creeley pf->num_lan_msix = ICE_MIN_LAN_TXRX_MSIX; 3674d25a0fc4SDave Ertman } else if ((v_remain < ICE_MIN_LAN_TXRX_MSIX + v_rdma) || 3675d25a0fc4SDave Ertman (v_remain - v_rdma < v_rdma)) { 3676d25a0fc4SDave Ertman /* Support minimum RDMA and give remaining 3677d25a0fc4SDave Ertman * vectors to LAN MSIX 3678d25a0fc4SDave Ertman */ 3679d25a0fc4SDave Ertman pf->num_rdma_msix = v_min_rdma; 3680d25a0fc4SDave Ertman pf->num_lan_msix = v_remain - v_min_rdma; 3681d25a0fc4SDave Ertman } else { 3682d25a0fc4SDave Ertman /* Split remaining MSIX with RDMA after 3683d25a0fc4SDave Ertman * accounting for AEQ MSIX 3684d25a0fc4SDave Ertman */ 3685d25a0fc4SDave Ertman pf->num_rdma_msix = (v_remain - ICE_RDMA_NUM_AEQ_MSIX) / 2 + 3686d25a0fc4SDave Ertman ICE_RDMA_NUM_AEQ_MSIX; 3687d25a0fc4SDave Ertman pf->num_lan_msix = v_remain - pf->num_rdma_msix; 3688d25a0fc4SDave Ertman } 3689741106f7STony Nguyen 3690741106f7STony Nguyen dev_notice(dev, "Enabled %d MSI-X vectors for LAN traffic.\n", 3691741106f7STony Nguyen pf->num_lan_msix); 3692d25a0fc4SDave Ertman 3693d25a0fc4SDave Ertman if (test_bit(ICE_FLAG_RDMA_ENA, pf->flags)) 3694d25a0fc4SDave Ertman dev_notice(dev, "Enabled %d MSI-X vectors for RDMA.\n", 3695d25a0fc4SDave Ertman pf->num_rdma_msix); 3696940b61afSAnirudh Venkataramanan } 3697940b61afSAnirudh Venkataramanan } 3698940b61afSAnirudh Venkataramanan 3699940b61afSAnirudh Venkataramanan return v_actual; 3700940b61afSAnirudh Venkataramanan 3701940b61afSAnirudh Venkataramanan msix_err: 37024015d11eSBrett Creeley devm_kfree(dev, pf->msix_entries); 3703940b61afSAnirudh Venkataramanan goto exit_err; 3704940b61afSAnirudh Venkataramanan 3705152b978aSAnirudh Venkataramanan no_hw_vecs_left_err: 370619cce2c6SAnirudh Venkataramanan dev_err(dev, "not enough device MSI-X vectors. requested = %d, available = %d\n", 3707152b978aSAnirudh Venkataramanan needed, v_left); 3708152b978aSAnirudh Venkataramanan err = -ERANGE; 3709940b61afSAnirudh Venkataramanan exit_err: 3710d25a0fc4SDave Ertman pf->num_rdma_msix = 0; 3711940b61afSAnirudh Venkataramanan pf->num_lan_msix = 0; 3712940b61afSAnirudh Venkataramanan return err; 3713940b61afSAnirudh Venkataramanan } 3714940b61afSAnirudh Venkataramanan 3715940b61afSAnirudh Venkataramanan /** 3716940b61afSAnirudh Venkataramanan * ice_dis_msix - Disable MSI-X interrupt setup in OS 3717940b61afSAnirudh Venkataramanan * @pf: board private structure 3718940b61afSAnirudh Venkataramanan */ 3719940b61afSAnirudh Venkataramanan static void ice_dis_msix(struct ice_pf *pf) 3720940b61afSAnirudh Venkataramanan { 3721940b61afSAnirudh Venkataramanan pci_disable_msix(pf->pdev); 37224015d11eSBrett Creeley devm_kfree(ice_pf_to_dev(pf), pf->msix_entries); 3723940b61afSAnirudh Venkataramanan pf->msix_entries = NULL; 3724940b61afSAnirudh Venkataramanan } 3725940b61afSAnirudh Venkataramanan 3726940b61afSAnirudh Venkataramanan /** 3727eb0208ecSPreethi Banala * ice_clear_interrupt_scheme - Undo things done by ice_init_interrupt_scheme 3728eb0208ecSPreethi Banala * @pf: board private structure 3729eb0208ecSPreethi Banala */ 3730eb0208ecSPreethi Banala static void ice_clear_interrupt_scheme(struct ice_pf *pf) 3731eb0208ecSPreethi Banala { 3732eb0208ecSPreethi Banala ice_dis_msix(pf); 3733eb0208ecSPreethi Banala 3734cbe66bfeSBrett Creeley if (pf->irq_tracker) { 37354015d11eSBrett Creeley devm_kfree(ice_pf_to_dev(pf), pf->irq_tracker); 3736cbe66bfeSBrett Creeley pf->irq_tracker = NULL; 3737eb0208ecSPreethi Banala } 3738eb0208ecSPreethi Banala } 3739eb0208ecSPreethi Banala 3740eb0208ecSPreethi Banala /** 3741940b61afSAnirudh Venkataramanan * ice_init_interrupt_scheme - Determine proper interrupt scheme 3742940b61afSAnirudh Venkataramanan * @pf: board private structure to initialize 3743940b61afSAnirudh Venkataramanan */ 3744940b61afSAnirudh Venkataramanan static int ice_init_interrupt_scheme(struct ice_pf *pf) 3745940b61afSAnirudh Venkataramanan { 3746cbe66bfeSBrett Creeley int vectors; 3747940b61afSAnirudh Venkataramanan 3748940b61afSAnirudh Venkataramanan vectors = ice_ena_msix_range(pf); 3749940b61afSAnirudh Venkataramanan 3750940b61afSAnirudh Venkataramanan if (vectors < 0) 3751940b61afSAnirudh Venkataramanan return vectors; 3752940b61afSAnirudh Venkataramanan 3753940b61afSAnirudh Venkataramanan /* set up vector assignment tracking */ 3754e94c0df9SGustavo A. R. Silva pf->irq_tracker = devm_kzalloc(ice_pf_to_dev(pf), 3755e94c0df9SGustavo A. R. Silva struct_size(pf->irq_tracker, list, vectors), 3756e94c0df9SGustavo A. R. Silva GFP_KERNEL); 3757cbe66bfeSBrett Creeley if (!pf->irq_tracker) { 3758940b61afSAnirudh Venkataramanan ice_dis_msix(pf); 3759940b61afSAnirudh Venkataramanan return -ENOMEM; 3760940b61afSAnirudh Venkataramanan } 3761940b61afSAnirudh Venkataramanan 3762eb0208ecSPreethi Banala /* populate SW interrupts pool with number of OS granted IRQs. */ 376388865fc4SKarol Kolacinski pf->num_avail_sw_msix = (u16)vectors; 376488865fc4SKarol Kolacinski pf->irq_tracker->num_entries = (u16)vectors; 3765cbe66bfeSBrett Creeley pf->irq_tracker->end = pf->irq_tracker->num_entries; 3766940b61afSAnirudh Venkataramanan 3767940b61afSAnirudh Venkataramanan return 0; 3768940b61afSAnirudh Venkataramanan } 3769940b61afSAnirudh Venkataramanan 3770940b61afSAnirudh Venkataramanan /** 377131765519SAnirudh Venkataramanan * ice_is_wol_supported - check if WoL is supported 377231765519SAnirudh Venkataramanan * @hw: pointer to hardware info 3773769c500dSAkeem G Abodunrin * 3774769c500dSAkeem G Abodunrin * Check if WoL is supported based on the HW configuration. 3775769c500dSAkeem G Abodunrin * Returns true if NVM supports and enables WoL for this port, false otherwise 3776769c500dSAkeem G Abodunrin */ 377731765519SAnirudh Venkataramanan bool ice_is_wol_supported(struct ice_hw *hw) 3778769c500dSAkeem G Abodunrin { 3779769c500dSAkeem G Abodunrin u16 wol_ctrl; 3780769c500dSAkeem G Abodunrin 3781769c500dSAkeem G Abodunrin /* A bit set to 1 in the NVM Software Reserved Word 2 (WoL control 3782769c500dSAkeem G Abodunrin * word) indicates WoL is not supported on the corresponding PF ID. 3783769c500dSAkeem G Abodunrin */ 3784769c500dSAkeem G Abodunrin if (ice_read_sr_word(hw, ICE_SR_NVM_WOL_CFG, &wol_ctrl)) 3785769c500dSAkeem G Abodunrin return false; 3786769c500dSAkeem G Abodunrin 378731765519SAnirudh Venkataramanan return !(BIT(hw->port_info->lport) & wol_ctrl); 3788769c500dSAkeem G Abodunrin } 3789769c500dSAkeem G Abodunrin 3790769c500dSAkeem G Abodunrin /** 379187324e74SHenry Tieman * ice_vsi_recfg_qs - Change the number of queues on a VSI 379287324e74SHenry Tieman * @vsi: VSI being changed 379387324e74SHenry Tieman * @new_rx: new number of Rx queues 379487324e74SHenry Tieman * @new_tx: new number of Tx queues 379587324e74SHenry Tieman * 379687324e74SHenry Tieman * Only change the number of queues if new_tx, or new_rx is non-0. 379787324e74SHenry Tieman * 379887324e74SHenry Tieman * Returns 0 on success. 379987324e74SHenry Tieman */ 380087324e74SHenry Tieman int ice_vsi_recfg_qs(struct ice_vsi *vsi, int new_rx, int new_tx) 380187324e74SHenry Tieman { 380287324e74SHenry Tieman struct ice_pf *pf = vsi->back; 380387324e74SHenry Tieman int err = 0, timeout = 50; 380487324e74SHenry Tieman 380587324e74SHenry Tieman if (!new_rx && !new_tx) 380687324e74SHenry Tieman return -EINVAL; 380787324e74SHenry Tieman 38087e408e07SAnirudh Venkataramanan while (test_and_set_bit(ICE_CFG_BUSY, pf->state)) { 380987324e74SHenry Tieman timeout--; 381087324e74SHenry Tieman if (!timeout) 381187324e74SHenry Tieman return -EBUSY; 381287324e74SHenry Tieman usleep_range(1000, 2000); 381387324e74SHenry Tieman } 381487324e74SHenry Tieman 381587324e74SHenry Tieman if (new_tx) 381688865fc4SKarol Kolacinski vsi->req_txq = (u16)new_tx; 381787324e74SHenry Tieman if (new_rx) 381888865fc4SKarol Kolacinski vsi->req_rxq = (u16)new_rx; 381987324e74SHenry Tieman 382087324e74SHenry Tieman /* set for the next time the netdev is started */ 382187324e74SHenry Tieman if (!netif_running(vsi->netdev)) { 382287324e74SHenry Tieman ice_vsi_rebuild(vsi, false); 382387324e74SHenry Tieman dev_dbg(ice_pf_to_dev(pf), "Link is down, queue count change happens when link is brought up\n"); 382487324e74SHenry Tieman goto done; 382587324e74SHenry Tieman } 382687324e74SHenry Tieman 382787324e74SHenry Tieman ice_vsi_close(vsi); 382887324e74SHenry Tieman ice_vsi_rebuild(vsi, false); 382987324e74SHenry Tieman ice_pf_dcb_recfg(pf); 383087324e74SHenry Tieman ice_vsi_open(vsi); 383187324e74SHenry Tieman done: 38327e408e07SAnirudh Venkataramanan clear_bit(ICE_CFG_BUSY, pf->state); 383387324e74SHenry Tieman return err; 383487324e74SHenry Tieman } 383587324e74SHenry Tieman 383687324e74SHenry Tieman /** 3837cd1f56f4SBrett Creeley * ice_set_safe_mode_vlan_cfg - configure PF VSI to allow all VLANs in safe mode 3838cd1f56f4SBrett Creeley * @pf: PF to configure 3839cd1f56f4SBrett Creeley * 3840cd1f56f4SBrett Creeley * No VLAN offloads/filtering are advertised in safe mode so make sure the PF 3841cd1f56f4SBrett Creeley * VSI can still Tx/Rx VLAN tagged packets. 3842cd1f56f4SBrett Creeley */ 3843cd1f56f4SBrett Creeley static void ice_set_safe_mode_vlan_cfg(struct ice_pf *pf) 3844cd1f56f4SBrett Creeley { 3845cd1f56f4SBrett Creeley struct ice_vsi *vsi = ice_get_main_vsi(pf); 3846cd1f56f4SBrett Creeley struct ice_vsi_ctx *ctxt; 3847cd1f56f4SBrett Creeley enum ice_status status; 3848cd1f56f4SBrett Creeley struct ice_hw *hw; 3849cd1f56f4SBrett Creeley 3850cd1f56f4SBrett Creeley if (!vsi) 3851cd1f56f4SBrett Creeley return; 3852cd1f56f4SBrett Creeley 3853cd1f56f4SBrett Creeley ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL); 3854cd1f56f4SBrett Creeley if (!ctxt) 3855cd1f56f4SBrett Creeley return; 3856cd1f56f4SBrett Creeley 3857cd1f56f4SBrett Creeley hw = &pf->hw; 3858cd1f56f4SBrett Creeley ctxt->info = vsi->info; 3859cd1f56f4SBrett Creeley 3860cd1f56f4SBrett Creeley ctxt->info.valid_sections = 3861cd1f56f4SBrett Creeley cpu_to_le16(ICE_AQ_VSI_PROP_VLAN_VALID | 3862cd1f56f4SBrett Creeley ICE_AQ_VSI_PROP_SECURITY_VALID | 3863cd1f56f4SBrett Creeley ICE_AQ_VSI_PROP_SW_VALID); 3864cd1f56f4SBrett Creeley 3865cd1f56f4SBrett Creeley /* disable VLAN anti-spoof */ 3866cd1f56f4SBrett Creeley ctxt->info.sec_flags &= ~(ICE_AQ_VSI_SEC_TX_VLAN_PRUNE_ENA << 3867cd1f56f4SBrett Creeley ICE_AQ_VSI_SEC_TX_PRUNE_ENA_S); 3868cd1f56f4SBrett Creeley 3869cd1f56f4SBrett Creeley /* disable VLAN pruning and keep all other settings */ 3870cd1f56f4SBrett Creeley ctxt->info.sw_flags2 &= ~ICE_AQ_VSI_SW_FLAG_RX_VLAN_PRUNE_ENA; 3871cd1f56f4SBrett Creeley 3872cd1f56f4SBrett Creeley /* allow all VLANs on Tx and don't strip on Rx */ 3873cd1f56f4SBrett Creeley ctxt->info.vlan_flags = ICE_AQ_VSI_VLAN_MODE_ALL | 3874cd1f56f4SBrett Creeley ICE_AQ_VSI_VLAN_EMOD_NOTHING; 3875cd1f56f4SBrett Creeley 3876cd1f56f4SBrett Creeley status = ice_update_vsi(hw, vsi->idx, ctxt, NULL); 3877cd1f56f4SBrett Creeley if (status) { 3878cd1f56f4SBrett Creeley dev_err(ice_pf_to_dev(vsi->back), "Failed to update VSI for safe mode VLANs, err %s aq_err %s\n", 3879cd1f56f4SBrett Creeley ice_stat_str(status), 3880cd1f56f4SBrett Creeley ice_aq_str(hw->adminq.sq_last_status)); 3881cd1f56f4SBrett Creeley } else { 3882cd1f56f4SBrett Creeley vsi->info.sec_flags = ctxt->info.sec_flags; 3883cd1f56f4SBrett Creeley vsi->info.sw_flags2 = ctxt->info.sw_flags2; 3884cd1f56f4SBrett Creeley vsi->info.vlan_flags = ctxt->info.vlan_flags; 3885cd1f56f4SBrett Creeley } 3886cd1f56f4SBrett Creeley 3887cd1f56f4SBrett Creeley kfree(ctxt); 3888cd1f56f4SBrett Creeley } 3889cd1f56f4SBrett Creeley 3890cd1f56f4SBrett Creeley /** 3891462acf6aSTony Nguyen * ice_log_pkg_init - log result of DDP package load 3892462acf6aSTony Nguyen * @hw: pointer to hardware info 3893462acf6aSTony Nguyen * @status: status of package load 3894462acf6aSTony Nguyen */ 3895462acf6aSTony Nguyen static void 3896462acf6aSTony Nguyen ice_log_pkg_init(struct ice_hw *hw, enum ice_status *status) 3897462acf6aSTony Nguyen { 3898462acf6aSTony Nguyen struct ice_pf *pf = (struct ice_pf *)hw->back; 38994015d11eSBrett Creeley struct device *dev = ice_pf_to_dev(pf); 3900462acf6aSTony Nguyen 3901462acf6aSTony Nguyen switch (*status) { 3902462acf6aSTony Nguyen case ICE_SUCCESS: 3903462acf6aSTony Nguyen /* The package download AdminQ command returned success because 3904462acf6aSTony Nguyen * this download succeeded or ICE_ERR_AQ_NO_WORK since there is 3905462acf6aSTony Nguyen * already a package loaded on the device. 3906462acf6aSTony Nguyen */ 3907462acf6aSTony Nguyen if (hw->pkg_ver.major == hw->active_pkg_ver.major && 3908462acf6aSTony Nguyen hw->pkg_ver.minor == hw->active_pkg_ver.minor && 3909462acf6aSTony Nguyen hw->pkg_ver.update == hw->active_pkg_ver.update && 3910462acf6aSTony Nguyen hw->pkg_ver.draft == hw->active_pkg_ver.draft && 3911462acf6aSTony Nguyen !memcmp(hw->pkg_name, hw->active_pkg_name, 3912462acf6aSTony Nguyen sizeof(hw->pkg_name))) { 3913462acf6aSTony Nguyen if (hw->pkg_dwnld_status == ICE_AQ_RC_EEXIST) 391419cce2c6SAnirudh Venkataramanan dev_info(dev, "DDP package already present on device: %s version %d.%d.%d.%d\n", 3915462acf6aSTony Nguyen hw->active_pkg_name, 3916462acf6aSTony Nguyen hw->active_pkg_ver.major, 3917462acf6aSTony Nguyen hw->active_pkg_ver.minor, 3918462acf6aSTony Nguyen hw->active_pkg_ver.update, 3919462acf6aSTony Nguyen hw->active_pkg_ver.draft); 3920462acf6aSTony Nguyen else 392119cce2c6SAnirudh Venkataramanan dev_info(dev, "The DDP package was successfully loaded: %s version %d.%d.%d.%d\n", 3922462acf6aSTony Nguyen hw->active_pkg_name, 3923462acf6aSTony Nguyen hw->active_pkg_ver.major, 3924462acf6aSTony Nguyen hw->active_pkg_ver.minor, 3925462acf6aSTony Nguyen hw->active_pkg_ver.update, 3926462acf6aSTony Nguyen hw->active_pkg_ver.draft); 3927462acf6aSTony Nguyen } else if (hw->active_pkg_ver.major != ICE_PKG_SUPP_VER_MAJ || 3928462acf6aSTony Nguyen hw->active_pkg_ver.minor != ICE_PKG_SUPP_VER_MNR) { 392919cce2c6SAnirudh 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", 3930462acf6aSTony Nguyen hw->active_pkg_name, 3931462acf6aSTony Nguyen hw->active_pkg_ver.major, 3932462acf6aSTony Nguyen hw->active_pkg_ver.minor, 3933462acf6aSTony Nguyen ICE_PKG_SUPP_VER_MAJ, ICE_PKG_SUPP_VER_MNR); 3934462acf6aSTony Nguyen *status = ICE_ERR_NOT_SUPPORTED; 3935462acf6aSTony Nguyen } else if (hw->active_pkg_ver.major == ICE_PKG_SUPP_VER_MAJ && 3936462acf6aSTony Nguyen hw->active_pkg_ver.minor == ICE_PKG_SUPP_VER_MNR) { 393719cce2c6SAnirudh 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", 3938462acf6aSTony Nguyen hw->active_pkg_name, 3939462acf6aSTony Nguyen hw->active_pkg_ver.major, 3940462acf6aSTony Nguyen hw->active_pkg_ver.minor, 3941462acf6aSTony Nguyen hw->active_pkg_ver.update, 3942462acf6aSTony Nguyen hw->active_pkg_ver.draft, 3943462acf6aSTony Nguyen hw->pkg_name, 3944462acf6aSTony Nguyen hw->pkg_ver.major, 3945462acf6aSTony Nguyen hw->pkg_ver.minor, 3946462acf6aSTony Nguyen hw->pkg_ver.update, 3947462acf6aSTony Nguyen hw->pkg_ver.draft); 3948462acf6aSTony Nguyen } else { 394919cce2c6SAnirudh 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"); 3950462acf6aSTony Nguyen *status = ICE_ERR_NOT_SUPPORTED; 3951462acf6aSTony Nguyen } 3952462acf6aSTony Nguyen break; 3953b8272919SVictor Raj case ICE_ERR_FW_DDP_MISMATCH: 3954b8272919SVictor 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"); 3955b8272919SVictor Raj break; 3956462acf6aSTony Nguyen case ICE_ERR_BUF_TOO_SHORT: 3957462acf6aSTony Nguyen case ICE_ERR_CFG: 395819cce2c6SAnirudh Venkataramanan dev_err(dev, "The DDP package file is invalid. Entering Safe Mode.\n"); 3959462acf6aSTony Nguyen break; 3960462acf6aSTony Nguyen case ICE_ERR_NOT_SUPPORTED: 3961462acf6aSTony Nguyen /* Package File version not supported */ 3962462acf6aSTony Nguyen if (hw->pkg_ver.major > ICE_PKG_SUPP_VER_MAJ || 3963462acf6aSTony Nguyen (hw->pkg_ver.major == ICE_PKG_SUPP_VER_MAJ && 3964462acf6aSTony Nguyen hw->pkg_ver.minor > ICE_PKG_SUPP_VER_MNR)) 396519cce2c6SAnirudh Venkataramanan dev_err(dev, "The DDP package file version is higher than the driver supports. Please use an updated driver. Entering Safe Mode.\n"); 3966462acf6aSTony Nguyen else if (hw->pkg_ver.major < ICE_PKG_SUPP_VER_MAJ || 3967462acf6aSTony Nguyen (hw->pkg_ver.major == ICE_PKG_SUPP_VER_MAJ && 3968462acf6aSTony Nguyen hw->pkg_ver.minor < ICE_PKG_SUPP_VER_MNR)) 396919cce2c6SAnirudh 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", 3970462acf6aSTony Nguyen ICE_PKG_SUPP_VER_MAJ, ICE_PKG_SUPP_VER_MNR); 3971462acf6aSTony Nguyen break; 3972462acf6aSTony Nguyen case ICE_ERR_AQ_ERROR: 3973e000248eSBruce Allan switch (hw->pkg_dwnld_status) { 3974462acf6aSTony Nguyen case ICE_AQ_RC_ENOSEC: 3975462acf6aSTony Nguyen case ICE_AQ_RC_EBADSIG: 397619cce2c6SAnirudh 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"); 3977462acf6aSTony Nguyen return; 3978462acf6aSTony Nguyen case ICE_AQ_RC_ESVN: 397919cce2c6SAnirudh 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"); 3980462acf6aSTony Nguyen return; 3981462acf6aSTony Nguyen case ICE_AQ_RC_EBADMAN: 3982462acf6aSTony Nguyen case ICE_AQ_RC_EBADBUF: 398319cce2c6SAnirudh Venkataramanan dev_err(dev, "An error occurred on the device while loading the DDP package. The device will be reset.\n"); 39849918f2d2SAnirudh Venkataramanan /* poll for reset to complete */ 39859918f2d2SAnirudh Venkataramanan if (ice_check_reset(hw)) 39869918f2d2SAnirudh Venkataramanan dev_err(dev, "Error resetting device. Please reload the driver\n"); 3987462acf6aSTony Nguyen return; 3988462acf6aSTony Nguyen default: 3989462acf6aSTony Nguyen break; 3990462acf6aSTony Nguyen } 39914e83fc93SBruce Allan fallthrough; 3992462acf6aSTony Nguyen default: 399319cce2c6SAnirudh Venkataramanan dev_err(dev, "An unknown error (%d) occurred when loading the DDP package. Entering Safe Mode.\n", 3994462acf6aSTony Nguyen *status); 3995462acf6aSTony Nguyen break; 3996462acf6aSTony Nguyen } 3997462acf6aSTony Nguyen } 3998462acf6aSTony Nguyen 3999462acf6aSTony Nguyen /** 4000462acf6aSTony Nguyen * ice_load_pkg - load/reload the DDP Package file 4001462acf6aSTony Nguyen * @firmware: firmware structure when firmware requested or NULL for reload 4002462acf6aSTony Nguyen * @pf: pointer to the PF instance 4003462acf6aSTony Nguyen * 4004462acf6aSTony Nguyen * Called on probe and post CORER/GLOBR rebuild to load DDP Package and 4005462acf6aSTony Nguyen * initialize HW tables. 4006462acf6aSTony Nguyen */ 4007462acf6aSTony Nguyen static void 4008462acf6aSTony Nguyen ice_load_pkg(const struct firmware *firmware, struct ice_pf *pf) 4009462acf6aSTony Nguyen { 4010462acf6aSTony Nguyen enum ice_status status = ICE_ERR_PARAM; 40114015d11eSBrett Creeley struct device *dev = ice_pf_to_dev(pf); 4012462acf6aSTony Nguyen struct ice_hw *hw = &pf->hw; 4013462acf6aSTony Nguyen 4014462acf6aSTony Nguyen /* Load DDP Package */ 4015462acf6aSTony Nguyen if (firmware && !hw->pkg_copy) { 4016462acf6aSTony Nguyen status = ice_copy_and_init_pkg(hw, firmware->data, 4017462acf6aSTony Nguyen firmware->size); 4018462acf6aSTony Nguyen ice_log_pkg_init(hw, &status); 4019462acf6aSTony Nguyen } else if (!firmware && hw->pkg_copy) { 4020462acf6aSTony Nguyen /* Reload package during rebuild after CORER/GLOBR reset */ 4021462acf6aSTony Nguyen status = ice_init_pkg(hw, hw->pkg_copy, hw->pkg_size); 4022462acf6aSTony Nguyen ice_log_pkg_init(hw, &status); 4023462acf6aSTony Nguyen } else { 402419cce2c6SAnirudh Venkataramanan dev_err(dev, "The DDP package file failed to load. Entering Safe Mode.\n"); 4025462acf6aSTony Nguyen } 4026462acf6aSTony Nguyen 4027462acf6aSTony Nguyen if (status) { 4028462acf6aSTony Nguyen /* Safe Mode */ 4029462acf6aSTony Nguyen clear_bit(ICE_FLAG_ADV_FEATURES, pf->flags); 4030462acf6aSTony Nguyen return; 4031462acf6aSTony Nguyen } 4032462acf6aSTony Nguyen 4033462acf6aSTony Nguyen /* Successful download package is the precondition for advanced 4034462acf6aSTony Nguyen * features, hence setting the ICE_FLAG_ADV_FEATURES flag 4035462acf6aSTony Nguyen */ 4036462acf6aSTony Nguyen set_bit(ICE_FLAG_ADV_FEATURES, pf->flags); 4037462acf6aSTony Nguyen } 4038462acf6aSTony Nguyen 4039462acf6aSTony Nguyen /** 4040c585ea42SBrett Creeley * ice_verify_cacheline_size - verify driver's assumption of 64 Byte cache lines 4041c585ea42SBrett Creeley * @pf: pointer to the PF structure 4042c585ea42SBrett Creeley * 4043c585ea42SBrett Creeley * There is no error returned here because the driver should be able to handle 4044c585ea42SBrett Creeley * 128 Byte cache lines, so we only print a warning in case issues are seen, 4045c585ea42SBrett Creeley * specifically with Tx. 4046c585ea42SBrett Creeley */ 4047c585ea42SBrett Creeley static void ice_verify_cacheline_size(struct ice_pf *pf) 4048c585ea42SBrett Creeley { 4049c585ea42SBrett Creeley if (rd32(&pf->hw, GLPCI_CNF2) & GLPCI_CNF2_CACHELINE_SIZE_M) 405019cce2c6SAnirudh Venkataramanan dev_warn(ice_pf_to_dev(pf), "%d Byte cache line assumption is invalid, driver may have Tx timeouts!\n", 4051c585ea42SBrett Creeley ICE_CACHE_LINE_BYTES); 4052c585ea42SBrett Creeley } 4053c585ea42SBrett Creeley 4054c585ea42SBrett Creeley /** 4055e3710a01SPaul M Stillwell Jr * ice_send_version - update firmware with driver version 4056e3710a01SPaul M Stillwell Jr * @pf: PF struct 4057e3710a01SPaul M Stillwell Jr * 4058e3710a01SPaul M Stillwell Jr * Returns ICE_SUCCESS on success, else error code 4059e3710a01SPaul M Stillwell Jr */ 4060e3710a01SPaul M Stillwell Jr static enum ice_status ice_send_version(struct ice_pf *pf) 4061e3710a01SPaul M Stillwell Jr { 4062e3710a01SPaul M Stillwell Jr struct ice_driver_ver dv; 4063e3710a01SPaul M Stillwell Jr 406434a2a3b8SJeff Kirsher dv.major_ver = 0xff; 406534a2a3b8SJeff Kirsher dv.minor_ver = 0xff; 406634a2a3b8SJeff Kirsher dv.build_ver = 0xff; 4067e3710a01SPaul M Stillwell Jr dv.subbuild_ver = 0; 406834a2a3b8SJeff Kirsher strscpy((char *)dv.driver_string, UTS_RELEASE, 4069e3710a01SPaul M Stillwell Jr sizeof(dv.driver_string)); 4070e3710a01SPaul M Stillwell Jr return ice_aq_send_driver_ver(&pf->hw, &dv, NULL); 4071e3710a01SPaul M Stillwell Jr } 4072e3710a01SPaul M Stillwell Jr 4073e3710a01SPaul M Stillwell Jr /** 4074148beb61SHenry Tieman * ice_init_fdir - Initialize flow director VSI and configuration 4075148beb61SHenry Tieman * @pf: pointer to the PF instance 4076148beb61SHenry Tieman * 4077148beb61SHenry Tieman * returns 0 on success, negative on error 4078148beb61SHenry Tieman */ 4079148beb61SHenry Tieman static int ice_init_fdir(struct ice_pf *pf) 4080148beb61SHenry Tieman { 4081148beb61SHenry Tieman struct device *dev = ice_pf_to_dev(pf); 4082148beb61SHenry Tieman struct ice_vsi *ctrl_vsi; 4083148beb61SHenry Tieman int err; 4084148beb61SHenry Tieman 4085148beb61SHenry Tieman /* Side Band Flow Director needs to have a control VSI. 4086148beb61SHenry Tieman * Allocate it and store it in the PF. 4087148beb61SHenry Tieman */ 4088148beb61SHenry Tieman ctrl_vsi = ice_ctrl_vsi_setup(pf, pf->hw.port_info); 4089148beb61SHenry Tieman if (!ctrl_vsi) { 4090148beb61SHenry Tieman dev_dbg(dev, "could not create control VSI\n"); 4091148beb61SHenry Tieman return -ENOMEM; 4092148beb61SHenry Tieman } 4093148beb61SHenry Tieman 4094148beb61SHenry Tieman err = ice_vsi_open_ctrl(ctrl_vsi); 4095148beb61SHenry Tieman if (err) { 4096148beb61SHenry Tieman dev_dbg(dev, "could not open control VSI\n"); 4097148beb61SHenry Tieman goto err_vsi_open; 4098148beb61SHenry Tieman } 4099148beb61SHenry Tieman 4100148beb61SHenry Tieman mutex_init(&pf->hw.fdir_fltr_lock); 4101148beb61SHenry Tieman 4102148beb61SHenry Tieman err = ice_fdir_create_dflt_rules(pf); 4103148beb61SHenry Tieman if (err) 4104148beb61SHenry Tieman goto err_fdir_rule; 4105148beb61SHenry Tieman 4106148beb61SHenry Tieman return 0; 4107148beb61SHenry Tieman 4108148beb61SHenry Tieman err_fdir_rule: 4109148beb61SHenry Tieman ice_fdir_release_flows(&pf->hw); 4110148beb61SHenry Tieman ice_vsi_close(ctrl_vsi); 4111148beb61SHenry Tieman err_vsi_open: 4112148beb61SHenry Tieman ice_vsi_release(ctrl_vsi); 4113148beb61SHenry Tieman if (pf->ctrl_vsi_idx != ICE_NO_VSI) { 4114148beb61SHenry Tieman pf->vsi[pf->ctrl_vsi_idx] = NULL; 4115148beb61SHenry Tieman pf->ctrl_vsi_idx = ICE_NO_VSI; 4116148beb61SHenry Tieman } 4117148beb61SHenry Tieman return err; 4118148beb61SHenry Tieman } 4119148beb61SHenry Tieman 4120148beb61SHenry Tieman /** 4121462acf6aSTony Nguyen * ice_get_opt_fw_name - return optional firmware file name or NULL 4122462acf6aSTony Nguyen * @pf: pointer to the PF instance 4123462acf6aSTony Nguyen */ 4124462acf6aSTony Nguyen static char *ice_get_opt_fw_name(struct ice_pf *pf) 4125462acf6aSTony Nguyen { 4126462acf6aSTony Nguyen /* Optional firmware name same as default with additional dash 4127462acf6aSTony Nguyen * followed by a EUI-64 identifier (PCIe Device Serial Number) 4128462acf6aSTony Nguyen */ 4129462acf6aSTony Nguyen struct pci_dev *pdev = pf->pdev; 4130ceb2f007SJacob Keller char *opt_fw_filename; 4131ceb2f007SJacob Keller u64 dsn; 4132462acf6aSTony Nguyen 4133462acf6aSTony Nguyen /* Determine the name of the optional file using the DSN (two 4134462acf6aSTony Nguyen * dwords following the start of the DSN Capability). 4135462acf6aSTony Nguyen */ 4136ceb2f007SJacob Keller dsn = pci_get_dsn(pdev); 4137ceb2f007SJacob Keller if (!dsn) 4138ceb2f007SJacob Keller return NULL; 4139ceb2f007SJacob Keller 4140462acf6aSTony Nguyen opt_fw_filename = kzalloc(NAME_MAX, GFP_KERNEL); 4141462acf6aSTony Nguyen if (!opt_fw_filename) 4142462acf6aSTony Nguyen return NULL; 4143462acf6aSTony Nguyen 41441a9c561aSPaul M Stillwell Jr snprintf(opt_fw_filename, NAME_MAX, "%sice-%016llx.pkg", 4145ceb2f007SJacob Keller ICE_DDP_PKG_PATH, dsn); 4146462acf6aSTony Nguyen 4147462acf6aSTony Nguyen return opt_fw_filename; 4148462acf6aSTony Nguyen } 4149462acf6aSTony Nguyen 4150462acf6aSTony Nguyen /** 4151462acf6aSTony Nguyen * ice_request_fw - Device initialization routine 4152462acf6aSTony Nguyen * @pf: pointer to the PF instance 4153462acf6aSTony Nguyen */ 4154462acf6aSTony Nguyen static void ice_request_fw(struct ice_pf *pf) 4155462acf6aSTony Nguyen { 4156462acf6aSTony Nguyen char *opt_fw_filename = ice_get_opt_fw_name(pf); 4157462acf6aSTony Nguyen const struct firmware *firmware = NULL; 41584015d11eSBrett Creeley struct device *dev = ice_pf_to_dev(pf); 4159462acf6aSTony Nguyen int err = 0; 4160462acf6aSTony Nguyen 4161462acf6aSTony Nguyen /* optional device-specific DDP (if present) overrides the default DDP 4162462acf6aSTony Nguyen * package file. kernel logs a debug message if the file doesn't exist, 4163462acf6aSTony Nguyen * and warning messages for other errors. 4164462acf6aSTony Nguyen */ 4165462acf6aSTony Nguyen if (opt_fw_filename) { 4166462acf6aSTony Nguyen err = firmware_request_nowarn(&firmware, opt_fw_filename, dev); 4167462acf6aSTony Nguyen if (err) { 4168462acf6aSTony Nguyen kfree(opt_fw_filename); 4169462acf6aSTony Nguyen goto dflt_pkg_load; 4170462acf6aSTony Nguyen } 4171462acf6aSTony Nguyen 4172462acf6aSTony Nguyen /* request for firmware was successful. Download to device */ 4173462acf6aSTony Nguyen ice_load_pkg(firmware, pf); 4174462acf6aSTony Nguyen kfree(opt_fw_filename); 4175462acf6aSTony Nguyen release_firmware(firmware); 4176462acf6aSTony Nguyen return; 4177462acf6aSTony Nguyen } 4178462acf6aSTony Nguyen 4179462acf6aSTony Nguyen dflt_pkg_load: 4180462acf6aSTony Nguyen err = request_firmware(&firmware, ICE_DDP_PKG_FILE, dev); 4181462acf6aSTony Nguyen if (err) { 418219cce2c6SAnirudh Venkataramanan dev_err(dev, "The DDP package file was not found or could not be read. Entering Safe Mode\n"); 4183462acf6aSTony Nguyen return; 4184462acf6aSTony Nguyen } 4185462acf6aSTony Nguyen 4186462acf6aSTony Nguyen /* request for firmware was successful. Download to device */ 4187462acf6aSTony Nguyen ice_load_pkg(firmware, pf); 4188462acf6aSTony Nguyen release_firmware(firmware); 4189462acf6aSTony Nguyen } 4190462acf6aSTony Nguyen 4191462acf6aSTony Nguyen /** 4192769c500dSAkeem G Abodunrin * ice_print_wake_reason - show the wake up cause in the log 4193769c500dSAkeem G Abodunrin * @pf: pointer to the PF struct 4194769c500dSAkeem G Abodunrin */ 4195769c500dSAkeem G Abodunrin static void ice_print_wake_reason(struct ice_pf *pf) 4196769c500dSAkeem G Abodunrin { 4197769c500dSAkeem G Abodunrin u32 wus = pf->wakeup_reason; 4198769c500dSAkeem G Abodunrin const char *wake_str; 4199769c500dSAkeem G Abodunrin 4200769c500dSAkeem G Abodunrin /* if no wake event, nothing to print */ 4201769c500dSAkeem G Abodunrin if (!wus) 4202769c500dSAkeem G Abodunrin return; 4203769c500dSAkeem G Abodunrin 4204769c500dSAkeem G Abodunrin if (wus & PFPM_WUS_LNKC_M) 4205769c500dSAkeem G Abodunrin wake_str = "Link\n"; 4206769c500dSAkeem G Abodunrin else if (wus & PFPM_WUS_MAG_M) 4207769c500dSAkeem G Abodunrin wake_str = "Magic Packet\n"; 4208769c500dSAkeem G Abodunrin else if (wus & PFPM_WUS_MNG_M) 4209769c500dSAkeem G Abodunrin wake_str = "Management\n"; 4210769c500dSAkeem G Abodunrin else if (wus & PFPM_WUS_FW_RST_WK_M) 4211769c500dSAkeem G Abodunrin wake_str = "Firmware Reset\n"; 4212769c500dSAkeem G Abodunrin else 4213769c500dSAkeem G Abodunrin wake_str = "Unknown\n"; 4214769c500dSAkeem G Abodunrin 4215769c500dSAkeem G Abodunrin dev_info(ice_pf_to_dev(pf), "Wake reason: %s", wake_str); 4216769c500dSAkeem G Abodunrin } 4217769c500dSAkeem G Abodunrin 4218769c500dSAkeem G Abodunrin /** 42191e23f076SAnirudh Venkataramanan * ice_register_netdev - register netdev and devlink port 42201e23f076SAnirudh Venkataramanan * @pf: pointer to the PF struct 42211e23f076SAnirudh Venkataramanan */ 42221e23f076SAnirudh Venkataramanan static int ice_register_netdev(struct ice_pf *pf) 42231e23f076SAnirudh Venkataramanan { 42241e23f076SAnirudh Venkataramanan struct ice_vsi *vsi; 42251e23f076SAnirudh Venkataramanan int err = 0; 42261e23f076SAnirudh Venkataramanan 42271e23f076SAnirudh Venkataramanan vsi = ice_get_main_vsi(pf); 42281e23f076SAnirudh Venkataramanan if (!vsi || !vsi->netdev) 42291e23f076SAnirudh Venkataramanan return -EIO; 42301e23f076SAnirudh Venkataramanan 42311e23f076SAnirudh Venkataramanan err = register_netdev(vsi->netdev); 42321e23f076SAnirudh Venkataramanan if (err) 42331e23f076SAnirudh Venkataramanan goto err_register_netdev; 42341e23f076SAnirudh Venkataramanan 4235a476d72aSAnirudh Venkataramanan set_bit(ICE_VSI_NETDEV_REGISTERED, vsi->state); 42361e23f076SAnirudh Venkataramanan netif_carrier_off(vsi->netdev); 42371e23f076SAnirudh Venkataramanan netif_tx_stop_all_queues(vsi->netdev); 42382ae0aa47SWojciech Drewek err = ice_devlink_create_pf_port(pf); 42391e23f076SAnirudh Venkataramanan if (err) 42401e23f076SAnirudh Venkataramanan goto err_devlink_create; 42411e23f076SAnirudh Venkataramanan 42422ae0aa47SWojciech Drewek devlink_port_type_eth_set(&pf->devlink_port, vsi->netdev); 42431e23f076SAnirudh Venkataramanan 42441e23f076SAnirudh Venkataramanan return 0; 42451e23f076SAnirudh Venkataramanan err_devlink_create: 42461e23f076SAnirudh Venkataramanan unregister_netdev(vsi->netdev); 4247a476d72aSAnirudh Venkataramanan clear_bit(ICE_VSI_NETDEV_REGISTERED, vsi->state); 42481e23f076SAnirudh Venkataramanan err_register_netdev: 42491e23f076SAnirudh Venkataramanan free_netdev(vsi->netdev); 42501e23f076SAnirudh Venkataramanan vsi->netdev = NULL; 4251a476d72aSAnirudh Venkataramanan clear_bit(ICE_VSI_NETDEV_ALLOCD, vsi->state); 42521e23f076SAnirudh Venkataramanan return err; 42531e23f076SAnirudh Venkataramanan } 42541e23f076SAnirudh Venkataramanan 42551e23f076SAnirudh Venkataramanan /** 4256837f08fdSAnirudh Venkataramanan * ice_probe - Device initialization routine 4257837f08fdSAnirudh Venkataramanan * @pdev: PCI device information struct 4258837f08fdSAnirudh Venkataramanan * @ent: entry in ice_pci_tbl 4259837f08fdSAnirudh Venkataramanan * 4260837f08fdSAnirudh Venkataramanan * Returns 0 on success, negative on failure 4261837f08fdSAnirudh Venkataramanan */ 4262c8b7abddSBruce Allan static int 4263c8b7abddSBruce Allan ice_probe(struct pci_dev *pdev, const struct pci_device_id __always_unused *ent) 4264837f08fdSAnirudh Venkataramanan { 426577ed84f4SBruce Allan struct device *dev = &pdev->dev; 4266837f08fdSAnirudh Venkataramanan struct ice_pf *pf; 4267837f08fdSAnirudh Venkataramanan struct ice_hw *hw; 4268b20e6c17SJakub Kicinski int i, err; 4269837f08fdSAnirudh Venkataramanan 427050ac7479SAnirudh Venkataramanan if (pdev->is_virtfn) { 427150ac7479SAnirudh Venkataramanan dev_err(dev, "can't probe a virtual function\n"); 427250ac7479SAnirudh Venkataramanan return -EINVAL; 427350ac7479SAnirudh Venkataramanan } 427450ac7479SAnirudh Venkataramanan 42754ee656bbSTony Nguyen /* this driver uses devres, see 42764ee656bbSTony Nguyen * Documentation/driver-api/driver-model/devres.rst 42774ee656bbSTony Nguyen */ 4278837f08fdSAnirudh Venkataramanan err = pcim_enable_device(pdev); 4279837f08fdSAnirudh Venkataramanan if (err) 4280837f08fdSAnirudh Venkataramanan return err; 4281837f08fdSAnirudh Venkataramanan 428280ad6ddeSJesse Brandeburg err = pcim_iomap_regions(pdev, BIT(ICE_BAR0), dev_driver_string(dev)); 4283837f08fdSAnirudh Venkataramanan if (err) { 428477ed84f4SBruce Allan dev_err(dev, "BAR0 I/O map error %d\n", err); 4285837f08fdSAnirudh Venkataramanan return err; 4286837f08fdSAnirudh Venkataramanan } 4287837f08fdSAnirudh Venkataramanan 42881adf7eadSJacob Keller pf = ice_allocate_pf(dev); 4289837f08fdSAnirudh Venkataramanan if (!pf) 4290837f08fdSAnirudh Venkataramanan return -ENOMEM; 4291837f08fdSAnirudh Venkataramanan 42922f2da36eSAnirudh Venkataramanan /* set up for high or low DMA */ 429377ed84f4SBruce Allan err = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(64)); 4294837f08fdSAnirudh Venkataramanan if (err) 429577ed84f4SBruce Allan err = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(32)); 4296837f08fdSAnirudh Venkataramanan if (err) { 429777ed84f4SBruce Allan dev_err(dev, "DMA configuration failed: 0x%x\n", err); 4298837f08fdSAnirudh Venkataramanan return err; 4299837f08fdSAnirudh Venkataramanan } 4300837f08fdSAnirudh Venkataramanan 4301837f08fdSAnirudh Venkataramanan pci_enable_pcie_error_reporting(pdev); 4302837f08fdSAnirudh Venkataramanan pci_set_master(pdev); 4303837f08fdSAnirudh Venkataramanan 4304837f08fdSAnirudh Venkataramanan pf->pdev = pdev; 4305837f08fdSAnirudh Venkataramanan pci_set_drvdata(pdev, pf); 43067e408e07SAnirudh Venkataramanan set_bit(ICE_DOWN, pf->state); 43078d81fa55SAkeem G Abodunrin /* Disable service task until DOWN bit is cleared */ 43087e408e07SAnirudh Venkataramanan set_bit(ICE_SERVICE_DIS, pf->state); 4309837f08fdSAnirudh Venkataramanan 4310837f08fdSAnirudh Venkataramanan hw = &pf->hw; 4311837f08fdSAnirudh Venkataramanan hw->hw_addr = pcim_iomap_table(pdev)[ICE_BAR0]; 43124e56802eSMichal Swiatkowski pci_save_state(pdev); 43134e56802eSMichal Swiatkowski 4314837f08fdSAnirudh Venkataramanan hw->back = pf; 4315837f08fdSAnirudh Venkataramanan hw->vendor_id = pdev->vendor; 4316837f08fdSAnirudh Venkataramanan hw->device_id = pdev->device; 4317837f08fdSAnirudh Venkataramanan pci_read_config_byte(pdev, PCI_REVISION_ID, &hw->revision_id); 4318837f08fdSAnirudh Venkataramanan hw->subsystem_vendor_id = pdev->subsystem_vendor; 4319837f08fdSAnirudh Venkataramanan hw->subsystem_device_id = pdev->subsystem_device; 4320837f08fdSAnirudh Venkataramanan hw->bus.device = PCI_SLOT(pdev->devfn); 4321837f08fdSAnirudh Venkataramanan hw->bus.func = PCI_FUNC(pdev->devfn); 4322f31e4b6fSAnirudh Venkataramanan ice_set_ctrlq_len(hw); 4323f31e4b6fSAnirudh Venkataramanan 4324837f08fdSAnirudh Venkataramanan pf->msg_enable = netif_msg_init(debug, ICE_DFLT_NETIF_M); 4325837f08fdSAnirudh Venkataramanan 43267ec59eeaSAnirudh Venkataramanan #ifndef CONFIG_DYNAMIC_DEBUG 43277ec59eeaSAnirudh Venkataramanan if (debug < -1) 43287ec59eeaSAnirudh Venkataramanan hw->debug_mask = debug; 43297ec59eeaSAnirudh Venkataramanan #endif 43307ec59eeaSAnirudh Venkataramanan 4331f31e4b6fSAnirudh Venkataramanan err = ice_init_hw(hw); 4332f31e4b6fSAnirudh Venkataramanan if (err) { 433377ed84f4SBruce Allan dev_err(dev, "ice_init_hw failed: %d\n", err); 4334f31e4b6fSAnirudh Venkataramanan err = -EIO; 4335f31e4b6fSAnirudh Venkataramanan goto err_exit_unroll; 4336f31e4b6fSAnirudh Venkataramanan } 4337f31e4b6fSAnirudh Venkataramanan 433840b24760SAnirudh Venkataramanan ice_init_feature_support(pf); 433940b24760SAnirudh Venkataramanan 4340462acf6aSTony Nguyen ice_request_fw(pf); 4341462acf6aSTony Nguyen 4342462acf6aSTony Nguyen /* if ice_request_fw fails, ICE_FLAG_ADV_FEATURES bit won't be 4343462acf6aSTony Nguyen * set in pf->state, which will cause ice_is_safe_mode to return 4344462acf6aSTony Nguyen * true 4345462acf6aSTony Nguyen */ 4346462acf6aSTony Nguyen if (ice_is_safe_mode(pf)) { 434719cce2c6SAnirudh Venkataramanan dev_err(dev, "Package download failed. Advanced features disabled - Device now in Safe Mode\n"); 4348462acf6aSTony Nguyen /* we already got function/device capabilities but these don't 4349462acf6aSTony Nguyen * reflect what the driver needs to do in safe mode. Instead of 4350462acf6aSTony Nguyen * adding conditional logic everywhere to ignore these 4351462acf6aSTony Nguyen * device/function capabilities, override them. 4352462acf6aSTony Nguyen */ 4353462acf6aSTony Nguyen ice_set_safe_mode_caps(hw); 4354462acf6aSTony Nguyen } 4355462acf6aSTony Nguyen 435678b5713aSAnirudh Venkataramanan err = ice_init_pf(pf); 435778b5713aSAnirudh Venkataramanan if (err) { 435878b5713aSAnirudh Venkataramanan dev_err(dev, "ice_init_pf failed: %d\n", err); 435978b5713aSAnirudh Venkataramanan goto err_init_pf_unroll; 436078b5713aSAnirudh Venkataramanan } 4361940b61afSAnirudh Venkataramanan 4362dce730f1SJacob Keller ice_devlink_init_regions(pf); 4363dce730f1SJacob Keller 4364b20e6c17SJakub Kicinski pf->hw.udp_tunnel_nic.set_port = ice_udp_tunnel_set_port; 4365b20e6c17SJakub Kicinski pf->hw.udp_tunnel_nic.unset_port = ice_udp_tunnel_unset_port; 4366b20e6c17SJakub Kicinski pf->hw.udp_tunnel_nic.flags = UDP_TUNNEL_NIC_INFO_MAY_SLEEP; 4367b20e6c17SJakub Kicinski pf->hw.udp_tunnel_nic.shared = &pf->hw.udp_tunnel_shared; 4368b20e6c17SJakub Kicinski i = 0; 4369b20e6c17SJakub Kicinski if (pf->hw.tnl.valid_count[TNL_VXLAN]) { 4370b20e6c17SJakub Kicinski pf->hw.udp_tunnel_nic.tables[i].n_entries = 4371b20e6c17SJakub Kicinski pf->hw.tnl.valid_count[TNL_VXLAN]; 4372b20e6c17SJakub Kicinski pf->hw.udp_tunnel_nic.tables[i].tunnel_types = 4373b20e6c17SJakub Kicinski UDP_TUNNEL_TYPE_VXLAN; 4374b20e6c17SJakub Kicinski i++; 4375b20e6c17SJakub Kicinski } 4376b20e6c17SJakub Kicinski if (pf->hw.tnl.valid_count[TNL_GENEVE]) { 4377b20e6c17SJakub Kicinski pf->hw.udp_tunnel_nic.tables[i].n_entries = 4378b20e6c17SJakub Kicinski pf->hw.tnl.valid_count[TNL_GENEVE]; 4379b20e6c17SJakub Kicinski pf->hw.udp_tunnel_nic.tables[i].tunnel_types = 4380b20e6c17SJakub Kicinski UDP_TUNNEL_TYPE_GENEVE; 4381b20e6c17SJakub Kicinski i++; 4382b20e6c17SJakub Kicinski } 4383b20e6c17SJakub Kicinski 4384995c90f2SAnirudh Venkataramanan pf->num_alloc_vsi = hw->func_caps.guar_num_vsi; 4385940b61afSAnirudh Venkataramanan if (!pf->num_alloc_vsi) { 4386940b61afSAnirudh Venkataramanan err = -EIO; 4387940b61afSAnirudh Venkataramanan goto err_init_pf_unroll; 4388940b61afSAnirudh Venkataramanan } 4389b20e6c17SJakub Kicinski if (pf->num_alloc_vsi > UDP_TUNNEL_NIC_MAX_SHARING_DEVICES) { 4390b20e6c17SJakub Kicinski dev_warn(&pf->pdev->dev, 4391b20e6c17SJakub Kicinski "limiting the VSI count due to UDP tunnel limitation %d > %d\n", 4392b20e6c17SJakub Kicinski pf->num_alloc_vsi, UDP_TUNNEL_NIC_MAX_SHARING_DEVICES); 4393b20e6c17SJakub Kicinski pf->num_alloc_vsi = UDP_TUNNEL_NIC_MAX_SHARING_DEVICES; 4394b20e6c17SJakub Kicinski } 4395940b61afSAnirudh Venkataramanan 439677ed84f4SBruce Allan pf->vsi = devm_kcalloc(dev, pf->num_alloc_vsi, sizeof(*pf->vsi), 439777ed84f4SBruce Allan GFP_KERNEL); 4398940b61afSAnirudh Venkataramanan if (!pf->vsi) { 4399940b61afSAnirudh Venkataramanan err = -ENOMEM; 4400940b61afSAnirudh Venkataramanan goto err_init_pf_unroll; 4401940b61afSAnirudh Venkataramanan } 4402940b61afSAnirudh Venkataramanan 4403940b61afSAnirudh Venkataramanan err = ice_init_interrupt_scheme(pf); 4404940b61afSAnirudh Venkataramanan if (err) { 440577ed84f4SBruce Allan dev_err(dev, "ice_init_interrupt_scheme failed: %d\n", err); 4406940b61afSAnirudh Venkataramanan err = -EIO; 4407bc3a0241SJacob Keller goto err_init_vsi_unroll; 4408940b61afSAnirudh Venkataramanan } 4409940b61afSAnirudh Venkataramanan 4410940b61afSAnirudh Venkataramanan /* In case of MSIX we are going to setup the misc vector right here 4411940b61afSAnirudh Venkataramanan * to handle admin queue events etc. In case of legacy and MSI 4412940b61afSAnirudh Venkataramanan * the misc functionality and queue processing is combined in 4413940b61afSAnirudh Venkataramanan * the same vector and that gets setup at open. 4414940b61afSAnirudh Venkataramanan */ 4415940b61afSAnirudh Venkataramanan err = ice_req_irq_msix_misc(pf); 4416940b61afSAnirudh Venkataramanan if (err) { 441777ed84f4SBruce Allan dev_err(dev, "setup of misc vector failed: %d\n", err); 4418940b61afSAnirudh Venkataramanan goto err_init_interrupt_unroll; 4419940b61afSAnirudh Venkataramanan } 4420940b61afSAnirudh Venkataramanan 4421940b61afSAnirudh Venkataramanan /* create switch struct for the switch element created by FW on boot */ 442277ed84f4SBruce Allan pf->first_sw = devm_kzalloc(dev, sizeof(*pf->first_sw), GFP_KERNEL); 4423940b61afSAnirudh Venkataramanan if (!pf->first_sw) { 4424940b61afSAnirudh Venkataramanan err = -ENOMEM; 4425940b61afSAnirudh Venkataramanan goto err_msix_misc_unroll; 4426940b61afSAnirudh Venkataramanan } 4427940b61afSAnirudh Venkataramanan 4428b1edc14aSMd Fahad Iqbal Polash if (hw->evb_veb) 4429940b61afSAnirudh Venkataramanan pf->first_sw->bridge_mode = BRIDGE_MODE_VEB; 4430b1edc14aSMd Fahad Iqbal Polash else 4431b1edc14aSMd Fahad Iqbal Polash pf->first_sw->bridge_mode = BRIDGE_MODE_VEPA; 4432b1edc14aSMd Fahad Iqbal Polash 4433940b61afSAnirudh Venkataramanan pf->first_sw->pf = pf; 4434940b61afSAnirudh Venkataramanan 4435940b61afSAnirudh Venkataramanan /* record the sw_id available for later use */ 4436940b61afSAnirudh Venkataramanan pf->first_sw->sw_id = hw->port_info->sw_id; 4437940b61afSAnirudh Venkataramanan 44383a858ba3SAnirudh Venkataramanan err = ice_setup_pf_sw(pf); 44393a858ba3SAnirudh Venkataramanan if (err) { 44402f2da36eSAnirudh Venkataramanan dev_err(dev, "probe failed due to setup PF switch: %d\n", err); 44413a858ba3SAnirudh Venkataramanan goto err_alloc_sw_unroll; 44423a858ba3SAnirudh Venkataramanan } 44439daf8208SAnirudh Venkataramanan 44447e408e07SAnirudh Venkataramanan clear_bit(ICE_SERVICE_DIS, pf->state); 44459daf8208SAnirudh Venkataramanan 4446e3710a01SPaul M Stillwell Jr /* tell the firmware we are up */ 4447e3710a01SPaul M Stillwell Jr err = ice_send_version(pf); 4448e3710a01SPaul M Stillwell Jr if (err) { 444919cce2c6SAnirudh Venkataramanan dev_err(dev, "probe failed sending driver version %s. error: %d\n", 445034a2a3b8SJeff Kirsher UTS_RELEASE, err); 445178116e97SMarcin Szycik goto err_send_version_unroll; 4452e3710a01SPaul M Stillwell Jr } 4453e3710a01SPaul M Stillwell Jr 44549daf8208SAnirudh Venkataramanan /* since everything is good, start the service timer */ 44559daf8208SAnirudh Venkataramanan mod_timer(&pf->serv_tmr, round_jiffies(jiffies + pf->serv_tmr_period)); 44569daf8208SAnirudh Venkataramanan 4457250c3b3eSBrett Creeley err = ice_init_link_events(pf->hw.port_info); 4458250c3b3eSBrett Creeley if (err) { 4459250c3b3eSBrett Creeley dev_err(dev, "ice_init_link_events failed: %d\n", err); 446078116e97SMarcin Szycik goto err_send_version_unroll; 4461250c3b3eSBrett Creeley } 4462250c3b3eSBrett Creeley 446308771bceSAnirudh Venkataramanan /* not a fatal error if this fails */ 44641a3571b5SPaul Greenwalt err = ice_init_nvm_phy_type(pf->hw.port_info); 446508771bceSAnirudh Venkataramanan if (err) 44661a3571b5SPaul Greenwalt dev_err(dev, "ice_init_nvm_phy_type failed: %d\n", err); 44671a3571b5SPaul Greenwalt 446808771bceSAnirudh Venkataramanan /* not a fatal error if this fails */ 44691a3571b5SPaul Greenwalt err = ice_update_link_info(pf->hw.port_info); 447008771bceSAnirudh Venkataramanan if (err) 44711a3571b5SPaul Greenwalt dev_err(dev, "ice_update_link_info failed: %d\n", err); 44721a3571b5SPaul Greenwalt 4473ea78ce4dSPaul Greenwalt ice_init_link_dflt_override(pf->hw.port_info); 4474ea78ce4dSPaul Greenwalt 4475c77849f5SAnirudh Venkataramanan ice_check_module_power(pf, pf->hw.port_info->phy.link_info.link_cfg_err); 4476c77849f5SAnirudh Venkataramanan 44771a3571b5SPaul Greenwalt /* if media available, initialize PHY settings */ 44781a3571b5SPaul Greenwalt if (pf->hw.port_info->phy.link_info.link_info & 44791a3571b5SPaul Greenwalt ICE_AQ_MEDIA_AVAILABLE) { 448008771bceSAnirudh Venkataramanan /* not a fatal error if this fails */ 44811a3571b5SPaul Greenwalt err = ice_init_phy_user_cfg(pf->hw.port_info); 448208771bceSAnirudh Venkataramanan if (err) 44831a3571b5SPaul Greenwalt dev_err(dev, "ice_init_phy_user_cfg failed: %d\n", err); 44841a3571b5SPaul Greenwalt 44851a3571b5SPaul Greenwalt if (!test_bit(ICE_FLAG_LINK_DOWN_ON_CLOSE_ENA, pf->flags)) { 44861a3571b5SPaul Greenwalt struct ice_vsi *vsi = ice_get_main_vsi(pf); 44871a3571b5SPaul Greenwalt 44881a3571b5SPaul Greenwalt if (vsi) 44891a3571b5SPaul Greenwalt ice_configure_phy(vsi); 44901a3571b5SPaul Greenwalt } 44911a3571b5SPaul Greenwalt } else { 44921a3571b5SPaul Greenwalt set_bit(ICE_FLAG_NO_MEDIA, pf->flags); 44931a3571b5SPaul Greenwalt } 44941a3571b5SPaul Greenwalt 4495c585ea42SBrett Creeley ice_verify_cacheline_size(pf); 4496c585ea42SBrett Creeley 4497769c500dSAkeem G Abodunrin /* Save wakeup reason register for later use */ 4498769c500dSAkeem G Abodunrin pf->wakeup_reason = rd32(hw, PFPM_WUS); 4499769c500dSAkeem G Abodunrin 4500769c500dSAkeem G Abodunrin /* check for a power management event */ 4501769c500dSAkeem G Abodunrin ice_print_wake_reason(pf); 4502769c500dSAkeem G Abodunrin 4503769c500dSAkeem G Abodunrin /* clear wake status, all bits */ 4504769c500dSAkeem G Abodunrin wr32(hw, PFPM_WUS, U32_MAX); 4505769c500dSAkeem G Abodunrin 4506769c500dSAkeem G Abodunrin /* Disable WoL at init, wait for user to enable */ 4507769c500dSAkeem G Abodunrin device_set_wakeup_enable(dev, false); 4508769c500dSAkeem G Abodunrin 4509cd1f56f4SBrett Creeley if (ice_is_safe_mode(pf)) { 4510cd1f56f4SBrett Creeley ice_set_safe_mode_vlan_cfg(pf); 4511de75135bSAnirudh Venkataramanan goto probe_done; 4512cd1f56f4SBrett Creeley } 4513462acf6aSTony Nguyen 4514462acf6aSTony Nguyen /* initialize DDP driven features */ 451506c16d89SJacob Keller if (test_bit(ICE_FLAG_PTP_SUPPORTED, pf->flags)) 451606c16d89SJacob Keller ice_ptp_init(pf); 4517462acf6aSTony Nguyen 4518148beb61SHenry Tieman /* Note: Flow director init failure is non-fatal to load */ 4519148beb61SHenry Tieman if (ice_init_fdir(pf)) 4520148beb61SHenry Tieman dev_err(dev, "could not initialize flow director\n"); 4521148beb61SHenry Tieman 4522462acf6aSTony Nguyen /* Note: DCB init failure is non-fatal to load */ 4523462acf6aSTony Nguyen if (ice_init_pf_dcb(pf, false)) { 4524462acf6aSTony Nguyen clear_bit(ICE_FLAG_DCB_CAPABLE, pf->flags); 4525462acf6aSTony Nguyen clear_bit(ICE_FLAG_DCB_ENA, pf->flags); 4526462acf6aSTony Nguyen } else { 4527462acf6aSTony Nguyen ice_cfg_lldp_mib_change(&pf->hw, true); 4528462acf6aSTony Nguyen } 4529462acf6aSTony Nguyen 4530df006dd4SDave Ertman if (ice_init_lag(pf)) 4531df006dd4SDave Ertman dev_warn(dev, "Failed to init link aggregation support\n"); 4532df006dd4SDave Ertman 4533e18ff118SPaul Greenwalt /* print PCI link speed and width */ 4534e18ff118SPaul Greenwalt pcie_print_link_status(pf->pdev); 4535e18ff118SPaul Greenwalt 4536de75135bSAnirudh Venkataramanan probe_done: 45371e23f076SAnirudh Venkataramanan err = ice_register_netdev(pf); 45381e23f076SAnirudh Venkataramanan if (err) 45391e23f076SAnirudh Venkataramanan goto err_netdev_reg; 45401e23f076SAnirudh Venkataramanan 4541de75135bSAnirudh Venkataramanan /* ready to go, so clear down state bit */ 45427e408e07SAnirudh Venkataramanan clear_bit(ICE_DOWN, pf->state); 4543d25a0fc4SDave Ertman if (ice_is_aux_ena(pf)) { 4544d25a0fc4SDave Ertman pf->aux_idx = ida_alloc(&ice_aux_ida, GFP_KERNEL); 4545d25a0fc4SDave Ertman if (pf->aux_idx < 0) { 4546d25a0fc4SDave Ertman dev_err(dev, "Failed to allocate device ID for AUX driver\n"); 4547d25a0fc4SDave Ertman err = -ENOMEM; 4548d25a0fc4SDave Ertman goto err_netdev_reg; 4549d25a0fc4SDave Ertman } 4550d25a0fc4SDave Ertman 4551d25a0fc4SDave Ertman err = ice_init_rdma(pf); 4552d25a0fc4SDave Ertman if (err) { 4553d25a0fc4SDave Ertman dev_err(dev, "Failed to initialize RDMA: %d\n", err); 4554d25a0fc4SDave Ertman err = -EIO; 4555d25a0fc4SDave Ertman goto err_init_aux_unroll; 4556d25a0fc4SDave Ertman } 4557d25a0fc4SDave Ertman } else { 4558d25a0fc4SDave Ertman dev_warn(dev, "RDMA is not supported on this device\n"); 4559d25a0fc4SDave Ertman } 4560d25a0fc4SDave Ertman 4561838cefd5SLeon Romanovsky ice_devlink_register(pf); 4562837f08fdSAnirudh Venkataramanan return 0; 4563f31e4b6fSAnirudh Venkataramanan 4564d25a0fc4SDave Ertman err_init_aux_unroll: 4565d25a0fc4SDave Ertman pf->adev = NULL; 4566d25a0fc4SDave Ertman ida_free(&ice_aux_ida, pf->aux_idx); 45671e23f076SAnirudh Venkataramanan err_netdev_reg: 456878116e97SMarcin Szycik err_send_version_unroll: 456978116e97SMarcin Szycik ice_vsi_release_all(pf); 45703a858ba3SAnirudh Venkataramanan err_alloc_sw_unroll: 45717e408e07SAnirudh Venkataramanan set_bit(ICE_SERVICE_DIS, pf->state); 45727e408e07SAnirudh Venkataramanan set_bit(ICE_DOWN, pf->state); 45734015d11eSBrett Creeley devm_kfree(dev, pf->first_sw); 4574940b61afSAnirudh Venkataramanan err_msix_misc_unroll: 4575940b61afSAnirudh Venkataramanan ice_free_irq_msix_misc(pf); 4576940b61afSAnirudh Venkataramanan err_init_interrupt_unroll: 4577940b61afSAnirudh Venkataramanan ice_clear_interrupt_scheme(pf); 4578bc3a0241SJacob Keller err_init_vsi_unroll: 457977ed84f4SBruce Allan devm_kfree(dev, pf->vsi); 4580940b61afSAnirudh Venkataramanan err_init_pf_unroll: 4581940b61afSAnirudh Venkataramanan ice_deinit_pf(pf); 4582dce730f1SJacob Keller ice_devlink_destroy_regions(pf); 4583940b61afSAnirudh Venkataramanan ice_deinit_hw(hw); 4584f31e4b6fSAnirudh Venkataramanan err_exit_unroll: 4585f31e4b6fSAnirudh Venkataramanan pci_disable_pcie_error_reporting(pdev); 4586769c500dSAkeem G Abodunrin pci_disable_device(pdev); 4587f31e4b6fSAnirudh Venkataramanan return err; 4588837f08fdSAnirudh Venkataramanan } 4589837f08fdSAnirudh Venkataramanan 4590837f08fdSAnirudh Venkataramanan /** 4591769c500dSAkeem G Abodunrin * ice_set_wake - enable or disable Wake on LAN 4592769c500dSAkeem G Abodunrin * @pf: pointer to the PF struct 4593769c500dSAkeem G Abodunrin * 4594769c500dSAkeem G Abodunrin * Simple helper for WoL control 4595769c500dSAkeem G Abodunrin */ 4596769c500dSAkeem G Abodunrin static void ice_set_wake(struct ice_pf *pf) 4597769c500dSAkeem G Abodunrin { 4598769c500dSAkeem G Abodunrin struct ice_hw *hw = &pf->hw; 4599769c500dSAkeem G Abodunrin bool wol = pf->wol_ena; 4600769c500dSAkeem G Abodunrin 4601769c500dSAkeem G Abodunrin /* clear wake state, otherwise new wake events won't fire */ 4602769c500dSAkeem G Abodunrin wr32(hw, PFPM_WUS, U32_MAX); 4603769c500dSAkeem G Abodunrin 4604769c500dSAkeem G Abodunrin /* enable / disable APM wake up, no RMW needed */ 4605769c500dSAkeem G Abodunrin wr32(hw, PFPM_APM, wol ? PFPM_APM_APME_M : 0); 4606769c500dSAkeem G Abodunrin 4607769c500dSAkeem G Abodunrin /* set magic packet filter enabled */ 4608769c500dSAkeem G Abodunrin wr32(hw, PFPM_WUFC, wol ? PFPM_WUFC_MAG_M : 0); 4609769c500dSAkeem G Abodunrin } 4610769c500dSAkeem G Abodunrin 4611769c500dSAkeem G Abodunrin /** 4612ef860480STony Nguyen * ice_setup_mc_magic_wake - setup device to wake on multicast magic packet 4613769c500dSAkeem G Abodunrin * @pf: pointer to the PF struct 4614769c500dSAkeem G Abodunrin * 4615769c500dSAkeem G Abodunrin * Issue firmware command to enable multicast magic wake, making 4616769c500dSAkeem G Abodunrin * sure that any locally administered address (LAA) is used for 4617769c500dSAkeem G Abodunrin * wake, and that PF reset doesn't undo the LAA. 4618769c500dSAkeem G Abodunrin */ 4619769c500dSAkeem G Abodunrin static void ice_setup_mc_magic_wake(struct ice_pf *pf) 4620769c500dSAkeem G Abodunrin { 4621769c500dSAkeem G Abodunrin struct device *dev = ice_pf_to_dev(pf); 4622769c500dSAkeem G Abodunrin struct ice_hw *hw = &pf->hw; 4623769c500dSAkeem G Abodunrin enum ice_status status; 4624769c500dSAkeem G Abodunrin u8 mac_addr[ETH_ALEN]; 4625769c500dSAkeem G Abodunrin struct ice_vsi *vsi; 4626769c500dSAkeem G Abodunrin u8 flags; 4627769c500dSAkeem G Abodunrin 4628769c500dSAkeem G Abodunrin if (!pf->wol_ena) 4629769c500dSAkeem G Abodunrin return; 4630769c500dSAkeem G Abodunrin 4631769c500dSAkeem G Abodunrin vsi = ice_get_main_vsi(pf); 4632769c500dSAkeem G Abodunrin if (!vsi) 4633769c500dSAkeem G Abodunrin return; 4634769c500dSAkeem G Abodunrin 4635769c500dSAkeem G Abodunrin /* Get current MAC address in case it's an LAA */ 4636769c500dSAkeem G Abodunrin if (vsi->netdev) 4637769c500dSAkeem G Abodunrin ether_addr_copy(mac_addr, vsi->netdev->dev_addr); 4638769c500dSAkeem G Abodunrin else 4639769c500dSAkeem G Abodunrin ether_addr_copy(mac_addr, vsi->port_info->mac.perm_addr); 4640769c500dSAkeem G Abodunrin 4641769c500dSAkeem G Abodunrin flags = ICE_AQC_MAN_MAC_WR_MC_MAG_EN | 4642769c500dSAkeem G Abodunrin ICE_AQC_MAN_MAC_UPDATE_LAA_WOL | 4643769c500dSAkeem G Abodunrin ICE_AQC_MAN_MAC_WR_WOL_LAA_PFR_KEEP; 4644769c500dSAkeem G Abodunrin 4645769c500dSAkeem G Abodunrin status = ice_aq_manage_mac_write(hw, mac_addr, flags, NULL); 4646769c500dSAkeem G Abodunrin if (status) 4647769c500dSAkeem G Abodunrin dev_err(dev, "Failed to enable Multicast Magic Packet wake, err %s aq_err %s\n", 4648769c500dSAkeem G Abodunrin ice_stat_str(status), 4649769c500dSAkeem G Abodunrin ice_aq_str(hw->adminq.sq_last_status)); 4650769c500dSAkeem G Abodunrin } 4651769c500dSAkeem G Abodunrin 4652769c500dSAkeem G Abodunrin /** 4653837f08fdSAnirudh Venkataramanan * ice_remove - Device removal routine 4654837f08fdSAnirudh Venkataramanan * @pdev: PCI device information struct 4655837f08fdSAnirudh Venkataramanan */ 4656837f08fdSAnirudh Venkataramanan static void ice_remove(struct pci_dev *pdev) 4657837f08fdSAnirudh Venkataramanan { 4658837f08fdSAnirudh Venkataramanan struct ice_pf *pf = pci_get_drvdata(pdev); 465981b23589SDave Ertman int i; 4660837f08fdSAnirudh Venkataramanan 4661838cefd5SLeon Romanovsky ice_devlink_unregister(pf); 4662afd9d4abSAnirudh Venkataramanan for (i = 0; i < ICE_MAX_RESET_WAIT; i++) { 4663afd9d4abSAnirudh Venkataramanan if (!ice_is_reset_in_progress(pf->state)) 4664afd9d4abSAnirudh Venkataramanan break; 4665afd9d4abSAnirudh Venkataramanan msleep(100); 4666afd9d4abSAnirudh Venkataramanan } 4667afd9d4abSAnirudh Venkataramanan 4668f844d521SBrett Creeley if (test_bit(ICE_FLAG_SRIOV_ENA, pf->flags)) { 46697e408e07SAnirudh Venkataramanan set_bit(ICE_VF_RESETS_DISABLED, pf->state); 4670f844d521SBrett Creeley ice_free_vfs(pf); 4671f844d521SBrett Creeley } 4672f844d521SBrett Creeley 46738d81fa55SAkeem G Abodunrin ice_service_task_stop(pf); 4674f31e4b6fSAnirudh Venkataramanan 4675d69ea414SJacob Keller ice_aq_cancel_waiting_tasks(pf); 4676f9f5301eSDave Ertman ice_unplug_aux_dev(pf); 4677d25a0fc4SDave Ertman ida_free(&ice_aux_ida, pf->aux_idx); 4678f9f5301eSDave Ertman set_bit(ICE_DOWN, pf->state); 4679d69ea414SJacob Keller 4680148beb61SHenry Tieman mutex_destroy(&(&pf->hw)->fdir_fltr_lock); 4681df006dd4SDave Ertman ice_deinit_lag(pf); 468206c16d89SJacob Keller if (test_bit(ICE_FLAG_PTP_SUPPORTED, pf->flags)) 468306c16d89SJacob Keller ice_ptp_release(pf); 468428bf2672SBrett Creeley if (!ice_is_safe_mode(pf)) 468528bf2672SBrett Creeley ice_remove_arfs(pf); 4686769c500dSAkeem G Abodunrin ice_setup_mc_magic_wake(pf); 46870f9d5027SAnirudh Venkataramanan ice_vsi_release_all(pf); 4688769c500dSAkeem G Abodunrin ice_set_wake(pf); 4689940b61afSAnirudh Venkataramanan ice_free_irq_msix_misc(pf); 469081b23589SDave Ertman ice_for_each_vsi(pf, i) { 469181b23589SDave Ertman if (!pf->vsi[i]) 469281b23589SDave Ertman continue; 469381b23589SDave Ertman ice_vsi_free_q_vectors(pf->vsi[i]); 469481b23589SDave Ertman } 4695940b61afSAnirudh Venkataramanan ice_deinit_pf(pf); 4696dce730f1SJacob Keller ice_devlink_destroy_regions(pf); 4697f31e4b6fSAnirudh Venkataramanan ice_deinit_hw(&pf->hw); 46981adf7eadSJacob Keller 469918057cb3SBruce Allan /* Issue a PFR as part of the prescribed driver unload flow. Do not 470018057cb3SBruce Allan * do it via ice_schedule_reset() since there is no need to rebuild 470118057cb3SBruce Allan * and the service task is already stopped. 470218057cb3SBruce Allan */ 470318057cb3SBruce Allan ice_reset(&pf->hw, ICE_RESET_PFR); 4704c6012ac1SBruce Allan pci_wait_for_pending_transaction(pdev); 4705c6012ac1SBruce Allan ice_clear_interrupt_scheme(pf); 4706837f08fdSAnirudh Venkataramanan pci_disable_pcie_error_reporting(pdev); 4707769c500dSAkeem G Abodunrin pci_disable_device(pdev); 4708837f08fdSAnirudh Venkataramanan } 4709837f08fdSAnirudh Venkataramanan 47105995b6d0SBrett Creeley /** 4711769c500dSAkeem G Abodunrin * ice_shutdown - PCI callback for shutting down device 4712769c500dSAkeem G Abodunrin * @pdev: PCI device information struct 4713769c500dSAkeem G Abodunrin */ 4714769c500dSAkeem G Abodunrin static void ice_shutdown(struct pci_dev *pdev) 4715769c500dSAkeem G Abodunrin { 4716769c500dSAkeem G Abodunrin struct ice_pf *pf = pci_get_drvdata(pdev); 4717769c500dSAkeem G Abodunrin 4718769c500dSAkeem G Abodunrin ice_remove(pdev); 4719769c500dSAkeem G Abodunrin 4720769c500dSAkeem G Abodunrin if (system_state == SYSTEM_POWER_OFF) { 4721769c500dSAkeem G Abodunrin pci_wake_from_d3(pdev, pf->wol_ena); 4722769c500dSAkeem G Abodunrin pci_set_power_state(pdev, PCI_D3hot); 4723769c500dSAkeem G Abodunrin } 4724769c500dSAkeem G Abodunrin } 4725769c500dSAkeem G Abodunrin 4726769c500dSAkeem G Abodunrin #ifdef CONFIG_PM 4727769c500dSAkeem G Abodunrin /** 4728769c500dSAkeem G Abodunrin * ice_prepare_for_shutdown - prep for PCI shutdown 4729769c500dSAkeem G Abodunrin * @pf: board private structure 4730769c500dSAkeem G Abodunrin * 4731769c500dSAkeem G Abodunrin * Inform or close all dependent features in prep for PCI device shutdown 4732769c500dSAkeem G Abodunrin */ 4733769c500dSAkeem G Abodunrin static void ice_prepare_for_shutdown(struct ice_pf *pf) 4734769c500dSAkeem G Abodunrin { 4735769c500dSAkeem G Abodunrin struct ice_hw *hw = &pf->hw; 4736769c500dSAkeem G Abodunrin u32 v; 4737769c500dSAkeem G Abodunrin 4738769c500dSAkeem G Abodunrin /* Notify VFs of impending reset */ 4739769c500dSAkeem G Abodunrin if (ice_check_sq_alive(hw, &hw->mailboxq)) 4740769c500dSAkeem G Abodunrin ice_vc_notify_reset(pf); 4741769c500dSAkeem G Abodunrin 4742769c500dSAkeem G Abodunrin dev_dbg(ice_pf_to_dev(pf), "Tearing down internal switch for shutdown\n"); 4743769c500dSAkeem G Abodunrin 4744769c500dSAkeem G Abodunrin /* disable the VSIs and their queues that are not already DOWN */ 4745769c500dSAkeem G Abodunrin ice_pf_dis_all_vsi(pf, false); 4746769c500dSAkeem G Abodunrin 4747769c500dSAkeem G Abodunrin ice_for_each_vsi(pf, v) 4748769c500dSAkeem G Abodunrin if (pf->vsi[v]) 4749769c500dSAkeem G Abodunrin pf->vsi[v]->vsi_num = 0; 4750769c500dSAkeem G Abodunrin 4751769c500dSAkeem G Abodunrin ice_shutdown_all_ctrlq(hw); 4752769c500dSAkeem G Abodunrin } 4753769c500dSAkeem G Abodunrin 4754769c500dSAkeem G Abodunrin /** 4755769c500dSAkeem G Abodunrin * ice_reinit_interrupt_scheme - Reinitialize interrupt scheme 4756769c500dSAkeem G Abodunrin * @pf: board private structure to reinitialize 4757769c500dSAkeem G Abodunrin * 4758769c500dSAkeem G Abodunrin * This routine reinitialize interrupt scheme that was cleared during 4759769c500dSAkeem G Abodunrin * power management suspend callback. 4760769c500dSAkeem G Abodunrin * 4761769c500dSAkeem G Abodunrin * This should be called during resume routine to re-allocate the q_vectors 4762769c500dSAkeem G Abodunrin * and reacquire interrupts. 4763769c500dSAkeem G Abodunrin */ 4764769c500dSAkeem G Abodunrin static int ice_reinit_interrupt_scheme(struct ice_pf *pf) 4765769c500dSAkeem G Abodunrin { 4766769c500dSAkeem G Abodunrin struct device *dev = ice_pf_to_dev(pf); 4767769c500dSAkeem G Abodunrin int ret, v; 4768769c500dSAkeem G Abodunrin 4769769c500dSAkeem G Abodunrin /* Since we clear MSIX flag during suspend, we need to 4770769c500dSAkeem G Abodunrin * set it back during resume... 4771769c500dSAkeem G Abodunrin */ 4772769c500dSAkeem G Abodunrin 4773769c500dSAkeem G Abodunrin ret = ice_init_interrupt_scheme(pf); 4774769c500dSAkeem G Abodunrin if (ret) { 4775769c500dSAkeem G Abodunrin dev_err(dev, "Failed to re-initialize interrupt %d\n", ret); 4776769c500dSAkeem G Abodunrin return ret; 4777769c500dSAkeem G Abodunrin } 4778769c500dSAkeem G Abodunrin 4779769c500dSAkeem G Abodunrin /* Remap vectors and rings, after successful re-init interrupts */ 4780769c500dSAkeem G Abodunrin ice_for_each_vsi(pf, v) { 4781769c500dSAkeem G Abodunrin if (!pf->vsi[v]) 4782769c500dSAkeem G Abodunrin continue; 4783769c500dSAkeem G Abodunrin 4784769c500dSAkeem G Abodunrin ret = ice_vsi_alloc_q_vectors(pf->vsi[v]); 4785769c500dSAkeem G Abodunrin if (ret) 4786769c500dSAkeem G Abodunrin goto err_reinit; 4787769c500dSAkeem G Abodunrin ice_vsi_map_rings_to_vectors(pf->vsi[v]); 4788769c500dSAkeem G Abodunrin } 4789769c500dSAkeem G Abodunrin 4790769c500dSAkeem G Abodunrin ret = ice_req_irq_msix_misc(pf); 4791769c500dSAkeem G Abodunrin if (ret) { 4792769c500dSAkeem G Abodunrin dev_err(dev, "Setting up misc vector failed after device suspend %d\n", 4793769c500dSAkeem G Abodunrin ret); 4794769c500dSAkeem G Abodunrin goto err_reinit; 4795769c500dSAkeem G Abodunrin } 4796769c500dSAkeem G Abodunrin 4797769c500dSAkeem G Abodunrin return 0; 4798769c500dSAkeem G Abodunrin 4799769c500dSAkeem G Abodunrin err_reinit: 4800769c500dSAkeem G Abodunrin while (v--) 4801769c500dSAkeem G Abodunrin if (pf->vsi[v]) 4802769c500dSAkeem G Abodunrin ice_vsi_free_q_vectors(pf->vsi[v]); 4803769c500dSAkeem G Abodunrin 4804769c500dSAkeem G Abodunrin return ret; 4805769c500dSAkeem G Abodunrin } 4806769c500dSAkeem G Abodunrin 4807769c500dSAkeem G Abodunrin /** 4808769c500dSAkeem G Abodunrin * ice_suspend 4809769c500dSAkeem G Abodunrin * @dev: generic device information structure 4810769c500dSAkeem G Abodunrin * 4811769c500dSAkeem G Abodunrin * Power Management callback to quiesce the device and prepare 4812769c500dSAkeem G Abodunrin * for D3 transition. 4813769c500dSAkeem G Abodunrin */ 481465c72291SWei Yongjun static int __maybe_unused ice_suspend(struct device *dev) 4815769c500dSAkeem G Abodunrin { 4816769c500dSAkeem G Abodunrin struct pci_dev *pdev = to_pci_dev(dev); 4817769c500dSAkeem G Abodunrin struct ice_pf *pf; 4818769c500dSAkeem G Abodunrin int disabled, v; 4819769c500dSAkeem G Abodunrin 4820769c500dSAkeem G Abodunrin pf = pci_get_drvdata(pdev); 4821769c500dSAkeem G Abodunrin 4822769c500dSAkeem G Abodunrin if (!ice_pf_state_is_nominal(pf)) { 4823769c500dSAkeem G Abodunrin dev_err(dev, "Device is not ready, no need to suspend it\n"); 4824769c500dSAkeem G Abodunrin return -EBUSY; 4825769c500dSAkeem G Abodunrin } 4826769c500dSAkeem G Abodunrin 4827769c500dSAkeem G Abodunrin /* Stop watchdog tasks until resume completion. 4828769c500dSAkeem G Abodunrin * Even though it is most likely that the service task is 4829769c500dSAkeem G Abodunrin * disabled if the device is suspended or down, the service task's 4830769c500dSAkeem G Abodunrin * state is controlled by a different state bit, and we should 4831769c500dSAkeem G Abodunrin * store and honor whatever state that bit is in at this point. 4832769c500dSAkeem G Abodunrin */ 4833769c500dSAkeem G Abodunrin disabled = ice_service_task_stop(pf); 4834769c500dSAkeem G Abodunrin 4835f9f5301eSDave Ertman ice_unplug_aux_dev(pf); 4836f9f5301eSDave Ertman 4837769c500dSAkeem G Abodunrin /* Already suspended?, then there is nothing to do */ 48387e408e07SAnirudh Venkataramanan if (test_and_set_bit(ICE_SUSPENDED, pf->state)) { 4839769c500dSAkeem G Abodunrin if (!disabled) 4840769c500dSAkeem G Abodunrin ice_service_task_restart(pf); 4841769c500dSAkeem G Abodunrin return 0; 4842769c500dSAkeem G Abodunrin } 4843769c500dSAkeem G Abodunrin 48447e408e07SAnirudh Venkataramanan if (test_bit(ICE_DOWN, pf->state) || 4845769c500dSAkeem G Abodunrin ice_is_reset_in_progress(pf->state)) { 4846769c500dSAkeem G Abodunrin dev_err(dev, "can't suspend device in reset or already down\n"); 4847769c500dSAkeem G Abodunrin if (!disabled) 4848769c500dSAkeem G Abodunrin ice_service_task_restart(pf); 4849769c500dSAkeem G Abodunrin return 0; 4850769c500dSAkeem G Abodunrin } 4851769c500dSAkeem G Abodunrin 4852769c500dSAkeem G Abodunrin ice_setup_mc_magic_wake(pf); 4853769c500dSAkeem G Abodunrin 4854769c500dSAkeem G Abodunrin ice_prepare_for_shutdown(pf); 4855769c500dSAkeem G Abodunrin 4856769c500dSAkeem G Abodunrin ice_set_wake(pf); 4857769c500dSAkeem G Abodunrin 4858769c500dSAkeem G Abodunrin /* Free vectors, clear the interrupt scheme and release IRQs 4859769c500dSAkeem G Abodunrin * for proper hibernation, especially with large number of CPUs. 4860769c500dSAkeem G Abodunrin * Otherwise hibernation might fail when mapping all the vectors back 4861769c500dSAkeem G Abodunrin * to CPU0. 4862769c500dSAkeem G Abodunrin */ 4863769c500dSAkeem G Abodunrin ice_free_irq_msix_misc(pf); 4864769c500dSAkeem G Abodunrin ice_for_each_vsi(pf, v) { 4865769c500dSAkeem G Abodunrin if (!pf->vsi[v]) 4866769c500dSAkeem G Abodunrin continue; 4867769c500dSAkeem G Abodunrin ice_vsi_free_q_vectors(pf->vsi[v]); 4868769c500dSAkeem G Abodunrin } 48691831da7eSYongxin Liu ice_free_cpu_rx_rmap(ice_get_main_vsi(pf)); 4870769c500dSAkeem G Abodunrin ice_clear_interrupt_scheme(pf); 4871769c500dSAkeem G Abodunrin 4872466e4392SAnirudh Venkataramanan pci_save_state(pdev); 4873769c500dSAkeem G Abodunrin pci_wake_from_d3(pdev, pf->wol_ena); 4874769c500dSAkeem G Abodunrin pci_set_power_state(pdev, PCI_D3hot); 4875769c500dSAkeem G Abodunrin return 0; 4876769c500dSAkeem G Abodunrin } 4877769c500dSAkeem G Abodunrin 4878769c500dSAkeem G Abodunrin /** 4879769c500dSAkeem G Abodunrin * ice_resume - PM callback for waking up from D3 4880769c500dSAkeem G Abodunrin * @dev: generic device information structure 4881769c500dSAkeem G Abodunrin */ 488265c72291SWei Yongjun static int __maybe_unused ice_resume(struct device *dev) 4883769c500dSAkeem G Abodunrin { 4884769c500dSAkeem G Abodunrin struct pci_dev *pdev = to_pci_dev(dev); 4885769c500dSAkeem G Abodunrin enum ice_reset_req reset_type; 4886769c500dSAkeem G Abodunrin struct ice_pf *pf; 4887769c500dSAkeem G Abodunrin struct ice_hw *hw; 4888769c500dSAkeem G Abodunrin int ret; 4889769c500dSAkeem G Abodunrin 4890769c500dSAkeem G Abodunrin pci_set_power_state(pdev, PCI_D0); 4891769c500dSAkeem G Abodunrin pci_restore_state(pdev); 4892769c500dSAkeem G Abodunrin pci_save_state(pdev); 4893769c500dSAkeem G Abodunrin 4894769c500dSAkeem G Abodunrin if (!pci_device_is_present(pdev)) 4895769c500dSAkeem G Abodunrin return -ENODEV; 4896769c500dSAkeem G Abodunrin 4897769c500dSAkeem G Abodunrin ret = pci_enable_device_mem(pdev); 4898769c500dSAkeem G Abodunrin if (ret) { 4899769c500dSAkeem G Abodunrin dev_err(dev, "Cannot enable device after suspend\n"); 4900769c500dSAkeem G Abodunrin return ret; 4901769c500dSAkeem G Abodunrin } 4902769c500dSAkeem G Abodunrin 4903769c500dSAkeem G Abodunrin pf = pci_get_drvdata(pdev); 4904769c500dSAkeem G Abodunrin hw = &pf->hw; 4905769c500dSAkeem G Abodunrin 4906769c500dSAkeem G Abodunrin pf->wakeup_reason = rd32(hw, PFPM_WUS); 4907769c500dSAkeem G Abodunrin ice_print_wake_reason(pf); 4908769c500dSAkeem G Abodunrin 4909769c500dSAkeem G Abodunrin /* We cleared the interrupt scheme when we suspended, so we need to 4910769c500dSAkeem G Abodunrin * restore it now to resume device functionality. 4911769c500dSAkeem G Abodunrin */ 4912769c500dSAkeem G Abodunrin ret = ice_reinit_interrupt_scheme(pf); 4913769c500dSAkeem G Abodunrin if (ret) 4914769c500dSAkeem G Abodunrin dev_err(dev, "Cannot restore interrupt scheme: %d\n", ret); 4915769c500dSAkeem G Abodunrin 49167e408e07SAnirudh Venkataramanan clear_bit(ICE_DOWN, pf->state); 4917769c500dSAkeem G Abodunrin /* Now perform PF reset and rebuild */ 4918769c500dSAkeem G Abodunrin reset_type = ICE_RESET_PFR; 4919769c500dSAkeem G Abodunrin /* re-enable service task for reset, but allow reset to schedule it */ 49207e408e07SAnirudh Venkataramanan clear_bit(ICE_SERVICE_DIS, pf->state); 4921769c500dSAkeem G Abodunrin 4922769c500dSAkeem G Abodunrin if (ice_schedule_reset(pf, reset_type)) 4923769c500dSAkeem G Abodunrin dev_err(dev, "Reset during resume failed.\n"); 4924769c500dSAkeem G Abodunrin 49257e408e07SAnirudh Venkataramanan clear_bit(ICE_SUSPENDED, pf->state); 4926769c500dSAkeem G Abodunrin ice_service_task_restart(pf); 4927769c500dSAkeem G Abodunrin 4928769c500dSAkeem G Abodunrin /* Restart the service task */ 4929769c500dSAkeem G Abodunrin mod_timer(&pf->serv_tmr, round_jiffies(jiffies + pf->serv_tmr_period)); 4930769c500dSAkeem G Abodunrin 4931769c500dSAkeem G Abodunrin return 0; 4932769c500dSAkeem G Abodunrin } 4933769c500dSAkeem G Abodunrin #endif /* CONFIG_PM */ 4934769c500dSAkeem G Abodunrin 4935769c500dSAkeem G Abodunrin /** 49365995b6d0SBrett Creeley * ice_pci_err_detected - warning that PCI error has been detected 49375995b6d0SBrett Creeley * @pdev: PCI device information struct 49385995b6d0SBrett Creeley * @err: the type of PCI error 49395995b6d0SBrett Creeley * 49405995b6d0SBrett Creeley * Called to warn that something happened on the PCI bus and the error handling 49415995b6d0SBrett Creeley * is in progress. Allows the driver to gracefully prepare/handle PCI errors. 49425995b6d0SBrett Creeley */ 49435995b6d0SBrett Creeley static pci_ers_result_t 494416d79cd4SLuc Van Oostenryck ice_pci_err_detected(struct pci_dev *pdev, pci_channel_state_t err) 49455995b6d0SBrett Creeley { 49465995b6d0SBrett Creeley struct ice_pf *pf = pci_get_drvdata(pdev); 49475995b6d0SBrett Creeley 49485995b6d0SBrett Creeley if (!pf) { 49495995b6d0SBrett Creeley dev_err(&pdev->dev, "%s: unrecoverable device error %d\n", 49505995b6d0SBrett Creeley __func__, err); 49515995b6d0SBrett Creeley return PCI_ERS_RESULT_DISCONNECT; 49525995b6d0SBrett Creeley } 49535995b6d0SBrett Creeley 49547e408e07SAnirudh Venkataramanan if (!test_bit(ICE_SUSPENDED, pf->state)) { 49555995b6d0SBrett Creeley ice_service_task_stop(pf); 49565995b6d0SBrett Creeley 49577e408e07SAnirudh Venkataramanan if (!test_bit(ICE_PREPARED_FOR_RESET, pf->state)) { 49587e408e07SAnirudh Venkataramanan set_bit(ICE_PFR_REQ, pf->state); 49595995b6d0SBrett Creeley ice_prepare_for_reset(pf); 49605995b6d0SBrett Creeley } 49615995b6d0SBrett Creeley } 49625995b6d0SBrett Creeley 49635995b6d0SBrett Creeley return PCI_ERS_RESULT_NEED_RESET; 49645995b6d0SBrett Creeley } 49655995b6d0SBrett Creeley 49665995b6d0SBrett Creeley /** 49675995b6d0SBrett Creeley * ice_pci_err_slot_reset - a PCI slot reset has just happened 49685995b6d0SBrett Creeley * @pdev: PCI device information struct 49695995b6d0SBrett Creeley * 49705995b6d0SBrett Creeley * Called to determine if the driver can recover from the PCI slot reset by 49715995b6d0SBrett Creeley * using a register read to determine if the device is recoverable. 49725995b6d0SBrett Creeley */ 49735995b6d0SBrett Creeley static pci_ers_result_t ice_pci_err_slot_reset(struct pci_dev *pdev) 49745995b6d0SBrett Creeley { 49755995b6d0SBrett Creeley struct ice_pf *pf = pci_get_drvdata(pdev); 49765995b6d0SBrett Creeley pci_ers_result_t result; 49775995b6d0SBrett Creeley int err; 49785995b6d0SBrett Creeley u32 reg; 49795995b6d0SBrett Creeley 49805995b6d0SBrett Creeley err = pci_enable_device_mem(pdev); 49815995b6d0SBrett Creeley if (err) { 498219cce2c6SAnirudh Venkataramanan dev_err(&pdev->dev, "Cannot re-enable PCI device after reset, error %d\n", 49835995b6d0SBrett Creeley err); 49845995b6d0SBrett Creeley result = PCI_ERS_RESULT_DISCONNECT; 49855995b6d0SBrett Creeley } else { 49865995b6d0SBrett Creeley pci_set_master(pdev); 49875995b6d0SBrett Creeley pci_restore_state(pdev); 49885995b6d0SBrett Creeley pci_save_state(pdev); 49895995b6d0SBrett Creeley pci_wake_from_d3(pdev, false); 49905995b6d0SBrett Creeley 49915995b6d0SBrett Creeley /* Check for life */ 49925995b6d0SBrett Creeley reg = rd32(&pf->hw, GLGEN_RTRIG); 49935995b6d0SBrett Creeley if (!reg) 49945995b6d0SBrett Creeley result = PCI_ERS_RESULT_RECOVERED; 49955995b6d0SBrett Creeley else 49965995b6d0SBrett Creeley result = PCI_ERS_RESULT_DISCONNECT; 49975995b6d0SBrett Creeley } 49985995b6d0SBrett Creeley 4999894020fdSKuppuswamy Sathyanarayanan err = pci_aer_clear_nonfatal_status(pdev); 50005995b6d0SBrett Creeley if (err) 500186f26a77SLinus Torvalds dev_dbg(&pdev->dev, "pci_aer_clear_nonfatal_status() failed, error %d\n", 50025995b6d0SBrett Creeley err); 50035995b6d0SBrett Creeley /* non-fatal, continue */ 50045995b6d0SBrett Creeley 50055995b6d0SBrett Creeley return result; 50065995b6d0SBrett Creeley } 50075995b6d0SBrett Creeley 50085995b6d0SBrett Creeley /** 50095995b6d0SBrett Creeley * ice_pci_err_resume - restart operations after PCI error recovery 50105995b6d0SBrett Creeley * @pdev: PCI device information struct 50115995b6d0SBrett Creeley * 50125995b6d0SBrett Creeley * Called to allow the driver to bring things back up after PCI error and/or 50135995b6d0SBrett Creeley * reset recovery have finished 50145995b6d0SBrett Creeley */ 50155995b6d0SBrett Creeley static void ice_pci_err_resume(struct pci_dev *pdev) 50165995b6d0SBrett Creeley { 50175995b6d0SBrett Creeley struct ice_pf *pf = pci_get_drvdata(pdev); 50185995b6d0SBrett Creeley 50195995b6d0SBrett Creeley if (!pf) { 502019cce2c6SAnirudh Venkataramanan dev_err(&pdev->dev, "%s failed, device is unrecoverable\n", 502119cce2c6SAnirudh Venkataramanan __func__); 50225995b6d0SBrett Creeley return; 50235995b6d0SBrett Creeley } 50245995b6d0SBrett Creeley 50257e408e07SAnirudh Venkataramanan if (test_bit(ICE_SUSPENDED, pf->state)) { 50265995b6d0SBrett Creeley dev_dbg(&pdev->dev, "%s failed to resume normal operations!\n", 50275995b6d0SBrett Creeley __func__); 50285995b6d0SBrett Creeley return; 50295995b6d0SBrett Creeley } 50305995b6d0SBrett Creeley 5031a54a0b24SNick Nunley ice_restore_all_vfs_msi_state(pdev); 5032a54a0b24SNick Nunley 50335995b6d0SBrett Creeley ice_do_reset(pf, ICE_RESET_PFR); 50345995b6d0SBrett Creeley ice_service_task_restart(pf); 50355995b6d0SBrett Creeley mod_timer(&pf->serv_tmr, round_jiffies(jiffies + pf->serv_tmr_period)); 50365995b6d0SBrett Creeley } 50375995b6d0SBrett Creeley 50385995b6d0SBrett Creeley /** 50395995b6d0SBrett Creeley * ice_pci_err_reset_prepare - prepare device driver for PCI reset 50405995b6d0SBrett Creeley * @pdev: PCI device information struct 50415995b6d0SBrett Creeley */ 50425995b6d0SBrett Creeley static void ice_pci_err_reset_prepare(struct pci_dev *pdev) 50435995b6d0SBrett Creeley { 50445995b6d0SBrett Creeley struct ice_pf *pf = pci_get_drvdata(pdev); 50455995b6d0SBrett Creeley 50467e408e07SAnirudh Venkataramanan if (!test_bit(ICE_SUSPENDED, pf->state)) { 50475995b6d0SBrett Creeley ice_service_task_stop(pf); 50485995b6d0SBrett Creeley 50497e408e07SAnirudh Venkataramanan if (!test_bit(ICE_PREPARED_FOR_RESET, pf->state)) { 50507e408e07SAnirudh Venkataramanan set_bit(ICE_PFR_REQ, pf->state); 50515995b6d0SBrett Creeley ice_prepare_for_reset(pf); 50525995b6d0SBrett Creeley } 50535995b6d0SBrett Creeley } 50545995b6d0SBrett Creeley } 50555995b6d0SBrett Creeley 50565995b6d0SBrett Creeley /** 50575995b6d0SBrett Creeley * ice_pci_err_reset_done - PCI reset done, device driver reset can begin 50585995b6d0SBrett Creeley * @pdev: PCI device information struct 50595995b6d0SBrett Creeley */ 50605995b6d0SBrett Creeley static void ice_pci_err_reset_done(struct pci_dev *pdev) 50615995b6d0SBrett Creeley { 50625995b6d0SBrett Creeley ice_pci_err_resume(pdev); 50635995b6d0SBrett Creeley } 50645995b6d0SBrett Creeley 5065837f08fdSAnirudh Venkataramanan /* ice_pci_tbl - PCI Device ID Table 5066837f08fdSAnirudh Venkataramanan * 5067837f08fdSAnirudh Venkataramanan * Wildcard entries (PCI_ANY_ID) should come last 5068837f08fdSAnirudh Venkataramanan * Last entry must be all 0s 5069837f08fdSAnirudh Venkataramanan * 5070837f08fdSAnirudh Venkataramanan * { Vendor ID, Device ID, SubVendor ID, SubDevice ID, 5071837f08fdSAnirudh Venkataramanan * Class, Class Mask, private data (not used) } 5072837f08fdSAnirudh Venkataramanan */ 5073837f08fdSAnirudh Venkataramanan static const struct pci_device_id ice_pci_tbl[] = { 5074633d7449SAnirudh Venkataramanan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E810C_BACKPLANE), 0 }, 5075633d7449SAnirudh Venkataramanan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E810C_QSFP), 0 }, 5076633d7449SAnirudh Venkataramanan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E810C_SFP), 0 }, 5077195fb977SBruce Allan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E810_XXV_SFP), 0 }, 5078e36aeec0SBruce Allan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E823C_BACKPLANE), 0 }, 5079e36aeec0SBruce Allan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E823C_QSFP), 0 }, 5080e36aeec0SBruce Allan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E823C_SFP), 0 }, 5081e36aeec0SBruce Allan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E823C_10G_BASE_T), 0 }, 5082e36aeec0SBruce Allan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E823C_SGMII), 0 }, 50835d9e618cSJacob Keller { PCI_VDEVICE(INTEL, ICE_DEV_ID_E822C_BACKPLANE), 0 }, 50845d9e618cSJacob Keller { PCI_VDEVICE(INTEL, ICE_DEV_ID_E822C_QSFP), 0 }, 50855d9e618cSJacob Keller { PCI_VDEVICE(INTEL, ICE_DEV_ID_E822C_SFP), 0 }, 50865d9e618cSJacob Keller { PCI_VDEVICE(INTEL, ICE_DEV_ID_E822C_10G_BASE_T), 0 }, 50875d9e618cSJacob Keller { PCI_VDEVICE(INTEL, ICE_DEV_ID_E822C_SGMII), 0 }, 50882fbfa966SBruce Allan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E822L_BACKPLANE), 0 }, 50895d9e618cSJacob Keller { PCI_VDEVICE(INTEL, ICE_DEV_ID_E822L_SFP), 0 }, 50905d9e618cSJacob Keller { PCI_VDEVICE(INTEL, ICE_DEV_ID_E822L_10G_BASE_T), 0 }, 50915d9e618cSJacob Keller { PCI_VDEVICE(INTEL, ICE_DEV_ID_E822L_SGMII), 0 }, 5092e36aeec0SBruce Allan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E823L_BACKPLANE), 0 }, 5093e36aeec0SBruce Allan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E823L_SFP), 0 }, 5094e36aeec0SBruce Allan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E823L_10G_BASE_T), 0 }, 5095e36aeec0SBruce Allan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E823L_1GBE), 0 }, 5096e36aeec0SBruce Allan { PCI_VDEVICE(INTEL, ICE_DEV_ID_E823L_QSFP), 0 }, 5097837f08fdSAnirudh Venkataramanan /* required last entry */ 5098837f08fdSAnirudh Venkataramanan { 0, } 5099837f08fdSAnirudh Venkataramanan }; 5100837f08fdSAnirudh Venkataramanan MODULE_DEVICE_TABLE(pci, ice_pci_tbl); 5101837f08fdSAnirudh Venkataramanan 5102769c500dSAkeem G Abodunrin static __maybe_unused SIMPLE_DEV_PM_OPS(ice_pm_ops, ice_suspend, ice_resume); 5103769c500dSAkeem G Abodunrin 51045995b6d0SBrett Creeley static const struct pci_error_handlers ice_pci_err_handler = { 51055995b6d0SBrett Creeley .error_detected = ice_pci_err_detected, 51065995b6d0SBrett Creeley .slot_reset = ice_pci_err_slot_reset, 51075995b6d0SBrett Creeley .reset_prepare = ice_pci_err_reset_prepare, 51085995b6d0SBrett Creeley .reset_done = ice_pci_err_reset_done, 51095995b6d0SBrett Creeley .resume = ice_pci_err_resume 51105995b6d0SBrett Creeley }; 51115995b6d0SBrett Creeley 5112837f08fdSAnirudh Venkataramanan static struct pci_driver ice_driver = { 5113837f08fdSAnirudh Venkataramanan .name = KBUILD_MODNAME, 5114837f08fdSAnirudh Venkataramanan .id_table = ice_pci_tbl, 5115837f08fdSAnirudh Venkataramanan .probe = ice_probe, 5116837f08fdSAnirudh Venkataramanan .remove = ice_remove, 5117769c500dSAkeem G Abodunrin #ifdef CONFIG_PM 5118769c500dSAkeem G Abodunrin .driver.pm = &ice_pm_ops, 5119769c500dSAkeem G Abodunrin #endif /* CONFIG_PM */ 5120769c500dSAkeem G Abodunrin .shutdown = ice_shutdown, 5121ddf30f7fSAnirudh Venkataramanan .sriov_configure = ice_sriov_configure, 51225995b6d0SBrett Creeley .err_handler = &ice_pci_err_handler 5123837f08fdSAnirudh Venkataramanan }; 5124837f08fdSAnirudh Venkataramanan 5125837f08fdSAnirudh Venkataramanan /** 5126837f08fdSAnirudh Venkataramanan * ice_module_init - Driver registration routine 5127837f08fdSAnirudh Venkataramanan * 5128837f08fdSAnirudh Venkataramanan * ice_module_init is the first routine called when the driver is 5129837f08fdSAnirudh Venkataramanan * loaded. All it does is register with the PCI subsystem. 5130837f08fdSAnirudh Venkataramanan */ 5131837f08fdSAnirudh Venkataramanan static int __init ice_module_init(void) 5132837f08fdSAnirudh Venkataramanan { 5133837f08fdSAnirudh Venkataramanan int status; 5134837f08fdSAnirudh Venkataramanan 513534a2a3b8SJeff Kirsher pr_info("%s\n", ice_driver_string); 5136837f08fdSAnirudh Venkataramanan pr_info("%s\n", ice_copyright); 5137837f08fdSAnirudh Venkataramanan 51380f9d5027SAnirudh Venkataramanan ice_wq = alloc_workqueue("%s", WQ_MEM_RECLAIM, 0, KBUILD_MODNAME); 5139940b61afSAnirudh Venkataramanan if (!ice_wq) { 5140940b61afSAnirudh Venkataramanan pr_err("Failed to create workqueue\n"); 5141940b61afSAnirudh Venkataramanan return -ENOMEM; 5142940b61afSAnirudh Venkataramanan } 5143940b61afSAnirudh Venkataramanan 5144837f08fdSAnirudh Venkataramanan status = pci_register_driver(&ice_driver); 5145940b61afSAnirudh Venkataramanan if (status) { 51462f2da36eSAnirudh Venkataramanan pr_err("failed to register PCI driver, err %d\n", status); 5147940b61afSAnirudh Venkataramanan destroy_workqueue(ice_wq); 5148940b61afSAnirudh Venkataramanan } 5149837f08fdSAnirudh Venkataramanan 5150837f08fdSAnirudh Venkataramanan return status; 5151837f08fdSAnirudh Venkataramanan } 5152837f08fdSAnirudh Venkataramanan module_init(ice_module_init); 5153837f08fdSAnirudh Venkataramanan 5154837f08fdSAnirudh Venkataramanan /** 5155837f08fdSAnirudh Venkataramanan * ice_module_exit - Driver exit cleanup routine 5156837f08fdSAnirudh Venkataramanan * 5157837f08fdSAnirudh Venkataramanan * ice_module_exit is called just before the driver is removed 5158837f08fdSAnirudh Venkataramanan * from memory. 5159837f08fdSAnirudh Venkataramanan */ 5160837f08fdSAnirudh Venkataramanan static void __exit ice_module_exit(void) 5161837f08fdSAnirudh Venkataramanan { 5162837f08fdSAnirudh Venkataramanan pci_unregister_driver(&ice_driver); 5163940b61afSAnirudh Venkataramanan destroy_workqueue(ice_wq); 5164837f08fdSAnirudh Venkataramanan pr_info("module unloaded\n"); 5165837f08fdSAnirudh Venkataramanan } 5166837f08fdSAnirudh Venkataramanan module_exit(ice_module_exit); 51673a858ba3SAnirudh Venkataramanan 51683a858ba3SAnirudh Venkataramanan /** 5169f9867df6SAnirudh Venkataramanan * ice_set_mac_address - NDO callback to set MAC address 5170e94d4478SAnirudh Venkataramanan * @netdev: network interface device structure 5171e94d4478SAnirudh Venkataramanan * @pi: pointer to an address structure 5172e94d4478SAnirudh Venkataramanan * 5173e94d4478SAnirudh Venkataramanan * Returns 0 on success, negative on failure 5174e94d4478SAnirudh Venkataramanan */ 5175e94d4478SAnirudh Venkataramanan static int ice_set_mac_address(struct net_device *netdev, void *pi) 5176e94d4478SAnirudh Venkataramanan { 5177e94d4478SAnirudh Venkataramanan struct ice_netdev_priv *np = netdev_priv(netdev); 5178e94d4478SAnirudh Venkataramanan struct ice_vsi *vsi = np->vsi; 5179e94d4478SAnirudh Venkataramanan struct ice_pf *pf = vsi->back; 5180e94d4478SAnirudh Venkataramanan struct ice_hw *hw = &pf->hw; 5181e94d4478SAnirudh Venkataramanan struct sockaddr *addr = pi; 5182e94d4478SAnirudh Venkataramanan enum ice_status status; 5183b357d971SBrett Creeley u8 old_mac[ETH_ALEN]; 5184e94d4478SAnirudh Venkataramanan u8 flags = 0; 5185bbb968e8SAkeem G Abodunrin int err = 0; 5186e94d4478SAnirudh Venkataramanan u8 *mac; 5187e94d4478SAnirudh Venkataramanan 5188e94d4478SAnirudh Venkataramanan mac = (u8 *)addr->sa_data; 5189e94d4478SAnirudh Venkataramanan 5190e94d4478SAnirudh Venkataramanan if (!is_valid_ether_addr(mac)) 5191e94d4478SAnirudh Venkataramanan return -EADDRNOTAVAIL; 5192e94d4478SAnirudh Venkataramanan 5193e94d4478SAnirudh Venkataramanan if (ether_addr_equal(netdev->dev_addr, mac)) { 51943ba7f53fSBrett Creeley netdev_dbg(netdev, "already using mac %pM\n", mac); 5195e94d4478SAnirudh Venkataramanan return 0; 5196e94d4478SAnirudh Venkataramanan } 5197e94d4478SAnirudh Venkataramanan 51987e408e07SAnirudh Venkataramanan if (test_bit(ICE_DOWN, pf->state) || 51995df7e45dSDave Ertman ice_is_reset_in_progress(pf->state)) { 5200e94d4478SAnirudh Venkataramanan netdev_err(netdev, "can't set mac %pM. device not ready\n", 5201e94d4478SAnirudh Venkataramanan mac); 5202e94d4478SAnirudh Venkataramanan return -EBUSY; 5203e94d4478SAnirudh Venkataramanan } 5204e94d4478SAnirudh Venkataramanan 52053ba7f53fSBrett Creeley netif_addr_lock_bh(netdev); 5206b357d971SBrett Creeley ether_addr_copy(old_mac, netdev->dev_addr); 5207b357d971SBrett Creeley /* change the netdev's MAC address */ 5208a05e4c0aSJakub Kicinski eth_hw_addr_set(netdev, mac); 5209b357d971SBrett Creeley netif_addr_unlock_bh(netdev); 5210b357d971SBrett Creeley 5211757976abSLihong Yang /* Clean up old MAC filter. Not an error if old filter doesn't exist */ 5212b357d971SBrett Creeley status = ice_fltr_remove_mac(vsi, old_mac, ICE_FWD_TO_VSI); 5213757976abSLihong Yang if (status && status != ICE_ERR_DOES_NOT_EXIST) { 5214e94d4478SAnirudh Venkataramanan err = -EADDRNOTAVAIL; 5215bbb968e8SAkeem G Abodunrin goto err_update_filters; 5216e94d4478SAnirudh Venkataramanan } 5217e94d4478SAnirudh Venkataramanan 521813ed5e8aSNick Nunley /* Add filter for new MAC. If filter exists, return success */ 52191b8f15b6SMichal Swiatkowski status = ice_fltr_add_mac(vsi, mac, ICE_FWD_TO_VSI); 52203ba7f53fSBrett Creeley if (status == ICE_ERR_ALREADY_EXISTS) 522113ed5e8aSNick Nunley /* Although this MAC filter is already present in hardware it's 522213ed5e8aSNick Nunley * possible in some cases (e.g. bonding) that dev_addr was 522313ed5e8aSNick Nunley * modified outside of the driver and needs to be restored back 522413ed5e8aSNick Nunley * to this value. 522513ed5e8aSNick Nunley */ 5226757976abSLihong Yang netdev_dbg(netdev, "filter for MAC %pM already exists\n", mac); 52273ba7f53fSBrett Creeley else if (status) 5228757976abSLihong Yang /* error if the new filter addition failed */ 5229757976abSLihong Yang err = -EADDRNOTAVAIL; 5230757976abSLihong Yang 5231bbb968e8SAkeem G Abodunrin err_update_filters: 5232e94d4478SAnirudh Venkataramanan if (err) { 52332f2da36eSAnirudh Venkataramanan netdev_err(netdev, "can't set MAC %pM. filter update failed\n", 5234e94d4478SAnirudh Venkataramanan mac); 5235b357d971SBrett Creeley netif_addr_lock_bh(netdev); 5236f3956ebbSJakub Kicinski eth_hw_addr_set(netdev, old_mac); 52373ba7f53fSBrett Creeley netif_addr_unlock_bh(netdev); 5238e94d4478SAnirudh Venkataramanan return err; 5239e94d4478SAnirudh Venkataramanan } 5240e94d4478SAnirudh Venkataramanan 52412f2da36eSAnirudh Venkataramanan netdev_dbg(vsi->netdev, "updated MAC address to %pM\n", 5242e94d4478SAnirudh Venkataramanan netdev->dev_addr); 5243e94d4478SAnirudh Venkataramanan 5244f9867df6SAnirudh Venkataramanan /* write new MAC address to the firmware */ 5245e94d4478SAnirudh Venkataramanan flags = ICE_AQC_MAN_MAC_UPDATE_LAA_WOL; 5246e94d4478SAnirudh Venkataramanan status = ice_aq_manage_mac_write(hw, mac, flags, NULL); 5247e94d4478SAnirudh Venkataramanan if (status) { 52480fee3577SLihong Yang netdev_err(netdev, "can't set MAC %pM. write to firmware failed error %s\n", 52490fee3577SLihong Yang mac, ice_stat_str(status)); 5250e94d4478SAnirudh Venkataramanan } 5251e94d4478SAnirudh Venkataramanan return 0; 5252e94d4478SAnirudh Venkataramanan } 5253e94d4478SAnirudh Venkataramanan 5254e94d4478SAnirudh Venkataramanan /** 5255e94d4478SAnirudh Venkataramanan * ice_set_rx_mode - NDO callback to set the netdev filters 5256e94d4478SAnirudh Venkataramanan * @netdev: network interface device structure 5257e94d4478SAnirudh Venkataramanan */ 5258e94d4478SAnirudh Venkataramanan static void ice_set_rx_mode(struct net_device *netdev) 5259e94d4478SAnirudh Venkataramanan { 5260e94d4478SAnirudh Venkataramanan struct ice_netdev_priv *np = netdev_priv(netdev); 5261e94d4478SAnirudh Venkataramanan struct ice_vsi *vsi = np->vsi; 5262e94d4478SAnirudh Venkataramanan 5263e94d4478SAnirudh Venkataramanan if (!vsi) 5264e94d4478SAnirudh Venkataramanan return; 5265e94d4478SAnirudh Venkataramanan 5266e94d4478SAnirudh Venkataramanan /* Set the flags to synchronize filters 5267e94d4478SAnirudh Venkataramanan * ndo_set_rx_mode may be triggered even without a change in netdev 5268e94d4478SAnirudh Venkataramanan * flags 5269e94d4478SAnirudh Venkataramanan */ 5270e97fb1aeSAnirudh Venkataramanan set_bit(ICE_VSI_UMAC_FLTR_CHANGED, vsi->state); 5271e97fb1aeSAnirudh Venkataramanan set_bit(ICE_VSI_MMAC_FLTR_CHANGED, vsi->state); 5272e94d4478SAnirudh Venkataramanan set_bit(ICE_FLAG_FLTR_SYNC, vsi->back->flags); 5273e94d4478SAnirudh Venkataramanan 5274e94d4478SAnirudh Venkataramanan /* schedule our worker thread which will take care of 5275e94d4478SAnirudh Venkataramanan * applying the new filter changes 5276e94d4478SAnirudh Venkataramanan */ 5277e94d4478SAnirudh Venkataramanan ice_service_task_schedule(vsi->back); 5278e94d4478SAnirudh Venkataramanan } 5279e94d4478SAnirudh Venkataramanan 5280e94d4478SAnirudh Venkataramanan /** 52811ddef455SUsha Ketineni * ice_set_tx_maxrate - NDO callback to set the maximum per-queue bitrate 52821ddef455SUsha Ketineni * @netdev: network interface device structure 52831ddef455SUsha Ketineni * @queue_index: Queue ID 52841ddef455SUsha Ketineni * @maxrate: maximum bandwidth in Mbps 52851ddef455SUsha Ketineni */ 52861ddef455SUsha Ketineni static int 52871ddef455SUsha Ketineni ice_set_tx_maxrate(struct net_device *netdev, int queue_index, u32 maxrate) 52881ddef455SUsha Ketineni { 52891ddef455SUsha Ketineni struct ice_netdev_priv *np = netdev_priv(netdev); 52901ddef455SUsha Ketineni struct ice_vsi *vsi = np->vsi; 52911ddef455SUsha Ketineni enum ice_status status; 52921ddef455SUsha Ketineni u16 q_handle; 52931ddef455SUsha Ketineni u8 tc; 52941ddef455SUsha Ketineni 52951ddef455SUsha Ketineni /* Validate maxrate requested is within permitted range */ 52961ddef455SUsha Ketineni if (maxrate && (maxrate > (ICE_SCHED_MAX_BW / 1000))) { 529719cce2c6SAnirudh Venkataramanan netdev_err(netdev, "Invalid max rate %d specified for the queue %d\n", 52981ddef455SUsha Ketineni maxrate, queue_index); 52991ddef455SUsha Ketineni return -EINVAL; 53001ddef455SUsha Ketineni } 53011ddef455SUsha Ketineni 53021ddef455SUsha Ketineni q_handle = vsi->tx_rings[queue_index]->q_handle; 53031ddef455SUsha Ketineni tc = ice_dcb_get_tc(vsi, queue_index); 53041ddef455SUsha Ketineni 53051ddef455SUsha Ketineni /* Set BW back to default, when user set maxrate to 0 */ 53061ddef455SUsha Ketineni if (!maxrate) 53071ddef455SUsha Ketineni status = ice_cfg_q_bw_dflt_lmt(vsi->port_info, vsi->idx, tc, 53081ddef455SUsha Ketineni q_handle, ICE_MAX_BW); 53091ddef455SUsha Ketineni else 53101ddef455SUsha Ketineni status = ice_cfg_q_bw_lmt(vsi->port_info, vsi->idx, tc, 53111ddef455SUsha Ketineni q_handle, ICE_MAX_BW, maxrate * 1000); 53121ddef455SUsha Ketineni if (status) { 53130fee3577SLihong Yang netdev_err(netdev, "Unable to set Tx max rate, error %s\n", 53140fee3577SLihong Yang ice_stat_str(status)); 53151ddef455SUsha Ketineni return -EIO; 53161ddef455SUsha Ketineni } 53171ddef455SUsha Ketineni 53181ddef455SUsha Ketineni return 0; 53191ddef455SUsha Ketineni } 53201ddef455SUsha Ketineni 53211ddef455SUsha Ketineni /** 5322e94d4478SAnirudh Venkataramanan * ice_fdb_add - add an entry to the hardware database 5323e94d4478SAnirudh Venkataramanan * @ndm: the input from the stack 5324e94d4478SAnirudh Venkataramanan * @tb: pointer to array of nladdr (unused) 5325e94d4478SAnirudh Venkataramanan * @dev: the net device pointer 5326e94d4478SAnirudh Venkataramanan * @addr: the MAC address entry being added 5327f9867df6SAnirudh Venkataramanan * @vid: VLAN ID 5328e94d4478SAnirudh Venkataramanan * @flags: instructions from stack about fdb operation 532999be37edSBruce Allan * @extack: netlink extended ack 5330e94d4478SAnirudh Venkataramanan */ 533199be37edSBruce Allan static int 533299be37edSBruce Allan ice_fdb_add(struct ndmsg *ndm, struct nlattr __always_unused *tb[], 533399be37edSBruce Allan struct net_device *dev, const unsigned char *addr, u16 vid, 533499be37edSBruce Allan u16 flags, struct netlink_ext_ack __always_unused *extack) 5335e94d4478SAnirudh Venkataramanan { 5336e94d4478SAnirudh Venkataramanan int err; 5337e94d4478SAnirudh Venkataramanan 5338e94d4478SAnirudh Venkataramanan if (vid) { 5339e94d4478SAnirudh Venkataramanan netdev_err(dev, "VLANs aren't supported yet for dev_uc|mc_add()\n"); 5340e94d4478SAnirudh Venkataramanan return -EINVAL; 5341e94d4478SAnirudh Venkataramanan } 5342e94d4478SAnirudh Venkataramanan if (ndm->ndm_state && !(ndm->ndm_state & NUD_PERMANENT)) { 5343e94d4478SAnirudh Venkataramanan netdev_err(dev, "FDB only supports static addresses\n"); 5344e94d4478SAnirudh Venkataramanan return -EINVAL; 5345e94d4478SAnirudh Venkataramanan } 5346e94d4478SAnirudh Venkataramanan 5347e94d4478SAnirudh Venkataramanan if (is_unicast_ether_addr(addr) || is_link_local_ether_addr(addr)) 5348e94d4478SAnirudh Venkataramanan err = dev_uc_add_excl(dev, addr); 5349e94d4478SAnirudh Venkataramanan else if (is_multicast_ether_addr(addr)) 5350e94d4478SAnirudh Venkataramanan err = dev_mc_add_excl(dev, addr); 5351e94d4478SAnirudh Venkataramanan else 5352e94d4478SAnirudh Venkataramanan err = -EINVAL; 5353e94d4478SAnirudh Venkataramanan 5354e94d4478SAnirudh Venkataramanan /* Only return duplicate errors if NLM_F_EXCL is set */ 5355e94d4478SAnirudh Venkataramanan if (err == -EEXIST && !(flags & NLM_F_EXCL)) 5356e94d4478SAnirudh Venkataramanan err = 0; 5357e94d4478SAnirudh Venkataramanan 5358e94d4478SAnirudh Venkataramanan return err; 5359e94d4478SAnirudh Venkataramanan } 5360e94d4478SAnirudh Venkataramanan 5361e94d4478SAnirudh Venkataramanan /** 5362e94d4478SAnirudh Venkataramanan * ice_fdb_del - delete an entry from the hardware database 5363e94d4478SAnirudh Venkataramanan * @ndm: the input from the stack 5364e94d4478SAnirudh Venkataramanan * @tb: pointer to array of nladdr (unused) 5365e94d4478SAnirudh Venkataramanan * @dev: the net device pointer 5366e94d4478SAnirudh Venkataramanan * @addr: the MAC address entry being added 5367f9867df6SAnirudh Venkataramanan * @vid: VLAN ID 5368e94d4478SAnirudh Venkataramanan */ 5369c8b7abddSBruce Allan static int 5370c8b7abddSBruce Allan ice_fdb_del(struct ndmsg *ndm, __always_unused struct nlattr *tb[], 5371e94d4478SAnirudh Venkataramanan struct net_device *dev, const unsigned char *addr, 5372e94d4478SAnirudh Venkataramanan __always_unused u16 vid) 5373e94d4478SAnirudh Venkataramanan { 5374e94d4478SAnirudh Venkataramanan int err; 5375e94d4478SAnirudh Venkataramanan 5376e94d4478SAnirudh Venkataramanan if (ndm->ndm_state & NUD_PERMANENT) { 5377e94d4478SAnirudh Venkataramanan netdev_err(dev, "FDB only supports static addresses\n"); 5378e94d4478SAnirudh Venkataramanan return -EINVAL; 5379e94d4478SAnirudh Venkataramanan } 5380e94d4478SAnirudh Venkataramanan 5381e94d4478SAnirudh Venkataramanan if (is_unicast_ether_addr(addr)) 5382e94d4478SAnirudh Venkataramanan err = dev_uc_del(dev, addr); 5383e94d4478SAnirudh Venkataramanan else if (is_multicast_ether_addr(addr)) 5384e94d4478SAnirudh Venkataramanan err = dev_mc_del(dev, addr); 5385e94d4478SAnirudh Venkataramanan else 5386e94d4478SAnirudh Venkataramanan err = -EINVAL; 5387e94d4478SAnirudh Venkataramanan 5388e94d4478SAnirudh Venkataramanan return err; 5389e94d4478SAnirudh Venkataramanan } 5390e94d4478SAnirudh Venkataramanan 5391e94d4478SAnirudh Venkataramanan /** 5392d76a60baSAnirudh Venkataramanan * ice_set_features - set the netdev feature flags 5393d76a60baSAnirudh Venkataramanan * @netdev: ptr to the netdev being adjusted 5394d76a60baSAnirudh Venkataramanan * @features: the feature set that the stack is suggesting 5395d76a60baSAnirudh Venkataramanan */ 5396c8b7abddSBruce Allan static int 5397c8b7abddSBruce Allan ice_set_features(struct net_device *netdev, netdev_features_t features) 5398d76a60baSAnirudh Venkataramanan { 5399d76a60baSAnirudh Venkataramanan struct ice_netdev_priv *np = netdev_priv(netdev); 5400d76a60baSAnirudh Venkataramanan struct ice_vsi *vsi = np->vsi; 54015f8cc355SHenry Tieman struct ice_pf *pf = vsi->back; 5402d76a60baSAnirudh Venkataramanan int ret = 0; 5403d76a60baSAnirudh Venkataramanan 5404462acf6aSTony Nguyen /* Don't set any netdev advanced features with device in Safe Mode */ 5405462acf6aSTony Nguyen if (ice_is_safe_mode(vsi->back)) { 540619cce2c6SAnirudh Venkataramanan dev_err(ice_pf_to_dev(vsi->back), "Device is in Safe Mode - not enabling advanced netdev features\n"); 5407462acf6aSTony Nguyen return ret; 5408462acf6aSTony Nguyen } 5409462acf6aSTony Nguyen 54105f8cc355SHenry Tieman /* Do not change setting during reset */ 54115f8cc355SHenry Tieman if (ice_is_reset_in_progress(pf->state)) { 541219cce2c6SAnirudh Venkataramanan dev_err(ice_pf_to_dev(vsi->back), "Device is resetting, changing advanced netdev features temporarily unavailable.\n"); 54135f8cc355SHenry Tieman return -EBUSY; 54145f8cc355SHenry Tieman } 54155f8cc355SHenry Tieman 54168f529ff9STony Nguyen /* Multiple features can be changed in one call so keep features in 54178f529ff9STony Nguyen * separate if/else statements to guarantee each feature is checked 54188f529ff9STony Nguyen */ 5419492af0abSMd Fahad Iqbal Polash if (features & NETIF_F_RXHASH && !(netdev->features & NETIF_F_RXHASH)) 54204fe36226SPaul M Stillwell Jr ice_vsi_manage_rss_lut(vsi, true); 5421492af0abSMd Fahad Iqbal Polash else if (!(features & NETIF_F_RXHASH) && 5422492af0abSMd Fahad Iqbal Polash netdev->features & NETIF_F_RXHASH) 54234fe36226SPaul M Stillwell Jr ice_vsi_manage_rss_lut(vsi, false); 5424492af0abSMd Fahad Iqbal Polash 5425d76a60baSAnirudh Venkataramanan if ((features & NETIF_F_HW_VLAN_CTAG_RX) && 5426d76a60baSAnirudh Venkataramanan !(netdev->features & NETIF_F_HW_VLAN_CTAG_RX)) 5427d76a60baSAnirudh Venkataramanan ret = ice_vsi_manage_vlan_stripping(vsi, true); 5428d76a60baSAnirudh Venkataramanan else if (!(features & NETIF_F_HW_VLAN_CTAG_RX) && 5429d76a60baSAnirudh Venkataramanan (netdev->features & NETIF_F_HW_VLAN_CTAG_RX)) 5430d76a60baSAnirudh Venkataramanan ret = ice_vsi_manage_vlan_stripping(vsi, false); 54318f529ff9STony Nguyen 54328f529ff9STony Nguyen if ((features & NETIF_F_HW_VLAN_CTAG_TX) && 5433d76a60baSAnirudh Venkataramanan !(netdev->features & NETIF_F_HW_VLAN_CTAG_TX)) 5434d76a60baSAnirudh Venkataramanan ret = ice_vsi_manage_vlan_insertion(vsi); 5435d76a60baSAnirudh Venkataramanan else if (!(features & NETIF_F_HW_VLAN_CTAG_TX) && 5436d76a60baSAnirudh Venkataramanan (netdev->features & NETIF_F_HW_VLAN_CTAG_TX)) 5437d76a60baSAnirudh Venkataramanan ret = ice_vsi_manage_vlan_insertion(vsi); 5438d76a60baSAnirudh Venkataramanan 54393171948eSTony Nguyen if ((features & NETIF_F_HW_VLAN_CTAG_FILTER) && 54403171948eSTony Nguyen !(netdev->features & NETIF_F_HW_VLAN_CTAG_FILTER)) 54413171948eSTony Nguyen ret = ice_cfg_vlan_pruning(vsi, true, false); 54423171948eSTony Nguyen else if (!(features & NETIF_F_HW_VLAN_CTAG_FILTER) && 54433171948eSTony Nguyen (netdev->features & NETIF_F_HW_VLAN_CTAG_FILTER)) 54443171948eSTony Nguyen ret = ice_cfg_vlan_pruning(vsi, false, false); 54453171948eSTony Nguyen 5446148beb61SHenry Tieman if ((features & NETIF_F_NTUPLE) && 544728bf2672SBrett Creeley !(netdev->features & NETIF_F_NTUPLE)) { 5448148beb61SHenry Tieman ice_vsi_manage_fdir(vsi, true); 544928bf2672SBrett Creeley ice_init_arfs(vsi); 545028bf2672SBrett Creeley } else if (!(features & NETIF_F_NTUPLE) && 545128bf2672SBrett Creeley (netdev->features & NETIF_F_NTUPLE)) { 5452148beb61SHenry Tieman ice_vsi_manage_fdir(vsi, false); 545328bf2672SBrett Creeley ice_clear_arfs(vsi); 545428bf2672SBrett Creeley } 5455148beb61SHenry Tieman 5456d76a60baSAnirudh Venkataramanan return ret; 5457d76a60baSAnirudh Venkataramanan } 5458d76a60baSAnirudh Venkataramanan 5459d76a60baSAnirudh Venkataramanan /** 5460f9867df6SAnirudh Venkataramanan * ice_vsi_vlan_setup - Setup VLAN offload properties on a VSI 5461f9867df6SAnirudh Venkataramanan * @vsi: VSI to setup VLAN properties for 5462d76a60baSAnirudh Venkataramanan */ 5463d76a60baSAnirudh Venkataramanan static int ice_vsi_vlan_setup(struct ice_vsi *vsi) 5464d76a60baSAnirudh Venkataramanan { 5465d76a60baSAnirudh Venkataramanan int ret = 0; 5466d76a60baSAnirudh Venkataramanan 5467d76a60baSAnirudh Venkataramanan if (vsi->netdev->features & NETIF_F_HW_VLAN_CTAG_RX) 5468d76a60baSAnirudh Venkataramanan ret = ice_vsi_manage_vlan_stripping(vsi, true); 5469d76a60baSAnirudh Venkataramanan if (vsi->netdev->features & NETIF_F_HW_VLAN_CTAG_TX) 5470d76a60baSAnirudh Venkataramanan ret = ice_vsi_manage_vlan_insertion(vsi); 5471d76a60baSAnirudh Venkataramanan 5472d76a60baSAnirudh Venkataramanan return ret; 5473d76a60baSAnirudh Venkataramanan } 5474d76a60baSAnirudh Venkataramanan 5475d76a60baSAnirudh Venkataramanan /** 5476cdedef59SAnirudh Venkataramanan * ice_vsi_cfg - Setup the VSI 5477cdedef59SAnirudh Venkataramanan * @vsi: the VSI being configured 5478cdedef59SAnirudh Venkataramanan * 5479cdedef59SAnirudh Venkataramanan * Return 0 on success and negative value on error 5480cdedef59SAnirudh Venkataramanan */ 54810e674aebSAnirudh Venkataramanan int ice_vsi_cfg(struct ice_vsi *vsi) 5482cdedef59SAnirudh Venkataramanan { 5483cdedef59SAnirudh Venkataramanan int err; 5484cdedef59SAnirudh Venkataramanan 5485c7f2c42bSAnirudh Venkataramanan if (vsi->netdev) { 5486e94d4478SAnirudh Venkataramanan ice_set_rx_mode(vsi->netdev); 54879ecd25c2SAnirudh Venkataramanan 54889ecd25c2SAnirudh Venkataramanan err = ice_vsi_vlan_setup(vsi); 54899ecd25c2SAnirudh Venkataramanan 5490d76a60baSAnirudh Venkataramanan if (err) 5491d76a60baSAnirudh Venkataramanan return err; 5492c7f2c42bSAnirudh Venkataramanan } 5493a629cf0aSAnirudh Venkataramanan ice_vsi_cfg_dcb_rings(vsi); 549403f7a986SAnirudh Venkataramanan 549503f7a986SAnirudh Venkataramanan err = ice_vsi_cfg_lan_txqs(vsi); 5496efc2214bSMaciej Fijalkowski if (!err && ice_is_xdp_ena_vsi(vsi)) 5497efc2214bSMaciej Fijalkowski err = ice_vsi_cfg_xdp_txqs(vsi); 5498cdedef59SAnirudh Venkataramanan if (!err) 5499cdedef59SAnirudh Venkataramanan err = ice_vsi_cfg_rxqs(vsi); 5500cdedef59SAnirudh Venkataramanan 5501cdedef59SAnirudh Venkataramanan return err; 5502cdedef59SAnirudh Venkataramanan } 5503cdedef59SAnirudh Venkataramanan 5504cdf1f1f1SJacob Keller /* THEORY OF MODERATION: 5505d8eb7ad5SJesse Brandeburg * The ice driver hardware works differently than the hardware that DIMLIB was 5506cdf1f1f1SJacob Keller * originally made for. ice hardware doesn't have packet count limits that 5507cdf1f1f1SJacob Keller * can trigger an interrupt, but it *does* have interrupt rate limit support, 5508d8eb7ad5SJesse Brandeburg * which is hard-coded to a limit of 250,000 ints/second. 5509d8eb7ad5SJesse Brandeburg * If not using dynamic moderation, the INTRL value can be modified 5510d8eb7ad5SJesse Brandeburg * by ethtool rx-usecs-high. 5511cdf1f1f1SJacob Keller */ 5512cdf1f1f1SJacob Keller struct ice_dim { 5513cdf1f1f1SJacob Keller /* the throttle rate for interrupts, basically worst case delay before 5514cdf1f1f1SJacob Keller * an initial interrupt fires, value is stored in microseconds. 5515cdf1f1f1SJacob Keller */ 5516cdf1f1f1SJacob Keller u16 itr; 5517cdf1f1f1SJacob Keller }; 5518cdf1f1f1SJacob Keller 5519cdf1f1f1SJacob Keller /* Make a different profile for Rx that doesn't allow quite so aggressive 5520d8eb7ad5SJesse Brandeburg * moderation at the high end (it maxes out at 126us or about 8k interrupts a 5521d8eb7ad5SJesse Brandeburg * second. 5522cdf1f1f1SJacob Keller */ 5523cdf1f1f1SJacob Keller static const struct ice_dim rx_profile[] = { 5524d8eb7ad5SJesse Brandeburg {2}, /* 500,000 ints/s, capped at 250K by INTRL */ 5525d8eb7ad5SJesse Brandeburg {8}, /* 125,000 ints/s */ 5526d8eb7ad5SJesse Brandeburg {16}, /* 62,500 ints/s */ 5527d8eb7ad5SJesse Brandeburg {62}, /* 16,129 ints/s */ 5528d8eb7ad5SJesse Brandeburg {126} /* 7,936 ints/s */ 5529cdf1f1f1SJacob Keller }; 5530cdf1f1f1SJacob Keller 5531cdf1f1f1SJacob Keller /* The transmit profile, which has the same sorts of values 5532cdf1f1f1SJacob Keller * as the previous struct 5533cdf1f1f1SJacob Keller */ 5534cdf1f1f1SJacob Keller static const struct ice_dim tx_profile[] = { 5535d8eb7ad5SJesse Brandeburg {2}, /* 500,000 ints/s, capped at 250K by INTRL */ 5536d8eb7ad5SJesse Brandeburg {8}, /* 125,000 ints/s */ 5537d8eb7ad5SJesse Brandeburg {40}, /* 16,125 ints/s */ 5538d8eb7ad5SJesse Brandeburg {128}, /* 7,812 ints/s */ 5539d8eb7ad5SJesse Brandeburg {256} /* 3,906 ints/s */ 5540cdf1f1f1SJacob Keller }; 5541cdf1f1f1SJacob Keller 5542cdf1f1f1SJacob Keller static void ice_tx_dim_work(struct work_struct *work) 5543cdf1f1f1SJacob Keller { 5544cdf1f1f1SJacob Keller struct ice_ring_container *rc; 5545cdf1f1f1SJacob Keller struct dim *dim; 5546d8eb7ad5SJesse Brandeburg u16 itr; 5547cdf1f1f1SJacob Keller 5548cdf1f1f1SJacob Keller dim = container_of(work, struct dim, work); 5549d8eb7ad5SJesse Brandeburg rc = (struct ice_ring_container *)dim->priv; 5550cdf1f1f1SJacob Keller 5551d8eb7ad5SJesse Brandeburg WARN_ON(dim->profile_ix >= ARRAY_SIZE(tx_profile)); 5552cdf1f1f1SJacob Keller 5553cdf1f1f1SJacob Keller /* look up the values in our local table */ 5554cdf1f1f1SJacob Keller itr = tx_profile[dim->profile_ix].itr; 5555cdf1f1f1SJacob Keller 5556d8eb7ad5SJesse Brandeburg ice_trace(tx_dim_work, container_of(rc, struct ice_q_vector, tx), dim); 5557cdf1f1f1SJacob Keller ice_write_itr(rc, itr); 5558cdf1f1f1SJacob Keller 5559cdf1f1f1SJacob Keller dim->state = DIM_START_MEASURE; 5560cdf1f1f1SJacob Keller } 5561cdf1f1f1SJacob Keller 5562cdf1f1f1SJacob Keller static void ice_rx_dim_work(struct work_struct *work) 5563cdf1f1f1SJacob Keller { 5564cdf1f1f1SJacob Keller struct ice_ring_container *rc; 5565cdf1f1f1SJacob Keller struct dim *dim; 5566d8eb7ad5SJesse Brandeburg u16 itr; 5567cdf1f1f1SJacob Keller 5568cdf1f1f1SJacob Keller dim = container_of(work, struct dim, work); 5569d8eb7ad5SJesse Brandeburg rc = (struct ice_ring_container *)dim->priv; 5570cdf1f1f1SJacob Keller 5571d8eb7ad5SJesse Brandeburg WARN_ON(dim->profile_ix >= ARRAY_SIZE(rx_profile)); 5572cdf1f1f1SJacob Keller 5573cdf1f1f1SJacob Keller /* look up the values in our local table */ 5574cdf1f1f1SJacob Keller itr = rx_profile[dim->profile_ix].itr; 5575cdf1f1f1SJacob Keller 5576d8eb7ad5SJesse Brandeburg ice_trace(rx_dim_work, container_of(rc, struct ice_q_vector, rx), dim); 5577cdf1f1f1SJacob Keller ice_write_itr(rc, itr); 5578cdf1f1f1SJacob Keller 5579cdf1f1f1SJacob Keller dim->state = DIM_START_MEASURE; 5580cdf1f1f1SJacob Keller } 5581cdf1f1f1SJacob Keller 5582d8eb7ad5SJesse Brandeburg #define ICE_DIM_DEFAULT_PROFILE_IX 1 5583d8eb7ad5SJesse Brandeburg 5584d8eb7ad5SJesse Brandeburg /** 5585d8eb7ad5SJesse Brandeburg * ice_init_moderation - set up interrupt moderation 5586d8eb7ad5SJesse Brandeburg * @q_vector: the vector containing rings to be configured 5587d8eb7ad5SJesse Brandeburg * 5588d8eb7ad5SJesse Brandeburg * Set up interrupt moderation registers, with the intent to do the right thing 5589d8eb7ad5SJesse Brandeburg * when called from reset or from probe, and whether or not dynamic moderation 5590d8eb7ad5SJesse Brandeburg * is enabled or not. Take special care to write all the registers in both 5591d8eb7ad5SJesse Brandeburg * dynamic moderation mode or not in order to make sure hardware is in a known 5592d8eb7ad5SJesse Brandeburg * state. 5593d8eb7ad5SJesse Brandeburg */ 5594d8eb7ad5SJesse Brandeburg static void ice_init_moderation(struct ice_q_vector *q_vector) 5595d8eb7ad5SJesse Brandeburg { 5596d8eb7ad5SJesse Brandeburg struct ice_ring_container *rc; 5597d8eb7ad5SJesse Brandeburg bool tx_dynamic, rx_dynamic; 5598d8eb7ad5SJesse Brandeburg 5599d8eb7ad5SJesse Brandeburg rc = &q_vector->tx; 5600d8eb7ad5SJesse Brandeburg INIT_WORK(&rc->dim.work, ice_tx_dim_work); 5601d8eb7ad5SJesse Brandeburg rc->dim.mode = DIM_CQ_PERIOD_MODE_START_FROM_EQE; 5602d8eb7ad5SJesse Brandeburg rc->dim.profile_ix = ICE_DIM_DEFAULT_PROFILE_IX; 5603d8eb7ad5SJesse Brandeburg rc->dim.priv = rc; 5604d8eb7ad5SJesse Brandeburg tx_dynamic = ITR_IS_DYNAMIC(rc); 5605d8eb7ad5SJesse Brandeburg 5606d8eb7ad5SJesse Brandeburg /* set the initial TX ITR to match the above */ 5607d8eb7ad5SJesse Brandeburg ice_write_itr(rc, tx_dynamic ? 5608d8eb7ad5SJesse Brandeburg tx_profile[rc->dim.profile_ix].itr : rc->itr_setting); 5609d8eb7ad5SJesse Brandeburg 5610d8eb7ad5SJesse Brandeburg rc = &q_vector->rx; 5611d8eb7ad5SJesse Brandeburg INIT_WORK(&rc->dim.work, ice_rx_dim_work); 5612d8eb7ad5SJesse Brandeburg rc->dim.mode = DIM_CQ_PERIOD_MODE_START_FROM_EQE; 5613d8eb7ad5SJesse Brandeburg rc->dim.profile_ix = ICE_DIM_DEFAULT_PROFILE_IX; 5614d8eb7ad5SJesse Brandeburg rc->dim.priv = rc; 5615d8eb7ad5SJesse Brandeburg rx_dynamic = ITR_IS_DYNAMIC(rc); 5616d8eb7ad5SJesse Brandeburg 5617d8eb7ad5SJesse Brandeburg /* set the initial RX ITR to match the above */ 5618d8eb7ad5SJesse Brandeburg ice_write_itr(rc, rx_dynamic ? rx_profile[rc->dim.profile_ix].itr : 5619d8eb7ad5SJesse Brandeburg rc->itr_setting); 5620d8eb7ad5SJesse Brandeburg 5621d8eb7ad5SJesse Brandeburg ice_set_q_vector_intrl(q_vector); 5622d8eb7ad5SJesse Brandeburg } 5623d8eb7ad5SJesse Brandeburg 5624cdedef59SAnirudh Venkataramanan /** 56252b245cb2SAnirudh Venkataramanan * ice_napi_enable_all - Enable NAPI for all q_vectors in the VSI 56262b245cb2SAnirudh Venkataramanan * @vsi: the VSI being configured 56272b245cb2SAnirudh Venkataramanan */ 56282b245cb2SAnirudh Venkataramanan static void ice_napi_enable_all(struct ice_vsi *vsi) 56292b245cb2SAnirudh Venkataramanan { 56302b245cb2SAnirudh Venkataramanan int q_idx; 56312b245cb2SAnirudh Venkataramanan 56322b245cb2SAnirudh Venkataramanan if (!vsi->netdev) 56332b245cb2SAnirudh Venkataramanan return; 56342b245cb2SAnirudh Venkataramanan 56350c2561c8SBrett Creeley ice_for_each_q_vector(vsi, q_idx) { 5636eec90376SYoung Xiao struct ice_q_vector *q_vector = vsi->q_vectors[q_idx]; 5637eec90376SYoung Xiao 5638d8eb7ad5SJesse Brandeburg ice_init_moderation(q_vector); 5639cdf1f1f1SJacob Keller 5640e72bba21SMaciej Fijalkowski if (q_vector->rx.rx_ring || q_vector->tx.tx_ring) 5641eec90376SYoung Xiao napi_enable(&q_vector->napi); 5642eec90376SYoung Xiao } 56432b245cb2SAnirudh Venkataramanan } 56442b245cb2SAnirudh Venkataramanan 56452b245cb2SAnirudh Venkataramanan /** 5646cdedef59SAnirudh Venkataramanan * ice_up_complete - Finish the last steps of bringing up a connection 5647cdedef59SAnirudh Venkataramanan * @vsi: The VSI being configured 5648cdedef59SAnirudh Venkataramanan * 5649cdedef59SAnirudh Venkataramanan * Return 0 on success and negative value on error 5650cdedef59SAnirudh Venkataramanan */ 5651cdedef59SAnirudh Venkataramanan static int ice_up_complete(struct ice_vsi *vsi) 5652cdedef59SAnirudh Venkataramanan { 5653cdedef59SAnirudh Venkataramanan struct ice_pf *pf = vsi->back; 5654cdedef59SAnirudh Venkataramanan int err; 5655cdedef59SAnirudh Venkataramanan 5656cdedef59SAnirudh Venkataramanan ice_vsi_cfg_msix(vsi); 5657cdedef59SAnirudh Venkataramanan 5658cdedef59SAnirudh Venkataramanan /* Enable only Rx rings, Tx rings were enabled by the FW when the 5659cdedef59SAnirudh Venkataramanan * Tx queue group list was configured and the context bits were 5660cdedef59SAnirudh Venkataramanan * programmed using ice_vsi_cfg_txqs 5661cdedef59SAnirudh Venkataramanan */ 566213a6233bSBrett Creeley err = ice_vsi_start_all_rx_rings(vsi); 5663cdedef59SAnirudh Venkataramanan if (err) 5664cdedef59SAnirudh Venkataramanan return err; 5665cdedef59SAnirudh Venkataramanan 5666e97fb1aeSAnirudh Venkataramanan clear_bit(ICE_VSI_DOWN, vsi->state); 56672b245cb2SAnirudh Venkataramanan ice_napi_enable_all(vsi); 5668cdedef59SAnirudh Venkataramanan ice_vsi_ena_irq(vsi); 5669cdedef59SAnirudh Venkataramanan 5670cdedef59SAnirudh Venkataramanan if (vsi->port_info && 5671cdedef59SAnirudh Venkataramanan (vsi->port_info->phy.link_info.link_info & ICE_AQ_LINK_UP) && 5672cdedef59SAnirudh Venkataramanan vsi->netdev) { 5673cdedef59SAnirudh Venkataramanan ice_print_link_msg(vsi, true); 5674cdedef59SAnirudh Venkataramanan netif_tx_start_all_queues(vsi->netdev); 5675cdedef59SAnirudh Venkataramanan netif_carrier_on(vsi->netdev); 5676cdedef59SAnirudh Venkataramanan } 5677cdedef59SAnirudh Venkataramanan 5678cdedef59SAnirudh Venkataramanan ice_service_task_schedule(pf); 5679cdedef59SAnirudh Venkataramanan 56801b5c19c7SBruce Allan return 0; 5681cdedef59SAnirudh Venkataramanan } 5682cdedef59SAnirudh Venkataramanan 5683cdedef59SAnirudh Venkataramanan /** 5684fcea6f3dSAnirudh Venkataramanan * ice_up - Bring the connection back up after being down 5685fcea6f3dSAnirudh Venkataramanan * @vsi: VSI being configured 5686fcea6f3dSAnirudh Venkataramanan */ 5687fcea6f3dSAnirudh Venkataramanan int ice_up(struct ice_vsi *vsi) 5688fcea6f3dSAnirudh Venkataramanan { 5689fcea6f3dSAnirudh Venkataramanan int err; 5690fcea6f3dSAnirudh Venkataramanan 5691fcea6f3dSAnirudh Venkataramanan err = ice_vsi_cfg(vsi); 5692fcea6f3dSAnirudh Venkataramanan if (!err) 5693fcea6f3dSAnirudh Venkataramanan err = ice_up_complete(vsi); 5694fcea6f3dSAnirudh Venkataramanan 5695fcea6f3dSAnirudh Venkataramanan return err; 5696fcea6f3dSAnirudh Venkataramanan } 5697fcea6f3dSAnirudh Venkataramanan 5698fcea6f3dSAnirudh Venkataramanan /** 5699fcea6f3dSAnirudh Venkataramanan * ice_fetch_u64_stats_per_ring - get packets and bytes stats per ring 5700e72bba21SMaciej Fijalkowski * @syncp: pointer to u64_stats_sync 5701e72bba21SMaciej Fijalkowski * @stats: stats that pkts and bytes count will be taken from 5702fcea6f3dSAnirudh Venkataramanan * @pkts: packets stats counter 5703fcea6f3dSAnirudh Venkataramanan * @bytes: bytes stats counter 5704fcea6f3dSAnirudh Venkataramanan * 5705fcea6f3dSAnirudh Venkataramanan * This function fetches stats from the ring considering the atomic operations 5706fcea6f3dSAnirudh Venkataramanan * that needs to be performed to read u64 values in 32 bit machine. 5707fcea6f3dSAnirudh Venkataramanan */ 5708c8b7abddSBruce Allan static void 5709e72bba21SMaciej Fijalkowski ice_fetch_u64_stats_per_ring(struct u64_stats_sync *syncp, struct ice_q_stats stats, 5710e72bba21SMaciej Fijalkowski u64 *pkts, u64 *bytes) 5711fcea6f3dSAnirudh Venkataramanan { 5712fcea6f3dSAnirudh Venkataramanan unsigned int start; 5713fcea6f3dSAnirudh Venkataramanan 5714fcea6f3dSAnirudh Venkataramanan do { 5715e72bba21SMaciej Fijalkowski start = u64_stats_fetch_begin_irq(syncp); 5716e72bba21SMaciej Fijalkowski *pkts = stats.pkts; 5717e72bba21SMaciej Fijalkowski *bytes = stats.bytes; 5718e72bba21SMaciej Fijalkowski } while (u64_stats_fetch_retry_irq(syncp, start)); 5719fcea6f3dSAnirudh Venkataramanan } 5720fcea6f3dSAnirudh Venkataramanan 5721fcea6f3dSAnirudh Venkataramanan /** 572249d358e0SMarta Plantykow * ice_update_vsi_tx_ring_stats - Update VSI Tx ring stats counters 572349d358e0SMarta Plantykow * @vsi: the VSI to be updated 572449d358e0SMarta Plantykow * @rings: rings to work on 572549d358e0SMarta Plantykow * @count: number of rings 572649d358e0SMarta Plantykow */ 572749d358e0SMarta Plantykow static void 5728e72bba21SMaciej Fijalkowski ice_update_vsi_tx_ring_stats(struct ice_vsi *vsi, struct ice_tx_ring **rings, 572949d358e0SMarta Plantykow u16 count) 573049d358e0SMarta Plantykow { 573149d358e0SMarta Plantykow struct rtnl_link_stats64 *vsi_stats = &vsi->net_stats; 573249d358e0SMarta Plantykow u16 i; 573349d358e0SMarta Plantykow 573449d358e0SMarta Plantykow for (i = 0; i < count; i++) { 5735e72bba21SMaciej Fijalkowski struct ice_tx_ring *ring; 5736e72bba21SMaciej Fijalkowski u64 pkts = 0, bytes = 0; 573749d358e0SMarta Plantykow 573849d358e0SMarta Plantykow ring = READ_ONCE(rings[i]); 5739e72bba21SMaciej Fijalkowski if (ring) 5740e72bba21SMaciej Fijalkowski ice_fetch_u64_stats_per_ring(&ring->syncp, ring->stats, &pkts, &bytes); 574149d358e0SMarta Plantykow vsi_stats->tx_packets += pkts; 574249d358e0SMarta Plantykow vsi_stats->tx_bytes += bytes; 574349d358e0SMarta Plantykow vsi->tx_restart += ring->tx_stats.restart_q; 574449d358e0SMarta Plantykow vsi->tx_busy += ring->tx_stats.tx_busy; 574549d358e0SMarta Plantykow vsi->tx_linearize += ring->tx_stats.tx_linearize; 574649d358e0SMarta Plantykow } 574749d358e0SMarta Plantykow } 574849d358e0SMarta Plantykow 574949d358e0SMarta Plantykow /** 5750fcea6f3dSAnirudh Venkataramanan * ice_update_vsi_ring_stats - Update VSI stats counters 5751fcea6f3dSAnirudh Venkataramanan * @vsi: the VSI to be updated 5752fcea6f3dSAnirudh Venkataramanan */ 5753fcea6f3dSAnirudh Venkataramanan static void ice_update_vsi_ring_stats(struct ice_vsi *vsi) 5754fcea6f3dSAnirudh Venkataramanan { 5755fcea6f3dSAnirudh Venkataramanan struct rtnl_link_stats64 *vsi_stats = &vsi->net_stats; 5756fcea6f3dSAnirudh Venkataramanan u64 pkts, bytes; 5757fcea6f3dSAnirudh Venkataramanan int i; 5758fcea6f3dSAnirudh Venkataramanan 5759fcea6f3dSAnirudh Venkataramanan /* reset netdev stats */ 5760fcea6f3dSAnirudh Venkataramanan vsi_stats->tx_packets = 0; 5761fcea6f3dSAnirudh Venkataramanan vsi_stats->tx_bytes = 0; 5762fcea6f3dSAnirudh Venkataramanan vsi_stats->rx_packets = 0; 5763fcea6f3dSAnirudh Venkataramanan vsi_stats->rx_bytes = 0; 5764fcea6f3dSAnirudh Venkataramanan 5765fcea6f3dSAnirudh Venkataramanan /* reset non-netdev (extended) stats */ 5766fcea6f3dSAnirudh Venkataramanan vsi->tx_restart = 0; 5767fcea6f3dSAnirudh Venkataramanan vsi->tx_busy = 0; 5768fcea6f3dSAnirudh Venkataramanan vsi->tx_linearize = 0; 5769fcea6f3dSAnirudh Venkataramanan vsi->rx_buf_failed = 0; 5770fcea6f3dSAnirudh Venkataramanan vsi->rx_page_failed = 0; 5771fcea6f3dSAnirudh Venkataramanan 5772fcea6f3dSAnirudh Venkataramanan rcu_read_lock(); 5773fcea6f3dSAnirudh Venkataramanan 5774fcea6f3dSAnirudh Venkataramanan /* update Tx rings counters */ 577549d358e0SMarta Plantykow ice_update_vsi_tx_ring_stats(vsi, vsi->tx_rings, vsi->num_txq); 5776fcea6f3dSAnirudh Venkataramanan 5777fcea6f3dSAnirudh Venkataramanan /* update Rx rings counters */ 5778fcea6f3dSAnirudh Venkataramanan ice_for_each_rxq(vsi, i) { 5779e72bba21SMaciej Fijalkowski struct ice_rx_ring *ring = READ_ONCE(vsi->rx_rings[i]); 5780b6b0501dSPaul M Stillwell Jr 5781e72bba21SMaciej Fijalkowski ice_fetch_u64_stats_per_ring(&ring->syncp, ring->stats, &pkts, &bytes); 5782fcea6f3dSAnirudh Venkataramanan vsi_stats->rx_packets += pkts; 5783fcea6f3dSAnirudh Venkataramanan vsi_stats->rx_bytes += bytes; 5784fcea6f3dSAnirudh Venkataramanan vsi->rx_buf_failed += ring->rx_stats.alloc_buf_failed; 5785fcea6f3dSAnirudh Venkataramanan vsi->rx_page_failed += ring->rx_stats.alloc_page_failed; 5786fcea6f3dSAnirudh Venkataramanan } 5787fcea6f3dSAnirudh Venkataramanan 578849d358e0SMarta Plantykow /* update XDP Tx rings counters */ 578949d358e0SMarta Plantykow if (ice_is_xdp_ena_vsi(vsi)) 579049d358e0SMarta Plantykow ice_update_vsi_tx_ring_stats(vsi, vsi->xdp_rings, 579149d358e0SMarta Plantykow vsi->num_xdp_txq); 579249d358e0SMarta Plantykow 5793fcea6f3dSAnirudh Venkataramanan rcu_read_unlock(); 5794fcea6f3dSAnirudh Venkataramanan } 5795fcea6f3dSAnirudh Venkataramanan 5796fcea6f3dSAnirudh Venkataramanan /** 5797fcea6f3dSAnirudh Venkataramanan * ice_update_vsi_stats - Update VSI stats counters 5798fcea6f3dSAnirudh Venkataramanan * @vsi: the VSI to be updated 5799fcea6f3dSAnirudh Venkataramanan */ 58005a4a8673SBruce Allan void ice_update_vsi_stats(struct ice_vsi *vsi) 5801fcea6f3dSAnirudh Venkataramanan { 5802fcea6f3dSAnirudh Venkataramanan struct rtnl_link_stats64 *cur_ns = &vsi->net_stats; 5803fcea6f3dSAnirudh Venkataramanan struct ice_eth_stats *cur_es = &vsi->eth_stats; 5804fcea6f3dSAnirudh Venkataramanan struct ice_pf *pf = vsi->back; 5805fcea6f3dSAnirudh Venkataramanan 5806e97fb1aeSAnirudh Venkataramanan if (test_bit(ICE_VSI_DOWN, vsi->state) || 58077e408e07SAnirudh Venkataramanan test_bit(ICE_CFG_BUSY, pf->state)) 5808fcea6f3dSAnirudh Venkataramanan return; 5809fcea6f3dSAnirudh Venkataramanan 5810fcea6f3dSAnirudh Venkataramanan /* get stats as recorded by Tx/Rx rings */ 5811fcea6f3dSAnirudh Venkataramanan ice_update_vsi_ring_stats(vsi); 5812fcea6f3dSAnirudh Venkataramanan 5813fcea6f3dSAnirudh Venkataramanan /* get VSI stats as recorded by the hardware */ 5814fcea6f3dSAnirudh Venkataramanan ice_update_eth_stats(vsi); 5815fcea6f3dSAnirudh Venkataramanan 5816fcea6f3dSAnirudh Venkataramanan cur_ns->tx_errors = cur_es->tx_errors; 581751fe27e1SAnirudh Venkataramanan cur_ns->rx_dropped = cur_es->rx_discards; 5818fcea6f3dSAnirudh Venkataramanan cur_ns->tx_dropped = cur_es->tx_discards; 5819fcea6f3dSAnirudh Venkataramanan cur_ns->multicast = cur_es->rx_multicast; 5820fcea6f3dSAnirudh Venkataramanan 5821fcea6f3dSAnirudh Venkataramanan /* update some more netdev stats if this is main VSI */ 5822fcea6f3dSAnirudh Venkataramanan if (vsi->type == ICE_VSI_PF) { 5823fcea6f3dSAnirudh Venkataramanan cur_ns->rx_crc_errors = pf->stats.crc_errors; 5824fcea6f3dSAnirudh Venkataramanan cur_ns->rx_errors = pf->stats.crc_errors + 58254f1fe43cSBrett Creeley pf->stats.illegal_bytes + 58264f1fe43cSBrett Creeley pf->stats.rx_len_errors + 58274f1fe43cSBrett Creeley pf->stats.rx_undersize + 58284f1fe43cSBrett Creeley pf->hw_csum_rx_error + 58294f1fe43cSBrett Creeley pf->stats.rx_jabber + 58304f1fe43cSBrett Creeley pf->stats.rx_fragments + 58314f1fe43cSBrett Creeley pf->stats.rx_oversize; 5832fcea6f3dSAnirudh Venkataramanan cur_ns->rx_length_errors = pf->stats.rx_len_errors; 583356923ab6SBrett Creeley /* record drops from the port level */ 583456923ab6SBrett Creeley cur_ns->rx_missed_errors = pf->stats.eth.rx_discards; 5835fcea6f3dSAnirudh Venkataramanan } 5836fcea6f3dSAnirudh Venkataramanan } 5837fcea6f3dSAnirudh Venkataramanan 5838fcea6f3dSAnirudh Venkataramanan /** 5839fcea6f3dSAnirudh Venkataramanan * ice_update_pf_stats - Update PF port stats counters 5840fcea6f3dSAnirudh Venkataramanan * @pf: PF whose stats needs to be updated 5841fcea6f3dSAnirudh Venkataramanan */ 58425a4a8673SBruce Allan void ice_update_pf_stats(struct ice_pf *pf) 5843fcea6f3dSAnirudh Venkataramanan { 5844fcea6f3dSAnirudh Venkataramanan struct ice_hw_port_stats *prev_ps, *cur_ps; 5845fcea6f3dSAnirudh Venkataramanan struct ice_hw *hw = &pf->hw; 58464ab95646SHenry Tieman u16 fd_ctr_base; 58479e7a5d17SUsha Ketineni u8 port; 5848fcea6f3dSAnirudh Venkataramanan 58499e7a5d17SUsha Ketineni port = hw->port_info->lport; 5850fcea6f3dSAnirudh Venkataramanan prev_ps = &pf->stats_prev; 5851fcea6f3dSAnirudh Venkataramanan cur_ps = &pf->stats; 5852fcea6f3dSAnirudh Venkataramanan 58539e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_GORCL(port), pf->stat_prev_loaded, 585436517fd3SJacob Keller &prev_ps->eth.rx_bytes, 5855fcea6f3dSAnirudh Venkataramanan &cur_ps->eth.rx_bytes); 5856fcea6f3dSAnirudh Venkataramanan 58579e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_UPRCL(port), pf->stat_prev_loaded, 585836517fd3SJacob Keller &prev_ps->eth.rx_unicast, 5859fcea6f3dSAnirudh Venkataramanan &cur_ps->eth.rx_unicast); 5860fcea6f3dSAnirudh Venkataramanan 58619e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_MPRCL(port), pf->stat_prev_loaded, 586236517fd3SJacob Keller &prev_ps->eth.rx_multicast, 5863fcea6f3dSAnirudh Venkataramanan &cur_ps->eth.rx_multicast); 5864fcea6f3dSAnirudh Venkataramanan 58659e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_BPRCL(port), pf->stat_prev_loaded, 586636517fd3SJacob Keller &prev_ps->eth.rx_broadcast, 5867fcea6f3dSAnirudh Venkataramanan &cur_ps->eth.rx_broadcast); 5868fcea6f3dSAnirudh Venkataramanan 586956923ab6SBrett Creeley ice_stat_update32(hw, PRTRPB_RDPC, pf->stat_prev_loaded, 587056923ab6SBrett Creeley &prev_ps->eth.rx_discards, 587156923ab6SBrett Creeley &cur_ps->eth.rx_discards); 587256923ab6SBrett Creeley 58739e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_GOTCL(port), pf->stat_prev_loaded, 587436517fd3SJacob Keller &prev_ps->eth.tx_bytes, 5875fcea6f3dSAnirudh Venkataramanan &cur_ps->eth.tx_bytes); 5876fcea6f3dSAnirudh Venkataramanan 58779e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_UPTCL(port), pf->stat_prev_loaded, 587836517fd3SJacob Keller &prev_ps->eth.tx_unicast, 5879fcea6f3dSAnirudh Venkataramanan &cur_ps->eth.tx_unicast); 5880fcea6f3dSAnirudh Venkataramanan 58819e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_MPTCL(port), pf->stat_prev_loaded, 588236517fd3SJacob Keller &prev_ps->eth.tx_multicast, 5883fcea6f3dSAnirudh Venkataramanan &cur_ps->eth.tx_multicast); 5884fcea6f3dSAnirudh Venkataramanan 58859e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_BPTCL(port), pf->stat_prev_loaded, 588636517fd3SJacob Keller &prev_ps->eth.tx_broadcast, 5887fcea6f3dSAnirudh Venkataramanan &cur_ps->eth.tx_broadcast); 5888fcea6f3dSAnirudh Venkataramanan 58899e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_TDOLD(port), pf->stat_prev_loaded, 5890fcea6f3dSAnirudh Venkataramanan &prev_ps->tx_dropped_link_down, 5891fcea6f3dSAnirudh Venkataramanan &cur_ps->tx_dropped_link_down); 5892fcea6f3dSAnirudh Venkataramanan 58939e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PRC64L(port), pf->stat_prev_loaded, 589436517fd3SJacob Keller &prev_ps->rx_size_64, &cur_ps->rx_size_64); 5895fcea6f3dSAnirudh Venkataramanan 58969e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PRC127L(port), pf->stat_prev_loaded, 589736517fd3SJacob Keller &prev_ps->rx_size_127, &cur_ps->rx_size_127); 5898fcea6f3dSAnirudh Venkataramanan 58999e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PRC255L(port), pf->stat_prev_loaded, 590036517fd3SJacob Keller &prev_ps->rx_size_255, &cur_ps->rx_size_255); 5901fcea6f3dSAnirudh Venkataramanan 59029e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PRC511L(port), pf->stat_prev_loaded, 590336517fd3SJacob Keller &prev_ps->rx_size_511, &cur_ps->rx_size_511); 5904fcea6f3dSAnirudh Venkataramanan 59059e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PRC1023L(port), pf->stat_prev_loaded, 5906fcea6f3dSAnirudh Venkataramanan &prev_ps->rx_size_1023, &cur_ps->rx_size_1023); 5907fcea6f3dSAnirudh Venkataramanan 59089e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PRC1522L(port), pf->stat_prev_loaded, 5909fcea6f3dSAnirudh Venkataramanan &prev_ps->rx_size_1522, &cur_ps->rx_size_1522); 5910fcea6f3dSAnirudh Venkataramanan 59119e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PRC9522L(port), pf->stat_prev_loaded, 5912fcea6f3dSAnirudh Venkataramanan &prev_ps->rx_size_big, &cur_ps->rx_size_big); 5913fcea6f3dSAnirudh Venkataramanan 59149e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PTC64L(port), pf->stat_prev_loaded, 591536517fd3SJacob Keller &prev_ps->tx_size_64, &cur_ps->tx_size_64); 5916fcea6f3dSAnirudh Venkataramanan 59179e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PTC127L(port), pf->stat_prev_loaded, 591836517fd3SJacob Keller &prev_ps->tx_size_127, &cur_ps->tx_size_127); 5919fcea6f3dSAnirudh Venkataramanan 59209e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PTC255L(port), pf->stat_prev_loaded, 592136517fd3SJacob Keller &prev_ps->tx_size_255, &cur_ps->tx_size_255); 5922fcea6f3dSAnirudh Venkataramanan 59239e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PTC511L(port), pf->stat_prev_loaded, 592436517fd3SJacob Keller &prev_ps->tx_size_511, &cur_ps->tx_size_511); 5925fcea6f3dSAnirudh Venkataramanan 59269e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PTC1023L(port), pf->stat_prev_loaded, 5927fcea6f3dSAnirudh Venkataramanan &prev_ps->tx_size_1023, &cur_ps->tx_size_1023); 5928fcea6f3dSAnirudh Venkataramanan 59299e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PTC1522L(port), pf->stat_prev_loaded, 5930fcea6f3dSAnirudh Venkataramanan &prev_ps->tx_size_1522, &cur_ps->tx_size_1522); 5931fcea6f3dSAnirudh Venkataramanan 59329e7a5d17SUsha Ketineni ice_stat_update40(hw, GLPRT_PTC9522L(port), pf->stat_prev_loaded, 5933fcea6f3dSAnirudh Venkataramanan &prev_ps->tx_size_big, &cur_ps->tx_size_big); 5934fcea6f3dSAnirudh Venkataramanan 59354ab95646SHenry Tieman fd_ctr_base = hw->fd_ctr_base; 59364ab95646SHenry Tieman 59374ab95646SHenry Tieman ice_stat_update40(hw, 59384ab95646SHenry Tieman GLSTAT_FD_CNT0L(ICE_FD_SB_STAT_IDX(fd_ctr_base)), 59394ab95646SHenry Tieman pf->stat_prev_loaded, &prev_ps->fd_sb_match, 59404ab95646SHenry Tieman &cur_ps->fd_sb_match); 59419e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_LXONRXC(port), pf->stat_prev_loaded, 5942fcea6f3dSAnirudh Venkataramanan &prev_ps->link_xon_rx, &cur_ps->link_xon_rx); 5943fcea6f3dSAnirudh Venkataramanan 59449e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_LXOFFRXC(port), pf->stat_prev_loaded, 5945fcea6f3dSAnirudh Venkataramanan &prev_ps->link_xoff_rx, &cur_ps->link_xoff_rx); 5946fcea6f3dSAnirudh Venkataramanan 59479e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_LXONTXC(port), pf->stat_prev_loaded, 5948fcea6f3dSAnirudh Venkataramanan &prev_ps->link_xon_tx, &cur_ps->link_xon_tx); 5949fcea6f3dSAnirudh Venkataramanan 59509e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_LXOFFTXC(port), pf->stat_prev_loaded, 5951fcea6f3dSAnirudh Venkataramanan &prev_ps->link_xoff_tx, &cur_ps->link_xoff_tx); 5952fcea6f3dSAnirudh Venkataramanan 59534b0fdcebSAnirudh Venkataramanan ice_update_dcb_stats(pf); 59544b0fdcebSAnirudh Venkataramanan 59559e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_CRCERRS(port), pf->stat_prev_loaded, 5956fcea6f3dSAnirudh Venkataramanan &prev_ps->crc_errors, &cur_ps->crc_errors); 5957fcea6f3dSAnirudh Venkataramanan 59589e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_ILLERRC(port), pf->stat_prev_loaded, 5959fcea6f3dSAnirudh Venkataramanan &prev_ps->illegal_bytes, &cur_ps->illegal_bytes); 5960fcea6f3dSAnirudh Venkataramanan 59619e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_MLFC(port), pf->stat_prev_loaded, 5962fcea6f3dSAnirudh Venkataramanan &prev_ps->mac_local_faults, 5963fcea6f3dSAnirudh Venkataramanan &cur_ps->mac_local_faults); 5964fcea6f3dSAnirudh Venkataramanan 59659e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_MRFC(port), pf->stat_prev_loaded, 5966fcea6f3dSAnirudh Venkataramanan &prev_ps->mac_remote_faults, 5967fcea6f3dSAnirudh Venkataramanan &cur_ps->mac_remote_faults); 5968fcea6f3dSAnirudh Venkataramanan 59699e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_RLEC(port), pf->stat_prev_loaded, 5970fcea6f3dSAnirudh Venkataramanan &prev_ps->rx_len_errors, &cur_ps->rx_len_errors); 5971fcea6f3dSAnirudh Venkataramanan 59729e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_RUC(port), pf->stat_prev_loaded, 5973fcea6f3dSAnirudh Venkataramanan &prev_ps->rx_undersize, &cur_ps->rx_undersize); 5974fcea6f3dSAnirudh Venkataramanan 59759e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_RFC(port), pf->stat_prev_loaded, 5976fcea6f3dSAnirudh Venkataramanan &prev_ps->rx_fragments, &cur_ps->rx_fragments); 5977fcea6f3dSAnirudh Venkataramanan 59789e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_ROC(port), pf->stat_prev_loaded, 5979fcea6f3dSAnirudh Venkataramanan &prev_ps->rx_oversize, &cur_ps->rx_oversize); 5980fcea6f3dSAnirudh Venkataramanan 59819e7a5d17SUsha Ketineni ice_stat_update32(hw, GLPRT_RJC(port), pf->stat_prev_loaded, 5982fcea6f3dSAnirudh Venkataramanan &prev_ps->rx_jabber, &cur_ps->rx_jabber); 5983fcea6f3dSAnirudh Venkataramanan 59844ab95646SHenry Tieman cur_ps->fd_sb_status = test_bit(ICE_FLAG_FD_ENA, pf->flags) ? 1 : 0; 59854ab95646SHenry Tieman 5986fcea6f3dSAnirudh Venkataramanan pf->stat_prev_loaded = true; 5987fcea6f3dSAnirudh Venkataramanan } 5988fcea6f3dSAnirudh Venkataramanan 5989fcea6f3dSAnirudh Venkataramanan /** 5990fcea6f3dSAnirudh Venkataramanan * ice_get_stats64 - get statistics for network device structure 5991fcea6f3dSAnirudh Venkataramanan * @netdev: network interface device structure 5992fcea6f3dSAnirudh Venkataramanan * @stats: main device statistics structure 5993fcea6f3dSAnirudh Venkataramanan */ 5994fcea6f3dSAnirudh Venkataramanan static 5995fcea6f3dSAnirudh Venkataramanan void ice_get_stats64(struct net_device *netdev, struct rtnl_link_stats64 *stats) 5996fcea6f3dSAnirudh Venkataramanan { 5997fcea6f3dSAnirudh Venkataramanan struct ice_netdev_priv *np = netdev_priv(netdev); 5998fcea6f3dSAnirudh Venkataramanan struct rtnl_link_stats64 *vsi_stats; 5999fcea6f3dSAnirudh Venkataramanan struct ice_vsi *vsi = np->vsi; 6000fcea6f3dSAnirudh Venkataramanan 6001fcea6f3dSAnirudh Venkataramanan vsi_stats = &vsi->net_stats; 6002fcea6f3dSAnirudh Venkataramanan 60033d57fd10SDave Ertman if (!vsi->num_txq || !vsi->num_rxq) 6004fcea6f3dSAnirudh Venkataramanan return; 60053d57fd10SDave Ertman 6006fcea6f3dSAnirudh Venkataramanan /* netdev packet/byte stats come from ring counter. These are obtained 6007fcea6f3dSAnirudh Venkataramanan * by summing up ring counters (done by ice_update_vsi_ring_stats). 60083d57fd10SDave Ertman * But, only call the update routine and read the registers if VSI is 60093d57fd10SDave Ertman * not down. 6010fcea6f3dSAnirudh Venkataramanan */ 6011e97fb1aeSAnirudh Venkataramanan if (!test_bit(ICE_VSI_DOWN, vsi->state)) 6012fcea6f3dSAnirudh Venkataramanan ice_update_vsi_ring_stats(vsi); 6013fcea6f3dSAnirudh Venkataramanan stats->tx_packets = vsi_stats->tx_packets; 6014fcea6f3dSAnirudh Venkataramanan stats->tx_bytes = vsi_stats->tx_bytes; 6015fcea6f3dSAnirudh Venkataramanan stats->rx_packets = vsi_stats->rx_packets; 6016fcea6f3dSAnirudh Venkataramanan stats->rx_bytes = vsi_stats->rx_bytes; 6017fcea6f3dSAnirudh Venkataramanan 6018fcea6f3dSAnirudh Venkataramanan /* The rest of the stats can be read from the hardware but instead we 6019fcea6f3dSAnirudh Venkataramanan * just return values that the watchdog task has already obtained from 6020fcea6f3dSAnirudh Venkataramanan * the hardware. 6021fcea6f3dSAnirudh Venkataramanan */ 6022fcea6f3dSAnirudh Venkataramanan stats->multicast = vsi_stats->multicast; 6023fcea6f3dSAnirudh Venkataramanan stats->tx_errors = vsi_stats->tx_errors; 6024fcea6f3dSAnirudh Venkataramanan stats->tx_dropped = vsi_stats->tx_dropped; 6025fcea6f3dSAnirudh Venkataramanan stats->rx_errors = vsi_stats->rx_errors; 6026fcea6f3dSAnirudh Venkataramanan stats->rx_dropped = vsi_stats->rx_dropped; 6027fcea6f3dSAnirudh Venkataramanan stats->rx_crc_errors = vsi_stats->rx_crc_errors; 6028fcea6f3dSAnirudh Venkataramanan stats->rx_length_errors = vsi_stats->rx_length_errors; 6029fcea6f3dSAnirudh Venkataramanan } 6030fcea6f3dSAnirudh Venkataramanan 6031fcea6f3dSAnirudh Venkataramanan /** 60322b245cb2SAnirudh Venkataramanan * ice_napi_disable_all - Disable NAPI for all q_vectors in the VSI 60332b245cb2SAnirudh Venkataramanan * @vsi: VSI having NAPI disabled 60342b245cb2SAnirudh Venkataramanan */ 60352b245cb2SAnirudh Venkataramanan static void ice_napi_disable_all(struct ice_vsi *vsi) 60362b245cb2SAnirudh Venkataramanan { 60372b245cb2SAnirudh Venkataramanan int q_idx; 60382b245cb2SAnirudh Venkataramanan 60392b245cb2SAnirudh Venkataramanan if (!vsi->netdev) 60402b245cb2SAnirudh Venkataramanan return; 60412b245cb2SAnirudh Venkataramanan 60420c2561c8SBrett Creeley ice_for_each_q_vector(vsi, q_idx) { 6043eec90376SYoung Xiao struct ice_q_vector *q_vector = vsi->q_vectors[q_idx]; 6044eec90376SYoung Xiao 6045e72bba21SMaciej Fijalkowski if (q_vector->rx.rx_ring || q_vector->tx.tx_ring) 6046eec90376SYoung Xiao napi_disable(&q_vector->napi); 6047cdf1f1f1SJacob Keller 6048cdf1f1f1SJacob Keller cancel_work_sync(&q_vector->tx.dim.work); 6049cdf1f1f1SJacob Keller cancel_work_sync(&q_vector->rx.dim.work); 6050eec90376SYoung Xiao } 60512b245cb2SAnirudh Venkataramanan } 60522b245cb2SAnirudh Venkataramanan 60532b245cb2SAnirudh Venkataramanan /** 6054cdedef59SAnirudh Venkataramanan * ice_down - Shutdown the connection 6055cdedef59SAnirudh Venkataramanan * @vsi: The VSI being stopped 6056cdedef59SAnirudh Venkataramanan */ 6057fcea6f3dSAnirudh Venkataramanan int ice_down(struct ice_vsi *vsi) 6058cdedef59SAnirudh Venkataramanan { 6059ab4ab73fSBruce Allan int i, tx_err, rx_err, link_err = 0; 6060cdedef59SAnirudh Venkataramanan 6061cdedef59SAnirudh Venkataramanan /* Caller of this function is expected to set the 60627e408e07SAnirudh Venkataramanan * vsi->state ICE_DOWN bit 6063cdedef59SAnirudh Venkataramanan */ 6064b3be918dSGrzegorz Nitka if (vsi->netdev && vsi->type == ICE_VSI_PF) { 6065cdedef59SAnirudh Venkataramanan netif_carrier_off(vsi->netdev); 6066cdedef59SAnirudh Venkataramanan netif_tx_disable(vsi->netdev); 6067b3be918dSGrzegorz Nitka } else if (vsi->type == ICE_VSI_SWITCHDEV_CTRL) { 6068b3be918dSGrzegorz Nitka ice_eswitch_stop_all_tx_queues(vsi->back); 6069cdedef59SAnirudh Venkataramanan } 6070cdedef59SAnirudh Venkataramanan 6071cdedef59SAnirudh Venkataramanan ice_vsi_dis_irq(vsi); 607203f7a986SAnirudh Venkataramanan 607303f7a986SAnirudh Venkataramanan tx_err = ice_vsi_stop_lan_tx_rings(vsi, ICE_NO_RESET, 0); 607472adf242SAnirudh Venkataramanan if (tx_err) 607519cce2c6SAnirudh Venkataramanan netdev_err(vsi->netdev, "Failed stop Tx rings, VSI %d error %d\n", 607672adf242SAnirudh Venkataramanan vsi->vsi_num, tx_err); 6077efc2214bSMaciej Fijalkowski if (!tx_err && ice_is_xdp_ena_vsi(vsi)) { 6078efc2214bSMaciej Fijalkowski tx_err = ice_vsi_stop_xdp_tx_rings(vsi); 6079efc2214bSMaciej Fijalkowski if (tx_err) 608019cce2c6SAnirudh Venkataramanan netdev_err(vsi->netdev, "Failed stop XDP rings, VSI %d error %d\n", 6081efc2214bSMaciej Fijalkowski vsi->vsi_num, tx_err); 6082efc2214bSMaciej Fijalkowski } 608372adf242SAnirudh Venkataramanan 608413a6233bSBrett Creeley rx_err = ice_vsi_stop_all_rx_rings(vsi); 608572adf242SAnirudh Venkataramanan if (rx_err) 608619cce2c6SAnirudh Venkataramanan netdev_err(vsi->netdev, "Failed stop Rx rings, VSI %d error %d\n", 608772adf242SAnirudh Venkataramanan vsi->vsi_num, rx_err); 608872adf242SAnirudh Venkataramanan 60892b245cb2SAnirudh Venkataramanan ice_napi_disable_all(vsi); 6090cdedef59SAnirudh Venkataramanan 6091ab4ab73fSBruce Allan if (test_bit(ICE_FLAG_LINK_DOWN_ON_CLOSE_ENA, vsi->back->flags)) { 6092b6f934f0SBrett Creeley link_err = ice_force_phys_link_state(vsi, false); 6093b6f934f0SBrett Creeley if (link_err) 609419cce2c6SAnirudh Venkataramanan netdev_err(vsi->netdev, "Failed to set physical link down, VSI %d error %d\n", 6095b6f934f0SBrett Creeley vsi->vsi_num, link_err); 6096ab4ab73fSBruce Allan } 6097b6f934f0SBrett Creeley 6098cdedef59SAnirudh Venkataramanan ice_for_each_txq(vsi, i) 6099cdedef59SAnirudh Venkataramanan ice_clean_tx_ring(vsi->tx_rings[i]); 6100cdedef59SAnirudh Venkataramanan 6101cdedef59SAnirudh Venkataramanan ice_for_each_rxq(vsi, i) 6102cdedef59SAnirudh Venkataramanan ice_clean_rx_ring(vsi->rx_rings[i]); 6103cdedef59SAnirudh Venkataramanan 6104b6f934f0SBrett Creeley if (tx_err || rx_err || link_err) { 610519cce2c6SAnirudh Venkataramanan netdev_err(vsi->netdev, "Failed to close VSI 0x%04X on switch 0x%04X\n", 6106cdedef59SAnirudh Venkataramanan vsi->vsi_num, vsi->vsw->sw_id); 610772adf242SAnirudh Venkataramanan return -EIO; 610872adf242SAnirudh Venkataramanan } 610972adf242SAnirudh Venkataramanan 611072adf242SAnirudh Venkataramanan return 0; 6111cdedef59SAnirudh Venkataramanan } 6112cdedef59SAnirudh Venkataramanan 6113cdedef59SAnirudh Venkataramanan /** 6114cdedef59SAnirudh Venkataramanan * ice_vsi_setup_tx_rings - Allocate VSI Tx queue resources 6115cdedef59SAnirudh Venkataramanan * @vsi: VSI having resources allocated 6116cdedef59SAnirudh Venkataramanan * 6117cdedef59SAnirudh Venkataramanan * Return 0 on success, negative on failure 6118cdedef59SAnirudh Venkataramanan */ 61190e674aebSAnirudh Venkataramanan int ice_vsi_setup_tx_rings(struct ice_vsi *vsi) 6120cdedef59SAnirudh Venkataramanan { 6121dab0588fSJesse Brandeburg int i, err = 0; 6122cdedef59SAnirudh Venkataramanan 6123cdedef59SAnirudh Venkataramanan if (!vsi->num_txq) { 61249a946843SAnirudh Venkataramanan dev_err(ice_pf_to_dev(vsi->back), "VSI %d has 0 Tx queues\n", 6125cdedef59SAnirudh Venkataramanan vsi->vsi_num); 6126cdedef59SAnirudh Venkataramanan return -EINVAL; 6127cdedef59SAnirudh Venkataramanan } 6128cdedef59SAnirudh Venkataramanan 6129cdedef59SAnirudh Venkataramanan ice_for_each_txq(vsi, i) { 6130e72bba21SMaciej Fijalkowski struct ice_tx_ring *ring = vsi->tx_rings[i]; 6131eb0ee8abSMichal Swiatkowski 6132eb0ee8abSMichal Swiatkowski if (!ring) 6133eb0ee8abSMichal Swiatkowski return -EINVAL; 6134eb0ee8abSMichal Swiatkowski 61351c54c839SGrzegorz Nitka if (vsi->netdev) 6136eb0ee8abSMichal Swiatkowski ring->netdev = vsi->netdev; 6137eb0ee8abSMichal Swiatkowski err = ice_setup_tx_ring(ring); 6138cdedef59SAnirudh Venkataramanan if (err) 6139cdedef59SAnirudh Venkataramanan break; 6140cdedef59SAnirudh Venkataramanan } 6141cdedef59SAnirudh Venkataramanan 6142cdedef59SAnirudh Venkataramanan return err; 6143cdedef59SAnirudh Venkataramanan } 6144cdedef59SAnirudh Venkataramanan 6145cdedef59SAnirudh Venkataramanan /** 6146cdedef59SAnirudh Venkataramanan * ice_vsi_setup_rx_rings - Allocate VSI Rx queue resources 6147cdedef59SAnirudh Venkataramanan * @vsi: VSI having resources allocated 6148cdedef59SAnirudh Venkataramanan * 6149cdedef59SAnirudh Venkataramanan * Return 0 on success, negative on failure 6150cdedef59SAnirudh Venkataramanan */ 61510e674aebSAnirudh Venkataramanan int ice_vsi_setup_rx_rings(struct ice_vsi *vsi) 6152cdedef59SAnirudh Venkataramanan { 6153dab0588fSJesse Brandeburg int i, err = 0; 6154cdedef59SAnirudh Venkataramanan 6155cdedef59SAnirudh Venkataramanan if (!vsi->num_rxq) { 61569a946843SAnirudh Venkataramanan dev_err(ice_pf_to_dev(vsi->back), "VSI %d has 0 Rx queues\n", 6157cdedef59SAnirudh Venkataramanan vsi->vsi_num); 6158cdedef59SAnirudh Venkataramanan return -EINVAL; 6159cdedef59SAnirudh Venkataramanan } 6160cdedef59SAnirudh Venkataramanan 6161cdedef59SAnirudh Venkataramanan ice_for_each_rxq(vsi, i) { 6162e72bba21SMaciej Fijalkowski struct ice_rx_ring *ring = vsi->rx_rings[i]; 6163eb0ee8abSMichal Swiatkowski 6164eb0ee8abSMichal Swiatkowski if (!ring) 6165eb0ee8abSMichal Swiatkowski return -EINVAL; 6166eb0ee8abSMichal Swiatkowski 61671c54c839SGrzegorz Nitka if (vsi->netdev) 6168eb0ee8abSMichal Swiatkowski ring->netdev = vsi->netdev; 6169eb0ee8abSMichal Swiatkowski err = ice_setup_rx_ring(ring); 6170cdedef59SAnirudh Venkataramanan if (err) 6171cdedef59SAnirudh Venkataramanan break; 6172cdedef59SAnirudh Venkataramanan } 6173cdedef59SAnirudh Venkataramanan 6174cdedef59SAnirudh Venkataramanan return err; 6175cdedef59SAnirudh Venkataramanan } 6176cdedef59SAnirudh Venkataramanan 6177cdedef59SAnirudh Venkataramanan /** 6178148beb61SHenry Tieman * ice_vsi_open_ctrl - open control VSI for use 6179148beb61SHenry Tieman * @vsi: the VSI to open 6180148beb61SHenry Tieman * 6181148beb61SHenry Tieman * Initialization of the Control VSI 6182148beb61SHenry Tieman * 6183148beb61SHenry Tieman * Returns 0 on success, negative value on error 6184148beb61SHenry Tieman */ 6185148beb61SHenry Tieman int ice_vsi_open_ctrl(struct ice_vsi *vsi) 6186148beb61SHenry Tieman { 6187148beb61SHenry Tieman char int_name[ICE_INT_NAME_STR_LEN]; 6188148beb61SHenry Tieman struct ice_pf *pf = vsi->back; 6189148beb61SHenry Tieman struct device *dev; 6190148beb61SHenry Tieman int err; 6191148beb61SHenry Tieman 6192148beb61SHenry Tieman dev = ice_pf_to_dev(pf); 6193148beb61SHenry Tieman /* allocate descriptors */ 6194148beb61SHenry Tieman err = ice_vsi_setup_tx_rings(vsi); 6195148beb61SHenry Tieman if (err) 6196148beb61SHenry Tieman goto err_setup_tx; 6197148beb61SHenry Tieman 6198148beb61SHenry Tieman err = ice_vsi_setup_rx_rings(vsi); 6199148beb61SHenry Tieman if (err) 6200148beb61SHenry Tieman goto err_setup_rx; 6201148beb61SHenry Tieman 6202148beb61SHenry Tieman err = ice_vsi_cfg(vsi); 6203148beb61SHenry Tieman if (err) 6204148beb61SHenry Tieman goto err_setup_rx; 6205148beb61SHenry Tieman 6206148beb61SHenry Tieman snprintf(int_name, sizeof(int_name) - 1, "%s-%s:ctrl", 6207148beb61SHenry Tieman dev_driver_string(dev), dev_name(dev)); 6208148beb61SHenry Tieman err = ice_vsi_req_irq_msix(vsi, int_name); 6209148beb61SHenry Tieman if (err) 6210148beb61SHenry Tieman goto err_setup_rx; 6211148beb61SHenry Tieman 6212148beb61SHenry Tieman ice_vsi_cfg_msix(vsi); 6213148beb61SHenry Tieman 6214148beb61SHenry Tieman err = ice_vsi_start_all_rx_rings(vsi); 6215148beb61SHenry Tieman if (err) 6216148beb61SHenry Tieman goto err_up_complete; 6217148beb61SHenry Tieman 6218e97fb1aeSAnirudh Venkataramanan clear_bit(ICE_VSI_DOWN, vsi->state); 6219148beb61SHenry Tieman ice_vsi_ena_irq(vsi); 6220148beb61SHenry Tieman 6221148beb61SHenry Tieman return 0; 6222148beb61SHenry Tieman 6223148beb61SHenry Tieman err_up_complete: 6224148beb61SHenry Tieman ice_down(vsi); 6225148beb61SHenry Tieman err_setup_rx: 6226148beb61SHenry Tieman ice_vsi_free_rx_rings(vsi); 6227148beb61SHenry Tieman err_setup_tx: 6228148beb61SHenry Tieman ice_vsi_free_tx_rings(vsi); 6229148beb61SHenry Tieman 6230148beb61SHenry Tieman return err; 6231148beb61SHenry Tieman } 6232148beb61SHenry Tieman 6233148beb61SHenry Tieman /** 6234cdedef59SAnirudh Venkataramanan * ice_vsi_open - Called when a network interface is made active 6235cdedef59SAnirudh Venkataramanan * @vsi: the VSI to open 6236cdedef59SAnirudh Venkataramanan * 6237cdedef59SAnirudh Venkataramanan * Initialization of the VSI 6238cdedef59SAnirudh Venkataramanan * 6239cdedef59SAnirudh Venkataramanan * Returns 0 on success, negative value on error 6240cdedef59SAnirudh Venkataramanan */ 62411a1c40dfSGrzegorz Nitka int ice_vsi_open(struct ice_vsi *vsi) 6242cdedef59SAnirudh Venkataramanan { 6243cdedef59SAnirudh Venkataramanan char int_name[ICE_INT_NAME_STR_LEN]; 6244cdedef59SAnirudh Venkataramanan struct ice_pf *pf = vsi->back; 6245cdedef59SAnirudh Venkataramanan int err; 6246cdedef59SAnirudh Venkataramanan 6247cdedef59SAnirudh Venkataramanan /* allocate descriptors */ 6248cdedef59SAnirudh Venkataramanan err = ice_vsi_setup_tx_rings(vsi); 6249cdedef59SAnirudh Venkataramanan if (err) 6250cdedef59SAnirudh Venkataramanan goto err_setup_tx; 6251cdedef59SAnirudh Venkataramanan 6252cdedef59SAnirudh Venkataramanan err = ice_vsi_setup_rx_rings(vsi); 6253cdedef59SAnirudh Venkataramanan if (err) 6254cdedef59SAnirudh Venkataramanan goto err_setup_rx; 6255cdedef59SAnirudh Venkataramanan 6256cdedef59SAnirudh Venkataramanan err = ice_vsi_cfg(vsi); 6257cdedef59SAnirudh Venkataramanan if (err) 6258cdedef59SAnirudh Venkataramanan goto err_setup_rx; 6259cdedef59SAnirudh Venkataramanan 6260cdedef59SAnirudh Venkataramanan snprintf(int_name, sizeof(int_name) - 1, "%s-%s", 62614015d11eSBrett Creeley dev_driver_string(ice_pf_to_dev(pf)), vsi->netdev->name); 6262ba880734SBrett Creeley err = ice_vsi_req_irq_msix(vsi, int_name); 6263cdedef59SAnirudh Venkataramanan if (err) 6264cdedef59SAnirudh Venkataramanan goto err_setup_rx; 6265cdedef59SAnirudh Venkataramanan 62661a1c40dfSGrzegorz Nitka if (vsi->type == ICE_VSI_PF) { 6267cdedef59SAnirudh Venkataramanan /* Notify the stack of the actual queue counts. */ 6268cdedef59SAnirudh Venkataramanan err = netif_set_real_num_tx_queues(vsi->netdev, vsi->num_txq); 6269cdedef59SAnirudh Venkataramanan if (err) 6270cdedef59SAnirudh Venkataramanan goto err_set_qs; 6271cdedef59SAnirudh Venkataramanan 6272cdedef59SAnirudh Venkataramanan err = netif_set_real_num_rx_queues(vsi->netdev, vsi->num_rxq); 6273cdedef59SAnirudh Venkataramanan if (err) 6274cdedef59SAnirudh Venkataramanan goto err_set_qs; 62751a1c40dfSGrzegorz Nitka } 6276cdedef59SAnirudh Venkataramanan 6277cdedef59SAnirudh Venkataramanan err = ice_up_complete(vsi); 6278cdedef59SAnirudh Venkataramanan if (err) 6279cdedef59SAnirudh Venkataramanan goto err_up_complete; 6280cdedef59SAnirudh Venkataramanan 6281cdedef59SAnirudh Venkataramanan return 0; 6282cdedef59SAnirudh Venkataramanan 6283cdedef59SAnirudh Venkataramanan err_up_complete: 6284cdedef59SAnirudh Venkataramanan ice_down(vsi); 6285cdedef59SAnirudh Venkataramanan err_set_qs: 6286cdedef59SAnirudh Venkataramanan ice_vsi_free_irq(vsi); 6287cdedef59SAnirudh Venkataramanan err_setup_rx: 6288cdedef59SAnirudh Venkataramanan ice_vsi_free_rx_rings(vsi); 6289cdedef59SAnirudh Venkataramanan err_setup_tx: 6290cdedef59SAnirudh Venkataramanan ice_vsi_free_tx_rings(vsi); 6291cdedef59SAnirudh Venkataramanan 6292cdedef59SAnirudh Venkataramanan return err; 6293cdedef59SAnirudh Venkataramanan } 6294cdedef59SAnirudh Venkataramanan 6295cdedef59SAnirudh Venkataramanan /** 62960f9d5027SAnirudh Venkataramanan * ice_vsi_release_all - Delete all VSIs 62970f9d5027SAnirudh Venkataramanan * @pf: PF from which all VSIs are being removed 62980f9d5027SAnirudh Venkataramanan */ 62990f9d5027SAnirudh Venkataramanan static void ice_vsi_release_all(struct ice_pf *pf) 63000f9d5027SAnirudh Venkataramanan { 63010f9d5027SAnirudh Venkataramanan int err, i; 63020f9d5027SAnirudh Venkataramanan 63030f9d5027SAnirudh Venkataramanan if (!pf->vsi) 63040f9d5027SAnirudh Venkataramanan return; 63050f9d5027SAnirudh Venkataramanan 630680ed404aSBrett Creeley ice_for_each_vsi(pf, i) { 63070f9d5027SAnirudh Venkataramanan if (!pf->vsi[i]) 63080f9d5027SAnirudh Venkataramanan continue; 63090f9d5027SAnirudh Venkataramanan 63100f9d5027SAnirudh Venkataramanan err = ice_vsi_release(pf->vsi[i]); 63110f9d5027SAnirudh Venkataramanan if (err) 631219cce2c6SAnirudh Venkataramanan dev_dbg(ice_pf_to_dev(pf), "Failed to release pf->vsi[%d], err %d, vsi_num = %d\n", 63130f9d5027SAnirudh Venkataramanan i, err, pf->vsi[i]->vsi_num); 63140f9d5027SAnirudh Venkataramanan } 63150f9d5027SAnirudh Venkataramanan } 63160f9d5027SAnirudh Venkataramanan 63170f9d5027SAnirudh Venkataramanan /** 6318462acf6aSTony Nguyen * ice_vsi_rebuild_by_type - Rebuild VSI of a given type 6319462acf6aSTony Nguyen * @pf: pointer to the PF instance 6320462acf6aSTony Nguyen * @type: VSI type to rebuild 6321462acf6aSTony Nguyen * 6322462acf6aSTony Nguyen * Iterates through the pf->vsi array and rebuilds VSIs of the requested type 63230f9d5027SAnirudh Venkataramanan */ 6324462acf6aSTony Nguyen static int ice_vsi_rebuild_by_type(struct ice_pf *pf, enum ice_vsi_type type) 63250f9d5027SAnirudh Venkataramanan { 63264015d11eSBrett Creeley struct device *dev = ice_pf_to_dev(pf); 6327462acf6aSTony Nguyen enum ice_status status; 6328462acf6aSTony Nguyen int i, err; 63290f9d5027SAnirudh Venkataramanan 633080ed404aSBrett Creeley ice_for_each_vsi(pf, i) { 63314425e053SKrzysztof Kazimierczak struct ice_vsi *vsi = pf->vsi[i]; 63320f9d5027SAnirudh Venkataramanan 6333462acf6aSTony Nguyen if (!vsi || vsi->type != type) 63340f9d5027SAnirudh Venkataramanan continue; 63350f9d5027SAnirudh Venkataramanan 6336462acf6aSTony Nguyen /* rebuild the VSI */ 633787324e74SHenry Tieman err = ice_vsi_rebuild(vsi, true); 63380f9d5027SAnirudh Venkataramanan if (err) { 633919cce2c6SAnirudh Venkataramanan dev_err(dev, "rebuild VSI failed, err %d, VSI index %d, type %s\n", 6340964674f1SAnirudh Venkataramanan err, vsi->idx, ice_vsi_type_str(type)); 63410f9d5027SAnirudh Venkataramanan return err; 63420f9d5027SAnirudh Venkataramanan } 63430f9d5027SAnirudh Venkataramanan 6344462acf6aSTony Nguyen /* replay filters for the VSI */ 6345462acf6aSTony Nguyen status = ice_replay_vsi(&pf->hw, vsi->idx); 6346462acf6aSTony Nguyen if (status) { 63470fee3577SLihong Yang dev_err(dev, "replay VSI failed, status %s, VSI index %d, type %s\n", 63480fee3577SLihong Yang ice_stat_str(status), vsi->idx, 63490fee3577SLihong Yang ice_vsi_type_str(type)); 6350334cb062SAnirudh Venkataramanan return -EIO; 6351334cb062SAnirudh Venkataramanan } 6352334cb062SAnirudh Venkataramanan 6353334cb062SAnirudh Venkataramanan /* Re-map HW VSI number, using VSI handle that has been 6354334cb062SAnirudh Venkataramanan * previously validated in ice_replay_vsi() call above 6355334cb062SAnirudh Venkataramanan */ 6356462acf6aSTony Nguyen vsi->vsi_num = ice_get_hw_vsi_num(&pf->hw, vsi->idx); 6357334cb062SAnirudh Venkataramanan 6358462acf6aSTony Nguyen /* enable the VSI */ 6359462acf6aSTony Nguyen err = ice_ena_vsi(vsi, false); 6360462acf6aSTony Nguyen if (err) { 636119cce2c6SAnirudh Venkataramanan dev_err(dev, "enable VSI failed, err %d, VSI index %d, type %s\n", 6362964674f1SAnirudh Venkataramanan err, vsi->idx, ice_vsi_type_str(type)); 6363462acf6aSTony Nguyen return err; 6364334cb062SAnirudh Venkataramanan } 6365334cb062SAnirudh Venkataramanan 63664015d11eSBrett Creeley dev_info(dev, "VSI rebuilt. VSI index %d, type %s\n", vsi->idx, 63674015d11eSBrett Creeley ice_vsi_type_str(type)); 6368462acf6aSTony Nguyen } 6369462acf6aSTony Nguyen 6370334cb062SAnirudh Venkataramanan return 0; 6371334cb062SAnirudh Venkataramanan } 6372334cb062SAnirudh Venkataramanan 6373334cb062SAnirudh Venkataramanan /** 6374462acf6aSTony Nguyen * ice_update_pf_netdev_link - Update PF netdev link status 6375462acf6aSTony Nguyen * @pf: pointer to the PF instance 6376462acf6aSTony Nguyen */ 6377462acf6aSTony Nguyen static void ice_update_pf_netdev_link(struct ice_pf *pf) 6378462acf6aSTony Nguyen { 6379462acf6aSTony Nguyen bool link_up; 6380462acf6aSTony Nguyen int i; 6381462acf6aSTony Nguyen 6382462acf6aSTony Nguyen ice_for_each_vsi(pf, i) { 6383462acf6aSTony Nguyen struct ice_vsi *vsi = pf->vsi[i]; 6384462acf6aSTony Nguyen 6385462acf6aSTony Nguyen if (!vsi || vsi->type != ICE_VSI_PF) 6386462acf6aSTony Nguyen return; 6387462acf6aSTony Nguyen 6388462acf6aSTony Nguyen ice_get_link_status(pf->vsi[i]->port_info, &link_up); 6389462acf6aSTony Nguyen if (link_up) { 6390462acf6aSTony Nguyen netif_carrier_on(pf->vsi[i]->netdev); 6391462acf6aSTony Nguyen netif_tx_wake_all_queues(pf->vsi[i]->netdev); 6392462acf6aSTony Nguyen } else { 6393462acf6aSTony Nguyen netif_carrier_off(pf->vsi[i]->netdev); 6394462acf6aSTony Nguyen netif_tx_stop_all_queues(pf->vsi[i]->netdev); 6395462acf6aSTony Nguyen } 6396462acf6aSTony Nguyen } 6397462acf6aSTony Nguyen } 6398462acf6aSTony Nguyen 6399462acf6aSTony Nguyen /** 64000b28b702SAnirudh Venkataramanan * ice_rebuild - rebuild after reset 64012f2da36eSAnirudh Venkataramanan * @pf: PF to rebuild 6402462acf6aSTony Nguyen * @reset_type: type of reset 640312bb018cSBrett Creeley * 640412bb018cSBrett Creeley * Do not rebuild VF VSI in this flow because that is already handled via 640512bb018cSBrett Creeley * ice_reset_all_vfs(). This is because requirements for resetting a VF after a 640612bb018cSBrett Creeley * PFR/CORER/GLOBER/etc. are different than the normal flow. Also, we don't want 640712bb018cSBrett Creeley * to reset/rebuild all the VF VSI twice. 64080b28b702SAnirudh Venkataramanan */ 6409462acf6aSTony Nguyen static void ice_rebuild(struct ice_pf *pf, enum ice_reset_req reset_type) 64100b28b702SAnirudh Venkataramanan { 64114015d11eSBrett Creeley struct device *dev = ice_pf_to_dev(pf); 64120b28b702SAnirudh Venkataramanan struct ice_hw *hw = &pf->hw; 64130b28b702SAnirudh Venkataramanan enum ice_status ret; 6414462acf6aSTony Nguyen int err; 64150b28b702SAnirudh Venkataramanan 64167e408e07SAnirudh Venkataramanan if (test_bit(ICE_DOWN, pf->state)) 64170b28b702SAnirudh Venkataramanan goto clear_recovery; 64180b28b702SAnirudh Venkataramanan 6419462acf6aSTony Nguyen dev_dbg(dev, "rebuilding PF after reset_type=%d\n", reset_type); 64200b28b702SAnirudh Venkataramanan 64210b28b702SAnirudh Venkataramanan ret = ice_init_all_ctrlq(hw); 64220b28b702SAnirudh Venkataramanan if (ret) { 64230fee3577SLihong Yang dev_err(dev, "control queues init failed %s\n", 64240fee3577SLihong Yang ice_stat_str(ret)); 64250f9d5027SAnirudh Venkataramanan goto err_init_ctrlq; 64260b28b702SAnirudh Venkataramanan } 64270b28b702SAnirudh Venkataramanan 6428462acf6aSTony Nguyen /* if DDP was previously loaded successfully */ 6429462acf6aSTony Nguyen if (!ice_is_safe_mode(pf)) { 6430462acf6aSTony Nguyen /* reload the SW DB of filter tables */ 6431462acf6aSTony Nguyen if (reset_type == ICE_RESET_PFR) 6432462acf6aSTony Nguyen ice_fill_blk_tbls(hw); 6433462acf6aSTony Nguyen else 6434462acf6aSTony Nguyen /* Reload DDP Package after CORER/GLOBR reset */ 6435462acf6aSTony Nguyen ice_load_pkg(NULL, pf); 6436462acf6aSTony Nguyen } 6437462acf6aSTony Nguyen 64380b28b702SAnirudh Venkataramanan ret = ice_clear_pf_cfg(hw); 64390b28b702SAnirudh Venkataramanan if (ret) { 64400fee3577SLihong Yang dev_err(dev, "clear PF configuration failed %s\n", 64410fee3577SLihong Yang ice_stat_str(ret)); 64420f9d5027SAnirudh Venkataramanan goto err_init_ctrlq; 64430b28b702SAnirudh Venkataramanan } 64440b28b702SAnirudh Venkataramanan 6445fc0f39bcSBrett Creeley if (pf->first_sw->dflt_vsi_ena) 644619cce2c6SAnirudh Venkataramanan dev_info(dev, "Clearing default VSI, re-enable after reset completes\n"); 6447fc0f39bcSBrett Creeley /* clear the default VSI configuration if it exists */ 6448fc0f39bcSBrett Creeley pf->first_sw->dflt_vsi = NULL; 6449fc0f39bcSBrett Creeley pf->first_sw->dflt_vsi_ena = false; 6450fc0f39bcSBrett Creeley 64510b28b702SAnirudh Venkataramanan ice_clear_pxe_mode(hw); 64520b28b702SAnirudh Venkataramanan 645397a4ec01SJacob Keller ret = ice_init_nvm(hw); 645497a4ec01SJacob Keller if (ret) { 645597a4ec01SJacob Keller dev_err(dev, "ice_init_nvm failed %s\n", ice_stat_str(ret)); 645697a4ec01SJacob Keller goto err_init_ctrlq; 645797a4ec01SJacob Keller } 645897a4ec01SJacob Keller 64590b28b702SAnirudh Venkataramanan ret = ice_get_caps(hw); 64600b28b702SAnirudh Venkataramanan if (ret) { 64610fee3577SLihong Yang dev_err(dev, "ice_get_caps failed %s\n", ice_stat_str(ret)); 64620f9d5027SAnirudh Venkataramanan goto err_init_ctrlq; 64630b28b702SAnirudh Venkataramanan } 64640b28b702SAnirudh Venkataramanan 646542449105SAnirudh Venkataramanan ret = ice_aq_set_mac_cfg(hw, ICE_AQ_SET_MAC_FRAME_SIZE_MAX, NULL); 646642449105SAnirudh Venkataramanan if (ret) { 646742449105SAnirudh Venkataramanan dev_err(dev, "set_mac_cfg failed %s\n", ice_stat_str(ret)); 646842449105SAnirudh Venkataramanan goto err_init_ctrlq; 646942449105SAnirudh Venkataramanan } 647042449105SAnirudh Venkataramanan 64710f9d5027SAnirudh Venkataramanan err = ice_sched_init_port(hw->port_info); 64720f9d5027SAnirudh Venkataramanan if (err) 64730f9d5027SAnirudh Venkataramanan goto err_sched_init_port; 64740f9d5027SAnirudh Venkataramanan 64750b28b702SAnirudh Venkataramanan /* start misc vector */ 64760b28b702SAnirudh Venkataramanan err = ice_req_irq_msix_misc(pf); 64770b28b702SAnirudh Venkataramanan if (err) { 64780b28b702SAnirudh Venkataramanan dev_err(dev, "misc vector setup failed: %d\n", err); 6479462acf6aSTony Nguyen goto err_sched_init_port; 64800b28b702SAnirudh Venkataramanan } 64810b28b702SAnirudh Venkataramanan 648283af0039SHenry Tieman if (test_bit(ICE_FLAG_FD_ENA, pf->flags)) { 648383af0039SHenry Tieman wr32(hw, PFQF_FD_ENA, PFQF_FD_ENA_FD_ENA_M); 648483af0039SHenry Tieman if (!rd32(hw, PFQF_FD_SIZE)) { 648583af0039SHenry Tieman u16 unused, guar, b_effort; 648683af0039SHenry Tieman 648783af0039SHenry Tieman guar = hw->func_caps.fd_fltr_guar; 648883af0039SHenry Tieman b_effort = hw->func_caps.fd_fltr_best_effort; 648983af0039SHenry Tieman 649083af0039SHenry Tieman /* force guaranteed filter pool for PF */ 649183af0039SHenry Tieman ice_alloc_fd_guar_item(hw, &unused, guar); 649283af0039SHenry Tieman /* force shared filter pool for PF */ 649383af0039SHenry Tieman ice_alloc_fd_shrd_item(hw, &unused, b_effort); 649483af0039SHenry Tieman } 649583af0039SHenry Tieman } 649683af0039SHenry Tieman 6497462acf6aSTony Nguyen if (test_bit(ICE_FLAG_DCB_ENA, pf->flags)) 6498462acf6aSTony Nguyen ice_dcb_rebuild(pf); 6499462acf6aSTony Nguyen 650006c16d89SJacob Keller /* If the PF previously had enabled PTP, PTP init needs to happen before 650106c16d89SJacob Keller * the VSI rebuild. If not, this causes the PTP link status events to 650206c16d89SJacob Keller * fail. 650306c16d89SJacob Keller */ 650406c16d89SJacob Keller if (test_bit(ICE_FLAG_PTP_SUPPORTED, pf->flags)) 650506c16d89SJacob Keller ice_ptp_init(pf); 650606c16d89SJacob Keller 6507462acf6aSTony Nguyen /* rebuild PF VSI */ 6508462acf6aSTony Nguyen err = ice_vsi_rebuild_by_type(pf, ICE_VSI_PF); 65090f9d5027SAnirudh Venkataramanan if (err) { 6510462acf6aSTony Nguyen dev_err(dev, "PF VSI rebuild failed: %d\n", err); 65110f9d5027SAnirudh Venkataramanan goto err_vsi_rebuild; 65120f9d5027SAnirudh Venkataramanan } 65130b28b702SAnirudh Venkataramanan 6514b3be918dSGrzegorz Nitka err = ice_vsi_rebuild_by_type(pf, ICE_VSI_SWITCHDEV_CTRL); 6515b3be918dSGrzegorz Nitka if (err) { 6516b3be918dSGrzegorz Nitka dev_err(dev, "Switchdev CTRL VSI rebuild failed: %d\n", err); 6517b3be918dSGrzegorz Nitka goto err_vsi_rebuild; 6518b3be918dSGrzegorz Nitka } 6519b3be918dSGrzegorz Nitka 652083af0039SHenry Tieman /* If Flow Director is active */ 652183af0039SHenry Tieman if (test_bit(ICE_FLAG_FD_ENA, pf->flags)) { 652283af0039SHenry Tieman err = ice_vsi_rebuild_by_type(pf, ICE_VSI_CTRL); 652383af0039SHenry Tieman if (err) { 652483af0039SHenry Tieman dev_err(dev, "control VSI rebuild failed: %d\n", err); 652583af0039SHenry Tieman goto err_vsi_rebuild; 652683af0039SHenry Tieman } 652783af0039SHenry Tieman 652883af0039SHenry Tieman /* replay HW Flow Director recipes */ 652983af0039SHenry Tieman if (hw->fdir_prof) 653083af0039SHenry Tieman ice_fdir_replay_flows(hw); 653183af0039SHenry Tieman 653283af0039SHenry Tieman /* replay Flow Director filters */ 653383af0039SHenry Tieman ice_fdir_replay_fltrs(pf); 653428bf2672SBrett Creeley 653528bf2672SBrett Creeley ice_rebuild_arfs(pf); 653683af0039SHenry Tieman } 653783af0039SHenry Tieman 6538462acf6aSTony Nguyen ice_update_pf_netdev_link(pf); 6539462acf6aSTony Nguyen 6540462acf6aSTony Nguyen /* tell the firmware we are up */ 6541462acf6aSTony Nguyen ret = ice_send_version(pf); 6542462acf6aSTony Nguyen if (ret) { 65430fee3577SLihong Yang dev_err(dev, "Rebuild failed due to error sending driver version: %s\n", 65440fee3577SLihong Yang ice_stat_str(ret)); 6545462acf6aSTony Nguyen goto err_vsi_rebuild; 6546ce317dd9SAnirudh Venkataramanan } 6547462acf6aSTony Nguyen 6548462acf6aSTony Nguyen ice_replay_post(hw); 6549ce317dd9SAnirudh Venkataramanan 65500f9d5027SAnirudh Venkataramanan /* if we get here, reset flow is successful */ 65517e408e07SAnirudh Venkataramanan clear_bit(ICE_RESET_FAILED, pf->state); 6552f9f5301eSDave Ertman 6553f9f5301eSDave Ertman ice_plug_aux_dev(pf); 65540b28b702SAnirudh Venkataramanan return; 65550b28b702SAnirudh Venkataramanan 65560f9d5027SAnirudh Venkataramanan err_vsi_rebuild: 65570f9d5027SAnirudh Venkataramanan err_sched_init_port: 65580f9d5027SAnirudh Venkataramanan ice_sched_cleanup_all(hw); 65590f9d5027SAnirudh Venkataramanan err_init_ctrlq: 65600b28b702SAnirudh Venkataramanan ice_shutdown_all_ctrlq(hw); 65617e408e07SAnirudh Venkataramanan set_bit(ICE_RESET_FAILED, pf->state); 65620b28b702SAnirudh Venkataramanan clear_recovery: 65630f9d5027SAnirudh Venkataramanan /* set this bit in PF state to control service task scheduling */ 65647e408e07SAnirudh Venkataramanan set_bit(ICE_NEEDS_RESTART, pf->state); 65650f9d5027SAnirudh Venkataramanan dev_err(dev, "Rebuild failed, unload and reload driver\n"); 65660b28b702SAnirudh Venkataramanan } 65670b28b702SAnirudh Venkataramanan 65680b28b702SAnirudh Venkataramanan /** 656923b44513SMaciej Fijalkowski * ice_max_xdp_frame_size - returns the maximum allowed frame size for XDP 657023b44513SMaciej Fijalkowski * @vsi: Pointer to VSI structure 657123b44513SMaciej Fijalkowski */ 657223b44513SMaciej Fijalkowski static int ice_max_xdp_frame_size(struct ice_vsi *vsi) 657323b44513SMaciej Fijalkowski { 657423b44513SMaciej Fijalkowski if (PAGE_SIZE >= 8192 || test_bit(ICE_FLAG_LEGACY_RX, vsi->back->flags)) 657523b44513SMaciej Fijalkowski return ICE_RXBUF_2048 - XDP_PACKET_HEADROOM; 657623b44513SMaciej Fijalkowski else 657723b44513SMaciej Fijalkowski return ICE_RXBUF_3072; 657823b44513SMaciej Fijalkowski } 657923b44513SMaciej Fijalkowski 658023b44513SMaciej Fijalkowski /** 6581e94d4478SAnirudh Venkataramanan * ice_change_mtu - NDO callback to change the MTU 6582e94d4478SAnirudh Venkataramanan * @netdev: network interface device structure 6583e94d4478SAnirudh Venkataramanan * @new_mtu: new value for maximum frame size 6584e94d4478SAnirudh Venkataramanan * 6585e94d4478SAnirudh Venkataramanan * Returns 0 on success, negative on failure 6586e94d4478SAnirudh Venkataramanan */ 6587e94d4478SAnirudh Venkataramanan static int ice_change_mtu(struct net_device *netdev, int new_mtu) 6588e94d4478SAnirudh Venkataramanan { 6589e94d4478SAnirudh Venkataramanan struct ice_netdev_priv *np = netdev_priv(netdev); 6590e94d4478SAnirudh Venkataramanan struct ice_vsi *vsi = np->vsi; 6591e94d4478SAnirudh Venkataramanan struct ice_pf *pf = vsi->back; 6592348048e7SDave Ertman struct iidc_event *event; 6593e94d4478SAnirudh Venkataramanan u8 count = 0; 6594348048e7SDave Ertman int err = 0; 6595e94d4478SAnirudh Venkataramanan 659622bef5e7SJesse Brandeburg if (new_mtu == (int)netdev->mtu) { 65972f2da36eSAnirudh Venkataramanan netdev_warn(netdev, "MTU is already %u\n", netdev->mtu); 6598e94d4478SAnirudh Venkataramanan return 0; 6599e94d4478SAnirudh Venkataramanan } 6600e94d4478SAnirudh Venkataramanan 6601efc2214bSMaciej Fijalkowski if (ice_is_xdp_ena_vsi(vsi)) { 660223b44513SMaciej Fijalkowski int frame_size = ice_max_xdp_frame_size(vsi); 6603efc2214bSMaciej Fijalkowski 6604efc2214bSMaciej Fijalkowski if (new_mtu + ICE_ETH_PKT_HDR_PAD > frame_size) { 6605efc2214bSMaciej Fijalkowski netdev_err(netdev, "max MTU for XDP usage is %d\n", 660623b44513SMaciej Fijalkowski frame_size - ICE_ETH_PKT_HDR_PAD); 6607efc2214bSMaciej Fijalkowski return -EINVAL; 6608efc2214bSMaciej Fijalkowski } 6609efc2214bSMaciej Fijalkowski } 6610efc2214bSMaciej Fijalkowski 6611e94d4478SAnirudh Venkataramanan /* if a reset is in progress, wait for some time for it to complete */ 6612e94d4478SAnirudh Venkataramanan do { 66135df7e45dSDave Ertman if (ice_is_reset_in_progress(pf->state)) { 6614e94d4478SAnirudh Venkataramanan count++; 6615e94d4478SAnirudh Venkataramanan usleep_range(1000, 2000); 6616e94d4478SAnirudh Venkataramanan } else { 6617e94d4478SAnirudh Venkataramanan break; 6618e94d4478SAnirudh Venkataramanan } 6619e94d4478SAnirudh Venkataramanan 6620e94d4478SAnirudh Venkataramanan } while (count < 100); 6621e94d4478SAnirudh Venkataramanan 6622e94d4478SAnirudh Venkataramanan if (count == 100) { 66232f2da36eSAnirudh Venkataramanan netdev_err(netdev, "can't change MTU. Device is busy\n"); 6624e94d4478SAnirudh Venkataramanan return -EBUSY; 6625e94d4478SAnirudh Venkataramanan } 6626e94d4478SAnirudh Venkataramanan 6627348048e7SDave Ertman event = kzalloc(sizeof(*event), GFP_KERNEL); 6628348048e7SDave Ertman if (!event) 6629348048e7SDave Ertman return -ENOMEM; 6630348048e7SDave Ertman 6631348048e7SDave Ertman set_bit(IIDC_EVENT_BEFORE_MTU_CHANGE, event->type); 6632348048e7SDave Ertman ice_send_event_to_aux(pf, event); 6633348048e7SDave Ertman clear_bit(IIDC_EVENT_BEFORE_MTU_CHANGE, event->type); 6634348048e7SDave Ertman 663522bef5e7SJesse Brandeburg netdev->mtu = (unsigned int)new_mtu; 6636e94d4478SAnirudh Venkataramanan 6637e94d4478SAnirudh Venkataramanan /* if VSI is up, bring it down and then back up */ 6638e97fb1aeSAnirudh Venkataramanan if (!test_and_set_bit(ICE_VSI_DOWN, vsi->state)) { 6639e94d4478SAnirudh Venkataramanan err = ice_down(vsi); 6640e94d4478SAnirudh Venkataramanan if (err) { 6641fe6cd890SMitch Williams netdev_err(netdev, "change MTU if_down err %d\n", err); 6642348048e7SDave Ertman goto event_after; 6643e94d4478SAnirudh Venkataramanan } 6644e94d4478SAnirudh Venkataramanan 6645e94d4478SAnirudh Venkataramanan err = ice_up(vsi); 6646e94d4478SAnirudh Venkataramanan if (err) { 66472f2da36eSAnirudh Venkataramanan netdev_err(netdev, "change MTU if_up err %d\n", err); 6648348048e7SDave Ertman goto event_after; 6649e94d4478SAnirudh Venkataramanan } 6650e94d4478SAnirudh Venkataramanan } 6651e94d4478SAnirudh Venkataramanan 6652bda5b7dbSTony Nguyen netdev_dbg(netdev, "changed MTU to %d\n", new_mtu); 6653348048e7SDave Ertman event_after: 6654348048e7SDave Ertman set_bit(IIDC_EVENT_AFTER_MTU_CHANGE, event->type); 6655348048e7SDave Ertman ice_send_event_to_aux(pf, event); 6656348048e7SDave Ertman kfree(event); 6657348048e7SDave Ertman 6658348048e7SDave Ertman return err; 6659e94d4478SAnirudh Venkataramanan } 6660e94d4478SAnirudh Venkataramanan 6661e94d4478SAnirudh Venkataramanan /** 6662a7605370SArnd Bergmann * ice_eth_ioctl - Access the hwtstamp interface 666377a78115SJacob Keller * @netdev: network interface device structure 666477a78115SJacob Keller * @ifr: interface request data 666577a78115SJacob Keller * @cmd: ioctl command 666677a78115SJacob Keller */ 6667a7605370SArnd Bergmann static int ice_eth_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd) 666877a78115SJacob Keller { 666977a78115SJacob Keller struct ice_netdev_priv *np = netdev_priv(netdev); 667077a78115SJacob Keller struct ice_pf *pf = np->vsi->back; 667177a78115SJacob Keller 667277a78115SJacob Keller switch (cmd) { 667377a78115SJacob Keller case SIOCGHWTSTAMP: 667477a78115SJacob Keller return ice_ptp_get_ts_config(pf, ifr); 667577a78115SJacob Keller case SIOCSHWTSTAMP: 667677a78115SJacob Keller return ice_ptp_set_ts_config(pf, ifr); 667777a78115SJacob Keller default: 667877a78115SJacob Keller return -EOPNOTSUPP; 667977a78115SJacob Keller } 668077a78115SJacob Keller } 668177a78115SJacob Keller 668277a78115SJacob Keller /** 66830fee3577SLihong Yang * ice_aq_str - convert AQ err code to a string 66840fee3577SLihong Yang * @aq_err: the AQ error code to convert 66850fee3577SLihong Yang */ 66860fee3577SLihong Yang const char *ice_aq_str(enum ice_aq_err aq_err) 66870fee3577SLihong Yang { 66880fee3577SLihong Yang switch (aq_err) { 66890fee3577SLihong Yang case ICE_AQ_RC_OK: 66900fee3577SLihong Yang return "OK"; 66910fee3577SLihong Yang case ICE_AQ_RC_EPERM: 66920fee3577SLihong Yang return "ICE_AQ_RC_EPERM"; 66930fee3577SLihong Yang case ICE_AQ_RC_ENOENT: 66940fee3577SLihong Yang return "ICE_AQ_RC_ENOENT"; 66950fee3577SLihong Yang case ICE_AQ_RC_ENOMEM: 66960fee3577SLihong Yang return "ICE_AQ_RC_ENOMEM"; 66970fee3577SLihong Yang case ICE_AQ_RC_EBUSY: 66980fee3577SLihong Yang return "ICE_AQ_RC_EBUSY"; 66990fee3577SLihong Yang case ICE_AQ_RC_EEXIST: 67000fee3577SLihong Yang return "ICE_AQ_RC_EEXIST"; 67010fee3577SLihong Yang case ICE_AQ_RC_EINVAL: 67020fee3577SLihong Yang return "ICE_AQ_RC_EINVAL"; 67030fee3577SLihong Yang case ICE_AQ_RC_ENOSPC: 67040fee3577SLihong Yang return "ICE_AQ_RC_ENOSPC"; 67050fee3577SLihong Yang case ICE_AQ_RC_ENOSYS: 67060fee3577SLihong Yang return "ICE_AQ_RC_ENOSYS"; 6707b5e19a64SChinh T Cao case ICE_AQ_RC_EMODE: 6708b5e19a64SChinh T Cao return "ICE_AQ_RC_EMODE"; 67090fee3577SLihong Yang case ICE_AQ_RC_ENOSEC: 67100fee3577SLihong Yang return "ICE_AQ_RC_ENOSEC"; 67110fee3577SLihong Yang case ICE_AQ_RC_EBADSIG: 67120fee3577SLihong Yang return "ICE_AQ_RC_EBADSIG"; 67130fee3577SLihong Yang case ICE_AQ_RC_ESVN: 67140fee3577SLihong Yang return "ICE_AQ_RC_ESVN"; 67150fee3577SLihong Yang case ICE_AQ_RC_EBADMAN: 67160fee3577SLihong Yang return "ICE_AQ_RC_EBADMAN"; 67170fee3577SLihong Yang case ICE_AQ_RC_EBADBUF: 67180fee3577SLihong Yang return "ICE_AQ_RC_EBADBUF"; 67190fee3577SLihong Yang } 67200fee3577SLihong Yang 67210fee3577SLihong Yang return "ICE_AQ_RC_UNKNOWN"; 67220fee3577SLihong Yang } 67230fee3577SLihong Yang 67240fee3577SLihong Yang /** 67250fee3577SLihong Yang * ice_stat_str - convert status err code to a string 67260fee3577SLihong Yang * @stat_err: the status error code to convert 67270fee3577SLihong Yang */ 67280fee3577SLihong Yang const char *ice_stat_str(enum ice_status stat_err) 67290fee3577SLihong Yang { 67300fee3577SLihong Yang switch (stat_err) { 67310fee3577SLihong Yang case ICE_SUCCESS: 67320fee3577SLihong Yang return "OK"; 67330fee3577SLihong Yang case ICE_ERR_PARAM: 67340fee3577SLihong Yang return "ICE_ERR_PARAM"; 67350fee3577SLihong Yang case ICE_ERR_NOT_IMPL: 67360fee3577SLihong Yang return "ICE_ERR_NOT_IMPL"; 67370fee3577SLihong Yang case ICE_ERR_NOT_READY: 67380fee3577SLihong Yang return "ICE_ERR_NOT_READY"; 67390fee3577SLihong Yang case ICE_ERR_NOT_SUPPORTED: 67400fee3577SLihong Yang return "ICE_ERR_NOT_SUPPORTED"; 67410fee3577SLihong Yang case ICE_ERR_BAD_PTR: 67420fee3577SLihong Yang return "ICE_ERR_BAD_PTR"; 67430fee3577SLihong Yang case ICE_ERR_INVAL_SIZE: 67440fee3577SLihong Yang return "ICE_ERR_INVAL_SIZE"; 67450fee3577SLihong Yang case ICE_ERR_DEVICE_NOT_SUPPORTED: 67460fee3577SLihong Yang return "ICE_ERR_DEVICE_NOT_SUPPORTED"; 67470fee3577SLihong Yang case ICE_ERR_RESET_FAILED: 67480fee3577SLihong Yang return "ICE_ERR_RESET_FAILED"; 67490fee3577SLihong Yang case ICE_ERR_FW_API_VER: 67500fee3577SLihong Yang return "ICE_ERR_FW_API_VER"; 67510fee3577SLihong Yang case ICE_ERR_NO_MEMORY: 67520fee3577SLihong Yang return "ICE_ERR_NO_MEMORY"; 67530fee3577SLihong Yang case ICE_ERR_CFG: 67540fee3577SLihong Yang return "ICE_ERR_CFG"; 67550fee3577SLihong Yang case ICE_ERR_OUT_OF_RANGE: 67560fee3577SLihong Yang return "ICE_ERR_OUT_OF_RANGE"; 67570fee3577SLihong Yang case ICE_ERR_ALREADY_EXISTS: 67580fee3577SLihong Yang return "ICE_ERR_ALREADY_EXISTS"; 6759e120a9abSJacob Keller case ICE_ERR_NVM: 6760e120a9abSJacob Keller return "ICE_ERR_NVM"; 67610fee3577SLihong Yang case ICE_ERR_NVM_CHECKSUM: 67620fee3577SLihong Yang return "ICE_ERR_NVM_CHECKSUM"; 67630fee3577SLihong Yang case ICE_ERR_BUF_TOO_SHORT: 67640fee3577SLihong Yang return "ICE_ERR_BUF_TOO_SHORT"; 67650fee3577SLihong Yang case ICE_ERR_NVM_BLANK_MODE: 67660fee3577SLihong Yang return "ICE_ERR_NVM_BLANK_MODE"; 67670fee3577SLihong Yang case ICE_ERR_IN_USE: 67680fee3577SLihong Yang return "ICE_ERR_IN_USE"; 67690fee3577SLihong Yang case ICE_ERR_MAX_LIMIT: 67700fee3577SLihong Yang return "ICE_ERR_MAX_LIMIT"; 67710fee3577SLihong Yang case ICE_ERR_RESET_ONGOING: 67720fee3577SLihong Yang return "ICE_ERR_RESET_ONGOING"; 67730fee3577SLihong Yang case ICE_ERR_HW_TABLE: 67740fee3577SLihong Yang return "ICE_ERR_HW_TABLE"; 67750fee3577SLihong Yang case ICE_ERR_DOES_NOT_EXIST: 67760fee3577SLihong Yang return "ICE_ERR_DOES_NOT_EXIST"; 6777b8272919SVictor Raj case ICE_ERR_FW_DDP_MISMATCH: 6778b8272919SVictor Raj return "ICE_ERR_FW_DDP_MISMATCH"; 67790fee3577SLihong Yang case ICE_ERR_AQ_ERROR: 67800fee3577SLihong Yang return "ICE_ERR_AQ_ERROR"; 67810fee3577SLihong Yang case ICE_ERR_AQ_TIMEOUT: 67820fee3577SLihong Yang return "ICE_ERR_AQ_TIMEOUT"; 67830fee3577SLihong Yang case ICE_ERR_AQ_FULL: 67840fee3577SLihong Yang return "ICE_ERR_AQ_FULL"; 67850fee3577SLihong Yang case ICE_ERR_AQ_NO_WORK: 67860fee3577SLihong Yang return "ICE_ERR_AQ_NO_WORK"; 67870fee3577SLihong Yang case ICE_ERR_AQ_EMPTY: 67880fee3577SLihong Yang return "ICE_ERR_AQ_EMPTY"; 6789b5c7f857SEvan Swanson case ICE_ERR_AQ_FW_CRITICAL: 6790b5c7f857SEvan Swanson return "ICE_ERR_AQ_FW_CRITICAL"; 67910fee3577SLihong Yang } 67920fee3577SLihong Yang 67930fee3577SLihong Yang return "ICE_ERR_UNKNOWN"; 67940fee3577SLihong Yang } 67950fee3577SLihong Yang 67960fee3577SLihong Yang /** 6797b66a972aSBrett Creeley * ice_set_rss_lut - Set RSS LUT 6798d76a60baSAnirudh Venkataramanan * @vsi: Pointer to VSI structure 6799d76a60baSAnirudh Venkataramanan * @lut: Lookup table 6800d76a60baSAnirudh Venkataramanan * @lut_size: Lookup table size 6801d76a60baSAnirudh Venkataramanan * 6802d76a60baSAnirudh Venkataramanan * Returns 0 on success, negative on failure 6803d76a60baSAnirudh Venkataramanan */ 6804b66a972aSBrett Creeley int ice_set_rss_lut(struct ice_vsi *vsi, u8 *lut, u16 lut_size) 6805d76a60baSAnirudh Venkataramanan { 6806b66a972aSBrett Creeley struct ice_aq_get_set_rss_lut_params params = {}; 6807b66a972aSBrett Creeley struct ice_hw *hw = &vsi->back->hw; 6808d76a60baSAnirudh Venkataramanan enum ice_status status; 6809d76a60baSAnirudh Venkataramanan 6810b66a972aSBrett Creeley if (!lut) 6811b66a972aSBrett Creeley return -EINVAL; 6812d76a60baSAnirudh Venkataramanan 6813b66a972aSBrett Creeley params.vsi_handle = vsi->idx; 6814b66a972aSBrett Creeley params.lut_size = lut_size; 6815b66a972aSBrett Creeley params.lut_type = vsi->rss_lut_type; 6816b66a972aSBrett Creeley params.lut = lut; 6817d76a60baSAnirudh Venkataramanan 6818b66a972aSBrett Creeley status = ice_aq_set_rss_lut(hw, ¶ms); 6819d76a60baSAnirudh Venkataramanan if (status) { 6820b66a972aSBrett Creeley dev_err(ice_pf_to_dev(vsi->back), "Cannot set RSS lut, err %s aq_err %s\n", 68210fee3577SLihong Yang ice_stat_str(status), 68229d68a79cSJesse Brandeburg ice_aq_str(hw->adminq.sq_last_status)); 6823d76a60baSAnirudh Venkataramanan return -EIO; 6824d76a60baSAnirudh Venkataramanan } 6825d76a60baSAnirudh Venkataramanan 6826d76a60baSAnirudh Venkataramanan return 0; 6827d76a60baSAnirudh Venkataramanan } 6828d76a60baSAnirudh Venkataramanan 6829d76a60baSAnirudh Venkataramanan /** 6830b66a972aSBrett Creeley * ice_set_rss_key - Set RSS key 6831b66a972aSBrett Creeley * @vsi: Pointer to the VSI structure 6832b66a972aSBrett Creeley * @seed: RSS hash seed 6833b66a972aSBrett Creeley * 6834b66a972aSBrett Creeley * Returns 0 on success, negative on failure 6835b66a972aSBrett Creeley */ 6836b66a972aSBrett Creeley int ice_set_rss_key(struct ice_vsi *vsi, u8 *seed) 6837b66a972aSBrett Creeley { 6838b66a972aSBrett Creeley struct ice_hw *hw = &vsi->back->hw; 6839b66a972aSBrett Creeley enum ice_status status; 6840b66a972aSBrett Creeley 6841b66a972aSBrett Creeley if (!seed) 6842b66a972aSBrett Creeley return -EINVAL; 6843b66a972aSBrett Creeley 6844b66a972aSBrett Creeley status = ice_aq_set_rss_key(hw, vsi->idx, (struct ice_aqc_get_set_rss_keys *)seed); 6845b66a972aSBrett Creeley if (status) { 6846b66a972aSBrett Creeley dev_err(ice_pf_to_dev(vsi->back), "Cannot set RSS key, err %s aq_err %s\n", 6847b66a972aSBrett Creeley ice_stat_str(status), 6848b66a972aSBrett Creeley ice_aq_str(hw->adminq.sq_last_status)); 6849b66a972aSBrett Creeley return -EIO; 6850b66a972aSBrett Creeley } 6851b66a972aSBrett Creeley 6852b66a972aSBrett Creeley return 0; 6853b66a972aSBrett Creeley } 6854b66a972aSBrett Creeley 6855b66a972aSBrett Creeley /** 6856b66a972aSBrett Creeley * ice_get_rss_lut - Get RSS LUT 6857d76a60baSAnirudh Venkataramanan * @vsi: Pointer to VSI structure 6858d76a60baSAnirudh Venkataramanan * @lut: Buffer to store the lookup table entries 6859d76a60baSAnirudh Venkataramanan * @lut_size: Size of buffer to store the lookup table entries 6860d76a60baSAnirudh Venkataramanan * 6861d76a60baSAnirudh Venkataramanan * Returns 0 on success, negative on failure 6862d76a60baSAnirudh Venkataramanan */ 6863b66a972aSBrett Creeley int ice_get_rss_lut(struct ice_vsi *vsi, u8 *lut, u16 lut_size) 6864d76a60baSAnirudh Venkataramanan { 6865b66a972aSBrett Creeley struct ice_aq_get_set_rss_lut_params params = {}; 6866b66a972aSBrett Creeley struct ice_hw *hw = &vsi->back->hw; 6867d76a60baSAnirudh Venkataramanan enum ice_status status; 6868d76a60baSAnirudh Venkataramanan 6869b66a972aSBrett Creeley if (!lut) 6870b66a972aSBrett Creeley return -EINVAL; 6871d76a60baSAnirudh Venkataramanan 6872b66a972aSBrett Creeley params.vsi_handle = vsi->idx; 6873b66a972aSBrett Creeley params.lut_size = lut_size; 6874b66a972aSBrett Creeley params.lut_type = vsi->rss_lut_type; 6875b66a972aSBrett Creeley params.lut = lut; 6876b66a972aSBrett Creeley 6877b66a972aSBrett Creeley status = ice_aq_get_rss_lut(hw, ¶ms); 6878d76a60baSAnirudh Venkataramanan if (status) { 6879b66a972aSBrett Creeley dev_err(ice_pf_to_dev(vsi->back), "Cannot get RSS lut, err %s aq_err %s\n", 68800fee3577SLihong Yang ice_stat_str(status), 68819d68a79cSJesse Brandeburg ice_aq_str(hw->adminq.sq_last_status)); 6882d76a60baSAnirudh Venkataramanan return -EIO; 6883d76a60baSAnirudh Venkataramanan } 6884b66a972aSBrett Creeley 6885b66a972aSBrett Creeley return 0; 6886d76a60baSAnirudh Venkataramanan } 6887d76a60baSAnirudh Venkataramanan 6888b66a972aSBrett Creeley /** 6889b66a972aSBrett Creeley * ice_get_rss_key - Get RSS key 6890b66a972aSBrett Creeley * @vsi: Pointer to VSI structure 6891b66a972aSBrett Creeley * @seed: Buffer to store the key in 6892b66a972aSBrett Creeley * 6893b66a972aSBrett Creeley * Returns 0 on success, negative on failure 6894b66a972aSBrett Creeley */ 6895b66a972aSBrett Creeley int ice_get_rss_key(struct ice_vsi *vsi, u8 *seed) 6896b66a972aSBrett Creeley { 6897b66a972aSBrett Creeley struct ice_hw *hw = &vsi->back->hw; 6898b66a972aSBrett Creeley enum ice_status status; 6899e3c53928SBrett Creeley 6900b66a972aSBrett Creeley if (!seed) 6901b66a972aSBrett Creeley return -EINVAL; 6902b66a972aSBrett Creeley 6903b66a972aSBrett Creeley status = ice_aq_get_rss_key(hw, vsi->idx, (struct ice_aqc_get_set_rss_keys *)seed); 6904d76a60baSAnirudh Venkataramanan if (status) { 6905b66a972aSBrett Creeley dev_err(ice_pf_to_dev(vsi->back), "Cannot get RSS key, err %s aq_err %s\n", 69060fee3577SLihong Yang ice_stat_str(status), 69079d68a79cSJesse Brandeburg ice_aq_str(hw->adminq.sq_last_status)); 6908d76a60baSAnirudh Venkataramanan return -EIO; 6909d76a60baSAnirudh Venkataramanan } 6910d76a60baSAnirudh Venkataramanan 6911d76a60baSAnirudh Venkataramanan return 0; 6912d76a60baSAnirudh Venkataramanan } 6913d76a60baSAnirudh Venkataramanan 6914d76a60baSAnirudh Venkataramanan /** 6915b1edc14aSMd Fahad Iqbal Polash * ice_bridge_getlink - Get the hardware bridge mode 6916b1edc14aSMd Fahad Iqbal Polash * @skb: skb buff 6917f9867df6SAnirudh Venkataramanan * @pid: process ID 6918b1edc14aSMd Fahad Iqbal Polash * @seq: RTNL message seq 6919b1edc14aSMd Fahad Iqbal Polash * @dev: the netdev being configured 6920b1edc14aSMd Fahad Iqbal Polash * @filter_mask: filter mask passed in 6921b1edc14aSMd Fahad Iqbal Polash * @nlflags: netlink flags passed in 6922b1edc14aSMd Fahad Iqbal Polash * 6923b1edc14aSMd Fahad Iqbal Polash * Return the bridge mode (VEB/VEPA) 6924b1edc14aSMd Fahad Iqbal Polash */ 6925b1edc14aSMd Fahad Iqbal Polash static int 6926b1edc14aSMd Fahad Iqbal Polash ice_bridge_getlink(struct sk_buff *skb, u32 pid, u32 seq, 6927b1edc14aSMd Fahad Iqbal Polash struct net_device *dev, u32 filter_mask, int nlflags) 6928b1edc14aSMd Fahad Iqbal Polash { 6929b1edc14aSMd Fahad Iqbal Polash struct ice_netdev_priv *np = netdev_priv(dev); 6930b1edc14aSMd Fahad Iqbal Polash struct ice_vsi *vsi = np->vsi; 6931b1edc14aSMd Fahad Iqbal Polash struct ice_pf *pf = vsi->back; 6932b1edc14aSMd Fahad Iqbal Polash u16 bmode; 6933b1edc14aSMd Fahad Iqbal Polash 6934b1edc14aSMd Fahad Iqbal Polash bmode = pf->first_sw->bridge_mode; 6935b1edc14aSMd Fahad Iqbal Polash 6936b1edc14aSMd Fahad Iqbal Polash return ndo_dflt_bridge_getlink(skb, pid, seq, dev, bmode, 0, 0, nlflags, 6937b1edc14aSMd Fahad Iqbal Polash filter_mask, NULL); 6938b1edc14aSMd Fahad Iqbal Polash } 6939b1edc14aSMd Fahad Iqbal Polash 6940b1edc14aSMd Fahad Iqbal Polash /** 6941b1edc14aSMd Fahad Iqbal Polash * ice_vsi_update_bridge_mode - Update VSI for switching bridge mode (VEB/VEPA) 6942b1edc14aSMd Fahad Iqbal Polash * @vsi: Pointer to VSI structure 6943b1edc14aSMd Fahad Iqbal Polash * @bmode: Hardware bridge mode (VEB/VEPA) 6944b1edc14aSMd Fahad Iqbal Polash * 6945b1edc14aSMd Fahad Iqbal Polash * Returns 0 on success, negative on failure 6946b1edc14aSMd Fahad Iqbal Polash */ 6947b1edc14aSMd Fahad Iqbal Polash static int ice_vsi_update_bridge_mode(struct ice_vsi *vsi, u16 bmode) 6948b1edc14aSMd Fahad Iqbal Polash { 6949b1edc14aSMd Fahad Iqbal Polash struct ice_aqc_vsi_props *vsi_props; 6950b1edc14aSMd Fahad Iqbal Polash struct ice_hw *hw = &vsi->back->hw; 6951198a666aSBruce Allan struct ice_vsi_ctx *ctxt; 6952b1edc14aSMd Fahad Iqbal Polash enum ice_status status; 6953198a666aSBruce Allan int ret = 0; 6954b1edc14aSMd Fahad Iqbal Polash 6955b1edc14aSMd Fahad Iqbal Polash vsi_props = &vsi->info; 6956198a666aSBruce Allan 69579efe35d0STony Nguyen ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL); 6958198a666aSBruce Allan if (!ctxt) 6959198a666aSBruce Allan return -ENOMEM; 6960198a666aSBruce Allan 6961198a666aSBruce Allan ctxt->info = vsi->info; 6962b1edc14aSMd Fahad Iqbal Polash 6963b1edc14aSMd Fahad Iqbal Polash if (bmode == BRIDGE_MODE_VEB) 6964b1edc14aSMd Fahad Iqbal Polash /* change from VEPA to VEB mode */ 6965198a666aSBruce Allan ctxt->info.sw_flags |= ICE_AQ_VSI_SW_FLAG_ALLOW_LB; 6966b1edc14aSMd Fahad Iqbal Polash else 6967b1edc14aSMd Fahad Iqbal Polash /* change from VEB to VEPA mode */ 6968198a666aSBruce Allan ctxt->info.sw_flags &= ~ICE_AQ_VSI_SW_FLAG_ALLOW_LB; 6969198a666aSBruce Allan ctxt->info.valid_sections = cpu_to_le16(ICE_AQ_VSI_PROP_SW_VALID); 69705726ca0eSAnirudh Venkataramanan 6971198a666aSBruce Allan status = ice_update_vsi(hw, vsi->idx, ctxt, NULL); 6972b1edc14aSMd Fahad Iqbal Polash if (status) { 69730fee3577SLihong Yang dev_err(ice_pf_to_dev(vsi->back), "update VSI for bridge mode failed, bmode = %d err %s aq_err %s\n", 69740fee3577SLihong Yang bmode, ice_stat_str(status), 69750fee3577SLihong Yang ice_aq_str(hw->adminq.sq_last_status)); 6976198a666aSBruce Allan ret = -EIO; 6977198a666aSBruce Allan goto out; 6978b1edc14aSMd Fahad Iqbal Polash } 6979b1edc14aSMd Fahad Iqbal Polash /* Update sw flags for book keeping */ 6980198a666aSBruce Allan vsi_props->sw_flags = ctxt->info.sw_flags; 6981b1edc14aSMd Fahad Iqbal Polash 6982198a666aSBruce Allan out: 69839efe35d0STony Nguyen kfree(ctxt); 6984198a666aSBruce Allan return ret; 6985b1edc14aSMd Fahad Iqbal Polash } 6986b1edc14aSMd Fahad Iqbal Polash 6987b1edc14aSMd Fahad Iqbal Polash /** 6988b1edc14aSMd Fahad Iqbal Polash * ice_bridge_setlink - Set the hardware bridge mode 6989b1edc14aSMd Fahad Iqbal Polash * @dev: the netdev being configured 6990b1edc14aSMd Fahad Iqbal Polash * @nlh: RTNL message 6991b1edc14aSMd Fahad Iqbal Polash * @flags: bridge setlink flags 69922fd527b7SPetr Machata * @extack: netlink extended ack 6993b1edc14aSMd Fahad Iqbal Polash * 6994b1edc14aSMd Fahad Iqbal Polash * Sets the bridge mode (VEB/VEPA) of the switch to which the netdev (VSI) is 6995b1edc14aSMd Fahad Iqbal Polash * hooked up to. Iterates through the PF VSI list and sets the loopback mode (if 6996b1edc14aSMd Fahad Iqbal Polash * not already set for all VSIs connected to this switch. And also update the 6997b1edc14aSMd Fahad Iqbal Polash * unicast switch filter rules for the corresponding switch of the netdev. 6998b1edc14aSMd Fahad Iqbal Polash */ 6999b1edc14aSMd Fahad Iqbal Polash static int 7000b1edc14aSMd Fahad Iqbal Polash ice_bridge_setlink(struct net_device *dev, struct nlmsghdr *nlh, 70013d505147SBruce Allan u16 __always_unused flags, 70023d505147SBruce Allan struct netlink_ext_ack __always_unused *extack) 7003b1edc14aSMd Fahad Iqbal Polash { 7004b1edc14aSMd Fahad Iqbal Polash struct ice_netdev_priv *np = netdev_priv(dev); 7005b1edc14aSMd Fahad Iqbal Polash struct ice_pf *pf = np->vsi->back; 7006b1edc14aSMd Fahad Iqbal Polash struct nlattr *attr, *br_spec; 7007b1edc14aSMd Fahad Iqbal Polash struct ice_hw *hw = &pf->hw; 7008b1edc14aSMd Fahad Iqbal Polash enum ice_status status; 7009b1edc14aSMd Fahad Iqbal Polash struct ice_sw *pf_sw; 7010b1edc14aSMd Fahad Iqbal Polash int rem, v, err = 0; 7011b1edc14aSMd Fahad Iqbal Polash 7012b1edc14aSMd Fahad Iqbal Polash pf_sw = pf->first_sw; 7013b1edc14aSMd Fahad Iqbal Polash /* find the attribute in the netlink message */ 7014b1edc14aSMd Fahad Iqbal Polash br_spec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC); 7015b1edc14aSMd Fahad Iqbal Polash 7016b1edc14aSMd Fahad Iqbal Polash nla_for_each_nested(attr, br_spec, rem) { 7017b1edc14aSMd Fahad Iqbal Polash __u16 mode; 7018b1edc14aSMd Fahad Iqbal Polash 7019b1edc14aSMd Fahad Iqbal Polash if (nla_type(attr) != IFLA_BRIDGE_MODE) 7020b1edc14aSMd Fahad Iqbal Polash continue; 7021b1edc14aSMd Fahad Iqbal Polash mode = nla_get_u16(attr); 7022b1edc14aSMd Fahad Iqbal Polash if (mode != BRIDGE_MODE_VEPA && mode != BRIDGE_MODE_VEB) 7023b1edc14aSMd Fahad Iqbal Polash return -EINVAL; 7024b1edc14aSMd Fahad Iqbal Polash /* Continue if bridge mode is not being flipped */ 7025b1edc14aSMd Fahad Iqbal Polash if (mode == pf_sw->bridge_mode) 7026b1edc14aSMd Fahad Iqbal Polash continue; 7027b1edc14aSMd Fahad Iqbal Polash /* Iterates through the PF VSI list and update the loopback 7028b1edc14aSMd Fahad Iqbal Polash * mode of the VSI 7029b1edc14aSMd Fahad Iqbal Polash */ 7030b1edc14aSMd Fahad Iqbal Polash ice_for_each_vsi(pf, v) { 7031b1edc14aSMd Fahad Iqbal Polash if (!pf->vsi[v]) 7032b1edc14aSMd Fahad Iqbal Polash continue; 7033b1edc14aSMd Fahad Iqbal Polash err = ice_vsi_update_bridge_mode(pf->vsi[v], mode); 7034b1edc14aSMd Fahad Iqbal Polash if (err) 7035b1edc14aSMd Fahad Iqbal Polash return err; 7036b1edc14aSMd Fahad Iqbal Polash } 7037b1edc14aSMd Fahad Iqbal Polash 7038b1edc14aSMd Fahad Iqbal Polash hw->evb_veb = (mode == BRIDGE_MODE_VEB); 7039b1edc14aSMd Fahad Iqbal Polash /* Update the unicast switch filter rules for the corresponding 7040b1edc14aSMd Fahad Iqbal Polash * switch of the netdev 7041b1edc14aSMd Fahad Iqbal Polash */ 7042b1edc14aSMd Fahad Iqbal Polash status = ice_update_sw_rule_bridge_mode(hw); 7043b1edc14aSMd Fahad Iqbal Polash if (status) { 70440fee3577SLihong Yang netdev_err(dev, "switch rule update failed, mode = %d err %s aq_err %s\n", 70450fee3577SLihong Yang mode, ice_stat_str(status), 70460fee3577SLihong Yang ice_aq_str(hw->adminq.sq_last_status)); 7047b1edc14aSMd Fahad Iqbal Polash /* revert hw->evb_veb */ 7048b1edc14aSMd Fahad Iqbal Polash hw->evb_veb = (pf_sw->bridge_mode == BRIDGE_MODE_VEB); 7049b1edc14aSMd Fahad Iqbal Polash return -EIO; 7050b1edc14aSMd Fahad Iqbal Polash } 7051b1edc14aSMd Fahad Iqbal Polash 7052b1edc14aSMd Fahad Iqbal Polash pf_sw->bridge_mode = mode; 7053b1edc14aSMd Fahad Iqbal Polash } 7054b1edc14aSMd Fahad Iqbal Polash 7055b1edc14aSMd Fahad Iqbal Polash return 0; 7056b1edc14aSMd Fahad Iqbal Polash } 7057b1edc14aSMd Fahad Iqbal Polash 7058b1edc14aSMd Fahad Iqbal Polash /** 7059b3969fd7SSudheer Mogilappagari * ice_tx_timeout - Respond to a Tx Hang 7060b3969fd7SSudheer Mogilappagari * @netdev: network interface device structure 7061644f40eaSBruce Allan * @txqueue: Tx queue 7062b3969fd7SSudheer Mogilappagari */ 70630290bd29SMichael S. Tsirkin static void ice_tx_timeout(struct net_device *netdev, unsigned int txqueue) 7064b3969fd7SSudheer Mogilappagari { 7065b3969fd7SSudheer Mogilappagari struct ice_netdev_priv *np = netdev_priv(netdev); 7066e72bba21SMaciej Fijalkowski struct ice_tx_ring *tx_ring = NULL; 7067b3969fd7SSudheer Mogilappagari struct ice_vsi *vsi = np->vsi; 7068b3969fd7SSudheer Mogilappagari struct ice_pf *pf = vsi->back; 7069807bc98dSBrett Creeley u32 i; 7070b3969fd7SSudheer Mogilappagari 7071b3969fd7SSudheer Mogilappagari pf->tx_timeout_count++; 7072b3969fd7SSudheer Mogilappagari 7073610ed0e9SAvinash JD /* Check if PFC is enabled for the TC to which the queue belongs 7074610ed0e9SAvinash JD * to. If yes then Tx timeout is not caused by a hung queue, no 7075610ed0e9SAvinash JD * need to reset and rebuild 7076610ed0e9SAvinash JD */ 7077610ed0e9SAvinash JD if (ice_is_pfc_causing_hung_q(pf, txqueue)) { 7078610ed0e9SAvinash JD dev_info(ice_pf_to_dev(pf), "Fake Tx hang detected on queue %u, timeout caused by PFC storm\n", 7079610ed0e9SAvinash JD txqueue); 7080610ed0e9SAvinash JD return; 7081610ed0e9SAvinash JD } 7082610ed0e9SAvinash JD 7083b3969fd7SSudheer Mogilappagari /* now that we have an index, find the tx_ring struct */ 70842faf63b6SMaciej Fijalkowski ice_for_each_txq(vsi, i) 7085bc0c6fabSBruce Allan if (vsi->tx_rings[i] && vsi->tx_rings[i]->desc) 7086ed5a3f66SJulio Faracco if (txqueue == vsi->tx_rings[i]->q_index) { 7087b3969fd7SSudheer Mogilappagari tx_ring = vsi->tx_rings[i]; 7088b3969fd7SSudheer Mogilappagari break; 7089b3969fd7SSudheer Mogilappagari } 7090b3969fd7SSudheer Mogilappagari 7091b3969fd7SSudheer Mogilappagari /* Reset recovery level if enough time has elapsed after last timeout. 7092b3969fd7SSudheer Mogilappagari * Also ensure no new reset action happens before next timeout period. 7093b3969fd7SSudheer Mogilappagari */ 7094b3969fd7SSudheer Mogilappagari if (time_after(jiffies, (pf->tx_timeout_last_recovery + HZ * 20))) 7095b3969fd7SSudheer Mogilappagari pf->tx_timeout_recovery_level = 1; 7096b3969fd7SSudheer Mogilappagari else if (time_before(jiffies, (pf->tx_timeout_last_recovery + 7097b3969fd7SSudheer Mogilappagari netdev->watchdog_timeo))) 7098b3969fd7SSudheer Mogilappagari return; 7099b3969fd7SSudheer Mogilappagari 7100b3969fd7SSudheer Mogilappagari if (tx_ring) { 7101807bc98dSBrett Creeley struct ice_hw *hw = &pf->hw; 7102807bc98dSBrett Creeley u32 head, val = 0; 7103807bc98dSBrett Creeley 7104ed5a3f66SJulio Faracco head = (rd32(hw, QTX_COMM_HEAD(vsi->txq_map[txqueue])) & 7105807bc98dSBrett Creeley QTX_COMM_HEAD_HEAD_M) >> QTX_COMM_HEAD_HEAD_S; 7106b3969fd7SSudheer Mogilappagari /* Read interrupt register */ 7107ba880734SBrett Creeley val = rd32(hw, GLINT_DYN_CTL(tx_ring->q_vector->reg_idx)); 7108b3969fd7SSudheer Mogilappagari 710993ff4858STony 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", 7110ed5a3f66SJulio Faracco vsi->vsi_num, txqueue, tx_ring->next_to_clean, 7111807bc98dSBrett Creeley head, tx_ring->next_to_use, val); 7112b3969fd7SSudheer Mogilappagari } 7113b3969fd7SSudheer Mogilappagari 7114b3969fd7SSudheer Mogilappagari pf->tx_timeout_last_recovery = jiffies; 711593ff4858STony Nguyen netdev_info(netdev, "tx_timeout recovery level %d, txqueue %u\n", 7116ed5a3f66SJulio Faracco pf->tx_timeout_recovery_level, txqueue); 7117b3969fd7SSudheer Mogilappagari 7118b3969fd7SSudheer Mogilappagari switch (pf->tx_timeout_recovery_level) { 7119b3969fd7SSudheer Mogilappagari case 1: 71207e408e07SAnirudh Venkataramanan set_bit(ICE_PFR_REQ, pf->state); 7121b3969fd7SSudheer Mogilappagari break; 7122b3969fd7SSudheer Mogilappagari case 2: 71237e408e07SAnirudh Venkataramanan set_bit(ICE_CORER_REQ, pf->state); 7124b3969fd7SSudheer Mogilappagari break; 7125b3969fd7SSudheer Mogilappagari case 3: 71267e408e07SAnirudh Venkataramanan set_bit(ICE_GLOBR_REQ, pf->state); 7127b3969fd7SSudheer Mogilappagari break; 7128b3969fd7SSudheer Mogilappagari default: 7129b3969fd7SSudheer Mogilappagari netdev_err(netdev, "tx_timeout recovery unsuccessful, device is in unrecoverable state.\n"); 71307e408e07SAnirudh Venkataramanan set_bit(ICE_DOWN, pf->state); 7131e97fb1aeSAnirudh Venkataramanan set_bit(ICE_VSI_NEEDS_RESTART, vsi->state); 71327e408e07SAnirudh Venkataramanan set_bit(ICE_SERVICE_DIS, pf->state); 7133b3969fd7SSudheer Mogilappagari break; 7134b3969fd7SSudheer Mogilappagari } 7135b3969fd7SSudheer Mogilappagari 7136b3969fd7SSudheer Mogilappagari ice_service_task_schedule(pf); 7137b3969fd7SSudheer Mogilappagari pf->tx_timeout_recovery_level++; 7138b3969fd7SSudheer Mogilappagari } 7139b3969fd7SSudheer Mogilappagari 7140b3969fd7SSudheer Mogilappagari /** 71410d08a441SKiran Patil * ice_setup_tc_cls_flower - flower classifier offloads 71420d08a441SKiran Patil * @np: net device to configure 71430d08a441SKiran Patil * @filter_dev: device on which filter is added 71440d08a441SKiran Patil * @cls_flower: offload data 71450d08a441SKiran Patil */ 71460d08a441SKiran Patil static int 71470d08a441SKiran Patil ice_setup_tc_cls_flower(struct ice_netdev_priv *np, 71480d08a441SKiran Patil struct net_device *filter_dev, 71490d08a441SKiran Patil struct flow_cls_offload *cls_flower) 71500d08a441SKiran Patil { 71510d08a441SKiran Patil struct ice_vsi *vsi = np->vsi; 71520d08a441SKiran Patil 71530d08a441SKiran Patil if (cls_flower->common.chain_index) 71540d08a441SKiran Patil return -EOPNOTSUPP; 71550d08a441SKiran Patil 71560d08a441SKiran Patil switch (cls_flower->command) { 71570d08a441SKiran Patil case FLOW_CLS_REPLACE: 71580d08a441SKiran Patil return ice_add_cls_flower(filter_dev, vsi, cls_flower); 71590d08a441SKiran Patil case FLOW_CLS_DESTROY: 71600d08a441SKiran Patil return ice_del_cls_flower(vsi, cls_flower); 71610d08a441SKiran Patil default: 71620d08a441SKiran Patil return -EINVAL; 71630d08a441SKiran Patil } 71640d08a441SKiran Patil } 71650d08a441SKiran Patil 71660d08a441SKiran Patil /** 71670d08a441SKiran Patil * ice_setup_tc_block_cb - callback handler registered for TC block 71680d08a441SKiran Patil * @type: TC SETUP type 71690d08a441SKiran Patil * @type_data: TC flower offload data that contains user input 71700d08a441SKiran Patil * @cb_priv: netdev private data 71710d08a441SKiran Patil */ 71720d08a441SKiran Patil static int 71730d08a441SKiran Patil ice_setup_tc_block_cb(enum tc_setup_type type, void *type_data, void *cb_priv) 71740d08a441SKiran Patil { 71750d08a441SKiran Patil struct ice_netdev_priv *np = cb_priv; 71760d08a441SKiran Patil 71770d08a441SKiran Patil switch (type) { 71780d08a441SKiran Patil case TC_SETUP_CLSFLOWER: 71790d08a441SKiran Patil return ice_setup_tc_cls_flower(np, np->vsi->netdev, 71800d08a441SKiran Patil type_data); 71810d08a441SKiran Patil default: 71820d08a441SKiran Patil return -EOPNOTSUPP; 71830d08a441SKiran Patil } 71840d08a441SKiran Patil } 71850d08a441SKiran Patil 71860d08a441SKiran Patil static LIST_HEAD(ice_block_cb_list); 71870d08a441SKiran Patil 71880d08a441SKiran Patil static int 71890d08a441SKiran Patil ice_setup_tc(struct net_device *netdev, enum tc_setup_type type, 71900d08a441SKiran Patil void *type_data) 71910d08a441SKiran Patil { 71920d08a441SKiran Patil struct ice_netdev_priv *np = netdev_priv(netdev); 71930d08a441SKiran Patil 71940d08a441SKiran Patil switch (type) { 71950d08a441SKiran Patil case TC_SETUP_BLOCK: 71960d08a441SKiran Patil return flow_block_cb_setup_simple(type_data, 71970d08a441SKiran Patil &ice_block_cb_list, 71980d08a441SKiran Patil ice_setup_tc_block_cb, 71990d08a441SKiran Patil np, np, true); 72000d08a441SKiran Patil default: 72010d08a441SKiran Patil return -EOPNOTSUPP; 72020d08a441SKiran Patil } 72030d08a441SKiran Patil return -EOPNOTSUPP; 72040d08a441SKiran Patil } 72050d08a441SKiran Patil 72060d08a441SKiran Patil /** 7207cdedef59SAnirudh Venkataramanan * ice_open - Called when a network interface becomes active 7208cdedef59SAnirudh Venkataramanan * @netdev: network interface device structure 7209cdedef59SAnirudh Venkataramanan * 7210cdedef59SAnirudh Venkataramanan * The open entry point is called when a network interface is made 7211cdedef59SAnirudh Venkataramanan * active by the system (IFF_UP). At this point all resources needed 7212cdedef59SAnirudh Venkataramanan * for transmit and receive operations are allocated, the interrupt 7213cdedef59SAnirudh Venkataramanan * handler is registered with the OS, the netdev watchdog is enabled, 7214cdedef59SAnirudh Venkataramanan * and the stack is notified that the interface is ready. 7215cdedef59SAnirudh Venkataramanan * 7216cdedef59SAnirudh Venkataramanan * Returns 0 on success, negative value on failure 7217cdedef59SAnirudh Venkataramanan */ 72180e674aebSAnirudh Venkataramanan int ice_open(struct net_device *netdev) 7219cdedef59SAnirudh Venkataramanan { 7220cdedef59SAnirudh Venkataramanan struct ice_netdev_priv *np = netdev_priv(netdev); 7221e95fc857SKrzysztof Goreczny struct ice_pf *pf = np->vsi->back; 7222e95fc857SKrzysztof Goreczny 7223e95fc857SKrzysztof Goreczny if (ice_is_reset_in_progress(pf->state)) { 7224e95fc857SKrzysztof Goreczny netdev_err(netdev, "can't open net device while reset is in progress"); 7225e95fc857SKrzysztof Goreczny return -EBUSY; 7226e95fc857SKrzysztof Goreczny } 7227e95fc857SKrzysztof Goreczny 7228e95fc857SKrzysztof Goreczny return ice_open_internal(netdev); 7229e95fc857SKrzysztof Goreczny } 7230e95fc857SKrzysztof Goreczny 7231e95fc857SKrzysztof Goreczny /** 7232e95fc857SKrzysztof Goreczny * ice_open_internal - Called when a network interface becomes active 7233e95fc857SKrzysztof Goreczny * @netdev: network interface device structure 7234e95fc857SKrzysztof Goreczny * 7235e95fc857SKrzysztof Goreczny * Internal ice_open implementation. Should not be used directly except for ice_open and reset 7236e95fc857SKrzysztof Goreczny * handling routine 7237e95fc857SKrzysztof Goreczny * 7238e95fc857SKrzysztof Goreczny * Returns 0 on success, negative value on failure 7239e95fc857SKrzysztof Goreczny */ 7240e95fc857SKrzysztof Goreczny int ice_open_internal(struct net_device *netdev) 7241e95fc857SKrzysztof Goreczny { 7242e95fc857SKrzysztof Goreczny struct ice_netdev_priv *np = netdev_priv(netdev); 7243cdedef59SAnirudh Venkataramanan struct ice_vsi *vsi = np->vsi; 7244de75135bSAnirudh Venkataramanan struct ice_pf *pf = vsi->back; 72456d599946STony Nguyen struct ice_port_info *pi; 7246d348d517SAnirudh Venkataramanan enum ice_status status; 7247cdedef59SAnirudh Venkataramanan int err; 7248cdedef59SAnirudh Venkataramanan 72497e408e07SAnirudh Venkataramanan if (test_bit(ICE_NEEDS_RESTART, pf->state)) { 72500f9d5027SAnirudh Venkataramanan netdev_err(netdev, "driver needs to be unloaded and reloaded\n"); 72510f9d5027SAnirudh Venkataramanan return -EIO; 72520f9d5027SAnirudh Venkataramanan } 72530f9d5027SAnirudh Venkataramanan 7254cdedef59SAnirudh Venkataramanan netif_carrier_off(netdev); 7255cdedef59SAnirudh Venkataramanan 72566d599946STony Nguyen pi = vsi->port_info; 7257d348d517SAnirudh Venkataramanan status = ice_update_link_info(pi); 7258d348d517SAnirudh Venkataramanan if (status) { 7259d348d517SAnirudh Venkataramanan netdev_err(netdev, "Failed to get link info, error %s\n", 7260d348d517SAnirudh Venkataramanan ice_stat_str(status)); 7261d348d517SAnirudh Venkataramanan return -EIO; 72626d599946STony Nguyen } 72636d599946STony Nguyen 7264c77849f5SAnirudh Venkataramanan ice_check_module_power(pf, pi->phy.link_info.link_cfg_err); 7265c77849f5SAnirudh Venkataramanan 72666d599946STony Nguyen /* Set PHY if there is media, otherwise, turn off PHY */ 72676d599946STony Nguyen if (pi->phy.link_info.link_info & ICE_AQ_MEDIA_AVAILABLE) { 72681a3571b5SPaul Greenwalt clear_bit(ICE_FLAG_NO_MEDIA, pf->flags); 72697e408e07SAnirudh Venkataramanan if (!test_bit(ICE_PHY_INIT_COMPLETE, pf->state)) { 72701a3571b5SPaul Greenwalt err = ice_init_phy_user_cfg(pi); 72711a3571b5SPaul Greenwalt if (err) { 72721a3571b5SPaul Greenwalt netdev_err(netdev, "Failed to initialize PHY settings, error %d\n", 72731a3571b5SPaul Greenwalt err); 72741a3571b5SPaul Greenwalt return err; 72751a3571b5SPaul Greenwalt } 72761a3571b5SPaul Greenwalt } 72771a3571b5SPaul Greenwalt 72781a3571b5SPaul Greenwalt err = ice_configure_phy(vsi); 7279b6f934f0SBrett Creeley if (err) { 728019cce2c6SAnirudh Venkataramanan netdev_err(netdev, "Failed to set physical link up, error %d\n", 72816d599946STony Nguyen err); 7282b6f934f0SBrett Creeley return err; 7283b6f934f0SBrett Creeley } 72846d599946STony Nguyen } else { 72851a3571b5SPaul Greenwalt set_bit(ICE_FLAG_NO_MEDIA, pf->flags); 7286d348d517SAnirudh Venkataramanan ice_set_link(vsi, false); 72876d599946STony Nguyen } 7288cdedef59SAnirudh Venkataramanan 7289b6f934f0SBrett Creeley err = ice_vsi_open(vsi); 7290cdedef59SAnirudh Venkataramanan if (err) 7291cdedef59SAnirudh Venkataramanan netdev_err(netdev, "Failed to open VSI 0x%04X on switch 0x%04X\n", 7292cdedef59SAnirudh Venkataramanan vsi->vsi_num, vsi->vsw->sw_id); 7293a4e82a81STony Nguyen 7294a4e82a81STony Nguyen /* Update existing tunnels information */ 7295a4e82a81STony Nguyen udp_tunnel_get_rx_info(netdev); 7296a4e82a81STony Nguyen 7297cdedef59SAnirudh Venkataramanan return err; 7298cdedef59SAnirudh Venkataramanan } 7299cdedef59SAnirudh Venkataramanan 7300cdedef59SAnirudh Venkataramanan /** 7301cdedef59SAnirudh Venkataramanan * ice_stop - Disables a network interface 7302cdedef59SAnirudh Venkataramanan * @netdev: network interface device structure 7303cdedef59SAnirudh Venkataramanan * 7304cdedef59SAnirudh Venkataramanan * The stop entry point is called when an interface is de-activated by the OS, 7305cdedef59SAnirudh Venkataramanan * and the netdevice enters the DOWN state. The hardware is still under the 7306cdedef59SAnirudh Venkataramanan * driver's control, but the netdev interface is disabled. 7307cdedef59SAnirudh Venkataramanan * 7308cdedef59SAnirudh Venkataramanan * Returns success only - not allowed to fail 7309cdedef59SAnirudh Venkataramanan */ 73100e674aebSAnirudh Venkataramanan int ice_stop(struct net_device *netdev) 7311cdedef59SAnirudh Venkataramanan { 7312cdedef59SAnirudh Venkataramanan struct ice_netdev_priv *np = netdev_priv(netdev); 7313cdedef59SAnirudh Venkataramanan struct ice_vsi *vsi = np->vsi; 7314e95fc857SKrzysztof Goreczny struct ice_pf *pf = vsi->back; 7315e95fc857SKrzysztof Goreczny 7316e95fc857SKrzysztof Goreczny if (ice_is_reset_in_progress(pf->state)) { 7317e95fc857SKrzysztof Goreczny netdev_err(netdev, "can't stop net device while reset is in progress"); 7318e95fc857SKrzysztof Goreczny return -EBUSY; 7319e95fc857SKrzysztof Goreczny } 7320cdedef59SAnirudh Venkataramanan 7321cdedef59SAnirudh Venkataramanan ice_vsi_close(vsi); 7322cdedef59SAnirudh Venkataramanan 7323cdedef59SAnirudh Venkataramanan return 0; 7324cdedef59SAnirudh Venkataramanan } 7325cdedef59SAnirudh Venkataramanan 7326e94d4478SAnirudh Venkataramanan /** 7327e94d4478SAnirudh Venkataramanan * ice_features_check - Validate encapsulated packet conforms to limits 7328e94d4478SAnirudh Venkataramanan * @skb: skb buffer 7329e94d4478SAnirudh Venkataramanan * @netdev: This port's netdev 7330e94d4478SAnirudh Venkataramanan * @features: Offload features that the stack believes apply 7331e94d4478SAnirudh Venkataramanan */ 7332e94d4478SAnirudh Venkataramanan static netdev_features_t 7333e94d4478SAnirudh Venkataramanan ice_features_check(struct sk_buff *skb, 7334e94d4478SAnirudh Venkataramanan struct net_device __always_unused *netdev, 7335e94d4478SAnirudh Venkataramanan netdev_features_t features) 7336e94d4478SAnirudh Venkataramanan { 7337e94d4478SAnirudh Venkataramanan size_t len; 7338e94d4478SAnirudh Venkataramanan 7339e94d4478SAnirudh Venkataramanan /* No point in doing any of this if neither checksum nor GSO are 7340e94d4478SAnirudh Venkataramanan * being requested for this frame. We can rule out both by just 7341e94d4478SAnirudh Venkataramanan * checking for CHECKSUM_PARTIAL 7342e94d4478SAnirudh Venkataramanan */ 7343e94d4478SAnirudh Venkataramanan if (skb->ip_summed != CHECKSUM_PARTIAL) 7344e94d4478SAnirudh Venkataramanan return features; 7345e94d4478SAnirudh Venkataramanan 7346e94d4478SAnirudh Venkataramanan /* We cannot support GSO if the MSS is going to be less than 7347e94d4478SAnirudh Venkataramanan * 64 bytes. If it is then we need to drop support for GSO. 7348e94d4478SAnirudh Venkataramanan */ 7349e94d4478SAnirudh Venkataramanan if (skb_is_gso(skb) && (skb_shinfo(skb)->gso_size < 64)) 7350e94d4478SAnirudh Venkataramanan features &= ~NETIF_F_GSO_MASK; 7351e94d4478SAnirudh Venkataramanan 7352e94d4478SAnirudh Venkataramanan len = skb_network_header(skb) - skb->data; 7353a4e82a81STony Nguyen if (len > ICE_TXD_MACLEN_MAX || len & 0x1) 7354e94d4478SAnirudh Venkataramanan goto out_rm_features; 7355e94d4478SAnirudh Venkataramanan 7356e94d4478SAnirudh Venkataramanan len = skb_transport_header(skb) - skb_network_header(skb); 7357a4e82a81STony Nguyen if (len > ICE_TXD_IPLEN_MAX || len & 0x1) 7358e94d4478SAnirudh Venkataramanan goto out_rm_features; 7359e94d4478SAnirudh Venkataramanan 7360e94d4478SAnirudh Venkataramanan if (skb->encapsulation) { 7361e94d4478SAnirudh Venkataramanan len = skb_inner_network_header(skb) - skb_transport_header(skb); 7362a4e82a81STony Nguyen if (len > ICE_TXD_L4LEN_MAX || len & 0x1) 7363e94d4478SAnirudh Venkataramanan goto out_rm_features; 7364e94d4478SAnirudh Venkataramanan 7365e94d4478SAnirudh Venkataramanan len = skb_inner_transport_header(skb) - 7366e94d4478SAnirudh Venkataramanan skb_inner_network_header(skb); 7367a4e82a81STony Nguyen if (len > ICE_TXD_IPLEN_MAX || len & 0x1) 7368e94d4478SAnirudh Venkataramanan goto out_rm_features; 7369e94d4478SAnirudh Venkataramanan } 7370e94d4478SAnirudh Venkataramanan 7371e94d4478SAnirudh Venkataramanan return features; 7372e94d4478SAnirudh Venkataramanan out_rm_features: 7373e94d4478SAnirudh Venkataramanan return features & ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK); 7374e94d4478SAnirudh Venkataramanan } 7375e94d4478SAnirudh Venkataramanan 7376462acf6aSTony Nguyen static const struct net_device_ops ice_netdev_safe_mode_ops = { 7377462acf6aSTony Nguyen .ndo_open = ice_open, 7378462acf6aSTony Nguyen .ndo_stop = ice_stop, 7379462acf6aSTony Nguyen .ndo_start_xmit = ice_start_xmit, 7380462acf6aSTony Nguyen .ndo_set_mac_address = ice_set_mac_address, 7381462acf6aSTony Nguyen .ndo_validate_addr = eth_validate_addr, 7382462acf6aSTony Nguyen .ndo_change_mtu = ice_change_mtu, 7383462acf6aSTony Nguyen .ndo_get_stats64 = ice_get_stats64, 7384462acf6aSTony Nguyen .ndo_tx_timeout = ice_tx_timeout, 7385ebc5399eSMaciej Fijalkowski .ndo_bpf = ice_xdp_safe_mode, 7386462acf6aSTony Nguyen }; 7387462acf6aSTony Nguyen 7388cdedef59SAnirudh Venkataramanan static const struct net_device_ops ice_netdev_ops = { 7389cdedef59SAnirudh Venkataramanan .ndo_open = ice_open, 7390cdedef59SAnirudh Venkataramanan .ndo_stop = ice_stop, 73912b245cb2SAnirudh Venkataramanan .ndo_start_xmit = ice_start_xmit, 73922a87bd73SDave Ertman .ndo_select_queue = ice_select_queue, 7393e94d4478SAnirudh Venkataramanan .ndo_features_check = ice_features_check, 7394e94d4478SAnirudh Venkataramanan .ndo_set_rx_mode = ice_set_rx_mode, 7395e94d4478SAnirudh Venkataramanan .ndo_set_mac_address = ice_set_mac_address, 7396e94d4478SAnirudh Venkataramanan .ndo_validate_addr = eth_validate_addr, 7397e94d4478SAnirudh Venkataramanan .ndo_change_mtu = ice_change_mtu, 7398fcea6f3dSAnirudh Venkataramanan .ndo_get_stats64 = ice_get_stats64, 73991ddef455SUsha Ketineni .ndo_set_tx_maxrate = ice_set_tx_maxrate, 7400a7605370SArnd Bergmann .ndo_eth_ioctl = ice_eth_ioctl, 74017c710869SAnirudh Venkataramanan .ndo_set_vf_spoofchk = ice_set_vf_spoofchk, 74027c710869SAnirudh Venkataramanan .ndo_set_vf_mac = ice_set_vf_mac, 74037c710869SAnirudh Venkataramanan .ndo_get_vf_config = ice_get_vf_cfg, 74047c710869SAnirudh Venkataramanan .ndo_set_vf_trust = ice_set_vf_trust, 74057c710869SAnirudh Venkataramanan .ndo_set_vf_vlan = ice_set_vf_port_vlan, 74067c710869SAnirudh Venkataramanan .ndo_set_vf_link_state = ice_set_vf_link_state, 7407730fdea4SJesse Brandeburg .ndo_get_vf_stats = ice_get_vf_stats, 74084ecc8633SBrett Creeley .ndo_set_vf_rate = ice_set_vf_bw, 7409d76a60baSAnirudh Venkataramanan .ndo_vlan_rx_add_vid = ice_vlan_rx_add_vid, 7410d76a60baSAnirudh Venkataramanan .ndo_vlan_rx_kill_vid = ice_vlan_rx_kill_vid, 74110d08a441SKiran Patil .ndo_setup_tc = ice_setup_tc, 7412d76a60baSAnirudh Venkataramanan .ndo_set_features = ice_set_features, 7413b1edc14aSMd Fahad Iqbal Polash .ndo_bridge_getlink = ice_bridge_getlink, 7414b1edc14aSMd Fahad Iqbal Polash .ndo_bridge_setlink = ice_bridge_setlink, 7415e94d4478SAnirudh Venkataramanan .ndo_fdb_add = ice_fdb_add, 7416e94d4478SAnirudh Venkataramanan .ndo_fdb_del = ice_fdb_del, 741728bf2672SBrett Creeley #ifdef CONFIG_RFS_ACCEL 741828bf2672SBrett Creeley .ndo_rx_flow_steer = ice_rx_flow_steer, 741928bf2672SBrett Creeley #endif 7420b3969fd7SSudheer Mogilappagari .ndo_tx_timeout = ice_tx_timeout, 7421efc2214bSMaciej Fijalkowski .ndo_bpf = ice_xdp, 7422efc2214bSMaciej Fijalkowski .ndo_xdp_xmit = ice_xdp_xmit, 74232d4238f5SKrzysztof Kazimierczak .ndo_xsk_wakeup = ice_xsk_wakeup, 7424cdedef59SAnirudh Venkataramanan }; 7425