iv/linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch '100GbE' of git://git.kernel.org/pub/scm/linux/kernel/git/tnguy/next-queue

Browse Source 
Tony Nguyen says:

====================
Intel Wired LAN Driver Updates 2024-02-12 (ice)

This series contains updates to ice driver only.

Grzegorz adds support for E825-C devices.

Wojciech reworks devlink reload to fulfill expected conditions (remove
and readd).
====================

Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
David S. Miller 2024-02-14 10:25:27 +00:00
commit b53e84645b
11 changed files with 202 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
drivers/net/ethernet/intel/ice/ice.h
View File

@ -896,6 +896,7 @@ static inline bool ice_is_adq_active(struct ice_pf *pf)
}
void ice_debugfs_fwlog_init(struct ice_pf *pf);
void ice_debugfs_pf_deinit(struct ice_pf *pf);
void ice_debugfs_init(void);
void ice_debugfs_exit(void);
void ice_pf_fwlog_update_module(struct ice_pf *pf, int log_level, int module);
@ -983,6 +984,8 @@ void ice_service_task_schedule(struct ice_pf *pf);
int ice_load(struct ice_pf *pf);
void ice_unload(struct ice_pf *pf);
void ice_adv_lnk_speed_maps_init(void);
int ice_init_dev(struct ice_pf *pf);
void ice_deinit_dev(struct ice_pf *pf);
/**
* ice_set_rdma_cap - enable RDMA support

37
drivers/net/ethernet/intel/ice/ice_common.c
View File

@ -154,6 +154,12 @@ static int ice_set_mac_type(struct ice_hw *hw)
case ICE_DEV_ID_E823L_SFP:
hw->mac_type = ICE_MAC_GENERIC;
break;
case ICE_DEV_ID_E825C_BACKPLANE:
case ICE_DEV_ID_E825C_QSFP:
case ICE_DEV_ID_E825C_SFP:
case ICE_DEV_ID_E825C_SGMII:
hw->mac_type = ICE_MAC_GENERIC_3K_E825;
break;
case ICE_DEV_ID_E830_BACKPLANE:
case ICE_DEV_ID_E830_QSFP56:
case ICE_DEV_ID_E830_SFP:
@ -169,6 +175,18 @@ static int ice_set_mac_type(struct ice_hw *hw)
return 0;
}
/**
* ice_is_generic_mac - check if device's mac_type is generic
* @hw: pointer to the hardware structure
*
* Return: true if mac_type is generic (with SBQ support), false if not
*/
bool ice_is_generic_mac(struct ice_hw *hw)
{
return (hw->mac_type == ICE_MAC_GENERIC ||
hw->mac_type == ICE_MAC_GENERIC_3K_E825);
}
/**
* ice_is_e810
* @hw: pointer to the hardware structure
@ -240,6 +258,25 @@ bool ice_is_e823(struct ice_hw *hw)
}
}
/**
* ice_is_e825c - Check if a device is E825C family device
* @hw: pointer to the hardware structure
*
* Return: true if the device is E825-C based, false if not.
*/
bool ice_is_e825c(struct ice_hw *hw)
{
switch (hw->device_id) {
case ICE_DEV_ID_E825C_BACKPLANE:
case ICE_DEV_ID_E825C_QSFP:
case ICE_DEV_ID_E825C_SFP:
case ICE_DEV_ID_E825C_SGMII:
return true;
default:
return false;
}
}
/**
* ice_clear_pf_cfg - Clear PF configuration
* @hw: pointer to the hardware structure

2
drivers/net/ethernet/intel/ice/ice_common.h
View File

@ -112,6 +112,7 @@ ice_update_phy_type(u64 *phy_type_low, u64 *phy_type_high,
int
ice_aq_manage_mac_write(struct ice_hw *hw, const u8 *mac_addr, u8 flags,
struct ice_sq_cd *cd);
bool ice_is_generic_mac(struct ice_hw *hw);
bool ice_is_e810(struct ice_hw *hw);
int ice_clear_pf_cfg(struct ice_hw *hw);
int
@ -251,6 +252,7 @@ ice_stat_update32(struct ice_hw *hw, u32 reg, bool prev_stat_loaded,
u64 *prev_stat, u64 *cur_stat);
bool ice_is_e810t(struct ice_hw *hw);
bool ice_is_e823(struct ice_hw *hw);
bool ice_is_e825c(struct ice_hw *hw);
int
ice_sched_query_elem(struct ice_hw *hw, u32 node_teid,
struct ice_aqc_txsched_elem_data *buf);

2
drivers/net/ethernet/intel/ice/ice_controlq.c
View File

@ -666,7 +666,7 @@ bool ice_is_sbq_supported(struct ice_hw *hw)
/* The device sideband queue is only supported on devices with the
* generic MAC type.
*/
return hw->mac_type == ICE_MAC_GENERIC;
return ice_is_generic_mac(hw);
}
/**

4
drivers/net/ethernet/intel/ice/ice_ddp.c
View File

@ -1825,6 +1825,7 @@ static u32 ice_get_pkg_segment_id(enum ice_mac_type mac_type)
seg_id = SEGMENT_TYPE_ICE_E830;
break;
case ICE_MAC_GENERIC:
case ICE_MAC_GENERIC_3K_E825:
default:
seg_id = SEGMENT_TYPE_ICE_E810;
break;
@ -1845,6 +1846,9 @@ static u32 ice_get_pkg_sign_type(enum ice_mac_type mac_type)
case ICE_MAC_E830:
sign_type = SEGMENT_SIGN_TYPE_RSA3K_SBB;
break;
case ICE_MAC_GENERIC_3K_E825:
sign_type = SEGMENT_SIGN_TYPE_RSA3K_E825;
break;
case ICE_MAC_GENERIC:
default:
sign_type = SEGMENT_SIGN_TYPE_RSA2K;

10
drivers/net/ethernet/intel/ice/ice_debugfs.c
View File

@ -644,6 +644,16 @@ err_create_module_files:
kfree(fw_modules);
}
/**
* ice_debugfs_pf_deinit - cleanup PF's debugfs
* @pf: pointer to the PF struct
*/
void ice_debugfs_pf_deinit(struct ice_pf *pf)
{
debugfs_remove_recursive(pf->ice_debugfs_pf);
pf->ice_debugfs_pf = NULL;
}
/**
* ice_debugfs_init - create root directory for debugfs entries
*/

8
drivers/net/ethernet/intel/ice/ice_devids.h
View File

@ -71,5 +71,13 @@
#define ICE_DEV_ID_E822L_10G_BASE_T 0x1899
/* Intel(R) Ethernet Connection E822-L 1GbE */
#define ICE_DEV_ID_E822L_SGMII 0x189A
/* Intel(R) Ethernet Connection E825-C for backplane */
#define ICE_DEV_ID_E825C_BACKPLANE 0x579c
/* Intel(R) Ethernet Connection E825-C for QSFP */
#define ICE_DEV_ID_E825C_QSFP 0x579d
/* Intel(R) Ethernet Connection E825-C for SFP */
#define ICE_DEV_ID_E825C_SFP 0x579e
/* Intel(R) Ethernet Connection E825-C 1GbE */
#define ICE_DEV_ID_E825C_SGMII 0x579f
#endif /* _ICE_DEVIDS_H_ */

68
drivers/net/ethernet/intel/ice/ice_devlink.c
View File

@ -444,6 +444,20 @@ ice_devlink_reload_empr_start(struct ice_pf *pf,
return 0;
}
/**
* ice_devlink_reinit_down - unload given PF
* @pf: pointer to the PF struct
*/
static void ice_devlink_reinit_down(struct ice_pf *pf)
{
/* No need to take devl_lock, it's already taken by devlink API */
ice_unload(pf);
rtnl_lock();
ice_vsi_decfg(ice_get_main_vsi(pf));
rtnl_unlock();
ice_deinit_dev(pf);
}
/**
* ice_devlink_reload_down - prepare for reload
* @devlink: pointer to the devlink instance to reload
@ -477,7 +491,7 @@ ice_devlink_reload_down(struct devlink *devlink, bool netns_change,
"Remove all VFs before doing reinit\n");
return -EOPNOTSUPP;
}
ice_unload(pf);
ice_devlink_reinit_down(pf);
return 0;
case DEVLINK_RELOAD_ACTION_FW_ACTIVATE:
return ice_devlink_reload_empr_start(pf, extack);
@ -1269,6 +1283,45 @@ static int ice_devlink_set_parent(struct devlink_rate *devlink_rate,
return status;
}
/**
* ice_devlink_reinit_up - do reinit of the given PF
* @pf: pointer to the PF struct
*/
static int ice_devlink_reinit_up(struct ice_pf *pf)
{
struct ice_vsi *vsi = ice_get_main_vsi(pf);
struct ice_vsi_cfg_params params;
int err;
err = ice_init_dev(pf);
if (err)
return err;
params = ice_vsi_to_params(vsi);
params.flags = ICE_VSI_FLAG_INIT;
rtnl_lock();
err = ice_vsi_cfg(vsi, &params);
rtnl_unlock();
if (err)
goto err_vsi_cfg;
/* No need to take devl_lock, it's already taken by devlink API */
err = ice_load(pf);
if (err)
goto err_load;
return 0;
err_load:
rtnl_lock();
ice_vsi_decfg(vsi);
rtnl_unlock();
err_vsi_cfg:
ice_deinit_dev(pf);
return err;
}
/**
* ice_devlink_reload_up - do reload up after reinit
* @devlink: pointer to the devlink instance reloading
@ -1289,7 +1342,7 @@ ice_devlink_reload_up(struct devlink *devlink,
switch (action) {
case DEVLINK_RELOAD_ACTION_DRIVER_REINIT:
*actions_performed = BIT(DEVLINK_RELOAD_ACTION_DRIVER_REINIT);
return ice_load(pf);
return ice_devlink_reinit_up(pf);
case DEVLINK_RELOAD_ACTION_FW_ACTIVATE:
*actions_performed = BIT(DEVLINK_RELOAD_ACTION_FW_ACTIVATE);
return ice_devlink_reload_empr_finish(pf, extack);
@ -1569,6 +1622,7 @@ static const struct devlink_port_ops ice_devlink_port_ops = {
* @pf: the PF to create a devlink port for
*
* Create and register a devlink_port for this PF.
* This function has to be called under devl_lock.
*
* Return: zero on success or an error code on failure.
*/
@ -1581,6 +1635,8 @@ int ice_devlink_create_pf_port(struct ice_pf *pf)
struct device *dev;
int err;
devlink = priv_to_devlink(pf);
dev = ice_pf_to_dev(pf);
devlink_port = &pf->devlink_port;
@ -1601,10 +1657,9 @@ int ice_devlink_create_pf_port(struct ice_pf *pf)
ice_devlink_set_switch_id(pf, &attrs.switch_id);
devlink_port_attrs_set(devlink_port, &attrs);
devlink = priv_to_devlink(pf);
err = devlink_port_register_with_ops(devlink, devlink_port, vsi->idx,
&ice_devlink_port_ops);
err = devl_port_register_with_ops(devlink, devlink_port, vsi->idx,
&ice_devlink_port_ops);
if (err) {
dev_err(dev, "Failed to create devlink port for PF %d, error %d\n",
pf->hw.pf_id, err);
@ -1619,10 +1674,11 @@ int ice_devlink_create_pf_port(struct ice_pf *pf)
* @pf: the PF to cleanup
*
* Unregisters the devlink_port structure associated with this PF.
* This function has to be called under devl_lock.
*/
void ice_devlink_destroy_pf_port(struct ice_pf *pf)
{
devlink_port_unregister(&pf->devlink_port);
devl_port_unregister(&pf->devlink_port);
}
/**

2
drivers/net/ethernet/intel/ice/ice_fwlog.c
View File

@ -188,6 +188,8 @@ void ice_fwlog_deinit(struct ice_hw *hw)
if (hw->bus.func)
return;
ice_debugfs_pf_deinit(hw->back);
/* make sure FW logging is disabled to not put the FW in a weird state
* for the next driver load
*/

203
drivers/net/ethernet/intel/ice/ice_main.c
View File

@ -1649,8 +1649,10 @@ static void ice_clean_sbq_subtask(struct ice_pf *pf)
{
struct ice_hw *hw = &pf->hw;
/* Nothing to do here if sideband queue is not supported */
if (!ice_is_sbq_supported(hw)) {
/* if mac_type is not generic, sideband is not supported
* and there's nothing to do here
*/
if (!ice_is_generic_mac(hw)) {
clear_bit(ICE_SIDEBANDQ_EVENT_PENDING, pf->state);
return;
}
@ -4572,90 +4574,6 @@ static void ice_decfg_netdev(struct ice_vsi *vsi)
vsi->netdev = NULL;
}
static int ice_start_eth(struct ice_vsi *vsi)
{
int err;
err = ice_init_mac_fltr(vsi->back);
if (err)
return err;
err = ice_vsi_open(vsi);
if (err)
ice_fltr_remove_all(vsi);
return err;
}
static void ice_stop_eth(struct ice_vsi *vsi)
{
ice_fltr_remove_all(vsi);
ice_vsi_close(vsi);
}
static int ice_init_eth(struct ice_pf *pf)
{
struct ice_vsi *vsi = ice_get_main_vsi(pf);
int err;
if (!vsi)
return -EINVAL;
/* init channel list */
INIT_LIST_HEAD(&vsi->ch_list);
err = ice_cfg_netdev(vsi);
if (err)
return err;
/* Setup DCB netlink interface */
ice_dcbnl_setup(vsi);
err = ice_init_mac_fltr(pf);
if (err)
goto err_init_mac_fltr;
err = ice_devlink_create_pf_port(pf);
if (err)
goto err_devlink_create_pf_port;
SET_NETDEV_DEVLINK_PORT(vsi->netdev, &pf->devlink_port);
err = ice_register_netdev(vsi);
if (err)
goto err_register_netdev;
err = ice_tc_indir_block_register(vsi);
if (err)
goto err_tc_indir_block_register;
ice_napi_add(vsi);
return 0;
err_tc_indir_block_register:
ice_unregister_netdev(vsi);
err_register_netdev:
ice_devlink_destroy_pf_port(pf);
err_devlink_create_pf_port:
err_init_mac_fltr:
ice_decfg_netdev(vsi);
return err;
}
static void ice_deinit_eth(struct ice_pf *pf)
{
struct ice_vsi *vsi = ice_get_main_vsi(pf);
if (!vsi)
return;
ice_vsi_close(vsi);
ice_unregister_netdev(vsi);
ice_devlink_destroy_pf_port(pf);
ice_tc_indir_block_unregister(vsi);
ice_decfg_netdev(vsi);
}
/**
* ice_wait_for_fw - wait for full FW readiness
* @hw: pointer to the hardware structure
@ -4681,7 +4599,7 @@ static int ice_wait_for_fw(struct ice_hw *hw, u32 timeout)
return -ETIMEDOUT;
}
static int ice_init_dev(struct ice_pf *pf)
int ice_init_dev(struct ice_pf *pf)
{
struct device *dev = ice_pf_to_dev(pf);
struct ice_hw *hw = &pf->hw;
@ -4774,7 +4692,7 @@ err_init_pf:
return err;
}
static void ice_deinit_dev(struct ice_pf *pf)
void ice_deinit_dev(struct ice_pf *pf)
{
ice_free_irq_msix_misc(pf);
ice_deinit_pf(pf);
@ -5079,31 +4997,47 @@ static void ice_deinit(struct ice_pf *pf)
/**
* ice_load - load pf by init hw and starting VSI
* @pf: pointer to the pf instance
*
* This function has to be called under devl_lock.
*/
int ice_load(struct ice_pf *pf)
{
struct ice_vsi_cfg_params params = {};
struct ice_vsi *vsi;
int err;
err = ice_init_dev(pf);
if (err)
return err;
devl_assert_locked(priv_to_devlink(pf));
vsi = ice_get_main_vsi(pf);
params = ice_vsi_to_params(vsi);
params.flags = ICE_VSI_FLAG_INIT;
/* init channel list */
INIT_LIST_HEAD(&vsi->ch_list);
rtnl_lock();
err = ice_vsi_cfg(vsi, &params);
err = ice_cfg_netdev(vsi);
if (err)
goto err_vsi_cfg;
return err;
err = ice_start_eth(ice_get_main_vsi(pf));
/* Setup DCB netlink interface */
ice_dcbnl_setup(vsi);
err = ice_init_mac_fltr(pf);
if (err)
goto err_start_eth;
rtnl_unlock();
goto err_init_mac_fltr;
err = ice_devlink_create_pf_port(pf);
if (err)
goto err_devlink_create_pf_port;
SET_NETDEV_DEVLINK_PORT(vsi->netdev, &pf->devlink_port);
err = ice_register_netdev(vsi);
if (err)
goto err_register_netdev;
err = ice_tc_indir_block_register(vsi);
if (err)
goto err_tc_indir_block_register;
ice_napi_add(vsi);
err = ice_init_rdma(pf);
if (err)
@ -5117,29 +5051,35 @@ int ice_load(struct ice_pf *pf)
return 0;
err_init_rdma:
ice_vsi_close(ice_get_main_vsi(pf));
rtnl_lock();
err_start_eth:
ice_vsi_decfg(ice_get_main_vsi(pf));
err_vsi_cfg:
rtnl_unlock();
ice_deinit_dev(pf);
ice_tc_indir_block_unregister(vsi);
err_tc_indir_block_register:
ice_unregister_netdev(vsi);
err_register_netdev:
ice_devlink_destroy_pf_port(pf);
err_devlink_create_pf_port:
err_init_mac_fltr:
ice_decfg_netdev(vsi);
return err;
}
/**
* ice_unload - unload pf by stopping VSI and deinit hw
* @pf: pointer to the pf instance
*
* This function has to be called under devl_lock.
*/
void ice_unload(struct ice_pf *pf)
{
struct ice_vsi *vsi = ice_get_main_vsi(pf);
devl_assert_locked(priv_to_devlink(pf));
ice_deinit_features(pf);
ice_deinit_rdma(pf);
rtnl_lock();
ice_stop_eth(ice_get_main_vsi(pf));
ice_vsi_decfg(ice_get_main_vsi(pf));
rtnl_unlock();
ice_deinit_dev(pf);
ice_tc_indir_block_unregister(vsi);
ice_unregister_netdev(vsi);
ice_devlink_destroy_pf_port(pf);
ice_decfg_netdev(vsi);
}
/**
@ -5237,27 +5177,23 @@ ice_probe(struct pci_dev *pdev, const struct pci_device_id __always_unused *ent)
if (err)
goto err_init;
err = ice_init_eth(pf);
devl_lock(priv_to_devlink(pf));
err = ice_load(pf);
devl_unlock(priv_to_devlink(pf));
if (err)
goto err_init_eth;
err = ice_init_rdma(pf);
if (err)
goto err_init_rdma;
goto err_load;
err = ice_init_devlink(pf);
if (err)
goto err_init_devlink;
ice_init_features(pf);
return 0;
err_init_devlink:
ice_deinit_rdma(pf);
err_init_rdma:
ice_deinit_eth(pf);
err_init_eth:
devl_lock(priv_to_devlink(pf));
ice_unload(pf);
devl_unlock(priv_to_devlink(pf));
err_load:
ice_deinit(pf);
err_init:
pci_disable_device(pdev);
@ -5340,8 +5276,6 @@ static void ice_remove(struct pci_dev *pdev)
msleep(100);
}
ice_debugfs_exit();
if (test_bit(ICE_FLAG_SRIOV_ENA, pf->flags)) {
set_bit(ICE_VF_RESETS_DISABLED, pf->state);
ice_free_vfs(pf);
@ -5355,12 +5289,14 @@ static void ice_remove(struct pci_dev *pdev)
if (!ice_is_safe_mode(pf))
ice_remove_arfs(pf);
ice_deinit_features(pf);
ice_deinit_devlink(pf);
ice_deinit_rdma(pf);
ice_deinit_eth(pf);
ice_deinit(pf);
ice_deinit_devlink(pf);
devl_lock(priv_to_devlink(pf));
ice_unload(pf);
devl_unlock(priv_to_devlink(pf));
ice_deinit(pf);
ice_vsi_release_all(pf);
ice_setup_mc_magic_wake(pf);
@ -5752,6 +5688,10 @@ static const struct pci_device_id ice_pci_tbl[] = {
{ PCI_VDEVICE(INTEL, ICE_DEV_ID_E823L_1GBE) },
{ PCI_VDEVICE(INTEL, ICE_DEV_ID_E823L_QSFP) },
{ PCI_VDEVICE(INTEL, ICE_DEV_ID_E822_SI_DFLT) },
{ PCI_VDEVICE(INTEL, ICE_DEV_ID_E825C_BACKPLANE), },
{ PCI_VDEVICE(INTEL, ICE_DEV_ID_E825C_QSFP), },
{ PCI_VDEVICE(INTEL, ICE_DEV_ID_E825C_SFP), },
{ PCI_VDEVICE(INTEL, ICE_DEV_ID_E825C_SGMII), },
{ PCI_VDEVICE(INTEL, ICE_DEV_ID_E830_BACKPLANE) },
{ PCI_VDEVICE(INTEL, ICE_DEV_ID_E830_QSFP56) },
{ PCI_VDEVICE(INTEL, ICE_DEV_ID_E830_SFP) },
@ -5841,6 +5781,7 @@ module_init(ice_module_init);
static void __exit ice_module_exit(void)
{
pci_unregister_driver(&ice_driver);
ice_debugfs_exit();
destroy_workqueue(ice_wq);
destroy_workqueue(ice_lag_wq);
pr_info("module unloaded\n");

1
drivers/net/ethernet/intel/ice/ice_type.h
View File

@ -132,6 +132,7 @@ enum ice_mac_type {
ICE_MAC_E810,
ICE_MAC_E830,
ICE_MAC_GENERIC,
ICE_MAC_GENERIC_3K_E825,
};
/* Media Types */