?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'block-5.11-2021-01-10' of git://git.kernel.dk/linux-block
[linux/fpc-iii.git] / drivers / acpi / arm64 / iort.c
blobd4eac6d7e9fbc5659bc494402212d0d9eedca66e
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (C) 2016, Semihalf
4 * Author: Tomasz Nowicki <tn@semihalf.com>
5 *
6 * This file implements early detection/parsing of I/O mapping
7 * reported to OS through firmware via I/O Remapping Table (IORT)
8 * IORT document number: ARM DEN 0049A
9 */
10
11 #define pr_fmt(fmt) "ACPI: IORT: " fmt
12
13 #include <linux/acpi_iort.h>
14 #include <linux/bitfield.h>
15 #include <linux/iommu.h>
16 #include <linux/kernel.h>
17 #include <linux/list.h>
18 #include <linux/pci.h>
19 #include <linux/platform_device.h>
20 #include <linux/slab.h>
21 #include <linux/dma-map-ops.h>
22
23 #define IORT_TYPE_MASK(type) (1 << (type))
24 #define IORT_MSI_TYPE (1 << ACPI_IORT_NODE_ITS_GROUP)
25 #define IORT_IOMMU_TYPE ((1 << ACPI_IORT_NODE_SMMU) | \
26 (1 << ACPI_IORT_NODE_SMMU_V3))
27
28 struct iort_its_msi_chip {
29 struct list_head list;
30 struct fwnode_handle *fw_node;
31 phys_addr_t base_addr;
32 u32 translation_id;
33 };
34
35 struct iort_fwnode {
36 struct list_head list;
37 struct acpi_iort_node *iort_node;
38 struct fwnode_handle *fwnode;
39 };
40 static LIST_HEAD(iort_fwnode_list);
41 static DEFINE_SPINLOCK(iort_fwnode_lock);
42
43 /**
44 * iort_set_fwnode() - Create iort_fwnode and use it to register
45 * iommu data in the iort_fwnode_list
46 *
47 * @iort_node: IORT table node associated with the IOMMU
48 * @fwnode: fwnode associated with the IORT node
49 *
50 * Returns: 0 on success
51 * <0 on failure
52 */
53 static inline int iort_set_fwnode(struct acpi_iort_node *iort_node,
54 struct fwnode_handle *fwnode)
55 {
56 struct iort_fwnode *np;
57
58 np = kzalloc(sizeof(struct iort_fwnode), GFP_ATOMIC);
59
60 if (WARN_ON(!np))
61 return -ENOMEM;
62
63 INIT_LIST_HEAD(&np->list);
64 np->iort_node = iort_node;
65 np->fwnode = fwnode;
66
67 spin_lock(&iort_fwnode_lock);
68 list_add_tail(&np->list, &iort_fwnode_list);
69 spin_unlock(&iort_fwnode_lock);
70
71 return 0;
72 }
73
74 /**
75 * iort_get_fwnode() - Retrieve fwnode associated with an IORT node
76 *
77 * @node: IORT table node to be looked-up
78 *
79 * Returns: fwnode_handle pointer on success, NULL on failure
80 */
81 static inline struct fwnode_handle *iort_get_fwnode(
82 struct acpi_iort_node *node)
83 {
84 struct iort_fwnode *curr;
85 struct fwnode_handle *fwnode = NULL;
86
87 spin_lock(&iort_fwnode_lock);
88 list_for_each_entry(curr, &iort_fwnode_list, list) {
89 if (curr->iort_node == node) {
90 fwnode = curr->fwnode;
91 break;
92 }
93 }
94 spin_unlock(&iort_fwnode_lock);
95
96 return fwnode;
97 }
98
99 /**
100 * iort_delete_fwnode() - Delete fwnode associated with an IORT node
101 *
102 * @node: IORT table node associated with fwnode to delete
103 */
104 static inline void iort_delete_fwnode(struct acpi_iort_node *node)
105 {
106 struct iort_fwnode *curr, *tmp;
107
108 spin_lock(&iort_fwnode_lock);
109 list_for_each_entry_safe(curr, tmp, &iort_fwnode_list, list) {
110 if (curr->iort_node == node) {
111 list_del(&curr->list);
112 kfree(curr);
113 break;
114 }
115 }
116 spin_unlock(&iort_fwnode_lock);
117 }
118
119 /**
120 * iort_get_iort_node() - Retrieve iort_node associated with an fwnode
121 *
122 * @fwnode: fwnode associated with device to be looked-up
123 *
124 * Returns: iort_node pointer on success, NULL on failure
125 */
126 static inline struct acpi_iort_node *iort_get_iort_node(
127 struct fwnode_handle *fwnode)
128 {
129 struct iort_fwnode *curr;
130 struct acpi_iort_node *iort_node = NULL;
131
132 spin_lock(&iort_fwnode_lock);
133 list_for_each_entry(curr, &iort_fwnode_list, list) {
134 if (curr->fwnode == fwnode) {
135 iort_node = curr->iort_node;
136 break;
137 }
138 }
139 spin_unlock(&iort_fwnode_lock);
140
141 return iort_node;
142 }
143
144 typedef acpi_status (*iort_find_node_callback)
145 (struct acpi_iort_node *node, void *context);
146
147 /* Root pointer to the mapped IORT table */
148 static struct acpi_table_header *iort_table;
149
150 static LIST_HEAD(iort_msi_chip_list);
151 static DEFINE_SPINLOCK(iort_msi_chip_lock);
152
153 /**
154 * iort_register_domain_token() - register domain token along with related
155 * ITS ID and base address to the list from where we can get it back later on.
156 * @trans_id: ITS ID.
157 * @base: ITS base address.
158 * @fw_node: Domain token.
159 *
160 * Returns: 0 on success, -ENOMEM if no memory when allocating list element
161 */
162 int iort_register_domain_token(int trans_id, phys_addr_t base,
163 struct fwnode_handle *fw_node)
164 {
165 struct iort_its_msi_chip *its_msi_chip;
166
167 its_msi_chip = kzalloc(sizeof(*its_msi_chip), GFP_KERNEL);
168 if (!its_msi_chip)
169 return -ENOMEM;
170
171 its_msi_chip->fw_node = fw_node;
172 its_msi_chip->translation_id = trans_id;
173 its_msi_chip->base_addr = base;
174
175 spin_lock(&iort_msi_chip_lock);
176 list_add(&its_msi_chip->list, &iort_msi_chip_list);
177 spin_unlock(&iort_msi_chip_lock);
178
179 return 0;
180 }
181
182 /**
183 * iort_deregister_domain_token() - Deregister domain token based on ITS ID
184 * @trans_id: ITS ID.
185 *
186 * Returns: none.
187 */
188 void iort_deregister_domain_token(int trans_id)
189 {
190 struct iort_its_msi_chip *its_msi_chip, *t;
191
192 spin_lock(&iort_msi_chip_lock);
193 list_for_each_entry_safe(its_msi_chip, t, &iort_msi_chip_list, list) {
194 if (its_msi_chip->translation_id == trans_id) {
195 list_del(&its_msi_chip->list);
196 kfree(its_msi_chip);
197 break;
198 }
199 }
200 spin_unlock(&iort_msi_chip_lock);
201 }
202
203 /**
204 * iort_find_domain_token() - Find domain token based on given ITS ID
205 * @trans_id: ITS ID.
206 *
207 * Returns: domain token when find on the list, NULL otherwise
208 */
209 struct fwnode_handle *iort_find_domain_token(int trans_id)
210 {
211 struct fwnode_handle *fw_node = NULL;
212 struct iort_its_msi_chip *its_msi_chip;
213
214 spin_lock(&iort_msi_chip_lock);
215 list_for_each_entry(its_msi_chip, &iort_msi_chip_list, list) {
216 if (its_msi_chip->translation_id == trans_id) {
217 fw_node = its_msi_chip->fw_node;
218 break;
219 }
220 }
221 spin_unlock(&iort_msi_chip_lock);
222
223 return fw_node;
224 }
225
226 static struct acpi_iort_node *iort_scan_node(enum acpi_iort_node_type type,
227 iort_find_node_callback callback,
228 void *context)
229 {
230 struct acpi_iort_node *iort_node, *iort_end;
231 struct acpi_table_iort *iort;
232 int i;
233
234 if (!iort_table)
235 return NULL;
236
237 /* Get the first IORT node */
238 iort = (struct acpi_table_iort *)iort_table;
239 iort_node = ACPI_ADD_PTR(struct acpi_iort_node, iort,
240 iort->node_offset);
241 iort_end = ACPI_ADD_PTR(struct acpi_iort_node, iort_table,
242 iort_table->length);
243
244 for (i = 0; i < iort->node_count; i++) {
245 if (WARN_TAINT(iort_node >= iort_end, TAINT_FIRMWARE_WORKAROUND,
246 "IORT node pointer overflows, bad table!\n"))
247 return NULL;
248
249 if (iort_node->type == type &&
250 ACPI_SUCCESS(callback(iort_node, context)))
251 return iort_node;
252
253 iort_node = ACPI_ADD_PTR(struct acpi_iort_node, iort_node,
254 iort_node->length);
255 }
256
257 return NULL;
258 }
259
260 static acpi_status iort_match_node_callback(struct acpi_iort_node *node,
261 void *context)
262 {
263 struct device *dev = context;
264 acpi_status status = AE_NOT_FOUND;
265
266 if (node->type == ACPI_IORT_NODE_NAMED_COMPONENT) {
267 struct acpi_buffer buf = { ACPI_ALLOCATE_BUFFER, NULL };
268 struct acpi_device *adev;
269 struct acpi_iort_named_component *ncomp;
270 struct device *nc_dev = dev;
271
272 /*
273 * Walk the device tree to find a device with an
274 * ACPI companion; there is no point in scanning
275 * IORT for a device matching a named component if
276 * the device does not have an ACPI companion to
277 * start with.
278 */
279 do {
280 adev = ACPI_COMPANION(nc_dev);
281 if (adev)
282 break;
283
284 nc_dev = nc_dev->parent;
285 } while (nc_dev);
286
287 if (!adev)
288 goto out;
289
290 status = acpi_get_name(adev->handle, ACPI_FULL_PATHNAME, &buf);
291 if (ACPI_FAILURE(status)) {
292 dev_warn(nc_dev, "Can't get device full path name\n");
293 goto out;
294 }
295
296 ncomp = (struct acpi_iort_named_component *)node->node_data;
297 status = !strcmp(ncomp->device_name, buf.pointer) ?
298 AE_OK : AE_NOT_FOUND;
299 acpi_os_free(buf.pointer);
300 } else if (node->type == ACPI_IORT_NODE_PCI_ROOT_COMPLEX) {
301 struct acpi_iort_root_complex *pci_rc;
302 struct pci_bus *bus;
303
304 bus = to_pci_bus(dev);
305 pci_rc = (struct acpi_iort_root_complex *)node->node_data;
306
307 /*
308 * It is assumed that PCI segment numbers maps one-to-one
309 * with root complexes. Each segment number can represent only
310 * one root complex.
311 */
312 status = pci_rc->pci_segment_number == pci_domain_nr(bus) ?
313 AE_OK : AE_NOT_FOUND;
314 }
315 out:
316 return status;
317 }
318
319 static int iort_id_map(struct acpi_iort_id_mapping *map, u8 type, u32 rid_in,
320 u32 *rid_out, bool check_overlap)
321 {
322 /* Single mapping does not care for input id */
323 if (map->flags & ACPI_IORT_ID_SINGLE_MAPPING) {
324 if (type == ACPI_IORT_NODE_NAMED_COMPONENT ||
325 type == ACPI_IORT_NODE_PCI_ROOT_COMPLEX) {
326 *rid_out = map->output_base;
327 return 0;
328 }
329
330 pr_warn(FW_BUG "[map %p] SINGLE MAPPING flag not allowed for node type %d, skipping ID map\n",
331 map, type);
332 return -ENXIO;
333 }
334
335 if (rid_in < map->input_base ||
336 (rid_in > map->input_base + map->id_count))
337 return -ENXIO;
338
339 if (check_overlap) {
340 /*
341 * We already found a mapping for this input ID at the end of
342 * another region. If it coincides with the start of this
343 * region, we assume the prior match was due to the off-by-1
344 * issue mentioned below, and allow it to be superseded.
345 * Otherwise, things are *really* broken, and we just disregard
346 * duplicate matches entirely to retain compatibility.
347 */
348 pr_err(FW_BUG "[map %p] conflicting mapping for input ID 0x%x\n",
349 map, rid_in);
350 if (rid_in != map->input_base)
351 return -ENXIO;
352
353 pr_err(FW_BUG "applying workaround.\n");
354 }
355
356 *rid_out = map->output_base + (rid_in - map->input_base);
357
358 /*
359 * Due to confusion regarding the meaning of the id_count field (which
360 * carries the number of IDs *minus 1*), we may have to disregard this
361 * match if it is at the end of the range, and overlaps with the start
362 * of another one.
363 */
364 if (map->id_count > 0 && rid_in == map->input_base + map->id_count)
365 return -EAGAIN;
366 return 0;
367 }
368
369 static struct acpi_iort_node *iort_node_get_id(struct acpi_iort_node *node,
370 u32 *id_out, int index)
371 {
372 struct acpi_iort_node *parent;
373 struct acpi_iort_id_mapping *map;
374
375 if (!node->mapping_offset || !node->mapping_count ||
376 index >= node->mapping_count)
377 return NULL;
378
379 map = ACPI_ADD_PTR(struct acpi_iort_id_mapping, node,
380 node->mapping_offset + index * sizeof(*map));
381
382 /* Firmware bug! */
383 if (!map->output_reference) {
384 pr_err(FW_BUG "[node %p type %d] ID map has NULL parent reference\n",
385 node, node->type);
386 return NULL;
387 }
388
389 parent = ACPI_ADD_PTR(struct acpi_iort_node, iort_table,
390 map->output_reference);
391
392 if (map->flags & ACPI_IORT_ID_SINGLE_MAPPING) {
393 if (node->type == ACPI_IORT_NODE_NAMED_COMPONENT ||
394 node->type == ACPI_IORT_NODE_PCI_ROOT_COMPLEX ||
395 node->type == ACPI_IORT_NODE_SMMU_V3 ||
396 node->type == ACPI_IORT_NODE_PMCG) {
397 *id_out = map->output_base;
398 return parent;
399 }
400 }
401
402 return NULL;
403 }
404
405 static int iort_get_id_mapping_index(struct acpi_iort_node *node)
406 {
407 struct acpi_iort_smmu_v3 *smmu;
408 struct acpi_iort_pmcg *pmcg;
409
410 switch (node->type) {
411 case ACPI_IORT_NODE_SMMU_V3:
412 /*
413 * SMMUv3 dev ID mapping index was introduced in revision 1
414 * table, not available in revision 0
415 */
416 if (node->revision < 1)
417 return -EINVAL;
418
419 smmu = (struct acpi_iort_smmu_v3 *)node->node_data;
420 /*
421 * ID mapping index is only ignored if all interrupts are
422 * GSIV based
423 */
424 if (smmu->event_gsiv && smmu->pri_gsiv && smmu->gerr_gsiv
425 && smmu->sync_gsiv)
426 return -EINVAL;
427
428 if (smmu->id_mapping_index >= node->mapping_count) {
429 pr_err(FW_BUG "[node %p type %d] ID mapping index overflows valid mappings\n",
430 node, node->type);
431 return -EINVAL;
432 }
433
434 return smmu->id_mapping_index;
435 case ACPI_IORT_NODE_PMCG:
436 pmcg = (struct acpi_iort_pmcg *)node->node_data;
437 if (pmcg->overflow_gsiv || node->mapping_count == 0)
438 return -EINVAL;
439
440 return 0;
441 default:
442 return -EINVAL;
443 }
444 }
445
446 static struct acpi_iort_node *iort_node_map_id(struct acpi_iort_node *node,
447 u32 id_in, u32 *id_out,
448 u8 type_mask)
449 {
450 u32 id = id_in;
451
452 /* Parse the ID mapping tree to find specified node type */
453 while (node) {
454 struct acpi_iort_id_mapping *map;
455 int i, index, rc = 0;
456 u32 out_ref = 0, map_id = id;
457
458 if (IORT_TYPE_MASK(node->type) & type_mask) {
459 if (id_out)
460 *id_out = id;
461 return node;
462 }
463
464 if (!node->mapping_offset || !node->mapping_count)
465 goto fail_map;
466
467 map = ACPI_ADD_PTR(struct acpi_iort_id_mapping, node,
468 node->mapping_offset);
469
470 /* Firmware bug! */
471 if (!map->output_reference) {
472 pr_err(FW_BUG "[node %p type %d] ID map has NULL parent reference\n",
473 node, node->type);
474 goto fail_map;
475 }
476
477 /*
478 * Get the special ID mapping index (if any) and skip its
479 * associated ID map to prevent erroneous multi-stage
480 * IORT ID translations.
481 */
482 index = iort_get_id_mapping_index(node);
483
484 /* Do the ID translation */
485 for (i = 0; i < node->mapping_count; i++, map++) {
486 /* if it is special mapping index, skip it */
487 if (i == index)
488 continue;
489
490 rc = iort_id_map(map, node->type, map_id, &id, out_ref);
491 if (!rc)
492 break;
493 if (rc == -EAGAIN)
494 out_ref = map->output_reference;
495 }
496
497 if (i == node->mapping_count && !out_ref)
498 goto fail_map;
499
500 node = ACPI_ADD_PTR(struct acpi_iort_node, iort_table,
501 rc ? out_ref : map->output_reference);
502 }
503
504 fail_map:
505 /* Map input ID to output ID unchanged on mapping failure */
506 if (id_out)
507 *id_out = id_in;
508
509 return NULL;
510 }
511
512 static struct acpi_iort_node *iort_node_map_platform_id(
513 struct acpi_iort_node *node, u32 *id_out, u8 type_mask,
514 int index)
515 {
516 struct acpi_iort_node *parent;
517 u32 id;
518
519 /* step 1: retrieve the initial dev id */
520 parent = iort_node_get_id(node, &id, index);
521 if (!parent)
522 return NULL;
523
524 /*
525 * optional step 2: map the initial dev id if its parent is not
526 * the target type we want, map it again for the use cases such
527 * as NC (named component) -> SMMU -> ITS. If the type is matched,
528 * return the initial dev id and its parent pointer directly.
529 */
530 if (!(IORT_TYPE_MASK(parent->type) & type_mask))
531 parent = iort_node_map_id(parent, id, id_out, type_mask);
532 else
533 if (id_out)
534 *id_out = id;
535
536 return parent;
537 }
538
539 static struct acpi_iort_node *iort_find_dev_node(struct device *dev)
540 {
541 struct pci_bus *pbus;
542
543 if (!dev_is_pci(dev)) {
544 struct acpi_iort_node *node;
545 /*
546 * scan iort_fwnode_list to see if it's an iort platform
547 * device (such as SMMU, PMCG),its iort node already cached
548 * and associated with fwnode when iort platform devices
549 * were initialized.
550 */
551 node = iort_get_iort_node(dev->fwnode);
552 if (node)
553 return node;
554 /*
555 * if not, then it should be a platform device defined in
556 * DSDT/SSDT (with Named Component node in IORT)
557 */
558 return iort_scan_node(ACPI_IORT_NODE_NAMED_COMPONENT,
559 iort_match_node_callback, dev);
560 }
561
562 pbus = to_pci_dev(dev)->bus;
563
564 return iort_scan_node(ACPI_IORT_NODE_PCI_ROOT_COMPLEX,
565 iort_match_node_callback, &pbus->dev);
566 }
567
568 /**
569 * iort_msi_map_id() - Map a MSI input ID for a device
570 * @dev: The device for which the mapping is to be done.
571 * @input_id: The device input ID.
572 *
573 * Returns: mapped MSI ID on success, input ID otherwise
574 */
575 u32 iort_msi_map_id(struct device *dev, u32 input_id)
576 {
577 struct acpi_iort_node *node;
578 u32 dev_id;
579
580 node = iort_find_dev_node(dev);
581 if (!node)
582 return input_id;
583
584 iort_node_map_id(node, input_id, &dev_id, IORT_MSI_TYPE);
585 return dev_id;
586 }
587
588 /**
589 * iort_pmsi_get_dev_id() - Get the device id for a device
590 * @dev: The device for which the mapping is to be done.
591 * @dev_id: The device ID found.
592 *
593 * Returns: 0 for successful find a dev id, -ENODEV on error
594 */
595 int iort_pmsi_get_dev_id(struct device *dev, u32 *dev_id)
596 {
597 int i, index;
598 struct acpi_iort_node *node;
599
600 node = iort_find_dev_node(dev);
601 if (!node)
602 return -ENODEV;
603
604 index = iort_get_id_mapping_index(node);
605 /* if there is a valid index, go get the dev_id directly */
606 if (index >= 0) {
607 if (iort_node_get_id(node, dev_id, index))
608 return 0;
609 } else {
610 for (i = 0; i < node->mapping_count; i++) {
611 if (iort_node_map_platform_id(node, dev_id,
612 IORT_MSI_TYPE, i))
613 return 0;
614 }
615 }
616
617 return -ENODEV;
618 }
619
620 static int __maybe_unused iort_find_its_base(u32 its_id, phys_addr_t *base)
621 {
622 struct iort_its_msi_chip *its_msi_chip;
623 int ret = -ENODEV;
624
625 spin_lock(&iort_msi_chip_lock);
626 list_for_each_entry(its_msi_chip, &iort_msi_chip_list, list) {
627 if (its_msi_chip->translation_id == its_id) {
628 *base = its_msi_chip->base_addr;
629 ret = 0;
630 break;
631 }
632 }
633 spin_unlock(&iort_msi_chip_lock);
634
635 return ret;
636 }
637
638 /**
639 * iort_dev_find_its_id() - Find the ITS identifier for a device
640 * @dev: The device.
641 * @id: Device's ID
642 * @idx: Index of the ITS identifier list.
643 * @its_id: ITS identifier.
644 *
645 * Returns: 0 on success, appropriate error value otherwise
646 */
647 static int iort_dev_find_its_id(struct device *dev, u32 id,
648 unsigned int idx, int *its_id)
649 {
650 struct acpi_iort_its_group *its;
651 struct acpi_iort_node *node;
652
653 node = iort_find_dev_node(dev);
654 if (!node)
655 return -ENXIO;
656
657 node = iort_node_map_id(node, id, NULL, IORT_MSI_TYPE);
658 if (!node)
659 return -ENXIO;
660
661 /* Move to ITS specific data */
662 its = (struct acpi_iort_its_group *)node->node_data;
663 if (idx >= its->its_count) {
664 dev_err(dev, "requested ITS ID index [%d] overruns ITS entries [%d]\n",
665 idx, its->its_count);
666 return -ENXIO;
667 }
668
669 *its_id = its->identifiers[idx];
670 return 0;
671 }
672
673 /**
674 * iort_get_device_domain() - Find MSI domain related to a device
675 * @dev: The device.
676 * @id: Requester ID for the device.
677 * @bus_token: irq domain bus token.
678 *
679 * Returns: the MSI domain for this device, NULL otherwise
680 */
681 struct irq_domain *iort_get_device_domain(struct device *dev, u32 id,
682 enum irq_domain_bus_token bus_token)
683 {
684 struct fwnode_handle *handle;
685 int its_id;
686
687 if (iort_dev_find_its_id(dev, id, 0, &its_id))
688 return NULL;
689
690 handle = iort_find_domain_token(its_id);
691 if (!handle)
692 return NULL;
693
694 return irq_find_matching_fwnode(handle, bus_token);
695 }
696
697 static void iort_set_device_domain(struct device *dev,
698 struct acpi_iort_node *node)
699 {
700 struct acpi_iort_its_group *its;
701 struct acpi_iort_node *msi_parent;
702 struct acpi_iort_id_mapping *map;
703 struct fwnode_handle *iort_fwnode;
704 struct irq_domain *domain;
705 int index;
706
707 index = iort_get_id_mapping_index(node);
708 if (index < 0)
709 return;
710
711 map = ACPI_ADD_PTR(struct acpi_iort_id_mapping, node,
712 node->mapping_offset + index * sizeof(*map));
713
714 /* Firmware bug! */
715 if (!map->output_reference ||
716 !(map->flags & ACPI_IORT_ID_SINGLE_MAPPING)) {
717 pr_err(FW_BUG "[node %p type %d] Invalid MSI mapping\n",
718 node, node->type);
719 return;
720 }
721
722 msi_parent = ACPI_ADD_PTR(struct acpi_iort_node, iort_table,
723 map->output_reference);
724
725 if (!msi_parent || msi_parent->type != ACPI_IORT_NODE_ITS_GROUP)
726 return;
727
728 /* Move to ITS specific data */
729 its = (struct acpi_iort_its_group *)msi_parent->node_data;
730
731 iort_fwnode = iort_find_domain_token(its->identifiers[0]);
732 if (!iort_fwnode)
733 return;
734
735 domain = irq_find_matching_fwnode(iort_fwnode, DOMAIN_BUS_PLATFORM_MSI);
736 if (domain)
737 dev_set_msi_domain(dev, domain);
738 }
739
740 /**
741 * iort_get_platform_device_domain() - Find MSI domain related to a
742 * platform device
743 * @dev: the dev pointer associated with the platform device
744 *
745 * Returns: the MSI domain for this device, NULL otherwise
746 */
747 static struct irq_domain *iort_get_platform_device_domain(struct device *dev)
748 {
749 struct acpi_iort_node *node, *msi_parent = NULL;
750 struct fwnode_handle *iort_fwnode;
751 struct acpi_iort_its_group *its;
752 int i;
753
754 /* find its associated iort node */
755 node = iort_scan_node(ACPI_IORT_NODE_NAMED_COMPONENT,
756 iort_match_node_callback, dev);
757 if (!node)
758 return NULL;
759
760 /* then find its msi parent node */
761 for (i = 0; i < node->mapping_count; i++) {
762 msi_parent = iort_node_map_platform_id(node, NULL,
763 IORT_MSI_TYPE, i);
764 if (msi_parent)
765 break;
766 }
767
768 if (!msi_parent)
769 return NULL;
770
771 /* Move to ITS specific data */
772 its = (struct acpi_iort_its_group *)msi_parent->node_data;
773
774 iort_fwnode = iort_find_domain_token(its->identifiers[0]);
775 if (!iort_fwnode)
776 return NULL;
777
778 return irq_find_matching_fwnode(iort_fwnode, DOMAIN_BUS_PLATFORM_MSI);
779 }
780
781 void acpi_configure_pmsi_domain(struct device *dev)
782 {
783 struct irq_domain *msi_domain;
784
785 msi_domain = iort_get_platform_device_domain(dev);
786 if (msi_domain)
787 dev_set_msi_domain(dev, msi_domain);
788 }
789
790 #ifdef CONFIG_IOMMU_API
791 static struct acpi_iort_node *iort_get_msi_resv_iommu(struct device *dev)
792 {
793 struct acpi_iort_node *iommu;
794 struct iommu_fwspec *fwspec = dev_iommu_fwspec_get(dev);
795
796 iommu = iort_get_iort_node(fwspec->iommu_fwnode);
797
798 if (iommu && (iommu->type == ACPI_IORT_NODE_SMMU_V3)) {
799 struct acpi_iort_smmu_v3 *smmu;
800
801 smmu = (struct acpi_iort_smmu_v3 *)iommu->node_data;
802 if (smmu->model == ACPI_IORT_SMMU_V3_HISILICON_HI161X)
803 return iommu;
804 }
805
806 return NULL;
807 }
808
809 static inline const struct iommu_ops *iort_fwspec_iommu_ops(struct device *dev)
810 {
811 struct iommu_fwspec *fwspec = dev_iommu_fwspec_get(dev);
812
813 return (fwspec && fwspec->ops) ? fwspec->ops : NULL;
814 }
815
816 static inline int iort_add_device_replay(struct device *dev)
817 {
818 int err = 0;
819
820 if (dev->bus && !device_iommu_mapped(dev))
821 err = iommu_probe_device(dev);
822
823 return err;
824 }
825
826 /**
827 * iort_iommu_msi_get_resv_regions - Reserved region driver helper
828 * @dev: Device from iommu_get_resv_regions()
829 * @head: Reserved region list from iommu_get_resv_regions()
830 *
831 * Returns: Number of msi reserved regions on success (0 if platform
832 * doesn't require the reservation or no associated msi regions),
833 * appropriate error value otherwise. The ITS interrupt translation
834 * spaces (ITS_base + SZ_64K, SZ_64K) associated with the device
835 * are the msi reserved regions.
836 */
837 int iort_iommu_msi_get_resv_regions(struct device *dev, struct list_head *head)
838 {
839 struct iommu_fwspec *fwspec = dev_iommu_fwspec_get(dev);
840 struct acpi_iort_its_group *its;
841 struct acpi_iort_node *iommu_node, *its_node = NULL;
842 int i, resv = 0;
843
844 iommu_node = iort_get_msi_resv_iommu(dev);
845 if (!iommu_node)
846 return 0;
847
848 /*
849 * Current logic to reserve ITS regions relies on HW topologies
850 * where a given PCI or named component maps its IDs to only one
851 * ITS group; if a PCI or named component can map its IDs to
852 * different ITS groups through IORT mappings this function has
853 * to be reworked to ensure we reserve regions for all ITS groups
854 * a given PCI or named component may map IDs to.
855 */
856
857 for (i = 0; i < fwspec->num_ids; i++) {
858 its_node = iort_node_map_id(iommu_node,
859 fwspec->ids[i],
860 NULL, IORT_MSI_TYPE);
861 if (its_node)
862 break;
863 }
864
865 if (!its_node)
866 return 0;
867
868 /* Move to ITS specific data */
869 its = (struct acpi_iort_its_group *)its_node->node_data;
870
871 for (i = 0; i < its->its_count; i++) {
872 phys_addr_t base;
873
874 if (!iort_find_its_base(its->identifiers[i], &base)) {
875 int prot = IOMMU_WRITE | IOMMU_NOEXEC | IOMMU_MMIO;
876 struct iommu_resv_region *region;
877
878 region = iommu_alloc_resv_region(base + SZ_64K, SZ_64K,
879 prot, IOMMU_RESV_MSI);
880 if (region) {
881 list_add_tail(&region->list, head);
882 resv++;
883 }
884 }
885 }
886
887 return (resv == its->its_count) ? resv : -ENODEV;
888 }
889
890 static inline bool iort_iommu_driver_enabled(u8 type)
891 {
892 switch (type) {
893 case ACPI_IORT_NODE_SMMU_V3:
894 return IS_ENABLED(CONFIG_ARM_SMMU_V3);
895 case ACPI_IORT_NODE_SMMU:
896 return IS_ENABLED(CONFIG_ARM_SMMU);
897 default:
898 pr_warn("IORT node type %u does not describe an SMMU\n", type);
899 return false;
900 }
901 }
902
903 static int arm_smmu_iort_xlate(struct device *dev, u32 streamid,
904 struct fwnode_handle *fwnode,
905 const struct iommu_ops *ops)
906 {
907 int ret = iommu_fwspec_init(dev, fwnode, ops);
908
909 if (!ret)
910 ret = iommu_fwspec_add_ids(dev, &streamid, 1);
911
912 return ret;
913 }
914
915 static bool iort_pci_rc_supports_ats(struct acpi_iort_node *node)
916 {
917 struct acpi_iort_root_complex *pci_rc;
918
919 pci_rc = (struct acpi_iort_root_complex *)node->node_data;
920 return pci_rc->ats_attribute & ACPI_IORT_ATS_SUPPORTED;
921 }
922
923 static int iort_iommu_xlate(struct device *dev, struct acpi_iort_node *node,
924 u32 streamid)
925 {
926 const struct iommu_ops *ops;
927 struct fwnode_handle *iort_fwnode;
928
929 if (!node)
930 return -ENODEV;
931
932 iort_fwnode = iort_get_fwnode(node);
933 if (!iort_fwnode)
934 return -ENODEV;
935
936 /*
937 * If the ops look-up fails, this means that either
938 * the SMMU drivers have not been probed yet or that
939 * the SMMU drivers are not built in the kernel;
940 * Depending on whether the SMMU drivers are built-in
941 * in the kernel or not, defer the IOMMU configuration
942 * or just abort it.
943 */
944 ops = iommu_ops_from_fwnode(iort_fwnode);
945 if (!ops)
946 return iort_iommu_driver_enabled(node->type) ?
947 -EPROBE_DEFER : -ENODEV;
948
949 return arm_smmu_iort_xlate(dev, streamid, iort_fwnode, ops);
950 }
951
952 struct iort_pci_alias_info {
953 struct device *dev;
954 struct acpi_iort_node *node;
955 };
956
957 static int iort_pci_iommu_init(struct pci_dev *pdev, u16 alias, void *data)
958 {
959 struct iort_pci_alias_info *info = data;
960 struct acpi_iort_node *parent;
961 u32 streamid;
962
963 parent = iort_node_map_id(info->node, alias, &streamid,
964 IORT_IOMMU_TYPE);
965 return iort_iommu_xlate(info->dev, parent, streamid);
966 }
967
968 static void iort_named_component_init(struct device *dev,
969 struct acpi_iort_node *node)
970 {
971 struct acpi_iort_named_component *nc;
972 struct iommu_fwspec *fwspec = dev_iommu_fwspec_get(dev);
973
974 if (!fwspec)
975 return;
976
977 nc = (struct acpi_iort_named_component *)node->node_data;
978 fwspec->num_pasid_bits = FIELD_GET(ACPI_IORT_NC_PASID_BITS,
979 nc->node_flags);
980 }
981
982 static int iort_nc_iommu_map(struct device *dev, struct acpi_iort_node *node)
983 {
984 struct acpi_iort_node *parent;
985 int err = -ENODEV, i = 0;
986 u32 streamid = 0;
987
988 do {
989
990 parent = iort_node_map_platform_id(node, &streamid,
991 IORT_IOMMU_TYPE,
992 i++);
993
994 if (parent)
995 err = iort_iommu_xlate(dev, parent, streamid);
996 } while (parent && !err);
997
998 return err;
999 }
1000
1001 static int iort_nc_iommu_map_id(struct device *dev,
1002 struct acpi_iort_node *node,
1003 const u32 *in_id)
1004 {
1005 struct acpi_iort_node *parent;
1006 u32 streamid;
1007
1008 parent = iort_node_map_id(node, *in_id, &streamid, IORT_IOMMU_TYPE);
1009 if (parent)
1010 return iort_iommu_xlate(dev, parent, streamid);
1011
1012 return -ENODEV;
1013 }
1014
1015
1016 /**
1017 * iort_iommu_configure_id - Set-up IOMMU configuration for a device.
1018 *
1019 * @dev: device to configure
1020 * @id_in: optional input id const value pointer
1021 *
1022 * Returns: iommu_ops pointer on configuration success
1023 * NULL on configuration failure
1024 */
1025 const struct iommu_ops *iort_iommu_configure_id(struct device *dev,
1026 const u32 *id_in)
1027 {
1028 struct acpi_iort_node *node;
1029 const struct iommu_ops *ops;
1030 int err = -ENODEV;
1031
1032 /*
1033 * If we already translated the fwspec there
1034 * is nothing left to do, return the iommu_ops.
1035 */
1036 ops = iort_fwspec_iommu_ops(dev);
1037 if (ops)
1038 return ops;
1039
1040 if (dev_is_pci(dev)) {
1041 struct iommu_fwspec *fwspec;
1042 struct pci_bus *bus = to_pci_dev(dev)->bus;
1043 struct iort_pci_alias_info info = { .dev = dev };
1044
1045 node = iort_scan_node(ACPI_IORT_NODE_PCI_ROOT_COMPLEX,
1046 iort_match_node_callback, &bus->dev);
1047 if (!node)
1048 return NULL;
1049
1050 info.node = node;
1051 err = pci_for_each_dma_alias(to_pci_dev(dev),
1052 iort_pci_iommu_init, &info);
1053
1054 fwspec = dev_iommu_fwspec_get(dev);
1055 if (fwspec && iort_pci_rc_supports_ats(node))
1056 fwspec->flags |= IOMMU_FWSPEC_PCI_RC_ATS;
1057 } else {
1058 node = iort_scan_node(ACPI_IORT_NODE_NAMED_COMPONENT,
1059 iort_match_node_callback, dev);
1060 if (!node)
1061 return NULL;
1062
1063 err = id_in ? iort_nc_iommu_map_id(dev, node, id_in) :
1064 iort_nc_iommu_map(dev, node);
1065
1066 if (!err)
1067 iort_named_component_init(dev, node);
1068 }
1069
1070 /*
1071 * If we have reason to believe the IOMMU driver missed the initial
1072 * add_device callback for dev, replay it to get things in order.
1073 */
1074 if (!err) {
1075 ops = iort_fwspec_iommu_ops(dev);
1076 err = iort_add_device_replay(dev);
1077 }
1078
1079 /* Ignore all other errors apart from EPROBE_DEFER */
1080 if (err == -EPROBE_DEFER) {
1081 ops = ERR_PTR(err);
1082 } else if (err) {
1083 dev_dbg(dev, "Adding to IOMMU failed: %d\n", err);
1084 ops = NULL;
1085 }
1086
1087 return ops;
1088 }
1089
1090 #else
1091 int iort_iommu_msi_get_resv_regions(struct device *dev, struct list_head *head)
1092 { return 0; }
1093 const struct iommu_ops *iort_iommu_configure_id(struct device *dev,
1094 const u32 *input_id)
1095 { return NULL; }
1096 #endif
1097
1098 static int nc_dma_get_range(struct device *dev, u64 *size)
1099 {
1100 struct acpi_iort_node *node;
1101 struct acpi_iort_named_component *ncomp;
1102
1103 node = iort_scan_node(ACPI_IORT_NODE_NAMED_COMPONENT,
1104 iort_match_node_callback, dev);
1105 if (!node)
1106 return -ENODEV;
1107
1108 ncomp = (struct acpi_iort_named_component *)node->node_data;
1109
1110 *size = ncomp->memory_address_limit >= 64 ? U64_MAX :
1111 1ULL<<ncomp->memory_address_limit;
1112
1113 return 0;
1114 }
1115
1116 static int rc_dma_get_range(struct device *dev, u64 *size)
1117 {
1118 struct acpi_iort_node *node;
1119 struct acpi_iort_root_complex *rc;
1120 struct pci_bus *pbus = to_pci_dev(dev)->bus;
1121
1122 node = iort_scan_node(ACPI_IORT_NODE_PCI_ROOT_COMPLEX,
1123 iort_match_node_callback, &pbus->dev);
1124 if (!node || node->revision < 1)
1125 return -ENODEV;
1126
1127 rc = (struct acpi_iort_root_complex *)node->node_data;
1128
1129 *size = rc->memory_address_limit >= 64 ? U64_MAX :
1130 1ULL<<rc->memory_address_limit;
1131
1132 return 0;
1133 }
1134
1135 /**
1136 * iort_dma_setup() - Set-up device DMA parameters.
1137 *
1138 * @dev: device to configure
1139 * @dma_addr: device DMA address result pointer
1140 * @dma_size: DMA range size result pointer
1141 */
1142 void iort_dma_setup(struct device *dev, u64 *dma_addr, u64 *dma_size)
1143 {
1144 u64 end, mask, dmaaddr = 0, size = 0, offset = 0;
1145 int ret;
1146
1147 /*
1148 * If @dev is expected to be DMA-capable then the bus code that created
1149 * it should have initialised its dma_mask pointer by this point. For
1150 * now, we'll continue the legacy behaviour of coercing it to the
1151 * coherent mask if not, but we'll no longer do so quietly.
1152 */
1153 if (!dev->dma_mask) {
1154 dev_warn(dev, "DMA mask not set\n");
1155 dev->dma_mask = &dev->coherent_dma_mask;
1156 }
1157
1158 if (dev->coherent_dma_mask)
1159 size = max(dev->coherent_dma_mask, dev->coherent_dma_mask + 1);
1160 else
1161 size = 1ULL << 32;
1162
1163 ret = acpi_dma_get_range(dev, &dmaaddr, &offset, &size);
1164 if (ret == -ENODEV)
1165 ret = dev_is_pci(dev) ? rc_dma_get_range(dev, &size)
1166 : nc_dma_get_range(dev, &size);
1167
1168 if (!ret) {
1169 /*
1170 * Limit coherent and dma mask based on size retrieved from
1171 * firmware.
1172 */
1173 end = dmaaddr + size - 1;
1174 mask = DMA_BIT_MASK(ilog2(end) + 1);
1175 dev->bus_dma_limit = end;
1176 dev->coherent_dma_mask = mask;
1177 *dev->dma_mask = mask;
1178 }
1179
1180 *dma_addr = dmaaddr;
1181 *dma_size = size;
1182
1183 ret = dma_direct_set_offset(dev, dmaaddr + offset, dmaaddr, size);
1184
1185 dev_dbg(dev, "dma_offset(%#08llx)%s\n", offset, ret ? " failed!" : "");
1186 }
1187
1188 static void __init acpi_iort_register_irq(int hwirq, const char *name,
1189 int trigger,
1190 struct resource *res)
1191 {
1192 int irq = acpi_register_gsi(NULL, hwirq, trigger,
1193 ACPI_ACTIVE_HIGH);
1194
1195 if (irq <= 0) {
1196 pr_err("could not register gsi hwirq %d name [%s]\n", hwirq,
1197 name);
1198 return;
1199 }
1200
1201 res->start = irq;
1202 res->end = irq;
1203 res->flags = IORESOURCE_IRQ;
1204 res->name = name;
1205 }
1206
1207 static int __init arm_smmu_v3_count_resources(struct acpi_iort_node *node)
1208 {
1209 struct acpi_iort_smmu_v3 *smmu;
1210 /* Always present mem resource */
1211 int num_res = 1;
1212
1213 /* Retrieve SMMUv3 specific data */
1214 smmu = (struct acpi_iort_smmu_v3 *)node->node_data;
1215
1216 if (smmu->event_gsiv)
1217 num_res++;
1218
1219 if (smmu->pri_gsiv)
1220 num_res++;
1221
1222 if (smmu->gerr_gsiv)
1223 num_res++;
1224
1225 if (smmu->sync_gsiv)
1226 num_res++;
1227
1228 return num_res;
1229 }
1230
1231 static bool arm_smmu_v3_is_combined_irq(struct acpi_iort_smmu_v3 *smmu)
1232 {
1233 /*
1234 * Cavium ThunderX2 implementation doesn't not support unique
1235 * irq line. Use single irq line for all the SMMUv3 interrupts.
1236 */
1237 if (smmu->model != ACPI_IORT_SMMU_V3_CAVIUM_CN99XX)
1238 return false;
1239
1240 /*
1241 * ThunderX2 doesn't support MSIs from the SMMU, so we're checking
1242 * SPI numbers here.
1243 */
1244 return smmu->event_gsiv == smmu->pri_gsiv &&
1245 smmu->event_gsiv == smmu->gerr_gsiv &&
1246 smmu->event_gsiv == smmu->sync_gsiv;
1247 }
1248
1249 static unsigned long arm_smmu_v3_resource_size(struct acpi_iort_smmu_v3 *smmu)
1250 {
1251 /*
1252 * Override the size, for Cavium ThunderX2 implementation
1253 * which doesn't support the page 1 SMMU register space.
1254 */
1255 if (smmu->model == ACPI_IORT_SMMU_V3_CAVIUM_CN99XX)
1256 return SZ_64K;
1257
1258 return SZ_128K;
1259 }
1260
1261 static void __init arm_smmu_v3_init_resources(struct resource *res,
1262 struct acpi_iort_node *node)
1263 {
1264 struct acpi_iort_smmu_v3 *smmu;
1265 int num_res = 0;
1266
1267 /* Retrieve SMMUv3 specific data */
1268 smmu = (struct acpi_iort_smmu_v3 *)node->node_data;
1269
1270 res[num_res].start = smmu->base_address;
1271 res[num_res].end = smmu->base_address +
1272 arm_smmu_v3_resource_size(smmu) - 1;
1273 res[num_res].flags = IORESOURCE_MEM;
1274
1275 num_res++;
1276 if (arm_smmu_v3_is_combined_irq(smmu)) {
1277 if (smmu->event_gsiv)
1278 acpi_iort_register_irq(smmu->event_gsiv, "combined",
1279 ACPI_EDGE_SENSITIVE,
1280 &res[num_res++]);
1281 } else {
1282
1283 if (smmu->event_gsiv)
1284 acpi_iort_register_irq(smmu->event_gsiv, "eventq",
1285 ACPI_EDGE_SENSITIVE,
1286 &res[num_res++]);
1287
1288 if (smmu->pri_gsiv)
1289 acpi_iort_register_irq(smmu->pri_gsiv, "priq",
1290 ACPI_EDGE_SENSITIVE,
1291 &res[num_res++]);
1292
1293 if (smmu->gerr_gsiv)
1294 acpi_iort_register_irq(smmu->gerr_gsiv, "gerror",
1295 ACPI_EDGE_SENSITIVE,
1296 &res[num_res++]);
1297
1298 if (smmu->sync_gsiv)
1299 acpi_iort_register_irq(smmu->sync_gsiv, "cmdq-sync",
1300 ACPI_EDGE_SENSITIVE,
1301 &res[num_res++]);
1302 }
1303 }
1304
1305 static void __init arm_smmu_v3_dma_configure(struct device *dev,
1306 struct acpi_iort_node *node)
1307 {
1308 struct acpi_iort_smmu_v3 *smmu;
1309 enum dev_dma_attr attr;
1310
1311 /* Retrieve SMMUv3 specific data */
1312 smmu = (struct acpi_iort_smmu_v3 *)node->node_data;
1313
1314 attr = (smmu->flags & ACPI_IORT_SMMU_V3_COHACC_OVERRIDE) ?
1315 DEV_DMA_COHERENT : DEV_DMA_NON_COHERENT;
1316
1317 /* We expect the dma masks to be equivalent for all SMMUv3 set-ups */
1318 dev->dma_mask = &dev->coherent_dma_mask;
1319
1320 /* Configure DMA for the page table walker */
1321 acpi_dma_configure(dev, attr);
1322 }
1323
1324 #if defined(CONFIG_ACPI_NUMA)
1325 /*
1326 * set numa proximity domain for smmuv3 device
1327 */
1328 static int __init arm_smmu_v3_set_proximity(struct device *dev,
1329 struct acpi_iort_node *node)
1330 {
1331 struct acpi_iort_smmu_v3 *smmu;
1332
1333 smmu = (struct acpi_iort_smmu_v3 *)node->node_data;
1334 if (smmu->flags & ACPI_IORT_SMMU_V3_PXM_VALID) {
1335 int dev_node = pxm_to_node(smmu->pxm);
1336
1337 if (dev_node != NUMA_NO_NODE && !node_online(dev_node))
1338 return -EINVAL;
1339
1340 set_dev_node(dev, dev_node);
1341 pr_info("SMMU-v3[%llx] Mapped to Proximity domain %d\n",
1342 smmu->base_address,
1343 smmu->pxm);
1344 }
1345 return 0;
1346 }
1347 #else
1348 #define arm_smmu_v3_set_proximity NULL
1349 #endif
1350
1351 static int __init arm_smmu_count_resources(struct acpi_iort_node *node)
1352 {
1353 struct acpi_iort_smmu *smmu;
1354
1355 /* Retrieve SMMU specific data */
1356 smmu = (struct acpi_iort_smmu *)node->node_data;
1357
1358 /*
1359 * Only consider the global fault interrupt and ignore the
1360 * configuration access interrupt.
1361 *
1362 * MMIO address and global fault interrupt resources are always
1363 * present so add them to the context interrupt count as a static
1364 * value.
1365 */
1366 return smmu->context_interrupt_count + 2;
1367 }
1368
1369 static void __init arm_smmu_init_resources(struct resource *res,
1370 struct acpi_iort_node *node)
1371 {
1372 struct acpi_iort_smmu *smmu;
1373 int i, hw_irq, trigger, num_res = 0;
1374 u64 *ctx_irq, *glb_irq;
1375
1376 /* Retrieve SMMU specific data */
1377 smmu = (struct acpi_iort_smmu *)node->node_data;
1378
1379 res[num_res].start = smmu->base_address;
1380 res[num_res].end = smmu->base_address + smmu->span - 1;
1381 res[num_res].flags = IORESOURCE_MEM;
1382 num_res++;
1383
1384 glb_irq = ACPI_ADD_PTR(u64, node, smmu->global_interrupt_offset);
1385 /* Global IRQs */
1386 hw_irq = IORT_IRQ_MASK(glb_irq[0]);
1387 trigger = IORT_IRQ_TRIGGER_MASK(glb_irq[0]);
1388
1389 acpi_iort_register_irq(hw_irq, "arm-smmu-global", trigger,
1390 &res[num_res++]);
1391
1392 /* Context IRQs */
1393 ctx_irq = ACPI_ADD_PTR(u64, node, smmu->context_interrupt_offset);
1394 for (i = 0; i < smmu->context_interrupt_count; i++) {
1395 hw_irq = IORT_IRQ_MASK(ctx_irq[i]);
1396 trigger = IORT_IRQ_TRIGGER_MASK(ctx_irq[i]);
1397
1398 acpi_iort_register_irq(hw_irq, "arm-smmu-context", trigger,
1399 &res[num_res++]);
1400 }
1401 }
1402
1403 static void __init arm_smmu_dma_configure(struct device *dev,
1404 struct acpi_iort_node *node)
1405 {
1406 struct acpi_iort_smmu *smmu;
1407 enum dev_dma_attr attr;
1408
1409 /* Retrieve SMMU specific data */
1410 smmu = (struct acpi_iort_smmu *)node->node_data;
1411
1412 attr = (smmu->flags & ACPI_IORT_SMMU_COHERENT_WALK) ?
1413 DEV_DMA_COHERENT : DEV_DMA_NON_COHERENT;
1414
1415 /* We expect the dma masks to be equivalent for SMMU set-ups */
1416 dev->dma_mask = &dev->coherent_dma_mask;
1417
1418 /* Configure DMA for the page table walker */
1419 acpi_dma_configure(dev, attr);
1420 }
1421
1422 static int __init arm_smmu_v3_pmcg_count_resources(struct acpi_iort_node *node)
1423 {
1424 struct acpi_iort_pmcg *pmcg;
1425
1426 /* Retrieve PMCG specific data */
1427 pmcg = (struct acpi_iort_pmcg *)node->node_data;
1428
1429 /*
1430 * There are always 2 memory resources.
1431 * If the overflow_gsiv is present then add that for a total of 3.
1432 */
1433 return pmcg->overflow_gsiv ? 3 : 2;
1434 }
1435
1436 static void __init arm_smmu_v3_pmcg_init_resources(struct resource *res,
1437 struct acpi_iort_node *node)
1438 {
1439 struct acpi_iort_pmcg *pmcg;
1440
1441 /* Retrieve PMCG specific data */
1442 pmcg = (struct acpi_iort_pmcg *)node->node_data;
1443
1444 res[0].start = pmcg->page0_base_address;
1445 res[0].end = pmcg->page0_base_address + SZ_4K - 1;
1446 res[0].flags = IORESOURCE_MEM;
1447 res[1].start = pmcg->page1_base_address;
1448 res[1].end = pmcg->page1_base_address + SZ_4K - 1;
1449 res[1].flags = IORESOURCE_MEM;
1450
1451 if (pmcg->overflow_gsiv)
1452 acpi_iort_register_irq(pmcg->overflow_gsiv, "overflow",
1453 ACPI_EDGE_SENSITIVE, &res[2]);
1454 }
1455
1456 static struct acpi_platform_list pmcg_plat_info[] __initdata = {
1457 /* HiSilicon Hip08 Platform */
1458 {"HISI ", "HIP08 ", 0, ACPI_SIG_IORT, greater_than_or_equal,
1459 "Erratum #162001800", IORT_SMMU_V3_PMCG_HISI_HIP08},
1460 { }
1461 };
1462
1463 static int __init arm_smmu_v3_pmcg_add_platdata(struct platform_device *pdev)
1464 {
1465 u32 model;
1466 int idx;
1467
1468 idx = acpi_match_platform_list(pmcg_plat_info);
1469 if (idx >= 0)
1470 model = pmcg_plat_info[idx].data;
1471 else
1472 model = IORT_SMMU_V3_PMCG_GENERIC;
1473
1474 return platform_device_add_data(pdev, &model, sizeof(model));
1475 }
1476
1477 struct iort_dev_config {
1478 const char *name;
1479 int (*dev_init)(struct acpi_iort_node *node);
1480 void (*dev_dma_configure)(struct device *dev,
1481 struct acpi_iort_node *node);
1482 int (*dev_count_resources)(struct acpi_iort_node *node);
1483 void (*dev_init_resources)(struct resource *res,
1484 struct acpi_iort_node *node);
1485 int (*dev_set_proximity)(struct device *dev,
1486 struct acpi_iort_node *node);
1487 int (*dev_add_platdata)(struct platform_device *pdev);
1488 };
1489
1490 static const struct iort_dev_config iort_arm_smmu_v3_cfg __initconst = {
1491 .name = "arm-smmu-v3",
1492 .dev_dma_configure = arm_smmu_v3_dma_configure,
1493 .dev_count_resources = arm_smmu_v3_count_resources,
1494 .dev_init_resources = arm_smmu_v3_init_resources,
1495 .dev_set_proximity = arm_smmu_v3_set_proximity,
1496 };
1497
1498 static const struct iort_dev_config iort_arm_smmu_cfg __initconst = {
1499 .name = "arm-smmu",
1500 .dev_dma_configure = arm_smmu_dma_configure,
1501 .dev_count_resources = arm_smmu_count_resources,
1502 .dev_init_resources = arm_smmu_init_resources,
1503 };
1504
1505 static const struct iort_dev_config iort_arm_smmu_v3_pmcg_cfg __initconst = {
1506 .name = "arm-smmu-v3-pmcg",
1507 .dev_count_resources = arm_smmu_v3_pmcg_count_resources,
1508 .dev_init_resources = arm_smmu_v3_pmcg_init_resources,
1509 .dev_add_platdata = arm_smmu_v3_pmcg_add_platdata,
1510 };
1511
1512 static __init const struct iort_dev_config *iort_get_dev_cfg(
1513 struct acpi_iort_node *node)
1514 {
1515 switch (node->type) {
1516 case ACPI_IORT_NODE_SMMU_V3:
1517 return &iort_arm_smmu_v3_cfg;
1518 case ACPI_IORT_NODE_SMMU:
1519 return &iort_arm_smmu_cfg;
1520 case ACPI_IORT_NODE_PMCG:
1521 return &iort_arm_smmu_v3_pmcg_cfg;
1522 default:
1523 return NULL;
1524 }
1525 }
1526
1527 /**
1528 * iort_add_platform_device() - Allocate a platform device for IORT node
1529 * @node: Pointer to device ACPI IORT node
1530 * @ops: Pointer to IORT device config struct
1531 *
1532 * Returns: 0 on success, <0 failure
1533 */
1534 static int __init iort_add_platform_device(struct acpi_iort_node *node,
1535 const struct iort_dev_config *ops)
1536 {
1537 struct fwnode_handle *fwnode;
1538 struct platform_device *pdev;
1539 struct resource *r;
1540 int ret, count;
1541
1542 pdev = platform_device_alloc(ops->name, PLATFORM_DEVID_AUTO);
1543 if (!pdev)
1544 return -ENOMEM;
1545
1546 if (ops->dev_set_proximity) {
1547 ret = ops->dev_set_proximity(&pdev->dev, node);
1548 if (ret)
1549 goto dev_put;
1550 }
1551
1552 count = ops->dev_count_resources(node);
1553
1554 r = kcalloc(count, sizeof(*r), GFP_KERNEL);
1555 if (!r) {
1556 ret = -ENOMEM;
1557 goto dev_put;
1558 }
1559
1560 ops->dev_init_resources(r, node);
1561
1562 ret = platform_device_add_resources(pdev, r, count);
1563 /*
1564 * Resources are duplicated in platform_device_add_resources,
1565 * free their allocated memory
1566 */
1567 kfree(r);
1568
1569 if (ret)
1570 goto dev_put;
1571
1572 /*
1573 * Platform devices based on PMCG nodes uses platform_data to
1574 * pass the hardware model info to the driver. For others, add
1575 * a copy of IORT node pointer to platform_data to be used to
1576 * retrieve IORT data information.
1577 */
1578 if (ops->dev_add_platdata)
1579 ret = ops->dev_add_platdata(pdev);
1580 else
1581 ret = platform_device_add_data(pdev, &node, sizeof(node));
1582
1583 if (ret)
1584 goto dev_put;
1585
1586 fwnode = iort_get_fwnode(node);
1587
1588 if (!fwnode) {
1589 ret = -ENODEV;
1590 goto dev_put;
1591 }
1592
1593 pdev->dev.fwnode = fwnode;
1594
1595 if (ops->dev_dma_configure)
1596 ops->dev_dma_configure(&pdev->dev, node);
1597
1598 iort_set_device_domain(&pdev->dev, node);
1599
1600 ret = platform_device_add(pdev);
1601 if (ret)
1602 goto dma_deconfigure;
1603
1604 return 0;
1605
1606 dma_deconfigure:
1607 arch_teardown_dma_ops(&pdev->dev);
1608 dev_put:
1609 platform_device_put(pdev);
1610
1611 return ret;
1612 }
1613
1614 #ifdef CONFIG_PCI
1615 static void __init iort_enable_acs(struct acpi_iort_node *iort_node)
1616 {
1617 static bool acs_enabled __initdata;
1618
1619 if (acs_enabled)
1620 return;
1621
1622 if (iort_node->type == ACPI_IORT_NODE_PCI_ROOT_COMPLEX) {
1623 struct acpi_iort_node *parent;
1624 struct acpi_iort_id_mapping *map;
1625 int i;
1626
1627 map = ACPI_ADD_PTR(struct acpi_iort_id_mapping, iort_node,
1628 iort_node->mapping_offset);
1629
1630 for (i = 0; i < iort_node->mapping_count; i++, map++) {
1631 if (!map->output_reference)
1632 continue;
1633
1634 parent = ACPI_ADD_PTR(struct acpi_iort_node,
1635 iort_table, map->output_reference);
1636 /*
1637 * If we detect a RC->SMMU mapping, make sure
1638 * we enable ACS on the system.
1639 */
1640 if ((parent->type == ACPI_IORT_NODE_SMMU) ||
1641 (parent->type == ACPI_IORT_NODE_SMMU_V3)) {
1642 pci_request_acs();
1643 acs_enabled = true;
1644 return;
1645 }
1646 }
1647 }
1648 }
1649 #else
1650 static inline void iort_enable_acs(struct acpi_iort_node *iort_node) { }
1651 #endif
1652
1653 static void __init iort_init_platform_devices(void)
1654 {
1655 struct acpi_iort_node *iort_node, *iort_end;
1656 struct acpi_table_iort *iort;
1657 struct fwnode_handle *fwnode;
1658 int i, ret;
1659 const struct iort_dev_config *ops;
1660
1661 /*
1662 * iort_table and iort both point to the start of IORT table, but
1663 * have different struct types
1664 */
1665 iort = (struct acpi_table_iort *)iort_table;
1666
1667 /* Get the first IORT node */
1668 iort_node = ACPI_ADD_PTR(struct acpi_iort_node, iort,
1669 iort->node_offset);
1670 iort_end = ACPI_ADD_PTR(struct acpi_iort_node, iort,
1671 iort_table->length);
1672
1673 for (i = 0; i < iort->node_count; i++) {
1674 if (iort_node >= iort_end) {
1675 pr_err("iort node pointer overflows, bad table\n");
1676 return;
1677 }
1678
1679 iort_enable_acs(iort_node);
1680
1681 ops = iort_get_dev_cfg(iort_node);
1682 if (ops) {
1683 fwnode = acpi_alloc_fwnode_static();
1684 if (!fwnode)
1685 return;
1686
1687 iort_set_fwnode(iort_node, fwnode);
1688
1689 ret = iort_add_platform_device(iort_node, ops);
1690 if (ret) {
1691 iort_delete_fwnode(iort_node);
1692 acpi_free_fwnode_static(fwnode);
1693 return;
1694 }
1695 }
1696
1697 iort_node = ACPI_ADD_PTR(struct acpi_iort_node, iort_node,
1698 iort_node->length);
1699 }
1700 }
1701
1702 void __init acpi_iort_init(void)
1703 {
1704 acpi_status status;
1705
1706 /* iort_table will be used at runtime after the iort init,
1707 * so we don't need to call acpi_put_table() to release
1708 * the IORT table mapping.
1709 */
1710 status = acpi_get_table(ACPI_SIG_IORT, 0, &iort_table);
1711 if (ACPI_FAILURE(status)) {
1712 if (status != AE_NOT_FOUND) {
1713 const char *msg = acpi_format_exception(status);
1714
1715 pr_err("Failed to get table, %s\n", msg);
1716 }
1717
1718 return;
1719 }
1720
1721 iort_init_platform_devices();
1722 }
1723
1724 #ifdef CONFIG_ZONE_DMA
1725 /*
1726 * Extract the highest CPU physical address accessible to all DMA masters in
1727 * the system. PHYS_ADDR_MAX is returned when no constrained device is found.
1728 */
1729 phys_addr_t __init acpi_iort_dma_get_max_cpu_address(void)
1730 {
1731 phys_addr_t limit = PHYS_ADDR_MAX;
1732 struct acpi_iort_node *node, *end;
1733 struct acpi_table_iort *iort;
1734 acpi_status status;
1735 int i;
1736
1737 if (acpi_disabled)
1738 return limit;
1739
1740 status = acpi_get_table(ACPI_SIG_IORT, 0,
1741 (struct acpi_table_header **)&iort);
1742 if (ACPI_FAILURE(status))
1743 return limit;
1744
1745 node = ACPI_ADD_PTR(struct acpi_iort_node, iort, iort->node_offset);
1746 end = ACPI_ADD_PTR(struct acpi_iort_node, iort, iort->header.length);
1747
1748 for (i = 0; i < iort->node_count; i++) {
1749 if (node >= end)
1750 break;
1751
1752 switch (node->type) {
1753 struct acpi_iort_named_component *ncomp;
1754 struct acpi_iort_root_complex *rc;
1755 phys_addr_t local_limit;
1756
1757 case ACPI_IORT_NODE_NAMED_COMPONENT:
1758 ncomp = (struct acpi_iort_named_component *)node->node_data;
1759 local_limit = DMA_BIT_MASK(ncomp->memory_address_limit);
1760 limit = min_not_zero(limit, local_limit);
1761 break;
1762
1763 case ACPI_IORT_NODE_PCI_ROOT_COMPLEX:
1764 if (node->revision < 1)
1765 break;
1766
1767 rc = (struct acpi_iort_root_complex *)node->node_data;
1768 local_limit = DMA_BIT_MASK(rc->memory_address_limit);
1769 limit = min_not_zero(limit, local_limit);
1770 break;
1771 }
1772 node = ACPI_ADD_PTR(struct acpi_iort_node, node, node->length);
1773 }
1774 acpi_put_table(&iort->header);
1775 return limit;
1776 }
1777 #endif
Linux with added FPC-III support