iommu.c 61.1 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0-only
2 3
/*
 * Copyright (C) 2007-2008 Advanced Micro Devices, Inc.
J
Joerg Roedel 已提交
4
 * Author: Joerg Roedel <jroedel@suse.de>
5 6
 */

7
#define pr_fmt(fmt)    "iommu: " fmt
8

9
#include <linux/device.h>
10
#include <linux/kernel.h>
11 12
#include <linux/bug.h>
#include <linux/types.h>
13 14
#include <linux/init.h>
#include <linux/export.h>
15
#include <linux/slab.h>
16 17
#include <linux/errno.h>
#include <linux/iommu.h>
A
Alex Williamson 已提交
18 19 20
#include <linux/idr.h>
#include <linux/notifier.h>
#include <linux/err.h>
21
#include <linux/pci.h>
22
#include <linux/bitops.h>
R
Robin Murphy 已提交
23
#include <linux/property.h>
24
#include <linux/fsl/mc.h>
25
#include <trace/events/iommu.h>
A
Alex Williamson 已提交
26 27

static struct kset *iommu_group_kset;
H
Heiner Kallweit 已提交
28
static DEFINE_IDA(iommu_group_ida);
29 30 31
#ifdef CONFIG_IOMMU_DEFAULT_PASSTHROUGH
static unsigned int iommu_def_domain_type = IOMMU_DOMAIN_IDENTITY;
#else
32
static unsigned int iommu_def_domain_type = IOMMU_DOMAIN_DMA;
33
#endif
34
static bool iommu_dma_strict __read_mostly = true;
A
Alex Williamson 已提交
35 36 37 38 39 40 41 42 43 44 45

struct iommu_group {
	struct kobject kobj;
	struct kobject *devices_kobj;
	struct list_head devices;
	struct mutex mutex;
	struct blocking_notifier_head notifier;
	void *iommu_data;
	void (*iommu_data_release)(void *iommu_data);
	char *name;
	int id;
46
	struct iommu_domain *default_domain;
47
	struct iommu_domain *domain;
A
Alex Williamson 已提交
48 49
};

J
Joerg Roedel 已提交
50
struct group_device {
A
Alex Williamson 已提交
51 52 53 54 55 56 57 58 59 60 61 62
	struct list_head list;
	struct device *dev;
	char *name;
};

struct iommu_group_attribute {
	struct attribute attr;
	ssize_t (*show)(struct iommu_group *group, char *buf);
	ssize_t (*store)(struct iommu_group *group,
			 const char *buf, size_t count);
};

63
static const char * const iommu_group_resv_type_string[] = {
64 65 66 67 68
	[IOMMU_RESV_DIRECT]			= "direct",
	[IOMMU_RESV_DIRECT_RELAXABLE]		= "direct-relaxable",
	[IOMMU_RESV_RESERVED]			= "reserved",
	[IOMMU_RESV_MSI]			= "msi",
	[IOMMU_RESV_SW_MSI]			= "msi",
69 70
};

A
Alex Williamson 已提交
71 72 73
#define IOMMU_GROUP_ATTR(_name, _mode, _show, _store)		\
struct iommu_group_attribute iommu_group_attr_##_name =		\
	__ATTR(_name, _mode, _show, _store)
74

A
Alex Williamson 已提交
75 76 77 78
#define to_iommu_group_attr(_attr)	\
	container_of(_attr, struct iommu_group_attribute, attr)
#define to_iommu_group(_kobj)		\
	container_of(_kobj, struct iommu_group, kobj)
79

80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
static LIST_HEAD(iommu_device_list);
static DEFINE_SPINLOCK(iommu_device_lock);

int iommu_device_register(struct iommu_device *iommu)
{
	spin_lock(&iommu_device_lock);
	list_add_tail(&iommu->list, &iommu_device_list);
	spin_unlock(&iommu_device_lock);

	return 0;
}

void iommu_device_unregister(struct iommu_device *iommu)
{
	spin_lock(&iommu_device_lock);
	list_del(&iommu->list);
	spin_unlock(&iommu_device_lock);
}

99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120
static struct iommu_param *iommu_get_dev_param(struct device *dev)
{
	struct iommu_param *param = dev->iommu_param;

	if (param)
		return param;

	param = kzalloc(sizeof(*param), GFP_KERNEL);
	if (!param)
		return NULL;

	mutex_init(&param->lock);
	dev->iommu_param = param;
	return param;
}

static void iommu_free_dev_param(struct device *dev)
{
	kfree(dev->iommu_param);
	dev->iommu_param = NULL;
}

121 122 123
int iommu_probe_device(struct device *dev)
{
	const struct iommu_ops *ops = dev->bus->iommu_ops;
124
	int ret;
125 126

	WARN_ON(dev->iommu_group);
127 128
	if (!ops)
		return -EINVAL;
129

130 131
	if (!iommu_get_dev_param(dev))
		return -ENOMEM;
132

133 134 135
	ret = ops->add_device(dev);
	if (ret)
		iommu_free_dev_param(dev);
136 137

	return ret;
138 139 140 141 142 143 144 145
}

void iommu_release_device(struct device *dev)
{
	const struct iommu_ops *ops = dev->bus->iommu_ops;

	if (dev->iommu_group)
		ops->remove_device(dev);
146 147

	iommu_free_dev_param(dev);
148 149
}

150 151
static struct iommu_domain *__iommu_domain_alloc(struct bus_type *bus,
						 unsigned type);
152 153 154 155 156 157
static int __iommu_attach_device(struct iommu_domain *domain,
				 struct device *dev);
static int __iommu_attach_group(struct iommu_domain *domain,
				struct iommu_group *group);
static void __iommu_detach_group(struct iommu_domain *domain,
				 struct iommu_group *group);
158

159 160 161
static int __init iommu_set_def_domain_type(char *str)
{
	bool pt;
162
	int ret;
163

164 165 166
	ret = kstrtobool(str, &pt);
	if (ret)
		return ret;
167 168 169 170 171 172

	iommu_def_domain_type = pt ? IOMMU_DOMAIN_IDENTITY : IOMMU_DOMAIN_DMA;
	return 0;
}
early_param("iommu.passthrough", iommu_set_def_domain_type);

173 174 175 176 177 178
static int __init iommu_dma_setup(char *str)
{
	return kstrtobool(str, &iommu_dma_strict);
}
early_param("iommu.strict", iommu_dma_setup);

A
Alex Williamson 已提交
179 180
static ssize_t iommu_group_attr_show(struct kobject *kobj,
				     struct attribute *__attr, char *buf)
181
{
A
Alex Williamson 已提交
182 183 184
	struct iommu_group_attribute *attr = to_iommu_group_attr(__attr);
	struct iommu_group *group = to_iommu_group(kobj);
	ssize_t ret = -EIO;
185

A
Alex Williamson 已提交
186 187 188 189 190 191 192 193 194 195 196 197
	if (attr->show)
		ret = attr->show(group, buf);
	return ret;
}

static ssize_t iommu_group_attr_store(struct kobject *kobj,
				      struct attribute *__attr,
				      const char *buf, size_t count)
{
	struct iommu_group_attribute *attr = to_iommu_group_attr(__attr);
	struct iommu_group *group = to_iommu_group(kobj);
	ssize_t ret = -EIO;
198

A
Alex Williamson 已提交
199 200 201
	if (attr->store)
		ret = attr->store(group, buf, count);
	return ret;
202 203
}

A
Alex Williamson 已提交
204 205 206 207
static const struct sysfs_ops iommu_group_sysfs_ops = {
	.show = iommu_group_attr_show,
	.store = iommu_group_attr_store,
};
208

A
Alex Williamson 已提交
209 210 211 212
static int iommu_group_create_file(struct iommu_group *group,
				   struct iommu_group_attribute *attr)
{
	return sysfs_create_file(&group->kobj, &attr->attr);
213 214
}

A
Alex Williamson 已提交
215 216 217 218 219 220 221 222 223 224 225
static void iommu_group_remove_file(struct iommu_group *group,
				    struct iommu_group_attribute *attr)
{
	sysfs_remove_file(&group->kobj, &attr->attr);
}

static ssize_t iommu_group_show_name(struct iommu_group *group, char *buf)
{
	return sprintf(buf, "%s\n", group->name);
}

E
Eric Auger 已提交
226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258
/**
 * iommu_insert_resv_region - Insert a new region in the
 * list of reserved regions.
 * @new: new region to insert
 * @regions: list of regions
 *
 * The new element is sorted by address with respect to the other
 * regions of the same type. In case it overlaps with another
 * region of the same type, regions are merged. In case it
 * overlaps with another region of different type, regions are
 * not merged.
 */
static int iommu_insert_resv_region(struct iommu_resv_region *new,
				    struct list_head *regions)
{
	struct iommu_resv_region *region;
	phys_addr_t start = new->start;
	phys_addr_t end = new->start + new->length - 1;
	struct list_head *pos = regions->next;

	while (pos != regions) {
		struct iommu_resv_region *entry =
			list_entry(pos, struct iommu_resv_region, list);
		phys_addr_t a = entry->start;
		phys_addr_t b = entry->start + entry->length - 1;
		int type = entry->type;

		if (end < a) {
			goto insert;
		} else if (start > b) {
			pos = pos->next;
		} else if ((start >= a) && (end <= b)) {
			if (new->type == type)
259
				return 0;
E
Eric Auger 已提交
260 261 262 263 264 265
			else
				pos = pos->next;
		} else {
			if (new->type == type) {
				phys_addr_t new_start = min(a, start);
				phys_addr_t new_end = max(b, end);
266
				int ret;
E
Eric Auger 已提交
267 268 269 270

				list_del(&entry->list);
				entry->start = new_start;
				entry->length = new_end - new_start + 1;
271 272 273
				ret = iommu_insert_resv_region(entry, regions);
				kfree(entry);
				return ret;
E
Eric Auger 已提交
274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293
			} else {
				pos = pos->next;
			}
		}
	}
insert:
	region = iommu_alloc_resv_region(new->start, new->length,
					 new->prot, new->type);
	if (!region)
		return -ENOMEM;

	list_add_tail(&region->list, pos);
	return 0;
}

static int
iommu_insert_device_resv_regions(struct list_head *dev_resv_regions,
				 struct list_head *group_resv_regions)
{
	struct iommu_resv_region *entry;
294
	int ret = 0;
E
Eric Auger 已提交
295 296 297 298 299 300 301 302 303 304 305 306

	list_for_each_entry(entry, dev_resv_regions, list) {
		ret = iommu_insert_resv_region(entry, group_resv_regions);
		if (ret)
			break;
	}
	return ret;
}

int iommu_get_group_resv_regions(struct iommu_group *group,
				 struct list_head *head)
{
307
	struct group_device *device;
E
Eric Auger 已提交
308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325
	int ret = 0;

	mutex_lock(&group->mutex);
	list_for_each_entry(device, &group->devices, list) {
		struct list_head dev_resv_regions;

		INIT_LIST_HEAD(&dev_resv_regions);
		iommu_get_resv_regions(device->dev, &dev_resv_regions);
		ret = iommu_insert_device_resv_regions(&dev_resv_regions, head);
		iommu_put_resv_regions(device->dev, &dev_resv_regions);
		if (ret)
			break;
	}
	mutex_unlock(&group->mutex);
	return ret;
}
EXPORT_SYMBOL_GPL(iommu_get_group_resv_regions);

326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347
static ssize_t iommu_group_show_resv_regions(struct iommu_group *group,
					     char *buf)
{
	struct iommu_resv_region *region, *next;
	struct list_head group_resv_regions;
	char *str = buf;

	INIT_LIST_HEAD(&group_resv_regions);
	iommu_get_group_resv_regions(group, &group_resv_regions);

	list_for_each_entry_safe(region, next, &group_resv_regions, list) {
		str += sprintf(str, "0x%016llx 0x%016llx %s\n",
			       (long long int)region->start,
			       (long long int)(region->start +
						region->length - 1),
			       iommu_group_resv_type_string[region->type]);
		kfree(region);
	}

	return (str - buf);
}

348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364
static ssize_t iommu_group_show_type(struct iommu_group *group,
				     char *buf)
{
	char *type = "unknown\n";

	if (group->default_domain) {
		switch (group->default_domain->type) {
		case IOMMU_DOMAIN_BLOCKED:
			type = "blocked\n";
			break;
		case IOMMU_DOMAIN_IDENTITY:
			type = "identity\n";
			break;
		case IOMMU_DOMAIN_UNMANAGED:
			type = "unmanaged\n";
			break;
		case IOMMU_DOMAIN_DMA:
365
			type = "DMA\n";
366 367 368 369 370 371 372 373
			break;
		}
	}
	strcpy(buf, type);

	return strlen(type);
}

A
Alex Williamson 已提交
374 375
static IOMMU_GROUP_ATTR(name, S_IRUGO, iommu_group_show_name, NULL);

376 377 378
static IOMMU_GROUP_ATTR(reserved_regions, 0444,
			iommu_group_show_resv_regions, NULL);

379 380
static IOMMU_GROUP_ATTR(type, 0444, iommu_group_show_type, NULL);

A
Alex Williamson 已提交
381 382 383 384
static void iommu_group_release(struct kobject *kobj)
{
	struct iommu_group *group = to_iommu_group(kobj);

385 386
	pr_debug("Releasing group %d\n", group->id);

A
Alex Williamson 已提交
387 388 389
	if (group->iommu_data_release)
		group->iommu_data_release(group->iommu_data);

390
	ida_simple_remove(&iommu_group_ida, group->id);
A
Alex Williamson 已提交
391

392 393 394
	if (group->default_domain)
		iommu_domain_free(group->default_domain);

A
Alex Williamson 已提交
395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415
	kfree(group->name);
	kfree(group);
}

static struct kobj_type iommu_group_ktype = {
	.sysfs_ops = &iommu_group_sysfs_ops,
	.release = iommu_group_release,
};

/**
 * iommu_group_alloc - Allocate a new group
 *
 * This function is called by an iommu driver to allocate a new iommu
 * group.  The iommu group represents the minimum granularity of the iommu.
 * Upon successful return, the caller holds a reference to the supplied
 * group in order to hold the group until devices are added.  Use
 * iommu_group_put() to release this extra reference count, allowing the
 * group to be automatically reclaimed once it has no devices or external
 * references.
 */
struct iommu_group *iommu_group_alloc(void)
416
{
A
Alex Williamson 已提交
417 418 419 420 421 422 423 424 425 426 427 428
	struct iommu_group *group;
	int ret;

	group = kzalloc(sizeof(*group), GFP_KERNEL);
	if (!group)
		return ERR_PTR(-ENOMEM);

	group->kobj.kset = iommu_group_kset;
	mutex_init(&group->mutex);
	INIT_LIST_HEAD(&group->devices);
	BLOCKING_INIT_NOTIFIER_HEAD(&group->notifier);

429 430
	ret = ida_simple_get(&iommu_group_ida, 0, 0, GFP_KERNEL);
	if (ret < 0) {
A
Alex Williamson 已提交
431
		kfree(group);
432
		return ERR_PTR(ret);
A
Alex Williamson 已提交
433
	}
434
	group->id = ret;
435

A
Alex Williamson 已提交
436 437 438
	ret = kobject_init_and_add(&group->kobj, &iommu_group_ktype,
				   NULL, "%d", group->id);
	if (ret) {
439
		ida_simple_remove(&iommu_group_ida, group->id);
A
Alex Williamson 已提交
440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456
		kfree(group);
		return ERR_PTR(ret);
	}

	group->devices_kobj = kobject_create_and_add("devices", &group->kobj);
	if (!group->devices_kobj) {
		kobject_put(&group->kobj); /* triggers .release & free */
		return ERR_PTR(-ENOMEM);
	}

	/*
	 * The devices_kobj holds a reference on the group kobject, so
	 * as long as that exists so will the group.  We can therefore
	 * use the devices_kobj for reference counting.
	 */
	kobject_put(&group->kobj);

457 458 459 460 461
	ret = iommu_group_create_file(group,
				      &iommu_group_attr_reserved_regions);
	if (ret)
		return ERR_PTR(ret);

462 463 464 465
	ret = iommu_group_create_file(group, &iommu_group_attr_type);
	if (ret)
		return ERR_PTR(ret);

466 467
	pr_debug("Allocated group %d\n", group->id);

A
Alex Williamson 已提交
468 469 470 471
	return group;
}
EXPORT_SYMBOL_GPL(iommu_group_alloc);

472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500
struct iommu_group *iommu_group_get_by_id(int id)
{
	struct kobject *group_kobj;
	struct iommu_group *group;
	const char *name;

	if (!iommu_group_kset)
		return NULL;

	name = kasprintf(GFP_KERNEL, "%d", id);
	if (!name)
		return NULL;

	group_kobj = kset_find_obj(iommu_group_kset, name);
	kfree(name);

	if (!group_kobj)
		return NULL;

	group = container_of(group_kobj, struct iommu_group, kobj);
	BUG_ON(group->id != id);

	kobject_get(group->devices_kobj);
	kobject_put(&group->kobj);

	return group;
}
EXPORT_SYMBOL_GPL(iommu_group_get_by_id);

A
Alex Williamson 已提交
501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526
/**
 * iommu_group_get_iommudata - retrieve iommu_data registered for a group
 * @group: the group
 *
 * iommu drivers can store data in the group for use when doing iommu
 * operations.  This function provides a way to retrieve it.  Caller
 * should hold a group reference.
 */
void *iommu_group_get_iommudata(struct iommu_group *group)
{
	return group->iommu_data;
}
EXPORT_SYMBOL_GPL(iommu_group_get_iommudata);

/**
 * iommu_group_set_iommudata - set iommu_data for a group
 * @group: the group
 * @iommu_data: new data
 * @release: release function for iommu_data
 *
 * iommu drivers can store data in the group for use when doing iommu
 * operations.  This function provides a way to set the data after
 * the group has been allocated.  Caller should hold a group reference.
 */
void iommu_group_set_iommudata(struct iommu_group *group, void *iommu_data,
			       void (*release)(void *iommu_data))
527
{
A
Alex Williamson 已提交
528 529 530 531
	group->iommu_data = iommu_data;
	group->iommu_data_release = release;
}
EXPORT_SYMBOL_GPL(iommu_group_set_iommudata);
532

A
Alex Williamson 已提交
533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562
/**
 * iommu_group_set_name - set name for a group
 * @group: the group
 * @name: name
 *
 * Allow iommu driver to set a name for a group.  When set it will
 * appear in a name attribute file under the group in sysfs.
 */
int iommu_group_set_name(struct iommu_group *group, const char *name)
{
	int ret;

	if (group->name) {
		iommu_group_remove_file(group, &iommu_group_attr_name);
		kfree(group->name);
		group->name = NULL;
		if (!name)
			return 0;
	}

	group->name = kstrdup(name, GFP_KERNEL);
	if (!group->name)
		return -ENOMEM;

	ret = iommu_group_create_file(group, &iommu_group_attr_name);
	if (ret) {
		kfree(group->name);
		group->name = NULL;
		return ret;
	}
563 564 565

	return 0;
}
A
Alex Williamson 已提交
566
EXPORT_SYMBOL_GPL(iommu_group_set_name);
567

568 569 570 571
static int iommu_group_create_direct_mappings(struct iommu_group *group,
					      struct device *dev)
{
	struct iommu_domain *domain = group->default_domain;
572
	struct iommu_resv_region *entry;
573 574 575 576 577 578 579
	struct list_head mappings;
	unsigned long pg_size;
	int ret = 0;

	if (!domain || domain->type != IOMMU_DOMAIN_DMA)
		return 0;

580
	BUG_ON(!domain->pgsize_bitmap);
581

582
	pg_size = 1UL << __ffs(domain->pgsize_bitmap);
583 584
	INIT_LIST_HEAD(&mappings);

585
	iommu_get_resv_regions(dev, &mappings);
586 587 588 589 590

	/* We need to consider overlapping regions for different devices */
	list_for_each_entry(entry, &mappings, list) {
		dma_addr_t start, end, addr;

591 592
		if (domain->ops->apply_resv_region)
			domain->ops->apply_resv_region(dev, domain, entry);
593

594 595 596
		start = ALIGN(entry->start, pg_size);
		end   = ALIGN(entry->start + entry->length, pg_size);

597 598
		if (entry->type != IOMMU_RESV_DIRECT &&
		    entry->type != IOMMU_RESV_DIRECT_RELAXABLE)
599 600
			continue;

601 602 603 604 605 606 607 608 609 610 611 612 613 614
		for (addr = start; addr < end; addr += pg_size) {
			phys_addr_t phys_addr;

			phys_addr = iommu_iova_to_phys(domain, addr);
			if (phys_addr)
				continue;

			ret = iommu_map(domain, addr, addr, pg_size, entry->prot);
			if (ret)
				goto out;
		}

	}

615 616
	iommu_flush_tlb_all(domain);

617
out:
618
	iommu_put_resv_regions(dev, &mappings);
619 620 621 622

	return ret;
}

A
Alex Williamson 已提交
623 624 625 626 627 628 629 630 631
/**
 * iommu_group_add_device - add a device to an iommu group
 * @group: the group into which to add the device (reference should be held)
 * @dev: the device
 *
 * This function is called by an iommu driver to add a device into a
 * group.  Adding a device increments the group reference count.
 */
int iommu_group_add_device(struct iommu_group *group, struct device *dev)
632
{
A
Alex Williamson 已提交
633
	int ret, i = 0;
J
Joerg Roedel 已提交
634
	struct group_device *device;
A
Alex Williamson 已提交
635 636 637 638 639 640

	device = kzalloc(sizeof(*device), GFP_KERNEL);
	if (!device)
		return -ENOMEM;

	device->dev = dev;
641

A
Alex Williamson 已提交
642
	ret = sysfs_create_link(&dev->kobj, &group->kobj, "iommu_group");
643 644
	if (ret)
		goto err_free_device;
A
Alex Williamson 已提交
645 646 647 648

	device->name = kasprintf(GFP_KERNEL, "%s", kobject_name(&dev->kobj));
rename:
	if (!device->name) {
649 650
		ret = -ENOMEM;
		goto err_remove_link;
A
Alex Williamson 已提交
651
	}
652

A
Alex Williamson 已提交
653 654 655 656 657 658 659 660
	ret = sysfs_create_link_nowarn(group->devices_kobj,
				       &dev->kobj, device->name);
	if (ret) {
		if (ret == -EEXIST && i >= 0) {
			/*
			 * Account for the slim chance of collision
			 * and append an instance to the name.
			 */
661
			kfree(device->name);
A
Alex Williamson 已提交
662 663 664 665
			device->name = kasprintf(GFP_KERNEL, "%s.%d",
						 kobject_name(&dev->kobj), i++);
			goto rename;
		}
666
		goto err_free_name;
A
Alex Williamson 已提交
667 668 669 670 671 672
	}

	kobject_get(group->devices_kobj);

	dev->iommu_group = group;

673 674
	iommu_group_create_direct_mappings(group, dev);

A
Alex Williamson 已提交
675 676
	mutex_lock(&group->mutex);
	list_add_tail(&device->list, &group->devices);
677
	if (group->domain)
678
		ret = __iommu_attach_device(group->domain, dev);
A
Alex Williamson 已提交
679
	mutex_unlock(&group->mutex);
680 681
	if (ret)
		goto err_put_group;
A
Alex Williamson 已提交
682 683 684 685

	/* Notify any listeners about change to group. */
	blocking_notifier_call_chain(&group->notifier,
				     IOMMU_GROUP_NOTIFY_ADD_DEVICE, dev);
686 687

	trace_add_device_to_group(group->id, dev);
688

689
	dev_info(dev, "Adding to iommu group %d\n", group->id);
690

691
	return 0;
692 693 694 695 696 697 698 699 700 701 702 703 704

err_put_group:
	mutex_lock(&group->mutex);
	list_del(&device->list);
	mutex_unlock(&group->mutex);
	dev->iommu_group = NULL;
	kobject_put(group->devices_kobj);
err_free_name:
	kfree(device->name);
err_remove_link:
	sysfs_remove_link(&dev->kobj, "iommu_group");
err_free_device:
	kfree(device);
705
	dev_err(dev, "Failed to add to iommu group %d: %d\n", group->id, ret);
706
	return ret;
707
}
A
Alex Williamson 已提交
708
EXPORT_SYMBOL_GPL(iommu_group_add_device);
709

A
Alex Williamson 已提交
710 711 712 713 714 715 716 717 718 719
/**
 * iommu_group_remove_device - remove a device from it's current group
 * @dev: device to be removed
 *
 * This function is called by an iommu driver to remove the device from
 * it's current group.  This decrements the iommu group reference count.
 */
void iommu_group_remove_device(struct device *dev)
{
	struct iommu_group *group = dev->iommu_group;
J
Joerg Roedel 已提交
720
	struct group_device *tmp_device, *device = NULL;
A
Alex Williamson 已提交
721

722
	dev_info(dev, "Removing from iommu group %d\n", group->id);
723

A
Alex Williamson 已提交
724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743
	/* Pre-notify listeners that a device is being removed. */
	blocking_notifier_call_chain(&group->notifier,
				     IOMMU_GROUP_NOTIFY_DEL_DEVICE, dev);

	mutex_lock(&group->mutex);
	list_for_each_entry(tmp_device, &group->devices, list) {
		if (tmp_device->dev == dev) {
			device = tmp_device;
			list_del(&device->list);
			break;
		}
	}
	mutex_unlock(&group->mutex);

	if (!device)
		return;

	sysfs_remove_link(group->devices_kobj, device->name);
	sysfs_remove_link(&dev->kobj, "iommu_group");

744 745
	trace_remove_device_from_group(group->id, dev);

A
Alex Williamson 已提交
746 747 748 749 750 751 752
	kfree(device->name);
	kfree(device);
	dev->iommu_group = NULL;
	kobject_put(group->devices_kobj);
}
EXPORT_SYMBOL_GPL(iommu_group_remove_device);

753 754
static int iommu_group_device_count(struct iommu_group *group)
{
J
Joerg Roedel 已提交
755
	struct group_device *entry;
756 757 758 759 760 761 762 763
	int ret = 0;

	list_for_each_entry(entry, &group->devices, list)
		ret++;

	return ret;
}

A
Alex Williamson 已提交
764 765 766 767 768 769 770 771 772 773 774
/**
 * iommu_group_for_each_dev - iterate over each device in the group
 * @group: the group
 * @data: caller opaque data to be passed to callback function
 * @fn: caller supplied callback function
 *
 * This function is called by group users to iterate over group devices.
 * Callers should hold a reference count to the group during callback.
 * The group->mutex is held across callbacks, which will block calls to
 * iommu_group_add/remove_device.
 */
775 776
static int __iommu_group_for_each_dev(struct iommu_group *group, void *data,
				      int (*fn)(struct device *, void *))
A
Alex Williamson 已提交
777
{
J
Joerg Roedel 已提交
778
	struct group_device *device;
A
Alex Williamson 已提交
779 780 781 782 783 784 785
	int ret = 0;

	list_for_each_entry(device, &group->devices, list) {
		ret = fn(device->dev, data);
		if (ret)
			break;
	}
786 787 788 789 790 791 792 793 794 795 796
	return ret;
}


int iommu_group_for_each_dev(struct iommu_group *group, void *data,
			     int (*fn)(struct device *, void *))
{
	int ret;

	mutex_lock(&group->mutex);
	ret = __iommu_group_for_each_dev(group, data, fn);
A
Alex Williamson 已提交
797
	mutex_unlock(&group->mutex);
798

A
Alex Williamson 已提交
799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821
	return ret;
}
EXPORT_SYMBOL_GPL(iommu_group_for_each_dev);

/**
 * iommu_group_get - Return the group for a device and increment reference
 * @dev: get the group that this device belongs to
 *
 * This function is called by iommu drivers and users to get the group
 * for the specified device.  If found, the group is returned and the group
 * reference in incremented, else NULL.
 */
struct iommu_group *iommu_group_get(struct device *dev)
{
	struct iommu_group *group = dev->iommu_group;

	if (group)
		kobject_get(group->devices_kobj);

	return group;
}
EXPORT_SYMBOL_GPL(iommu_group_get);

822 823 824 825 826 827 828 829 830 831 832 833 834
/**
 * iommu_group_ref_get - Increment reference on a group
 * @group: the group to use, must not be NULL
 *
 * This function is called by iommu drivers to take additional references on an
 * existing group.  Returns the given group for convenience.
 */
struct iommu_group *iommu_group_ref_get(struct iommu_group *group)
{
	kobject_get(group->devices_kobj);
	return group;
}

A
Alex Williamson 已提交
835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878
/**
 * iommu_group_put - Decrement group reference
 * @group: the group to use
 *
 * This function is called by iommu drivers and users to release the
 * iommu group.  Once the reference count is zero, the group is released.
 */
void iommu_group_put(struct iommu_group *group)
{
	if (group)
		kobject_put(group->devices_kobj);
}
EXPORT_SYMBOL_GPL(iommu_group_put);

/**
 * iommu_group_register_notifier - Register a notifier for group changes
 * @group: the group to watch
 * @nb: notifier block to signal
 *
 * This function allows iommu group users to track changes in a group.
 * See include/linux/iommu.h for actions sent via this notifier.  Caller
 * should hold a reference to the group throughout notifier registration.
 */
int iommu_group_register_notifier(struct iommu_group *group,
				  struct notifier_block *nb)
{
	return blocking_notifier_chain_register(&group->notifier, nb);
}
EXPORT_SYMBOL_GPL(iommu_group_register_notifier);

/**
 * iommu_group_unregister_notifier - Unregister a notifier
 * @group: the group to watch
 * @nb: notifier block to signal
 *
 * Unregister a previously registered group notifier block.
 */
int iommu_group_unregister_notifier(struct iommu_group *group,
				    struct notifier_block *nb)
{
	return blocking_notifier_chain_unregister(&group->notifier, nb);
}
EXPORT_SYMBOL_GPL(iommu_group_unregister_notifier);

879 880 881 882 883 884 885
/**
 * iommu_register_device_fault_handler() - Register a device fault handler
 * @dev: the device
 * @handler: the fault handler
 * @data: private data passed as argument to the handler
 *
 * When an IOMMU fault event is received, this handler gets called with the
886 887 888 889 890 891 892 893
 * fault event and data as argument. The handler should return 0 on success. If
 * the fault is recoverable (IOMMU_FAULT_PAGE_REQ), the consumer should also
 * complete the fault by calling iommu_page_response() with one of the following
 * response code:
 * - IOMMU_PAGE_RESP_SUCCESS: retry the translation
 * - IOMMU_PAGE_RESP_INVALID: terminate the fault
 * - IOMMU_PAGE_RESP_FAILURE: terminate the fault and stop reporting
 *   page faults if possible.
894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922
 *
 * Return 0 if the fault handler was installed successfully, or an error.
 */
int iommu_register_device_fault_handler(struct device *dev,
					iommu_dev_fault_handler_t handler,
					void *data)
{
	struct iommu_param *param = dev->iommu_param;
	int ret = 0;

	if (!param)
		return -EINVAL;

	mutex_lock(&param->lock);
	/* Only allow one fault handler registered for each device */
	if (param->fault_param) {
		ret = -EBUSY;
		goto done_unlock;
	}

	get_device(dev);
	param->fault_param = kzalloc(sizeof(*param->fault_param), GFP_KERNEL);
	if (!param->fault_param) {
		put_device(dev);
		ret = -ENOMEM;
		goto done_unlock;
	}
	param->fault_param->handler = handler;
	param->fault_param->data = data;
923 924
	mutex_init(&param->fault_param->lock);
	INIT_LIST_HEAD(&param->fault_param->faults);
925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954

done_unlock:
	mutex_unlock(&param->lock);

	return ret;
}
EXPORT_SYMBOL_GPL(iommu_register_device_fault_handler);

/**
 * iommu_unregister_device_fault_handler() - Unregister the device fault handler
 * @dev: the device
 *
 * Remove the device fault handler installed with
 * iommu_register_device_fault_handler().
 *
 * Return 0 on success, or an error.
 */
int iommu_unregister_device_fault_handler(struct device *dev)
{
	struct iommu_param *param = dev->iommu_param;
	int ret = 0;

	if (!param)
		return -EINVAL;

	mutex_lock(&param->lock);

	if (!param->fault_param)
		goto unlock;

955 956 957 958 959 960
	/* we cannot unregister handler if there are pending faults */
	if (!list_empty(&param->fault_param->faults)) {
		ret = -EBUSY;
		goto unlock;
	}

961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976
	kfree(param->fault_param);
	param->fault_param = NULL;
	put_device(dev);
unlock:
	mutex_unlock(&param->lock);

	return ret;
}
EXPORT_SYMBOL_GPL(iommu_unregister_device_fault_handler);

/**
 * iommu_report_device_fault() - Report fault event to device driver
 * @dev: the device
 * @evt: fault event data
 *
 * Called by IOMMU drivers when a fault is detected, typically in a threaded IRQ
977 978
 * handler. When this function fails and the fault is recoverable, it is the
 * caller's responsibility to complete the fault.
979 980 981 982 983 984
 *
 * Return 0 on success, or an error.
 */
int iommu_report_device_fault(struct device *dev, struct iommu_fault_event *evt)
{
	struct iommu_param *param = dev->iommu_param;
985
	struct iommu_fault_event *evt_pending = NULL;
986 987 988 989 990 991 992 993 994 995 996 997 998
	struct iommu_fault_param *fparam;
	int ret = 0;

	if (!param || !evt)
		return -EINVAL;

	/* we only report device fault if there is a handler registered */
	mutex_lock(&param->lock);
	fparam = param->fault_param;
	if (!fparam || !fparam->handler) {
		ret = -EINVAL;
		goto done_unlock;
	}
999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012

	if (evt->fault.type == IOMMU_FAULT_PAGE_REQ &&
	    (evt->fault.prm.flags & IOMMU_FAULT_PAGE_REQUEST_LAST_PAGE)) {
		evt_pending = kmemdup(evt, sizeof(struct iommu_fault_event),
				      GFP_KERNEL);
		if (!evt_pending) {
			ret = -ENOMEM;
			goto done_unlock;
		}
		mutex_lock(&fparam->lock);
		list_add_tail(&evt_pending->list, &fparam->faults);
		mutex_unlock(&fparam->lock);
	}

1013
	ret = fparam->handler(&evt->fault, fparam->data);
1014 1015 1016 1017 1018 1019
	if (ret && evt_pending) {
		mutex_lock(&fparam->lock);
		list_del(&evt_pending->list);
		mutex_unlock(&fparam->lock);
		kfree(evt_pending);
	}
1020 1021 1022 1023 1024 1025
done_unlock:
	mutex_unlock(&param->lock);
	return ret;
}
EXPORT_SYMBOL_GPL(iommu_report_device_fault);

1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078
int iommu_page_response(struct device *dev,
			struct iommu_page_response *msg)
{
	bool pasid_valid;
	int ret = -EINVAL;
	struct iommu_fault_event *evt;
	struct iommu_fault_page_request *prm;
	struct iommu_param *param = dev->iommu_param;
	struct iommu_domain *domain = iommu_get_domain_for_dev(dev);

	if (!domain || !domain->ops->page_response)
		return -ENODEV;

	if (!param || !param->fault_param)
		return -EINVAL;

	if (msg->version != IOMMU_PAGE_RESP_VERSION_1 ||
	    msg->flags & ~IOMMU_PAGE_RESP_PASID_VALID)
		return -EINVAL;

	/* Only send response if there is a fault report pending */
	mutex_lock(&param->fault_param->lock);
	if (list_empty(&param->fault_param->faults)) {
		dev_warn_ratelimited(dev, "no pending PRQ, drop response\n");
		goto done_unlock;
	}
	/*
	 * Check if we have a matching page request pending to respond,
	 * otherwise return -EINVAL
	 */
	list_for_each_entry(evt, &param->fault_param->faults, list) {
		prm = &evt->fault.prm;
		pasid_valid = prm->flags & IOMMU_FAULT_PAGE_REQUEST_PASID_VALID;

		if ((pasid_valid && prm->pasid != msg->pasid) ||
		    prm->grpid != msg->grpid)
			continue;

		/* Sanitize the reply */
		msg->flags = pasid_valid ? IOMMU_PAGE_RESP_PASID_VALID : 0;

		ret = domain->ops->page_response(dev, evt, msg);
		list_del(&evt->list);
		kfree(evt);
		break;
	}

done_unlock:
	mutex_unlock(&param->fault_param->lock);
	return ret;
}
EXPORT_SYMBOL_GPL(iommu_page_response);

A
Alex Williamson 已提交
1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089
/**
 * iommu_group_id - Return ID for a group
 * @group: the group to ID
 *
 * Return the unique ID for the group matching the sysfs group number.
 */
int iommu_group_id(struct iommu_group *group)
{
	return group->id;
}
EXPORT_SYMBOL_GPL(iommu_group_id);
1090

1091 1092 1093
static struct iommu_group *get_pci_alias_group(struct pci_dev *pdev,
					       unsigned long *devfns);

1094 1095 1096 1097 1098 1099 1100 1101 1102 1103
/*
 * To consider a PCI device isolated, we require ACS to support Source
 * Validation, Request Redirection, Completer Redirection, and Upstream
 * Forwarding.  This effectively means that devices cannot spoof their
 * requester ID, requests and completions cannot be redirected, and all
 * transactions are forwarded upstream, even as it passes through a
 * bridge where the target device is downstream.
 */
#define REQ_ACS_FLAGS   (PCI_ACS_SV | PCI_ACS_RR | PCI_ACS_CR | PCI_ACS_UF)

1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135
/*
 * For multifunction devices which are not isolated from each other, find
 * all the other non-isolated functions and look for existing groups.  For
 * each function, we also need to look for aliases to or from other devices
 * that may already have a group.
 */
static struct iommu_group *get_pci_function_alias_group(struct pci_dev *pdev,
							unsigned long *devfns)
{
	struct pci_dev *tmp = NULL;
	struct iommu_group *group;

	if (!pdev->multifunction || pci_acs_enabled(pdev, REQ_ACS_FLAGS))
		return NULL;

	for_each_pci_dev(tmp) {
		if (tmp == pdev || tmp->bus != pdev->bus ||
		    PCI_SLOT(tmp->devfn) != PCI_SLOT(pdev->devfn) ||
		    pci_acs_enabled(tmp, REQ_ACS_FLAGS))
			continue;

		group = get_pci_alias_group(tmp, devfns);
		if (group) {
			pci_dev_put(tmp);
			return group;
		}
	}

	return NULL;
}

/*
1136 1137
 * Look for aliases to or from the given device for existing groups. DMA
 * aliases are only supported on the same bus, therefore the search
1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161
 * space is quite small (especially since we're really only looking at pcie
 * device, and therefore only expect multiple slots on the root complex or
 * downstream switch ports).  It's conceivable though that a pair of
 * multifunction devices could have aliases between them that would cause a
 * loop.  To prevent this, we use a bitmap to track where we've been.
 */
static struct iommu_group *get_pci_alias_group(struct pci_dev *pdev,
					       unsigned long *devfns)
{
	struct pci_dev *tmp = NULL;
	struct iommu_group *group;

	if (test_and_set_bit(pdev->devfn & 0xff, devfns))
		return NULL;

	group = iommu_group_get(&pdev->dev);
	if (group)
		return group;

	for_each_pci_dev(tmp) {
		if (tmp == pdev || tmp->bus != pdev->bus)
			continue;

		/* We alias them or they alias us */
1162
		if (pci_devs_are_dma_aliases(pdev, tmp)) {
1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179
			group = get_pci_alias_group(tmp, devfns);
			if (group) {
				pci_dev_put(tmp);
				return group;
			}

			group = get_pci_function_alias_group(tmp, devfns);
			if (group) {
				pci_dev_put(tmp);
				return group;
			}
		}
	}

	return NULL;
}

1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198
struct group_for_pci_data {
	struct pci_dev *pdev;
	struct iommu_group *group;
};

/*
 * DMA alias iterator callback, return the last seen device.  Stop and return
 * the IOMMU group if we find one along the way.
 */
static int get_pci_alias_or_group(struct pci_dev *pdev, u16 alias, void *opaque)
{
	struct group_for_pci_data *data = opaque;

	data->pdev = pdev;
	data->group = iommu_group_get(&pdev->dev);

	return data->group != NULL;
}

1199 1200 1201 1202 1203 1204
/*
 * Generic device_group call-back function. It just allocates one
 * iommu-group per device.
 */
struct iommu_group *generic_device_group(struct device *dev)
{
1205
	return iommu_group_alloc();
1206 1207
}

1208 1209 1210 1211
/*
 * Use standard PCI bus topology, isolation features, and DMA alias quirks
 * to find or create an IOMMU group for a device.
 */
1212
struct iommu_group *pci_device_group(struct device *dev)
1213
{
1214
	struct pci_dev *pdev = to_pci_dev(dev);
1215 1216 1217
	struct group_for_pci_data data;
	struct pci_bus *bus;
	struct iommu_group *group = NULL;
1218
	u64 devfns[4] = { 0 };
1219

1220 1221 1222
	if (WARN_ON(!dev_is_pci(dev)))
		return ERR_PTR(-EINVAL);

1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254
	/*
	 * Find the upstream DMA alias for the device.  A device must not
	 * be aliased due to topology in order to have its own IOMMU group.
	 * If we find an alias along the way that already belongs to a
	 * group, use it.
	 */
	if (pci_for_each_dma_alias(pdev, get_pci_alias_or_group, &data))
		return data.group;

	pdev = data.pdev;

	/*
	 * Continue upstream from the point of minimum IOMMU granularity
	 * due to aliases to the point where devices are protected from
	 * peer-to-peer DMA by PCI ACS.  Again, if we find an existing
	 * group, use it.
	 */
	for (bus = pdev->bus; !pci_is_root_bus(bus); bus = bus->parent) {
		if (!bus->self)
			continue;

		if (pci_acs_path_enabled(bus->self, NULL, REQ_ACS_FLAGS))
			break;

		pdev = bus->self;

		group = iommu_group_get(&pdev->dev);
		if (group)
			return group;
	}

	/*
1255 1256
	 * Look for existing groups on device aliases.  If we alias another
	 * device or another device aliases us, use the same group.
1257
	 */
1258 1259 1260
	group = get_pci_alias_group(pdev, (unsigned long *)devfns);
	if (group)
		return group;
1261 1262

	/*
1263 1264 1265
	 * Look for existing groups on non-isolated functions on the same
	 * slot and aliases of those funcions, if any.  No need to clear
	 * the search bitmap, the tested devfns are still valid.
1266
	 */
1267 1268 1269
	group = get_pci_function_alias_group(pdev, (unsigned long *)devfns);
	if (group)
		return group;
1270 1271

	/* No shared group found, allocate new */
1272
	return iommu_group_alloc();
1273 1274
}

1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286
/* Get the IOMMU group for device on fsl-mc bus */
struct iommu_group *fsl_mc_device_group(struct device *dev)
{
	struct device *cont_dev = fsl_mc_cont_dev(dev);
	struct iommu_group *group;

	group = iommu_group_get(cont_dev);
	if (!group)
		group = iommu_group_alloc();
	return group;
}

1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298
/**
 * iommu_group_get_for_dev - Find or create the IOMMU group for a device
 * @dev: target device
 *
 * This function is intended to be called by IOMMU drivers and extended to
 * support common, bus-defined algorithms when determining or creating the
 * IOMMU group for a device.  On success, the caller will hold a reference
 * to the returned IOMMU group, which will already include the provided
 * device.  The reference should be released with iommu_group_put().
 */
struct iommu_group *iommu_group_get_for_dev(struct device *dev)
{
1299
	const struct iommu_ops *ops = dev->bus->iommu_ops;
1300
	struct iommu_group *group;
1301 1302 1303 1304 1305 1306
	int ret;

	group = iommu_group_get(dev);
	if (group)
		return group;

1307 1308
	if (!ops)
		return ERR_PTR(-EINVAL);
1309

1310
	group = ops->device_group(dev);
1311 1312 1313
	if (WARN_ON_ONCE(group == NULL))
		return ERR_PTR(-EINVAL);

1314 1315 1316
	if (IS_ERR(group))
		return group;

1317 1318 1319 1320 1321
	/*
	 * Try to allocate a default domain - needs support from the
	 * IOMMU driver.
	 */
	if (!group->default_domain) {
1322 1323 1324 1325 1326
		struct iommu_domain *dom;

		dom = __iommu_domain_alloc(dev->bus, iommu_def_domain_type);
		if (!dom && iommu_def_domain_type != IOMMU_DOMAIN_DMA) {
			dom = __iommu_domain_alloc(dev->bus, IOMMU_DOMAIN_DMA);
1327 1328 1329 1330 1331
			if (dom) {
				dev_warn(dev,
					 "failed to allocate default IOMMU domain of type %u; falling back to IOMMU_DOMAIN_DMA",
					 iommu_def_domain_type);
			}
1332 1333 1334
		}

		group->default_domain = dom;
1335
		if (!group->domain)
1336
			group->domain = dom;
1337 1338 1339 1340 1341 1342 1343

		if (dom && !iommu_dma_strict) {
			int attr = 1;
			iommu_domain_set_attr(dom,
					      DOMAIN_ATTR_DMA_USE_FLUSH_QUEUE,
					      &attr);
		}
1344 1345
	}

1346 1347 1348 1349 1350 1351 1352 1353 1354
	ret = iommu_group_add_device(group, dev);
	if (ret) {
		iommu_group_put(group);
		return ERR_PTR(ret);
	}

	return group;
}

1355 1356 1357 1358 1359
struct iommu_domain *iommu_group_default_domain(struct iommu_group *group)
{
	return group->default_domain;
}

A
Alex Williamson 已提交
1360
static int add_iommu_group(struct device *dev, void *data)
1361
{
1362
	int ret = iommu_probe_device(dev);
1363 1364 1365 1366 1367 1368 1369 1370 1371 1372

	/*
	 * We ignore -ENODEV errors for now, as they just mean that the
	 * device is not translated by an IOMMU. We still care about
	 * other errors and fail to initialize when they happen.
	 */
	if (ret == -ENODEV)
		ret = 0;

	return ret;
1373 1374
}

1375 1376
static int remove_iommu_group(struct device *dev, void *data)
{
1377
	iommu_release_device(dev);
1378 1379 1380 1381

	return 0;
}

A
Alex Williamson 已提交
1382 1383
static int iommu_bus_notifier(struct notifier_block *nb,
			      unsigned long action, void *data)
1384
{
1385
	unsigned long group_action = 0;
1386
	struct device *dev = data;
A
Alex Williamson 已提交
1387 1388 1389 1390 1391 1392 1393
	struct iommu_group *group;

	/*
	 * ADD/DEL call into iommu driver ops if provided, which may
	 * result in ADD/DEL notifiers to group->notifier
	 */
	if (action == BUS_NOTIFY_ADD_DEVICE) {
1394
		int ret;
1395

1396 1397
		ret = iommu_probe_device(dev);
		return (ret) ? NOTIFY_DONE : NOTIFY_OK;
1398
	} else if (action == BUS_NOTIFY_REMOVED_DEVICE) {
1399 1400
		iommu_release_device(dev);
		return NOTIFY_OK;
A
Alex Williamson 已提交
1401
	}
1402

A
Alex Williamson 已提交
1403 1404 1405 1406 1407 1408 1409
	/*
	 * Remaining BUS_NOTIFYs get filtered and republished to the
	 * group, if anyone is listening
	 */
	group = iommu_group_get(dev);
	if (!group)
		return 0;
1410

A
Alex Williamson 已提交
1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424
	switch (action) {
	case BUS_NOTIFY_BIND_DRIVER:
		group_action = IOMMU_GROUP_NOTIFY_BIND_DRIVER;
		break;
	case BUS_NOTIFY_BOUND_DRIVER:
		group_action = IOMMU_GROUP_NOTIFY_BOUND_DRIVER;
		break;
	case BUS_NOTIFY_UNBIND_DRIVER:
		group_action = IOMMU_GROUP_NOTIFY_UNBIND_DRIVER;
		break;
	case BUS_NOTIFY_UNBOUND_DRIVER:
		group_action = IOMMU_GROUP_NOTIFY_UNBOUND_DRIVER;
		break;
	}
1425

A
Alex Williamson 已提交
1426 1427 1428
	if (group_action)
		blocking_notifier_call_chain(&group->notifier,
					     group_action, dev);
1429

A
Alex Williamson 已提交
1430
	iommu_group_put(group);
1431 1432 1433
	return 0;
}

M
Mark Salter 已提交
1434
static int iommu_bus_init(struct bus_type *bus, const struct iommu_ops *ops)
1435
{
M
Mark Salter 已提交
1436 1437
	int err;
	struct notifier_block *nb;
1438

M
Mark Salter 已提交
1439 1440 1441 1442 1443 1444 1445
	nb = kzalloc(sizeof(struct notifier_block), GFP_KERNEL);
	if (!nb)
		return -ENOMEM;

	nb->notifier_call = iommu_bus_notifier;

	err = bus_register_notifier(bus, nb);
1446 1447
	if (err)
		goto out_free;
1448

L
Lu Baolu 已提交
1449
	err = bus_for_each_dev(bus, NULL, NULL, add_iommu_group);
1450 1451 1452
	if (err)
		goto out_err;

1453 1454

	return 0;
1455 1456 1457

out_err:
	/* Clean up */
L
Lu Baolu 已提交
1458
	bus_for_each_dev(bus, NULL, NULL, remove_iommu_group);
1459 1460 1461 1462 1463 1464
	bus_unregister_notifier(bus, nb);

out_free:
	kfree(nb);

	return err;
1465
}
1466

1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479
/**
 * bus_set_iommu - set iommu-callbacks for the bus
 * @bus: bus.
 * @ops: the callbacks provided by the iommu-driver
 *
 * This function is called by an iommu driver to set the iommu methods
 * used for a particular bus. Drivers for devices on that bus can use
 * the iommu-api after these ops are registered.
 * This special function is needed because IOMMUs are usually devices on
 * the bus itself, so the iommu drivers are not initialized when the bus
 * is set up. With this function the iommu-driver can set the iommu-ops
 * afterwards.
 */
1480
int bus_set_iommu(struct bus_type *bus, const struct iommu_ops *ops)
1481
{
1482 1483
	int err;

1484 1485
	if (bus->iommu_ops != NULL)
		return -EBUSY;
1486

1487 1488 1489
	bus->iommu_ops = ops;

	/* Do IOMMU specific setup for this bus-type */
1490 1491 1492 1493 1494
	err = iommu_bus_init(bus, ops);
	if (err)
		bus->iommu_ops = NULL;

	return err;
1495
}
1496
EXPORT_SYMBOL_GPL(bus_set_iommu);
1497

1498
bool iommu_present(struct bus_type *bus)
1499
{
1500
	return bus->iommu_ops != NULL;
1501
}
1502
EXPORT_SYMBOL_GPL(iommu_present);
1503

1504 1505 1506 1507 1508 1509 1510 1511 1512
bool iommu_capable(struct bus_type *bus, enum iommu_cap cap)
{
	if (!bus->iommu_ops || !bus->iommu_ops->capable)
		return false;

	return bus->iommu_ops->capable(cap);
}
EXPORT_SYMBOL_GPL(iommu_capable);

1513 1514 1515 1516
/**
 * iommu_set_fault_handler() - set a fault handler for an iommu domain
 * @domain: iommu domain
 * @handler: fault handler
1517
 * @token: user data, will be passed back to the fault handler
1518 1519 1520 1521 1522 1523
 *
 * This function should be used by IOMMU users which want to be notified
 * whenever an IOMMU fault happens.
 *
 * The fault handler itself should return 0 on success, and an appropriate
 * error code otherwise.
1524 1525
 */
void iommu_set_fault_handler(struct iommu_domain *domain,
1526 1527
					iommu_fault_handler_t handler,
					void *token)
1528 1529 1530 1531
{
	BUG_ON(!domain);

	domain->handler = handler;
1532
	domain->handler_token = token;
1533
}
1534
EXPORT_SYMBOL_GPL(iommu_set_fault_handler);
1535

1536 1537
static struct iommu_domain *__iommu_domain_alloc(struct bus_type *bus,
						 unsigned type)
1538 1539 1540
{
	struct iommu_domain *domain;

1541
	if (bus == NULL || bus->iommu_ops == NULL)
1542 1543
		return NULL;

1544
	domain = bus->iommu_ops->domain_alloc(type);
1545 1546 1547
	if (!domain)
		return NULL;

1548
	domain->ops  = bus->iommu_ops;
1549
	domain->type = type;
1550 1551
	/* Assume all sizes by default; the driver may override this later */
	domain->pgsize_bitmap  = bus->iommu_ops->pgsize_bitmap;
1552

1553 1554 1555
	return domain;
}

1556 1557 1558
struct iommu_domain *iommu_domain_alloc(struct bus_type *bus)
{
	return __iommu_domain_alloc(bus, IOMMU_DOMAIN_UNMANAGED);
1559 1560 1561 1562 1563
}
EXPORT_SYMBOL_GPL(iommu_domain_alloc);

void iommu_domain_free(struct iommu_domain *domain)
{
1564
	domain->ops->domain_free(domain);
1565 1566 1567
}
EXPORT_SYMBOL_GPL(iommu_domain_free);

1568 1569
static int __iommu_attach_device(struct iommu_domain *domain,
				 struct device *dev)
1570
{
1571
	int ret;
1572 1573 1574 1575
	if ((domain->ops->is_attach_deferred != NULL) &&
	    domain->ops->is_attach_deferred(domain, dev))
		return 0;

1576 1577 1578
	if (unlikely(domain->ops->attach_dev == NULL))
		return -ENODEV;

1579 1580 1581 1582
	ret = domain->ops->attach_dev(domain, dev);
	if (!ret)
		trace_attach_device_to_domain(dev);
	return ret;
1583
}
1584 1585 1586 1587 1588 1589 1590

int iommu_attach_device(struct iommu_domain *domain, struct device *dev)
{
	struct iommu_group *group;
	int ret;

	group = iommu_group_get(dev);
1591 1592 1593
	if (!group)
		return -ENODEV;

1594
	/*
1595
	 * Lock the group to make sure the device-count doesn't
1596 1597 1598 1599 1600 1601 1602
	 * change while we are attaching
	 */
	mutex_lock(&group->mutex);
	ret = -EINVAL;
	if (iommu_group_device_count(group) != 1)
		goto out_unlock;

1603
	ret = __iommu_attach_group(domain, group);
1604 1605 1606 1607 1608 1609 1610

out_unlock:
	mutex_unlock(&group->mutex);
	iommu_group_put(group);

	return ret;
}
1611 1612
EXPORT_SYMBOL_GPL(iommu_attach_device);

1613 1614
static void __iommu_detach_device(struct iommu_domain *domain,
				  struct device *dev)
1615
{
1616 1617 1618 1619
	if ((domain->ops->is_attach_deferred != NULL) &&
	    domain->ops->is_attach_deferred(domain, dev))
		return;

1620 1621 1622 1623
	if (unlikely(domain->ops->detach_dev == NULL))
		return;

	domain->ops->detach_dev(domain, dev);
1624
	trace_detach_device_from_domain(dev);
1625
}
1626 1627 1628 1629 1630 1631

void iommu_detach_device(struct iommu_domain *domain, struct device *dev)
{
	struct iommu_group *group;

	group = iommu_group_get(dev);
1632 1633
	if (!group)
		return;
1634 1635 1636 1637 1638 1639 1640

	mutex_lock(&group->mutex);
	if (iommu_group_device_count(group) != 1) {
		WARN_ON(1);
		goto out_unlock;
	}

1641
	__iommu_detach_group(domain, group);
1642 1643 1644 1645 1646

out_unlock:
	mutex_unlock(&group->mutex);
	iommu_group_put(group);
}
1647 1648
EXPORT_SYMBOL_GPL(iommu_detach_device);

1649 1650 1651 1652 1653 1654
struct iommu_domain *iommu_get_domain_for_dev(struct device *dev)
{
	struct iommu_domain *domain;
	struct iommu_group *group;

	group = iommu_group_get(dev);
1655
	if (!group)
1656 1657 1658 1659 1660 1661 1662 1663 1664
		return NULL;

	domain = group->domain;

	iommu_group_put(group);

	return domain;
}
EXPORT_SYMBOL_GPL(iommu_get_domain_for_dev);
1665

A
Alex Williamson 已提交
1666
/*
1667 1668 1669 1670 1671 1672 1673 1674
 * For IOMMU_DOMAIN_DMA implementations which already provide their own
 * guarantees that the group and its default domain are valid and correct.
 */
struct iommu_domain *iommu_get_dma_domain(struct device *dev)
{
	return dev->iommu_group->default_domain;
}

A
Alex Williamson 已提交
1675
/*
R
Rami Rosen 已提交
1676
 * IOMMU groups are really the natural working unit of the IOMMU, but
A
Alex Williamson 已提交
1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688
 * the IOMMU API works on domains and devices.  Bridge that gap by
 * iterating over the devices in a group.  Ideally we'd have a single
 * device which represents the requestor ID of the group, but we also
 * allow IOMMU drivers to create policy defined minimum sets, where
 * the physical hardware may be able to distiguish members, but we
 * wish to group them at a higher level (ex. untrusted multi-function
 * PCI devices).  Thus we attach each device.
 */
static int iommu_group_do_attach_device(struct device *dev, void *data)
{
	struct iommu_domain *domain = data;

1689
	return __iommu_attach_device(domain, dev);
A
Alex Williamson 已提交
1690 1691
}

1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705
static int __iommu_attach_group(struct iommu_domain *domain,
				struct iommu_group *group)
{
	int ret;

	if (group->default_domain && group->domain != group->default_domain)
		return -EBUSY;

	ret = __iommu_group_for_each_dev(group, domain,
					 iommu_group_do_attach_device);
	if (ret == 0)
		group->domain = domain;

	return ret;
A
Alex Williamson 已提交
1706 1707 1708 1709
}

int iommu_attach_group(struct iommu_domain *domain, struct iommu_group *group)
{
1710 1711 1712 1713 1714 1715 1716
	int ret;

	mutex_lock(&group->mutex);
	ret = __iommu_attach_group(domain, group);
	mutex_unlock(&group->mutex);

	return ret;
A
Alex Williamson 已提交
1717 1718 1719 1720 1721 1722 1723
}
EXPORT_SYMBOL_GPL(iommu_attach_group);

static int iommu_group_do_detach_device(struct device *dev, void *data)
{
	struct iommu_domain *domain = data;

1724
	__iommu_detach_device(domain, dev);
A
Alex Williamson 已提交
1725 1726 1727 1728

	return 0;
}

1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752
static void __iommu_detach_group(struct iommu_domain *domain,
				 struct iommu_group *group)
{
	int ret;

	if (!group->default_domain) {
		__iommu_group_for_each_dev(group, domain,
					   iommu_group_do_detach_device);
		group->domain = NULL;
		return;
	}

	if (group->domain == group->default_domain)
		return;

	/* Detach by re-attaching to the default domain */
	ret = __iommu_group_for_each_dev(group, group->default_domain,
					 iommu_group_do_attach_device);
	if (ret != 0)
		WARN_ON(1);
	else
		group->domain = group->default_domain;
}

A
Alex Williamson 已提交
1753 1754
void iommu_detach_group(struct iommu_domain *domain, struct iommu_group *group)
{
1755 1756 1757
	mutex_lock(&group->mutex);
	__iommu_detach_group(domain, group);
	mutex_unlock(&group->mutex);
A
Alex Williamson 已提交
1758 1759 1760
}
EXPORT_SYMBOL_GPL(iommu_detach_group);

1761
phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain, dma_addr_t iova)
1762
{
1763 1764 1765 1766
	if (unlikely(domain->ops->iova_to_phys == NULL))
		return 0;

	return domain->ops->iova_to_phys(domain, iova);
1767 1768
}
EXPORT_SYMBOL_GPL(iommu_iova_to_phys);
S
Sheng Yang 已提交
1769

A
Alex Williamson 已提交
1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789
static size_t iommu_pgsize(struct iommu_domain *domain,
			   unsigned long addr_merge, size_t size)
{
	unsigned int pgsize_idx;
	size_t pgsize;

	/* Max page size that still fits into 'size' */
	pgsize_idx = __fls(size);

	/* need to consider alignment requirements ? */
	if (likely(addr_merge)) {
		/* Max page size allowed by address */
		unsigned int align_pgsize_idx = __ffs(addr_merge);
		pgsize_idx = min(pgsize_idx, align_pgsize_idx);
	}

	/* build a mask of acceptable page sizes */
	pgsize = (1UL << (pgsize_idx + 1)) - 1;

	/* throw away page sizes not supported by the hardware */
1790
	pgsize &= domain->pgsize_bitmap;
A
Alex Williamson 已提交
1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801

	/* make sure we're still sane */
	BUG_ON(!pgsize);

	/* pick the biggest page */
	pgsize_idx = __fls(pgsize);
	pgsize = 1UL << pgsize_idx;

	return pgsize;
}

1802
int iommu_map(struct iommu_domain *domain, unsigned long iova,
1803
	      phys_addr_t paddr, size_t size, int prot)
1804
{
1805
	const struct iommu_ops *ops = domain->ops;
1806 1807 1808
	unsigned long orig_iova = iova;
	unsigned int min_pagesz;
	size_t orig_size = size;
1809
	phys_addr_t orig_paddr = paddr;
1810
	int ret = 0;
1811

1812
	if (unlikely(ops->map == NULL ||
1813
		     domain->pgsize_bitmap == 0UL))
1814
		return -ENODEV;
1815

1816 1817 1818
	if (unlikely(!(domain->type & __IOMMU_DOMAIN_PAGING)))
		return -EINVAL;

1819
	/* find out the minimum page size supported */
1820
	min_pagesz = 1 << __ffs(domain->pgsize_bitmap);
1821 1822 1823 1824 1825 1826 1827

	/*
	 * both the virtual address and the physical one, as well as
	 * the size of the mapping, must be aligned (at least) to the
	 * size of the smallest page supported by the hardware
	 */
	if (!IS_ALIGNED(iova | paddr | size, min_pagesz)) {
1828
		pr_err("unaligned: iova 0x%lx pa %pa size 0x%zx min_pagesz 0x%x\n",
1829
		       iova, &paddr, size, min_pagesz);
1830 1831 1832
		return -EINVAL;
	}

1833
	pr_debug("map: iova 0x%lx pa %pa size 0x%zx\n", iova, &paddr, size);
1834 1835

	while (size) {
A
Alex Williamson 已提交
1836
		size_t pgsize = iommu_pgsize(domain, iova | paddr, size);
1837

1838
		pr_debug("mapping: iova 0x%lx pa %pa pgsize 0x%zx\n",
1839
			 iova, &paddr, pgsize);
1840

1841
		ret = ops->map(domain, iova, paddr, pgsize, prot);
1842 1843 1844 1845 1846 1847 1848 1849
		if (ret)
			break;

		iova += pgsize;
		paddr += pgsize;
		size -= pgsize;
	}

1850 1851 1852
	if (ops->iotlb_sync_map)
		ops->iotlb_sync_map(domain);

1853 1854 1855
	/* unroll mapping in case something went wrong */
	if (ret)
		iommu_unmap(domain, orig_iova, orig_size - size);
1856
	else
1857
		trace_map(orig_iova, orig_paddr, orig_size);
1858 1859

	return ret;
1860 1861 1862
}
EXPORT_SYMBOL_GPL(iommu_map);

1863 1864
static size_t __iommu_unmap(struct iommu_domain *domain,
			    unsigned long iova, size_t size,
1865
			    struct iommu_iotlb_gather *iotlb_gather)
1866
{
1867
	const struct iommu_ops *ops = domain->ops;
1868
	size_t unmapped_page, unmapped = 0;
1869
	unsigned long orig_iova = iova;
1870
	unsigned int min_pagesz;
1871

1872
	if (unlikely(ops->unmap == NULL ||
1873
		     domain->pgsize_bitmap == 0UL))
1874
		return 0;
1875

1876
	if (unlikely(!(domain->type & __IOMMU_DOMAIN_PAGING)))
1877
		return 0;
1878

1879
	/* find out the minimum page size supported */
1880
	min_pagesz = 1 << __ffs(domain->pgsize_bitmap);
1881 1882 1883 1884 1885 1886 1887

	/*
	 * The virtual address, as well as the size of the mapping, must be
	 * aligned (at least) to the size of the smallest page supported
	 * by the hardware
	 */
	if (!IS_ALIGNED(iova | size, min_pagesz)) {
1888 1889
		pr_err("unaligned: iova 0x%lx size 0x%zx min_pagesz 0x%x\n",
		       iova, size, min_pagesz);
1890
		return 0;
1891 1892
	}

1893
	pr_debug("unmap this: iova 0x%lx size 0x%zx\n", iova, size);
1894 1895 1896 1897 1898 1899

	/*
	 * Keep iterating until we either unmap 'size' bytes (or more)
	 * or we hit an area that isn't mapped.
	 */
	while (unmapped < size) {
A
Alex Williamson 已提交
1900
		size_t pgsize = iommu_pgsize(domain, iova, size - unmapped);
1901

1902
		unmapped_page = ops->unmap(domain, iova, pgsize, iotlb_gather);
1903 1904 1905
		if (!unmapped_page)
			break;

1906 1907
		pr_debug("unmapped: iova 0x%lx size 0x%zx\n",
			 iova, unmapped_page);
1908 1909 1910 1911 1912

		iova += unmapped_page;
		unmapped += unmapped_page;
	}

1913
	trace_unmap(orig_iova, size, unmapped);
1914
	return unmapped;
1915
}
1916 1917 1918 1919

size_t iommu_unmap(struct iommu_domain *domain,
		   unsigned long iova, size_t size)
{
1920 1921 1922 1923 1924 1925 1926 1927
	struct iommu_iotlb_gather iotlb_gather;
	size_t ret;

	iommu_iotlb_gather_init(&iotlb_gather);
	ret = __iommu_unmap(domain, iova, size, &iotlb_gather);
	iommu_tlb_sync(domain, &iotlb_gather);

	return ret;
1928
}
1929
EXPORT_SYMBOL_GPL(iommu_unmap);
1930

1931
size_t iommu_unmap_fast(struct iommu_domain *domain,
1932 1933
			unsigned long iova, size_t size,
			struct iommu_iotlb_gather *iotlb_gather)
1934
{
1935
	return __iommu_unmap(domain, iova, size, iotlb_gather);
1936 1937 1938
}
EXPORT_SYMBOL_GPL(iommu_unmap_fast);

1939 1940
size_t iommu_map_sg(struct iommu_domain *domain, unsigned long iova,
		    struct scatterlist *sg, unsigned int nents, int prot)
O
Olav Haugan 已提交
1941
{
1942 1943 1944
	size_t len = 0, mapped = 0;
	phys_addr_t start;
	unsigned int i = 0;
1945
	int ret;
O
Olav Haugan 已提交
1946

1947 1948
	while (i <= nents) {
		phys_addr_t s_phys = sg_phys(sg);
1949

1950 1951 1952 1953
		if (len && s_phys != start + len) {
			ret = iommu_map(domain, iova + mapped, start, len, prot);
			if (ret)
				goto out_err;
1954

1955 1956 1957
			mapped += len;
			len = 0;
		}
1958

1959 1960 1961 1962 1963 1964
		if (len) {
			len += sg->length;
		} else {
			len = sg->length;
			start = s_phys;
		}
1965

1966 1967
		if (++i < nents)
			sg = sg_next(sg);
O
Olav Haugan 已提交
1968 1969 1970
	}

	return mapped;
1971 1972 1973 1974 1975 1976 1977

out_err:
	/* undo mappings already done */
	iommu_unmap(domain, iova, mapped);

	return 0;

O
Olav Haugan 已提交
1978
}
1979
EXPORT_SYMBOL_GPL(iommu_map_sg);
1980 1981

int iommu_domain_window_enable(struct iommu_domain *domain, u32 wnd_nr,
1982
			       phys_addr_t paddr, u64 size, int prot)
1983 1984 1985 1986
{
	if (unlikely(domain->ops->domain_window_enable == NULL))
		return -ENODEV;

1987 1988
	return domain->ops->domain_window_enable(domain, wnd_nr, paddr, size,
						 prot);
1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000
}
EXPORT_SYMBOL_GPL(iommu_domain_window_enable);

void iommu_domain_window_disable(struct iommu_domain *domain, u32 wnd_nr)
{
	if (unlikely(domain->ops->domain_window_disable == NULL))
		return;

	return domain->ops->domain_window_disable(domain, wnd_nr);
}
EXPORT_SYMBOL_GPL(iommu_domain_window_disable);

2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042
/**
 * report_iommu_fault() - report about an IOMMU fault to the IOMMU framework
 * @domain: the iommu domain where the fault has happened
 * @dev: the device where the fault has happened
 * @iova: the faulting address
 * @flags: mmu fault flags (e.g. IOMMU_FAULT_READ/IOMMU_FAULT_WRITE/...)
 *
 * This function should be called by the low-level IOMMU implementations
 * whenever IOMMU faults happen, to allow high-level users, that are
 * interested in such events, to know about them.
 *
 * This event may be useful for several possible use cases:
 * - mere logging of the event
 * - dynamic TLB/PTE loading
 * - if restarting of the faulting device is required
 *
 * Returns 0 on success and an appropriate error code otherwise (if dynamic
 * PTE/TLB loading will one day be supported, implementations will be able
 * to tell whether it succeeded or not according to this return value).
 *
 * Specifically, -ENOSYS is returned if a fault handler isn't installed
 * (though fault handlers can also return -ENOSYS, in case they want to
 * elicit the default behavior of the IOMMU drivers).
 */
int report_iommu_fault(struct iommu_domain *domain, struct device *dev,
		       unsigned long iova, int flags)
{
	int ret = -ENOSYS;

	/*
	 * if upper layers showed interest and installed a fault handler,
	 * invoke it.
	 */
	if (domain->handler)
		ret = domain->handler(domain, dev, iova, flags,
						domain->handler_token);

	trace_io_page_fault(dev, iova, flags);
	return ret;
}
EXPORT_SYMBOL_GPL(report_iommu_fault);

A
Alex Williamson 已提交
2043
static int __init iommu_init(void)
2044
{
A
Alex Williamson 已提交
2045 2046 2047 2048
	iommu_group_kset = kset_create_and_add("iommu_groups",
					       NULL, kernel_kobj);
	BUG_ON(!iommu_group_kset);

2049 2050
	iommu_debugfs_setup();

A
Alex Williamson 已提交
2051
	return 0;
2052
}
2053
core_initcall(iommu_init);
2054 2055 2056 2057

int iommu_domain_get_attr(struct iommu_domain *domain,
			  enum iommu_attr attr, void *data)
{
2058
	struct iommu_domain_geometry *geometry;
2059
	bool *paging;
2060 2061 2062 2063 2064 2065 2066
	int ret = 0;

	switch (attr) {
	case DOMAIN_ATTR_GEOMETRY:
		geometry  = data;
		*geometry = domain->geometry;

2067 2068 2069
		break;
	case DOMAIN_ATTR_PAGING:
		paging  = data;
2070
		*paging = (domain->pgsize_bitmap != 0UL);
2071 2072 2073 2074
		break;
	default:
		if (!domain->ops->domain_get_attr)
			return -EINVAL;
2075

2076 2077 2078 2079
		ret = domain->ops->domain_get_attr(domain, attr, data);
	}

	return ret;
2080 2081 2082 2083 2084 2085
}
EXPORT_SYMBOL_GPL(iommu_domain_get_attr);

int iommu_domain_set_attr(struct iommu_domain *domain,
			  enum iommu_attr attr, void *data)
{
2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096
	int ret = 0;

	switch (attr) {
	default:
		if (domain->ops->domain_set_attr == NULL)
			return -EINVAL;

		ret = domain->ops->domain_set_attr(domain, attr, data);
	}

	return ret;
2097
}
2098
EXPORT_SYMBOL_GPL(iommu_domain_set_attr);
2099

2100
void iommu_get_resv_regions(struct device *dev, struct list_head *list)
2101 2102 2103
{
	const struct iommu_ops *ops = dev->bus->iommu_ops;

2104 2105
	if (ops && ops->get_resv_regions)
		ops->get_resv_regions(dev, list);
2106 2107
}

2108
void iommu_put_resv_regions(struct device *dev, struct list_head *list)
2109 2110 2111
{
	const struct iommu_ops *ops = dev->bus->iommu_ops;

2112 2113
	if (ops && ops->put_resv_regions)
		ops->put_resv_regions(dev, list);
2114
}
2115

E
Eric Auger 已提交
2116
struct iommu_resv_region *iommu_alloc_resv_region(phys_addr_t start,
2117 2118
						  size_t length, int prot,
						  enum iommu_resv_type type)
E
Eric Auger 已提交
2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131
{
	struct iommu_resv_region *region;

	region = kzalloc(sizeof(*region), GFP_KERNEL);
	if (!region)
		return NULL;

	INIT_LIST_HEAD(&region->list);
	region->start = start;
	region->length = length;
	region->prot = prot;
	region->type = type;
	return region;
2132
}
2133

2134 2135
static int
request_default_domain_for_dev(struct device *dev, unsigned long type)
2136
{
2137
	struct iommu_domain *domain;
2138 2139 2140 2141
	struct iommu_group *group;
	int ret;

	/* Device must already be in a group before calling this function */
2142 2143 2144
	group = iommu_group_get(dev);
	if (!group)
		return -EINVAL;
2145 2146 2147 2148 2149

	mutex_lock(&group->mutex);

	/* Check if the default domain is already direct mapped */
	ret = 0;
2150
	if (group->default_domain && group->default_domain->type == type)
2151 2152 2153 2154 2155 2156 2157 2158 2159
		goto out;

	/* Don't change mappings of existing devices */
	ret = -EBUSY;
	if (iommu_group_device_count(group) != 1)
		goto out;

	/* Allocate a direct mapped domain */
	ret = -ENOMEM;
2160 2161
	domain = __iommu_domain_alloc(dev->bus, type);
	if (!domain)
2162 2163 2164
		goto out;

	/* Attach the device to the domain */
2165
	ret = __iommu_attach_group(domain, group);
2166
	if (ret) {
2167
		iommu_domain_free(domain);
2168 2169 2170
		goto out;
	}

2171 2172
	iommu_group_create_direct_mappings(group, dev);

2173 2174 2175
	/* Make the direct mapped domain the default for this group */
	if (group->default_domain)
		iommu_domain_free(group->default_domain);
2176
	group->default_domain = domain;
2177

2178 2179
	dev_info(dev, "Using iommu %s mapping\n",
		 type == IOMMU_DOMAIN_DMA ? "dma" : "direct");
2180 2181 2182 2183 2184 2185 2186 2187

	ret = 0;
out:
	mutex_unlock(&group->mutex);
	iommu_group_put(group);

	return ret;
}
R
Robin Murphy 已提交
2188

2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200
/* Request that a device is direct mapped by the IOMMU */
int iommu_request_dm_for_dev(struct device *dev)
{
	return request_default_domain_for_dev(dev, IOMMU_DOMAIN_IDENTITY);
}

/* Request that a device can't be direct mapped by the IOMMU */
int iommu_request_dma_domain_for_dev(struct device *dev)
{
	return request_default_domain_for_dev(dev, IOMMU_DOMAIN_DMA);
}

2201
const struct iommu_ops *iommu_ops_from_fwnode(struct fwnode_handle *fwnode)
2202 2203
{
	const struct iommu_ops *ops = NULL;
2204
	struct iommu_device *iommu;
2205

2206 2207 2208 2209
	spin_lock(&iommu_device_lock);
	list_for_each_entry(iommu, &iommu_device_list, list)
		if (iommu->fwnode == fwnode) {
			ops = iommu->ops;
2210 2211
			break;
		}
2212
	spin_unlock(&iommu_device_lock);
2213 2214 2215
	return ops;
}

R
Robin Murphy 已提交
2216 2217 2218
int iommu_fwspec_init(struct device *dev, struct fwnode_handle *iommu_fwnode,
		      const struct iommu_ops *ops)
{
2219
	struct iommu_fwspec *fwspec = dev_iommu_fwspec_get(dev);
R
Robin Murphy 已提交
2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230

	if (fwspec)
		return ops == fwspec->ops ? 0 : -EINVAL;

	fwspec = kzalloc(sizeof(*fwspec), GFP_KERNEL);
	if (!fwspec)
		return -ENOMEM;

	of_node_get(to_of_node(iommu_fwnode));
	fwspec->iommu_fwnode = iommu_fwnode;
	fwspec->ops = ops;
2231
	dev_iommu_fwspec_set(dev, fwspec);
R
Robin Murphy 已提交
2232 2233 2234 2235 2236 2237
	return 0;
}
EXPORT_SYMBOL_GPL(iommu_fwspec_init);

void iommu_fwspec_free(struct device *dev)
{
2238
	struct iommu_fwspec *fwspec = dev_iommu_fwspec_get(dev);
R
Robin Murphy 已提交
2239 2240 2241 2242

	if (fwspec) {
		fwnode_handle_put(fwspec->iommu_fwnode);
		kfree(fwspec);
2243
		dev_iommu_fwspec_set(dev, NULL);
R
Robin Murphy 已提交
2244 2245 2246 2247 2248 2249
	}
}
EXPORT_SYMBOL_GPL(iommu_fwspec_free);

int iommu_fwspec_add_ids(struct device *dev, u32 *ids, int num_ids)
{
2250
	struct iommu_fwspec *fwspec = dev_iommu_fwspec_get(dev);
R
Robin Murphy 已提交
2251 2252 2253 2254 2255 2256 2257 2258
	size_t size;
	int i;

	if (!fwspec)
		return -EINVAL;

	size = offsetof(struct iommu_fwspec, ids[fwspec->num_ids + num_ids]);
	if (size > sizeof(*fwspec)) {
2259
		fwspec = krealloc(fwspec, size, GFP_KERNEL);
R
Robin Murphy 已提交
2260 2261
		if (!fwspec)
			return -ENOMEM;
2262

2263
		dev_iommu_fwspec_set(dev, fwspec);
R
Robin Murphy 已提交
2264 2265 2266 2267 2268 2269 2270 2271 2272
	}

	for (i = 0; i < num_ids; i++)
		fwspec->ids[fwspec->num_ids + i] = ids[i];

	fwspec->num_ids += num_ids;
	return 0;
}
EXPORT_SYMBOL_GPL(iommu_fwspec_add_ids);
2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368

/*
 * Per device IOMMU features.
 */
bool iommu_dev_has_feature(struct device *dev, enum iommu_dev_features feat)
{
	const struct iommu_ops *ops = dev->bus->iommu_ops;

	if (ops && ops->dev_has_feat)
		return ops->dev_has_feat(dev, feat);

	return false;
}
EXPORT_SYMBOL_GPL(iommu_dev_has_feature);

int iommu_dev_enable_feature(struct device *dev, enum iommu_dev_features feat)
{
	const struct iommu_ops *ops = dev->bus->iommu_ops;

	if (ops && ops->dev_enable_feat)
		return ops->dev_enable_feat(dev, feat);

	return -ENODEV;
}
EXPORT_SYMBOL_GPL(iommu_dev_enable_feature);

/*
 * The device drivers should do the necessary cleanups before calling this.
 * For example, before disabling the aux-domain feature, the device driver
 * should detach all aux-domains. Otherwise, this will return -EBUSY.
 */
int iommu_dev_disable_feature(struct device *dev, enum iommu_dev_features feat)
{
	const struct iommu_ops *ops = dev->bus->iommu_ops;

	if (ops && ops->dev_disable_feat)
		return ops->dev_disable_feat(dev, feat);

	return -EBUSY;
}
EXPORT_SYMBOL_GPL(iommu_dev_disable_feature);

bool iommu_dev_feature_enabled(struct device *dev, enum iommu_dev_features feat)
{
	const struct iommu_ops *ops = dev->bus->iommu_ops;

	if (ops && ops->dev_feat_enabled)
		return ops->dev_feat_enabled(dev, feat);

	return false;
}
EXPORT_SYMBOL_GPL(iommu_dev_feature_enabled);

/*
 * Aux-domain specific attach/detach.
 *
 * Only works if iommu_dev_feature_enabled(dev, IOMMU_DEV_FEAT_AUX) returns
 * true. Also, as long as domains are attached to a device through this
 * interface, any tries to call iommu_attach_device() should fail
 * (iommu_detach_device() can't fail, so we fail when trying to re-attach).
 * This should make us safe against a device being attached to a guest as a
 * whole while there are still pasid users on it (aux and sva).
 */
int iommu_aux_attach_device(struct iommu_domain *domain, struct device *dev)
{
	int ret = -ENODEV;

	if (domain->ops->aux_attach_dev)
		ret = domain->ops->aux_attach_dev(domain, dev);

	if (!ret)
		trace_attach_device_to_domain(dev);

	return ret;
}
EXPORT_SYMBOL_GPL(iommu_aux_attach_device);

void iommu_aux_detach_device(struct iommu_domain *domain, struct device *dev)
{
	if (domain->ops->aux_detach_dev) {
		domain->ops->aux_detach_dev(domain, dev);
		trace_detach_device_from_domain(dev);
	}
}
EXPORT_SYMBOL_GPL(iommu_aux_detach_device);

int iommu_aux_get_pasid(struct iommu_domain *domain, struct device *dev)
{
	int ret = -ENODEV;

	if (domain->ops->aux_get_pasid)
		ret = domain->ops->aux_get_pasid(domain, dev);

	return ret;
}
EXPORT_SYMBOL_GPL(iommu_aux_get_pasid);
2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472

/**
 * iommu_sva_bind_device() - Bind a process address space to a device
 * @dev: the device
 * @mm: the mm to bind, caller must hold a reference to it
 *
 * Create a bond between device and address space, allowing the device to access
 * the mm using the returned PASID. If a bond already exists between @device and
 * @mm, it is returned and an additional reference is taken. Caller must call
 * iommu_sva_unbind_device() to release each reference.
 *
 * iommu_dev_enable_feature(dev, IOMMU_DEV_FEAT_SVA) must be called first, to
 * initialize the required SVA features.
 *
 * On error, returns an ERR_PTR value.
 */
struct iommu_sva *
iommu_sva_bind_device(struct device *dev, struct mm_struct *mm, void *drvdata)
{
	struct iommu_group *group;
	struct iommu_sva *handle = ERR_PTR(-EINVAL);
	const struct iommu_ops *ops = dev->bus->iommu_ops;

	if (!ops || !ops->sva_bind)
		return ERR_PTR(-ENODEV);

	group = iommu_group_get(dev);
	if (!group)
		return ERR_PTR(-ENODEV);

	/* Ensure device count and domain don't change while we're binding */
	mutex_lock(&group->mutex);

	/*
	 * To keep things simple, SVA currently doesn't support IOMMU groups
	 * with more than one device. Existing SVA-capable systems are not
	 * affected by the problems that required IOMMU groups (lack of ACS
	 * isolation, device ID aliasing and other hardware issues).
	 */
	if (iommu_group_device_count(group) != 1)
		goto out_unlock;

	handle = ops->sva_bind(dev, mm, drvdata);

out_unlock:
	mutex_unlock(&group->mutex);
	iommu_group_put(group);

	return handle;
}
EXPORT_SYMBOL_GPL(iommu_sva_bind_device);

/**
 * iommu_sva_unbind_device() - Remove a bond created with iommu_sva_bind_device
 * @handle: the handle returned by iommu_sva_bind_device()
 *
 * Put reference to a bond between device and address space. The device should
 * not be issuing any more transaction for this PASID. All outstanding page
 * requests for this PASID must have been flushed to the IOMMU.
 *
 * Returns 0 on success, or an error value
 */
void iommu_sva_unbind_device(struct iommu_sva *handle)
{
	struct iommu_group *group;
	struct device *dev = handle->dev;
	const struct iommu_ops *ops = dev->bus->iommu_ops;

	if (!ops || !ops->sva_unbind)
		return;

	group = iommu_group_get(dev);
	if (!group)
		return;

	mutex_lock(&group->mutex);
	ops->sva_unbind(handle);
	mutex_unlock(&group->mutex);

	iommu_group_put(group);
}
EXPORT_SYMBOL_GPL(iommu_sva_unbind_device);

int iommu_sva_set_ops(struct iommu_sva *handle,
		      const struct iommu_sva_ops *sva_ops)
{
	if (handle->ops && handle->ops != sva_ops)
		return -EEXIST;

	handle->ops = sva_ops;
	return 0;
}
EXPORT_SYMBOL_GPL(iommu_sva_set_ops);

int iommu_sva_get_pasid(struct iommu_sva *handle)
{
	const struct iommu_ops *ops = handle->dev->bus->iommu_ops;

	if (!ops || !ops->sva_get_pasid)
		return IOMMU_PASID_INVALID;

	return ops->sva_get_pasid(handle);
}
EXPORT_SYMBOL_GPL(iommu_sva_get_pasid);