1#include <linux/kernel.h>
2#include <linux/export.h>
3#include <linux/of.h>
4#include <linux/of_address.h>
5#include <linux/of_device.h>
6#include <linux/of_pci.h>
7#include <linux/slab.h>
8
9static inline int __of_pci_pci_compare(struct device_node *node,
10				       unsigned int data)
11{
12	int devfn;
13
14	devfn = of_pci_get_devfn(node);
15	if (devfn < 0)
16		return 0;
17
18	return devfn == data;
19}
20
21struct device_node *of_pci_find_child_device(struct device_node *parent,
22					     unsigned int devfn)
23{
24	struct device_node *node, *node2;
25
26	for_each_child_of_node(parent, node) {
27		if (__of_pci_pci_compare(node, devfn))
28			return node;
29		/*
30		 * Some OFs create a parent node "multifunc-device" as
31		 * a fake root for all functions of a multi-function
32		 * device we go down them as well.
33		 */
34		if (!strcmp(node->name, "multifunc-device")) {
35			for_each_child_of_node(node, node2) {
36				if (__of_pci_pci_compare(node2, devfn)) {
37					of_node_put(node);
38					return node2;
39				}
40			}
41		}
42	}
43	return NULL;
44}
45EXPORT_SYMBOL_GPL(of_pci_find_child_device);
46
47/**
48 * of_pci_get_devfn() - Get device and function numbers for a device node
49 * @np: device node
50 *
51 * Parses a standard 5-cell PCI resource and returns an 8-bit value that can
52 * be passed to the PCI_SLOT() and PCI_FUNC() macros to extract the device
53 * and function numbers respectively. On error a negative error code is
54 * returned.
55 */
56int of_pci_get_devfn(struct device_node *np)
57{
58	unsigned int size;
59	const __be32 *reg;
60
61	reg = of_get_property(np, "reg", &size);
62
63	if (!reg || size < 5 * sizeof(__be32))
64		return -EINVAL;
65
66	return (be32_to_cpup(reg) >> 8) & 0xff;
67}
68EXPORT_SYMBOL_GPL(of_pci_get_devfn);
69
70/**
71 * of_pci_parse_bus_range() - parse the bus-range property of a PCI device
72 * @node: device node
73 * @res: address to a struct resource to return the bus-range
74 *
75 * Returns 0 on success or a negative error-code on failure.
76 */
77int of_pci_parse_bus_range(struct device_node *node, struct resource *res)
78{
79	const __be32 *values;
80	int len;
81
82	values = of_get_property(node, "bus-range", &len);
83	if (!values || len < sizeof(*values) * 2)
84		return -EINVAL;
85
86	res->name = node->name;
87	res->start = be32_to_cpup(values++);
88	res->end = be32_to_cpup(values);
89	res->flags = IORESOURCE_BUS;
90
91	return 0;
92}
93EXPORT_SYMBOL_GPL(of_pci_parse_bus_range);
94
95/**
96 * This function will try to obtain the host bridge domain number by
97 * finding a property called "linux,pci-domain" of the given device node.
98 *
99 * @node: device tree node with the domain information
100 *
101 * Returns the associated domain number from DT in the range [0-0xffff], or
102 * a negative value if the required property is not found.
103 */
104int of_get_pci_domain_nr(struct device_node *node)
105{
106	const __be32 *value;
107	int len;
108	u16 domain;
109
110	value = of_get_property(node, "linux,pci-domain", &len);
111	if (!value || len < sizeof(*value))
112		return -EINVAL;
113
114	domain = (u16)be32_to_cpup(value);
115
116	return domain;
117}
118EXPORT_SYMBOL_GPL(of_get_pci_domain_nr);
119
120/**
121 * of_pci_dma_configure - Setup DMA configuration
122 * @dev: ptr to pci_dev struct of the PCI device
123 *
124 * Function to update PCI devices's DMA configuration using the same
125 * info from the OF node of host bridge's parent (if any).
126 */
127void of_pci_dma_configure(struct pci_dev *pci_dev)
128{
129	struct device *dev = &pci_dev->dev;
130	struct device *bridge = pci_get_host_bridge_device(pci_dev);
131
132	if (!bridge->parent)
133		return;
134
135	of_dma_configure(dev, bridge->parent->of_node);
136	pci_put_host_bridge_device(bridge);
137}
138EXPORT_SYMBOL_GPL(of_pci_dma_configure);
139
140#if defined(CONFIG_OF_ADDRESS)
141/**
142 * of_pci_get_host_bridge_resources - Parse PCI host bridge resources from DT
143 * @dev: device node of the host bridge having the range property
144 * @busno: bus number associated with the bridge root bus
145 * @bus_max: maximum number of buses for this bridge
146 * @resources: list where the range of resources will be added after DT parsing
147 * @io_base: pointer to a variable that will contain on return the physical
148 * address for the start of the I/O range. Can be NULL if the caller doesn't
149 * expect IO ranges to be present in the device tree.
150 *
151 * It is the caller's job to free the @resources list.
152 *
153 * This function will parse the "ranges" property of a PCI host bridge device
154 * node and setup the resource mapping based on its content. It is expected
155 * that the property conforms with the Power ePAPR document.
156 *
157 * It returns zero if the range parsing has been successful or a standard error
158 * value if it failed.
159 */
160int of_pci_get_host_bridge_resources(struct device_node *dev,
161			unsigned char busno, unsigned char bus_max,
162			struct list_head *resources, resource_size_t *io_base)
163{
164	struct resource_entry *window;
165	struct resource *res;
166	struct resource *bus_range;
167	struct of_pci_range range;
168	struct of_pci_range_parser parser;
169	char range_type[4];
170	int err;
171
172	if (io_base)
173		*io_base = (resource_size_t)OF_BAD_ADDR;
174
175	bus_range = kzalloc(sizeof(*bus_range), GFP_KERNEL);
176	if (!bus_range)
177		return -ENOMEM;
178
179	pr_info("PCI host bridge %s ranges:\n", dev->full_name);
180
181	err = of_pci_parse_bus_range(dev, bus_range);
182	if (err) {
183		bus_range->start = busno;
184		bus_range->end = bus_max;
185		bus_range->flags = IORESOURCE_BUS;
186		pr_info("  No bus range found for %s, using %pR\n",
187			dev->full_name, bus_range);
188	} else {
189		if (bus_range->end > bus_range->start + bus_max)
190			bus_range->end = bus_range->start + bus_max;
191	}
192	pci_add_resource(resources, bus_range);
193
194	/* Check for ranges property */
195	err = of_pci_range_parser_init(&parser, dev);
196	if (err)
197		goto parse_failed;
198
199	pr_debug("Parsing ranges property...\n");
200	for_each_of_pci_range(&parser, &range) {
201		/* Read next ranges element */
202		if ((range.flags & IORESOURCE_TYPE_BITS) == IORESOURCE_IO)
203			snprintf(range_type, 4, " IO");
204		else if ((range.flags & IORESOURCE_TYPE_BITS) == IORESOURCE_MEM)
205			snprintf(range_type, 4, "MEM");
206		else
207			snprintf(range_type, 4, "err");
208		pr_info("  %s %#010llx..%#010llx -> %#010llx\n", range_type,
209			range.cpu_addr, range.cpu_addr + range.size - 1,
210			range.pci_addr);
211
212		/*
213		 * If we failed translation or got a zero-sized region
214		 * then skip this range
215		 */
216		if (range.cpu_addr == OF_BAD_ADDR || range.size == 0)
217			continue;
218
219		res = kzalloc(sizeof(struct resource), GFP_KERNEL);
220		if (!res) {
221			err = -ENOMEM;
222			goto parse_failed;
223		}
224
225		err = of_pci_range_to_resource(&range, dev, res);
226		if (err)
227			goto conversion_failed;
228
229		if (resource_type(res) == IORESOURCE_IO) {
230			if (!io_base) {
231				pr_err("I/O range found for %s. Please provide an io_base pointer to save CPU base address\n",
232					dev->full_name);
233				err = -EINVAL;
234				goto conversion_failed;
235			}
236			if (*io_base != (resource_size_t)OF_BAD_ADDR)
237				pr_warn("More than one I/O resource converted for %s. CPU base address for old range lost!\n",
238					dev->full_name);
239			*io_base = range.cpu_addr;
240		}
241
242		pci_add_resource_offset(resources, res,	res->start - range.pci_addr);
243	}
244
245	return 0;
246
247conversion_failed:
248	kfree(res);
249parse_failed:
250	resource_list_for_each_entry(window, resources)
251		kfree(window->res);
252	pci_free_resource_list(resources);
253	return err;
254}
255EXPORT_SYMBOL_GPL(of_pci_get_host_bridge_resources);
256#endif /* CONFIG_OF_ADDRESS */
257
258#ifdef CONFIG_PCI_MSI
259
260static LIST_HEAD(of_pci_msi_chip_list);
261static DEFINE_MUTEX(of_pci_msi_chip_mutex);
262
263int of_pci_msi_chip_add(struct msi_controller *chip)
264{
265	if (!of_property_read_bool(chip->of_node, "msi-controller"))
266		return -EINVAL;
267
268	mutex_lock(&of_pci_msi_chip_mutex);
269	list_add(&chip->list, &of_pci_msi_chip_list);
270	mutex_unlock(&of_pci_msi_chip_mutex);
271
272	return 0;
273}
274EXPORT_SYMBOL_GPL(of_pci_msi_chip_add);
275
276void of_pci_msi_chip_remove(struct msi_controller *chip)
277{
278	mutex_lock(&of_pci_msi_chip_mutex);
279	list_del(&chip->list);
280	mutex_unlock(&of_pci_msi_chip_mutex);
281}
282EXPORT_SYMBOL_GPL(of_pci_msi_chip_remove);
283
284struct msi_controller *of_pci_find_msi_chip_by_node(struct device_node *of_node)
285{
286	struct msi_controller *c;
287
288	mutex_lock(&of_pci_msi_chip_mutex);
289	list_for_each_entry(c, &of_pci_msi_chip_list, list) {
290		if (c->of_node == of_node) {
291			mutex_unlock(&of_pci_msi_chip_mutex);
292			return c;
293		}
294	}
295	mutex_unlock(&of_pci_msi_chip_mutex);
296
297	return NULL;
298}
299EXPORT_SYMBOL_GPL(of_pci_find_msi_chip_by_node);
300
301#endif /* CONFIG_PCI_MSI */
302