nagai/kernel
3
0
Fork 0
forked from mirrors/linux
Code Pull requests Activity

ice: remove splitting MSI-X between features

Browse source 
With dynamic approach to alloc MSI-X there is no sense to statically
split MSI-X between PF features.

Splitting was also calculating needed MSI-X. Move this part to separate
function and use as max value.

Remove ICE_ESWITCH_MSIX, as there is no need for additional MSI-X for
switchdev.

Reviewed-by: Jacob Keller <jacob.e.keller@intel.com>
Reviewed-by: Wojciech Drewek <wojciech.drewek@intel.com>
Tested-by: Pucha Himasekhar Reddy <himasekharx.reddy.pucha@intel.com>
Signed-off-by: Michal Swiatkowski <michal.swiatkowski@linux.intel.com>
Signed-off-by: Tony Nguyen <anthony.l.nguyen@intel.com>
This commit is contained in:
Michal Swiatkowski 2024-12-03 07:58:11 +01:00 committed by Tony Nguyen
parent b2657259fc
commit 79d97b8cf9
2 changed files with 16 additions and 158 deletions
repo.diff.show_diff_stats Download patch file Download diff file Expand all files Collapse all files

2
drivers/net/ethernet/intel/ice/ice.h
View file

@ -98,8 +98,6 @@
#define ICE_MIN_MSIX (ICE_MIN_LAN_TXRX_MSIX + ICE_MIN_LAN_OICR_MSIX)
#define ICE_FDIR_MSIX 2
#define ICE_RDMA_NUM_AEQ_MSIX 4
#define ICE_MIN_RDMA_MSIX 2
#define ICE_ESWITCH_MSIX 1
#define ICE_NO_VSI 0xffff
#define ICE_VSI_MAP_CONTIG 0
#define ICE_VSI_MAP_SCATTER 1

172
drivers/net/ethernet/intel/ice/ice_irq.c
View file

@ -84,155 +84,11 @@ static struct ice_irq_entry *ice_get_irq_res(struct ice_pf *pf, bool dyn_only)
return entry;
}
/**
* ice_reduce_msix_usage - Reduce usage of MSI-X vectors
* @pf: board private structure
* @v_remain: number of remaining MSI-X vectors to be distributed
*
* Reduce the usage of MSI-X vectors when entire request cannot be fulfilled.
* pf->num_lan_msix and pf->num_rdma_msix values are set based on number of
* remaining vectors.
*/
static void ice_reduce_msix_usage(struct ice_pf *pf, int v_remain)
static int ice_get_default_msix_amount(struct ice_pf *pf)
{
int v_rdma;
if (!ice_is_rdma_ena(pf)) {
pf->num_lan_msix = v_remain;
return;
}
/* RDMA needs at least 1 interrupt in addition to AEQ MSIX */
v_rdma = ICE_RDMA_NUM_AEQ_MSIX + 1;
if (v_remain < ICE_MIN_LAN_TXRX_MSIX + ICE_MIN_RDMA_MSIX) {
dev_warn(ice_pf_to_dev(pf), "Not enough MSI-X vectors to support RDMA.\n");
clear_bit(ICE_FLAG_RDMA_ENA, pf->flags);
pf->num_rdma_msix = 0;
pf->num_lan_msix = ICE_MIN_LAN_TXRX_MSIX;
} else if ((v_remain < ICE_MIN_LAN_TXRX_MSIX + v_rdma) ||
(v_remain - v_rdma < v_rdma)) {
/* Support minimum RDMA and give remaining vectors to LAN MSIX
*/
pf->num_rdma_msix = ICE_MIN_RDMA_MSIX;
pf->num_lan_msix = v_remain - ICE_MIN_RDMA_MSIX;
} else {
/* Split remaining MSIX with RDMA after accounting for AEQ MSIX
*/
pf->num_rdma_msix = (v_remain - ICE_RDMA_NUM_AEQ_MSIX) / 2 +
ICE_RDMA_NUM_AEQ_MSIX;
pf->num_lan_msix = v_remain - pf->num_rdma_msix;
}
}
/**
* ice_ena_msix_range - Request a range of MSIX vectors from the OS
* @pf: board private structure
*
* Compute the number of MSIX vectors wanted and request from the OS. Adjust
* device usage if there are not enough vectors. Return the number of vectors
* reserved or negative on failure.
*/
static int ice_ena_msix_range(struct ice_pf *pf)
{
int num_cpus, hw_num_msix, v_other, v_wanted, v_actual;
struct device *dev = ice_pf_to_dev(pf);
int err;
hw_num_msix = pf->hw.func_caps.common_cap.num_msix_vectors;
num_cpus = num_online_cpus();
/* LAN miscellaneous handler */
v_other = ICE_MIN_LAN_OICR_MSIX;
/* Flow Director */
if (test_bit(ICE_FLAG_FD_ENA, pf->flags))
v_other += ICE_FDIR_MSIX;
/* switchdev */
v_other += ICE_ESWITCH_MSIX;
v_wanted = v_other;
/* LAN traffic */
pf->num_lan_msix = num_cpus;
v_wanted += pf->num_lan_msix;
/* RDMA auxiliary driver */
if (ice_is_rdma_ena(pf)) {
pf->num_rdma_msix = num_cpus + ICE_RDMA_NUM_AEQ_MSIX;
v_wanted += pf->num_rdma_msix;
}
if (v_wanted > hw_num_msix) {
int v_remain;
dev_warn(dev, "not enough device MSI-X vectors. wanted = %d, available = %d\n",
v_wanted, hw_num_msix);
if (hw_num_msix < ICE_MIN_MSIX) {
err = -ERANGE;
goto exit_err;
}
v_remain = hw_num_msix - v_other;
if (v_remain < ICE_MIN_LAN_TXRX_MSIX) {
v_other = ICE_MIN_MSIX - ICE_MIN_LAN_TXRX_MSIX;
v_remain = ICE_MIN_LAN_TXRX_MSIX;
}
ice_reduce_msix_usage(pf, v_remain);
v_wanted = pf->num_lan_msix + pf->num_rdma_msix + v_other;
dev_notice(dev, "Reducing request to %d MSI-X vectors for LAN traffic.\n",
pf->num_lan_msix);
if (ice_is_rdma_ena(pf))
dev_notice(dev, "Reducing request to %d MSI-X vectors for RDMA.\n",
pf->num_rdma_msix);
}
/* actually reserve the vectors */
v_actual = pci_alloc_irq_vectors(pf->pdev, ICE_MIN_MSIX, v_wanted,
PCI_IRQ_MSIX);
if (v_actual < 0) {
dev_err(dev, "unable to reserve MSI-X vectors\n");
err = v_actual;
goto exit_err;
}
if (v_actual < v_wanted) {
dev_warn(dev, "not enough OS MSI-X vectors. requested = %d, obtained = %d\n",
v_wanted, v_actual);
if (v_actual < ICE_MIN_MSIX) {
/* error if we can't get minimum vectors */
pci_free_irq_vectors(pf->pdev);
err = -ERANGE;
goto exit_err;
} else {
int v_remain = v_actual - v_other;
if (v_remain < ICE_MIN_LAN_TXRX_MSIX)
v_remain = ICE_MIN_LAN_TXRX_MSIX;
ice_reduce_msix_usage(pf, v_remain);
dev_notice(dev, "Enabled %d MSI-X vectors for LAN traffic.\n",
pf->num_lan_msix);
if (ice_is_rdma_ena(pf))
dev_notice(dev, "Enabled %d MSI-X vectors for RDMA.\n",
pf->num_rdma_msix);
}
}
return v_actual;
exit_err:
pf->num_rdma_msix = 0;
pf->num_lan_msix = 0;
return err;
return ICE_MIN_LAN_OICR_MSIX + num_online_cpus() +
(test_bit(ICE_FLAG_FD_ENA, pf->flags) ? ICE_FDIR_MSIX : 0) +
(ice_is_rdma_ena(pf) ? num_online_cpus() + ICE_RDMA_NUM_AEQ_MSIX : 0);
}
/**
@ -259,17 +115,21 @@ int ice_init_interrupt_scheme(struct ice_pf *pf)
pf->msix.min = ICE_MIN_MSIX;
if (!pf->msix.max)
pf->msix.max = total_vectors / 2;
pf->msix.max = min(total_vectors,
ice_get_default_msix_amount(pf));
vectors = ice_ena_msix_range(pf);
if (vectors < 0)
return -ENOMEM;
if (pci_msix_can_alloc_dyn(pf->pdev))
if (pci_msix_can_alloc_dyn(pf->pdev)) {
vectors = pf->msix.min;
max_vectors = total_vectors;
else
} else {
vectors = pf->msix.max;
max_vectors = vectors;
}
vectors = pci_alloc_irq_vectors(pf->pdev, pf->msix.min, vectors,
PCI_IRQ_MSIX);
if (vectors < pf->msix.min)
return -ENOMEM;
ice_init_irq_tracker(pf, max_vectors, vectors);