acpi/riscv/rimt.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2024-2025, Ventana Micro Systems Inc
 *	Author: Sunil V L <sunilvl@ventanamicro.com>
 *
 */

#define pr_fmt(fmt)	"ACPI: RIMT: " fmt

#include <linux/acpi.h>
#include <linux/acpi_rimt.h>
#include <linux/iommu.h>
#include <linux/list.h>
#include <linux/pci.h>
#include <linux/platform_device.h>
#include "init.h"

struct rimt_fwnode {
	struct list_head list;
	struct acpi_rimt_node *rimt_node;
	struct fwnode_handle *fwnode;
};

static LIST_HEAD(rimt_fwnode_list);
static DEFINE_SPINLOCK(rimt_fwnode_lock);

#define RIMT_TYPE_MASK(type)	(1 << (type))
#define RIMT_IOMMU_TYPE		BIT(0)

/* Root pointer to the mapped RIMT table */
static struct acpi_table_header *rimt_table;

/**
 * rimt_set_fwnode() - Create rimt_fwnode and use it to register
 *		       iommu data in the rimt_fwnode_list
 *
 * @rimt_node: RIMT table node associated with the IOMMU
 * @fwnode: fwnode associated with the RIMT node
 *
 * Returns: 0 on success
 *          <0 on failure
 */
static int rimt_set_fwnode(struct acpi_rimt_node *rimt_node,
			   struct fwnode_handle *fwnode)
{
	struct rimt_fwnode *np;

	np = kzalloc_obj(*np, GFP_ATOMIC);

	if (WARN_ON(!np))
		return -ENOMEM;

	INIT_LIST_HEAD(&np->list);
	np->rimt_node = rimt_node;
	np->fwnode = fwnode;

	spin_lock(&rimt_fwnode_lock);
	list_add_tail(&np->list, &rimt_fwnode_list);
	spin_unlock(&rimt_fwnode_lock);

	return 0;
}

static acpi_status rimt_match_node_callback(struct acpi_rimt_node *node,
					    void *context)
{
	acpi_status status = AE_NOT_FOUND;
	struct device *dev = context;

	if (node->type == ACPI_RIMT_NODE_TYPE_IOMMU) {
		struct acpi_rimt_iommu *iommu_node = (struct acpi_rimt_iommu *)&node->node_data;

		if (dev_is_pci(dev)) {
			struct pci_dev *pdev;
			u16 bdf;

			pdev = to_pci_dev(dev);
			bdf = PCI_DEVID(pdev->bus->number, pdev->devfn);
			if ((pci_domain_nr(pdev->bus) == iommu_node->pcie_segment_number) &&
			    bdf == iommu_node->pcie_bdf) {
				status = AE_OK;
			} else {
				status = AE_NOT_FOUND;
			}
		} else {
			struct platform_device *pdev = to_platform_device(dev);
			struct resource *res;

			res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
			if (res && res->start == iommu_node->base_address)
				status = AE_OK;
			else
				status = AE_NOT_FOUND;
		}
	} else if (node->type == ACPI_RIMT_NODE_TYPE_PCIE_ROOT_COMPLEX) {
		struct acpi_rimt_pcie_rc *pci_rc;
		struct pci_bus *bus;

		bus = to_pci_bus(dev);
		pci_rc = (struct acpi_rimt_pcie_rc *)node->node_data;

		/*
		 * It is assumed that PCI segment numbers maps one-to-one
		 * with root complexes. Each segment number can represent only
		 * one root complex.
		 */
		status = pci_rc->pcie_segment_number == pci_domain_nr(bus) ?
							AE_OK : AE_NOT_FOUND;
	} else if (node->type == ACPI_RIMT_NODE_TYPE_PLAT_DEVICE) {
		struct acpi_buffer buf = { ACPI_ALLOCATE_BUFFER, NULL };
		struct acpi_rimt_platform_device *ncomp;
		struct device *plat_dev = dev;
		struct acpi_device *adev;

		/*
		 * Walk the device tree to find a device with an
		 * ACPI companion; there is no point in scanning
		 * RIMT for a device matching a platform device if
		 * the device does not have an ACPI companion to
		 * start with.
		 */
		do {
			adev = ACPI_COMPANION(plat_dev);
			if (adev)
				break;

			plat_dev = plat_dev->parent;
		} while (plat_dev);

		if (!adev)
			return status;

		status = acpi_get_name(adev->handle, ACPI_FULL_PATHNAME, &buf);
		if (ACPI_FAILURE(status)) {
			dev_warn(plat_dev, "Can't get device full path name\n");
			return status;
		}

		ncomp = (struct acpi_rimt_platform_device *)node->node_data;
		status = !strcmp(ncomp->device_name, buf.pointer) ?
							AE_OK : AE_NOT_FOUND;
		acpi_os_free(buf.pointer);
	}

	return status;
}

static struct acpi_rimt_node *rimt_scan_node(enum acpi_rimt_node_type type,
					     void *context)
{
	struct acpi_rimt_node *rimt_node, *rimt_end;
	struct acpi_table_rimt *rimt;
	int i;

	if (!rimt_table)
		return NULL;

	/* Get the first RIMT node */
	rimt = (struct acpi_table_rimt *)rimt_table;
	rimt_node = ACPI_ADD_PTR(struct acpi_rimt_node, rimt,
				 rimt->node_offset);
	rimt_end = ACPI_ADD_PTR(struct acpi_rimt_node, rimt_table,
				rimt_table->length);

	for (i = 0; i < rimt->num_nodes; i++) {
		if (WARN_TAINT(rimt_node >= rimt_end, TAINT_FIRMWARE_WORKAROUND,
			       "RIMT node pointer overflows, bad table!\n"))
			return NULL;

		if (rimt_node->type == type &&
		    ACPI_SUCCESS(rimt_match_node_callback(rimt_node, context)))
			return rimt_node;

		rimt_node = ACPI_ADD_PTR(struct acpi_rimt_node, rimt_node,
					 rimt_node->length);
	}

	return NULL;
}

/*
 * RISC-V supports IOMMU as a PCI device or a platform device.
 * When it is a platform device, there should be a namespace device as
 * well along with RIMT. To create the link between RIMT information and
 * the platform device, the IOMMU driver should register itself with the
 * RIMT module. This is true for PCI based IOMMU as well.
 */
int rimt_iommu_register(struct device *dev)
{
	struct fwnode_handle *rimt_fwnode;
	struct acpi_rimt_node *node;

	node = rimt_scan_node(ACPI_RIMT_NODE_TYPE_IOMMU, dev);
	if (!node) {
		pr_err("Could not find IOMMU node in RIMT\n");
		return -ENODEV;
	}

	if (dev_is_pci(dev)) {
		rimt_fwnode = acpi_alloc_fwnode_static();
		if (!rimt_fwnode)
			return -ENOMEM;

		rimt_fwnode->dev = dev;
		if (!dev->fwnode)
			dev->fwnode = rimt_fwnode;

		rimt_set_fwnode(node, rimt_fwnode);
	} else {
		rimt_set_fwnode(node, dev->fwnode);
	}

	return 0;
}

#ifdef CONFIG_IOMMU_API

/**
 * rimt_get_fwnode() - Retrieve fwnode associated with an RIMT node
 *
 * @node: RIMT table node to be looked-up
 *
 * Returns: fwnode_handle pointer on success, NULL on failure
 */
static struct fwnode_handle *rimt_get_fwnode(struct acpi_rimt_node *node)
{
	struct fwnode_handle *fwnode = NULL;
	struct rimt_fwnode *curr;

	spin_lock(&rimt_fwnode_lock);
	list_for_each_entry(curr, &rimt_fwnode_list, list) {
		if (curr->rimt_node == node) {
			fwnode = curr->fwnode;
			break;
		}
	}
	spin_unlock(&rimt_fwnode_lock);

	return fwnode;
}

static bool rimt_pcie_rc_supports_ats(struct acpi_rimt_node *node)
{
	struct acpi_rimt_pcie_rc *pci_rc;

	pci_rc = (struct acpi_rimt_pcie_rc *)node->node_data;
	return pci_rc->flags & ACPI_RIMT_PCIE_ATS_SUPPORTED;
}

static int rimt_iommu_xlate(struct device *dev, struct acpi_rimt_node *node, u32 deviceid)
{
	struct fwnode_handle *rimt_fwnode;

	if (!node)
		return -ENODEV;

	rimt_fwnode = rimt_get_fwnode(node);

	/*
	 * The IOMMU drivers may not be probed yet.
	 * Defer the IOMMU configuration
	 */
	if (!rimt_fwnode)
		return -EPROBE_DEFER;

	/*
	 * EPROBE_DEFER ensures IOMMU is probed before the devices that
	 * depend on them. During shutdown, however, the IOMMU may be removed
	 * first, leading to issues. To avoid this, a device link is added
	 * which enforces the correct removal order.
	 */
	device_link_add(dev, rimt_fwnode->dev, DL_FLAG_AUTOREMOVE_CONSUMER);
	return acpi_iommu_fwspec_init(dev, deviceid, rimt_fwnode);
}

struct rimt_pci_alias_info {
	struct device *dev;
	struct acpi_rimt_node *node;
	const struct iommu_ops *ops;
};

static int rimt_id_map(struct acpi_rimt_id_mapping *map, u8 type, u32 rid_in, u32 *rid_out)
{
	if (rid_in < map->source_id_base ||
	    (rid_in > map->source_id_base + map->num_ids))
		return -ENXIO;

	*rid_out = map->dest_id_base + (rid_in - map->source_id_base);
	return 0;
}

static struct acpi_rimt_node *rimt_node_get_id(struct acpi_rimt_node *node,
					       u32 *id_out, int index)
{
	struct acpi_rimt_platform_device *plat_node;
	u32 id_mapping_offset, num_id_mapping;
	struct acpi_rimt_pcie_rc *pci_node;
	struct acpi_rimt_id_mapping *map;
	struct acpi_rimt_node *parent;

	if (node->type == ACPI_RIMT_NODE_TYPE_PCIE_ROOT_COMPLEX) {
		pci_node = (struct acpi_rimt_pcie_rc *)&node->node_data;
		id_mapping_offset = pci_node->id_mapping_offset;
		num_id_mapping = pci_node->num_id_mappings;
	} else if (node->type == ACPI_RIMT_NODE_TYPE_PLAT_DEVICE) {
		plat_node = (struct acpi_rimt_platform_device *)&node->node_data;
		id_mapping_offset = plat_node->id_mapping_offset;
		num_id_mapping = plat_node->num_id_mappings;
	} else {
		return NULL;
	}

	if (!id_mapping_offset || !num_id_mapping || index >= num_id_mapping)
		return NULL;

	map = ACPI_ADD_PTR(struct acpi_rimt_id_mapping, node,
			   id_mapping_offset + index * sizeof(*map));

	/* Firmware bug! */
	if (!map->dest_offset) {
		pr_err(FW_BUG "[node %p type %d] ID map has NULL parent reference\n",
		       node, node->type);
		return NULL;
	}

	parent = ACPI_ADD_PTR(struct acpi_rimt_node, rimt_table, map->dest_offset);

	if (node->type == ACPI_RIMT_NODE_TYPE_PLAT_DEVICE ||
	    node->type == ACPI_RIMT_NODE_TYPE_PCIE_ROOT_COMPLEX) {
		*id_out = map->dest_id_base;
		return parent;
	}

	return NULL;
}

static struct acpi_rimt_node *rimt_node_map_id(struct acpi_rimt_node *node,
					       u32 id_in, u32 *id_out,
					       u8 type_mask)
{
	struct acpi_rimt_platform_device *plat_node;
	u32 id_mapping_offset, num_id_mapping;
	struct acpi_rimt_pcie_rc *pci_node;
	u32 id = id_in;

	/* Parse the ID mapping tree to find specified node type */
	while (node) {
		struct acpi_rimt_id_mapping *map;
		int i, rc = 0;
		u32 map_id = id;

		if (RIMT_TYPE_MASK(node->type) & type_mask) {
			if (id_out)
				*id_out = id;
			return node;
		}

		if (node->type == ACPI_RIMT_NODE_TYPE_PCIE_ROOT_COMPLEX) {
			pci_node = (struct acpi_rimt_pcie_rc *)&node->node_data;
			id_mapping_offset = pci_node->id_mapping_offset;
			num_id_mapping = pci_node->num_id_mappings;
		} else if (node->type == ACPI_RIMT_NODE_TYPE_PLAT_DEVICE) {
			plat_node = (struct acpi_rimt_platform_device *)&node->node_data;
			id_mapping_offset = plat_node->id_mapping_offset;
			num_id_mapping = plat_node->num_id_mappings;
		} else {
			goto fail_map;
		}

		if (!id_mapping_offset || !num_id_mapping)
			goto fail_map;

		map = ACPI_ADD_PTR(struct acpi_rimt_id_mapping, node,
				   id_mapping_offset);

		/* Firmware bug! */
		if (!map->dest_offset) {
			pr_err(FW_BUG "[node %p type %d] ID map has NULL parent reference\n",
			       node, node->type);
			goto fail_map;
		}

		/* Do the ID translation */
		for (i = 0; i < num_id_mapping; i++, map++) {
			rc = rimt_id_map(map, node->type, map_id, &id);
			if (!rc)
				break;
		}

		if (i == num_id_mapping)
			goto fail_map;

		node = ACPI_ADD_PTR(struct acpi_rimt_node, rimt_table,
				    rc ? 0 : map->dest_offset);
	}

fail_map:
	/* Map input ID to output ID unchanged on mapping failure */
	if (id_out)
		*id_out = id_in;

	return NULL;
}

static struct acpi_rimt_node *rimt_node_map_platform_id(struct acpi_rimt_node *node, u32 *id_out,
							u8 type_mask, int index)
{
	struct acpi_rimt_node *parent;
	u32 id;

	parent = rimt_node_get_id(node, &id, index);
	if (!parent)
		return NULL;

	if (!(RIMT_TYPE_MASK(parent->type) & type_mask))
		parent = rimt_node_map_id(parent, id, id_out, type_mask);
	else
		if (id_out)
			*id_out = id;

	return parent;
}

static int rimt_pci_iommu_init(struct pci_dev *pdev, u16 alias, void *data)
{
	struct rimt_pci_alias_info *info = data;
	struct acpi_rimt_node *parent;
	u32 deviceid;

	parent = rimt_node_map_id(info->node, alias, &deviceid, RIMT_IOMMU_TYPE);
	return rimt_iommu_xlate(info->dev, parent, deviceid);
}

static int rimt_plat_iommu_map(struct device *dev, struct acpi_rimt_node *node)
{
	struct acpi_rimt_node *parent;
	int err = -ENODEV, i = 0;
	u32 deviceid = 0;

	do {
		parent = rimt_node_map_platform_id(node, &deviceid,
						   RIMT_IOMMU_TYPE,
						   i++);

		if (parent)
			err = rimt_iommu_xlate(dev, parent, deviceid);
	} while (parent && !err);

	return err;
}

static int rimt_plat_iommu_map_id(struct device *dev,
				  struct acpi_rimt_node *node,
				  const u32 *in_id)
{
	struct acpi_rimt_node *parent;
	u32 deviceid;

	parent = rimt_node_map_id(node, *in_id, &deviceid, RIMT_IOMMU_TYPE);
	if (parent)
		return rimt_iommu_xlate(dev, parent, deviceid);

	return -ENODEV;
}

/**
 * rimt_iommu_configure_id - Set-up IOMMU configuration for a device.
 *
 * @dev: device to configure
 * @id_in: optional input id const value pointer
 *
 * Returns: 0 on success, <0 on failure
 */
int rimt_iommu_configure_id(struct device *dev, const u32 *id_in)
{
	struct acpi_rimt_node *node;
	int err = -ENODEV;

	if (dev_is_pci(dev)) {
		struct iommu_fwspec *fwspec;
		struct pci_bus *bus = to_pci_dev(dev)->bus;
		struct rimt_pci_alias_info info = { .dev = dev };

		node = rimt_scan_node(ACPI_RIMT_NODE_TYPE_PCIE_ROOT_COMPLEX, &bus->dev);
		if (!node)
			return -ENODEV;

		info.node = node;
		err = pci_for_each_dma_alias(to_pci_dev(dev),
					     rimt_pci_iommu_init, &info);

		fwspec = dev_iommu_fwspec_get(dev);
		if (fwspec && rimt_pcie_rc_supports_ats(node))
			fwspec->flags |= IOMMU_FWSPEC_PCI_RC_ATS;
	} else {
		node = rimt_scan_node(ACPI_RIMT_NODE_TYPE_PLAT_DEVICE, dev);
		if (!node)
			return -ENODEV;

		err = id_in ? rimt_plat_iommu_map_id(dev, node, id_in) :
			      rimt_plat_iommu_map(dev, node);
	}

	return err;
}

#endif

void __init riscv_acpi_rimt_init(void)
{
	acpi_status status;

	/* rimt_table will be used at runtime after the rimt init,
	 * so we don't need to call acpi_put_table() to release
	 * the RIMT table mapping.
	 */
	status = acpi_get_table(ACPI_SIG_RIMT, 0, &rimt_table);
	if (ACPI_FAILURE(status)) {
		if (status != AE_NOT_FOUND) {
			const char *msg = acpi_format_exception(status);

			pr_err("Failed to get table, %s\n", msg);
		}

		return;
	}
}