Merge branch 'iommu/page-sizes' into x86/amd
[~shefty/rdma-dev.git] / drivers / iommu / iommu.c
1 /*
2  * Copyright (C) 2007-2008 Advanced Micro Devices, Inc.
3  * Author: Joerg Roedel <joerg.roedel@amd.com>
4  *
5  * This program is free software; you can redistribute it and/or modify it
6  * under the terms of the GNU General Public License version 2 as published
7  * by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
17  */
18
19 #define pr_fmt(fmt)    "%s: " fmt, __func__
20
21 #include <linux/device.h>
22 #include <linux/kernel.h>
23 #include <linux/bug.h>
24 #include <linux/types.h>
25 #include <linux/module.h>
26 #include <linux/slab.h>
27 #include <linux/errno.h>
28 #include <linux/iommu.h>
29
30 static void iommu_bus_init(struct bus_type *bus, struct iommu_ops *ops)
31 {
32 }
33
34 /**
35  * bus_set_iommu - set iommu-callbacks for the bus
36  * @bus: bus.
37  * @ops: the callbacks provided by the iommu-driver
38  *
39  * This function is called by an iommu driver to set the iommu methods
40  * used for a particular bus. Drivers for devices on that bus can use
41  * the iommu-api after these ops are registered.
42  * This special function is needed because IOMMUs are usually devices on
43  * the bus itself, so the iommu drivers are not initialized when the bus
44  * is set up. With this function the iommu-driver can set the iommu-ops
45  * afterwards.
46  */
47 int bus_set_iommu(struct bus_type *bus, struct iommu_ops *ops)
48 {
49         if (bus->iommu_ops != NULL)
50                 return -EBUSY;
51
52         bus->iommu_ops = ops;
53
54         /* Do IOMMU specific setup for this bus-type */
55         iommu_bus_init(bus, ops);
56
57         return 0;
58 }
59 EXPORT_SYMBOL_GPL(bus_set_iommu);
60
61 bool iommu_present(struct bus_type *bus)
62 {
63         return bus->iommu_ops != NULL;
64 }
65 EXPORT_SYMBOL_GPL(iommu_present);
66
67 /**
68  * iommu_set_fault_handler() - set a fault handler for an iommu domain
69  * @domain: iommu domain
70  * @handler: fault handler
71  *
72  * This function should be used by IOMMU users which want to be notified
73  * whenever an IOMMU fault happens.
74  *
75  * The fault handler itself should return 0 on success, and an appropriate
76  * error code otherwise.
77  */
78 void iommu_set_fault_handler(struct iommu_domain *domain,
79                                         iommu_fault_handler_t handler)
80 {
81         BUG_ON(!domain);
82
83         domain->handler = handler;
84 }
85 EXPORT_SYMBOL_GPL(iommu_set_fault_handler);
86
87 struct iommu_domain *iommu_domain_alloc(struct bus_type *bus)
88 {
89         struct iommu_domain *domain;
90         int ret;
91
92         if (bus == NULL || bus->iommu_ops == NULL)
93                 return NULL;
94
95         domain = kmalloc(sizeof(*domain), GFP_KERNEL);
96         if (!domain)
97                 return NULL;
98
99         domain->ops = bus->iommu_ops;
100
101         ret = domain->ops->domain_init(domain);
102         if (ret)
103                 goto out_free;
104
105         return domain;
106
107 out_free:
108         kfree(domain);
109
110         return NULL;
111 }
112 EXPORT_SYMBOL_GPL(iommu_domain_alloc);
113
114 void iommu_domain_free(struct iommu_domain *domain)
115 {
116         if (likely(domain->ops->domain_destroy != NULL))
117                 domain->ops->domain_destroy(domain);
118
119         kfree(domain);
120 }
121 EXPORT_SYMBOL_GPL(iommu_domain_free);
122
123 int iommu_attach_device(struct iommu_domain *domain, struct device *dev)
124 {
125         if (unlikely(domain->ops->attach_dev == NULL))
126                 return -ENODEV;
127
128         return domain->ops->attach_dev(domain, dev);
129 }
130 EXPORT_SYMBOL_GPL(iommu_attach_device);
131
132 void iommu_detach_device(struct iommu_domain *domain, struct device *dev)
133 {
134         if (unlikely(domain->ops->detach_dev == NULL))
135                 return;
136
137         domain->ops->detach_dev(domain, dev);
138 }
139 EXPORT_SYMBOL_GPL(iommu_detach_device);
140
141 phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain,
142                                unsigned long iova)
143 {
144         if (unlikely(domain->ops->iova_to_phys == NULL))
145                 return 0;
146
147         return domain->ops->iova_to_phys(domain, iova);
148 }
149 EXPORT_SYMBOL_GPL(iommu_iova_to_phys);
150
151 int iommu_domain_has_cap(struct iommu_domain *domain,
152                          unsigned long cap)
153 {
154         if (unlikely(domain->ops->domain_has_cap == NULL))
155                 return 0;
156
157         return domain->ops->domain_has_cap(domain, cap);
158 }
159 EXPORT_SYMBOL_GPL(iommu_domain_has_cap);
160
161 int iommu_map(struct iommu_domain *domain, unsigned long iova,
162               phys_addr_t paddr, size_t size, int prot)
163 {
164         unsigned long orig_iova = iova;
165         unsigned int min_pagesz;
166         size_t orig_size = size;
167         int ret = 0;
168
169         if (unlikely(domain->ops->map == NULL))
170                 return -ENODEV;
171
172         /* find out the minimum page size supported */
173         min_pagesz = 1 << __ffs(domain->ops->pgsize_bitmap);
174
175         /*
176          * both the virtual address and the physical one, as well as
177          * the size of the mapping, must be aligned (at least) to the
178          * size of the smallest page supported by the hardware
179          */
180         if (!IS_ALIGNED(iova | paddr | size, min_pagesz)) {
181                 pr_err("unaligned: iova 0x%lx pa 0x%lx size 0x%lx min_pagesz "
182                         "0x%x\n", iova, (unsigned long)paddr,
183                         (unsigned long)size, min_pagesz);
184                 return -EINVAL;
185         }
186
187         pr_debug("map: iova 0x%lx pa 0x%lx size 0x%lx\n", iova,
188                                 (unsigned long)paddr, (unsigned long)size);
189
190         while (size) {
191                 unsigned long pgsize, addr_merge = iova | paddr;
192                 unsigned int pgsize_idx;
193
194                 /* Max page size that still fits into 'size' */
195                 pgsize_idx = __fls(size);
196
197                 /* need to consider alignment requirements ? */
198                 if (likely(addr_merge)) {
199                         /* Max page size allowed by both iova and paddr */
200                         unsigned int align_pgsize_idx = __ffs(addr_merge);
201
202                         pgsize_idx = min(pgsize_idx, align_pgsize_idx);
203                 }
204
205                 /* build a mask of acceptable page sizes */
206                 pgsize = (1UL << (pgsize_idx + 1)) - 1;
207
208                 /* throw away page sizes not supported by the hardware */
209                 pgsize &= domain->ops->pgsize_bitmap;
210
211                 /* make sure we're still sane */
212                 BUG_ON(!pgsize);
213
214                 /* pick the biggest page */
215                 pgsize_idx = __fls(pgsize);
216                 pgsize = 1UL << pgsize_idx;
217
218                 pr_debug("mapping: iova 0x%lx pa 0x%lx pgsize %lu\n", iova,
219                                         (unsigned long)paddr, pgsize);
220
221                 ret = domain->ops->map(domain, iova, paddr, pgsize, prot);
222                 if (ret)
223                         break;
224
225                 iova += pgsize;
226                 paddr += pgsize;
227                 size -= pgsize;
228         }
229
230         /* unroll mapping in case something went wrong */
231         if (ret)
232                 iommu_unmap(domain, orig_iova, orig_size - size);
233
234         return ret;
235 }
236 EXPORT_SYMBOL_GPL(iommu_map);
237
238 size_t iommu_unmap(struct iommu_domain *domain, unsigned long iova, size_t size)
239 {
240         size_t unmapped_page, unmapped = 0;
241         unsigned int min_pagesz;
242
243         if (unlikely(domain->ops->unmap == NULL))
244                 return -ENODEV;
245
246         /* find out the minimum page size supported */
247         min_pagesz = 1 << __ffs(domain->ops->pgsize_bitmap);
248
249         /*
250          * The virtual address, as well as the size of the mapping, must be
251          * aligned (at least) to the size of the smallest page supported
252          * by the hardware
253          */
254         if (!IS_ALIGNED(iova | size, min_pagesz)) {
255                 pr_err("unaligned: iova 0x%lx size 0x%lx min_pagesz 0x%x\n",
256                                         iova, (unsigned long)size, min_pagesz);
257                 return -EINVAL;
258         }
259
260         pr_debug("unmap this: iova 0x%lx size 0x%lx\n", iova,
261                                                         (unsigned long)size);
262
263         /*
264          * Keep iterating until we either unmap 'size' bytes (or more)
265          * or we hit an area that isn't mapped.
266          */
267         while (unmapped < size) {
268                 size_t left = size - unmapped;
269
270                 unmapped_page = domain->ops->unmap(domain, iova, left);
271                 if (!unmapped_page)
272                         break;
273
274                 pr_debug("unmapped: iova 0x%lx size %lx\n", iova,
275                                         (unsigned long)unmapped_page);
276
277                 iova += unmapped_page;
278                 unmapped += unmapped_page;
279         }
280
281         return unmapped;
282 }
283 EXPORT_SYMBOL_GPL(iommu_unmap);