[mirror_ubuntu-zesty-kernel.git] / drivers / iommu / s390-iommu.c

/*
 * IOMMU API for s390 PCI devices
 *
 * Copyright IBM Corp. 2015
 * Author(s): Gerald Schaefer <gerald.schaefer@de.ibm.com>
 */

#include <linux/pci.h>
#include <linux/iommu.h>
#include <linux/iommu-helper.h>
#include <linux/sizes.h>
#include <asm/pci_dma.h>

/*
 * Physically contiguous memory regions can be mapped with 4 KiB alignment,
 * we allow all page sizes that are an order of 4KiB (no special large page
 * support so far).
 */
#define S390_IOMMU_PGSIZES	(~0xFFFUL)

struct s390_domain {
	struct iommu_domain	domain;
	struct list_head	devices;
	unsigned long		*dma_table;
	spinlock_t		dma_table_lock;
	spinlock_t		list_lock;
};

struct s390_domain_device {
	struct list_head	list;
	struct zpci_dev		*zdev;
};

static struct s390_domain *to_s390_domain(struct iommu_domain *dom)
{
	return container_of(dom, struct s390_domain, domain);
}

static bool s390_iommu_capable(enum iommu_cap cap)
{
	switch (cap) {
	case IOMMU_CAP_CACHE_COHERENCY:
		return true;
	case IOMMU_CAP_INTR_REMAP:
		return true;
	default:
		return false;
	}
}

static struct iommu_domain *s390_domain_alloc(unsigned domain_type)
{
	struct s390_domain *s390_domain;

	if (domain_type != IOMMU_DOMAIN_UNMANAGED)
		return NULL;

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

	s390_domain->dma_table = dma_alloc_cpu_table();
	if (!s390_domain->dma_table) {
		kfree(s390_domain);
		return NULL;
	}

	spin_lock_init(&s390_domain->dma_table_lock);
	spin_lock_init(&s390_domain->list_lock);
	INIT_LIST_HEAD(&s390_domain->devices);

	return &s390_domain->domain;
}

static void s390_domain_free(struct iommu_domain *domain)
{
	struct s390_domain *s390_domain = to_s390_domain(domain);

	dma_cleanup_tables(s390_domain->dma_table);
	kfree(s390_domain);
}

static int s390_iommu_attach_device(struct iommu_domain *domain,
				    struct device *dev)
{
	struct s390_domain *s390_domain = to_s390_domain(domain);
	struct zpci_dev *zdev = to_pci_dev(dev)->sysdata;
	struct s390_domain_device *domain_device;
	unsigned long flags;
	int rc;

	if (!zdev)
		return -ENODEV;

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

	if (zdev->dma_table)
		zpci_dma_exit_device(zdev);

	zdev->dma_table = s390_domain->dma_table;
	rc = zpci_register_ioat(zdev, 0, zdev->start_dma, zdev->end_dma,
				(u64) zdev->dma_table);
	if (rc)
		goto out_restore;

	spin_lock_irqsave(&s390_domain->list_lock, flags);
	/* First device defines the DMA range limits */
	if (list_empty(&s390_domain->devices)) {
		domain->geometry.aperture_start = zdev->start_dma;
		domain->geometry.aperture_end = zdev->end_dma;
		domain->geometry.force_aperture = true;
	/* Allow only devices with identical DMA range limits */
	} else if (domain->geometry.aperture_start != zdev->start_dma ||
		   domain->geometry.aperture_end != zdev->end_dma) {
		rc = -EINVAL;
		spin_unlock_irqrestore(&s390_domain->list_lock, flags);
		goto out_restore;
	}
	domain_device->zdev = zdev;
	zdev->s390_domain = s390_domain;
	list_add(&domain_device->list, &s390_domain->devices);
	spin_unlock_irqrestore(&s390_domain->list_lock, flags);

	return 0;

out_restore:
	zpci_dma_init_device(zdev);
	kfree(domain_device);

	return rc;
}

static void s390_iommu_detach_device(struct iommu_domain *domain,
				     struct device *dev)
{
	struct s390_domain *s390_domain = to_s390_domain(domain);
	struct zpci_dev *zdev = to_pci_dev(dev)->sysdata;
	struct s390_domain_device *domain_device, *tmp;
	unsigned long flags;
	int found = 0;

	if (!zdev)
		return;

	spin_lock_irqsave(&s390_domain->list_lock, flags);
	list_for_each_entry_safe(domain_device, tmp, &s390_domain->devices,
				 list) {
		if (domain_device->zdev == zdev) {
			list_del(&domain_device->list);
			kfree(domain_device);
			found = 1;
			break;
		}
	}
	spin_unlock_irqrestore(&s390_domain->list_lock, flags);

	if (found) {
		zdev->s390_domain = NULL;
		zpci_unregister_ioat(zdev, 0);
		zpci_dma_init_device(zdev);
	}
}

static int s390_iommu_add_device(struct device *dev)
{
	struct iommu_group *group;
	int rc;

	group = iommu_group_get(dev);
	if (!group) {
		group = iommu_group_alloc();
		if (IS_ERR(group))
			return PTR_ERR(group);
	}

	rc = iommu_group_add_device(group, dev);
	iommu_group_put(group);

	return rc;
}

static void s390_iommu_remove_device(struct device *dev)
{
	struct zpci_dev *zdev = to_pci_dev(dev)->sysdata;
	struct iommu_domain *domain;

	/*
	 * This is a workaround for a scenario where the IOMMU API common code
	 * "forgets" to call the detach_dev callback: After binding a device
	 * to vfio-pci and completing the VFIO_SET_IOMMU ioctl (which triggers
	 * the attach_dev), removing the device via
	 * "echo 1 > /sys/bus/pci/devices/.../remove" won't trigger detach_dev,
	 * only remove_device will be called via the BUS_NOTIFY_REMOVED_DEVICE
	 * notifier.
	 *
	 * So let's call detach_dev from here if it hasn't been called before.
	 */
	if (zdev && zdev->s390_domain) {
		domain = iommu_get_domain_for_dev(dev);
		if (domain)
			s390_iommu_detach_device(domain, dev);
	}

	iommu_group_remove_device(dev);
}

static int s390_iommu_update_trans(struct s390_domain *s390_domain,
				   unsigned long pa, dma_addr_t dma_addr,
				   size_t size, int flags)
{
	struct s390_domain_device *domain_device;
	u8 *page_addr = (u8 *) (pa & PAGE_MASK);
	dma_addr_t start_dma_addr = dma_addr;
	unsigned long irq_flags, nr_pages, i;
	unsigned long *entry;
	int rc = 0;

	if (dma_addr < s390_domain->domain.geometry.aperture_start ||
	    dma_addr + size > s390_domain->domain.geometry.aperture_end)
		return -EINVAL;

	nr_pages = PAGE_ALIGN(size) >> PAGE_SHIFT;
	if (!nr_pages)
		return 0;

	spin_lock_irqsave(&s390_domain->dma_table_lock, irq_flags);
	for (i = 0; i < nr_pages; i++) {
		entry = dma_walk_cpu_trans(s390_domain->dma_table, dma_addr);
		if (!entry) {
			rc = -ENOMEM;
			goto undo_cpu_trans;
		}
		dma_update_cpu_trans(entry, page_addr, flags);
		page_addr += PAGE_SIZE;
		dma_addr += PAGE_SIZE;
	}

	spin_lock(&s390_domain->list_lock);
	list_for_each_entry(domain_device, &s390_domain->devices, list) {
		rc = zpci_refresh_trans((u64) domain_device->zdev->fh << 32,
					start_dma_addr, nr_pages * PAGE_SIZE);
		if (rc)
			break;
	}
	spin_unlock(&s390_domain->list_lock);

undo_cpu_trans:
	if (rc && ((flags & ZPCI_PTE_VALID_MASK) == ZPCI_PTE_VALID)) {
		flags = ZPCI_PTE_INVALID;
		while (i-- > 0) {
			page_addr -= PAGE_SIZE;
			dma_addr -= PAGE_SIZE;
			entry = dma_walk_cpu_trans(s390_domain->dma_table,
						   dma_addr);
			if (!entry)
				break;
			dma_update_cpu_trans(entry, page_addr, flags);
		}
	}
	spin_unlock_irqrestore(&s390_domain->dma_table_lock, irq_flags);

	return rc;
}

static int s390_iommu_map(struct iommu_domain *domain, unsigned long iova,
			  phys_addr_t paddr, size_t size, int prot)
{
	struct s390_domain *s390_domain = to_s390_domain(domain);
	int flags = ZPCI_PTE_VALID, rc = 0;

	if (!(prot & IOMMU_READ))
		return -EINVAL;

	if (!(prot & IOMMU_WRITE))
		flags |= ZPCI_TABLE_PROTECTED;

	rc = s390_iommu_update_trans(s390_domain, (unsigned long) paddr, iova,
				     size, flags);

	return rc;
}

static phys_addr_t s390_iommu_iova_to_phys(struct iommu_domain *domain,
					   dma_addr_t iova)
{
	struct s390_domain *s390_domain = to_s390_domain(domain);
	unsigned long *sto, *pto, *rto, flags;
	unsigned int rtx, sx, px;
	phys_addr_t phys = 0;

	if (iova < domain->geometry.aperture_start ||
	    iova > domain->geometry.aperture_end)
		return 0;

	rtx = calc_rtx(iova);
	sx = calc_sx(iova);
	px = calc_px(iova);
	rto = s390_domain->dma_table;

	spin_lock_irqsave(&s390_domain->dma_table_lock, flags);
	if (rto && reg_entry_isvalid(rto[rtx])) {
		sto = get_rt_sto(rto[rtx]);
		if (sto && reg_entry_isvalid(sto[sx])) {
			pto = get_st_pto(sto[sx]);
			if (pto && pt_entry_isvalid(pto[px]))
				phys = pto[px] & ZPCI_PTE_ADDR_MASK;
		}
	}
	spin_unlock_irqrestore(&s390_domain->dma_table_lock, flags);

	return phys;
}

static size_t s390_iommu_unmap(struct iommu_domain *domain,
			       unsigned long iova, size_t size)
{
	struct s390_domain *s390_domain = to_s390_domain(domain);
	int flags = ZPCI_PTE_INVALID;
	phys_addr_t paddr;
	int rc;

	paddr = s390_iommu_iova_to_phys(domain, iova);
	if (!paddr)
		return 0;

	rc = s390_iommu_update_trans(s390_domain, (unsigned long) paddr, iova,
				     size, flags);
	if (rc)
		return 0;

	return size;
}

static struct iommu_ops s390_iommu_ops = {
	.capable = s390_iommu_capable,
	.domain_alloc = s390_domain_alloc,
	.domain_free = s390_domain_free,
	.attach_dev = s390_iommu_attach_device,
	.detach_dev = s390_iommu_detach_device,
	.map = s390_iommu_map,
	.unmap = s390_iommu_unmap,
	.iova_to_phys = s390_iommu_iova_to_phys,
	.add_device = s390_iommu_add_device,
	.remove_device = s390_iommu_remove_device,
	.pgsize_bitmap = S390_IOMMU_PGSIZES,
};

static int __init s390_iommu_init(void)
{
	return bus_set_iommu(&pci_bus_type, &s390_iommu_ops);
}
subsys_initcall(s390_iommu_init);
Commit	Line	Data
8128f23c GS	1	/*
	2	* IOMMU API for s390 PCI devices
	3	*
	4	* Copyright IBM Corp. 2015
	5	* Author(s): Gerald Schaefer <gerald.schaefer@de.ibm.com>
	6	*/
	7
	8	#include <linux/pci.h>
	9	#include <linux/iommu.h>
	10	#include <linux/iommu-helper.h>
8128f23c GS	11	#include <linux/sizes.h>
	12	#include <asm/pci_dma.h>
	13
	14	/*
	15	* Physically contiguous memory regions can be mapped with 4 KiB alignment,
	16	* we allow all page sizes that are an order of 4KiB (no special large page
	17	* support so far).
	18	*/
	19	#define S390_IOMMU_PGSIZES (~0xFFFUL)
	20
	21	struct s390_domain {
	22	struct iommu_domain domain;
	23	struct list_head devices;
	24	unsigned long *dma_table;
	25	spinlock_t dma_table_lock;
	26	spinlock_t list_lock;
	27	};
	28
	29	struct s390_domain_device {
	30	struct list_head list;
	31	struct zpci_dev *zdev;
	32	};
	33
	34	static struct s390_domain to_s390_domain(struct iommu_domain dom)
	35	{
	36	return container_of(dom, struct s390_domain, domain);
	37	}
	38
	39	static bool s390_iommu_capable(enum iommu_cap cap)
	40	{
	41	switch (cap) {
	42	case IOMMU_CAP_CACHE_COHERENCY:
	43	return true;
	44	case IOMMU_CAP_INTR_REMAP:
	45	return true;
	46	default:
	47	return false;
	48	}
	49	}
	50
7cd75787	51	static struct iommu_domain *s390_domain_alloc(unsigned domain_type)
8128f23c GS	52	{
	53	struct s390_domain *s390_domain;
	54
	55	if (domain_type != IOMMU_DOMAIN_UNMANAGED)
	56	return NULL;
	57
	58	s390_domain = kzalloc(sizeof(*s390_domain), GFP_KERNEL);
	59	if (!s390_domain)
	60	return NULL;
	61
	62	s390_domain->dma_table = dma_alloc_cpu_table();
	63	if (!s390_domain->dma_table) {
	64	kfree(s390_domain);
	65	return NULL;
	66	}
	67
	68	spin_lock_init(&s390_domain->dma_table_lock);
	69	spin_lock_init(&s390_domain->list_lock);
	70	INIT_LIST_HEAD(&s390_domain->devices);
	71
	72	return &s390_domain->domain;
	73	}
	74
7cd75787	75	static void s390_domain_free(struct iommu_domain *domain)
8128f23c GS	76	{
	77	struct s390_domain *s390_domain = to_s390_domain(domain);
	78
	79	dma_cleanup_tables(s390_domain->dma_table);
	80	kfree(s390_domain);
	81	}
	82
	83	static int s390_iommu_attach_device(struct iommu_domain *domain,
	84	struct device *dev)
	85	{
	86	struct s390_domain *s390_domain = to_s390_domain(domain);
	87	struct zpci_dev *zdev = to_pci_dev(dev)->sysdata;
	88	struct s390_domain_device *domain_device;
	89	unsigned long flags;
	90	int rc;
	91
	92	if (!zdev)
	93	return -ENODEV;
	94
	95	domain_device = kzalloc(sizeof(*domain_device), GFP_KERNEL);
	96	if (!domain_device)
	97	return -ENOMEM;
	98
	99	if (zdev->dma_table)
	100	zpci_dma_exit_device(zdev);
	101
	102	zdev->dma_table = s390_domain->dma_table;
bb2b7ffb	103	rc = zpci_register_ioat(zdev, 0, zdev->start_dma, zdev->end_dma,
8128f23c GS	104	(u64) zdev->dma_table);
	105	if (rc)
	106	goto out_restore;
	107
	108	spin_lock_irqsave(&s390_domain->list_lock, flags);
	109	/* First device defines the DMA range limits */
	110	if (list_empty(&s390_domain->devices)) {
	111	domain->geometry.aperture_start = zdev->start_dma;
	112	domain->geometry.aperture_end = zdev->end_dma;
	113	domain->geometry.force_aperture = true;
	114	/* Allow only devices with identical DMA range limits */
	115	} else if (domain->geometry.aperture_start != zdev->start_dma \|\|
	116	domain->geometry.aperture_end != zdev->end_dma) {
	117	rc = -EINVAL;
	118	spin_unlock_irqrestore(&s390_domain->list_lock, flags);
	119	goto out_restore;
	120	}
	121	domain_device->zdev = zdev;
	122	zdev->s390_domain = s390_domain;
	123	list_add(&domain_device->list, &s390_domain->devices);
	124	spin_unlock_irqrestore(&s390_domain->list_lock, flags);
	125
	126	return 0;
	127
	128	out_restore:
	129	zpci_dma_init_device(zdev);
	130	kfree(domain_device);
	131
	132	return rc;
	133	}
	134
	135	static void s390_iommu_detach_device(struct iommu_domain *domain,
	136	struct device *dev)
	137	{
	138	struct s390_domain *s390_domain = to_s390_domain(domain);
	139	struct zpci_dev *zdev = to_pci_dev(dev)->sysdata;
	140	struct s390_domain_device domain_device, tmp;
	141	unsigned long flags;
	142	int found = 0;
	143
	144	if (!zdev)
	145	return;
	146
	147	spin_lock_irqsave(&s390_domain->list_lock, flags);
	148	list_for_each_entry_safe(domain_device, tmp, &s390_domain->devices,
	149	list) {
	150	if (domain_device->zdev == zdev) {
	151	list_del(&domain_device->list);
	152	kfree(domain_device);
	153	found = 1;
	154	break;
	155	}
	156	}
	157	spin_unlock_irqrestore(&s390_domain->list_lock, flags);
	158
	159	if (found) {
	160	zdev->s390_domain = NULL;
	161	zpci_unregister_ioat(zdev, 0);
	162	zpci_dma_init_device(zdev);
	163	}
	164	}
	165
	166	static int s390_iommu_add_device(struct device *dev)
	167	{
168	struct iommu_group *group;
169	int rc;
170
171	group = iommu_group_get(dev);
172	if (!group) {
173	group = iommu_group_alloc();
174	if (IS_ERR(group))
175	return PTR_ERR(group);
176	}
177
178	rc = iommu_group_add_device(group, dev);
179	iommu_group_put(group);
180
181	return rc;
182	}
183
184	static void s390_iommu_remove_device(struct device *dev)
185	{
186	struct zpci_dev *zdev = to_pci_dev(dev)->sysdata;
187	struct iommu_domain *domain;
188
189	/*
190	* This is a workaround for a scenario where the IOMMU API common code
191	* "forgets" to call the detach_dev callback: After binding a device
192	* to vfio-pci and completing the VFIO_SET_IOMMU ioctl (which triggers
193	* the attach_dev), removing the device via
194	* "echo 1 > /sys/bus/pci/devices/.../remove" won't trigger detach_dev,
195	* only remove_device will be called via the BUS_NOTIFY_REMOVED_DEVICE
196	* notifier.
197	*
198	* So let's call detach_dev from here if it hasn't been called before.
199	*/
200	if (zdev && zdev->s390_domain) {
201	domain = iommu_get_domain_for_dev(dev);
202	if (domain)
203	s390_iommu_detach_device(domain, dev);
204	}
205
206	iommu_group_remove_device(dev);
207	}
208
209	static int s390_iommu_update_trans(struct s390_domain *s390_domain,
210	unsigned long pa, dma_addr_t dma_addr,
211	size_t size, int flags)
212	{
213	struct s390_domain_device *domain_device;
214	u8 page_addr = (u8 ) (pa & PAGE_MASK);
215	dma_addr_t start_dma_addr = dma_addr;
216	unsigned long irq_flags, nr_pages, i;
66728eee	217	unsigned long *entry;
8128f23c GS	218	int rc = 0;
	219
	220	if (dma_addr < s390_domain->domain.geometry.aperture_start \|\|
	221	dma_addr + size > s390_domain->domain.geometry.aperture_end)
	222	return -EINVAL;
	223
	224	nr_pages = PAGE_ALIGN(size) >> PAGE_SHIFT;
	225	if (!nr_pages)
	226	return 0;
	227
	228	spin_lock_irqsave(&s390_domain->dma_table_lock, irq_flags);
	229	for (i = 0; i < nr_pages; i++) {
66728eee SO	230	entry = dma_walk_cpu_trans(s390_domain->dma_table, dma_addr);
	231	if (!entry) {
	232	rc = -ENOMEM;
	233	goto undo_cpu_trans;
	234	}
	235	dma_update_cpu_trans(entry, page_addr, flags);
8128f23c GS	236	page_addr += PAGE_SIZE;
	237	dma_addr += PAGE_SIZE;
	238	}
	239
	240	spin_lock(&s390_domain->list_lock);
	241	list_for_each_entry(domain_device, &s390_domain->devices, list) {
	242	rc = zpci_refresh_trans((u64) domain_device->zdev->fh << 32,
	243	start_dma_addr, nr_pages * PAGE_SIZE);
	244	if (rc)
	245	break;
	246	}
	247	spin_unlock(&s390_domain->list_lock);
66728eee SO	248
	249	undo_cpu_trans:
	250	if (rc && ((flags & ZPCI_PTE_VALID_MASK) == ZPCI_PTE_VALID)) {
	251	flags = ZPCI_PTE_INVALID;
	252	while (i-- > 0) {
	253	page_addr -= PAGE_SIZE;
	254	dma_addr -= PAGE_SIZE;
	255	entry = dma_walk_cpu_trans(s390_domain->dma_table,
	256	dma_addr);
	257	if (!entry)
	258	break;
	259	dma_update_cpu_trans(entry, page_addr, flags);
	260	}
	261	}
8128f23c GS	262	spin_unlock_irqrestore(&s390_domain->dma_table_lock, irq_flags);
	263
	264	return rc;
	265	}
	266
	267	static int s390_iommu_map(struct iommu_domain *domain, unsigned long iova,
	268	phys_addr_t paddr, size_t size, int prot)
	269	{
	270	struct s390_domain *s390_domain = to_s390_domain(domain);
	271	int flags = ZPCI_PTE_VALID, rc = 0;
	272
	273	if (!(prot & IOMMU_READ))
	274	return -EINVAL;
	275
	276	if (!(prot & IOMMU_WRITE))
	277	flags \|= ZPCI_TABLE_PROTECTED;
	278
	279	rc = s390_iommu_update_trans(s390_domain, (unsigned long) paddr, iova,
	280	size, flags);
	281
	282	return rc;
	283	}
	284
	285	static phys_addr_t s390_iommu_iova_to_phys(struct iommu_domain *domain,
	286	dma_addr_t iova)
	287	{
	288	struct s390_domain *s390_domain = to_s390_domain(domain);
	289	unsigned long sto, pto, *rto, flags;
	290	unsigned int rtx, sx, px;
	291	phys_addr_t phys = 0;
	292
	293	if (iova < domain->geometry.aperture_start \|\|
	294	iova > domain->geometry.aperture_end)
	295	return 0;
	296
	297	rtx = calc_rtx(iova);
	298	sx = calc_sx(iova);
	299	px = calc_px(iova);
	300	rto = s390_domain->dma_table;
	301
	302	spin_lock_irqsave(&s390_domain->dma_table_lock, flags);
	303	if (rto && reg_entry_isvalid(rto[rtx])) {
	304	sto = get_rt_sto(rto[rtx]);
	305	if (sto && reg_entry_isvalid(sto[sx])) {
	306	pto = get_st_pto(sto[sx]);
	307	if (pto && pt_entry_isvalid(pto[px]))
	308	phys = pto[px] & ZPCI_PTE_ADDR_MASK;
	309	}
	310	}
	311	spin_unlock_irqrestore(&s390_domain->dma_table_lock, flags);
	312
	313	return phys;
	314	}
	315
	316	static size_t s390_iommu_unmap(struct iommu_domain *domain,
	317	unsigned long iova, size_t size)
	318	{
	319	struct s390_domain *s390_domain = to_s390_domain(domain);
	320	int flags = ZPCI_PTE_INVALID;
	321	phys_addr_t paddr;
	322	int rc;
	323
	324	paddr = s390_iommu_iova_to_phys(domain, iova);
	325	if (!paddr)
326	return 0;
327
328	rc = s390_iommu_update_trans(s390_domain, (unsigned long) paddr, iova,
329	size, flags);
330	if (rc)
331	return 0;
332
333	return size;
334	}
335
336	static struct iommu_ops s390_iommu_ops = {
337	.capable = s390_iommu_capable,
338	.domain_alloc = s390_domain_alloc,
339	.domain_free = s390_domain_free,
340	.attach_dev = s390_iommu_attach_device,
341	.detach_dev = s390_iommu_detach_device,
342	.map = s390_iommu_map,
343	.unmap = s390_iommu_unmap,
344	.iova_to_phys = s390_iommu_iova_to_phys,
345	.add_device = s390_iommu_add_device,
346	.remove_device = s390_iommu_remove_device,
347	.pgsize_bitmap = S390_IOMMU_PGSIZES,
348	};
349
350	static int __init s390_iommu_init(void)
351	{
352	return bus_set_iommu(&pci_bus_type, &s390_iommu_ops);
353	}
354	subsys_initcall(s390_iommu_init);