iommu.c 42.4 KB
Newer Older
1 2
/*
 * Copyright (C) 2007-2008 Advanced Micro Devices, Inc.
J
Joerg Roedel 已提交
3
 * Author: Joerg Roedel <jroedel@suse.de>
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published
 * by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 */

19
#define pr_fmt(fmt)    "iommu: " fmt
20

21
#include <linux/device.h>
22
#include <linux/kernel.h>
23 24
#include <linux/bug.h>
#include <linux/types.h>
25 26
#include <linux/module.h>
#include <linux/slab.h>
27 28
#include <linux/errno.h>
#include <linux/iommu.h>
A
Alex Williamson 已提交
29 30 31
#include <linux/idr.h>
#include <linux/notifier.h>
#include <linux/err.h>
32
#include <linux/pci.h>
33
#include <linux/bitops.h>
R
Robin Murphy 已提交
34
#include <linux/property.h>
35
#include <trace/events/iommu.h>
A
Alex Williamson 已提交
36 37

static struct kset *iommu_group_kset;
H
Heiner Kallweit 已提交
38
static DEFINE_IDA(iommu_group_ida);
A
Alex Williamson 已提交
39

40 41 42 43
struct iommu_callback_data {
	const struct iommu_ops *ops;
};

A
Alex Williamson 已提交
44 45 46 47 48 49 50 51 52 53
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;
54
	struct iommu_domain *default_domain;
55
	struct iommu_domain *domain;
A
Alex Williamson 已提交
56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73
};

struct iommu_device {
	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);
};

#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
static struct iommu_domain *__iommu_domain_alloc(struct bus_type *bus,
						 unsigned type);
82 83 84 85 86 87
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);
88

A
Alex Williamson 已提交
89 90
static ssize_t iommu_group_attr_show(struct kobject *kobj,
				     struct attribute *__attr, char *buf)
91
{
A
Alex Williamson 已提交
92 93 94
	struct iommu_group_attribute *attr = to_iommu_group_attr(__attr);
	struct iommu_group *group = to_iommu_group(kobj);
	ssize_t ret = -EIO;
95

A
Alex Williamson 已提交
96 97 98 99 100 101 102 103 104 105 106 107
	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;
108

A
Alex Williamson 已提交
109 110 111
	if (attr->store)
		ret = attr->store(group, buf, count);
	return ret;
112 113
}

A
Alex Williamson 已提交
114 115 116 117
static const struct sysfs_ops iommu_group_sysfs_ops = {
	.show = iommu_group_attr_show,
	.store = iommu_group_attr_store,
};
118

A
Alex Williamson 已提交
119 120 121 122
static int iommu_group_create_file(struct iommu_group *group,
				   struct iommu_group_attribute *attr)
{
	return sysfs_create_file(&group->kobj, &attr->attr);
123 124
}

A
Alex Williamson 已提交
125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141
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);
}

static IOMMU_GROUP_ATTR(name, S_IRUGO, iommu_group_show_name, NULL);

static void iommu_group_release(struct kobject *kobj)
{
	struct iommu_group *group = to_iommu_group(kobj);

142 143
	pr_debug("Releasing group %d\n", group->id);

A
Alex Williamson 已提交
144 145 146
	if (group->iommu_data_release)
		group->iommu_data_release(group->iommu_data);

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

149 150 151
	if (group->default_domain)
		iommu_domain_free(group->default_domain);

A
Alex Williamson 已提交
152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173
	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
 * @name: Optional name to associate with group, visible in sysfs
 *
 * 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)
174
{
A
Alex Williamson 已提交
175 176 177 178 179 180 181 182 183 184 185 186
	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);

187 188
	ret = ida_simple_get(&iommu_group_ida, 0, 0, GFP_KERNEL);
	if (ret < 0) {
A
Alex Williamson 已提交
189
		kfree(group);
190
		return ERR_PTR(ret);
A
Alex Williamson 已提交
191
	}
192
	group->id = ret;
193

A
Alex Williamson 已提交
194 195 196
	ret = kobject_init_and_add(&group->kobj, &iommu_group_ktype,
				   NULL, "%d", group->id);
	if (ret) {
197
		ida_simple_remove(&iommu_group_ida, group->id);
A
Alex Williamson 已提交
198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214
		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);

215 216
	pr_debug("Allocated group %d\n", group->id);

A
Alex Williamson 已提交
217 218 219 220
	return group;
}
EXPORT_SYMBOL_GPL(iommu_group_alloc);

221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249
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 已提交
250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275
/**
 * 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))
276
{
A
Alex Williamson 已提交
277 278 279 280
	group->iommu_data = iommu_data;
	group->iommu_data_release = release;
}
EXPORT_SYMBOL_GPL(iommu_group_set_iommudata);
281

A
Alex Williamson 已提交
282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311
/**
 * 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;
	}
312 313 314

	return 0;
}
A
Alex Williamson 已提交
315
EXPORT_SYMBOL_GPL(iommu_group_set_name);
316

317 318 319 320 321 322 323 324 325 326 327 328
static int iommu_group_create_direct_mappings(struct iommu_group *group,
					      struct device *dev)
{
	struct iommu_domain *domain = group->default_domain;
	struct iommu_dm_region *entry;
	struct list_head mappings;
	unsigned long pg_size;
	int ret = 0;

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

329
	BUG_ON(!domain->pgsize_bitmap);
330

331
	pg_size = 1UL << __ffs(domain->pgsize_bitmap);
332 333 334 335 336 337 338 339
	INIT_LIST_HEAD(&mappings);

	iommu_get_dm_regions(dev, &mappings);

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

340 341 342
		if (domain->ops->apply_dm_region)
			domain->ops->apply_dm_region(dev, domain, entry);

343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365
		start = ALIGN(entry->start, pg_size);
		end   = ALIGN(entry->start + entry->length, pg_size);

		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;
		}

	}

out:
	iommu_put_dm_regions(dev, &mappings);

	return ret;
}

A
Alex Williamson 已提交
366 367 368 369 370 371 372 373 374
/**
 * 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)
375
{
A
Alex Williamson 已提交
376 377 378 379 380 381 382 383
	int ret, i = 0;
	struct iommu_device *device;

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

	device->dev = dev;
384

A
Alex Williamson 已提交
385 386 387 388 389 390 391 392 393 394 395 396 397
	ret = sysfs_create_link(&dev->kobj, &group->kobj, "iommu_group");
	if (ret) {
		kfree(device);
		return ret;
	}

	device->name = kasprintf(GFP_KERNEL, "%s", kobject_name(&dev->kobj));
rename:
	if (!device->name) {
		sysfs_remove_link(&dev->kobj, "iommu_group");
		kfree(device);
		return -ENOMEM;
	}
398

A
Alex Williamson 已提交
399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421
	ret = sysfs_create_link_nowarn(group->devices_kobj,
				       &dev->kobj, device->name);
	if (ret) {
		kfree(device->name);
		if (ret == -EEXIST && i >= 0) {
			/*
			 * Account for the slim chance of collision
			 * and append an instance to the name.
			 */
			device->name = kasprintf(GFP_KERNEL, "%s.%d",
						 kobject_name(&dev->kobj), i++);
			goto rename;
		}

		sysfs_remove_link(&dev->kobj, "iommu_group");
		kfree(device);
		return ret;
	}

	kobject_get(group->devices_kobj);

	dev->iommu_group = group;

422 423
	iommu_group_create_direct_mappings(group, dev);

A
Alex Williamson 已提交
424 425
	mutex_lock(&group->mutex);
	list_add_tail(&device->list, &group->devices);
426 427
	if (group->domain)
		__iommu_attach_device(group->domain, dev);
A
Alex Williamson 已提交
428 429 430 431 432
	mutex_unlock(&group->mutex);

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

	trace_add_device_to_group(group->id, dev);
435 436 437

	pr_info("Adding device %s to group %d\n", dev_name(dev), group->id);

438 439
	return 0;
}
A
Alex Williamson 已提交
440
EXPORT_SYMBOL_GPL(iommu_group_add_device);
441

A
Alex Williamson 已提交
442 443 444 445 446 447 448 449 450 451 452 453
/**
 * 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;
	struct iommu_device *tmp_device, *device = NULL;

454 455
	pr_info("Removing device %s from group %d\n", dev_name(dev), group->id);

A
Alex Williamson 已提交
456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475
	/* 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");

476 477
	trace_remove_device_from_group(group->id, dev);

A
Alex Williamson 已提交
478 479 480 481 482 483 484
	kfree(device->name);
	kfree(device);
	dev->iommu_group = NULL;
	kobject_put(group->devices_kobj);
}
EXPORT_SYMBOL_GPL(iommu_group_remove_device);

485 486 487 488 489 490 491 492 493 494 495
static int iommu_group_device_count(struct iommu_group *group)
{
	struct iommu_device *entry;
	int ret = 0;

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

	return ret;
}

A
Alex Williamson 已提交
496 497 498 499 500 501 502 503 504 505 506
/**
 * 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.
 */
507 508
static int __iommu_group_for_each_dev(struct iommu_group *group, void *data,
				      int (*fn)(struct device *, void *))
A
Alex Williamson 已提交
509 510 511 512 513 514 515 516 517
{
	struct iommu_device *device;
	int ret = 0;

	list_for_each_entry(device, &group->devices, list) {
		ret = fn(device->dev, data);
		if (ret)
			break;
	}
518 519 520 521 522 523 524 525 526 527 528
	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 已提交
529
	mutex_unlock(&group->mutex);
530

A
Alex Williamson 已提交
531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553
	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);

554 555 556 557 558 559 560 561 562 563 564 565 566
/**
 * 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 已提交
567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621
/**
 * 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);

/**
 * 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);
622

623 624 625
static struct iommu_group *get_pci_alias_group(struct pci_dev *pdev,
					       unsigned long *devfns);

626 627 628 629 630 631 632 633 634 635
/*
 * 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)

636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667
/*
 * 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;
}

/*
668 669
 * Look for aliases to or from the given device for existing groups. DMA
 * aliases are only supported on the same bus, therefore the search
670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693
 * 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 */
694
		if (pci_devs_are_dma_aliases(pdev, tmp)) {
695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711
			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;
}

712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730
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;
}

731 732 733 734 735 736 737 738 739 740 741 742 743 744 745
/*
 * Generic device_group call-back function. It just allocates one
 * iommu-group per device.
 */
struct iommu_group *generic_device_group(struct device *dev)
{
	struct iommu_group *group;

	group = iommu_group_alloc();
	if (IS_ERR(group))
		return NULL;

	return group;
}

746 747 748 749
/*
 * Use standard PCI bus topology, isolation features, and DMA alias quirks
 * to find or create an IOMMU group for a device.
 */
750
struct iommu_group *pci_device_group(struct device *dev)
751
{
752
	struct pci_dev *pdev = to_pci_dev(dev);
753 754 755
	struct group_for_pci_data data;
	struct pci_bus *bus;
	struct iommu_group *group = NULL;
756
	u64 devfns[4] = { 0 };
757

758 759 760
	if (WARN_ON(!dev_is_pci(dev)))
		return ERR_PTR(-EINVAL);

761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792
	/*
	 * 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;
	}

	/*
793 794
	 * Look for existing groups on device aliases.  If we alias another
	 * device or another device aliases us, use the same group.
795
	 */
796 797 798
	group = get_pci_alias_group(pdev, (unsigned long *)devfns);
	if (group)
		return group;
799 800

	/*
801 802 803
	 * 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.
804
	 */
805 806 807
	group = get_pci_function_alias_group(pdev, (unsigned long *)devfns);
	if (group)
		return group;
808 809

	/* No shared group found, allocate new */
810
	group = iommu_group_alloc();
811 812 813
	if (IS_ERR(group))
		return NULL;

814
	return group;
815 816 817 818 819 820 821 822 823 824 825 826 827 828
}

/**
 * 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)
{
829
	const struct iommu_ops *ops = dev->bus->iommu_ops;
830
	struct iommu_group *group;
831 832 833 834 835 836
	int ret;

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

837
	group = ERR_PTR(-EINVAL);
838

839 840
	if (ops && ops->device_group)
		group = ops->device_group(dev);
841 842 843 844

	if (IS_ERR(group))
		return group;

845 846 847 848 849 850 851
	/*
	 * Try to allocate a default domain - needs support from the
	 * IOMMU driver.
	 */
	if (!group->default_domain) {
		group->default_domain = __iommu_domain_alloc(dev->bus,
							     IOMMU_DOMAIN_DMA);
852 853
		if (!group->domain)
			group->domain = group->default_domain;
854 855
	}

856 857 858 859 860 861 862 863 864
	ret = iommu_group_add_device(group, dev);
	if (ret) {
		iommu_group_put(group);
		return ERR_PTR(ret);
	}

	return group;
}

865 866 867 868 869
struct iommu_domain *iommu_group_default_domain(struct iommu_group *group)
{
	return group->default_domain;
}

A
Alex Williamson 已提交
870
static int add_iommu_group(struct device *dev, void *data)
871
{
872 873
	struct iommu_callback_data *cb = data;
	const struct iommu_ops *ops = cb->ops;
874
	int ret;
A
Alex Williamson 已提交
875 876

	if (!ops->add_device)
877
		return 0;
878

A
Alex Williamson 已提交
879 880
	WARN_ON(dev->iommu_group);

881 882 883 884 885 886 887 888 889 890 891
	ret = ops->add_device(dev);

	/*
	 * 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;
892 893
}

894 895 896 897 898 899 900
static int remove_iommu_group(struct device *dev, void *data)
{
	struct iommu_callback_data *cb = data;
	const struct iommu_ops *ops = cb->ops;

	if (ops->remove_device && dev->iommu_group)
		ops->remove_device(dev);
901 902 903 904

	return 0;
}

A
Alex Williamson 已提交
905 906
static int iommu_bus_notifier(struct notifier_block *nb,
			      unsigned long action, void *data)
907 908
{
	struct device *dev = data;
909
	const struct iommu_ops *ops = dev->bus->iommu_ops;
A
Alex Williamson 已提交
910 911 912 913 914 915 916 917 918 919
	struct iommu_group *group;
	unsigned long group_action = 0;

	/*
	 * 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) {
		if (ops->add_device)
			return ops->add_device(dev);
920
	} else if (action == BUS_NOTIFY_REMOVED_DEVICE) {
A
Alex Williamson 已提交
921 922 923 924 925
		if (ops->remove_device && dev->iommu_group) {
			ops->remove_device(dev);
			return 0;
		}
	}
926

A
Alex Williamson 已提交
927 928 929 930 931 932 933
	/*
	 * Remaining BUS_NOTIFYs get filtered and republished to the
	 * group, if anyone is listening
	 */
	group = iommu_group_get(dev);
	if (!group)
		return 0;
934

A
Alex Williamson 已提交
935 936 937 938 939 940 941 942 943 944 945 946 947 948
	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;
	}
949

A
Alex Williamson 已提交
950 951 952
	if (group_action)
		blocking_notifier_call_chain(&group->notifier,
					     group_action, dev);
953

A
Alex Williamson 已提交
954
	iommu_group_put(group);
955 956 957
	return 0;
}

M
Mark Salter 已提交
958
static int iommu_bus_init(struct bus_type *bus, const struct iommu_ops *ops)
959
{
M
Mark Salter 已提交
960 961
	int err;
	struct notifier_block *nb;
962 963 964 965
	struct iommu_callback_data cb = {
		.ops = ops,
	};

M
Mark Salter 已提交
966 967 968 969 970 971 972
	nb = kzalloc(sizeof(struct notifier_block), GFP_KERNEL);
	if (!nb)
		return -ENOMEM;

	nb->notifier_call = iommu_bus_notifier;

	err = bus_register_notifier(bus, nb);
973 974
	if (err)
		goto out_free;
975 976

	err = bus_for_each_dev(bus, NULL, &cb, add_iommu_group);
977 978 979
	if (err)
		goto out_err;

980 981

	return 0;
982 983 984 985 986 987 988 989 990 991

out_err:
	/* Clean up */
	bus_for_each_dev(bus, NULL, &cb, remove_iommu_group);
	bus_unregister_notifier(bus, nb);

out_free:
	kfree(nb);

	return err;
992
}
993

994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006
/**
 * 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.
 */
1007
int bus_set_iommu(struct bus_type *bus, const struct iommu_ops *ops)
1008
{
1009 1010
	int err;

1011 1012
	if (bus->iommu_ops != NULL)
		return -EBUSY;
1013

1014 1015 1016
	bus->iommu_ops = ops;

	/* Do IOMMU specific setup for this bus-type */
1017 1018 1019 1020 1021
	err = iommu_bus_init(bus, ops);
	if (err)
		bus->iommu_ops = NULL;

	return err;
1022
}
1023
EXPORT_SYMBOL_GPL(bus_set_iommu);
1024

1025
bool iommu_present(struct bus_type *bus)
1026
{
1027
	return bus->iommu_ops != NULL;
1028
}
1029
EXPORT_SYMBOL_GPL(iommu_present);
1030

1031 1032 1033 1034 1035 1036 1037 1038 1039
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);

1040 1041 1042 1043
/**
 * iommu_set_fault_handler() - set a fault handler for an iommu domain
 * @domain: iommu domain
 * @handler: fault handler
1044
 * @token: user data, will be passed back to the fault handler
1045 1046 1047 1048 1049 1050
 *
 * 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.
1051 1052
 */
void iommu_set_fault_handler(struct iommu_domain *domain,
1053 1054
					iommu_fault_handler_t handler,
					void *token)
1055 1056 1057 1058
{
	BUG_ON(!domain);

	domain->handler = handler;
1059
	domain->handler_token = token;
1060
}
1061
EXPORT_SYMBOL_GPL(iommu_set_fault_handler);
1062

1063 1064
static struct iommu_domain *__iommu_domain_alloc(struct bus_type *bus,
						 unsigned type)
1065 1066 1067
{
	struct iommu_domain *domain;

1068
	if (bus == NULL || bus->iommu_ops == NULL)
1069 1070
		return NULL;

1071
	domain = bus->iommu_ops->domain_alloc(type);
1072 1073 1074
	if (!domain)
		return NULL;

1075
	domain->ops  = bus->iommu_ops;
1076
	domain->type = type;
1077 1078
	/* Assume all sizes by default; the driver may override this later */
	domain->pgsize_bitmap  = bus->iommu_ops->pgsize_bitmap;
1079

1080 1081 1082
	return domain;
}

1083 1084 1085
struct iommu_domain *iommu_domain_alloc(struct bus_type *bus)
{
	return __iommu_domain_alloc(bus, IOMMU_DOMAIN_UNMANAGED);
1086 1087 1088 1089 1090
}
EXPORT_SYMBOL_GPL(iommu_domain_alloc);

void iommu_domain_free(struct iommu_domain *domain)
{
1091
	domain->ops->domain_free(domain);
1092 1093 1094
}
EXPORT_SYMBOL_GPL(iommu_domain_free);

1095 1096
static int __iommu_attach_device(struct iommu_domain *domain,
				 struct device *dev)
1097
{
1098
	int ret;
1099 1100 1101
	if (unlikely(domain->ops->attach_dev == NULL))
		return -ENODEV;

1102 1103 1104 1105
	ret = domain->ops->attach_dev(domain, dev);
	if (!ret)
		trace_attach_device_to_domain(dev);
	return ret;
1106
}
1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126

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

	group = iommu_group_get(dev);
	/* FIXME: Remove this when groups a mandatory for iommu drivers */
	if (group == NULL)
		return __iommu_attach_device(domain, dev);

	/*
	 * We have a group - lock it to make sure the device-count doesn't
	 * change while we are attaching
	 */
	mutex_lock(&group->mutex);
	ret = -EINVAL;
	if (iommu_group_device_count(group) != 1)
		goto out_unlock;

1127
	ret = __iommu_attach_group(domain, group);
1128 1129 1130 1131 1132 1133 1134

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

	return ret;
}
1135 1136
EXPORT_SYMBOL_GPL(iommu_attach_device);

1137 1138
static void __iommu_detach_device(struct iommu_domain *domain,
				  struct device *dev)
1139
{
1140 1141 1142 1143
	if (unlikely(domain->ops->detach_dev == NULL))
		return;

	domain->ops->detach_dev(domain, dev);
1144
	trace_detach_device_from_domain(dev);
1145
}
1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161

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

	group = iommu_group_get(dev);
	/* FIXME: Remove this when groups a mandatory for iommu drivers */
	if (group == NULL)
		return __iommu_detach_device(domain, dev);

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

1162
	__iommu_detach_group(domain, group);
1163 1164 1165 1166 1167

out_unlock:
	mutex_unlock(&group->mutex);
	iommu_group_put(group);
}
1168 1169
EXPORT_SYMBOL_GPL(iommu_detach_device);

1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186
struct iommu_domain *iommu_get_domain_for_dev(struct device *dev)
{
	struct iommu_domain *domain;
	struct iommu_group *group;

	group = iommu_group_get(dev);
	/* FIXME: Remove this when groups a mandatory for iommu drivers */
	if (group == NULL)
		return NULL;

	domain = group->domain;

	iommu_group_put(group);

	return domain;
}
EXPORT_SYMBOL_GPL(iommu_get_domain_for_dev);
1187

A
Alex Williamson 已提交
1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201
/*
 * IOMMU groups are really the natrual working unit of the IOMMU, but
 * 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;

1202
	return __iommu_attach_device(domain, dev);
A
Alex Williamson 已提交
1203 1204
}

1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218
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 已提交
1219 1220 1221 1222
}

int iommu_attach_group(struct iommu_domain *domain, struct iommu_group *group)
{
1223 1224 1225 1226 1227 1228 1229
	int ret;

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

	return ret;
A
Alex Williamson 已提交
1230 1231 1232 1233 1234 1235 1236
}
EXPORT_SYMBOL_GPL(iommu_attach_group);

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

1237
	__iommu_detach_device(domain, dev);
A
Alex Williamson 已提交
1238 1239 1240 1241

	return 0;
}

1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265
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 已提交
1266 1267
void iommu_detach_group(struct iommu_domain *domain, struct iommu_group *group)
{
1268 1269 1270
	mutex_lock(&group->mutex);
	__iommu_detach_group(domain, group);
	mutex_unlock(&group->mutex);
A
Alex Williamson 已提交
1271 1272 1273
}
EXPORT_SYMBOL_GPL(iommu_detach_group);

1274
phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain, dma_addr_t iova)
1275
{
1276 1277 1278 1279
	if (unlikely(domain->ops->iova_to_phys == NULL))
		return 0;

	return domain->ops->iova_to_phys(domain, iova);
1280 1281
}
EXPORT_SYMBOL_GPL(iommu_iova_to_phys);
S
Sheng Yang 已提交
1282

A
Alex Williamson 已提交
1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302
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 */
1303
	pgsize &= domain->pgsize_bitmap;
A
Alex Williamson 已提交
1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314

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

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

	return pgsize;
}

1315
int iommu_map(struct iommu_domain *domain, unsigned long iova,
1316
	      phys_addr_t paddr, size_t size, int prot)
1317
{
1318 1319 1320
	unsigned long orig_iova = iova;
	unsigned int min_pagesz;
	size_t orig_size = size;
1321
	phys_addr_t orig_paddr = paddr;
1322
	int ret = 0;
1323

1324
	if (unlikely(domain->ops->map == NULL ||
1325
		     domain->pgsize_bitmap == 0UL))
1326
		return -ENODEV;
1327

1328 1329 1330
	if (unlikely(!(domain->type & __IOMMU_DOMAIN_PAGING)))
		return -EINVAL;

1331
	/* find out the minimum page size supported */
1332
	min_pagesz = 1 << __ffs(domain->pgsize_bitmap);
1333 1334 1335 1336 1337 1338 1339

	/*
	 * 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)) {
1340
		pr_err("unaligned: iova 0x%lx pa %pa size 0x%zx min_pagesz 0x%x\n",
1341
		       iova, &paddr, size, min_pagesz);
1342 1343 1344
		return -EINVAL;
	}

1345
	pr_debug("map: iova 0x%lx pa %pa size 0x%zx\n", iova, &paddr, size);
1346 1347

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

1350
		pr_debug("mapping: iova 0x%lx pa %pa pgsize 0x%zx\n",
1351
			 iova, &paddr, pgsize);
1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364

		ret = domain->ops->map(domain, iova, paddr, pgsize, prot);
		if (ret)
			break;

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

	/* unroll mapping in case something went wrong */
	if (ret)
		iommu_unmap(domain, orig_iova, orig_size - size);
1365
	else
1366
		trace_map(orig_iova, orig_paddr, orig_size);
1367 1368

	return ret;
1369 1370 1371
}
EXPORT_SYMBOL_GPL(iommu_map);

1372
size_t iommu_unmap(struct iommu_domain *domain, unsigned long iova, size_t size)
1373
{
1374 1375
	size_t unmapped_page, unmapped = 0;
	unsigned int min_pagesz;
1376
	unsigned long orig_iova = iova;
1377

1378
	if (unlikely(domain->ops->unmap == NULL ||
1379
		     domain->pgsize_bitmap == 0UL))
1380 1381
		return -ENODEV;

1382 1383 1384
	if (unlikely(!(domain->type & __IOMMU_DOMAIN_PAGING)))
		return -EINVAL;

1385
	/* find out the minimum page size supported */
1386
	min_pagesz = 1 << __ffs(domain->pgsize_bitmap);
1387 1388 1389 1390 1391 1392 1393

	/*
	 * 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)) {
1394 1395
		pr_err("unaligned: iova 0x%lx size 0x%zx min_pagesz 0x%x\n",
		       iova, size, min_pagesz);
1396 1397 1398
		return -EINVAL;
	}

1399
	pr_debug("unmap this: iova 0x%lx size 0x%zx\n", iova, size);
1400 1401 1402 1403 1404 1405

	/*
	 * 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 已提交
1406
		size_t pgsize = iommu_pgsize(domain, iova, size - unmapped);
1407

A
Alex Williamson 已提交
1408
		unmapped_page = domain->ops->unmap(domain, iova, pgsize);
1409 1410 1411
		if (!unmapped_page)
			break;

1412 1413
		pr_debug("unmapped: iova 0x%lx size 0x%zx\n",
			 iova, unmapped_page);
1414 1415 1416 1417 1418

		iova += unmapped_page;
		unmapped += unmapped_page;
	}

1419
	trace_unmap(orig_iova, size, unmapped);
1420
	return unmapped;
1421 1422
}
EXPORT_SYMBOL_GPL(iommu_unmap);
1423

O
Olav Haugan 已提交
1424 1425 1426
size_t default_iommu_map_sg(struct iommu_domain *domain, unsigned long iova,
			 struct scatterlist *sg, unsigned int nents, int prot)
{
1427
	struct scatterlist *s;
O
Olav Haugan 已提交
1428
	size_t mapped = 0;
1429
	unsigned int i, min_pagesz;
1430
	int ret;
O
Olav Haugan 已提交
1431

1432
	if (unlikely(domain->pgsize_bitmap == 0UL))
1433
		return 0;
O
Olav Haugan 已提交
1434

1435
	min_pagesz = 1 << __ffs(domain->pgsize_bitmap);
1436 1437

	for_each_sg(sg, s, nents, i) {
D
Dan Williams 已提交
1438
		phys_addr_t phys = page_to_phys(sg_page(s)) + s->offset;
1439 1440 1441 1442 1443 1444 1445 1446

		/*
		 * We are mapping on IOMMU page boundaries, so offset within
		 * the page must be 0. However, the IOMMU may support pages
		 * smaller than PAGE_SIZE, so s->offset may still represent
		 * an offset of that boundary within the CPU page.
		 */
		if (!IS_ALIGNED(s->offset, min_pagesz))
1447 1448 1449 1450 1451 1452 1453
			goto out_err;

		ret = iommu_map(domain, iova + mapped, phys, s->length, prot);
		if (ret)
			goto out_err;

		mapped += s->length;
O
Olav Haugan 已提交
1454 1455 1456
	}

	return mapped;
1457 1458 1459 1460 1461 1462 1463

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

	return 0;

O
Olav Haugan 已提交
1464 1465
}
EXPORT_SYMBOL_GPL(default_iommu_map_sg);
1466 1467

int iommu_domain_window_enable(struct iommu_domain *domain, u32 wnd_nr,
1468
			       phys_addr_t paddr, u64 size, int prot)
1469 1470 1471 1472
{
	if (unlikely(domain->ops->domain_window_enable == NULL))
		return -ENODEV;

1473 1474
	return domain->ops->domain_window_enable(domain, wnd_nr, paddr, size,
						 prot);
1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486
}
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);

A
Alex Williamson 已提交
1487
static int __init iommu_init(void)
1488
{
A
Alex Williamson 已提交
1489 1490 1491 1492 1493
	iommu_group_kset = kset_create_and_add("iommu_groups",
					       NULL, kernel_kobj);
	BUG_ON(!iommu_group_kset);

	return 0;
1494
}
1495
core_initcall(iommu_init);
1496 1497 1498 1499

int iommu_domain_get_attr(struct iommu_domain *domain,
			  enum iommu_attr attr, void *data)
{
1500
	struct iommu_domain_geometry *geometry;
1501
	bool *paging;
1502
	int ret = 0;
1503
	u32 *count;
1504 1505 1506 1507 1508 1509

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

1510 1511 1512
		break;
	case DOMAIN_ATTR_PAGING:
		paging  = data;
1513
		*paging = (domain->pgsize_bitmap != 0UL);
1514 1515 1516 1517 1518 1519 1520 1521 1522
		break;
	case DOMAIN_ATTR_WINDOWS:
		count = data;

		if (domain->ops->domain_get_windows != NULL)
			*count = domain->ops->domain_get_windows(domain);
		else
			ret = -ENODEV;

1523 1524 1525 1526
		break;
	default:
		if (!domain->ops->domain_get_attr)
			return -EINVAL;
1527

1528 1529 1530 1531
		ret = domain->ops->domain_get_attr(domain, attr, data);
	}

	return ret;
1532 1533 1534 1535 1536 1537
}
EXPORT_SYMBOL_GPL(iommu_domain_get_attr);

int iommu_domain_set_attr(struct iommu_domain *domain,
			  enum iommu_attr attr, void *data)
{
1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548
	int ret = 0;
	u32 *count;

	switch (attr) {
	case DOMAIN_ATTR_WINDOWS:
		count = data;

		if (domain->ops->domain_set_windows != NULL)
			ret = domain->ops->domain_set_windows(domain, *count);
		else
			ret = -ENODEV;
1549

1550 1551 1552 1553 1554 1555 1556 1557 1558
		break;
	default:
		if (domain->ops->domain_set_attr == NULL)
			return -EINVAL;

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

	return ret;
1559
}
1560
EXPORT_SYMBOL_GPL(iommu_domain_set_attr);
1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576

void iommu_get_dm_regions(struct device *dev, struct list_head *list)
{
	const struct iommu_ops *ops = dev->bus->iommu_ops;

	if (ops && ops->get_dm_regions)
		ops->get_dm_regions(dev, list);
}

void iommu_put_dm_regions(struct device *dev, struct list_head *list)
{
	const struct iommu_ops *ops = dev->bus->iommu_ops;

	if (ops && ops->put_dm_regions)
		ops->put_dm_regions(dev, list);
}
1577 1578 1579 1580 1581 1582 1583 1584 1585 1586

/* Request that a device is direct mapped by the IOMMU */
int iommu_request_dm_for_dev(struct device *dev)
{
	struct iommu_domain *dm_domain;
	struct iommu_group *group;
	int ret;

	/* Device must already be in a group before calling this function */
	group = iommu_group_get_for_dev(dev);
1587 1588
	if (IS_ERR(group))
		return PTR_ERR(group);
1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629

	mutex_lock(&group->mutex);

	/* Check if the default domain is already direct mapped */
	ret = 0;
	if (group->default_domain &&
	    group->default_domain->type == IOMMU_DOMAIN_IDENTITY)
		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;
	dm_domain = __iommu_domain_alloc(dev->bus, IOMMU_DOMAIN_IDENTITY);
	if (!dm_domain)
		goto out;

	/* Attach the device to the domain */
	ret = __iommu_attach_group(dm_domain, group);
	if (ret) {
		iommu_domain_free(dm_domain);
		goto out;
	}

	/* Make the direct mapped domain the default for this group */
	if (group->default_domain)
		iommu_domain_free(group->default_domain);
	group->default_domain = dm_domain;

	pr_info("Using direct mapping for device %s\n", dev_name(dev));

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

	return ret;
}
R
Robin Murphy 已提交
1630

1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670
struct iommu_instance {
	struct list_head list;
	struct fwnode_handle *fwnode;
	const struct iommu_ops *ops;
};
static LIST_HEAD(iommu_instance_list);
static DEFINE_SPINLOCK(iommu_instance_lock);

void iommu_register_instance(struct fwnode_handle *fwnode,
			     const struct iommu_ops *ops)
{
	struct iommu_instance *iommu = kzalloc(sizeof(*iommu), GFP_KERNEL);

	if (WARN_ON(!iommu))
		return;

	of_node_get(to_of_node(fwnode));
	INIT_LIST_HEAD(&iommu->list);
	iommu->fwnode = fwnode;
	iommu->ops = ops;
	spin_lock(&iommu_instance_lock);
	list_add_tail(&iommu->list, &iommu_instance_list);
	spin_unlock(&iommu_instance_lock);
}

const struct iommu_ops *iommu_get_instance(struct fwnode_handle *fwnode)
{
	struct iommu_instance *instance;
	const struct iommu_ops *ops = NULL;

	spin_lock(&iommu_instance_lock);
	list_for_each_entry(instance, &iommu_instance_list, list)
		if (instance->fwnode == fwnode) {
			ops = instance->ops;
			break;
		}
	spin_unlock(&iommu_instance_lock);
	return ops;
}

R
Robin Murphy 已提交
1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726
int iommu_fwspec_init(struct device *dev, struct fwnode_handle *iommu_fwnode,
		      const struct iommu_ops *ops)
{
	struct iommu_fwspec *fwspec = dev->iommu_fwspec;

	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;
	dev->iommu_fwspec = fwspec;
	return 0;
}
EXPORT_SYMBOL_GPL(iommu_fwspec_init);

void iommu_fwspec_free(struct device *dev)
{
	struct iommu_fwspec *fwspec = dev->iommu_fwspec;

	if (fwspec) {
		fwnode_handle_put(fwspec->iommu_fwnode);
		kfree(fwspec);
		dev->iommu_fwspec = NULL;
	}
}
EXPORT_SYMBOL_GPL(iommu_fwspec_free);

int iommu_fwspec_add_ids(struct device *dev, u32 *ids, int num_ids)
{
	struct iommu_fwspec *fwspec = dev->iommu_fwspec;
	size_t size;
	int i;

	if (!fwspec)
		return -EINVAL;

	size = offsetof(struct iommu_fwspec, ids[fwspec->num_ids + num_ids]);
	if (size > sizeof(*fwspec)) {
		fwspec = krealloc(dev->iommu_fwspec, size, GFP_KERNEL);
		if (!fwspec)
			return -ENOMEM;
	}

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

	fwspec->num_ids += num_ids;
	dev->iommu_fwspec = fwspec;
	return 0;
}
EXPORT_SYMBOL_GPL(iommu_fwspec_add_ids);