1 files changed, 30 insertions, 82 deletions
diff --git a/drivers/of/of_pci.c b/drivers/of/of_pci.c
index ac1ec54e4fd5..ec7b060ae952 100644
--- a/drivers/of/of_pci.c
+++ b/drivers/of/of_pci.c
@@ -1,92 +1,40 @@
 #include <linux/kernel.h>
 #include <linux/of_pci.h>
-#include <linux/of_irq.h>
 #include <asm/prom.h>
-/**
+static inline int __of_pci_pci_compare(struct device_node *node,
- * of_irq_map_pci - Resolve the interrupt for a PCI device
+                                       unsigned int devfn)
- * @pdev:       the device whose interrupt is to be resolved
- * @out_irq:    structure of_irq filled by this function
- *
- * This function resolves the PCI interrupt for a given PCI device. If a
- * device-node exists for a given pci_dev, it will use normal OF tree
- * walking. If not, it will implement standard swizzling and walk up the
- * PCI tree until an device-node is found, at which point it will finish
- * resolving using the OF tree walking.
- */
-int of_irq_map_pci(struct pci_dev *pdev, struct of_irq *out_irq)
 {
-        struct device_node *dn, *ppnode;
+        unsigned int size;
-        struct pci_dev *ppdev;
+        const __be32 *reg = of_get_property(node, "reg", &size);
-        u32 lspec;
-        __be32 lspec_be;
-        __be32 laddr[3];
-        u8 pin;
-        int rc;
-        /* Check if we have a device node, if yes, fallback to standard
+        if (!reg || size < 5 * sizeof(__be32))
-         * device tree parsing
+                return 0;
-         */
+        return ((be32_to_cpup(&reg[0]) >> 8) & 0xff) == devfn;
-        dn = pci_device_to_OF_node(pdev);
+}
-        if (dn) {
-                rc = of_irq_map_one(dn, 0, out_irq);
-                if (!rc)
-                        return rc;
-        }
-        /* Ok, we don't, time to have fun. Let's start by building up an
-         * interrupt spec.  we assume #interrupt-cells is 1, which is standard
-         * for PCI. If you do different, then don't use that routine.
-         */
-        rc = pci_read_config_byte(pdev, PCI_INTERRUPT_PIN, &pin);
-        if (rc != 0)
-                return rc;
-        /* No pin, exit */
-        if (pin == 0)
-                return -ENODEV;
-        /* Now we walk up the PCI tree */
-        lspec = pin;
-        for (;;) {
-                /* Get the pci_dev of our parent */
-                ppdev = pdev->bus->self;
-                /* Ouch, it's a host bridge... */
-                if (ppdev == NULL) {
-                        ppnode = pci_bus_to_OF_node(pdev->bus);
-                        /* No node for host bridge ? give up */
-                        if (ppnode == NULL)
-                                return -EINVAL;
-                } else {
-                        /* We found a P2P bridge, check if it has a node */
-                        ppnode = pci_device_to_OF_node(ppdev);
-                }
-                /* Ok, we have found a parent with a device-node, hand over to
-                 * the OF parsing code.
-                 * We build a unit address from the linux device to be used for
-                 * resolution. Note that we use the linux bus number which may
-                 * not match your firmware bus numbering.
-                 * Fortunately, in most cases, interrupt-map-mask doesn't
-                 * include the bus number as part of the matching.
-                 * You should still be careful about that though if you intend
-                 * to rely on this function (you ship  a firmware that doesn't
-                 * create device nodes for all PCI devices).
-                 */
-                if (ppnode)
-                        break;
-                /* We can only get here if we hit a P2P bridge with no node,
+struct device_node *of_pci_find_child_device(struct device_node *parent,
-                 * let's do standard swizzling and try again
+                                             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.
                 */
-                lspec = pci_swizzle_interrupt_pin(pdev, lspec);
+                if (!strcmp(node->name, "multifunc-device")) {
-                pdev = ppdev;
+                        for_each_child_of_node(node, node2) {
+                                if (__of_pci_pci_compare(node2, devfn)) {
+                                        of_node_put(node);
+                                        return node2;
+                                }
+                        }
+                }
        }
+        return NULL;
-        lspec_be = cpu_to_be32(lspec);
-        laddr[0] = cpu_to_be32((pdev->bus->number << 16) | (pdev->devfn << 8));
-        laddr[1]  = laddr[2] = cpu_to_be32(0);
-        return of_irq_map_raw(ppnode, &lspec_be, 1, laddr, out_irq);
 }
-EXPORT_SYMBOL_GPL(of_irq_map_pci);
+EXPORT_SYMBOL_GPL(of_pci_find_child_device);

diff --git a/drivers/of/of_pci.c b/drivers/of/of_pci.c index ac1ec54e4fd5..ec7b060ae952 100644 --- a/drivers/of/of_pci.c +++ b/drivers/of/of_pci.c
@@ -1,92 +1,40 @@
1	#include <linux/kernel.h>	1	#include <linux/kernel.h>
2	#include <linux/of_pci.h>	2	#include <linux/of_pci.h>
3	#include <linux/of_irq.h>
4	#include <asm/prom.h>	3	#include <asm/prom.h>
5		4
6	/**	5	static inline int __of_pci_pci_compare(struct device_node *node,
7	* of_irq_map_pci - Resolve the interrupt for a PCI device	6	unsigned int devfn)
8	* @pdev: the device whose interrupt is to be resolved
9	* @out_irq: structure of_irq filled by this function
10	*
11	* This function resolves the PCI interrupt for a given PCI device. If a
12	* device-node exists for a given pci_dev, it will use normal OF tree
13	* walking. If not, it will implement standard swizzling and walk up the
14	* PCI tree until an device-node is found, at which point it will finish
15	* resolving using the OF tree walking.
16	*/
17	int of_irq_map_pci(struct pci_dev pdev, struct of_irq out_irq)
18	{	7	{
19	struct device_node dn, ppnode;	8	unsigned int size;
20	struct pci_dev *ppdev;	9	const __be32 *reg = of_get_property(node, "reg", &size);
21	u32 lspec;
22	__be32 lspec_be;
23	__be32 laddr[3];
24	u8 pin;
25	int rc;
26		10
27	/* Check if we have a device node, if yes, fallback to standard	11	if (!reg \|\| size < 5 * sizeof(__be32))
28	* device tree parsing	12	return 0;
29	*/	13	return ((be32_to_cpup(&reg[0]) >> 8) & 0xff) == devfn;
30	dn = pci_device_to_OF_node(pdev);	14	}
31	if (dn) {
32	rc = of_irq_map_one(dn, 0, out_irq);
33	if (!rc)
34	return rc;
35	}
36
37	/* Ok, we don't, time to have fun. Let's start by building up an
38	* interrupt spec. we assume #interrupt-cells is 1, which is standard
39	* for PCI. If you do different, then don't use that routine.
40	*/
41	rc = pci_read_config_byte(pdev, PCI_INTERRUPT_PIN, &pin);
42	if (rc != 0)
43	return rc;
44	/* No pin, exit */
45	if (pin == 0)
46	return -ENODEV;
47
48	/* Now we walk up the PCI tree */
49	lspec = pin;
50	for (;;) {
51	/* Get the pci_dev of our parent */
52	ppdev = pdev->bus->self;
53
54	/* Ouch, it's a host bridge... */
55	if (ppdev == NULL) {
56	ppnode = pci_bus_to_OF_node(pdev->bus);
57
58	/* No node for host bridge ? give up */
59	if (ppnode == NULL)
60	return -EINVAL;
61	} else {
62	/* We found a P2P bridge, check if it has a node */
63	ppnode = pci_device_to_OF_node(ppdev);
64	}
65
66	/* Ok, we have found a parent with a device-node, hand over to
67	* the OF parsing code.
68	* We build a unit address from the linux device to be used for
69	* resolution. Note that we use the linux bus number which may
70	* not match your firmware bus numbering.
71	* Fortunately, in most cases, interrupt-map-mask doesn't
72	* include the bus number as part of the matching.
73	* You should still be careful about that though if you intend
74	* to rely on this function (you ship a firmware that doesn't
75	* create device nodes for all PCI devices).
76	*/
77	if (ppnode)
78	break;
79		15
80	/* We can only get here if we hit a P2P bridge with no node,	16	struct device_node of_pci_find_child_device(struct device_node parent,
81	* let's do standard swizzling and try again	17	unsigned int devfn)
		18	{
		19	struct device_node node, node2;
		20
		21	for_each_child_of_node(parent, node) {
		22	if (__of_pci_pci_compare(node, devfn))
		23	return node;
		24	/*
		25	* Some OFs create a parent node "multifunc-device" as
		26	* a fake root for all functions of a multi-function
		27	* device we go down them as well.
82	*/	28	*/
83	lspec = pci_swizzle_interrupt_pin(pdev, lspec);	29	if (!strcmp(node->name, "multifunc-device")) {
84	pdev = ppdev;	30	for_each_child_of_node(node, node2) {
		31	if (__of_pci_pci_compare(node2, devfn)) {
		32	of_node_put(node);
		33	return node2;
		34	}
		35	}
		36	}
85	}	37	}
86		38	return NULL;
87	lspec_be = cpu_to_be32(lspec);
88	laddr[0] = cpu_to_be32((pdev->bus->number << 16) \| (pdev->devfn << 8));
89	laddr[1] = laddr[2] = cpu_to_be32(0);
90	return of_irq_map_raw(ppnode, &lspec_be, 1, laddr, out_irq);
91	}	39	}
92	EXPORT_SYMBOL_GPL(of_irq_map_pci);	40	EXPORT_SYMBOL_GPL(of_pci_find_child_device);