Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 93411c27 authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'net-remove-pci_enable_msix' 



Christoph Hellwig says:

====================
remove pci_enable_msix() V3

this series removes the remaining callers of the pci_enable_msix()
function and then the function itself.  The final removal has been
Acked by Bjorn.

Changes since V2:
 - add another patch on Dave's request
 - add various acks
 - spelling fixes in the commit logs

Changes since V1:
 - replace the two previous thunderx patches with a new one from Thanneeru
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents c6606a87 3680b1f6

drivers/net/ethernet/amazon/ena/ena_netdev.c

+12 −43
Original line number Diff line number Diff line
@@ -133,7 +133,7 @@ static int ena_init_rx_cpu_rmap(struct ena_adapter *adapter) 
		int irq_idx = ENA_IO_IRQ_IDX(i);



		rc = irq_cpu_rmap_add(adapter->netdev->rx_cpu_rmap,

				      adapter->msix_entries[irq_idx].vector);

				      pci_irq_vector(adapter->pdev, irq_idx));

		if (rc) {

			free_irq_cpu_rmap(adapter->netdev->rx_cpu_rmap);

			adapter->netdev->rx_cpu_rmap = NULL;
@@ -1208,13 +1208,7 @@ static irqreturn_t ena_intr_msix_io(int irq, void *data) 


static int ena_enable_msix(struct ena_adapter *adapter, int num_queues)

{

	int i, msix_vecs, rc;



	if (test_bit(ENA_FLAG_MSIX_ENABLED, &adapter->flags)) {

		netif_err(adapter, probe, adapter->netdev,

			  "Error, MSI-X is already enabled\n");

		return -EPERM;

	}

	int msix_vecs, rc;



	/* Reserved the max msix vectors we might need */

	msix_vecs = ENA_MAX_MSIX_VEC(num_queues);
@@ -1222,16 +1216,9 @@ static int ena_enable_msix(struct ena_adapter *adapter, int num_queues) 
	netif_dbg(adapter, probe, adapter->netdev,

		  "trying to enable MSI-X, vectors %d\n", msix_vecs);



	adapter->msix_entries = vzalloc(msix_vecs * sizeof(struct msix_entry));



	if (!adapter->msix_entries)

		return -ENOMEM;



	for (i = 0; i < msix_vecs; i++)

		adapter->msix_entries[i].entry = i;



	rc = pci_enable_msix(adapter->pdev, adapter->msix_entries, msix_vecs);

	if (rc != 0) {

	rc = pci_alloc_irq_vectors(adapter->pdev, msix_vecs, msix_vecs,

			PCI_IRQ_MSIX);

	if (rc < 0) {

		netif_err(adapter, probe, adapter->netdev,

			  "Failed to enable MSI-X, vectors %d rc %d\n",

			  msix_vecs, rc);
@@ -1248,7 +1235,6 @@ static int ena_enable_msix(struct ena_adapter *adapter, int num_queues) 
	}



	adapter->msix_vecs = msix_vecs;

	set_bit(ENA_FLAG_MSIX_ENABLED, &adapter->flags);



	return 0;

}
@@ -1264,7 +1250,7 @@ static void ena_setup_mgmnt_intr(struct ena_adapter *adapter) 
		ena_intr_msix_mgmnt;

	adapter->irq_tbl[ENA_MGMNT_IRQ_IDX].data = adapter;

	adapter->irq_tbl[ENA_MGMNT_IRQ_IDX].vector =

		adapter->msix_entries[ENA_MGMNT_IRQ_IDX].vector;

		pci_irq_vector(adapter->pdev, ENA_MGMNT_IRQ_IDX);

	cpu = cpumask_first(cpu_online_mask);

	adapter->irq_tbl[ENA_MGMNT_IRQ_IDX].cpu = cpu;

	cpumask_set_cpu(cpu,
@@ -1287,7 +1273,7 @@ static void ena_setup_io_intr(struct ena_adapter *adapter) 
		adapter->irq_tbl[irq_idx].handler = ena_intr_msix_io;

		adapter->irq_tbl[irq_idx].data = &adapter->ena_napi[i];

		adapter->irq_tbl[irq_idx].vector =

			adapter->msix_entries[irq_idx].vector;

			pci_irq_vector(adapter->pdev, irq_idx);

		adapter->irq_tbl[irq_idx].cpu = cpu;



		cpumask_set_cpu(cpu,
@@ -1325,12 +1311,6 @@ static int ena_request_io_irq(struct ena_adapter *adapter) 
	struct ena_irq *irq;

	int rc = 0, i, k;



	if (!test_bit(ENA_FLAG_MSIX_ENABLED, &adapter->flags)) {

		netif_err(adapter, ifup, adapter->netdev,

			  "Failed to request I/O IRQ: MSI-X is not enabled\n");

		return -EINVAL;

	}



	for (i = ENA_IO_IRQ_FIRST_IDX; i < adapter->msix_vecs; i++) {

		irq = &adapter->irq_tbl[i];

		rc = request_irq(irq->vector, irq->handler, flags, irq->name,
@@ -1389,16 +1369,6 @@ static void ena_free_io_irq(struct ena_adapter *adapter) 
	}

}



static void ena_disable_msix(struct ena_adapter *adapter)

{

	if (test_and_clear_bit(ENA_FLAG_MSIX_ENABLED, &adapter->flags))

		pci_disable_msix(adapter->pdev);



	if (adapter->msix_entries)

		vfree(adapter->msix_entries);

	adapter->msix_entries = NULL;

}



static void ena_disable_io_intr_sync(struct ena_adapter *adapter)

{

	int i;
@@ -2479,8 +2449,7 @@ static int ena_enable_msix_and_set_admin_interrupts(struct ena_adapter *adapter, 
	return 0;



err_disable_msix:

	ena_disable_msix(adapter);



	pci_free_irq_vectors(adapter->pdev);

	return rc;

}
@@ -2518,7 +2487,7 @@ static void ena_fw_reset_device(struct work_struct *work) 


	ena_free_mgmnt_irq(adapter);



	ena_disable_msix(adapter);

	pci_free_irq_vectors(adapter->pdev);



	ena_com_abort_admin_commands(ena_dev);
@@ -2569,7 +2538,7 @@ static void ena_fw_reset_device(struct work_struct *work) 
	return;

err_disable_msix:

	ena_free_mgmnt_irq(adapter);

	ena_disable_msix(adapter);

	pci_free_irq_vectors(adapter->pdev);

err_device_destroy:

	ena_com_admin_destroy(ena_dev);

err:
@@ -3103,7 +3072,7 @@ static int ena_probe(struct pci_dev *pdev, const struct pci_device_id *ent) 
err_free_msix:

	ena_com_dev_reset(ena_dev);

	ena_free_mgmnt_irq(adapter);

	ena_disable_msix(adapter);

	pci_free_irq_vectors(adapter->pdev);

err_worker_destroy:

	ena_com_destroy_interrupt_moderation(ena_dev);

	del_timer(&adapter->timer_service);
@@ -3188,7 +3157,7 @@ static void ena_remove(struct pci_dev *pdev) 


	ena_free_mgmnt_irq(adapter);



	ena_disable_msix(adapter);

	pci_free_irq_vectors(adapter->pdev);



	free_netdev(netdev);

drivers/net/ethernet/amazon/ena/ena_netdev.h

+0 −2
Original line number Diff line number Diff line
@@ -248,7 +248,6 @@ enum ena_flags_t { 
	ENA_FLAG_DEVICE_RUNNING,

	ENA_FLAG_DEV_UP,

	ENA_FLAG_LINK_UP,

	ENA_FLAG_MSIX_ENABLED,

	ENA_FLAG_TRIGGER_RESET

};
@@ -267,7 +266,6 @@ struct ena_adapter { 


	int num_queues;



	struct msix_entry *msix_entries;

	int msix_vecs;



	u32 tx_usecs, rx_usecs; /* interrupt moderation */

drivers/net/ethernet/atheros/alx/alx.h

+0 −6
Original line number Diff line number Diff line
@@ -102,9 +102,6 @@ struct alx_napi { 


#define ALX_MAX_NAPIS 8



#define ALX_FLAG_USING_MSIX	BIT(0)

#define ALX_FLAG_USING_MSI	BIT(1)



struct alx_priv {

	struct net_device *dev;
@@ -112,7 +109,6 @@ struct alx_priv { 


	/* msi-x vectors */

	int num_vec;

	struct msix_entry *msix_entries;



	/* all descriptor memory */

	struct {
@@ -139,8 +135,6 @@ struct alx_priv { 


	u16 msg_enable;



	int flags;



	/* protects hw.stats */

	spinlock_t stats_lock;

};

drivers/net/ethernet/atheros/alx/main.c

+54 −74
Original line number Diff line number Diff line
@@ -314,7 +314,7 @@ static int alx_poll(struct napi_struct *napi, int budget) 
	napi_complete_done(&np->napi, work);



	/* enable interrupt */

	if (alx->flags & ALX_FLAG_USING_MSIX) {

	if (alx->hw.pdev->msix_enabled) {

		alx_mask_msix(hw, np->vec_idx, false);

	} else {

		spin_lock_irqsave(&alx->irq_lock, flags);
@@ -811,7 +811,7 @@ static void alx_config_vector_mapping(struct alx_priv *alx) 
	u32 tbl[2] = {0, 0};

	int i, vector, idx, shift;



	if (alx->flags & ALX_FLAG_USING_MSIX) {

	if (alx->hw.pdev->msix_enabled) {

		/* tx mappings */

		for (i = 0, vector = 1; i < alx->num_txq; i++, vector++) {

			idx = txq_vec_mapping_shift[i * 2];
@@ -828,29 +828,19 @@ static void alx_config_vector_mapping(struct alx_priv *alx) 
	alx_write_mem32(hw, ALX_MSI_ID_MAP, 0);

}



static bool alx_enable_msix(struct alx_priv *alx)

static int alx_enable_msix(struct alx_priv *alx)

{

	int i, err, num_vec, num_txq, num_rxq;

	int err, num_vec, num_txq, num_rxq;



	num_txq = min_t(int, num_online_cpus(), ALX_MAX_TX_QUEUES);

	num_rxq = 1;

	num_vec = max_t(int, num_txq, num_rxq) + 1;



	alx->msix_entries = kcalloc(num_vec, sizeof(struct msix_entry),

				    GFP_KERNEL);

	if (!alx->msix_entries) {

		netdev_warn(alx->dev, "Allocation of msix entries failed!\n");

		return false;

	}



	for (i = 0; i < num_vec; i++)

		alx->msix_entries[i].entry = i;



	err = pci_enable_msix(alx->hw.pdev, alx->msix_entries, num_vec);

	err = pci_alloc_irq_vectors(alx->hw.pdev, num_vec, num_vec,

			PCI_IRQ_MSIX);

	if (err) {

		kfree(alx->msix_entries);

		netdev_warn(alx->dev, "Enabling MSI-X interrupts failed!\n");

		return false;

		return err;

	}



	alx->num_vec = num_vec;
@@ -858,7 +848,7 @@ static bool alx_enable_msix(struct alx_priv *alx) 
	alx->num_txq = num_txq;

	alx->num_rxq = num_rxq;



	return true;

	return err;

}



static int alx_request_msix(struct alx_priv *alx)
@@ -866,7 +856,7 @@ static int alx_request_msix(struct alx_priv *alx) 
	struct net_device *netdev = alx->dev;

	int i, err, vector = 0, free_vector = 0;



	err = request_irq(alx->msix_entries[0].vector, alx_intr_msix_misc,

	err = request_irq(pci_irq_vector(alx->hw.pdev, 0), alx_intr_msix_misc,

			  0, netdev->name, alx);

	if (err)

		goto out_err;
@@ -889,7 +879,7 @@ static int alx_request_msix(struct alx_priv *alx) 
			sprintf(np->irq_lbl, "%s-unused", netdev->name);



		np->vec_idx = vector;

		err = request_irq(alx->msix_entries[vector].vector,

		err = request_irq(pci_irq_vector(alx->hw.pdev, vector),

				  alx_intr_msix_ring, 0, np->irq_lbl, np);

		if (err)

			goto out_free;
@@ -897,47 +887,31 @@ static int alx_request_msix(struct alx_priv *alx) 
	return 0;



out_free:

	free_irq(alx->msix_entries[free_vector++].vector, alx);

	free_irq(pci_irq_vector(alx->hw.pdev, free_vector++), alx);



	vector--;

	for (i = 0; i < vector; i++)

		free_irq(alx->msix_entries[free_vector++].vector,

		free_irq(pci_irq_vector(alx->hw.pdev,free_vector++),

			 alx->qnapi[i]);



out_err:

	return err;

}



static void alx_init_intr(struct alx_priv *alx, bool msix)

static int alx_init_intr(struct alx_priv *alx)

{

	if (msix) {

		if (alx_enable_msix(alx))

			alx->flags |= ALX_FLAG_USING_MSIX;

	}

	int ret;



	ret = pci_alloc_irq_vectors(alx->hw.pdev, 1, 1,

			PCI_IRQ_MSI | PCI_IRQ_LEGACY);

	if (ret)

		return ret;



	if (!(alx->flags & ALX_FLAG_USING_MSIX)) {

	alx->num_vec = 1;

	alx->num_napi = 1;

	alx->num_txq = 1;

	alx->num_rxq = 1;



		if (!pci_enable_msi(alx->hw.pdev))

			alx->flags |= ALX_FLAG_USING_MSI;

	}

}



static void alx_disable_advanced_intr(struct alx_priv *alx)

{

	if (alx->flags & ALX_FLAG_USING_MSIX) {

		kfree(alx->msix_entries);

		pci_disable_msix(alx->hw.pdev);

		alx->flags &= ~ALX_FLAG_USING_MSIX;

	}



	if (alx->flags & ALX_FLAG_USING_MSI) {

		pci_disable_msi(alx->hw.pdev);

		alx->flags &= ~ALX_FLAG_USING_MSI;

	}

	return 0;

}



static void alx_irq_enable(struct alx_priv *alx)
@@ -950,11 +924,12 @@ static void alx_irq_enable(struct alx_priv *alx) 
	alx_write_mem32(hw, ALX_IMR, alx->int_mask);

	alx_post_write(hw);



	if (alx->flags & ALX_FLAG_USING_MSIX)

	if (alx->hw.pdev->msix_enabled) {

		/* enable all msix irqs */

		for (i = 0; i < alx->num_vec; i++)

			alx_mask_msix(hw, i, false);

	}

}



static void alx_irq_disable(struct alx_priv *alx)

{
@@ -965,13 +940,13 @@ static void alx_irq_disable(struct alx_priv *alx) 
	alx_write_mem32(hw, ALX_IMR, 0);

	alx_post_write(hw);



	if (alx->flags & ALX_FLAG_USING_MSIX) {

	if (alx->hw.pdev->msix_enabled) {

		for (i = 0; i < alx->num_vec; i++) {

			alx_mask_msix(hw, i, true);

			synchronize_irq(alx->msix_entries[i].vector);

			synchronize_irq(pci_irq_vector(alx->hw.pdev, i));

		}

	} else {

		synchronize_irq(alx->hw.pdev->irq);

		synchronize_irq(pci_irq_vector(alx->hw.pdev, 0));

	}

}
@@ -981,8 +956,11 @@ static int alx_realloc_resources(struct alx_priv *alx) 


	alx_free_rings(alx);

	alx_free_napis(alx);

	alx_disable_advanced_intr(alx);

	alx_init_intr(alx, false);

	pci_free_irq_vectors(alx->hw.pdev);



	err = alx_init_intr(alx);

	if (err)

		return err;



	err = alx_alloc_napis(alx);

	if (err)
@@ -1004,7 +982,7 @@ static int alx_request_irq(struct alx_priv *alx) 


	msi_ctrl = (hw->imt >> 1) << ALX_MSI_RETRANS_TM_SHIFT;



	if (alx->flags & ALX_FLAG_USING_MSIX) {

	if (alx->hw.pdev->msix_enabled) {

		alx_write_mem32(hw, ALX_MSI_RETRANS_TIMER, msi_ctrl);

		err = alx_request_msix(alx);

		if (!err)
@@ -1016,20 +994,20 @@ static int alx_request_irq(struct alx_priv *alx) 
			goto out;

	}



	if (alx->flags & ALX_FLAG_USING_MSI) {

	if (alx->hw.pdev->msi_enabled) {

		alx_write_mem32(hw, ALX_MSI_RETRANS_TIMER,

				msi_ctrl | ALX_MSI_MASK_SEL_LINE);

		err = request_irq(pdev->irq, alx_intr_msi, 0,

		err = request_irq(pci_irq_vector(pdev, 0), alx_intr_msi, 0,

				  alx->dev->name, alx);

		if (!err)

			goto out;



		/* fall back to legacy interrupt */

		alx->flags &= ~ALX_FLAG_USING_MSI;

		pci_disable_msi(alx->hw.pdev);

		pci_free_irq_vectors(alx->hw.pdev);

	}



	alx_write_mem32(hw, ALX_MSI_RETRANS_TIMER, 0);

	err = request_irq(pdev->irq, alx_intr_legacy, IRQF_SHARED,

	err = request_irq(pci_irq_vector(pdev, 0), alx_intr_legacy, IRQF_SHARED,

			  alx->dev->name, alx);

out:

	if (!err)
@@ -1042,18 +1020,15 @@ static int alx_request_irq(struct alx_priv *alx) 
static void alx_free_irq(struct alx_priv *alx)

{

	struct pci_dev *pdev = alx->hw.pdev;

	int i, vector = 0;

	int i;



	if (alx->flags & ALX_FLAG_USING_MSIX) {

		free_irq(alx->msix_entries[vector++].vector, alx);

	free_irq(pci_irq_vector(pdev, 0), alx);

	if (alx->hw.pdev->msix_enabled) {

		for (i = 0; i < alx->num_napi; i++)

			free_irq(alx->msix_entries[vector++].vector,

				 alx->qnapi[i]);

	} else {

		free_irq(pdev->irq, alx);

			free_irq(pci_irq_vector(pdev, i + 1), alx->qnapi[i]);

	}



	alx_disable_advanced_intr(alx);

	pci_free_irq_vectors(pdev);

}



static int alx_identify_hw(struct alx_priv *alx)
@@ -1221,7 +1196,12 @@ static int __alx_open(struct alx_priv *alx, bool resume) 
{

	int err;



	alx_init_intr(alx, true);

	err = alx_enable_msix(alx);

	if (err < 0) {

		err = alx_init_intr(alx);

		if (err)

			return err;

	}



	if (!resume)

		netif_carrier_off(alx->dev);
@@ -1264,7 +1244,7 @@ static int __alx_open(struct alx_priv *alx, bool resume) 
	alx_free_rings(alx);

	alx_free_napis(alx);

out_disable_adv_intr:

	alx_disable_advanced_intr(alx);

	pci_free_irq_vectors(alx->hw.pdev);

	return err;

}
@@ -1637,11 +1617,11 @@ static void alx_poll_controller(struct net_device *netdev) 
	struct alx_priv *alx = netdev_priv(netdev);

	int i;



	if (alx->flags & ALX_FLAG_USING_MSIX) {

	if (alx->hw.pdev->msix_enabled) {

		alx_intr_msix_misc(0, alx);

		for (i = 0; i < alx->num_txq; i++)

			alx_intr_msix_ring(0, alx->qnapi[i]);

	} else if (alx->flags & ALX_FLAG_USING_MSI)

	} else if (alx->hw.pdev->msi_enabled)

		alx_intr_msi(0, alx);

	else

		alx_intr_legacy(0, alx);
@@ -1783,7 +1763,7 @@ static int alx_probe(struct pci_dev *pdev, const struct pci_device_id *ent) 


	netdev->netdev_ops = &alx_netdev_ops;

	netdev->ethtool_ops = &alx_ethtool_ops;

	netdev->irq = pdev->irq;

	netdev->irq = pci_irq_vector(pdev, 0);

	netdev->watchdog_timeo = ALX_WATCHDOG_TIME;



	if (ent->driver_data & ALX_DEV_QUIRK_MSI_INTX_DISABLE_BUG)

drivers/net/ethernet/cavium/thunder/nic.h

+0 −2
Original line number Diff line number Diff line
@@ -319,9 +319,7 @@ struct nicvf { 
	struct bgx_stats	bgx_stats;



	/* MSI-X  */

	bool			msix_enabled;

	u8			num_vec;

	struct msix_entry	msix_entries[NIC_VF_MSIX_VECTORS];

	char			irq_name[NIC_VF_MSIX_VECTORS][IFNAMSIZ + 15];

	bool			irq_allocated[NIC_VF_MSIX_VECTORS];

	cpumask_var_t		affinity_mask[NIC_VF_MSIX_VECTORS];