]>
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); |
12 | if (devfn < 0) | |
98d9f30c | 13 | return 0; |
45ab9702 TR |
14 | |
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 | 91 | |
41e5c0f8 LD |
92 | /** |
93 | * This function will try to obtain the host bridge domain number by | |
94 | * finding a property called "linux,pci-domain" of the given device node. | |
95 | * | |
96 | * @node: device tree node with the domain information | |
97 | * | |
98 | * Returns the associated domain number from DT in the range [0-0xffff], or | |
99 | * a negative value if the required property is not found. | |
100 | */ | |
101 | int of_get_pci_domain_nr(struct device_node *node) | |
102 | { | |
103 | const __be32 *value; | |
104 | int len; | |
105 | u16 domain; | |
106 | ||
107 | value = of_get_property(node, "linux,pci-domain", &len); | |
108 | if (!value || len < sizeof(*value)) | |
109 | return -EINVAL; | |
110 | ||
111 | domain = (u16)be32_to_cpup(value); | |
112 | ||
113 | return domain; | |
114 | } | |
115 | EXPORT_SYMBOL_GPL(of_get_pci_domain_nr); | |
116 | ||
0d5a6db3 TP |
117 | #ifdef CONFIG_PCI_MSI |
118 | ||
119 | static LIST_HEAD(of_pci_msi_chip_list); | |
120 | static DEFINE_MUTEX(of_pci_msi_chip_mutex); | |
121 | ||
122 | int of_pci_msi_chip_add(struct msi_chip *chip) | |
123 | { | |
124 | if (!of_property_read_bool(chip->of_node, "msi-controller")) | |
125 | return -EINVAL; | |
126 | ||
127 | mutex_lock(&of_pci_msi_chip_mutex); | |
128 | list_add(&chip->list, &of_pci_msi_chip_list); | |
129 | mutex_unlock(&of_pci_msi_chip_mutex); | |
130 | ||
131 | return 0; | |
132 | } | |
133 | EXPORT_SYMBOL_GPL(of_pci_msi_chip_add); | |
134 | ||
135 | void of_pci_msi_chip_remove(struct msi_chip *chip) | |
136 | { | |
137 | mutex_lock(&of_pci_msi_chip_mutex); | |
138 | list_del(&chip->list); | |
139 | mutex_unlock(&of_pci_msi_chip_mutex); | |
140 | } | |
141 | EXPORT_SYMBOL_GPL(of_pci_msi_chip_remove); | |
142 | ||
143 | struct msi_chip *of_pci_find_msi_chip_by_node(struct device_node *of_node) | |
144 | { | |
145 | struct msi_chip *c; | |
146 | ||
147 | mutex_lock(&of_pci_msi_chip_mutex); | |
148 | list_for_each_entry(c, &of_pci_msi_chip_list, list) { | |
149 | if (c->of_node == of_node) { | |
150 | mutex_unlock(&of_pci_msi_chip_mutex); | |
151 | return c; | |
152 | } | |
153 | } | |
154 | mutex_unlock(&of_pci_msi_chip_mutex); | |
155 | ||
156 | return NULL; | |
157 | } | |
158 | EXPORT_SYMBOL_GPL(of_pci_find_msi_chip_by_node); | |
159 | ||
160 | #endif /* CONFIG_PCI_MSI */ |