[mirror_ubuntu-zesty-kernel.git] / drivers / of / of_pci.c

#define pr_fmt(fmt)	"OF: PCI: " fmt

#include <linux/kernel.h>
#include <linux/export.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_device.h>
#include <linux/of_pci.h>
#include <linux/slab.h>

static inline int __of_pci_pci_compare(struct device_node *node,
				       unsigned int data)
{
	int devfn;

	devfn = of_pci_get_devfn(node);
	if (devfn < 0)
		return 0;

	return devfn == data;
}

struct device_node *of_pci_find_child_device(struct device_node *parent,
					     unsigned int devfn)
{
	struct device_node *node, *node2;

	for_each_child_of_node(parent, node) {
		if (__of_pci_pci_compare(node, devfn))
			return node;
		/*
		 * Some OFs create a parent node "multifunc-device" as
		 * a fake root for all functions of a multi-function
		 * device we go down them as well.
		 */
		if (!strcmp(node->name, "multifunc-device")) {
			for_each_child_of_node(node, node2) {
				if (__of_pci_pci_compare(node2, devfn)) {
					of_node_put(node);
					return node2;
				}
			}
		}
	}
	return NULL;
}
EXPORT_SYMBOL_GPL(of_pci_find_child_device);

/**
 * of_pci_get_devfn() - Get device and function numbers for a device node
 * @np: device node
 *
 * Parses a standard 5-cell PCI resource and returns an 8-bit value that can
 * be passed to the PCI_SLOT() and PCI_FUNC() macros to extract the device
 * and function numbers respectively. On error a negative error code is
 * returned.
 */
int of_pci_get_devfn(struct device_node *np)
{
	unsigned int size;
	const __be32 *reg;

	reg = of_get_property(np, "reg", &size);

	if (!reg || size < 5 * sizeof(__be32))
		return -EINVAL;

	return (be32_to_cpup(reg) >> 8) & 0xff;
}
EXPORT_SYMBOL_GPL(of_pci_get_devfn);

/**
 * of_pci_parse_bus_range() - parse the bus-range property of a PCI device
 * @node: device node
 * @res: address to a struct resource to return the bus-range
 *
 * Returns 0 on success or a negative error-code on failure.
 */
int of_pci_parse_bus_range(struct device_node *node, struct resource *res)
{
	const __be32 *values;
	int len;

	values = of_get_property(node, "bus-range", &len);
	if (!values || len < sizeof(*values) * 2)
		return -EINVAL;

	res->name = node->name;
	res->start = be32_to_cpup(values++);
	res->end = be32_to_cpup(values);
	res->flags = IORESOURCE_BUS;

	return 0;
}
EXPORT_SYMBOL_GPL(of_pci_parse_bus_range);

/**
 * This function will try to obtain the host bridge domain number by
 * finding a property called "linux,pci-domain" of the given device node.
 *
 * @node: device tree node with the domain information
 *
 * Returns the associated domain number from DT in the range [0-0xffff], or
 * a negative value if the required property is not found.
 */
int of_get_pci_domain_nr(struct device_node *node)
{
	const __be32 *value;
	int len;
	u16 domain;

	value = of_get_property(node, "linux,pci-domain", &len);
	if (!value || len < sizeof(*value))
		return -EINVAL;

	domain = (u16)be32_to_cpup(value);

	return domain;
}
EXPORT_SYMBOL_GPL(of_get_pci_domain_nr);

/**
 * This function will try to find the limitation of link speed by finding
 * a property called "max-link-speed" of the given device node.
 *
 * @node: device tree node with the max link speed information
 *
 * Returns the associated max link speed from DT, or a negative value if the
 * required property is not found or is invalid.
 */
int of_pci_get_max_link_speed(struct device_node *node)
{
	u32 max_link_speed;

	if (of_property_read_u32(node, "max-link-speed", &max_link_speed) ||
	    max_link_speed > 4)
		return -EINVAL;

	return max_link_speed;
}
EXPORT_SYMBOL_GPL(of_pci_get_max_link_speed);

/**
 * of_pci_check_probe_only - Setup probe only mode if linux,pci-probe-only
 *                           is present and valid
 */
void of_pci_check_probe_only(void)
{
	u32 val;
	int ret;

	ret = of_property_read_u32(of_chosen, "linux,pci-probe-only", &val);
	if (ret) {
		if (ret == -ENODATA || ret == -EOVERFLOW)
			pr_warn("linux,pci-probe-only without valid value, ignoring\n");
		return;
	}

	if (val)
		pci_add_flags(PCI_PROBE_ONLY);
	else
		pci_clear_flags(PCI_PROBE_ONLY);

	pr_info("PROBE_ONLY %sabled\n", val ? "en" : "dis");
}
EXPORT_SYMBOL_GPL(of_pci_check_probe_only);

#if defined(CONFIG_OF_ADDRESS)
/**
 * of_pci_get_host_bridge_resources - Parse PCI host bridge resources from DT
 * @dev: device node of the host bridge having the range property
 * @busno: bus number associated with the bridge root bus
 * @bus_max: maximum number of buses for this bridge
 * @resources: list where the range of resources will be added after DT parsing
 * @io_base: pointer to a variable that will contain on return the physical
 * address for the start of the I/O range. Can be NULL if the caller doesn't
 * expect IO ranges to be present in the device tree.
 *
 * It is the caller's job to free the @resources list.
 *
 * This function will parse the "ranges" property of a PCI host bridge device
 * node and setup the resource mapping based on its content. It is expected
 * that the property conforms with the Power ePAPR document.
 *
 * It returns zero if the range parsing has been successful or a standard error
 * value if it failed.
 */
int of_pci_get_host_bridge_resources(struct device_node *dev,
			unsigned char busno, unsigned char bus_max,
			struct list_head *resources, resource_size_t *io_base)
{
	struct resource_entry *window;
	struct resource *res;
	struct resource *bus_range;
	struct of_pci_range range;
	struct of_pci_range_parser parser;
	char range_type[4];
	int err;

	if (io_base)
		*io_base = (resource_size_t)OF_BAD_ADDR;

	bus_range = kzalloc(sizeof(*bus_range), GFP_KERNEL);
	if (!bus_range)
		return -ENOMEM;

	pr_info("host bridge %s ranges:\n", dev->full_name);

	err = of_pci_parse_bus_range(dev, bus_range);
	if (err) {
		bus_range->start = busno;
		bus_range->end = bus_max;
		bus_range->flags = IORESOURCE_BUS;
		pr_info("  No bus range found for %s, using %pR\n",
			dev->full_name, bus_range);
	} else {
		if (bus_range->end > bus_range->start + bus_max)
			bus_range->end = bus_range->start + bus_max;
	}
	pci_add_resource(resources, bus_range);

	/* Check for ranges property */
	err = of_pci_range_parser_init(&parser, dev);
	if (err)
		goto parse_failed;

	pr_debug("Parsing ranges property...\n");
	for_each_of_pci_range(&parser, &range) {
		/* Read next ranges element */
		if ((range.flags & IORESOURCE_TYPE_BITS) == IORESOURCE_IO)
			snprintf(range_type, 4, " IO");
		else if ((range.flags & IORESOURCE_TYPE_BITS) == IORESOURCE_MEM)
			snprintf(range_type, 4, "MEM");
		else
			snprintf(range_type, 4, "err");
		pr_info("  %s %#010llx..%#010llx -> %#010llx\n", range_type,
			range.cpu_addr, range.cpu_addr + range.size - 1,
			range.pci_addr);

		/*
		 * If we failed translation or got a zero-sized region
		 * then skip this range
		 */
		if (range.cpu_addr == OF_BAD_ADDR || range.size == 0)
			continue;

		res = kzalloc(sizeof(struct resource), GFP_KERNEL);
		if (!res) {
			err = -ENOMEM;
			goto parse_failed;
		}

		err = of_pci_range_to_resource(&range, dev, res);
		if (err) {
			kfree(res);
			continue;
		}

		if (resource_type(res) == IORESOURCE_IO) {
			if (!io_base) {
				pr_err("I/O range found for %s. Please provide an io_base pointer to save CPU base address\n",
					dev->full_name);
				err = -EINVAL;
				goto conversion_failed;
			}
			if (*io_base != (resource_size_t)OF_BAD_ADDR)
				pr_warn("More than one I/O resource converted for %s. CPU base address for old range lost!\n",
					dev->full_name);
			*io_base = range.cpu_addr;
		}

		pci_add_resource_offset(resources, res,	res->start - range.pci_addr);
	}

	return 0;

conversion_failed:
	kfree(res);
parse_failed:
	resource_list_for_each_entry(window, resources)
		kfree(window->res);
	pci_free_resource_list(resources);
	return err;
}
EXPORT_SYMBOL_GPL(of_pci_get_host_bridge_resources);
#endif /* CONFIG_OF_ADDRESS */

#ifdef CONFIG_PCI_MSI

static LIST_HEAD(of_pci_msi_chip_list);
static DEFINE_MUTEX(of_pci_msi_chip_mutex);

int of_pci_msi_chip_add(struct msi_controller *chip)
{
	if (!of_property_read_bool(chip->of_node, "msi-controller"))
		return -EINVAL;

	mutex_lock(&of_pci_msi_chip_mutex);
	list_add(&chip->list, &of_pci_msi_chip_list);
	mutex_unlock(&of_pci_msi_chip_mutex);

	return 0;
}
EXPORT_SYMBOL_GPL(of_pci_msi_chip_add);

void of_pci_msi_chip_remove(struct msi_controller *chip)
{
	mutex_lock(&of_pci_msi_chip_mutex);
	list_del(&chip->list);
	mutex_unlock(&of_pci_msi_chip_mutex);
}
EXPORT_SYMBOL_GPL(of_pci_msi_chip_remove);

struct msi_controller *of_pci_find_msi_chip_by_node(struct device_node *of_node)
{
	struct msi_controller *c;

	mutex_lock(&of_pci_msi_chip_mutex);
	list_for_each_entry(c, &of_pci_msi_chip_list, list) {
		if (c->of_node == of_node) {
			mutex_unlock(&of_pci_msi_chip_mutex);
			return c;
		}
	}
	mutex_unlock(&of_pci_msi_chip_mutex);

	return NULL;
}
EXPORT_SYMBOL_GPL(of_pci_find_msi_chip_by_node);

#endif /* CONFIG_PCI_MSI */

/**
 * of_pci_map_rid - Translate a requester ID through a downstream mapping.
 * @np: root complex device node.
 * @rid: PCI requester ID to map.
 * @map_name: property name of the map to use.
 * @map_mask_name: optional property name of the mask to use.
 * @target: optional pointer to a target device node.
 * @id_out: optional pointer to receive the translated ID.
 *
 * Given a PCI requester ID, look up the appropriate implementation-defined
 * platform ID and/or the target device which receives transactions on that
 * ID, as per the "iommu-map" and "msi-map" bindings. Either of @target or
 * @id_out may be NULL if only the other is required. If @target points to
 * a non-NULL device node pointer, only entries targeting that node will be
 * matched; if it points to a NULL value, it will receive the device node of
 * the first matching target phandle, with a reference held.
 *
 * Return: 0 on success or a standard error code on failure.
 */
int of_pci_map_rid(struct device_node *np, u32 rid,
		   const char *map_name, const char *map_mask_name,
		   struct device_node **target, u32 *id_out)
{
	u32 map_mask, masked_rid;
	int map_len;
	const __be32 *map = NULL;

	if (!np || !map_name || (!target && !id_out))
		return -EINVAL;

	map = of_get_property(np, map_name, &map_len);
	if (!map) {
		if (target)
			return -ENODEV;
		/* Otherwise, no map implies no translation */
		*id_out = rid;
		return 0;
	}

	if (!map_len || map_len % (4 * sizeof(*map))) {
		pr_err("%s: Error: Bad %s length: %d\n", np->full_name,
			map_name, map_len);
		return -EINVAL;
	}

	/* The default is to select all bits. */
	map_mask = 0xffffffff;

	/*
	 * Can be overridden by "{iommu,msi}-map-mask" property.
	 * If of_property_read_u32() fails, the default is used.
	 */
	if (map_mask_name)
		of_property_read_u32(np, map_mask_name, &map_mask);

	masked_rid = map_mask & rid;
	for ( ; map_len > 0; map_len -= 4 * sizeof(*map), map += 4) {
		struct device_node *phandle_node;
		u32 rid_base = be32_to_cpup(map + 0);
		u32 phandle = be32_to_cpup(map + 1);
		u32 out_base = be32_to_cpup(map + 2);
		u32 rid_len = be32_to_cpup(map + 3);

		if (rid_base & ~map_mask) {
			pr_err("%s: Invalid %s translation - %s-mask (0x%x) ignores rid-base (0x%x)\n",
				np->full_name, map_name, map_name,
				map_mask, rid_base);
			return -EFAULT;
		}

		if (masked_rid < rid_base || masked_rid >= rid_base + rid_len)
			continue;

		phandle_node = of_find_node_by_phandle(phandle);
		if (!phandle_node)
			return -ENODEV;

		if (target) {
			if (*target)
				of_node_put(phandle_node);
			else
				*target = phandle_node;

			if (*target != phandle_node)
				continue;
		}

		if (id_out)
			*id_out = masked_rid - rid_base + out_base;

		pr_debug("%s: %s, using mask %08x, rid-base: %08x, out-base: %08x, length: %08x, rid: %08x -> %08x\n",
			np->full_name, map_name, map_mask, rid_base, out_base,
			rid_len, rid, *id_out);
		return 0;
	}

	pr_err("%s: Invalid %s translation - no match for rid 0x%x on %s\n",
		np->full_name, map_name, rid,
		target && *target ? (*target)->full_name : "any target");
	return -EFAULT;
}
Commit	Line	Data
606ad42a RH	1	#define pr_fmt(fmt) "OF: PCI: " fmt
606ad42a RH	2
04bea68b	3	#include <linux/kernel.h>
9775913f	4	#include <linux/export.h>
a6422850	5	#include <linux/of.h>
cbe4097f	6	#include <linux/of_address.h>
c49b8fc2	7	#include <linux/of_device.h>
04bea68b	8	#include <linux/of_pci.h>
cbe4097f	9	#include <linux/slab.h>
04bea68b	10
98d9f30c	11	static inline int __of_pci_pci_compare(struct device_node *node,
45ab9702	12	unsigned int data)
04bea68b	13	{
45ab9702	14	int devfn;
04bea68b	15
45ab9702 TR	16	devfn = of_pci_get_devfn(node);
45ab9702 TR	17	if (devfn < 0)
98d9f30c	18	return 0;
45ab9702 TR	19
45ab9702 TR	20	return devfn == data;
98d9f30c	21	}
04bea68b	22
98d9f30c BH	23	struct device_node of_pci_find_child_device(struct device_node parent,
	24	unsigned int devfn)
	25	{
	26	struct device_node node, node2;
	27
	28	for_each_child_of_node(parent, node) {
	29	if (__of_pci_pci_compare(node, devfn))
	30	return node;
	31	/*
	32	* Some OFs create a parent node "multifunc-device" as
	33	* a fake root for all functions of a multi-function
	34	* device we go down them as well.
04bea68b	35	*/
98d9f30c BH	36	if (!strcmp(node->name, "multifunc-device")) {
	37	for_each_child_of_node(node, node2) {
	38	if (__of_pci_pci_compare(node2, devfn)) {
	39	of_node_put(node);
	40	return node2;
	41	}
	42	}
	43	}
04bea68b	44	}
98d9f30c	45	return NULL;
04bea68b	46	}
98d9f30c	47	EXPORT_SYMBOL_GPL(of_pci_find_child_device);
45ab9702 TR	48
	49	/**
	50	* of_pci_get_devfn() - Get device and function numbers for a device node
	51	* @np: device node
	52	*
	53	* Parses a standard 5-cell PCI resource and returns an 8-bit value that can
	54	* be passed to the PCI_SLOT() and PCI_FUNC() macros to extract the device
	55	* and function numbers respectively. On error a negative error code is
	56	* returned.
	57	*/
	58	int of_pci_get_devfn(struct device_node *np)
	59	{
	60	unsigned int size;
	61	const __be32 *reg;
	62
	63	reg = of_get_property(np, "reg", &size);
	64
	65	if (!reg \|\| size < 5 * sizeof(__be32))
	66	return -EINVAL;
	67
	68	return (be32_to_cpup(reg) >> 8) & 0xff;
	69	}
	70	EXPORT_SYMBOL_GPL(of_pci_get_devfn);
4e23d3f5 TR	71
	72	/**
	73	* of_pci_parse_bus_range() - parse the bus-range property of a PCI device
	74	* @node: device node
	75	* @res: address to a struct resource to return the bus-range
	76	*
	77	* Returns 0 on success or a negative error-code on failure.
	78	*/
	79	int of_pci_parse_bus_range(struct device_node node, struct resource res)
	80	{
	81	const __be32 *values;
	82	int len;
	83
	84	values = of_get_property(node, "bus-range", &len);
	85	if (!values \|\| len < sizeof(values) 2)
	86	return -EINVAL;
	87
	88	res->name = node->name;
	89	res->start = be32_to_cpup(values++);
	90	res->end = be32_to_cpup(values);
	91	res->flags = IORESOURCE_BUS;
	92
	93	return 0;
	94	}
	95	EXPORT_SYMBOL_GPL(of_pci_parse_bus_range);
0d5a6db3	96
41e5c0f8 LD	97	/**
	98	* This function will try to obtain the host bridge domain number by
	99	* finding a property called "linux,pci-domain" of the given device node.
	100	*
	101	* @node: device tree node with the domain information
	102	*
	103	* Returns the associated domain number from DT in the range [0-0xffff], or
	104	* a negative value if the required property is not found.
	105	*/
	106	int of_get_pci_domain_nr(struct device_node *node)
	107	{
	108	const __be32 *value;
	109	int len;
	110	u16 domain;
	111
	112	value = of_get_property(node, "linux,pci-domain", &len);
	113	if (!value \|\| len < sizeof(*value))
	114	return -EINVAL;
	115
	116	domain = (u16)be32_to_cpup(value);
	117
	118	return domain;
	119	}
	120	EXPORT_SYMBOL_GPL(of_get_pci_domain_nr);
	121
9a1dc389 SL	122	/**
	123	* This function will try to find the limitation of link speed by finding
	124	* a property called "max-link-speed" of the given device node.
	125	*
	126	* @node: device tree node with the max link speed information
	127	*
	128	* Returns the associated max link speed from DT, or a negative value if the
	129	* required property is not found or is invalid.
	130	*/
	131	int of_pci_get_max_link_speed(struct device_node *node)
	132	{
	133	u32 max_link_speed;
	134
	135	if (of_property_read_u32(node, "max-link-speed", &max_link_speed) \|\|
	136	max_link_speed > 4)
	137	return -EINVAL;
	138
	139	return max_link_speed;
	140	}
	141	EXPORT_SYMBOL_GPL(of_pci_get_max_link_speed);
	142
f81c11af MZ	143	/**
	144	* of_pci_check_probe_only - Setup probe only mode if linux,pci-probe-only
	145	* is present and valid
	146	*/
	147	void of_pci_check_probe_only(void)
	148	{
	149	u32 val;
	150	int ret;
	151
	152	ret = of_property_read_u32(of_chosen, "linux,pci-probe-only", &val);
	153	if (ret) {
	154	if (ret == -ENODATA \|\| ret == -EOVERFLOW)
	155	pr_warn("linux,pci-probe-only without valid value, ignoring\n");
	156	return;
	157	}
	158
	159	if (val)
	160	pci_add_flags(PCI_PROBE_ONLY);
	161	else
	162	pci_clear_flags(PCI_PROBE_ONLY);
	163
606ad42a	164	pr_info("PROBE_ONLY %sabled\n", val ? "en" : "dis");
f81c11af MZ	165	}
	166	EXPORT_SYMBOL_GPL(of_pci_check_probe_only);
	167
cbe4097f LD	168	#if defined(CONFIG_OF_ADDRESS)
	169	/**
	170	* of_pci_get_host_bridge_resources - Parse PCI host bridge resources from DT
	171	* @dev: device node of the host bridge having the range property
	172	* @busno: bus number associated with the bridge root bus
	173	* @bus_max: maximum number of buses for this bridge
	174	* @resources: list where the range of resources will be added after DT parsing
	175	* @io_base: pointer to a variable that will contain on return the physical
	176	* address for the start of the I/O range. Can be NULL if the caller doesn't
	177	* expect IO ranges to be present in the device tree.
	178	*
	179	* It is the caller's job to free the @resources list.
	180	*
	181	* This function will parse the "ranges" property of a PCI host bridge device
	182	* node and setup the resource mapping based on its content. It is expected
	183	* that the property conforms with the Power ePAPR document.
	184	*
	185	* It returns zero if the range parsing has been successful or a standard error
	186	* value if it failed.
	187	*/
	188	int of_pci_get_host_bridge_resources(struct device_node *dev,
	189	unsigned char busno, unsigned char bus_max,
	190	struct list_head resources, resource_size_t io_base)
	191	{
5c493df2	192	struct resource_entry *window;
cbe4097f LD	193	struct resource *res;
	194	struct resource *bus_range;
	195	struct of_pci_range range;
	196	struct of_pci_range_parser parser;
	197	char range_type[4];
	198	int err;
	199
	200	if (io_base)
	201	*io_base = (resource_size_t)OF_BAD_ADDR;
	202
	203	bus_range = kzalloc(sizeof(*bus_range), GFP_KERNEL);
	204	if (!bus_range)
	205	return -ENOMEM;
	206
606ad42a	207	pr_info("host bridge %s ranges:\n", dev->full_name);
cbe4097f LD	208
	209	err = of_pci_parse_bus_range(dev, bus_range);
	210	if (err) {
	211	bus_range->start = busno;
	212	bus_range->end = bus_max;
	213	bus_range->flags = IORESOURCE_BUS;
	214	pr_info(" No bus range found for %s, using %pR\n",
	215	dev->full_name, bus_range);
	216	} else {
	217	if (bus_range->end > bus_range->start + bus_max)
	218	bus_range->end = bus_range->start + bus_max;
	219	}
	220	pci_add_resource(resources, bus_range);
	221
	222	/* Check for ranges property */
	223	err = of_pci_range_parser_init(&parser, dev);
	224	if (err)
	225	goto parse_failed;
	226
	227	pr_debug("Parsing ranges property...\n");
	228	for_each_of_pci_range(&parser, &range) {
	229	/* Read next ranges element */
	230	if ((range.flags & IORESOURCE_TYPE_BITS) == IORESOURCE_IO)
	231	snprintf(range_type, 4, " IO");
	232	else if ((range.flags & IORESOURCE_TYPE_BITS) == IORESOURCE_MEM)
	233	snprintf(range_type, 4, "MEM");
	234	else
	235	snprintf(range_type, 4, "err");
	236	pr_info(" %s %#010llx..%#010llx -> %#010llx\n", range_type,
	237	range.cpu_addr, range.cpu_addr + range.size - 1,
	238	range.pci_addr);
	239
	240	/*
	241	* If we failed translation or got a zero-sized region
	242	* then skip this range
	243	*/
	244	if (range.cpu_addr == OF_BAD_ADDR \|\| range.size == 0)
	245	continue;
	246
	247	res = kzalloc(sizeof(struct resource), GFP_KERNEL);
	248	if (!res) {
	249	err = -ENOMEM;
	250	goto parse_failed;
	251	}
	252
	253	err = of_pci_range_to_resource(&range, dev, res);
f134f251 PF	254	if (err) {
	255	kfree(res);
	256	continue;
	257	}
cbe4097f LD	258
	259	if (resource_type(res) == IORESOURCE_IO) {
	260	if (!io_base) {
	261	pr_err("I/O range found for %s. Please provide an io_base pointer to save CPU base address\n",
	262	dev->full_name);
	263	err = -EINVAL;
	264	goto conversion_failed;
	265	}
	266	if (*io_base != (resource_size_t)OF_BAD_ADDR)
	267	pr_warn("More than one I/O resource converted for %s. CPU base address for old range lost!\n",
	268	dev->full_name);
	269	*io_base = range.cpu_addr;
	270	}
	271
	272	pci_add_resource_offset(resources, res, res->start - range.pci_addr);
	273	}
	274
	275	return 0;
	276
	277	conversion_failed:
	278	kfree(res);
	279	parse_failed:
5c493df2	280	resource_list_for_each_entry(window, resources)
d2be00c0	281	kfree(window->res);
cbe4097f LD	282	pci_free_resource_list(resources);
	283	return err;
	284	}
	285	EXPORT_SYMBOL_GPL(of_pci_get_host_bridge_resources);
	286	#endif /* CONFIG_OF_ADDRESS */
	287
0d5a6db3 TP	288	#ifdef CONFIG_PCI_MSI
	289
	290	static LIST_HEAD(of_pci_msi_chip_list);
	291	static DEFINE_MUTEX(of_pci_msi_chip_mutex);
	292
c2791b80	293	int of_pci_msi_chip_add(struct msi_controller *chip)
0d5a6db3 TP	294	{
	295	if (!of_property_read_bool(chip->of_node, "msi-controller"))
	296	return -EINVAL;
	297
	298	mutex_lock(&of_pci_msi_chip_mutex);
	299	list_add(&chip->list, &of_pci_msi_chip_list);
	300	mutex_unlock(&of_pci_msi_chip_mutex);
	301
	302	return 0;
	303	}
	304	EXPORT_SYMBOL_GPL(of_pci_msi_chip_add);
	305
c2791b80	306	void of_pci_msi_chip_remove(struct msi_controller *chip)
0d5a6db3 TP	307	{
	308	mutex_lock(&of_pci_msi_chip_mutex);
	309	list_del(&chip->list);
	310	mutex_unlock(&of_pci_msi_chip_mutex);
	311	}
	312	EXPORT_SYMBOL_GPL(of_pci_msi_chip_remove);
	313
c2791b80	314	struct msi_controller of_pci_find_msi_chip_by_node(struct device_node of_node)
0d5a6db3	315	{
c2791b80	316	struct msi_controller *c;
0d5a6db3 TP	317
	318	mutex_lock(&of_pci_msi_chip_mutex);
	319	list_for_each_entry(c, &of_pci_msi_chip_list, list) {
	320	if (c->of_node == of_node) {
	321	mutex_unlock(&of_pci_msi_chip_mutex);
	322	return c;
	323	}
	324	}
	325	mutex_unlock(&of_pci_msi_chip_mutex);
	326
	327	return NULL;
	328	}
	329	EXPORT_SYMBOL_GPL(of_pci_find_msi_chip_by_node);
	330
	331	#endif /* CONFIG_PCI_MSI */
987068fc RM	332
	333	/**
	334	* of_pci_map_rid - Translate a requester ID through a downstream mapping.
	335	* @np: root complex device node.
	336	* @rid: PCI requester ID to map.
	337	* @map_name: property name of the map to use.
	338	* @map_mask_name: optional property name of the mask to use.
	339	* @target: optional pointer to a target device node.
	340	* @id_out: optional pointer to receive the translated ID.
	341	*
	342	* Given a PCI requester ID, look up the appropriate implementation-defined
	343	* platform ID and/or the target device which receives transactions on that
	344	* ID, as per the "iommu-map" and "msi-map" bindings. Either of @target or
	345	* @id_out may be NULL if only the other is required. If @target points to
	346	* a non-NULL device node pointer, only entries targeting that node will be
	347	* matched; if it points to a NULL value, it will receive the device node of
	348	* the first matching target phandle, with a reference held.
	349	*
	350	* Return: 0 on success or a standard error code on failure.
	351	*/
	352	int of_pci_map_rid(struct device_node *np, u32 rid,
	353	const char map_name, const char map_mask_name,
	354	struct device_node *target, u32 id_out)
	355	{
	356	u32 map_mask, masked_rid;
	357	int map_len;
	358	const __be32 *map = NULL;
	359
	360	if (!np \|\| !map_name \|\| (!target && !id_out))
	361	return -EINVAL;
	362
	363	map = of_get_property(np, map_name, &map_len);
	364	if (!map) {
	365	if (target)
	366	return -ENODEV;
	367	/* Otherwise, no map implies no translation */
	368	*id_out = rid;
	369	return 0;
	370	}
	371
	372	if (!map_len \|\| map_len % (4 * sizeof(*map))) {
	373	pr_err("%s: Error: Bad %s length: %d\n", np->full_name,
	374	map_name, map_len);
	375	return -EINVAL;
	376	}
	377
	378	/* The default is to select all bits. */
	379	map_mask = 0xffffffff;
	380
	381	/*
	382	* Can be overridden by "{iommu,msi}-map-mask" property.
	383	* If of_property_read_u32() fails, the default is used.
	384	*/
	385	if (map_mask_name)
	386	of_property_read_u32(np, map_mask_name, &map_mask);
	387
	388	masked_rid = map_mask & rid;
	389	for ( ; map_len > 0; map_len -= 4 * sizeof(*map), map += 4) {
	390	struct device_node *phandle_node;
	391	u32 rid_base = be32_to_cpup(map + 0);
	392	u32 phandle = be32_to_cpup(map + 1);
	393	u32 out_base = be32_to_cpup(map + 2);
	394	u32 rid_len = be32_to_cpup(map + 3);
	395
396	if (rid_base & ~map_mask) {
397	pr_err("%s: Invalid %s translation - %s-mask (0x%x) ignores rid-base (0x%x)\n",
398	np->full_name, map_name, map_name,
399	map_mask, rid_base);
400	return -EFAULT;
401	}
402
403	if (masked_rid < rid_base \|\| masked_rid >= rid_base + rid_len)
404	continue;
405
406	phandle_node = of_find_node_by_phandle(phandle);
407	if (!phandle_node)
408	return -ENODEV;
409
410	if (target) {
411	if (*target)
412	of_node_put(phandle_node);
413	else
414	*target = phandle_node;
415
416	if (*target != phandle_node)
417	continue;
418	}
419
420	if (id_out)
421	*id_out = masked_rid - rid_base + out_base;
422
423	pr_debug("%s: %s, using mask %08x, rid-base: %08x, out-base: %08x, length: %08x, rid: %08x -> %08x\n",
424	np->full_name, map_name, map_mask, rid_base, out_base,
425	rid_len, rid, *id_out);
426	return 0;
427	}
428
429	pr_err("%s: Invalid %s translation - no match for rid 0x%x on %s\n",
430	np->full_name, map_name, rid,
431	target && target ? (target)->full_name : "any target");
432	return -EFAULT;
433	}