]>
Commit | Line | Data |
---|---|---|
88ef16d8 TN |
1 | /* |
2 | * Copyright (C) 2016, Semihalf | |
3 | * Author: Tomasz Nowicki <tn@semihalf.com> | |
4 | * | |
5 | * This program is free software; you can redistribute it and/or modify it | |
6 | * under the terms and conditions of the GNU General Public License, | |
7 | * version 2, as published by the Free Software Foundation. | |
8 | * | |
9 | * This program is distributed in the hope it will be useful, but WITHOUT | |
10 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
11 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | |
12 | * more details. | |
13 | * | |
14 | * This file implements early detection/parsing of I/O mapping | |
15 | * reported to OS through firmware via I/O Remapping Table (IORT) | |
16 | * IORT document number: ARM DEN 0049A | |
17 | */ | |
18 | ||
19 | #define pr_fmt(fmt) "ACPI: IORT: " fmt | |
20 | ||
21 | #include <linux/acpi_iort.h> | |
22 | #include <linux/kernel.h> | |
23 | #include <linux/pci.h> | |
24 | ||
4bf2efd2 TN |
25 | struct iort_its_msi_chip { |
26 | struct list_head list; | |
27 | struct fwnode_handle *fw_node; | |
28 | u32 translation_id; | |
29 | }; | |
30 | ||
88ef16d8 TN |
31 | typedef acpi_status (*iort_find_node_callback) |
32 | (struct acpi_iort_node *node, void *context); | |
33 | ||
34 | /* Root pointer to the mapped IORT table */ | |
35 | static struct acpi_table_header *iort_table; | |
36 | ||
37 | static LIST_HEAD(iort_msi_chip_list); | |
38 | static DEFINE_SPINLOCK(iort_msi_chip_lock); | |
39 | ||
4bf2efd2 TN |
40 | /** |
41 | * iort_register_domain_token() - register domain token and related ITS ID | |
42 | * to the list from where we can get it back later on. | |
43 | * @trans_id: ITS ID. | |
44 | * @fw_node: Domain token. | |
45 | * | |
46 | * Returns: 0 on success, -ENOMEM if no memory when allocating list element | |
47 | */ | |
48 | int iort_register_domain_token(int trans_id, struct fwnode_handle *fw_node) | |
49 | { | |
50 | struct iort_its_msi_chip *its_msi_chip; | |
51 | ||
52 | its_msi_chip = kzalloc(sizeof(*its_msi_chip), GFP_KERNEL); | |
53 | if (!its_msi_chip) | |
54 | return -ENOMEM; | |
55 | ||
56 | its_msi_chip->fw_node = fw_node; | |
57 | its_msi_chip->translation_id = trans_id; | |
58 | ||
59 | spin_lock(&iort_msi_chip_lock); | |
60 | list_add(&its_msi_chip->list, &iort_msi_chip_list); | |
61 | spin_unlock(&iort_msi_chip_lock); | |
62 | ||
63 | return 0; | |
64 | } | |
65 | ||
66 | /** | |
67 | * iort_deregister_domain_token() - Deregister domain token based on ITS ID | |
68 | * @trans_id: ITS ID. | |
69 | * | |
70 | * Returns: none. | |
71 | */ | |
72 | void iort_deregister_domain_token(int trans_id) | |
73 | { | |
74 | struct iort_its_msi_chip *its_msi_chip, *t; | |
75 | ||
76 | spin_lock(&iort_msi_chip_lock); | |
77 | list_for_each_entry_safe(its_msi_chip, t, &iort_msi_chip_list, list) { | |
78 | if (its_msi_chip->translation_id == trans_id) { | |
79 | list_del(&its_msi_chip->list); | |
80 | kfree(its_msi_chip); | |
81 | break; | |
82 | } | |
83 | } | |
84 | spin_unlock(&iort_msi_chip_lock); | |
85 | } | |
86 | ||
87 | /** | |
88 | * iort_find_domain_token() - Find domain token based on given ITS ID | |
89 | * @trans_id: ITS ID. | |
90 | * | |
91 | * Returns: domain token when find on the list, NULL otherwise | |
92 | */ | |
93 | struct fwnode_handle *iort_find_domain_token(int trans_id) | |
94 | { | |
95 | struct fwnode_handle *fw_node = NULL; | |
96 | struct iort_its_msi_chip *its_msi_chip; | |
97 | ||
98 | spin_lock(&iort_msi_chip_lock); | |
99 | list_for_each_entry(its_msi_chip, &iort_msi_chip_list, list) { | |
100 | if (its_msi_chip->translation_id == trans_id) { | |
101 | fw_node = its_msi_chip->fw_node; | |
102 | break; | |
103 | } | |
104 | } | |
105 | spin_unlock(&iort_msi_chip_lock); | |
106 | ||
107 | return fw_node; | |
108 | } | |
109 | ||
88ef16d8 TN |
110 | static struct acpi_iort_node *iort_scan_node(enum acpi_iort_node_type type, |
111 | iort_find_node_callback callback, | |
112 | void *context) | |
113 | { | |
114 | struct acpi_iort_node *iort_node, *iort_end; | |
115 | struct acpi_table_iort *iort; | |
116 | int i; | |
117 | ||
118 | if (!iort_table) | |
119 | return NULL; | |
120 | ||
121 | /* Get the first IORT node */ | |
122 | iort = (struct acpi_table_iort *)iort_table; | |
123 | iort_node = ACPI_ADD_PTR(struct acpi_iort_node, iort, | |
124 | iort->node_offset); | |
125 | iort_end = ACPI_ADD_PTR(struct acpi_iort_node, iort_table, | |
126 | iort_table->length); | |
127 | ||
128 | for (i = 0; i < iort->node_count; i++) { | |
129 | if (WARN_TAINT(iort_node >= iort_end, TAINT_FIRMWARE_WORKAROUND, | |
130 | "IORT node pointer overflows, bad table!\n")) | |
131 | return NULL; | |
132 | ||
133 | if (iort_node->type == type && | |
134 | ACPI_SUCCESS(callback(iort_node, context))) | |
135 | return iort_node; | |
136 | ||
137 | iort_node = ACPI_ADD_PTR(struct acpi_iort_node, iort_node, | |
138 | iort_node->length); | |
139 | } | |
140 | ||
141 | return NULL; | |
142 | } | |
143 | ||
144 | static acpi_status iort_match_node_callback(struct acpi_iort_node *node, | |
145 | void *context) | |
146 | { | |
147 | struct device *dev = context; | |
148 | acpi_status status; | |
149 | ||
150 | if (node->type == ACPI_IORT_NODE_NAMED_COMPONENT) { | |
151 | struct acpi_buffer buf = { ACPI_ALLOCATE_BUFFER, NULL }; | |
152 | struct acpi_device *adev = to_acpi_device_node(dev->fwnode); | |
153 | struct acpi_iort_named_component *ncomp; | |
154 | ||
155 | if (!adev) { | |
156 | status = AE_NOT_FOUND; | |
157 | goto out; | |
158 | } | |
159 | ||
160 | status = acpi_get_name(adev->handle, ACPI_FULL_PATHNAME, &buf); | |
161 | if (ACPI_FAILURE(status)) { | |
162 | dev_warn(dev, "Can't get device full path name\n"); | |
163 | goto out; | |
164 | } | |
165 | ||
166 | ncomp = (struct acpi_iort_named_component *)node->node_data; | |
167 | status = !strcmp(ncomp->device_name, buf.pointer) ? | |
168 | AE_OK : AE_NOT_FOUND; | |
169 | acpi_os_free(buf.pointer); | |
170 | } else if (node->type == ACPI_IORT_NODE_PCI_ROOT_COMPLEX) { | |
171 | struct acpi_iort_root_complex *pci_rc; | |
172 | struct pci_bus *bus; | |
173 | ||
174 | bus = to_pci_bus(dev); | |
175 | pci_rc = (struct acpi_iort_root_complex *)node->node_data; | |
176 | ||
177 | /* | |
178 | * It is assumed that PCI segment numbers maps one-to-one | |
179 | * with root complexes. Each segment number can represent only | |
180 | * one root complex. | |
181 | */ | |
182 | status = pci_rc->pci_segment_number == pci_domain_nr(bus) ? | |
183 | AE_OK : AE_NOT_FOUND; | |
184 | } else { | |
185 | status = AE_NOT_FOUND; | |
186 | } | |
187 | out: | |
188 | return status; | |
189 | } | |
190 | ||
191 | static int iort_id_map(struct acpi_iort_id_mapping *map, u8 type, u32 rid_in, | |
192 | u32 *rid_out) | |
193 | { | |
194 | /* Single mapping does not care for input id */ | |
195 | if (map->flags & ACPI_IORT_ID_SINGLE_MAPPING) { | |
196 | if (type == ACPI_IORT_NODE_NAMED_COMPONENT || | |
197 | type == ACPI_IORT_NODE_PCI_ROOT_COMPLEX) { | |
198 | *rid_out = map->output_base; | |
199 | return 0; | |
200 | } | |
201 | ||
202 | pr_warn(FW_BUG "[map %p] SINGLE MAPPING flag not allowed for node type %d, skipping ID map\n", | |
203 | map, type); | |
204 | return -ENXIO; | |
205 | } | |
206 | ||
207 | if (rid_in < map->input_base || | |
208 | (rid_in >= map->input_base + map->id_count)) | |
209 | return -ENXIO; | |
210 | ||
211 | *rid_out = map->output_base + (rid_in - map->input_base); | |
212 | return 0; | |
213 | } | |
214 | ||
215 | static struct acpi_iort_node *iort_node_map_rid(struct acpi_iort_node *node, | |
216 | u32 rid_in, u32 *rid_out, | |
217 | u8 type) | |
218 | { | |
219 | u32 rid = rid_in; | |
220 | ||
221 | /* Parse the ID mapping tree to find specified node type */ | |
222 | while (node) { | |
223 | struct acpi_iort_id_mapping *map; | |
224 | int i; | |
225 | ||
226 | if (node->type == type) { | |
227 | if (rid_out) | |
228 | *rid_out = rid; | |
229 | return node; | |
230 | } | |
231 | ||
232 | if (!node->mapping_offset || !node->mapping_count) | |
233 | goto fail_map; | |
234 | ||
235 | map = ACPI_ADD_PTR(struct acpi_iort_id_mapping, node, | |
236 | node->mapping_offset); | |
237 | ||
238 | /* Firmware bug! */ | |
239 | if (!map->output_reference) { | |
240 | pr_err(FW_BUG "[node %p type %d] ID map has NULL parent reference\n", | |
241 | node, node->type); | |
242 | goto fail_map; | |
243 | } | |
244 | ||
245 | /* Do the RID translation */ | |
246 | for (i = 0; i < node->mapping_count; i++, map++) { | |
247 | if (!iort_id_map(map, node->type, rid, &rid)) | |
248 | break; | |
249 | } | |
250 | ||
251 | if (i == node->mapping_count) | |
252 | goto fail_map; | |
253 | ||
254 | node = ACPI_ADD_PTR(struct acpi_iort_node, iort_table, | |
255 | map->output_reference); | |
256 | } | |
257 | ||
258 | fail_map: | |
259 | /* Map input RID to output RID unchanged on mapping failure*/ | |
260 | if (rid_out) | |
261 | *rid_out = rid_in; | |
262 | ||
263 | return NULL; | |
264 | } | |
265 | ||
266 | static struct acpi_iort_node *iort_find_dev_node(struct device *dev) | |
267 | { | |
268 | struct pci_bus *pbus; | |
269 | ||
270 | if (!dev_is_pci(dev)) | |
271 | return iort_scan_node(ACPI_IORT_NODE_NAMED_COMPONENT, | |
272 | iort_match_node_callback, dev); | |
273 | ||
274 | /* Find a PCI root bus */ | |
275 | pbus = to_pci_dev(dev)->bus; | |
276 | while (!pci_is_root_bus(pbus)) | |
277 | pbus = pbus->parent; | |
278 | ||
279 | return iort_scan_node(ACPI_IORT_NODE_PCI_ROOT_COMPLEX, | |
280 | iort_match_node_callback, &pbus->dev); | |
281 | } | |
282 | ||
4bf2efd2 TN |
283 | /** |
284 | * iort_msi_map_rid() - Map a MSI requester ID for a device | |
285 | * @dev: The device for which the mapping is to be done. | |
286 | * @req_id: The device requester ID. | |
287 | * | |
288 | * Returns: mapped MSI RID on success, input requester ID otherwise | |
289 | */ | |
290 | u32 iort_msi_map_rid(struct device *dev, u32 req_id) | |
291 | { | |
292 | struct acpi_iort_node *node; | |
293 | u32 dev_id; | |
294 | ||
295 | node = iort_find_dev_node(dev); | |
296 | if (!node) | |
297 | return req_id; | |
298 | ||
299 | iort_node_map_rid(node, req_id, &dev_id, ACPI_IORT_NODE_ITS_GROUP); | |
300 | return dev_id; | |
301 | } | |
302 | ||
303 | /** | |
304 | * iort_dev_find_its_id() - Find the ITS identifier for a device | |
305 | * @dev: The device. | |
306 | * @idx: Index of the ITS identifier list. | |
307 | * @its_id: ITS identifier. | |
308 | * | |
309 | * Returns: 0 on success, appropriate error value otherwise | |
310 | */ | |
311 | static int iort_dev_find_its_id(struct device *dev, u32 req_id, | |
312 | unsigned int idx, int *its_id) | |
313 | { | |
314 | struct acpi_iort_its_group *its; | |
315 | struct acpi_iort_node *node; | |
316 | ||
317 | node = iort_find_dev_node(dev); | |
318 | if (!node) | |
319 | return -ENXIO; | |
320 | ||
321 | node = iort_node_map_rid(node, req_id, NULL, ACPI_IORT_NODE_ITS_GROUP); | |
322 | if (!node) | |
323 | return -ENXIO; | |
324 | ||
325 | /* Move to ITS specific data */ | |
326 | its = (struct acpi_iort_its_group *)node->node_data; | |
327 | if (idx > its->its_count) { | |
328 | dev_err(dev, "requested ITS ID index [%d] is greater than available [%d]\n", | |
329 | idx, its->its_count); | |
330 | return -ENXIO; | |
331 | } | |
332 | ||
333 | *its_id = its->identifiers[idx]; | |
334 | return 0; | |
335 | } | |
336 | ||
337 | /** | |
338 | * iort_get_device_domain() - Find MSI domain related to a device | |
339 | * @dev: The device. | |
340 | * @req_id: Requester ID for the device. | |
341 | * | |
342 | * Returns: the MSI domain for this device, NULL otherwise | |
343 | */ | |
344 | struct irq_domain *iort_get_device_domain(struct device *dev, u32 req_id) | |
345 | { | |
346 | struct fwnode_handle *handle; | |
347 | int its_id; | |
348 | ||
349 | if (iort_dev_find_its_id(dev, req_id, 0, &its_id)) | |
350 | return NULL; | |
351 | ||
352 | handle = iort_find_domain_token(its_id); | |
353 | if (!handle) | |
354 | return NULL; | |
355 | ||
356 | return irq_find_matching_fwnode(handle, DOMAIN_BUS_PCI_MSI); | |
357 | } | |
358 | ||
88ef16d8 TN |
359 | void __init acpi_iort_init(void) |
360 | { | |
361 | acpi_status status; | |
362 | ||
363 | status = acpi_get_table(ACPI_SIG_IORT, 0, &iort_table); | |
364 | if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) { | |
365 | const char *msg = acpi_format_exception(status); | |
366 | pr_err("Failed to get table, %s\n", msg); | |
367 | } | |
368 | } |