xref: /openbmc/linux/drivers/acpi/arm64/iort.c (revision ca481398)
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/iommu.h>
23 #include <linux/kernel.h>
24 #include <linux/list.h>
25 #include <linux/pci.h>
26 #include <linux/platform_device.h>
27 #include <linux/slab.h>
28 
29 #define IORT_TYPE_MASK(type)	(1 << (type))
30 #define IORT_MSI_TYPE		(1 << ACPI_IORT_NODE_ITS_GROUP)
31 #define IORT_IOMMU_TYPE		((1 << ACPI_IORT_NODE_SMMU) |	\
32 				(1 << ACPI_IORT_NODE_SMMU_V3))
33 
34 /* Until ACPICA headers cover IORT rev. C */
35 #ifndef ACPI_IORT_SMMU_V3_CAVIUM_CN99XX
36 #define ACPI_IORT_SMMU_V3_CAVIUM_CN99XX		0x2
37 #endif
38 
39 struct iort_its_msi_chip {
40 	struct list_head	list;
41 	struct fwnode_handle	*fw_node;
42 	u32			translation_id;
43 };
44 
45 struct iort_fwnode {
46 	struct list_head list;
47 	struct acpi_iort_node *iort_node;
48 	struct fwnode_handle *fwnode;
49 };
50 static LIST_HEAD(iort_fwnode_list);
51 static DEFINE_SPINLOCK(iort_fwnode_lock);
52 
53 /**
54  * iort_set_fwnode() - Create iort_fwnode and use it to register
55  *		       iommu data in the iort_fwnode_list
56  *
57  * @node: IORT table node associated with the IOMMU
58  * @fwnode: fwnode associated with the IORT node
59  *
60  * Returns: 0 on success
61  *          <0 on failure
62  */
63 static inline int iort_set_fwnode(struct acpi_iort_node *iort_node,
64 				  struct fwnode_handle *fwnode)
65 {
66 	struct iort_fwnode *np;
67 
68 	np = kzalloc(sizeof(struct iort_fwnode), GFP_ATOMIC);
69 
70 	if (WARN_ON(!np))
71 		return -ENOMEM;
72 
73 	INIT_LIST_HEAD(&np->list);
74 	np->iort_node = iort_node;
75 	np->fwnode = fwnode;
76 
77 	spin_lock(&iort_fwnode_lock);
78 	list_add_tail(&np->list, &iort_fwnode_list);
79 	spin_unlock(&iort_fwnode_lock);
80 
81 	return 0;
82 }
83 
84 /**
85  * iort_get_fwnode() - Retrieve fwnode associated with an IORT node
86  *
87  * @node: IORT table node to be looked-up
88  *
89  * Returns: fwnode_handle pointer on success, NULL on failure
90  */
91 static inline
92 struct fwnode_handle *iort_get_fwnode(struct acpi_iort_node *node)
93 {
94 	struct iort_fwnode *curr;
95 	struct fwnode_handle *fwnode = NULL;
96 
97 	spin_lock(&iort_fwnode_lock);
98 	list_for_each_entry(curr, &iort_fwnode_list, list) {
99 		if (curr->iort_node == node) {
100 			fwnode = curr->fwnode;
101 			break;
102 		}
103 	}
104 	spin_unlock(&iort_fwnode_lock);
105 
106 	return fwnode;
107 }
108 
109 /**
110  * iort_delete_fwnode() - Delete fwnode associated with an IORT node
111  *
112  * @node: IORT table node associated with fwnode to delete
113  */
114 static inline void iort_delete_fwnode(struct acpi_iort_node *node)
115 {
116 	struct iort_fwnode *curr, *tmp;
117 
118 	spin_lock(&iort_fwnode_lock);
119 	list_for_each_entry_safe(curr, tmp, &iort_fwnode_list, list) {
120 		if (curr->iort_node == node) {
121 			list_del(&curr->list);
122 			kfree(curr);
123 			break;
124 		}
125 	}
126 	spin_unlock(&iort_fwnode_lock);
127 }
128 
129 typedef acpi_status (*iort_find_node_callback)
130 	(struct acpi_iort_node *node, void *context);
131 
132 /* Root pointer to the mapped IORT table */
133 static struct acpi_table_header *iort_table;
134 
135 static LIST_HEAD(iort_msi_chip_list);
136 static DEFINE_SPINLOCK(iort_msi_chip_lock);
137 
138 /**
139  * iort_register_domain_token() - register domain token and related ITS ID
140  * to the list from where we can get it back later on.
141  * @trans_id: ITS ID.
142  * @fw_node: Domain token.
143  *
144  * Returns: 0 on success, -ENOMEM if no memory when allocating list element
145  */
146 int iort_register_domain_token(int trans_id, struct fwnode_handle *fw_node)
147 {
148 	struct iort_its_msi_chip *its_msi_chip;
149 
150 	its_msi_chip = kzalloc(sizeof(*its_msi_chip), GFP_KERNEL);
151 	if (!its_msi_chip)
152 		return -ENOMEM;
153 
154 	its_msi_chip->fw_node = fw_node;
155 	its_msi_chip->translation_id = trans_id;
156 
157 	spin_lock(&iort_msi_chip_lock);
158 	list_add(&its_msi_chip->list, &iort_msi_chip_list);
159 	spin_unlock(&iort_msi_chip_lock);
160 
161 	return 0;
162 }
163 
164 /**
165  * iort_deregister_domain_token() - Deregister domain token based on ITS ID
166  * @trans_id: ITS ID.
167  *
168  * Returns: none.
169  */
170 void iort_deregister_domain_token(int trans_id)
171 {
172 	struct iort_its_msi_chip *its_msi_chip, *t;
173 
174 	spin_lock(&iort_msi_chip_lock);
175 	list_for_each_entry_safe(its_msi_chip, t, &iort_msi_chip_list, list) {
176 		if (its_msi_chip->translation_id == trans_id) {
177 			list_del(&its_msi_chip->list);
178 			kfree(its_msi_chip);
179 			break;
180 		}
181 	}
182 	spin_unlock(&iort_msi_chip_lock);
183 }
184 
185 /**
186  * iort_find_domain_token() - Find domain token based on given ITS ID
187  * @trans_id: ITS ID.
188  *
189  * Returns: domain token when find on the list, NULL otherwise
190  */
191 struct fwnode_handle *iort_find_domain_token(int trans_id)
192 {
193 	struct fwnode_handle *fw_node = NULL;
194 	struct iort_its_msi_chip *its_msi_chip;
195 
196 	spin_lock(&iort_msi_chip_lock);
197 	list_for_each_entry(its_msi_chip, &iort_msi_chip_list, list) {
198 		if (its_msi_chip->translation_id == trans_id) {
199 			fw_node = its_msi_chip->fw_node;
200 			break;
201 		}
202 	}
203 	spin_unlock(&iort_msi_chip_lock);
204 
205 	return fw_node;
206 }
207 
208 static struct acpi_iort_node *iort_scan_node(enum acpi_iort_node_type type,
209 					     iort_find_node_callback callback,
210 					     void *context)
211 {
212 	struct acpi_iort_node *iort_node, *iort_end;
213 	struct acpi_table_iort *iort;
214 	int i;
215 
216 	if (!iort_table)
217 		return NULL;
218 
219 	/* Get the first IORT node */
220 	iort = (struct acpi_table_iort *)iort_table;
221 	iort_node = ACPI_ADD_PTR(struct acpi_iort_node, iort,
222 				 iort->node_offset);
223 	iort_end = ACPI_ADD_PTR(struct acpi_iort_node, iort_table,
224 				iort_table->length);
225 
226 	for (i = 0; i < iort->node_count; i++) {
227 		if (WARN_TAINT(iort_node >= iort_end, TAINT_FIRMWARE_WORKAROUND,
228 			       "IORT node pointer overflows, bad table!\n"))
229 			return NULL;
230 
231 		if (iort_node->type == type &&
232 		    ACPI_SUCCESS(callback(iort_node, context)))
233 			return iort_node;
234 
235 		iort_node = ACPI_ADD_PTR(struct acpi_iort_node, iort_node,
236 					 iort_node->length);
237 	}
238 
239 	return NULL;
240 }
241 
242 static acpi_status iort_match_node_callback(struct acpi_iort_node *node,
243 					    void *context)
244 {
245 	struct device *dev = context;
246 	acpi_status status = AE_NOT_FOUND;
247 
248 	if (node->type == ACPI_IORT_NODE_NAMED_COMPONENT) {
249 		struct acpi_buffer buf = { ACPI_ALLOCATE_BUFFER, NULL };
250 		struct acpi_device *adev = to_acpi_device_node(dev->fwnode);
251 		struct acpi_iort_named_component *ncomp;
252 
253 		if (!adev)
254 			goto out;
255 
256 		status = acpi_get_name(adev->handle, ACPI_FULL_PATHNAME, &buf);
257 		if (ACPI_FAILURE(status)) {
258 			dev_warn(dev, "Can't get device full path name\n");
259 			goto out;
260 		}
261 
262 		ncomp = (struct acpi_iort_named_component *)node->node_data;
263 		status = !strcmp(ncomp->device_name, buf.pointer) ?
264 							AE_OK : AE_NOT_FOUND;
265 		acpi_os_free(buf.pointer);
266 	} else if (node->type == ACPI_IORT_NODE_PCI_ROOT_COMPLEX) {
267 		struct acpi_iort_root_complex *pci_rc;
268 		struct pci_bus *bus;
269 
270 		bus = to_pci_bus(dev);
271 		pci_rc = (struct acpi_iort_root_complex *)node->node_data;
272 
273 		/*
274 		 * It is assumed that PCI segment numbers maps one-to-one
275 		 * with root complexes. Each segment number can represent only
276 		 * one root complex.
277 		 */
278 		status = pci_rc->pci_segment_number == pci_domain_nr(bus) ?
279 							AE_OK : AE_NOT_FOUND;
280 	}
281 out:
282 	return status;
283 }
284 
285 static int iort_id_map(struct acpi_iort_id_mapping *map, u8 type, u32 rid_in,
286 		       u32 *rid_out)
287 {
288 	/* Single mapping does not care for input id */
289 	if (map->flags & ACPI_IORT_ID_SINGLE_MAPPING) {
290 		if (type == ACPI_IORT_NODE_NAMED_COMPONENT ||
291 		    type == ACPI_IORT_NODE_PCI_ROOT_COMPLEX) {
292 			*rid_out = map->output_base;
293 			return 0;
294 		}
295 
296 		pr_warn(FW_BUG "[map %p] SINGLE MAPPING flag not allowed for node type %d, skipping ID map\n",
297 			map, type);
298 		return -ENXIO;
299 	}
300 
301 	if (rid_in < map->input_base ||
302 	    (rid_in >= map->input_base + map->id_count))
303 		return -ENXIO;
304 
305 	*rid_out = map->output_base + (rid_in - map->input_base);
306 	return 0;
307 }
308 
309 static
310 struct acpi_iort_node *iort_node_get_id(struct acpi_iort_node *node,
311 					u32 *id_out, int index)
312 {
313 	struct acpi_iort_node *parent;
314 	struct acpi_iort_id_mapping *map;
315 
316 	if (!node->mapping_offset || !node->mapping_count ||
317 				     index >= node->mapping_count)
318 		return NULL;
319 
320 	map = ACPI_ADD_PTR(struct acpi_iort_id_mapping, node,
321 			   node->mapping_offset + index * sizeof(*map));
322 
323 	/* Firmware bug! */
324 	if (!map->output_reference) {
325 		pr_err(FW_BUG "[node %p type %d] ID map has NULL parent reference\n",
326 		       node, node->type);
327 		return NULL;
328 	}
329 
330 	parent = ACPI_ADD_PTR(struct acpi_iort_node, iort_table,
331 			       map->output_reference);
332 
333 	if (map->flags & ACPI_IORT_ID_SINGLE_MAPPING) {
334 		if (node->type == ACPI_IORT_NODE_NAMED_COMPONENT ||
335 		    node->type == ACPI_IORT_NODE_PCI_ROOT_COMPLEX) {
336 			*id_out = map->output_base;
337 			return parent;
338 		}
339 	}
340 
341 	return NULL;
342 }
343 
344 static struct acpi_iort_node *iort_node_map_id(struct acpi_iort_node *node,
345 					       u32 id_in, u32 *id_out,
346 					       u8 type_mask)
347 {
348 	u32 id = id_in;
349 
350 	/* Parse the ID mapping tree to find specified node type */
351 	while (node) {
352 		struct acpi_iort_id_mapping *map;
353 		int i;
354 
355 		if (IORT_TYPE_MASK(node->type) & type_mask) {
356 			if (id_out)
357 				*id_out = id;
358 			return node;
359 		}
360 
361 		if (!node->mapping_offset || !node->mapping_count)
362 			goto fail_map;
363 
364 		map = ACPI_ADD_PTR(struct acpi_iort_id_mapping, node,
365 				   node->mapping_offset);
366 
367 		/* Firmware bug! */
368 		if (!map->output_reference) {
369 			pr_err(FW_BUG "[node %p type %d] ID map has NULL parent reference\n",
370 			       node, node->type);
371 			goto fail_map;
372 		}
373 
374 		/* Do the ID translation */
375 		for (i = 0; i < node->mapping_count; i++, map++) {
376 			if (!iort_id_map(map, node->type, id, &id))
377 				break;
378 		}
379 
380 		if (i == node->mapping_count)
381 			goto fail_map;
382 
383 		node = ACPI_ADD_PTR(struct acpi_iort_node, iort_table,
384 				    map->output_reference);
385 	}
386 
387 fail_map:
388 	/* Map input ID to output ID unchanged on mapping failure */
389 	if (id_out)
390 		*id_out = id_in;
391 
392 	return NULL;
393 }
394 
395 static
396 struct acpi_iort_node *iort_node_map_platform_id(struct acpi_iort_node *node,
397 						 u32 *id_out, u8 type_mask,
398 						 int index)
399 {
400 	struct acpi_iort_node *parent;
401 	u32 id;
402 
403 	/* step 1: retrieve the initial dev id */
404 	parent = iort_node_get_id(node, &id, index);
405 	if (!parent)
406 		return NULL;
407 
408 	/*
409 	 * optional step 2: map the initial dev id if its parent is not
410 	 * the target type we want, map it again for the use cases such
411 	 * as NC (named component) -> SMMU -> ITS. If the type is matched,
412 	 * return the initial dev id and its parent pointer directly.
413 	 */
414 	if (!(IORT_TYPE_MASK(parent->type) & type_mask))
415 		parent = iort_node_map_id(parent, id, id_out, type_mask);
416 	else
417 		if (id_out)
418 			*id_out = id;
419 
420 	return parent;
421 }
422 
423 static struct acpi_iort_node *iort_find_dev_node(struct device *dev)
424 {
425 	struct pci_bus *pbus;
426 
427 	if (!dev_is_pci(dev))
428 		return iort_scan_node(ACPI_IORT_NODE_NAMED_COMPONENT,
429 				      iort_match_node_callback, dev);
430 
431 	/* Find a PCI root bus */
432 	pbus = to_pci_dev(dev)->bus;
433 	while (!pci_is_root_bus(pbus))
434 		pbus = pbus->parent;
435 
436 	return iort_scan_node(ACPI_IORT_NODE_PCI_ROOT_COMPLEX,
437 			      iort_match_node_callback, &pbus->dev);
438 }
439 
440 /**
441  * iort_msi_map_rid() - Map a MSI requester ID for a device
442  * @dev: The device for which the mapping is to be done.
443  * @req_id: The device requester ID.
444  *
445  * Returns: mapped MSI RID on success, input requester ID otherwise
446  */
447 u32 iort_msi_map_rid(struct device *dev, u32 req_id)
448 {
449 	struct acpi_iort_node *node;
450 	u32 dev_id;
451 
452 	node = iort_find_dev_node(dev);
453 	if (!node)
454 		return req_id;
455 
456 	iort_node_map_id(node, req_id, &dev_id, IORT_MSI_TYPE);
457 	return dev_id;
458 }
459 
460 /**
461  * iort_pmsi_get_dev_id() - Get the device id for a device
462  * @dev: The device for which the mapping is to be done.
463  * @dev_id: The device ID found.
464  *
465  * Returns: 0 for successful find a dev id, -ENODEV on error
466  */
467 int iort_pmsi_get_dev_id(struct device *dev, u32 *dev_id)
468 {
469 	int i;
470 	struct acpi_iort_node *node;
471 
472 	node = iort_find_dev_node(dev);
473 	if (!node)
474 		return -ENODEV;
475 
476 	for (i = 0; i < node->mapping_count; i++) {
477 		if (iort_node_map_platform_id(node, dev_id, IORT_MSI_TYPE, i))
478 			return 0;
479 	}
480 
481 	return -ENODEV;
482 }
483 
484 /**
485  * iort_dev_find_its_id() - Find the ITS identifier for a device
486  * @dev: The device.
487  * @req_id: Device's requester ID
488  * @idx: Index of the ITS identifier list.
489  * @its_id: ITS identifier.
490  *
491  * Returns: 0 on success, appropriate error value otherwise
492  */
493 static int iort_dev_find_its_id(struct device *dev, u32 req_id,
494 				unsigned int idx, int *its_id)
495 {
496 	struct acpi_iort_its_group *its;
497 	struct acpi_iort_node *node;
498 
499 	node = iort_find_dev_node(dev);
500 	if (!node)
501 		return -ENXIO;
502 
503 	node = iort_node_map_id(node, req_id, NULL, IORT_MSI_TYPE);
504 	if (!node)
505 		return -ENXIO;
506 
507 	/* Move to ITS specific data */
508 	its = (struct acpi_iort_its_group *)node->node_data;
509 	if (idx > its->its_count) {
510 		dev_err(dev, "requested ITS ID index [%d] is greater than available [%d]\n",
511 			idx, its->its_count);
512 		return -ENXIO;
513 	}
514 
515 	*its_id = its->identifiers[idx];
516 	return 0;
517 }
518 
519 /**
520  * iort_get_device_domain() - Find MSI domain related to a device
521  * @dev: The device.
522  * @req_id: Requester ID for the device.
523  *
524  * Returns: the MSI domain for this device, NULL otherwise
525  */
526 struct irq_domain *iort_get_device_domain(struct device *dev, u32 req_id)
527 {
528 	struct fwnode_handle *handle;
529 	int its_id;
530 
531 	if (iort_dev_find_its_id(dev, req_id, 0, &its_id))
532 		return NULL;
533 
534 	handle = iort_find_domain_token(its_id);
535 	if (!handle)
536 		return NULL;
537 
538 	return irq_find_matching_fwnode(handle, DOMAIN_BUS_PCI_MSI);
539 }
540 
541 /**
542  * iort_get_platform_device_domain() - Find MSI domain related to a
543  * platform device
544  * @dev: the dev pointer associated with the platform device
545  *
546  * Returns: the MSI domain for this device, NULL otherwise
547  */
548 static struct irq_domain *iort_get_platform_device_domain(struct device *dev)
549 {
550 	struct acpi_iort_node *node, *msi_parent;
551 	struct fwnode_handle *iort_fwnode;
552 	struct acpi_iort_its_group *its;
553 	int i;
554 
555 	/* find its associated iort node */
556 	node = iort_scan_node(ACPI_IORT_NODE_NAMED_COMPONENT,
557 			      iort_match_node_callback, dev);
558 	if (!node)
559 		return NULL;
560 
561 	/* then find its msi parent node */
562 	for (i = 0; i < node->mapping_count; i++) {
563 		msi_parent = iort_node_map_platform_id(node, NULL,
564 						       IORT_MSI_TYPE, i);
565 		if (msi_parent)
566 			break;
567 	}
568 
569 	if (!msi_parent)
570 		return NULL;
571 
572 	/* Move to ITS specific data */
573 	its = (struct acpi_iort_its_group *)msi_parent->node_data;
574 
575 	iort_fwnode = iort_find_domain_token(its->identifiers[0]);
576 	if (!iort_fwnode)
577 		return NULL;
578 
579 	return irq_find_matching_fwnode(iort_fwnode, DOMAIN_BUS_PLATFORM_MSI);
580 }
581 
582 void acpi_configure_pmsi_domain(struct device *dev)
583 {
584 	struct irq_domain *msi_domain;
585 
586 	msi_domain = iort_get_platform_device_domain(dev);
587 	if (msi_domain)
588 		dev_set_msi_domain(dev, msi_domain);
589 }
590 
591 static int __maybe_unused __get_pci_rid(struct pci_dev *pdev, u16 alias,
592 					void *data)
593 {
594 	u32 *rid = data;
595 
596 	*rid = alias;
597 	return 0;
598 }
599 
600 static int arm_smmu_iort_xlate(struct device *dev, u32 streamid,
601 			       struct fwnode_handle *fwnode,
602 			       const struct iommu_ops *ops)
603 {
604 	int ret = iommu_fwspec_init(dev, fwnode, ops);
605 
606 	if (!ret)
607 		ret = iommu_fwspec_add_ids(dev, &streamid, 1);
608 
609 	return ret;
610 }
611 
612 static inline bool iort_iommu_driver_enabled(u8 type)
613 {
614 	switch (type) {
615 	case ACPI_IORT_NODE_SMMU_V3:
616 		return IS_BUILTIN(CONFIG_ARM_SMMU_V3);
617 	case ACPI_IORT_NODE_SMMU:
618 		return IS_BUILTIN(CONFIG_ARM_SMMU);
619 	default:
620 		pr_warn("IORT node type %u does not describe an SMMU\n", type);
621 		return false;
622 	}
623 }
624 
625 #ifdef CONFIG_IOMMU_API
626 static inline
627 const struct iommu_ops *iort_fwspec_iommu_ops(struct iommu_fwspec *fwspec)
628 {
629 	return (fwspec && fwspec->ops) ? fwspec->ops : NULL;
630 }
631 
632 static inline
633 int iort_add_device_replay(const struct iommu_ops *ops, struct device *dev)
634 {
635 	int err = 0;
636 
637 	if (ops->add_device && dev->bus && !dev->iommu_group)
638 		err = ops->add_device(dev);
639 
640 	return err;
641 }
642 #else
643 static inline
644 const struct iommu_ops *iort_fwspec_iommu_ops(struct iommu_fwspec *fwspec)
645 { return NULL; }
646 static inline
647 int iort_add_device_replay(const struct iommu_ops *ops, struct device *dev)
648 { return 0; }
649 #endif
650 
651 static int iort_iommu_xlate(struct device *dev, struct acpi_iort_node *node,
652 			    u32 streamid)
653 {
654 	const struct iommu_ops *ops;
655 	struct fwnode_handle *iort_fwnode;
656 
657 	if (!node)
658 		return -ENODEV;
659 
660 	iort_fwnode = iort_get_fwnode(node);
661 	if (!iort_fwnode)
662 		return -ENODEV;
663 
664 	/*
665 	 * If the ops look-up fails, this means that either
666 	 * the SMMU drivers have not been probed yet or that
667 	 * the SMMU drivers are not built in the kernel;
668 	 * Depending on whether the SMMU drivers are built-in
669 	 * in the kernel or not, defer the IOMMU configuration
670 	 * or just abort it.
671 	 */
672 	ops = iommu_ops_from_fwnode(iort_fwnode);
673 	if (!ops)
674 		return iort_iommu_driver_enabled(node->type) ?
675 		       -EPROBE_DEFER : -ENODEV;
676 
677 	return arm_smmu_iort_xlate(dev, streamid, iort_fwnode, ops);
678 }
679 
680 struct iort_pci_alias_info {
681 	struct device *dev;
682 	struct acpi_iort_node *node;
683 };
684 
685 static int iort_pci_iommu_init(struct pci_dev *pdev, u16 alias, void *data)
686 {
687 	struct iort_pci_alias_info *info = data;
688 	struct acpi_iort_node *parent;
689 	u32 streamid;
690 
691 	parent = iort_node_map_id(info->node, alias, &streamid,
692 				  IORT_IOMMU_TYPE);
693 	return iort_iommu_xlate(info->dev, parent, streamid);
694 }
695 
696 static int nc_dma_get_range(struct device *dev, u64 *size)
697 {
698 	struct acpi_iort_node *node;
699 	struct acpi_iort_named_component *ncomp;
700 
701 	node = iort_scan_node(ACPI_IORT_NODE_NAMED_COMPONENT,
702 			      iort_match_node_callback, dev);
703 	if (!node)
704 		return -ENODEV;
705 
706 	ncomp = (struct acpi_iort_named_component *)node->node_data;
707 
708 	*size = ncomp->memory_address_limit >= 64 ? U64_MAX :
709 			1ULL<<ncomp->memory_address_limit;
710 
711 	return 0;
712 }
713 
714 /**
715  * iort_dma_setup() - Set-up device DMA parameters.
716  *
717  * @dev: device to configure
718  * @dma_addr: device DMA address result pointer
719  * @size: DMA range size result pointer
720  */
721 void iort_dma_setup(struct device *dev, u64 *dma_addr, u64 *dma_size)
722 {
723 	u64 mask, dmaaddr = 0, size = 0, offset = 0;
724 	int ret, msb;
725 
726 	/*
727 	 * Set default coherent_dma_mask to 32 bit.  Drivers are expected to
728 	 * setup the correct supported mask.
729 	 */
730 	if (!dev->coherent_dma_mask)
731 		dev->coherent_dma_mask = DMA_BIT_MASK(32);
732 
733 	/*
734 	 * Set it to coherent_dma_mask by default if the architecture
735 	 * code has not set it.
736 	 */
737 	if (!dev->dma_mask)
738 		dev->dma_mask = &dev->coherent_dma_mask;
739 
740 	size = max(dev->coherent_dma_mask, dev->coherent_dma_mask + 1);
741 
742 	if (dev_is_pci(dev))
743 		ret = acpi_dma_get_range(dev, &dmaaddr, &offset, &size);
744 	else
745 		ret = nc_dma_get_range(dev, &size);
746 
747 	if (!ret) {
748 		msb = fls64(dmaaddr + size - 1);
749 		/*
750 		 * Round-up to the power-of-two mask or set
751 		 * the mask to the whole 64-bit address space
752 		 * in case the DMA region covers the full
753 		 * memory window.
754 		 */
755 		mask = msb == 64 ? U64_MAX : (1ULL << msb) - 1;
756 		/*
757 		 * Limit coherent and dma mask based on size
758 		 * retrieved from firmware.
759 		 */
760 		dev->coherent_dma_mask = mask;
761 		*dev->dma_mask = mask;
762 	}
763 
764 	*dma_addr = dmaaddr;
765 	*dma_size = size;
766 
767 	dev->dma_pfn_offset = PFN_DOWN(offset);
768 	dev_dbg(dev, "dma_pfn_offset(%#08llx)\n", offset);
769 }
770 
771 /**
772  * iort_iommu_configure - Set-up IOMMU configuration for a device.
773  *
774  * @dev: device to configure
775  *
776  * Returns: iommu_ops pointer on configuration success
777  *          NULL on configuration failure
778  */
779 const struct iommu_ops *iort_iommu_configure(struct device *dev)
780 {
781 	struct acpi_iort_node *node, *parent;
782 	const struct iommu_ops *ops;
783 	u32 streamid = 0;
784 	int err = -ENODEV;
785 
786 	/*
787 	 * If we already translated the fwspec there
788 	 * is nothing left to do, return the iommu_ops.
789 	 */
790 	ops = iort_fwspec_iommu_ops(dev->iommu_fwspec);
791 	if (ops)
792 		return ops;
793 
794 	if (dev_is_pci(dev)) {
795 		struct pci_bus *bus = to_pci_dev(dev)->bus;
796 		struct iort_pci_alias_info info = { .dev = dev };
797 
798 		node = iort_scan_node(ACPI_IORT_NODE_PCI_ROOT_COMPLEX,
799 				      iort_match_node_callback, &bus->dev);
800 		if (!node)
801 			return NULL;
802 
803 		info.node = node;
804 		err = pci_for_each_dma_alias(to_pci_dev(dev),
805 					     iort_pci_iommu_init, &info);
806 	} else {
807 		int i = 0;
808 
809 		node = iort_scan_node(ACPI_IORT_NODE_NAMED_COMPONENT,
810 				      iort_match_node_callback, dev);
811 		if (!node)
812 			return NULL;
813 
814 		do {
815 			parent = iort_node_map_platform_id(node, &streamid,
816 							   IORT_IOMMU_TYPE,
817 							   i++);
818 
819 			if (parent)
820 				err = iort_iommu_xlate(dev, parent, streamid);
821 		} while (parent && !err);
822 	}
823 
824 	/*
825 	 * If we have reason to believe the IOMMU driver missed the initial
826 	 * add_device callback for dev, replay it to get things in order.
827 	 */
828 	if (!err) {
829 		ops = iort_fwspec_iommu_ops(dev->iommu_fwspec);
830 		err = iort_add_device_replay(ops, dev);
831 	}
832 
833 	/* Ignore all other errors apart from EPROBE_DEFER */
834 	if (err == -EPROBE_DEFER) {
835 		ops = ERR_PTR(err);
836 	} else if (err) {
837 		dev_dbg(dev, "Adding to IOMMU failed: %d\n", err);
838 		ops = NULL;
839 	}
840 
841 	return ops;
842 }
843 
844 static void __init acpi_iort_register_irq(int hwirq, const char *name,
845 					  int trigger,
846 					  struct resource *res)
847 {
848 	int irq = acpi_register_gsi(NULL, hwirq, trigger,
849 				    ACPI_ACTIVE_HIGH);
850 
851 	if (irq <= 0) {
852 		pr_err("could not register gsi hwirq %d name [%s]\n", hwirq,
853 								      name);
854 		return;
855 	}
856 
857 	res->start = irq;
858 	res->end = irq;
859 	res->flags = IORESOURCE_IRQ;
860 	res->name = name;
861 }
862 
863 static int __init arm_smmu_v3_count_resources(struct acpi_iort_node *node)
864 {
865 	struct acpi_iort_smmu_v3 *smmu;
866 	/* Always present mem resource */
867 	int num_res = 1;
868 
869 	/* Retrieve SMMUv3 specific data */
870 	smmu = (struct acpi_iort_smmu_v3 *)node->node_data;
871 
872 	if (smmu->event_gsiv)
873 		num_res++;
874 
875 	if (smmu->pri_gsiv)
876 		num_res++;
877 
878 	if (smmu->gerr_gsiv)
879 		num_res++;
880 
881 	if (smmu->sync_gsiv)
882 		num_res++;
883 
884 	return num_res;
885 }
886 
887 static bool arm_smmu_v3_is_combined_irq(struct acpi_iort_smmu_v3 *smmu)
888 {
889 	/*
890 	 * Cavium ThunderX2 implementation doesn't not support unique
891 	 * irq line. Use single irq line for all the SMMUv3 interrupts.
892 	 */
893 	if (smmu->model != ACPI_IORT_SMMU_V3_CAVIUM_CN99XX)
894 		return false;
895 
896 	/*
897 	 * ThunderX2 doesn't support MSIs from the SMMU, so we're checking
898 	 * SPI numbers here.
899 	 */
900 	return smmu->event_gsiv == smmu->pri_gsiv &&
901 	       smmu->event_gsiv == smmu->gerr_gsiv &&
902 	       smmu->event_gsiv == smmu->sync_gsiv;
903 }
904 
905 static unsigned long arm_smmu_v3_resource_size(struct acpi_iort_smmu_v3 *smmu)
906 {
907 	/*
908 	 * Override the size, for Cavium ThunderX2 implementation
909 	 * which doesn't support the page 1 SMMU register space.
910 	 */
911 	if (smmu->model == ACPI_IORT_SMMU_V3_CAVIUM_CN99XX)
912 		return SZ_64K;
913 
914 	return SZ_128K;
915 }
916 
917 static void __init arm_smmu_v3_init_resources(struct resource *res,
918 					      struct acpi_iort_node *node)
919 {
920 	struct acpi_iort_smmu_v3 *smmu;
921 	int num_res = 0;
922 
923 	/* Retrieve SMMUv3 specific data */
924 	smmu = (struct acpi_iort_smmu_v3 *)node->node_data;
925 
926 	res[num_res].start = smmu->base_address;
927 	res[num_res].end = smmu->base_address +
928 				arm_smmu_v3_resource_size(smmu) - 1;
929 	res[num_res].flags = IORESOURCE_MEM;
930 
931 	num_res++;
932 	if (arm_smmu_v3_is_combined_irq(smmu)) {
933 		if (smmu->event_gsiv)
934 			acpi_iort_register_irq(smmu->event_gsiv, "combined",
935 					       ACPI_EDGE_SENSITIVE,
936 					       &res[num_res++]);
937 	} else {
938 
939 		if (smmu->event_gsiv)
940 			acpi_iort_register_irq(smmu->event_gsiv, "eventq",
941 					       ACPI_EDGE_SENSITIVE,
942 					       &res[num_res++]);
943 
944 		if (smmu->pri_gsiv)
945 			acpi_iort_register_irq(smmu->pri_gsiv, "priq",
946 					       ACPI_EDGE_SENSITIVE,
947 					       &res[num_res++]);
948 
949 		if (smmu->gerr_gsiv)
950 			acpi_iort_register_irq(smmu->gerr_gsiv, "gerror",
951 					       ACPI_EDGE_SENSITIVE,
952 					       &res[num_res++]);
953 
954 		if (smmu->sync_gsiv)
955 			acpi_iort_register_irq(smmu->sync_gsiv, "cmdq-sync",
956 					       ACPI_EDGE_SENSITIVE,
957 					       &res[num_res++]);
958 	}
959 }
960 
961 static bool __init arm_smmu_v3_is_coherent(struct acpi_iort_node *node)
962 {
963 	struct acpi_iort_smmu_v3 *smmu;
964 
965 	/* Retrieve SMMUv3 specific data */
966 	smmu = (struct acpi_iort_smmu_v3 *)node->node_data;
967 
968 	return smmu->flags & ACPI_IORT_SMMU_V3_COHACC_OVERRIDE;
969 }
970 
971 #if defined(CONFIG_ACPI_NUMA) && defined(ACPI_IORT_SMMU_V3_PXM_VALID)
972 /*
973  * set numa proximity domain for smmuv3 device
974  */
975 static void  __init arm_smmu_v3_set_proximity(struct device *dev,
976 					      struct acpi_iort_node *node)
977 {
978 	struct acpi_iort_smmu_v3 *smmu;
979 
980 	smmu = (struct acpi_iort_smmu_v3 *)node->node_data;
981 	if (smmu->flags & ACPI_IORT_SMMU_V3_PXM_VALID) {
982 		set_dev_node(dev, acpi_map_pxm_to_node(smmu->pxm));
983 		pr_info("SMMU-v3[%llx] Mapped to Proximity domain %d\n",
984 			smmu->base_address,
985 			smmu->pxm);
986 	}
987 }
988 #else
989 #define arm_smmu_v3_set_proximity NULL
990 #endif
991 
992 static int __init arm_smmu_count_resources(struct acpi_iort_node *node)
993 {
994 	struct acpi_iort_smmu *smmu;
995 
996 	/* Retrieve SMMU specific data */
997 	smmu = (struct acpi_iort_smmu *)node->node_data;
998 
999 	/*
1000 	 * Only consider the global fault interrupt and ignore the
1001 	 * configuration access interrupt.
1002 	 *
1003 	 * MMIO address and global fault interrupt resources are always
1004 	 * present so add them to the context interrupt count as a static
1005 	 * value.
1006 	 */
1007 	return smmu->context_interrupt_count + 2;
1008 }
1009 
1010 static void __init arm_smmu_init_resources(struct resource *res,
1011 					   struct acpi_iort_node *node)
1012 {
1013 	struct acpi_iort_smmu *smmu;
1014 	int i, hw_irq, trigger, num_res = 0;
1015 	u64 *ctx_irq, *glb_irq;
1016 
1017 	/* Retrieve SMMU specific data */
1018 	smmu = (struct acpi_iort_smmu *)node->node_data;
1019 
1020 	res[num_res].start = smmu->base_address;
1021 	res[num_res].end = smmu->base_address + smmu->span - 1;
1022 	res[num_res].flags = IORESOURCE_MEM;
1023 	num_res++;
1024 
1025 	glb_irq = ACPI_ADD_PTR(u64, node, smmu->global_interrupt_offset);
1026 	/* Global IRQs */
1027 	hw_irq = IORT_IRQ_MASK(glb_irq[0]);
1028 	trigger = IORT_IRQ_TRIGGER_MASK(glb_irq[0]);
1029 
1030 	acpi_iort_register_irq(hw_irq, "arm-smmu-global", trigger,
1031 				     &res[num_res++]);
1032 
1033 	/* Context IRQs */
1034 	ctx_irq = ACPI_ADD_PTR(u64, node, smmu->context_interrupt_offset);
1035 	for (i = 0; i < smmu->context_interrupt_count; i++) {
1036 		hw_irq = IORT_IRQ_MASK(ctx_irq[i]);
1037 		trigger = IORT_IRQ_TRIGGER_MASK(ctx_irq[i]);
1038 
1039 		acpi_iort_register_irq(hw_irq, "arm-smmu-context", trigger,
1040 				       &res[num_res++]);
1041 	}
1042 }
1043 
1044 static bool __init arm_smmu_is_coherent(struct acpi_iort_node *node)
1045 {
1046 	struct acpi_iort_smmu *smmu;
1047 
1048 	/* Retrieve SMMU specific data */
1049 	smmu = (struct acpi_iort_smmu *)node->node_data;
1050 
1051 	return smmu->flags & ACPI_IORT_SMMU_COHERENT_WALK;
1052 }
1053 
1054 struct iort_iommu_config {
1055 	const char *name;
1056 	int (*iommu_init)(struct acpi_iort_node *node);
1057 	bool (*iommu_is_coherent)(struct acpi_iort_node *node);
1058 	int (*iommu_count_resources)(struct acpi_iort_node *node);
1059 	void (*iommu_init_resources)(struct resource *res,
1060 				     struct acpi_iort_node *node);
1061 	void (*iommu_set_proximity)(struct device *dev,
1062 				    struct acpi_iort_node *node);
1063 };
1064 
1065 static const struct iort_iommu_config iort_arm_smmu_v3_cfg __initconst = {
1066 	.name = "arm-smmu-v3",
1067 	.iommu_is_coherent = arm_smmu_v3_is_coherent,
1068 	.iommu_count_resources = arm_smmu_v3_count_resources,
1069 	.iommu_init_resources = arm_smmu_v3_init_resources,
1070 	.iommu_set_proximity = arm_smmu_v3_set_proximity,
1071 };
1072 
1073 static const struct iort_iommu_config iort_arm_smmu_cfg __initconst = {
1074 	.name = "arm-smmu",
1075 	.iommu_is_coherent = arm_smmu_is_coherent,
1076 	.iommu_count_resources = arm_smmu_count_resources,
1077 	.iommu_init_resources = arm_smmu_init_resources
1078 };
1079 
1080 static __init
1081 const struct iort_iommu_config *iort_get_iommu_cfg(struct acpi_iort_node *node)
1082 {
1083 	switch (node->type) {
1084 	case ACPI_IORT_NODE_SMMU_V3:
1085 		return &iort_arm_smmu_v3_cfg;
1086 	case ACPI_IORT_NODE_SMMU:
1087 		return &iort_arm_smmu_cfg;
1088 	default:
1089 		return NULL;
1090 	}
1091 }
1092 
1093 /**
1094  * iort_add_smmu_platform_device() - Allocate a platform device for SMMU
1095  * @node: Pointer to SMMU ACPI IORT node
1096  *
1097  * Returns: 0 on success, <0 failure
1098  */
1099 static int __init iort_add_smmu_platform_device(struct acpi_iort_node *node)
1100 {
1101 	struct fwnode_handle *fwnode;
1102 	struct platform_device *pdev;
1103 	struct resource *r;
1104 	enum dev_dma_attr attr;
1105 	int ret, count;
1106 	const struct iort_iommu_config *ops = iort_get_iommu_cfg(node);
1107 
1108 	if (!ops)
1109 		return -ENODEV;
1110 
1111 	pdev = platform_device_alloc(ops->name, PLATFORM_DEVID_AUTO);
1112 	if (!pdev)
1113 		return -ENOMEM;
1114 
1115 	if (ops->iommu_set_proximity)
1116 		ops->iommu_set_proximity(&pdev->dev, node);
1117 
1118 	count = ops->iommu_count_resources(node);
1119 
1120 	r = kcalloc(count, sizeof(*r), GFP_KERNEL);
1121 	if (!r) {
1122 		ret = -ENOMEM;
1123 		goto dev_put;
1124 	}
1125 
1126 	ops->iommu_init_resources(r, node);
1127 
1128 	ret = platform_device_add_resources(pdev, r, count);
1129 	/*
1130 	 * Resources are duplicated in platform_device_add_resources,
1131 	 * free their allocated memory
1132 	 */
1133 	kfree(r);
1134 
1135 	if (ret)
1136 		goto dev_put;
1137 
1138 	/*
1139 	 * Add a copy of IORT node pointer to platform_data to
1140 	 * be used to retrieve IORT data information.
1141 	 */
1142 	ret = platform_device_add_data(pdev, &node, sizeof(node));
1143 	if (ret)
1144 		goto dev_put;
1145 
1146 	/*
1147 	 * We expect the dma masks to be equivalent for
1148 	 * all SMMUs set-ups
1149 	 */
1150 	pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask;
1151 
1152 	fwnode = iort_get_fwnode(node);
1153 
1154 	if (!fwnode) {
1155 		ret = -ENODEV;
1156 		goto dev_put;
1157 	}
1158 
1159 	pdev->dev.fwnode = fwnode;
1160 
1161 	attr = ops->iommu_is_coherent(node) ?
1162 			     DEV_DMA_COHERENT : DEV_DMA_NON_COHERENT;
1163 
1164 	/* Configure DMA for the page table walker */
1165 	acpi_dma_configure(&pdev->dev, attr);
1166 
1167 	ret = platform_device_add(pdev);
1168 	if (ret)
1169 		goto dma_deconfigure;
1170 
1171 	return 0;
1172 
1173 dma_deconfigure:
1174 	acpi_dma_deconfigure(&pdev->dev);
1175 dev_put:
1176 	platform_device_put(pdev);
1177 
1178 	return ret;
1179 }
1180 
1181 static bool __init iort_enable_acs(struct acpi_iort_node *iort_node)
1182 {
1183 	if (iort_node->type == ACPI_IORT_NODE_PCI_ROOT_COMPLEX) {
1184 		struct acpi_iort_node *parent;
1185 		struct acpi_iort_id_mapping *map;
1186 		int i;
1187 
1188 		map = ACPI_ADD_PTR(struct acpi_iort_id_mapping, iort_node,
1189 				   iort_node->mapping_offset);
1190 
1191 		for (i = 0; i < iort_node->mapping_count; i++, map++) {
1192 			if (!map->output_reference)
1193 				continue;
1194 
1195 			parent = ACPI_ADD_PTR(struct acpi_iort_node,
1196 					iort_table,  map->output_reference);
1197 			/*
1198 			 * If we detect a RC->SMMU mapping, make sure
1199 			 * we enable ACS on the system.
1200 			 */
1201 			if ((parent->type == ACPI_IORT_NODE_SMMU) ||
1202 				(parent->type == ACPI_IORT_NODE_SMMU_V3)) {
1203 				pci_request_acs();
1204 				return true;
1205 			}
1206 		}
1207 	}
1208 
1209 	return false;
1210 }
1211 
1212 static void __init iort_init_platform_devices(void)
1213 {
1214 	struct acpi_iort_node *iort_node, *iort_end;
1215 	struct acpi_table_iort *iort;
1216 	struct fwnode_handle *fwnode;
1217 	int i, ret;
1218 	bool acs_enabled = false;
1219 
1220 	/*
1221 	 * iort_table and iort both point to the start of IORT table, but
1222 	 * have different struct types
1223 	 */
1224 	iort = (struct acpi_table_iort *)iort_table;
1225 
1226 	/* Get the first IORT node */
1227 	iort_node = ACPI_ADD_PTR(struct acpi_iort_node, iort,
1228 				 iort->node_offset);
1229 	iort_end = ACPI_ADD_PTR(struct acpi_iort_node, iort,
1230 				iort_table->length);
1231 
1232 	for (i = 0; i < iort->node_count; i++) {
1233 		if (iort_node >= iort_end) {
1234 			pr_err("iort node pointer overflows, bad table\n");
1235 			return;
1236 		}
1237 
1238 		if (!acs_enabled)
1239 			acs_enabled = iort_enable_acs(iort_node);
1240 
1241 		if ((iort_node->type == ACPI_IORT_NODE_SMMU) ||
1242 			(iort_node->type == ACPI_IORT_NODE_SMMU_V3)) {
1243 
1244 			fwnode = acpi_alloc_fwnode_static();
1245 			if (!fwnode)
1246 				return;
1247 
1248 			iort_set_fwnode(iort_node, fwnode);
1249 
1250 			ret = iort_add_smmu_platform_device(iort_node);
1251 			if (ret) {
1252 				iort_delete_fwnode(iort_node);
1253 				acpi_free_fwnode_static(fwnode);
1254 				return;
1255 			}
1256 		}
1257 
1258 		iort_node = ACPI_ADD_PTR(struct acpi_iort_node, iort_node,
1259 					 iort_node->length);
1260 	}
1261 }
1262 
1263 void __init acpi_iort_init(void)
1264 {
1265 	acpi_status status;
1266 
1267 	status = acpi_get_table(ACPI_SIG_IORT, 0, &iort_table);
1268 	if (ACPI_FAILURE(status)) {
1269 		if (status != AE_NOT_FOUND) {
1270 			const char *msg = acpi_format_exception(status);
1271 
1272 			pr_err("Failed to get table, %s\n", msg);
1273 		}
1274 
1275 		return;
1276 	}
1277 
1278 	iort_init_platform_devices();
1279 }
1280