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

Commit 65d5352f authored by Alex Williamson's avatar Alex Williamson Committed by Joerg Roedel
Browse files

iommu/amd: Use iommu_group_get_for_dev() 



The common iommu_group_get_for_dev() allows us to greatly simplify
our group lookup for a new device.  Also, since we insert IVRS
aliases into the PCI DMA alias quirks, we should alway come up with
the same results as the existing code.

Signed-off-by: default avatarAlex Williamson <alex.williamson@redhat.com>
Cc: Joerg Roedel <joro@8bytes.org>
Signed-off-by: default avatarJoerg Roedel <jroedel@suse.de>
parent c1931090

drivers/iommu/amd_iommu.c

+5 −159
Original line number Original line Diff line number Diff line
@@ -46,7 +46,6 @@ 
#include "amd_iommu_proto.h"

#include "amd_iommu_proto.h"

#include "amd_iommu_types.h"

#include "amd_iommu_types.h"

#include "irq_remapping.h"

#include "irq_remapping.h"

#include "pci.h"





#define CMD_SET_TYPE(cmd, t) ((cmd)->data[1] |= ((t) << 28))

#define CMD_SET_TYPE(cmd, t) ((cmd)->data[1] |= ((t) << 28))
@@ -133,9 +132,6 @@ static void free_dev_data(struct iommu_dev_data *dev_data) 
	list_del(&dev_data->dev_data_list);

	list_del(&dev_data->dev_data_list);

	spin_unlock_irqrestore(&dev_data_list_lock, flags);

	spin_unlock_irqrestore(&dev_data_list_lock, flags);





	if (dev_data->group)

		iommu_group_put(dev_data->group);



	kfree(dev_data);

	kfree(dev_data);

}

}
@@ -264,169 +260,19 @@ static bool check_device(struct device *dev) 
	return true;

	return true;

}

}





static struct pci_bus *find_hosted_bus(struct pci_bus *bus)

static int init_iommu_group(struct device *dev)

{

	while (!bus->self) {

		if (!pci_is_root_bus(bus))

			bus = bus->parent;

		else

			return ERR_PTR(-ENODEV);

	}



	return bus;

}



#define REQ_ACS_FLAGS	(PCI_ACS_SV | PCI_ACS_RR | PCI_ACS_CR | PCI_ACS_UF)



static struct pci_dev *get_isolation_root(struct pci_dev *pdev)

{

	struct pci_dev *dma_pdev = pdev;



	/* Account for quirked devices */

	swap_pci_ref(&dma_pdev, pci_get_dma_source(dma_pdev));



	/*

	 * If it's a multifunction device that does not support our

	 * required ACS flags, add to the same group as lowest numbered

	 * function that also does not suport the required ACS flags.

	 */

	if (dma_pdev->multifunction &&

	    !pci_acs_enabled(dma_pdev, REQ_ACS_FLAGS)) {

		u8 i, slot = PCI_SLOT(dma_pdev->devfn);



		for (i = 0; i < 8; i++) {

			struct pci_dev *tmp;



			tmp = pci_get_slot(dma_pdev->bus, PCI_DEVFN(slot, i));

			if (!tmp)

				continue;



			if (!pci_acs_enabled(tmp, REQ_ACS_FLAGS)) {

				swap_pci_ref(&dma_pdev, tmp);

				break;

			}

			pci_dev_put(tmp);

		}

	}



	/*

	 * Devices on the root bus go through the iommu.  If that's not us,

	 * find the next upstream device and test ACS up to the root bus.

	 * Finding the next device may require skipping virtual buses.

	 */

	while (!pci_is_root_bus(dma_pdev->bus)) {

		struct pci_bus *bus = find_hosted_bus(dma_pdev->bus);

		if (IS_ERR(bus))

			break;



		if (pci_acs_path_enabled(bus->self, NULL, REQ_ACS_FLAGS))

			break;



		swap_pci_ref(&dma_pdev, pci_dev_get(bus->self));

	}



	return dma_pdev;

}



static int use_pdev_iommu_group(struct pci_dev *pdev, struct device *dev)

{

{

	struct iommu_group *group = iommu_group_get(&pdev->dev);

	struct iommu_group *group;

	int ret;



	if (!group) {

		group = iommu_group_alloc();

		if (IS_ERR(group))

			return PTR_ERR(group);



		WARN_ON(&pdev->dev != dev);

	}





	ret = iommu_group_add_device(group, dev);

	group = iommu_group_get_for_dev(dev);

	iommu_group_put(group);

	return ret;

}





static int use_dev_data_iommu_group(struct iommu_dev_data *dev_data,

				    struct device *dev)

{

	if (!dev_data->group) {

		struct iommu_group *group = iommu_group_alloc();

	if (IS_ERR(group))

	if (IS_ERR(group))

		return PTR_ERR(group);

		return PTR_ERR(group);





		dev_data->group = group;

	}



	return iommu_group_add_device(dev_data->group, dev);

}



static int init_iommu_group(struct device *dev)

{

	struct iommu_dev_data *dev_data;

	struct iommu_group *group;

	struct pci_dev *dma_pdev;

	int ret;



	group = iommu_group_get(dev);

	if (group) {

	iommu_group_put(group);

	iommu_group_put(group);

	return 0;

	return 0;

}

}





	dev_data = find_dev_data(get_device_id(dev));

	if (!dev_data)

		return -ENOMEM;



	if (dev_data->alias_data) {

		u16 alias;

		struct pci_bus *bus;



		if (dev_data->alias_data->group)

			goto use_group;



		/*

		 * If the alias device exists, it's effectively just a first

		 * level quirk for finding the DMA source.

		 */

		alias = amd_iommu_alias_table[dev_data->devid];

		dma_pdev = pci_get_bus_and_slot(alias >> 8, alias & 0xff);

		if (dma_pdev) {

			dma_pdev = get_isolation_root(dma_pdev);

			goto use_pdev;

		}



		/*

		 * If the alias is virtual, try to find a parent device

		 * and test whether the IOMMU group is actualy rooted above

		 * the alias.  Be careful to also test the parent device if

		 * we think the alias is the root of the group.

		 */

		bus = pci_find_bus(0, alias >> 8);

		if (!bus)

			goto use_group;



		bus = find_hosted_bus(bus);

		if (IS_ERR(bus) || !bus->self)

			goto use_group;



		dma_pdev = get_isolation_root(pci_dev_get(bus->self));

		if (dma_pdev != bus->self || (dma_pdev->multifunction &&

		    !pci_acs_enabled(dma_pdev, REQ_ACS_FLAGS)))

			goto use_pdev;



		pci_dev_put(dma_pdev);

		goto use_group;

	}



	dma_pdev = get_isolation_root(pci_dev_get(to_pci_dev(dev)));

use_pdev:

	ret = use_pdev_iommu_group(dma_pdev, dev);

	pci_dev_put(dma_pdev);

	return ret;

use_group:

	return use_dev_data_iommu_group(dev_data->alias_data, dev);

}



static int __last_alias(struct pci_dev *pdev, u16 alias, void *data)

static int __last_alias(struct pci_dev *pdev, u16 alias, void *data)

{

{

	*(u16 *)data = alias;

	*(u16 *)data = alias;

drivers/iommu/amd_iommu_types.h

+0 −1
Original line number Original line Diff line number Diff line
@@ -432,7 +432,6 @@ struct iommu_dev_data { 
	struct iommu_dev_data *alias_data;/* The alias dev_data */

	struct iommu_dev_data *alias_data;/* The alias dev_data */

	struct protection_domain *domain; /* Domain the device is bound to */

	struct protection_domain *domain; /* Domain the device is bound to */

	atomic_t bind;			  /* Domain attach reference count */

	atomic_t bind;			  /* Domain attach reference count */

	struct iommu_group *group;	  /* IOMMU group for virtual aliases */

	u16 devid;			  /* PCI Device ID */

	u16 devid;			  /* PCI Device ID */

	bool iommu_v2;			  /* Device can make use of IOMMUv2 */

	bool iommu_v2;			  /* Device can make use of IOMMUv2 */

	bool passthrough;		  /* Default for device is pt_domain */

	bool passthrough;		  /* Default for device is pt_domain */