PCI/P2PDMA: Add constants for map type results to upstream_bridge_distance()

#include <linux/seq_buf.h>

#include <linux/iommu.h>

enum pci_p2pdma_map_type {

	PCI_P2PDMA_MAP_UNKNOWN = 0,

	PCI_P2PDMA_MAP_NOT_SUPPORTED,

	PCI_P2PDMA_MAP_BUS_ADDR,

	PCI_P2PDMA_MAP_THRU_HOST_BRIDGE,

};

struct pci_p2pdma {

	struct gen_pool *pool;

	bool p2pmem_published;

 * port of the switch, to the common upstream port, back up to the second

 * downstream port and then to Device B.

 *

 * Any two devices that don't have a common upstream bridge will return -1.

 * In this way devices on separate PCIe root ports will be rejected, which

 * is what we want for peer-to-peer seeing each PCIe root port defines a

 * separate hierarchy domain and there's no way to determine whether the root

 * complex supports forwarding between them.

 * Any two devices that cannot communicate using p2pdma will return

 * PCI_P2PDMA_MAP_NOT_SUPPORTED.

 *

 * Any two devices that have a data path that goes through the host bridge

 * will consult a whitelist. If the host bridges are on the whitelist,

 * this function will return PCI_P2PDMA_MAP_THRU_HOST_BRIDGE.

 *

 * In the case where two devices are connected to different PCIe switches,

 * this function will still return a positive distance as long as both

 * switches eventually have a common upstream bridge. Note this covers

 * the case of using multiple PCIe switches to achieve a desired level of

 * fan-out from a root port. The exact distance will be a function of the

 * number of switches between Device A and Device B.

 * If either bridge is not on the whitelist this function returns

 * PCI_P2PDMA_MAP_NOT_SUPPORTED.

 *

 * If a bridge which has any ACS redirection bits set is in the path

 * then this functions will return -2. This is so we reject any

 * cases where the TLPs are forwarded up into the root complex.

 * In this case, a list of all infringing bridge addresses will be

 * populated in acs_list (assuming it's non-null) for printk purposes.

 * If a bridge which has any ACS redirection bits set is in the path,

 * acs_redirects will be set to true. In this case, a list of all infringing

 * bridge addresses will be populated in acs_list (assuming it's non-null)

 * for printk purposes.

 */

static int upstream_bridge_distance(struct pci_dev *provider,

				    struct pci_dev *client,

				    struct seq_buf *acs_list)

static enum pci_p2pdma_map_type

upstream_bridge_distance(struct pci_dev *provider, struct pci_dev *client,

		int *dist, bool *acs_redirects, struct seq_buf *acs_list)

{

	struct pci_dev *a = provider, *b = client, *bb;

	int dist_a = 0;

	int dist_b = 0;

	int acs_cnt = 0;

	if (acs_redirects)

		*acs_redirects = false;

	/*

	 * Note, we don't need to take references to devices returned by

	 * pci_upstream_bridge() seeing we hold a reference to a child

		dist_a++;

	}

	if (dist)

		*dist = dist_a + dist_b;

	/*

	 * Allow the connection if both devices are on a whitelisted root

	 * complex, but add an arbitrary large value to the distance.

	 */

	if (root_complex_whitelist(provider) &&

	    root_complex_whitelist(client))

		return 0x1000 + dist_a + dist_b;

		return PCI_P2PDMA_MAP_THRU_HOST_BRIDGE;

	return -1;

	return PCI_P2PDMA_MAP_NOT_SUPPORTED;

check_b_path_acs:

	bb = b;

		bb = pci_upstream_bridge(bb);

	}

	if (acs_cnt)

		return -2;

	if (dist)

		*dist = dist_a + dist_b;

	return dist_a + dist_b;

	if (acs_cnt) {

		if (acs_redirects)

			*acs_redirects = true;

		return PCI_P2PDMA_MAP_NOT_SUPPORTED;

	}

	return PCI_P2PDMA_MAP_BUS_ADDR;

}

static int upstream_bridge_distance_warn(struct pci_dev *provider,

					 struct pci_dev *client)

static enum pci_p2pdma_map_type

upstream_bridge_distance_warn(struct pci_dev *provider, struct pci_dev *client,

			      int *dist)

{

	struct seq_buf acs_list;

	bool acs_redirects;

	int ret;

	seq_buf_init(&acs_list, kmalloc(PAGE_SIZE, GFP_KERNEL), PAGE_SIZE);

	if (!acs_list.buffer)

		return -ENOMEM;

	ret = upstream_bridge_distance(provider, client, &acs_list);

	if (ret == -2) {

		pci_warn(client, "cannot be used for peer-to-peer DMA as ACS redirect is set between the client and provider (%s)\n",

	ret = upstream_bridge_distance(provider, client, dist, &acs_redirects,

				       &acs_list);

	if (acs_redirects) {

		pci_warn(client, "ACS redirect is set between the client and provider (%s)\n",

			 pci_name(provider));

		/* Drop final semicolon */

		acs_list.buffer[acs_list.len-1] = 0;

		pci_warn(client, "to disable ACS redirect for this path, add the kernel parameter: pci=disable_acs_redir=%s\n",

			 acs_list.buffer);

	}

	} else if (ret < 0) {

		pci_warn(client, "cannot be used for peer-to-peer DMA as the client and provider (%s) do not share an upstream bridge\n",

	if (ret == PCI_P2PDMA_MAP_NOT_SUPPORTED) {

		pci_warn(client, "cannot be used for peer-to-peer DMA as the client and provider (%s) do not share an upstream bridge or whitelisted host bridge\n",

			 pci_name(provider));

	}

{

	bool not_supported = false;

	struct pci_dev *pci_client;

	int distance = 0;

	int total_dist = 0;

	int distance;

	int i, ret;

	if (num_clients == 0)

		if (verbose)

			ret = upstream_bridge_distance_warn(provider,

							    pci_client);

					pci_client, &distance);

		else

			ret = upstream_bridge_distance(provider, pci_client,

						       NULL);

						       &distance, NULL, NULL);

		pci_dev_put(pci_client);

		if (ret < 0)

		if (ret == PCI_P2PDMA_MAP_NOT_SUPPORTED)

			not_supported = true;

		if (not_supported && !verbose)

			break;

		distance += ret;

		total_dist += distance;

	}

	if (not_supported)

		return -1;

	return distance;

	return total_dist;

}

EXPORT_SYMBOL_GPL(pci_p2pdma_distance_many);