1 #include <linux/kernel.h>
2 #include <linux/of_pci.h>
3 #include <linux/of_irq.h>
4 #include <linux/export.h>
7 * of_irq_parse_pci - Resolve the interrupt for a PCI device
8 * @pdev: the device whose interrupt is to be resolved
9 * @out_irq: structure of_irq filled by this function
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.
17 int of_irq_parse_pci(const struct pci_dev
*pdev
, struct of_phandle_args
*out_irq
)
19 struct device_node
*dn
, *ppnode
;
20 struct pci_dev
*ppdev
;
25 /* Check if we have a device node, if yes, fallback to standard
28 dn
= pci_device_to_OF_node(pdev
);
30 rc
= of_irq_parse_one(dn
, 0, out_irq
);
35 /* Ok, we don't, time to have fun. Let's start by building up an
36 * interrupt spec. we assume #interrupt-cells is 1, which is standard
37 * for PCI. If you do different, then don't use that routine.
39 rc
= pci_read_config_byte(pdev
, PCI_INTERRUPT_PIN
, &pin
);
46 /* Now we walk up the PCI tree */
48 /* Get the pci_dev of our parent */
49 ppdev
= pdev
->bus
->self
;
51 /* Ouch, it's a host bridge... */
53 ppnode
= pci_bus_to_OF_node(pdev
->bus
);
55 /* No node for host bridge ? give up */
59 /* We found a P2P bridge, check if it has a node */
60 ppnode
= pci_device_to_OF_node(ppdev
);
63 /* Ok, we have found a parent with a device-node, hand over to
64 * the OF parsing code.
65 * We build a unit address from the linux device to be used for
66 * resolution. Note that we use the linux bus number which may
67 * not match your firmware bus numbering.
68 * Fortunately, in most cases, interrupt-map-mask doesn't
69 * include the bus number as part of the matching.
70 * You should still be careful about that though if you intend
71 * to rely on this function (you ship a firmware that doesn't
72 * create device nodes for all PCI devices).
77 /* We can only get here if we hit a P2P bridge with no node,
78 * let's do standard swizzling and try again
80 pin
= pci_swizzle_interrupt_pin(pdev
, pin
);
85 out_irq
->args_count
= 1;
86 out_irq
->args
[0] = pin
;
87 laddr
[0] = cpu_to_be32((pdev
->bus
->number
<< 16) | (pdev
->devfn
<< 8));
88 laddr
[1] = laddr
[2] = cpu_to_be32(0);
89 return of_irq_parse_raw(laddr
, out_irq
);
91 EXPORT_SYMBOL_GPL(of_irq_parse_pci
);
94 * of_irq_parse_and_map_pci() - Decode a PCI irq from the device tree and map to a virq
95 * @dev: The pci device needing an irq
96 * @slot: PCI slot number; passed when used as map_irq callback. Unused
97 * @pin: PCI irq pin number; passed when used as map_irq callback. Unused
99 * @slot and @pin are unused, but included in the function so that this
100 * function can be used directly as the map_irq callback to pci_fixup_irqs().
102 int of_irq_parse_and_map_pci(const struct pci_dev
*dev
, u8 slot
, u8 pin
)
104 struct of_phandle_args oirq
;
107 ret
= of_irq_parse_pci(dev
, &oirq
);
109 dev_err(&dev
->dev
, "of_irq_parse_pci() failed with rc=%d\n", ret
);
110 return 0; /* Proper return code 0 == NO_IRQ */
113 return irq_create_of_mapping(&oirq
);
115 EXPORT_SYMBOL_GPL(of_irq_parse_and_map_pci
);
This page took 0.032281 seconds and 5 git commands to generate.