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

Commit 99b3c58f authored by Piotr Gregor's avatar Piotr Gregor Committed by Bjorn Helgaas
Browse files

PCI: Test INTx masking during enumeration, not at run-time 



The test for INTx masking via PCI_COMMAND_INTX_DISABLE performed in
pci_intx_mask_supported() should be done before the device can be used.
This is to avoid writing PCI_COMMAND while the driver owns the device, in
case that has any effect on MSI/MSI-X interrupts.

Move the content of pci_intx_mask_supported() to pci_intx_mask_broken() and
call it from pci_setup_device().

The test result can be queried at any time later using the same
pci_intx_mask_supported() interface as before (though with changed
implementation), so callers (uio, vfio) should be unaffected.

Signed-off-by: default avatarPiotr Gregor <piotrgregor@rsyncme.org>
[bhelgaas: changelog, remove quirk check, remove locking, move
dev->broken_intx_masking assignment to caller]
Signed-off-by: default avatarBjorn Helgaas <bhelgaas@google.com>
Reviewed-by: default avatarAlex Williamson <alex.williamson@redhat.com>
Acked-by: default avatarMichael S. Tsirkin <mst@redhat.com>
parent 2ea659a9

drivers/pci/pci.c

+1 −41
Original line number Diff line number Diff line
@@ -3708,46 +3708,6 @@ void pci_intx(struct pci_dev *pdev, int enable) 
}

EXPORT_SYMBOL_GPL(pci_intx);



/**

 * pci_intx_mask_supported - probe for INTx masking support

 * @dev: the PCI device to operate on

 *

 * Check if the device dev support INTx masking via the config space

 * command word.

 */

bool pci_intx_mask_supported(struct pci_dev *dev)

{

	bool mask_supported = false;

	u16 orig, new;



	if (dev->broken_intx_masking)

		return false;



	pci_cfg_access_lock(dev);



	pci_read_config_word(dev, PCI_COMMAND, &orig);

	pci_write_config_word(dev, PCI_COMMAND,

			      orig ^ PCI_COMMAND_INTX_DISABLE);

	pci_read_config_word(dev, PCI_COMMAND, &new);



	/*

	 * There's no way to protect against hardware bugs or detect them

	 * reliably, but as long as we know what the value should be, let's

	 * go ahead and check it.

	 */

	if ((new ^ orig) & ~PCI_COMMAND_INTX_DISABLE) {

		dev_err(&dev->dev, "Command register changed from 0x%x to 0x%x: driver or hardware bug?\n",

			orig, new);

	} else if ((new ^ orig) & PCI_COMMAND_INTX_DISABLE) {

		mask_supported = true;

		pci_write_config_word(dev, PCI_COMMAND, orig);

	}



	pci_cfg_access_unlock(dev);

	return mask_supported;

}

EXPORT_SYMBOL_GPL(pci_intx_mask_supported);



static bool pci_check_and_set_intx_mask(struct pci_dev *dev, bool mask)

{

	struct pci_bus *bus = dev->bus;
@@ -3798,7 +3758,7 @@ static bool pci_check_and_set_intx_mask(struct pci_dev *dev, bool mask) 
 * @dev: the PCI device to operate on

 *

 * Check if the device dev has its INTx line asserted, mask it and

 * return true in that case. False is returned if not interrupt was

 * return true in that case. False is returned if no interrupt was

 * pending.

 */

bool pci_check_and_mask_intx(struct pci_dev *dev)

drivers/pci/probe.c

+30 −0
Original line number Diff line number Diff line
@@ -1329,6 +1329,34 @@ static void pci_msi_setup_pci_dev(struct pci_dev *dev) 
		pci_msix_clear_and_set_ctrl(dev, PCI_MSIX_FLAGS_ENABLE, 0);

}



/**

 * pci_intx_mask_broken - test PCI_COMMAND_INTX_DISABLE writability

 * @dev: PCI device

 *

 * Test whether PCI_COMMAND_INTX_DISABLE is writable for @dev.  Check this

 * at enumeration-time to avoid modifying PCI_COMMAND at run-time.

 */

static int pci_intx_mask_broken(struct pci_dev *dev)

{

	u16 orig, toggle, new;



	pci_read_config_word(dev, PCI_COMMAND, &orig);

	toggle = orig ^ PCI_COMMAND_INTX_DISABLE;

	pci_write_config_word(dev, PCI_COMMAND, toggle);

	pci_read_config_word(dev, PCI_COMMAND, &new);



	pci_write_config_word(dev, PCI_COMMAND, orig);



	/*

	 * PCI_COMMAND_INTX_DISABLE was reserved and read-only prior to PCI

	 * r2.3, so strictly speaking, a device is not *broken* if it's not

	 * writable.  But we'll live with the misnomer for now.

	 */

	if (new != toggle)

		return 1;

	return 0;

}



/**

 * pci_setup_device - fill in class and map information of a device

 * @dev: the device structure to fill
@@ -1399,6 +1427,8 @@ int pci_setup_device(struct pci_dev *dev) 
		}

	}



	dev->broken_intx_masking = pci_intx_mask_broken(dev);



	switch (dev->hdr_type) {		    /* header type */

	case PCI_HEADER_TYPE_NORMAL:		    /* standard header */

		if (class == PCI_CLASS_BRIDGE_PCI)

include/linux/pci.h

+10 −2
Original line number Diff line number Diff line
@@ -366,7 +366,7 @@ struct pci_dev { 
	unsigned int	is_thunderbolt:1; /* Thunderbolt controller */

	unsigned int    __aer_firmware_first_valid:1;

	unsigned int	__aer_firmware_first:1;

	unsigned int	broken_intx_masking:1;

	unsigned int	broken_intx_masking:1; /* INTx masking can't be used */

	unsigned int	io_window_1k:1;	/* Intel P2P bridge 1K I/O windows */

	unsigned int	irq_managed:1;

	unsigned int	has_secondary_link:1;
@@ -1003,6 +1003,15 @@ int __must_check pci_reenable_device(struct pci_dev *); 
int __must_check pcim_enable_device(struct pci_dev *pdev);

void pcim_pin_device(struct pci_dev *pdev);



static inline bool pci_intx_mask_supported(struct pci_dev *pdev)

{

	/*

	 * INTx masking is supported if PCI_COMMAND_INTX_DISABLE is

	 * writable and no quirk has marked the feature broken.

	 */

	return !pdev->broken_intx_masking;

}



static inline int pci_is_enabled(struct pci_dev *pdev)

{

	return (atomic_read(&pdev->enable_cnt) > 0);
@@ -1026,7 +1035,6 @@ int __must_check pci_set_mwi(struct pci_dev *dev); 
int pci_try_set_mwi(struct pci_dev *dev);

void pci_clear_mwi(struct pci_dev *dev);

void pci_intx(struct pci_dev *dev, int enable);

bool pci_intx_mask_supported(struct pci_dev *dev);

bool pci_check_and_mask_intx(struct pci_dev *dev);

bool pci_check_and_unmask_intx(struct pci_dev *dev);

int pci_wait_for_pending(struct pci_dev *dev, int pos, u16 mask);