// SPDX-License-Identifier: GPL-2.0-only
#include <linux/acpi.h>
#include <linux/acpi_iovt.h>
#include <linux/pci.h>
#include "init.h"
struct iovt_device_entry {
struct list_head list;
int start_devid, end_devid;
};
struct iovt_fwnode {
struct list_head list;
struct fwnode_handle *fwnode;
int flag;
int nid, segment, devid;
struct list_head ep_list;
};
static bool checksum_valid;
static LIST_HEAD(iovt_fwnode_list);
static DEFINE_SPINLOCK(iovt_fwnode_lock);
static u8 acpi_iovt_checksum(u8 *buffer, u32 len)
{
u8 sum = 0, *end = buffer + len;
while (buffer < end)
sum += *buffer++;
return sum;
}
#ifdef CONFIG_PCI
static void __init iovt_enable_acs(struct acpi_iovt_iommu *iommu)
{
static bool acs_enabled __initdata;
if (acs_enabled)
return;
/* IOMMU V1 only supports PCI device management */
if ((iommu->header.type == ACPI_IOVT_IOMMU_V1) ||
(iommu->flags & (ACPI_IOVT_IOMMU_PCI_DEVICE | ACPI_IOVT_IOMMU_MAGAGE_BY_SEGMENT))) {
pci_request_acs();
acs_enabled = true;
}
}
#else
static inline void iovt_enable_acs(struct acpi_iovt_iommu *iommu) { }
#endif
static int __init iovt_get_pci_iommu_fwnode(struct iovt_fwnode *np, u16 segment, u16 bdf)
{
struct pci_dev *pdev;
struct fwnode_handle *fwnode;
pdev = pci_get_domain_bus_and_slot(segment, PCI_BUS_NUM(bdf), bdf & 0xff);
if (!pdev) {
pr_err("No PCI IOMMU found for segment 0x%x bdf 0x%x\n", segment, bdf);
return -ENODEV;
}
fwnode = dev_fwnode(&pdev->dev);
if (!fwnode) {
/*
* PCI devices aren't necessarily described by ACPI. Create
* a fwnode so the IOMMU subsystem can identify this device.
*/
fwnode = acpi_alloc_fwnode_static();
if (!fwnode) {
pci_dev_put(pdev);
return -ENOMEM;
}
set_primary_fwnode(&pdev->dev, fwnode);
}
np->fwnode = dev_fwnode(&pdev->dev);
if (np->flag & ACPI_IOVT_IOMMU_PXM_VALID)
set_dev_node(&pdev->dev, np->nid);
pci_dev_put(pdev);
return 0;
}
static int __init iovt_validate_entries(struct acpi_iovt_iommu *iommu)
{
int i, done = 1;
struct acpi_iovt_device_entry *ep;
ep = ACPI_ADD_PTR(struct acpi_iovt_device_entry, iommu, iommu->device_entry_offset);
for (i = 0; i < iommu->device_entry_num; i++) {
switch (ep->type) {
case ACPI_IOVT_DEVICE_ENTRY_START:
if (!done)
return -EINVAL;
done = 0;
break;
case ACPI_IOVT_DEVICE_ENTRY_END:
if (done)
return -EINVAL;
done = 1;
break;
case ACPI_IOVT_DEVICE_ENTRY_SINGLE:
default: /* Reserved for future */
if (!done)
return -EINVAL;
done = 1;
break;
}
ep = ACPI_ADD_PTR(struct acpi_iovt_device_entry, ep, ep->length);
}
return done ? 0 : -EINVAL;
}
static int __init iovt_add_iommu(struct acpi_iovt_iommu *iommu)
{
int i, ret;
struct iovt_fwnode *np;
struct iovt_device_entry *entry;
struct acpi_iovt_device_entry *ep;
np = kzalloc_obj(struct iovt_fwnode, GFP_ATOMIC);
if (WARN_ON(!np))
return -ENOMEM;
INIT_LIST_HEAD(&np->list);
np->flag = iommu->flags;
np->segment = iommu->segment;
if (np->flag & ACPI_IOVT_IOMMU_PXM_VALID)
np->nid = pxm_to_node(iommu->proximity_domain);
if (np->flag & ACPI_IOVT_IOMMU_PCI_DEVICE) {
np->devid = iommu->device_id;
ret = iovt_get_pci_iommu_fwnode(np, np->segment, np->devid);
if (ret < 0) {
kfree(np);
return ret;
}
} else {
np->fwnode = acpi_alloc_fwnode_static();
if (!np->fwnode) {
kfree(np);
return -ENOMEM;
}
}
/* All devices in the segment are managed by this IOMMU */
if (np->flag & ACPI_IOVT_IOMMU_MAGAGE_BY_SEGMENT)
goto skip;
if (iovt_validate_entries(iommu) < 0) {
kfree(np);
return -EINVAL;
}
INIT_LIST_HEAD(&np->ep_list);
ep = ACPI_ADD_PTR(struct acpi_iovt_device_entry, iommu, iommu->device_entry_offset);
for (i = 0; i < iommu->device_entry_num; i++) {
switch (ep->type) {
case ACPI_IOVT_DEVICE_ENTRY_START:
entry = kzalloc_obj(struct iovt_device_entry, GFP_ATOMIC);
if (!entry)
return -ENOMEM;
entry->start_devid = ep->device_id;
break;
case ACPI_IOVT_DEVICE_ENTRY_END:
/* START & END are paired */
entry->end_devid = ep->device_id;
list_add_tail(&entry->list, &np->ep_list);
break;
case ACPI_IOVT_DEVICE_ENTRY_SINGLE:
entry = kzalloc_obj(struct iovt_device_entry, GFP_ATOMIC);
if (!entry)
return -ENOMEM;
entry->start_devid = ep->device_id;
entry->end_devid = ep->device_id;
list_add_tail(&entry->list, &np->ep_list);
break;
default:
break;
}
ep = ACPI_ADD_PTR(struct acpi_iovt_device_entry, ep, ep->length);
}
skip:
spin_lock(&iovt_fwnode_lock);
list_add_tail(&np->list, &iovt_fwnode_list);
spin_unlock(&iovt_fwnode_lock);
return 0;
}
static void __init iovt_init_devices(struct acpi_table_header *header)
{
int i;
struct acpi_table_iovt *iovt;
struct acpi_iovt_iommu *iommu;
/* Get the first IOVT node */
iovt = (struct acpi_table_iovt *)header;
iommu = ACPI_ADD_PTR(struct acpi_iovt_iommu, iovt, iovt->iommu_offset);
for (i = 0; i < iovt->iommu_count; i++) {
iovt_add_iommu(iommu);
iommu = ACPI_ADD_PTR(struct acpi_iovt_iommu, iommu, iommu->header.length);
}
}
void __init acpi_iovt_init(void)
{
int i;
acpi_status status;
struct acpi_table_header *hdr;
struct acpi_table_iovt *iovt;
struct acpi_iovt_iommu *iommu;
status = acpi_get_table(ACPI_SIG_IOVT, 0, &hdr);
if (ACPI_FAILURE(status)) {
if (status != AE_NOT_FOUND)
pr_err("Failed to get table, %s\n", acpi_format_exception(status));
return;
}
if (acpi_iovt_checksum((unsigned char *)hdr, hdr->length)) {
pr_err("IOVT invalid checksum\n");
acpi_put_table(hdr);
return;
}
checksum_valid = true;
iovt = (struct acpi_table_iovt *)hdr;
iommu = ACPI_ADD_PTR(struct acpi_iovt_iommu, iovt, iovt->iommu_offset);
for (i = 0; i < iovt->iommu_count; i++) {
iovt_enable_acs(iommu);
iommu = ACPI_ADD_PTR(struct acpi_iovt_iommu, iommu, iommu->header.length);
}
acpi_put_table(hdr);
}
void __init acpi_iovt_late_init(void)
{
acpi_status status;
struct acpi_table_header *hdr;
if (!checksum_valid)
return;
status = acpi_get_table(ACPI_SIG_IOVT, 0, &hdr);
if (ACPI_FAILURE(status)) {
if (status != AE_NOT_FOUND)
pr_err("Failed to get table, %s\n", acpi_format_exception(status));
return;
}
iovt_init_devices(hdr);
acpi_put_table(hdr);
}
static int iovt_pci_iommu_init(struct pci_dev *pdev, u16 dev_id, void *data)
{
struct iovt_fwnode *np;
struct iovt_device_entry *entry;
struct device *aliased_dev = data;
u32 domain = pci_domain_nr(pdev->bus);
list_for_each_entry(np, &iovt_fwnode_list, list) {
if (domain != np->segment)
continue;
/* We're not translating ourself */
if (dev_id == np->devid)
return -EINVAL;
if (np->flag & ACPI_IOVT_IOMMU_MAGAGE_BY_SEGMENT)
goto found;
list_for_each_entry(entry, &np->ep_list, list) {
if (dev_id >= entry->start_devid && dev_id <= entry->end_devid)
goto found;
}
}
return -ENODEV;
found:
return acpi_iommu_fwspec_init(aliased_dev, (domain << 16) + dev_id, np->fwnode);
}
/*
* iovt_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 iovt_iommu_configure_id(struct device *dev, const u32 *id_in)
{
if (!dev_is_pci(dev))
return -ENODEV;
return pci_for_each_dma_alias(to_pci_dev(dev), iovt_pci_iommu_init, dev);
}