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

#include <linux/kernel.h>
#include <linux/export.h>
#include <linux/of.h>
#include <linux/of_pci.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);

#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_chip *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_chip *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_chip *of_pci_find_msi_chip_by_node(struct device_node *of_node)
{
	struct msi_chip *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 */
Commit	Line	Data
04bea68b	1	#include <linux/kernel.h>
9775913f	2	#include <linux/export.h>
a6422850	3	#include <linux/of.h>
04bea68b	4	#include <linux/of_pci.h>
04bea68b	5
98d9f30c	6	static inline int __of_pci_pci_compare(struct device_node *node,
45ab9702	7	unsigned int data)
04bea68b	8	{
45ab9702	9	int devfn;
04bea68b	10
45ab9702 TR	11	devfn = of_pci_get_devfn(node);
45ab9702 TR	12	if (devfn < 0)
98d9f30c	13	return 0;
45ab9702 TR	14
45ab9702 TR	15	return devfn == data;
98d9f30c	16	}
04bea68b	17
98d9f30c BH	18	struct device_node of_pci_find_child_device(struct device_node parent,
	19	unsigned int devfn)
	20	{
	21	struct device_node node, node2;
	22
	23	for_each_child_of_node(parent, node) {
	24	if (__of_pci_pci_compare(node, devfn))
	25	return node;
	26	/*
	27	* Some OFs create a parent node "multifunc-device" as
	28	* a fake root for all functions of a multi-function
	29	* device we go down them as well.
04bea68b	30	*/
98d9f30c BH	31	if (!strcmp(node->name, "multifunc-device")) {
	32	for_each_child_of_node(node, node2) {
	33	if (__of_pci_pci_compare(node2, devfn)) {
	34	of_node_put(node);
	35	return node2;
	36	}
	37	}
	38	}
04bea68b	39	}
98d9f30c	40	return NULL;
04bea68b	41	}
98d9f30c	42	EXPORT_SYMBOL_GPL(of_pci_find_child_device);
45ab9702 TR	43
	44	/**
	45	* of_pci_get_devfn() - Get device and function numbers for a device node
	46	* @np: device node
	47	*
	48	* Parses a standard 5-cell PCI resource and returns an 8-bit value that can
	49	* be passed to the PCI_SLOT() and PCI_FUNC() macros to extract the device
	50	* and function numbers respectively. On error a negative error code is
	51	* returned.
	52	*/
	53	int of_pci_get_devfn(struct device_node *np)
	54	{
	55	unsigned int size;
	56	const __be32 *reg;
	57
	58	reg = of_get_property(np, "reg", &size);
	59
	60	if (!reg \|\| size < 5 * sizeof(__be32))
	61	return -EINVAL;
	62
	63	return (be32_to_cpup(reg) >> 8) & 0xff;
	64	}
	65	EXPORT_SYMBOL_GPL(of_pci_get_devfn);
4e23d3f5 TR	66
	67	/**
	68	* of_pci_parse_bus_range() - parse the bus-range property of a PCI device
	69	* @node: device node
	70	* @res: address to a struct resource to return the bus-range
	71	*
	72	* Returns 0 on success or a negative error-code on failure.
	73	*/
	74	int of_pci_parse_bus_range(struct device_node node, struct resource res)
	75	{
	76	const __be32 *values;
	77	int len;
	78
	79	values = of_get_property(node, "bus-range", &len);
	80	if (!values \|\| len < sizeof(values) 2)
	81	return -EINVAL;
	82
	83	res->name = node->name;
	84	res->start = be32_to_cpup(values++);
	85	res->end = be32_to_cpup(values);
	86	res->flags = IORESOURCE_BUS;
	87
	88	return 0;
	89	}
	90	EXPORT_SYMBOL_GPL(of_pci_parse_bus_range);
0d5a6db3 TP	91
	92	#ifdef CONFIG_PCI_MSI
	93
	94	static LIST_HEAD(of_pci_msi_chip_list);
	95	static DEFINE_MUTEX(of_pci_msi_chip_mutex);
	96
	97	int of_pci_msi_chip_add(struct msi_chip *chip)
	98	{
	99	if (!of_property_read_bool(chip->of_node, "msi-controller"))
	100	return -EINVAL;
	101
	102	mutex_lock(&of_pci_msi_chip_mutex);
	103	list_add(&chip->list, &of_pci_msi_chip_list);
	104	mutex_unlock(&of_pci_msi_chip_mutex);
	105
	106	return 0;
	107	}
	108	EXPORT_SYMBOL_GPL(of_pci_msi_chip_add);
	109
	110	void of_pci_msi_chip_remove(struct msi_chip *chip)
	111	{
	112	mutex_lock(&of_pci_msi_chip_mutex);
	113	list_del(&chip->list);
	114	mutex_unlock(&of_pci_msi_chip_mutex);
	115	}
	116	EXPORT_SYMBOL_GPL(of_pci_msi_chip_remove);
	117
	118	struct msi_chip of_pci_find_msi_chip_by_node(struct device_node of_node)
	119	{
	120	struct msi_chip *c;
	121
	122	mutex_lock(&of_pci_msi_chip_mutex);
	123	list_for_each_entry(c, &of_pci_msi_chip_list, list) {
	124	if (c->of_node == of_node) {
	125	mutex_unlock(&of_pci_msi_chip_mutex);
	126	return c;
	127	}
	128	}
	129	mutex_unlock(&of_pci_msi_chip_mutex);
	130
	131	return NULL;
	132	}
	133	EXPORT_SYMBOL_GPL(of_pci_find_msi_chip_by_node);
	134
	135	#endif /* CONFIG_PCI_MSI */