Commit | Line | Data |
---|---|---|
45ae7cff WD |
1 | /* |
2 | * IOMMU API for ARM architected SMMU implementations. | |
3 | * | |
4 | * This program is free software; you can redistribute it and/or modify | |
5 | * it under the terms of the GNU General Public License version 2 as | |
6 | * published by the Free Software Foundation. | |
7 | * | |
8 | * This program is distributed in the hope that it will be useful, | |
9 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
10 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
11 | * GNU General Public License for more details. | |
12 | * | |
13 | * You should have received a copy of the GNU General Public License | |
14 | * along with this program; if not, write to the Free Software | |
15 | * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. | |
16 | * | |
17 | * Copyright (C) 2013 ARM Limited | |
18 | * | |
19 | * Author: Will Deacon <will.deacon@arm.com> | |
20 | * | |
21 | * This driver currently supports: | |
22 | * - SMMUv1 and v2 implementations | |
23 | * - Stream-matching and stream-indexing | |
24 | * - v7/v8 long-descriptor format | |
25 | * - Non-secure access to the SMMU | |
45ae7cff | 26 | * - Context fault reporting |
dc0eaa4e | 27 | * - Extended Stream ID (16 bit) |
45ae7cff WD |
28 | */ |
29 | ||
30 | #define pr_fmt(fmt) "arm-smmu: " fmt | |
31 | ||
d6fcd3b1 LP |
32 | #include <linux/acpi.h> |
33 | #include <linux/acpi_iort.h> | |
1f3d5ca4 | 34 | #include <linux/atomic.h> |
45ae7cff | 35 | #include <linux/delay.h> |
9adb9594 | 36 | #include <linux/dma-iommu.h> |
45ae7cff WD |
37 | #include <linux/dma-mapping.h> |
38 | #include <linux/err.h> | |
39 | #include <linux/interrupt.h> | |
40 | #include <linux/io.h> | |
f9a05f05 | 41 | #include <linux/io-64-nonatomic-hi-lo.h> |
45ae7cff | 42 | #include <linux/iommu.h> |
859a732e | 43 | #include <linux/iopoll.h> |
45ae7cff WD |
44 | #include <linux/module.h> |
45 | #include <linux/of.h> | |
bae2c2d4 | 46 | #include <linux/of_address.h> |
d6fc5d97 | 47 | #include <linux/of_device.h> |
adfec2e7 | 48 | #include <linux/of_iommu.h> |
a9a1b0b5 | 49 | #include <linux/pci.h> |
45ae7cff WD |
50 | #include <linux/platform_device.h> |
51 | #include <linux/slab.h> | |
52 | #include <linux/spinlock.h> | |
53 | ||
54 | #include <linux/amba/bus.h> | |
55 | ||
518f7136 | 56 | #include "io-pgtable.h" |
45ae7cff | 57 | |
45ae7cff WD |
58 | /* Maximum number of context banks per SMMU */ |
59 | #define ARM_SMMU_MAX_CBS 128 | |
60 | ||
45ae7cff WD |
61 | /* SMMU global address space */ |
62 | #define ARM_SMMU_GR0(smmu) ((smmu)->base) | |
c757e852 | 63 | #define ARM_SMMU_GR1(smmu) ((smmu)->base + (1 << (smmu)->pgshift)) |
45ae7cff | 64 | |
3a5df8ff AH |
65 | /* |
66 | * SMMU global address space with conditional offset to access secure | |
67 | * aliases of non-secure registers (e.g. nsCR0: 0x400, nsGFSR: 0x448, | |
68 | * nsGFSYNR0: 0x450) | |
69 | */ | |
70 | #define ARM_SMMU_GR0_NS(smmu) \ | |
71 | ((smmu)->base + \ | |
72 | ((smmu->options & ARM_SMMU_OPT_SECURE_CFG_ACCESS) \ | |
73 | ? 0x400 : 0)) | |
74 | ||
f9a05f05 RM |
75 | /* |
76 | * Some 64-bit registers only make sense to write atomically, but in such | |
77 | * cases all the data relevant to AArch32 formats lies within the lower word, | |
78 | * therefore this actually makes more sense than it might first appear. | |
79 | */ | |
668b4ada | 80 | #ifdef CONFIG_64BIT |
f9a05f05 | 81 | #define smmu_write_atomic_lq writeq_relaxed |
668b4ada | 82 | #else |
f9a05f05 | 83 | #define smmu_write_atomic_lq writel_relaxed |
668b4ada TC |
84 | #endif |
85 | ||
45ae7cff WD |
86 | /* Configuration registers */ |
87 | #define ARM_SMMU_GR0_sCR0 0x0 | |
88 | #define sCR0_CLIENTPD (1 << 0) | |
89 | #define sCR0_GFRE (1 << 1) | |
90 | #define sCR0_GFIE (1 << 2) | |
dc0eaa4e | 91 | #define sCR0_EXIDENABLE (1 << 3) |
45ae7cff WD |
92 | #define sCR0_GCFGFRE (1 << 4) |
93 | #define sCR0_GCFGFIE (1 << 5) | |
94 | #define sCR0_USFCFG (1 << 10) | |
95 | #define sCR0_VMIDPNE (1 << 11) | |
96 | #define sCR0_PTM (1 << 12) | |
97 | #define sCR0_FB (1 << 13) | |
4e3e9b69 | 98 | #define sCR0_VMID16EN (1 << 31) |
45ae7cff WD |
99 | #define sCR0_BSU_SHIFT 14 |
100 | #define sCR0_BSU_MASK 0x3 | |
101 | ||
3ca3712a PF |
102 | /* Auxiliary Configuration register */ |
103 | #define ARM_SMMU_GR0_sACR 0x10 | |
104 | ||
45ae7cff WD |
105 | /* Identification registers */ |
106 | #define ARM_SMMU_GR0_ID0 0x20 | |
107 | #define ARM_SMMU_GR0_ID1 0x24 | |
108 | #define ARM_SMMU_GR0_ID2 0x28 | |
109 | #define ARM_SMMU_GR0_ID3 0x2c | |
110 | #define ARM_SMMU_GR0_ID4 0x30 | |
111 | #define ARM_SMMU_GR0_ID5 0x34 | |
112 | #define ARM_SMMU_GR0_ID6 0x38 | |
113 | #define ARM_SMMU_GR0_ID7 0x3c | |
114 | #define ARM_SMMU_GR0_sGFSR 0x48 | |
115 | #define ARM_SMMU_GR0_sGFSYNR0 0x50 | |
116 | #define ARM_SMMU_GR0_sGFSYNR1 0x54 | |
117 | #define ARM_SMMU_GR0_sGFSYNR2 0x58 | |
45ae7cff WD |
118 | |
119 | #define ID0_S1TS (1 << 30) | |
120 | #define ID0_S2TS (1 << 29) | |
121 | #define ID0_NTS (1 << 28) | |
122 | #define ID0_SMS (1 << 27) | |
859a732e | 123 | #define ID0_ATOSNS (1 << 26) |
7602b871 RM |
124 | #define ID0_PTFS_NO_AARCH32 (1 << 25) |
125 | #define ID0_PTFS_NO_AARCH32S (1 << 24) | |
45ae7cff WD |
126 | #define ID0_CTTW (1 << 14) |
127 | #define ID0_NUMIRPT_SHIFT 16 | |
128 | #define ID0_NUMIRPT_MASK 0xff | |
3c8766d0 OH |
129 | #define ID0_NUMSIDB_SHIFT 9 |
130 | #define ID0_NUMSIDB_MASK 0xf | |
dc0eaa4e | 131 | #define ID0_EXIDS (1 << 8) |
45ae7cff WD |
132 | #define ID0_NUMSMRG_SHIFT 0 |
133 | #define ID0_NUMSMRG_MASK 0xff | |
134 | ||
135 | #define ID1_PAGESIZE (1 << 31) | |
136 | #define ID1_NUMPAGENDXB_SHIFT 28 | |
137 | #define ID1_NUMPAGENDXB_MASK 7 | |
138 | #define ID1_NUMS2CB_SHIFT 16 | |
139 | #define ID1_NUMS2CB_MASK 0xff | |
140 | #define ID1_NUMCB_SHIFT 0 | |
141 | #define ID1_NUMCB_MASK 0xff | |
142 | ||
143 | #define ID2_OAS_SHIFT 4 | |
144 | #define ID2_OAS_MASK 0xf | |
145 | #define ID2_IAS_SHIFT 0 | |
146 | #define ID2_IAS_MASK 0xf | |
147 | #define ID2_UBS_SHIFT 8 | |
148 | #define ID2_UBS_MASK 0xf | |
149 | #define ID2_PTFS_4K (1 << 12) | |
150 | #define ID2_PTFS_16K (1 << 13) | |
151 | #define ID2_PTFS_64K (1 << 14) | |
4e3e9b69 | 152 | #define ID2_VMID16 (1 << 15) |
45ae7cff | 153 | |
3ca3712a PF |
154 | #define ID7_MAJOR_SHIFT 4 |
155 | #define ID7_MAJOR_MASK 0xf | |
45ae7cff | 156 | |
45ae7cff | 157 | /* Global TLB invalidation */ |
45ae7cff WD |
158 | #define ARM_SMMU_GR0_TLBIVMID 0x64 |
159 | #define ARM_SMMU_GR0_TLBIALLNSNH 0x68 | |
160 | #define ARM_SMMU_GR0_TLBIALLH 0x6c | |
161 | #define ARM_SMMU_GR0_sTLBGSYNC 0x70 | |
162 | #define ARM_SMMU_GR0_sTLBGSTATUS 0x74 | |
163 | #define sTLBGSTATUS_GSACTIVE (1 << 0) | |
164 | #define TLB_LOOP_TIMEOUT 1000000 /* 1s! */ | |
8513c893 | 165 | #define TLB_SPIN_COUNT 10 |
45ae7cff WD |
166 | |
167 | /* Stream mapping registers */ | |
168 | #define ARM_SMMU_GR0_SMR(n) (0x800 + ((n) << 2)) | |
169 | #define SMR_VALID (1 << 31) | |
170 | #define SMR_MASK_SHIFT 16 | |
45ae7cff | 171 | #define SMR_ID_SHIFT 0 |
45ae7cff WD |
172 | |
173 | #define ARM_SMMU_GR0_S2CR(n) (0xc00 + ((n) << 2)) | |
174 | #define S2CR_CBNDX_SHIFT 0 | |
175 | #define S2CR_CBNDX_MASK 0xff | |
dc0eaa4e | 176 | #define S2CR_EXIDVALID (1 << 10) |
45ae7cff WD |
177 | #define S2CR_TYPE_SHIFT 16 |
178 | #define S2CR_TYPE_MASK 0x3 | |
8e8b203e RM |
179 | enum arm_smmu_s2cr_type { |
180 | S2CR_TYPE_TRANS, | |
181 | S2CR_TYPE_BYPASS, | |
182 | S2CR_TYPE_FAULT, | |
183 | }; | |
45ae7cff | 184 | |
d346180e | 185 | #define S2CR_PRIVCFG_SHIFT 24 |
8e8b203e RM |
186 | #define S2CR_PRIVCFG_MASK 0x3 |
187 | enum arm_smmu_s2cr_privcfg { | |
188 | S2CR_PRIVCFG_DEFAULT, | |
189 | S2CR_PRIVCFG_DIPAN, | |
190 | S2CR_PRIVCFG_UNPRIV, | |
191 | S2CR_PRIVCFG_PRIV, | |
192 | }; | |
d346180e | 193 | |
45ae7cff WD |
194 | /* Context bank attribute registers */ |
195 | #define ARM_SMMU_GR1_CBAR(n) (0x0 + ((n) << 2)) | |
196 | #define CBAR_VMID_SHIFT 0 | |
197 | #define CBAR_VMID_MASK 0xff | |
57ca90f6 WD |
198 | #define CBAR_S1_BPSHCFG_SHIFT 8 |
199 | #define CBAR_S1_BPSHCFG_MASK 3 | |
200 | #define CBAR_S1_BPSHCFG_NSH 3 | |
45ae7cff WD |
201 | #define CBAR_S1_MEMATTR_SHIFT 12 |
202 | #define CBAR_S1_MEMATTR_MASK 0xf | |
203 | #define CBAR_S1_MEMATTR_WB 0xf | |
204 | #define CBAR_TYPE_SHIFT 16 | |
205 | #define CBAR_TYPE_MASK 0x3 | |
206 | #define CBAR_TYPE_S2_TRANS (0 << CBAR_TYPE_SHIFT) | |
207 | #define CBAR_TYPE_S1_TRANS_S2_BYPASS (1 << CBAR_TYPE_SHIFT) | |
208 | #define CBAR_TYPE_S1_TRANS_S2_FAULT (2 << CBAR_TYPE_SHIFT) | |
209 | #define CBAR_TYPE_S1_TRANS_S2_TRANS (3 << CBAR_TYPE_SHIFT) | |
210 | #define CBAR_IRPTNDX_SHIFT 24 | |
211 | #define CBAR_IRPTNDX_MASK 0xff | |
212 | ||
213 | #define ARM_SMMU_GR1_CBA2R(n) (0x800 + ((n) << 2)) | |
214 | #define CBA2R_RW64_32BIT (0 << 0) | |
215 | #define CBA2R_RW64_64BIT (1 << 0) | |
4e3e9b69 TC |
216 | #define CBA2R_VMID_SHIFT 16 |
217 | #define CBA2R_VMID_MASK 0xffff | |
45ae7cff WD |
218 | |
219 | /* Translation context bank */ | |
452107c7 | 220 | #define ARM_SMMU_CB(smmu, n) ((smmu)->cb_base + ((n) << (smmu)->pgshift)) |
45ae7cff WD |
221 | |
222 | #define ARM_SMMU_CB_SCTLR 0x0 | |
f0cfffc4 | 223 | #define ARM_SMMU_CB_ACTLR 0x4 |
45ae7cff WD |
224 | #define ARM_SMMU_CB_RESUME 0x8 |
225 | #define ARM_SMMU_CB_TTBCR2 0x10 | |
668b4ada TC |
226 | #define ARM_SMMU_CB_TTBR0 0x20 |
227 | #define ARM_SMMU_CB_TTBR1 0x28 | |
45ae7cff | 228 | #define ARM_SMMU_CB_TTBCR 0x30 |
6070529b | 229 | #define ARM_SMMU_CB_CONTEXTIDR 0x34 |
45ae7cff | 230 | #define ARM_SMMU_CB_S1_MAIR0 0x38 |
518f7136 | 231 | #define ARM_SMMU_CB_S1_MAIR1 0x3c |
f9a05f05 | 232 | #define ARM_SMMU_CB_PAR 0x50 |
45ae7cff | 233 | #define ARM_SMMU_CB_FSR 0x58 |
f9a05f05 | 234 | #define ARM_SMMU_CB_FAR 0x60 |
45ae7cff | 235 | #define ARM_SMMU_CB_FSYNR0 0x68 |
518f7136 | 236 | #define ARM_SMMU_CB_S1_TLBIVA 0x600 |
1463fe44 | 237 | #define ARM_SMMU_CB_S1_TLBIASID 0x610 |
518f7136 WD |
238 | #define ARM_SMMU_CB_S1_TLBIVAL 0x620 |
239 | #define ARM_SMMU_CB_S2_TLBIIPAS2 0x630 | |
240 | #define ARM_SMMU_CB_S2_TLBIIPAS2L 0x638 | |
11febfca RM |
241 | #define ARM_SMMU_CB_TLBSYNC 0x7f0 |
242 | #define ARM_SMMU_CB_TLBSTATUS 0x7f4 | |
661d962f | 243 | #define ARM_SMMU_CB_ATS1PR 0x800 |
859a732e | 244 | #define ARM_SMMU_CB_ATSR 0x8f0 |
45ae7cff WD |
245 | |
246 | #define SCTLR_S1_ASIDPNE (1 << 12) | |
247 | #define SCTLR_CFCFG (1 << 7) | |
248 | #define SCTLR_CFIE (1 << 6) | |
249 | #define SCTLR_CFRE (1 << 5) | |
250 | #define SCTLR_E (1 << 4) | |
251 | #define SCTLR_AFE (1 << 2) | |
252 | #define SCTLR_TRE (1 << 1) | |
253 | #define SCTLR_M (1 << 0) | |
45ae7cff | 254 | |
f0cfffc4 RM |
255 | #define ARM_MMU500_ACTLR_CPRE (1 << 1) |
256 | ||
3ca3712a | 257 | #define ARM_MMU500_ACR_CACHE_LOCK (1 << 26) |
6eb18d4a | 258 | #define ARM_MMU500_ACR_SMTNMB_TLBEN (1 << 8) |
3ca3712a | 259 | |
859a732e MH |
260 | #define CB_PAR_F (1 << 0) |
261 | ||
262 | #define ATSR_ACTIVE (1 << 0) | |
263 | ||
45ae7cff WD |
264 | #define RESUME_RETRY (0 << 0) |
265 | #define RESUME_TERMINATE (1 << 0) | |
266 | ||
45ae7cff | 267 | #define TTBCR2_SEP_SHIFT 15 |
5dc5616e | 268 | #define TTBCR2_SEP_UPSTREAM (0x7 << TTBCR2_SEP_SHIFT) |
3677a649 | 269 | #define TTBCR2_AS (1 << 4) |
45ae7cff | 270 | |
668b4ada | 271 | #define TTBRn_ASID_SHIFT 48 |
45ae7cff WD |
272 | |
273 | #define FSR_MULTI (1 << 31) | |
274 | #define FSR_SS (1 << 30) | |
275 | #define FSR_UUT (1 << 8) | |
276 | #define FSR_ASF (1 << 7) | |
277 | #define FSR_TLBLKF (1 << 6) | |
278 | #define FSR_TLBMCF (1 << 5) | |
279 | #define FSR_EF (1 << 4) | |
280 | #define FSR_PF (1 << 3) | |
281 | #define FSR_AFF (1 << 2) | |
282 | #define FSR_TF (1 << 1) | |
283 | ||
2907320d MH |
284 | #define FSR_IGN (FSR_AFF | FSR_ASF | \ |
285 | FSR_TLBMCF | FSR_TLBLKF) | |
286 | #define FSR_FAULT (FSR_MULTI | FSR_SS | FSR_UUT | \ | |
adaba320 | 287 | FSR_EF | FSR_PF | FSR_TF | FSR_IGN) |
45ae7cff WD |
288 | |
289 | #define FSYNR0_WNR (1 << 4) | |
290 | ||
f3ebee80 EA |
291 | #define MSI_IOVA_BASE 0x8000000 |
292 | #define MSI_IOVA_LENGTH 0x100000 | |
293 | ||
4cf740b0 | 294 | static int force_stage; |
25a1c96c | 295 | module_param(force_stage, int, S_IRUGO); |
4cf740b0 WD |
296 | MODULE_PARM_DESC(force_stage, |
297 | "Force SMMU mappings to be installed at a particular stage of translation. A value of '1' or '2' forces the corresponding stage. All other values are ignored (i.e. no stage is forced). Note that selecting a specific stage will disable support for nested translation."); | |
25a1c96c RM |
298 | static bool disable_bypass; |
299 | module_param(disable_bypass, bool, S_IRUGO); | |
300 | MODULE_PARM_DESC(disable_bypass, | |
301 | "Disable bypass streams such that incoming transactions from devices that are not attached to an iommu domain will report an abort back to the device and will not be allowed to pass through the SMMU."); | |
4cf740b0 | 302 | |
09360403 | 303 | enum arm_smmu_arch_version { |
b7862e35 RM |
304 | ARM_SMMU_V1, |
305 | ARM_SMMU_V1_64K, | |
09360403 RM |
306 | ARM_SMMU_V2, |
307 | }; | |
308 | ||
67b65a3f RM |
309 | enum arm_smmu_implementation { |
310 | GENERIC_SMMU, | |
f0cfffc4 | 311 | ARM_MMU500, |
e086d912 | 312 | CAVIUM_SMMUV2, |
67b65a3f RM |
313 | }; |
314 | ||
8e8b203e | 315 | struct arm_smmu_s2cr { |
588888a7 RM |
316 | struct iommu_group *group; |
317 | int count; | |
8e8b203e RM |
318 | enum arm_smmu_s2cr_type type; |
319 | enum arm_smmu_s2cr_privcfg privcfg; | |
320 | u8 cbndx; | |
321 | }; | |
322 | ||
323 | #define s2cr_init_val (struct arm_smmu_s2cr){ \ | |
324 | .type = disable_bypass ? S2CR_TYPE_FAULT : S2CR_TYPE_BYPASS, \ | |
325 | } | |
326 | ||
45ae7cff | 327 | struct arm_smmu_smr { |
45ae7cff WD |
328 | u16 mask; |
329 | u16 id; | |
1f3d5ca4 | 330 | bool valid; |
45ae7cff WD |
331 | }; |
332 | ||
a9a1b0b5 | 333 | struct arm_smmu_master_cfg { |
f80cd885 | 334 | struct arm_smmu_device *smmu; |
adfec2e7 | 335 | s16 smendx[]; |
45ae7cff | 336 | }; |
1f3d5ca4 | 337 | #define INVALID_SMENDX -1 |
adfec2e7 RM |
338 | #define __fwspec_cfg(fw) ((struct arm_smmu_master_cfg *)fw->iommu_priv) |
339 | #define fwspec_smmu(fw) (__fwspec_cfg(fw)->smmu) | |
8c82d6ec RM |
340 | #define fwspec_smendx(fw, i) \ |
341 | (i >= fw->num_ids ? INVALID_SMENDX : __fwspec_cfg(fw)->smendx[i]) | |
adfec2e7 | 342 | #define for_each_cfg_sme(fw, i, idx) \ |
8c82d6ec | 343 | for (i = 0; idx = fwspec_smendx(fw, i), i < fw->num_ids; ++i) |
45ae7cff WD |
344 | |
345 | struct arm_smmu_device { | |
346 | struct device *dev; | |
45ae7cff WD |
347 | |
348 | void __iomem *base; | |
452107c7 | 349 | void __iomem *cb_base; |
c757e852 | 350 | unsigned long pgshift; |
45ae7cff WD |
351 | |
352 | #define ARM_SMMU_FEAT_COHERENT_WALK (1 << 0) | |
353 | #define ARM_SMMU_FEAT_STREAM_MATCH (1 << 1) | |
354 | #define ARM_SMMU_FEAT_TRANS_S1 (1 << 2) | |
355 | #define ARM_SMMU_FEAT_TRANS_S2 (1 << 3) | |
356 | #define ARM_SMMU_FEAT_TRANS_NESTED (1 << 4) | |
859a732e | 357 | #define ARM_SMMU_FEAT_TRANS_OPS (1 << 5) |
4e3e9b69 | 358 | #define ARM_SMMU_FEAT_VMID16 (1 << 6) |
7602b871 RM |
359 | #define ARM_SMMU_FEAT_FMT_AARCH64_4K (1 << 7) |
360 | #define ARM_SMMU_FEAT_FMT_AARCH64_16K (1 << 8) | |
361 | #define ARM_SMMU_FEAT_FMT_AARCH64_64K (1 << 9) | |
362 | #define ARM_SMMU_FEAT_FMT_AARCH32_L (1 << 10) | |
363 | #define ARM_SMMU_FEAT_FMT_AARCH32_S (1 << 11) | |
dc0eaa4e | 364 | #define ARM_SMMU_FEAT_EXIDS (1 << 12) |
45ae7cff | 365 | u32 features; |
3a5df8ff AH |
366 | |
367 | #define ARM_SMMU_OPT_SECURE_CFG_ACCESS (1 << 0) | |
368 | u32 options; | |
09360403 | 369 | enum arm_smmu_arch_version version; |
67b65a3f | 370 | enum arm_smmu_implementation model; |
45ae7cff WD |
371 | |
372 | u32 num_context_banks; | |
373 | u32 num_s2_context_banks; | |
374 | DECLARE_BITMAP(context_map, ARM_SMMU_MAX_CBS); | |
375 | atomic_t irptndx; | |
376 | ||
377 | u32 num_mapping_groups; | |
21174240 RM |
378 | u16 streamid_mask; |
379 | u16 smr_mask_mask; | |
1f3d5ca4 | 380 | struct arm_smmu_smr *smrs; |
8e8b203e | 381 | struct arm_smmu_s2cr *s2crs; |
588888a7 | 382 | struct mutex stream_map_mutex; |
45ae7cff | 383 | |
518f7136 WD |
384 | unsigned long va_size; |
385 | unsigned long ipa_size; | |
386 | unsigned long pa_size; | |
d5466357 | 387 | unsigned long pgsize_bitmap; |
45ae7cff WD |
388 | |
389 | u32 num_global_irqs; | |
390 | u32 num_context_irqs; | |
391 | unsigned int *irqs; | |
392 | ||
1bd37a68 | 393 | u32 cavium_id_base; /* Specific to Cavium */ |
9648cbc9 JR |
394 | |
395 | /* IOMMU core code handle */ | |
396 | struct iommu_device iommu; | |
45ae7cff WD |
397 | }; |
398 | ||
7602b871 RM |
399 | enum arm_smmu_context_fmt { |
400 | ARM_SMMU_CTX_FMT_NONE, | |
401 | ARM_SMMU_CTX_FMT_AARCH64, | |
402 | ARM_SMMU_CTX_FMT_AARCH32_L, | |
403 | ARM_SMMU_CTX_FMT_AARCH32_S, | |
45ae7cff WD |
404 | }; |
405 | ||
406 | struct arm_smmu_cfg { | |
45ae7cff WD |
407 | u8 cbndx; |
408 | u8 irptndx; | |
280b683c RM |
409 | union { |
410 | u16 asid; | |
411 | u16 vmid; | |
412 | }; | |
45ae7cff | 413 | u32 cbar; |
7602b871 | 414 | enum arm_smmu_context_fmt fmt; |
45ae7cff | 415 | }; |
faea13b7 | 416 | #define INVALID_IRPTNDX 0xff |
45ae7cff | 417 | |
c752ce45 WD |
418 | enum arm_smmu_domain_stage { |
419 | ARM_SMMU_DOMAIN_S1 = 0, | |
420 | ARM_SMMU_DOMAIN_S2, | |
421 | ARM_SMMU_DOMAIN_NESTED, | |
61bc6711 | 422 | ARM_SMMU_DOMAIN_BYPASS, |
c752ce45 WD |
423 | }; |
424 | ||
45ae7cff | 425 | struct arm_smmu_domain { |
44680eed | 426 | struct arm_smmu_device *smmu; |
518f7136 WD |
427 | struct io_pgtable_ops *pgtbl_ops; |
428 | spinlock_t pgtbl_lock; | |
44680eed | 429 | struct arm_smmu_cfg cfg; |
c752ce45 | 430 | enum arm_smmu_domain_stage stage; |
518f7136 | 431 | struct mutex init_mutex; /* Protects smmu pointer */ |
1d672638 | 432 | struct iommu_domain domain; |
45ae7cff WD |
433 | }; |
434 | ||
3a5df8ff AH |
435 | struct arm_smmu_option_prop { |
436 | u32 opt; | |
437 | const char *prop; | |
438 | }; | |
439 | ||
1bd37a68 TC |
440 | static atomic_t cavium_smmu_context_count = ATOMIC_INIT(0); |
441 | ||
021bb842 RM |
442 | static bool using_legacy_binding, using_generic_binding; |
443 | ||
2907320d | 444 | static struct arm_smmu_option_prop arm_smmu_options[] = { |
3a5df8ff AH |
445 | { ARM_SMMU_OPT_SECURE_CFG_ACCESS, "calxeda,smmu-secure-config-access" }, |
446 | { 0, NULL}, | |
447 | }; | |
448 | ||
1d672638 JR |
449 | static struct arm_smmu_domain *to_smmu_domain(struct iommu_domain *dom) |
450 | { | |
451 | return container_of(dom, struct arm_smmu_domain, domain); | |
452 | } | |
453 | ||
3a5df8ff AH |
454 | static void parse_driver_options(struct arm_smmu_device *smmu) |
455 | { | |
456 | int i = 0; | |
2907320d | 457 | |
3a5df8ff AH |
458 | do { |
459 | if (of_property_read_bool(smmu->dev->of_node, | |
460 | arm_smmu_options[i].prop)) { | |
461 | smmu->options |= arm_smmu_options[i].opt; | |
462 | dev_notice(smmu->dev, "option %s\n", | |
463 | arm_smmu_options[i].prop); | |
464 | } | |
465 | } while (arm_smmu_options[++i].opt); | |
466 | } | |
467 | ||
8f68f8e2 | 468 | static struct device_node *dev_get_dev_node(struct device *dev) |
a9a1b0b5 WD |
469 | { |
470 | if (dev_is_pci(dev)) { | |
471 | struct pci_bus *bus = to_pci_dev(dev)->bus; | |
2907320d | 472 | |
a9a1b0b5 WD |
473 | while (!pci_is_root_bus(bus)) |
474 | bus = bus->parent; | |
f80cd885 | 475 | return of_node_get(bus->bridge->parent->of_node); |
a9a1b0b5 WD |
476 | } |
477 | ||
f80cd885 | 478 | return of_node_get(dev->of_node); |
a9a1b0b5 WD |
479 | } |
480 | ||
f80cd885 | 481 | static int __arm_smmu_get_pci_sid(struct pci_dev *pdev, u16 alias, void *data) |
45ae7cff | 482 | { |
f80cd885 RM |
483 | *((__be32 *)data) = cpu_to_be32(alias); |
484 | return 0; /* Continue walking */ | |
45ae7cff WD |
485 | } |
486 | ||
f80cd885 | 487 | static int __find_legacy_master_phandle(struct device *dev, void *data) |
a9a1b0b5 | 488 | { |
f80cd885 RM |
489 | struct of_phandle_iterator *it = *(void **)data; |
490 | struct device_node *np = it->node; | |
491 | int err; | |
492 | ||
493 | of_for_each_phandle(it, err, dev->of_node, "mmu-masters", | |
494 | "#stream-id-cells", 0) | |
495 | if (it->node == np) { | |
496 | *(void **)data = dev; | |
497 | return 1; | |
498 | } | |
499 | it->node = np; | |
500 | return err == -ENOENT ? 0 : err; | |
a9a1b0b5 WD |
501 | } |
502 | ||
d6fc5d97 | 503 | static struct platform_driver arm_smmu_driver; |
adfec2e7 | 504 | static struct iommu_ops arm_smmu_ops; |
d6fc5d97 | 505 | |
adfec2e7 RM |
506 | static int arm_smmu_register_legacy_master(struct device *dev, |
507 | struct arm_smmu_device **smmu) | |
45ae7cff | 508 | { |
adfec2e7 | 509 | struct device *smmu_dev; |
f80cd885 RM |
510 | struct device_node *np; |
511 | struct of_phandle_iterator it; | |
512 | void *data = ⁢ | |
adfec2e7 | 513 | u32 *sids; |
f80cd885 RM |
514 | __be32 pci_sid; |
515 | int err; | |
45ae7cff | 516 | |
f80cd885 RM |
517 | np = dev_get_dev_node(dev); |
518 | if (!np || !of_find_property(np, "#stream-id-cells", NULL)) { | |
519 | of_node_put(np); | |
520 | return -ENODEV; | |
521 | } | |
45ae7cff | 522 | |
f80cd885 | 523 | it.node = np; |
d6fc5d97 RM |
524 | err = driver_for_each_device(&arm_smmu_driver.driver, NULL, &data, |
525 | __find_legacy_master_phandle); | |
adfec2e7 | 526 | smmu_dev = data; |
f80cd885 RM |
527 | of_node_put(np); |
528 | if (err == 0) | |
529 | return -ENODEV; | |
530 | if (err < 0) | |
531 | return err; | |
45ae7cff | 532 | |
f80cd885 RM |
533 | if (dev_is_pci(dev)) { |
534 | /* "mmu-masters" assumes Stream ID == Requester ID */ | |
535 | pci_for_each_dma_alias(to_pci_dev(dev), __arm_smmu_get_pci_sid, | |
536 | &pci_sid); | |
537 | it.cur = &pci_sid; | |
538 | it.cur_count = 1; | |
539 | } | |
45ae7cff | 540 | |
adfec2e7 RM |
541 | err = iommu_fwspec_init(dev, &smmu_dev->of_node->fwnode, |
542 | &arm_smmu_ops); | |
543 | if (err) | |
544 | return err; | |
45ae7cff | 545 | |
adfec2e7 RM |
546 | sids = kcalloc(it.cur_count, sizeof(*sids), GFP_KERNEL); |
547 | if (!sids) | |
548 | return -ENOMEM; | |
44680eed | 549 | |
adfec2e7 RM |
550 | *smmu = dev_get_drvdata(smmu_dev); |
551 | of_phandle_iterator_args(&it, sids, it.cur_count); | |
552 | err = iommu_fwspec_add_ids(dev, sids, it.cur_count); | |
553 | kfree(sids); | |
554 | return err; | |
45ae7cff WD |
555 | } |
556 | ||
557 | static int __arm_smmu_alloc_bitmap(unsigned long *map, int start, int end) | |
558 | { | |
559 | int idx; | |
560 | ||
561 | do { | |
562 | idx = find_next_zero_bit(map, end, start); | |
563 | if (idx == end) | |
564 | return -ENOSPC; | |
565 | } while (test_and_set_bit(idx, map)); | |
566 | ||
567 | return idx; | |
568 | } | |
569 | ||
570 | static void __arm_smmu_free_bitmap(unsigned long *map, int idx) | |
571 | { | |
572 | clear_bit(idx, map); | |
573 | } | |
574 | ||
575 | /* Wait for any pending TLB invalidations to complete */ | |
11febfca RM |
576 | static void __arm_smmu_tlb_sync(struct arm_smmu_device *smmu, |
577 | void __iomem *sync, void __iomem *status) | |
45ae7cff | 578 | { |
8513c893 | 579 | unsigned int spin_cnt, delay; |
45ae7cff | 580 | |
11febfca | 581 | writel_relaxed(0, sync); |
8513c893 RM |
582 | for (delay = 1; delay < TLB_LOOP_TIMEOUT; delay *= 2) { |
583 | for (spin_cnt = TLB_SPIN_COUNT; spin_cnt > 0; spin_cnt--) { | |
584 | if (!(readl_relaxed(status) & sTLBGSTATUS_GSACTIVE)) | |
585 | return; | |
586 | cpu_relax(); | |
45ae7cff | 587 | } |
8513c893 | 588 | udelay(delay); |
45ae7cff | 589 | } |
8513c893 RM |
590 | dev_err_ratelimited(smmu->dev, |
591 | "TLB sync timed out -- SMMU may be deadlocked\n"); | |
45ae7cff WD |
592 | } |
593 | ||
11febfca RM |
594 | static void arm_smmu_tlb_sync_global(struct arm_smmu_device *smmu) |
595 | { | |
596 | void __iomem *base = ARM_SMMU_GR0(smmu); | |
597 | ||
598 | __arm_smmu_tlb_sync(smmu, base + ARM_SMMU_GR0_sTLBGSYNC, | |
599 | base + ARM_SMMU_GR0_sTLBGSTATUS); | |
600 | } | |
601 | ||
602 | static void arm_smmu_tlb_sync_context(void *cookie) | |
518f7136 WD |
603 | { |
604 | struct arm_smmu_domain *smmu_domain = cookie; | |
11febfca RM |
605 | struct arm_smmu_device *smmu = smmu_domain->smmu; |
606 | void __iomem *base = ARM_SMMU_CB(smmu, smmu_domain->cfg.cbndx); | |
607 | ||
608 | __arm_smmu_tlb_sync(smmu, base + ARM_SMMU_CB_TLBSYNC, | |
609 | base + ARM_SMMU_CB_TLBSTATUS); | |
518f7136 WD |
610 | } |
611 | ||
11febfca | 612 | static void arm_smmu_tlb_sync_vmid(void *cookie) |
518f7136 WD |
613 | { |
614 | struct arm_smmu_domain *smmu_domain = cookie; | |
11febfca RM |
615 | |
616 | arm_smmu_tlb_sync_global(smmu_domain->smmu); | |
518f7136 WD |
617 | } |
618 | ||
11febfca | 619 | static void arm_smmu_tlb_inv_context_s1(void *cookie) |
1463fe44 | 620 | { |
518f7136 | 621 | struct arm_smmu_domain *smmu_domain = cookie; |
44680eed | 622 | struct arm_smmu_cfg *cfg = &smmu_domain->cfg; |
11febfca | 623 | void __iomem *base = ARM_SMMU_CB(smmu_domain->smmu, cfg->cbndx); |
1463fe44 | 624 | |
11febfca RM |
625 | writel_relaxed(cfg->asid, base + ARM_SMMU_CB_S1_TLBIASID); |
626 | arm_smmu_tlb_sync_context(cookie); | |
627 | } | |
1463fe44 | 628 | |
11febfca RM |
629 | static void arm_smmu_tlb_inv_context_s2(void *cookie) |
630 | { | |
631 | struct arm_smmu_domain *smmu_domain = cookie; | |
632 | struct arm_smmu_device *smmu = smmu_domain->smmu; | |
633 | void __iomem *base = ARM_SMMU_GR0(smmu); | |
1463fe44 | 634 | |
11febfca RM |
635 | writel_relaxed(smmu_domain->cfg.vmid, base + ARM_SMMU_GR0_TLBIVMID); |
636 | arm_smmu_tlb_sync_global(smmu); | |
518f7136 WD |
637 | } |
638 | ||
639 | static void arm_smmu_tlb_inv_range_nosync(unsigned long iova, size_t size, | |
06c610e8 | 640 | size_t granule, bool leaf, void *cookie) |
518f7136 WD |
641 | { |
642 | struct arm_smmu_domain *smmu_domain = cookie; | |
643 | struct arm_smmu_cfg *cfg = &smmu_domain->cfg; | |
518f7136 | 644 | bool stage1 = cfg->cbar != CBAR_TYPE_S2_TRANS; |
11febfca | 645 | void __iomem *reg = ARM_SMMU_CB(smmu_domain->smmu, cfg->cbndx); |
518f7136 WD |
646 | |
647 | if (stage1) { | |
518f7136 WD |
648 | reg += leaf ? ARM_SMMU_CB_S1_TLBIVAL : ARM_SMMU_CB_S1_TLBIVA; |
649 | ||
7602b871 | 650 | if (cfg->fmt != ARM_SMMU_CTX_FMT_AARCH64) { |
518f7136 | 651 | iova &= ~12UL; |
280b683c | 652 | iova |= cfg->asid; |
75df1386 RM |
653 | do { |
654 | writel_relaxed(iova, reg); | |
655 | iova += granule; | |
656 | } while (size -= granule); | |
518f7136 WD |
657 | } else { |
658 | iova >>= 12; | |
280b683c | 659 | iova |= (u64)cfg->asid << 48; |
75df1386 RM |
660 | do { |
661 | writeq_relaxed(iova, reg); | |
662 | iova += granule >> 12; | |
663 | } while (size -= granule); | |
518f7136 | 664 | } |
11febfca | 665 | } else { |
518f7136 WD |
666 | reg += leaf ? ARM_SMMU_CB_S2_TLBIIPAS2L : |
667 | ARM_SMMU_CB_S2_TLBIIPAS2; | |
75df1386 RM |
668 | iova >>= 12; |
669 | do { | |
f9a05f05 | 670 | smmu_write_atomic_lq(iova, reg); |
75df1386 RM |
671 | iova += granule >> 12; |
672 | } while (size -= granule); | |
518f7136 WD |
673 | } |
674 | } | |
675 | ||
11febfca RM |
676 | /* |
677 | * On MMU-401 at least, the cost of firing off multiple TLBIVMIDs appears | |
678 | * almost negligible, but the benefit of getting the first one in as far ahead | |
679 | * of the sync as possible is significant, hence we don't just make this a | |
680 | * no-op and set .tlb_sync to arm_smmu_inv_context_s2() as you might think. | |
681 | */ | |
682 | static void arm_smmu_tlb_inv_vmid_nosync(unsigned long iova, size_t size, | |
683 | size_t granule, bool leaf, void *cookie) | |
684 | { | |
685 | struct arm_smmu_domain *smmu_domain = cookie; | |
686 | void __iomem *base = ARM_SMMU_GR0(smmu_domain->smmu); | |
687 | ||
688 | writel_relaxed(smmu_domain->cfg.vmid, base + ARM_SMMU_GR0_TLBIVMID); | |
689 | } | |
690 | ||
691 | static const struct iommu_gather_ops arm_smmu_s1_tlb_ops = { | |
692 | .tlb_flush_all = arm_smmu_tlb_inv_context_s1, | |
518f7136 | 693 | .tlb_add_flush = arm_smmu_tlb_inv_range_nosync, |
11febfca RM |
694 | .tlb_sync = arm_smmu_tlb_sync_context, |
695 | }; | |
696 | ||
697 | static const struct iommu_gather_ops arm_smmu_s2_tlb_ops_v2 = { | |
698 | .tlb_flush_all = arm_smmu_tlb_inv_context_s2, | |
518f7136 | 699 | .tlb_add_flush = arm_smmu_tlb_inv_range_nosync, |
11febfca RM |
700 | .tlb_sync = arm_smmu_tlb_sync_context, |
701 | }; | |
702 | ||
703 | static const struct iommu_gather_ops arm_smmu_s2_tlb_ops_v1 = { | |
704 | .tlb_flush_all = arm_smmu_tlb_inv_context_s2, | |
705 | .tlb_add_flush = arm_smmu_tlb_inv_vmid_nosync, | |
706 | .tlb_sync = arm_smmu_tlb_sync_vmid, | |
518f7136 WD |
707 | }; |
708 | ||
45ae7cff WD |
709 | static irqreturn_t arm_smmu_context_fault(int irq, void *dev) |
710 | { | |
3714ce1d | 711 | u32 fsr, fsynr; |
45ae7cff WD |
712 | unsigned long iova; |
713 | struct iommu_domain *domain = dev; | |
1d672638 | 714 | struct arm_smmu_domain *smmu_domain = to_smmu_domain(domain); |
44680eed WD |
715 | struct arm_smmu_cfg *cfg = &smmu_domain->cfg; |
716 | struct arm_smmu_device *smmu = smmu_domain->smmu; | |
45ae7cff WD |
717 | void __iomem *cb_base; |
718 | ||
452107c7 | 719 | cb_base = ARM_SMMU_CB(smmu, cfg->cbndx); |
45ae7cff WD |
720 | fsr = readl_relaxed(cb_base + ARM_SMMU_CB_FSR); |
721 | ||
722 | if (!(fsr & FSR_FAULT)) | |
723 | return IRQ_NONE; | |
724 | ||
45ae7cff | 725 | fsynr = readl_relaxed(cb_base + ARM_SMMU_CB_FSYNR0); |
f9a05f05 | 726 | iova = readq_relaxed(cb_base + ARM_SMMU_CB_FAR); |
45ae7cff | 727 | |
3714ce1d WD |
728 | dev_err_ratelimited(smmu->dev, |
729 | "Unhandled context fault: fsr=0x%x, iova=0x%08lx, fsynr=0x%x, cb=%d\n", | |
730 | fsr, iova, fsynr, cfg->cbndx); | |
45ae7cff | 731 | |
3714ce1d WD |
732 | writel(fsr, cb_base + ARM_SMMU_CB_FSR); |
733 | return IRQ_HANDLED; | |
45ae7cff WD |
734 | } |
735 | ||
736 | static irqreturn_t arm_smmu_global_fault(int irq, void *dev) | |
737 | { | |
738 | u32 gfsr, gfsynr0, gfsynr1, gfsynr2; | |
739 | struct arm_smmu_device *smmu = dev; | |
3a5df8ff | 740 | void __iomem *gr0_base = ARM_SMMU_GR0_NS(smmu); |
45ae7cff WD |
741 | |
742 | gfsr = readl_relaxed(gr0_base + ARM_SMMU_GR0_sGFSR); | |
743 | gfsynr0 = readl_relaxed(gr0_base + ARM_SMMU_GR0_sGFSYNR0); | |
744 | gfsynr1 = readl_relaxed(gr0_base + ARM_SMMU_GR0_sGFSYNR1); | |
745 | gfsynr2 = readl_relaxed(gr0_base + ARM_SMMU_GR0_sGFSYNR2); | |
746 | ||
3a5df8ff AH |
747 | if (!gfsr) |
748 | return IRQ_NONE; | |
749 | ||
45ae7cff WD |
750 | dev_err_ratelimited(smmu->dev, |
751 | "Unexpected global fault, this could be serious\n"); | |
752 | dev_err_ratelimited(smmu->dev, | |
753 | "\tGFSR 0x%08x, GFSYNR0 0x%08x, GFSYNR1 0x%08x, GFSYNR2 0x%08x\n", | |
754 | gfsr, gfsynr0, gfsynr1, gfsynr2); | |
755 | ||
756 | writel(gfsr, gr0_base + ARM_SMMU_GR0_sGFSR); | |
adaba320 | 757 | return IRQ_HANDLED; |
45ae7cff WD |
758 | } |
759 | ||
518f7136 WD |
760 | static void arm_smmu_init_context_bank(struct arm_smmu_domain *smmu_domain, |
761 | struct io_pgtable_cfg *pgtbl_cfg) | |
45ae7cff | 762 | { |
6070529b | 763 | u32 reg, reg2; |
668b4ada | 764 | u64 reg64; |
45ae7cff | 765 | bool stage1; |
44680eed WD |
766 | struct arm_smmu_cfg *cfg = &smmu_domain->cfg; |
767 | struct arm_smmu_device *smmu = smmu_domain->smmu; | |
c88ae5de | 768 | void __iomem *cb_base, *gr1_base; |
45ae7cff | 769 | |
45ae7cff | 770 | gr1_base = ARM_SMMU_GR1(smmu); |
44680eed | 771 | stage1 = cfg->cbar != CBAR_TYPE_S2_TRANS; |
452107c7 | 772 | cb_base = ARM_SMMU_CB(smmu, cfg->cbndx); |
45ae7cff | 773 | |
4a1c93cb | 774 | if (smmu->version > ARM_SMMU_V1) { |
7602b871 RM |
775 | if (cfg->fmt == ARM_SMMU_CTX_FMT_AARCH64) |
776 | reg = CBA2R_RW64_64BIT; | |
777 | else | |
778 | reg = CBA2R_RW64_32BIT; | |
4e3e9b69 TC |
779 | /* 16-bit VMIDs live in CBA2R */ |
780 | if (smmu->features & ARM_SMMU_FEAT_VMID16) | |
280b683c | 781 | reg |= cfg->vmid << CBA2R_VMID_SHIFT; |
4e3e9b69 | 782 | |
4a1c93cb WD |
783 | writel_relaxed(reg, gr1_base + ARM_SMMU_GR1_CBA2R(cfg->cbndx)); |
784 | } | |
785 | ||
45ae7cff | 786 | /* CBAR */ |
44680eed | 787 | reg = cfg->cbar; |
b7862e35 | 788 | if (smmu->version < ARM_SMMU_V2) |
2907320d | 789 | reg |= cfg->irptndx << CBAR_IRPTNDX_SHIFT; |
45ae7cff | 790 | |
57ca90f6 WD |
791 | /* |
792 | * Use the weakest shareability/memory types, so they are | |
793 | * overridden by the ttbcr/pte. | |
794 | */ | |
795 | if (stage1) { | |
796 | reg |= (CBAR_S1_BPSHCFG_NSH << CBAR_S1_BPSHCFG_SHIFT) | | |
797 | (CBAR_S1_MEMATTR_WB << CBAR_S1_MEMATTR_SHIFT); | |
4e3e9b69 TC |
798 | } else if (!(smmu->features & ARM_SMMU_FEAT_VMID16)) { |
799 | /* 8-bit VMIDs live in CBAR */ | |
280b683c | 800 | reg |= cfg->vmid << CBAR_VMID_SHIFT; |
57ca90f6 | 801 | } |
44680eed | 802 | writel_relaxed(reg, gr1_base + ARM_SMMU_GR1_CBAR(cfg->cbndx)); |
45ae7cff | 803 | |
125458ab SG |
804 | /* |
805 | * TTBCR | |
806 | * We must write this before the TTBRs, since it determines the | |
807 | * access behaviour of some fields (in particular, ASID[15:8]). | |
808 | */ | |
518f7136 | 809 | if (stage1) { |
6070529b RM |
810 | if (cfg->fmt == ARM_SMMU_CTX_FMT_AARCH32_S) { |
811 | reg = pgtbl_cfg->arm_v7s_cfg.tcr; | |
812 | reg2 = 0; | |
813 | } else { | |
814 | reg = pgtbl_cfg->arm_lpae_s1_cfg.tcr; | |
815 | reg2 = pgtbl_cfg->arm_lpae_s1_cfg.tcr >> 32; | |
816 | reg2 |= TTBCR2_SEP_UPSTREAM; | |
3677a649 TN |
817 | if (cfg->fmt == ARM_SMMU_CTX_FMT_AARCH64) |
818 | reg2 |= TTBCR2_AS; | |
45ae7cff | 819 | } |
6070529b RM |
820 | if (smmu->version > ARM_SMMU_V1) |
821 | writel_relaxed(reg2, cb_base + ARM_SMMU_CB_TTBCR2); | |
45ae7cff | 822 | } else { |
518f7136 | 823 | reg = pgtbl_cfg->arm_lpae_s2_cfg.vtcr; |
45ae7cff | 824 | } |
6070529b | 825 | writel_relaxed(reg, cb_base + ARM_SMMU_CB_TTBCR); |
45ae7cff | 826 | |
518f7136 WD |
827 | /* TTBRs */ |
828 | if (stage1) { | |
6070529b RM |
829 | if (cfg->fmt == ARM_SMMU_CTX_FMT_AARCH32_S) { |
830 | reg = pgtbl_cfg->arm_v7s_cfg.ttbr[0]; | |
831 | writel_relaxed(reg, cb_base + ARM_SMMU_CB_TTBR0); | |
832 | reg = pgtbl_cfg->arm_v7s_cfg.ttbr[1]; | |
833 | writel_relaxed(reg, cb_base + ARM_SMMU_CB_TTBR1); | |
280b683c | 834 | writel_relaxed(cfg->asid, cb_base + ARM_SMMU_CB_CONTEXTIDR); |
6070529b RM |
835 | } else { |
836 | reg64 = pgtbl_cfg->arm_lpae_s1_cfg.ttbr[0]; | |
280b683c | 837 | reg64 |= (u64)cfg->asid << TTBRn_ASID_SHIFT; |
6070529b RM |
838 | writeq_relaxed(reg64, cb_base + ARM_SMMU_CB_TTBR0); |
839 | reg64 = pgtbl_cfg->arm_lpae_s1_cfg.ttbr[1]; | |
280b683c | 840 | reg64 |= (u64)cfg->asid << TTBRn_ASID_SHIFT; |
6070529b RM |
841 | writeq_relaxed(reg64, cb_base + ARM_SMMU_CB_TTBR1); |
842 | } | |
518f7136 | 843 | } else { |
668b4ada | 844 | reg64 = pgtbl_cfg->arm_lpae_s2_cfg.vttbr; |
f9a05f05 | 845 | writeq_relaxed(reg64, cb_base + ARM_SMMU_CB_TTBR0); |
518f7136 | 846 | } |
a65217a4 | 847 | |
518f7136 | 848 | /* MAIRs (stage-1 only) */ |
45ae7cff | 849 | if (stage1) { |
6070529b RM |
850 | if (cfg->fmt == ARM_SMMU_CTX_FMT_AARCH32_S) { |
851 | reg = pgtbl_cfg->arm_v7s_cfg.prrr; | |
852 | reg2 = pgtbl_cfg->arm_v7s_cfg.nmrr; | |
853 | } else { | |
854 | reg = pgtbl_cfg->arm_lpae_s1_cfg.mair[0]; | |
855 | reg2 = pgtbl_cfg->arm_lpae_s1_cfg.mair[1]; | |
856 | } | |
45ae7cff | 857 | writel_relaxed(reg, cb_base + ARM_SMMU_CB_S1_MAIR0); |
6070529b | 858 | writel_relaxed(reg2, cb_base + ARM_SMMU_CB_S1_MAIR1); |
45ae7cff WD |
859 | } |
860 | ||
45ae7cff | 861 | /* SCTLR */ |
6070529b | 862 | reg = SCTLR_CFIE | SCTLR_CFRE | SCTLR_AFE | SCTLR_TRE | SCTLR_M; |
45ae7cff WD |
863 | if (stage1) |
864 | reg |= SCTLR_S1_ASIDPNE; | |
865 | #ifdef __BIG_ENDIAN | |
866 | reg |= SCTLR_E; | |
867 | #endif | |
25724841 | 868 | writel_relaxed(reg, cb_base + ARM_SMMU_CB_SCTLR); |
45ae7cff WD |
869 | } |
870 | ||
871 | static int arm_smmu_init_domain_context(struct iommu_domain *domain, | |
44680eed | 872 | struct arm_smmu_device *smmu) |
45ae7cff | 873 | { |
a18037b2 | 874 | int irq, start, ret = 0; |
518f7136 WD |
875 | unsigned long ias, oas; |
876 | struct io_pgtable_ops *pgtbl_ops; | |
877 | struct io_pgtable_cfg pgtbl_cfg; | |
878 | enum io_pgtable_fmt fmt; | |
1d672638 | 879 | struct arm_smmu_domain *smmu_domain = to_smmu_domain(domain); |
44680eed | 880 | struct arm_smmu_cfg *cfg = &smmu_domain->cfg; |
11febfca | 881 | const struct iommu_gather_ops *tlb_ops; |
45ae7cff | 882 | |
518f7136 | 883 | mutex_lock(&smmu_domain->init_mutex); |
a18037b2 MH |
884 | if (smmu_domain->smmu) |
885 | goto out_unlock; | |
886 | ||
61bc6711 WD |
887 | if (domain->type == IOMMU_DOMAIN_IDENTITY) { |
888 | smmu_domain->stage = ARM_SMMU_DOMAIN_BYPASS; | |
889 | smmu_domain->smmu = smmu; | |
890 | goto out_unlock; | |
891 | } | |
892 | ||
c752ce45 WD |
893 | /* |
894 | * Mapping the requested stage onto what we support is surprisingly | |
895 | * complicated, mainly because the spec allows S1+S2 SMMUs without | |
896 | * support for nested translation. That means we end up with the | |
897 | * following table: | |
898 | * | |
899 | * Requested Supported Actual | |
900 | * S1 N S1 | |
901 | * S1 S1+S2 S1 | |
902 | * S1 S2 S2 | |
903 | * S1 S1 S1 | |
904 | * N N N | |
905 | * N S1+S2 S2 | |
906 | * N S2 S2 | |
907 | * N S1 S1 | |
908 | * | |
909 | * Note that you can't actually request stage-2 mappings. | |
910 | */ | |
911 | if (!(smmu->features & ARM_SMMU_FEAT_TRANS_S1)) | |
912 | smmu_domain->stage = ARM_SMMU_DOMAIN_S2; | |
913 | if (!(smmu->features & ARM_SMMU_FEAT_TRANS_S2)) | |
914 | smmu_domain->stage = ARM_SMMU_DOMAIN_S1; | |
915 | ||
7602b871 RM |
916 | /* |
917 | * Choosing a suitable context format is even more fiddly. Until we | |
918 | * grow some way for the caller to express a preference, and/or move | |
919 | * the decision into the io-pgtable code where it arguably belongs, | |
920 | * just aim for the closest thing to the rest of the system, and hope | |
921 | * that the hardware isn't esoteric enough that we can't assume AArch64 | |
922 | * support to be a superset of AArch32 support... | |
923 | */ | |
924 | if (smmu->features & ARM_SMMU_FEAT_FMT_AARCH32_L) | |
925 | cfg->fmt = ARM_SMMU_CTX_FMT_AARCH32_L; | |
6070529b RM |
926 | if (IS_ENABLED(CONFIG_IOMMU_IO_PGTABLE_ARMV7S) && |
927 | !IS_ENABLED(CONFIG_64BIT) && !IS_ENABLED(CONFIG_ARM_LPAE) && | |
928 | (smmu->features & ARM_SMMU_FEAT_FMT_AARCH32_S) && | |
929 | (smmu_domain->stage == ARM_SMMU_DOMAIN_S1)) | |
930 | cfg->fmt = ARM_SMMU_CTX_FMT_AARCH32_S; | |
7602b871 RM |
931 | if ((IS_ENABLED(CONFIG_64BIT) || cfg->fmt == ARM_SMMU_CTX_FMT_NONE) && |
932 | (smmu->features & (ARM_SMMU_FEAT_FMT_AARCH64_64K | | |
933 | ARM_SMMU_FEAT_FMT_AARCH64_16K | | |
934 | ARM_SMMU_FEAT_FMT_AARCH64_4K))) | |
935 | cfg->fmt = ARM_SMMU_CTX_FMT_AARCH64; | |
936 | ||
937 | if (cfg->fmt == ARM_SMMU_CTX_FMT_NONE) { | |
938 | ret = -EINVAL; | |
939 | goto out_unlock; | |
940 | } | |
941 | ||
c752ce45 WD |
942 | switch (smmu_domain->stage) { |
943 | case ARM_SMMU_DOMAIN_S1: | |
944 | cfg->cbar = CBAR_TYPE_S1_TRANS_S2_BYPASS; | |
945 | start = smmu->num_s2_context_banks; | |
518f7136 WD |
946 | ias = smmu->va_size; |
947 | oas = smmu->ipa_size; | |
7602b871 | 948 | if (cfg->fmt == ARM_SMMU_CTX_FMT_AARCH64) { |
518f7136 | 949 | fmt = ARM_64_LPAE_S1; |
6070529b | 950 | } else if (cfg->fmt == ARM_SMMU_CTX_FMT_AARCH32_L) { |
518f7136 | 951 | fmt = ARM_32_LPAE_S1; |
7602b871 RM |
952 | ias = min(ias, 32UL); |
953 | oas = min(oas, 40UL); | |
6070529b RM |
954 | } else { |
955 | fmt = ARM_V7S; | |
956 | ias = min(ias, 32UL); | |
957 | oas = min(oas, 32UL); | |
7602b871 | 958 | } |
11febfca | 959 | tlb_ops = &arm_smmu_s1_tlb_ops; |
c752ce45 WD |
960 | break; |
961 | case ARM_SMMU_DOMAIN_NESTED: | |
45ae7cff WD |
962 | /* |
963 | * We will likely want to change this if/when KVM gets | |
964 | * involved. | |
965 | */ | |
c752ce45 | 966 | case ARM_SMMU_DOMAIN_S2: |
9c5c92e3 WD |
967 | cfg->cbar = CBAR_TYPE_S2_TRANS; |
968 | start = 0; | |
518f7136 WD |
969 | ias = smmu->ipa_size; |
970 | oas = smmu->pa_size; | |
7602b871 | 971 | if (cfg->fmt == ARM_SMMU_CTX_FMT_AARCH64) { |
518f7136 | 972 | fmt = ARM_64_LPAE_S2; |
7602b871 | 973 | } else { |
518f7136 | 974 | fmt = ARM_32_LPAE_S2; |
7602b871 RM |
975 | ias = min(ias, 40UL); |
976 | oas = min(oas, 40UL); | |
977 | } | |
11febfca RM |
978 | if (smmu->version == ARM_SMMU_V2) |
979 | tlb_ops = &arm_smmu_s2_tlb_ops_v2; | |
980 | else | |
981 | tlb_ops = &arm_smmu_s2_tlb_ops_v1; | |
c752ce45 WD |
982 | break; |
983 | default: | |
984 | ret = -EINVAL; | |
985 | goto out_unlock; | |
45ae7cff | 986 | } |
45ae7cff WD |
987 | ret = __arm_smmu_alloc_bitmap(smmu->context_map, start, |
988 | smmu->num_context_banks); | |
287980e4 | 989 | if (ret < 0) |
a18037b2 | 990 | goto out_unlock; |
45ae7cff | 991 | |
44680eed | 992 | cfg->cbndx = ret; |
b7862e35 | 993 | if (smmu->version < ARM_SMMU_V2) { |
44680eed WD |
994 | cfg->irptndx = atomic_inc_return(&smmu->irptndx); |
995 | cfg->irptndx %= smmu->num_context_irqs; | |
45ae7cff | 996 | } else { |
44680eed | 997 | cfg->irptndx = cfg->cbndx; |
45ae7cff WD |
998 | } |
999 | ||
280b683c RM |
1000 | if (smmu_domain->stage == ARM_SMMU_DOMAIN_S2) |
1001 | cfg->vmid = cfg->cbndx + 1 + smmu->cavium_id_base; | |
1002 | else | |
1003 | cfg->asid = cfg->cbndx + smmu->cavium_id_base; | |
1004 | ||
518f7136 | 1005 | pgtbl_cfg = (struct io_pgtable_cfg) { |
d5466357 | 1006 | .pgsize_bitmap = smmu->pgsize_bitmap, |
518f7136 WD |
1007 | .ias = ias, |
1008 | .oas = oas, | |
11febfca | 1009 | .tlb = tlb_ops, |
2df7a25c | 1010 | .iommu_dev = smmu->dev, |
518f7136 WD |
1011 | }; |
1012 | ||
1013 | smmu_domain->smmu = smmu; | |
1014 | pgtbl_ops = alloc_io_pgtable_ops(fmt, &pgtbl_cfg, smmu_domain); | |
1015 | if (!pgtbl_ops) { | |
1016 | ret = -ENOMEM; | |
1017 | goto out_clear_smmu; | |
1018 | } | |
1019 | ||
d5466357 RM |
1020 | /* Update the domain's page sizes to reflect the page table format */ |
1021 | domain->pgsize_bitmap = pgtbl_cfg.pgsize_bitmap; | |
455eb7d3 RM |
1022 | domain->geometry.aperture_end = (1UL << ias) - 1; |
1023 | domain->geometry.force_aperture = true; | |
a18037b2 | 1024 | |
518f7136 WD |
1025 | /* Initialise the context bank with our page table cfg */ |
1026 | arm_smmu_init_context_bank(smmu_domain, &pgtbl_cfg); | |
1027 | ||
1028 | /* | |
1029 | * Request context fault interrupt. Do this last to avoid the | |
1030 | * handler seeing a half-initialised domain state. | |
1031 | */ | |
44680eed | 1032 | irq = smmu->irqs[smmu->num_global_irqs + cfg->irptndx]; |
bee14004 PF |
1033 | ret = devm_request_irq(smmu->dev, irq, arm_smmu_context_fault, |
1034 | IRQF_SHARED, "arm-smmu-context-fault", domain); | |
287980e4 | 1035 | if (ret < 0) { |
45ae7cff | 1036 | dev_err(smmu->dev, "failed to request context IRQ %d (%u)\n", |
44680eed WD |
1037 | cfg->irptndx, irq); |
1038 | cfg->irptndx = INVALID_IRPTNDX; | |
45ae7cff WD |
1039 | } |
1040 | ||
518f7136 WD |
1041 | mutex_unlock(&smmu_domain->init_mutex); |
1042 | ||
1043 | /* Publish page table ops for map/unmap */ | |
1044 | smmu_domain->pgtbl_ops = pgtbl_ops; | |
a9a1b0b5 | 1045 | return 0; |
45ae7cff | 1046 | |
518f7136 WD |
1047 | out_clear_smmu: |
1048 | smmu_domain->smmu = NULL; | |
a18037b2 | 1049 | out_unlock: |
518f7136 | 1050 | mutex_unlock(&smmu_domain->init_mutex); |
45ae7cff WD |
1051 | return ret; |
1052 | } | |
1053 | ||
1054 | static void arm_smmu_destroy_domain_context(struct iommu_domain *domain) | |
1055 | { | |
1d672638 | 1056 | struct arm_smmu_domain *smmu_domain = to_smmu_domain(domain); |
44680eed WD |
1057 | struct arm_smmu_device *smmu = smmu_domain->smmu; |
1058 | struct arm_smmu_cfg *cfg = &smmu_domain->cfg; | |
1463fe44 | 1059 | void __iomem *cb_base; |
45ae7cff WD |
1060 | int irq; |
1061 | ||
61bc6711 | 1062 | if (!smmu || domain->type == IOMMU_DOMAIN_IDENTITY) |
45ae7cff WD |
1063 | return; |
1064 | ||
518f7136 WD |
1065 | /* |
1066 | * Disable the context bank and free the page tables before freeing | |
1067 | * it. | |
1068 | */ | |
452107c7 | 1069 | cb_base = ARM_SMMU_CB(smmu, cfg->cbndx); |
1463fe44 | 1070 | writel_relaxed(0, cb_base + ARM_SMMU_CB_SCTLR); |
1463fe44 | 1071 | |
44680eed WD |
1072 | if (cfg->irptndx != INVALID_IRPTNDX) { |
1073 | irq = smmu->irqs[smmu->num_global_irqs + cfg->irptndx]; | |
bee14004 | 1074 | devm_free_irq(smmu->dev, irq, domain); |
45ae7cff WD |
1075 | } |
1076 | ||
44830b0c | 1077 | free_io_pgtable_ops(smmu_domain->pgtbl_ops); |
44680eed | 1078 | __arm_smmu_free_bitmap(smmu->context_map, cfg->cbndx); |
45ae7cff WD |
1079 | } |
1080 | ||
1d672638 | 1081 | static struct iommu_domain *arm_smmu_domain_alloc(unsigned type) |
45ae7cff WD |
1082 | { |
1083 | struct arm_smmu_domain *smmu_domain; | |
45ae7cff | 1084 | |
61bc6711 WD |
1085 | if (type != IOMMU_DOMAIN_UNMANAGED && |
1086 | type != IOMMU_DOMAIN_DMA && | |
1087 | type != IOMMU_DOMAIN_IDENTITY) | |
1d672638 | 1088 | return NULL; |
45ae7cff WD |
1089 | /* |
1090 | * Allocate the domain and initialise some of its data structures. | |
1091 | * We can't really do anything meaningful until we've added a | |
1092 | * master. | |
1093 | */ | |
1094 | smmu_domain = kzalloc(sizeof(*smmu_domain), GFP_KERNEL); | |
1095 | if (!smmu_domain) | |
1d672638 | 1096 | return NULL; |
45ae7cff | 1097 | |
021bb842 RM |
1098 | if (type == IOMMU_DOMAIN_DMA && (using_legacy_binding || |
1099 | iommu_get_dma_cookie(&smmu_domain->domain))) { | |
9adb9594 RM |
1100 | kfree(smmu_domain); |
1101 | return NULL; | |
1102 | } | |
1103 | ||
518f7136 WD |
1104 | mutex_init(&smmu_domain->init_mutex); |
1105 | spin_lock_init(&smmu_domain->pgtbl_lock); | |
1d672638 JR |
1106 | |
1107 | return &smmu_domain->domain; | |
45ae7cff WD |
1108 | } |
1109 | ||
1d672638 | 1110 | static void arm_smmu_domain_free(struct iommu_domain *domain) |
45ae7cff | 1111 | { |
1d672638 | 1112 | struct arm_smmu_domain *smmu_domain = to_smmu_domain(domain); |
1463fe44 WD |
1113 | |
1114 | /* | |
1115 | * Free the domain resources. We assume that all devices have | |
1116 | * already been detached. | |
1117 | */ | |
9adb9594 | 1118 | iommu_put_dma_cookie(domain); |
45ae7cff | 1119 | arm_smmu_destroy_domain_context(domain); |
45ae7cff WD |
1120 | kfree(smmu_domain); |
1121 | } | |
1122 | ||
1f3d5ca4 RM |
1123 | static void arm_smmu_write_smr(struct arm_smmu_device *smmu, int idx) |
1124 | { | |
1125 | struct arm_smmu_smr *smr = smmu->smrs + idx; | |
f80cd885 | 1126 | u32 reg = smr->id << SMR_ID_SHIFT | smr->mask << SMR_MASK_SHIFT; |
1f3d5ca4 | 1127 | |
dc0eaa4e | 1128 | if (!(smmu->features & ARM_SMMU_FEAT_EXIDS) && smr->valid) |
1f3d5ca4 RM |
1129 | reg |= SMR_VALID; |
1130 | writel_relaxed(reg, ARM_SMMU_GR0(smmu) + ARM_SMMU_GR0_SMR(idx)); | |
1131 | } | |
1132 | ||
8e8b203e RM |
1133 | static void arm_smmu_write_s2cr(struct arm_smmu_device *smmu, int idx) |
1134 | { | |
1135 | struct arm_smmu_s2cr *s2cr = smmu->s2crs + idx; | |
1136 | u32 reg = (s2cr->type & S2CR_TYPE_MASK) << S2CR_TYPE_SHIFT | | |
1137 | (s2cr->cbndx & S2CR_CBNDX_MASK) << S2CR_CBNDX_SHIFT | | |
1138 | (s2cr->privcfg & S2CR_PRIVCFG_MASK) << S2CR_PRIVCFG_SHIFT; | |
1139 | ||
dc0eaa4e AM |
1140 | if (smmu->features & ARM_SMMU_FEAT_EXIDS && smmu->smrs && |
1141 | smmu->smrs[idx].valid) | |
1142 | reg |= S2CR_EXIDVALID; | |
8e8b203e RM |
1143 | writel_relaxed(reg, ARM_SMMU_GR0(smmu) + ARM_SMMU_GR0_S2CR(idx)); |
1144 | } | |
1145 | ||
1146 | static void arm_smmu_write_sme(struct arm_smmu_device *smmu, int idx) | |
1147 | { | |
1148 | arm_smmu_write_s2cr(smmu, idx); | |
1149 | if (smmu->smrs) | |
1150 | arm_smmu_write_smr(smmu, idx); | |
1151 | } | |
1152 | ||
dc0eaa4e AM |
1153 | /* |
1154 | * The width of SMR's mask field depends on sCR0_EXIDENABLE, so this function | |
1155 | * should be called after sCR0 is written. | |
1156 | */ | |
1157 | static void arm_smmu_test_smr_masks(struct arm_smmu_device *smmu) | |
1158 | { | |
1159 | void __iomem *gr0_base = ARM_SMMU_GR0(smmu); | |
1160 | u32 smr; | |
1161 | ||
1162 | if (!smmu->smrs) | |
1163 | return; | |
1164 | ||
1165 | /* | |
1166 | * SMR.ID bits may not be preserved if the corresponding MASK | |
1167 | * bits are set, so check each one separately. We can reject | |
1168 | * masters later if they try to claim IDs outside these masks. | |
1169 | */ | |
1170 | smr = smmu->streamid_mask << SMR_ID_SHIFT; | |
1171 | writel_relaxed(smr, gr0_base + ARM_SMMU_GR0_SMR(0)); | |
1172 | smr = readl_relaxed(gr0_base + ARM_SMMU_GR0_SMR(0)); | |
1173 | smmu->streamid_mask = smr >> SMR_ID_SHIFT; | |
1174 | ||
1175 | smr = smmu->streamid_mask << SMR_MASK_SHIFT; | |
1176 | writel_relaxed(smr, gr0_base + ARM_SMMU_GR0_SMR(0)); | |
1177 | smr = readl_relaxed(gr0_base + ARM_SMMU_GR0_SMR(0)); | |
1178 | smmu->smr_mask_mask = smr >> SMR_MASK_SHIFT; | |
1179 | } | |
1180 | ||
588888a7 | 1181 | static int arm_smmu_find_sme(struct arm_smmu_device *smmu, u16 id, u16 mask) |
1f3d5ca4 RM |
1182 | { |
1183 | struct arm_smmu_smr *smrs = smmu->smrs; | |
588888a7 | 1184 | int i, free_idx = -ENOSPC; |
1f3d5ca4 | 1185 | |
588888a7 RM |
1186 | /* Stream indexing is blissfully easy */ |
1187 | if (!smrs) | |
1188 | return id; | |
1189 | ||
1190 | /* Validating SMRs is... less so */ | |
1191 | for (i = 0; i < smmu->num_mapping_groups; ++i) { | |
1192 | if (!smrs[i].valid) { | |
1193 | /* | |
1194 | * Note the first free entry we come across, which | |
1195 | * we'll claim in the end if nothing else matches. | |
1196 | */ | |
1197 | if (free_idx < 0) | |
1198 | free_idx = i; | |
1f3d5ca4 RM |
1199 | continue; |
1200 | } | |
588888a7 RM |
1201 | /* |
1202 | * If the new entry is _entirely_ matched by an existing entry, | |
1203 | * then reuse that, with the guarantee that there also cannot | |
1204 | * be any subsequent conflicting entries. In normal use we'd | |
1205 | * expect simply identical entries for this case, but there's | |
1206 | * no harm in accommodating the generalisation. | |
1207 | */ | |
1208 | if ((mask & smrs[i].mask) == mask && | |
1209 | !((id ^ smrs[i].id) & ~smrs[i].mask)) | |
1210 | return i; | |
1211 | /* | |
1212 | * If the new entry has any other overlap with an existing one, | |
1213 | * though, then there always exists at least one stream ID | |
1214 | * which would cause a conflict, and we can't allow that risk. | |
1215 | */ | |
1216 | if (!((id ^ smrs[i].id) & ~(smrs[i].mask | mask))) | |
1217 | return -EINVAL; | |
1218 | } | |
1f3d5ca4 | 1219 | |
588888a7 RM |
1220 | return free_idx; |
1221 | } | |
1222 | ||
1223 | static bool arm_smmu_free_sme(struct arm_smmu_device *smmu, int idx) | |
1224 | { | |
1225 | if (--smmu->s2crs[idx].count) | |
1226 | return false; | |
1227 | ||
1228 | smmu->s2crs[idx] = s2cr_init_val; | |
1229 | if (smmu->smrs) | |
1230 | smmu->smrs[idx].valid = false; | |
1231 | ||
1232 | return true; | |
1233 | } | |
1234 | ||
1235 | static int arm_smmu_master_alloc_smes(struct device *dev) | |
1236 | { | |
adfec2e7 RM |
1237 | struct iommu_fwspec *fwspec = dev->iommu_fwspec; |
1238 | struct arm_smmu_master_cfg *cfg = fwspec->iommu_priv; | |
588888a7 RM |
1239 | struct arm_smmu_device *smmu = cfg->smmu; |
1240 | struct arm_smmu_smr *smrs = smmu->smrs; | |
1241 | struct iommu_group *group; | |
1242 | int i, idx, ret; | |
1243 | ||
1244 | mutex_lock(&smmu->stream_map_mutex); | |
1245 | /* Figure out a viable stream map entry allocation */ | |
adfec2e7 | 1246 | for_each_cfg_sme(fwspec, i, idx) { |
021bb842 RM |
1247 | u16 sid = fwspec->ids[i]; |
1248 | u16 mask = fwspec->ids[i] >> SMR_MASK_SHIFT; | |
1249 | ||
588888a7 RM |
1250 | if (idx != INVALID_SMENDX) { |
1251 | ret = -EEXIST; | |
1252 | goto out_err; | |
45ae7cff WD |
1253 | } |
1254 | ||
021bb842 | 1255 | ret = arm_smmu_find_sme(smmu, sid, mask); |
588888a7 RM |
1256 | if (ret < 0) |
1257 | goto out_err; | |
1258 | ||
1259 | idx = ret; | |
1260 | if (smrs && smmu->s2crs[idx].count == 0) { | |
021bb842 RM |
1261 | smrs[idx].id = sid; |
1262 | smrs[idx].mask = mask; | |
588888a7 RM |
1263 | smrs[idx].valid = true; |
1264 | } | |
1265 | smmu->s2crs[idx].count++; | |
1266 | cfg->smendx[i] = (s16)idx; | |
45ae7cff WD |
1267 | } |
1268 | ||
588888a7 RM |
1269 | group = iommu_group_get_for_dev(dev); |
1270 | if (!group) | |
1271 | group = ERR_PTR(-ENOMEM); | |
1272 | if (IS_ERR(group)) { | |
1273 | ret = PTR_ERR(group); | |
1274 | goto out_err; | |
1275 | } | |
1276 | iommu_group_put(group); | |
1f3d5ca4 | 1277 | |
45ae7cff | 1278 | /* It worked! Now, poke the actual hardware */ |
adfec2e7 | 1279 | for_each_cfg_sme(fwspec, i, idx) { |
588888a7 RM |
1280 | arm_smmu_write_sme(smmu, idx); |
1281 | smmu->s2crs[idx].group = group; | |
1282 | } | |
45ae7cff | 1283 | |
588888a7 | 1284 | mutex_unlock(&smmu->stream_map_mutex); |
45ae7cff WD |
1285 | return 0; |
1286 | ||
588888a7 | 1287 | out_err: |
1f3d5ca4 | 1288 | while (i--) { |
588888a7 | 1289 | arm_smmu_free_sme(smmu, cfg->smendx[i]); |
1f3d5ca4 RM |
1290 | cfg->smendx[i] = INVALID_SMENDX; |
1291 | } | |
588888a7 RM |
1292 | mutex_unlock(&smmu->stream_map_mutex); |
1293 | return ret; | |
45ae7cff WD |
1294 | } |
1295 | ||
adfec2e7 | 1296 | static void arm_smmu_master_free_smes(struct iommu_fwspec *fwspec) |
45ae7cff | 1297 | { |
adfec2e7 RM |
1298 | struct arm_smmu_device *smmu = fwspec_smmu(fwspec); |
1299 | struct arm_smmu_master_cfg *cfg = fwspec->iommu_priv; | |
d3097e39 | 1300 | int i, idx; |
43b412be | 1301 | |
588888a7 | 1302 | mutex_lock(&smmu->stream_map_mutex); |
adfec2e7 | 1303 | for_each_cfg_sme(fwspec, i, idx) { |
588888a7 RM |
1304 | if (arm_smmu_free_sme(smmu, idx)) |
1305 | arm_smmu_write_sme(smmu, idx); | |
1f3d5ca4 | 1306 | cfg->smendx[i] = INVALID_SMENDX; |
45ae7cff | 1307 | } |
588888a7 | 1308 | mutex_unlock(&smmu->stream_map_mutex); |
45ae7cff WD |
1309 | } |
1310 | ||
45ae7cff | 1311 | static int arm_smmu_domain_add_master(struct arm_smmu_domain *smmu_domain, |
adfec2e7 | 1312 | struct iommu_fwspec *fwspec) |
45ae7cff | 1313 | { |
44680eed | 1314 | struct arm_smmu_device *smmu = smmu_domain->smmu; |
8e8b203e | 1315 | struct arm_smmu_s2cr *s2cr = smmu->s2crs; |
8e8b203e | 1316 | u8 cbndx = smmu_domain->cfg.cbndx; |
61bc6711 | 1317 | enum arm_smmu_s2cr_type type; |
588888a7 | 1318 | int i, idx; |
45ae7cff | 1319 | |
61bc6711 WD |
1320 | if (smmu_domain->stage == ARM_SMMU_DOMAIN_BYPASS) |
1321 | type = S2CR_TYPE_BYPASS; | |
1322 | else | |
1323 | type = S2CR_TYPE_TRANS; | |
1324 | ||
adfec2e7 | 1325 | for_each_cfg_sme(fwspec, i, idx) { |
8e8b203e | 1326 | if (type == s2cr[idx].type && cbndx == s2cr[idx].cbndx) |
588888a7 | 1327 | continue; |
1f3d5ca4 | 1328 | |
8e8b203e | 1329 | s2cr[idx].type = type; |
e1989807 | 1330 | s2cr[idx].privcfg = S2CR_PRIVCFG_DEFAULT; |
8e8b203e RM |
1331 | s2cr[idx].cbndx = cbndx; |
1332 | arm_smmu_write_s2cr(smmu, idx); | |
43b412be | 1333 | } |
8e8b203e | 1334 | return 0; |
bc7f2ce0 WD |
1335 | } |
1336 | ||
45ae7cff WD |
1337 | static int arm_smmu_attach_dev(struct iommu_domain *domain, struct device *dev) |
1338 | { | |
a18037b2 | 1339 | int ret; |
adfec2e7 RM |
1340 | struct iommu_fwspec *fwspec = dev->iommu_fwspec; |
1341 | struct arm_smmu_device *smmu; | |
1d672638 | 1342 | struct arm_smmu_domain *smmu_domain = to_smmu_domain(domain); |
45ae7cff | 1343 | |
adfec2e7 | 1344 | if (!fwspec || fwspec->ops != &arm_smmu_ops) { |
45ae7cff WD |
1345 | dev_err(dev, "cannot attach to SMMU, is it on the same bus?\n"); |
1346 | return -ENXIO; | |
1347 | } | |
1348 | ||
fba4f8e5 RM |
1349 | /* |
1350 | * FIXME: The arch/arm DMA API code tries to attach devices to its own | |
1351 | * domains between of_xlate() and add_device() - we have no way to cope | |
1352 | * with that, so until ARM gets converted to rely on groups and default | |
1353 | * domains, just say no (but more politely than by dereferencing NULL). | |
1354 | * This should be at least a WARN_ON once that's sorted. | |
1355 | */ | |
1356 | if (!fwspec->iommu_priv) | |
1357 | return -ENODEV; | |
1358 | ||
adfec2e7 | 1359 | smmu = fwspec_smmu(fwspec); |
518f7136 | 1360 | /* Ensure that the domain is finalised */ |
adfec2e7 | 1361 | ret = arm_smmu_init_domain_context(domain, smmu); |
287980e4 | 1362 | if (ret < 0) |
518f7136 WD |
1363 | return ret; |
1364 | ||
45ae7cff | 1365 | /* |
44680eed WD |
1366 | * Sanity check the domain. We don't support domains across |
1367 | * different SMMUs. | |
45ae7cff | 1368 | */ |
adfec2e7 | 1369 | if (smmu_domain->smmu != smmu) { |
45ae7cff WD |
1370 | dev_err(dev, |
1371 | "cannot attach to SMMU %s whilst already attached to domain on SMMU %s\n", | |
adfec2e7 | 1372 | dev_name(smmu_domain->smmu->dev), dev_name(smmu->dev)); |
a18037b2 | 1373 | return -EINVAL; |
45ae7cff | 1374 | } |
45ae7cff WD |
1375 | |
1376 | /* Looks ok, so add the device to the domain */ | |
adfec2e7 | 1377 | return arm_smmu_domain_add_master(smmu_domain, fwspec); |
45ae7cff WD |
1378 | } |
1379 | ||
45ae7cff | 1380 | static int arm_smmu_map(struct iommu_domain *domain, unsigned long iova, |
b410aed9 | 1381 | phys_addr_t paddr, size_t size, int prot) |
45ae7cff | 1382 | { |
518f7136 WD |
1383 | int ret; |
1384 | unsigned long flags; | |
1d672638 | 1385 | struct arm_smmu_domain *smmu_domain = to_smmu_domain(domain); |
518f7136 | 1386 | struct io_pgtable_ops *ops= smmu_domain->pgtbl_ops; |
45ae7cff | 1387 | |
518f7136 | 1388 | if (!ops) |
45ae7cff WD |
1389 | return -ENODEV; |
1390 | ||
518f7136 WD |
1391 | spin_lock_irqsave(&smmu_domain->pgtbl_lock, flags); |
1392 | ret = ops->map(ops, iova, paddr, size, prot); | |
1393 | spin_unlock_irqrestore(&smmu_domain->pgtbl_lock, flags); | |
1394 | return ret; | |
45ae7cff WD |
1395 | } |
1396 | ||
1397 | static size_t arm_smmu_unmap(struct iommu_domain *domain, unsigned long iova, | |
1398 | size_t size) | |
1399 | { | |
518f7136 WD |
1400 | size_t ret; |
1401 | unsigned long flags; | |
1d672638 | 1402 | struct arm_smmu_domain *smmu_domain = to_smmu_domain(domain); |
518f7136 | 1403 | struct io_pgtable_ops *ops= smmu_domain->pgtbl_ops; |
45ae7cff | 1404 | |
518f7136 WD |
1405 | if (!ops) |
1406 | return 0; | |
1407 | ||
1408 | spin_lock_irqsave(&smmu_domain->pgtbl_lock, flags); | |
1409 | ret = ops->unmap(ops, iova, size); | |
1410 | spin_unlock_irqrestore(&smmu_domain->pgtbl_lock, flags); | |
1411 | return ret; | |
45ae7cff WD |
1412 | } |
1413 | ||
859a732e MH |
1414 | static phys_addr_t arm_smmu_iova_to_phys_hard(struct iommu_domain *domain, |
1415 | dma_addr_t iova) | |
1416 | { | |
1d672638 | 1417 | struct arm_smmu_domain *smmu_domain = to_smmu_domain(domain); |
859a732e MH |
1418 | struct arm_smmu_device *smmu = smmu_domain->smmu; |
1419 | struct arm_smmu_cfg *cfg = &smmu_domain->cfg; | |
1420 | struct io_pgtable_ops *ops= smmu_domain->pgtbl_ops; | |
1421 | struct device *dev = smmu->dev; | |
1422 | void __iomem *cb_base; | |
1423 | u32 tmp; | |
1424 | u64 phys; | |
661d962f | 1425 | unsigned long va; |
859a732e | 1426 | |
452107c7 | 1427 | cb_base = ARM_SMMU_CB(smmu, cfg->cbndx); |
859a732e | 1428 | |
661d962f RM |
1429 | /* ATS1 registers can only be written atomically */ |
1430 | va = iova & ~0xfffUL; | |
661d962f | 1431 | if (smmu->version == ARM_SMMU_V2) |
f9a05f05 RM |
1432 | smmu_write_atomic_lq(va, cb_base + ARM_SMMU_CB_ATS1PR); |
1433 | else /* Register is only 32-bit in v1 */ | |
661d962f | 1434 | writel_relaxed(va, cb_base + ARM_SMMU_CB_ATS1PR); |
859a732e MH |
1435 | |
1436 | if (readl_poll_timeout_atomic(cb_base + ARM_SMMU_CB_ATSR, tmp, | |
1437 | !(tmp & ATSR_ACTIVE), 5, 50)) { | |
1438 | dev_err(dev, | |
077124c9 | 1439 | "iova to phys timed out on %pad. Falling back to software table walk.\n", |
859a732e MH |
1440 | &iova); |
1441 | return ops->iova_to_phys(ops, iova); | |
1442 | } | |
1443 | ||
f9a05f05 | 1444 | phys = readq_relaxed(cb_base + ARM_SMMU_CB_PAR); |
859a732e MH |
1445 | if (phys & CB_PAR_F) { |
1446 | dev_err(dev, "translation fault!\n"); | |
1447 | dev_err(dev, "PAR = 0x%llx\n", phys); | |
1448 | return 0; | |
1449 | } | |
1450 | ||
1451 | return (phys & GENMASK_ULL(39, 12)) | (iova & 0xfff); | |
1452 | } | |
1453 | ||
45ae7cff | 1454 | static phys_addr_t arm_smmu_iova_to_phys(struct iommu_domain *domain, |
859a732e | 1455 | dma_addr_t iova) |
45ae7cff | 1456 | { |
518f7136 WD |
1457 | phys_addr_t ret; |
1458 | unsigned long flags; | |
1d672638 | 1459 | struct arm_smmu_domain *smmu_domain = to_smmu_domain(domain); |
518f7136 | 1460 | struct io_pgtable_ops *ops= smmu_domain->pgtbl_ops; |
45ae7cff | 1461 | |
bdf95923 SG |
1462 | if (domain->type == IOMMU_DOMAIN_IDENTITY) |
1463 | return iova; | |
1464 | ||
518f7136 | 1465 | if (!ops) |
a44a9791 | 1466 | return 0; |
45ae7cff | 1467 | |
518f7136 | 1468 | spin_lock_irqsave(&smmu_domain->pgtbl_lock, flags); |
83a60ed8 BR |
1469 | if (smmu_domain->smmu->features & ARM_SMMU_FEAT_TRANS_OPS && |
1470 | smmu_domain->stage == ARM_SMMU_DOMAIN_S1) { | |
859a732e | 1471 | ret = arm_smmu_iova_to_phys_hard(domain, iova); |
83a60ed8 | 1472 | } else { |
859a732e | 1473 | ret = ops->iova_to_phys(ops, iova); |
83a60ed8 BR |
1474 | } |
1475 | ||
518f7136 | 1476 | spin_unlock_irqrestore(&smmu_domain->pgtbl_lock, flags); |
859a732e | 1477 | |
518f7136 | 1478 | return ret; |
45ae7cff WD |
1479 | } |
1480 | ||
1fd0c775 | 1481 | static bool arm_smmu_capable(enum iommu_cap cap) |
45ae7cff | 1482 | { |
d0948945 WD |
1483 | switch (cap) { |
1484 | case IOMMU_CAP_CACHE_COHERENCY: | |
1fd0c775 JR |
1485 | /* |
1486 | * Return true here as the SMMU can always send out coherent | |
1487 | * requests. | |
1488 | */ | |
1489 | return true; | |
0029a8dd AM |
1490 | case IOMMU_CAP_NOEXEC: |
1491 | return true; | |
d0948945 | 1492 | default: |
1fd0c775 | 1493 | return false; |
d0948945 | 1494 | } |
45ae7cff | 1495 | } |
45ae7cff | 1496 | |
021bb842 RM |
1497 | static int arm_smmu_match_node(struct device *dev, void *data) |
1498 | { | |
ce9babe5 | 1499 | return dev->fwnode == data; |
021bb842 RM |
1500 | } |
1501 | ||
ce9babe5 LP |
1502 | static |
1503 | struct arm_smmu_device *arm_smmu_get_by_fwnode(struct fwnode_handle *fwnode) | |
021bb842 RM |
1504 | { |
1505 | struct device *dev = driver_find_device(&arm_smmu_driver.driver, NULL, | |
ce9babe5 | 1506 | fwnode, arm_smmu_match_node); |
021bb842 RM |
1507 | put_device(dev); |
1508 | return dev ? dev_get_drvdata(dev) : NULL; | |
1509 | } | |
1510 | ||
f80cd885 | 1511 | static int arm_smmu_add_device(struct device *dev) |
45ae7cff | 1512 | { |
adfec2e7 | 1513 | struct arm_smmu_device *smmu; |
03edb226 | 1514 | struct arm_smmu_master_cfg *cfg; |
021bb842 | 1515 | struct iommu_fwspec *fwspec = dev->iommu_fwspec; |
f80cd885 | 1516 | int i, ret; |
8f68f8e2 | 1517 | |
021bb842 RM |
1518 | if (using_legacy_binding) { |
1519 | ret = arm_smmu_register_legacy_master(dev, &smmu); | |
1520 | fwspec = dev->iommu_fwspec; | |
1521 | if (ret) | |
1522 | goto out_free; | |
3c117b54 | 1523 | } else if (fwspec && fwspec->ops == &arm_smmu_ops) { |
ce9babe5 | 1524 | smmu = arm_smmu_get_by_fwnode(fwspec->iommu_fwnode); |
021bb842 RM |
1525 | } else { |
1526 | return -ENODEV; | |
1527 | } | |
a9a1b0b5 | 1528 | |
f80cd885 | 1529 | ret = -EINVAL; |
adfec2e7 RM |
1530 | for (i = 0; i < fwspec->num_ids; i++) { |
1531 | u16 sid = fwspec->ids[i]; | |
021bb842 | 1532 | u16 mask = fwspec->ids[i] >> SMR_MASK_SHIFT; |
03edb226 | 1533 | |
adfec2e7 | 1534 | if (sid & ~smmu->streamid_mask) { |
f80cd885 | 1535 | dev_err(dev, "stream ID 0x%x out of range for SMMU (0x%x)\n", |
021bb842 RM |
1536 | sid, smmu->streamid_mask); |
1537 | goto out_free; | |
1538 | } | |
1539 | if (mask & ~smmu->smr_mask_mask) { | |
1540 | dev_err(dev, "SMR mask 0x%x out of range for SMMU (0x%x)\n", | |
6323f474 | 1541 | mask, smmu->smr_mask_mask); |
f80cd885 RM |
1542 | goto out_free; |
1543 | } | |
1f3d5ca4 | 1544 | } |
5fc63a7c | 1545 | |
adfec2e7 RM |
1546 | ret = -ENOMEM; |
1547 | cfg = kzalloc(offsetof(struct arm_smmu_master_cfg, smendx[i]), | |
1548 | GFP_KERNEL); | |
1549 | if (!cfg) | |
1550 | goto out_free; | |
1551 | ||
1552 | cfg->smmu = smmu; | |
1553 | fwspec->iommu_priv = cfg; | |
1554 | while (i--) | |
1555 | cfg->smendx[i] = INVALID_SMENDX; | |
1556 | ||
588888a7 | 1557 | ret = arm_smmu_master_alloc_smes(dev); |
adfec2e7 RM |
1558 | if (ret) |
1559 | goto out_free; | |
1560 | ||
9648cbc9 JR |
1561 | iommu_device_link(&smmu->iommu, dev); |
1562 | ||
adfec2e7 | 1563 | return 0; |
f80cd885 RM |
1564 | |
1565 | out_free: | |
adfec2e7 RM |
1566 | if (fwspec) |
1567 | kfree(fwspec->iommu_priv); | |
1568 | iommu_fwspec_free(dev); | |
f80cd885 | 1569 | return ret; |
03edb226 WD |
1570 | } |
1571 | ||
45ae7cff WD |
1572 | static void arm_smmu_remove_device(struct device *dev) |
1573 | { | |
adfec2e7 | 1574 | struct iommu_fwspec *fwspec = dev->iommu_fwspec; |
9648cbc9 JR |
1575 | struct arm_smmu_master_cfg *cfg; |
1576 | struct arm_smmu_device *smmu; | |
1577 | ||
8e8b203e | 1578 | |
adfec2e7 | 1579 | if (!fwspec || fwspec->ops != &arm_smmu_ops) |
f80cd885 | 1580 | return; |
8e8b203e | 1581 | |
9648cbc9 JR |
1582 | cfg = fwspec->iommu_priv; |
1583 | smmu = cfg->smmu; | |
1584 | ||
1585 | iommu_device_unlink(&smmu->iommu, dev); | |
adfec2e7 | 1586 | arm_smmu_master_free_smes(fwspec); |
5fc63a7c | 1587 | iommu_group_remove_device(dev); |
adfec2e7 RM |
1588 | kfree(fwspec->iommu_priv); |
1589 | iommu_fwspec_free(dev); | |
45ae7cff WD |
1590 | } |
1591 | ||
af659932 JR |
1592 | static struct iommu_group *arm_smmu_device_group(struct device *dev) |
1593 | { | |
adfec2e7 RM |
1594 | struct iommu_fwspec *fwspec = dev->iommu_fwspec; |
1595 | struct arm_smmu_device *smmu = fwspec_smmu(fwspec); | |
588888a7 RM |
1596 | struct iommu_group *group = NULL; |
1597 | int i, idx; | |
1598 | ||
adfec2e7 | 1599 | for_each_cfg_sme(fwspec, i, idx) { |
588888a7 RM |
1600 | if (group && smmu->s2crs[idx].group && |
1601 | group != smmu->s2crs[idx].group) | |
1602 | return ERR_PTR(-EINVAL); | |
1603 | ||
1604 | group = smmu->s2crs[idx].group; | |
1605 | } | |
1606 | ||
1607 | if (group) | |
e1b44cbe | 1608 | return iommu_group_ref_get(group); |
af659932 JR |
1609 | |
1610 | if (dev_is_pci(dev)) | |
1611 | group = pci_device_group(dev); | |
1612 | else | |
1613 | group = generic_device_group(dev); | |
1614 | ||
af659932 JR |
1615 | return group; |
1616 | } | |
1617 | ||
c752ce45 WD |
1618 | static int arm_smmu_domain_get_attr(struct iommu_domain *domain, |
1619 | enum iommu_attr attr, void *data) | |
1620 | { | |
1d672638 | 1621 | struct arm_smmu_domain *smmu_domain = to_smmu_domain(domain); |
c752ce45 | 1622 | |
0834cc28 WD |
1623 | if (domain->type != IOMMU_DOMAIN_UNMANAGED) |
1624 | return -EINVAL; | |
1625 | ||
c752ce45 WD |
1626 | switch (attr) { |
1627 | case DOMAIN_ATTR_NESTING: | |
1628 | *(int *)data = (smmu_domain->stage == ARM_SMMU_DOMAIN_NESTED); | |
1629 | return 0; | |
1630 | default: | |
1631 | return -ENODEV; | |
1632 | } | |
1633 | } | |
1634 | ||
1635 | static int arm_smmu_domain_set_attr(struct iommu_domain *domain, | |
1636 | enum iommu_attr attr, void *data) | |
1637 | { | |
518f7136 | 1638 | int ret = 0; |
1d672638 | 1639 | struct arm_smmu_domain *smmu_domain = to_smmu_domain(domain); |
c752ce45 | 1640 | |
0834cc28 WD |
1641 | if (domain->type != IOMMU_DOMAIN_UNMANAGED) |
1642 | return -EINVAL; | |
1643 | ||
518f7136 WD |
1644 | mutex_lock(&smmu_domain->init_mutex); |
1645 | ||
c752ce45 WD |
1646 | switch (attr) { |
1647 | case DOMAIN_ATTR_NESTING: | |
518f7136 WD |
1648 | if (smmu_domain->smmu) { |
1649 | ret = -EPERM; | |
1650 | goto out_unlock; | |
1651 | } | |
1652 | ||
c752ce45 WD |
1653 | if (*(int *)data) |
1654 | smmu_domain->stage = ARM_SMMU_DOMAIN_NESTED; | |
1655 | else | |
1656 | smmu_domain->stage = ARM_SMMU_DOMAIN_S1; | |
1657 | ||
518f7136 | 1658 | break; |
c752ce45 | 1659 | default: |
518f7136 | 1660 | ret = -ENODEV; |
c752ce45 | 1661 | } |
518f7136 WD |
1662 | |
1663 | out_unlock: | |
1664 | mutex_unlock(&smmu_domain->init_mutex); | |
1665 | return ret; | |
c752ce45 WD |
1666 | } |
1667 | ||
021bb842 RM |
1668 | static int arm_smmu_of_xlate(struct device *dev, struct of_phandle_args *args) |
1669 | { | |
56fbf600 | 1670 | u32 mask, fwid = 0; |
021bb842 RM |
1671 | |
1672 | if (args->args_count > 0) | |
1673 | fwid |= (u16)args->args[0]; | |
1674 | ||
1675 | if (args->args_count > 1) | |
1676 | fwid |= (u16)args->args[1] << SMR_MASK_SHIFT; | |
56fbf600 RM |
1677 | else if (!of_property_read_u32(args->np, "stream-match-mask", &mask)) |
1678 | fwid |= (u16)mask << SMR_MASK_SHIFT; | |
021bb842 RM |
1679 | |
1680 | return iommu_fwspec_add_ids(dev, &fwid, 1); | |
1681 | } | |
1682 | ||
f3ebee80 EA |
1683 | static void arm_smmu_get_resv_regions(struct device *dev, |
1684 | struct list_head *head) | |
1685 | { | |
1686 | struct iommu_resv_region *region; | |
1687 | int prot = IOMMU_WRITE | IOMMU_NOEXEC | IOMMU_MMIO; | |
1688 | ||
1689 | region = iommu_alloc_resv_region(MSI_IOVA_BASE, MSI_IOVA_LENGTH, | |
9d3a4de4 | 1690 | prot, IOMMU_RESV_SW_MSI); |
f3ebee80 EA |
1691 | if (!region) |
1692 | return; | |
1693 | ||
1694 | list_add_tail(®ion->list, head); | |
273df963 RM |
1695 | |
1696 | iommu_dma_get_resv_regions(dev, head); | |
f3ebee80 EA |
1697 | } |
1698 | ||
1699 | static void arm_smmu_put_resv_regions(struct device *dev, | |
1700 | struct list_head *head) | |
1701 | { | |
1702 | struct iommu_resv_region *entry, *next; | |
1703 | ||
1704 | list_for_each_entry_safe(entry, next, head, list) | |
1705 | kfree(entry); | |
1706 | } | |
1707 | ||
518f7136 | 1708 | static struct iommu_ops arm_smmu_ops = { |
c752ce45 | 1709 | .capable = arm_smmu_capable, |
1d672638 JR |
1710 | .domain_alloc = arm_smmu_domain_alloc, |
1711 | .domain_free = arm_smmu_domain_free, | |
c752ce45 | 1712 | .attach_dev = arm_smmu_attach_dev, |
c752ce45 WD |
1713 | .map = arm_smmu_map, |
1714 | .unmap = arm_smmu_unmap, | |
76771c93 | 1715 | .map_sg = default_iommu_map_sg, |
c752ce45 WD |
1716 | .iova_to_phys = arm_smmu_iova_to_phys, |
1717 | .add_device = arm_smmu_add_device, | |
1718 | .remove_device = arm_smmu_remove_device, | |
af659932 | 1719 | .device_group = arm_smmu_device_group, |
c752ce45 WD |
1720 | .domain_get_attr = arm_smmu_domain_get_attr, |
1721 | .domain_set_attr = arm_smmu_domain_set_attr, | |
021bb842 | 1722 | .of_xlate = arm_smmu_of_xlate, |
f3ebee80 EA |
1723 | .get_resv_regions = arm_smmu_get_resv_regions, |
1724 | .put_resv_regions = arm_smmu_put_resv_regions, | |
518f7136 | 1725 | .pgsize_bitmap = -1UL, /* Restricted during device attach */ |
45ae7cff WD |
1726 | }; |
1727 | ||
1728 | static void arm_smmu_device_reset(struct arm_smmu_device *smmu) | |
1729 | { | |
1730 | void __iomem *gr0_base = ARM_SMMU_GR0(smmu); | |
659db6f6 | 1731 | void __iomem *cb_base; |
1f3d5ca4 | 1732 | int i; |
3ca3712a | 1733 | u32 reg, major; |
659db6f6 | 1734 | |
3a5df8ff AH |
1735 | /* clear global FSR */ |
1736 | reg = readl_relaxed(ARM_SMMU_GR0_NS(smmu) + ARM_SMMU_GR0_sGFSR); | |
1737 | writel(reg, ARM_SMMU_GR0_NS(smmu) + ARM_SMMU_GR0_sGFSR); | |
45ae7cff | 1738 | |
1f3d5ca4 RM |
1739 | /* |
1740 | * Reset stream mapping groups: Initial values mark all SMRn as | |
1741 | * invalid and all S2CRn as bypass unless overridden. | |
1742 | */ | |
8e8b203e RM |
1743 | for (i = 0; i < smmu->num_mapping_groups; ++i) |
1744 | arm_smmu_write_sme(smmu, i); | |
45ae7cff | 1745 | |
6eb18d4a NG |
1746 | if (smmu->model == ARM_MMU500) { |
1747 | /* | |
1748 | * Before clearing ARM_MMU500_ACTLR_CPRE, need to | |
1749 | * clear CACHE_LOCK bit of ACR first. And, CACHE_LOCK | |
1750 | * bit is only present in MMU-500r2 onwards. | |
1751 | */ | |
1752 | reg = readl_relaxed(gr0_base + ARM_SMMU_GR0_ID7); | |
1753 | major = (reg >> ID7_MAJOR_SHIFT) & ID7_MAJOR_MASK; | |
3ca3712a | 1754 | reg = readl_relaxed(gr0_base + ARM_SMMU_GR0_sACR); |
6eb18d4a NG |
1755 | if (major >= 2) |
1756 | reg &= ~ARM_MMU500_ACR_CACHE_LOCK; | |
1757 | /* | |
1758 | * Allow unmatched Stream IDs to allocate bypass | |
1759 | * TLB entries for reduced latency. | |
1760 | */ | |
1761 | reg |= ARM_MMU500_ACR_SMTNMB_TLBEN; | |
3ca3712a PF |
1762 | writel_relaxed(reg, gr0_base + ARM_SMMU_GR0_sACR); |
1763 | } | |
1764 | ||
659db6f6 AH |
1765 | /* Make sure all context banks are disabled and clear CB_FSR */ |
1766 | for (i = 0; i < smmu->num_context_banks; ++i) { | |
452107c7 | 1767 | cb_base = ARM_SMMU_CB(smmu, i); |
659db6f6 AH |
1768 | writel_relaxed(0, cb_base + ARM_SMMU_CB_SCTLR); |
1769 | writel_relaxed(FSR_FAULT, cb_base + ARM_SMMU_CB_FSR); | |
f0cfffc4 RM |
1770 | /* |
1771 | * Disable MMU-500's not-particularly-beneficial next-page | |
1772 | * prefetcher for the sake of errata #841119 and #826419. | |
1773 | */ | |
1774 | if (smmu->model == ARM_MMU500) { | |
1775 | reg = readl_relaxed(cb_base + ARM_SMMU_CB_ACTLR); | |
1776 | reg &= ~ARM_MMU500_ACTLR_CPRE; | |
1777 | writel_relaxed(reg, cb_base + ARM_SMMU_CB_ACTLR); | |
1778 | } | |
659db6f6 | 1779 | } |
1463fe44 | 1780 | |
45ae7cff | 1781 | /* Invalidate the TLB, just in case */ |
45ae7cff WD |
1782 | writel_relaxed(0, gr0_base + ARM_SMMU_GR0_TLBIALLH); |
1783 | writel_relaxed(0, gr0_base + ARM_SMMU_GR0_TLBIALLNSNH); | |
1784 | ||
3a5df8ff | 1785 | reg = readl_relaxed(ARM_SMMU_GR0_NS(smmu) + ARM_SMMU_GR0_sCR0); |
659db6f6 | 1786 | |
45ae7cff | 1787 | /* Enable fault reporting */ |
659db6f6 | 1788 | reg |= (sCR0_GFRE | sCR0_GFIE | sCR0_GCFGFRE | sCR0_GCFGFIE); |
45ae7cff WD |
1789 | |
1790 | /* Disable TLB broadcasting. */ | |
659db6f6 | 1791 | reg |= (sCR0_VMIDPNE | sCR0_PTM); |
45ae7cff | 1792 | |
25a1c96c RM |
1793 | /* Enable client access, handling unmatched streams as appropriate */ |
1794 | reg &= ~sCR0_CLIENTPD; | |
1795 | if (disable_bypass) | |
1796 | reg |= sCR0_USFCFG; | |
1797 | else | |
1798 | reg &= ~sCR0_USFCFG; | |
45ae7cff WD |
1799 | |
1800 | /* Disable forced broadcasting */ | |
659db6f6 | 1801 | reg &= ~sCR0_FB; |
45ae7cff WD |
1802 | |
1803 | /* Don't upgrade barriers */ | |
659db6f6 | 1804 | reg &= ~(sCR0_BSU_MASK << sCR0_BSU_SHIFT); |
45ae7cff | 1805 | |
4e3e9b69 TC |
1806 | if (smmu->features & ARM_SMMU_FEAT_VMID16) |
1807 | reg |= sCR0_VMID16EN; | |
1808 | ||
dc0eaa4e AM |
1809 | if (smmu->features & ARM_SMMU_FEAT_EXIDS) |
1810 | reg |= sCR0_EXIDENABLE; | |
1811 | ||
45ae7cff | 1812 | /* Push the button */ |
11febfca | 1813 | arm_smmu_tlb_sync_global(smmu); |
3a5df8ff | 1814 | writel(reg, ARM_SMMU_GR0_NS(smmu) + ARM_SMMU_GR0_sCR0); |
45ae7cff WD |
1815 | } |
1816 | ||
1817 | static int arm_smmu_id_size_to_bits(int size) | |
1818 | { | |
1819 | switch (size) { | |
1820 | case 0: | |
1821 | return 32; | |
1822 | case 1: | |
1823 | return 36; | |
1824 | case 2: | |
1825 | return 40; | |
1826 | case 3: | |
1827 | return 42; | |
1828 | case 4: | |
1829 | return 44; | |
1830 | case 5: | |
1831 | default: | |
1832 | return 48; | |
1833 | } | |
1834 | } | |
1835 | ||
1836 | static int arm_smmu_device_cfg_probe(struct arm_smmu_device *smmu) | |
1837 | { | |
1838 | unsigned long size; | |
1839 | void __iomem *gr0_base = ARM_SMMU_GR0(smmu); | |
1840 | u32 id; | |
bbb8a184 | 1841 | bool cttw_reg, cttw_fw = smmu->features & ARM_SMMU_FEAT_COHERENT_WALK; |
8e8b203e | 1842 | int i; |
45ae7cff WD |
1843 | |
1844 | dev_notice(smmu->dev, "probing hardware configuration...\n"); | |
b7862e35 RM |
1845 | dev_notice(smmu->dev, "SMMUv%d with:\n", |
1846 | smmu->version == ARM_SMMU_V2 ? 2 : 1); | |
45ae7cff WD |
1847 | |
1848 | /* ID0 */ | |
1849 | id = readl_relaxed(gr0_base + ARM_SMMU_GR0_ID0); | |
4cf740b0 WD |
1850 | |
1851 | /* Restrict available stages based on module parameter */ | |
1852 | if (force_stage == 1) | |
1853 | id &= ~(ID0_S2TS | ID0_NTS); | |
1854 | else if (force_stage == 2) | |
1855 | id &= ~(ID0_S1TS | ID0_NTS); | |
1856 | ||
45ae7cff WD |
1857 | if (id & ID0_S1TS) { |
1858 | smmu->features |= ARM_SMMU_FEAT_TRANS_S1; | |
1859 | dev_notice(smmu->dev, "\tstage 1 translation\n"); | |
1860 | } | |
1861 | ||
1862 | if (id & ID0_S2TS) { | |
1863 | smmu->features |= ARM_SMMU_FEAT_TRANS_S2; | |
1864 | dev_notice(smmu->dev, "\tstage 2 translation\n"); | |
1865 | } | |
1866 | ||
1867 | if (id & ID0_NTS) { | |
1868 | smmu->features |= ARM_SMMU_FEAT_TRANS_NESTED; | |
1869 | dev_notice(smmu->dev, "\tnested translation\n"); | |
1870 | } | |
1871 | ||
1872 | if (!(smmu->features & | |
4cf740b0 | 1873 | (ARM_SMMU_FEAT_TRANS_S1 | ARM_SMMU_FEAT_TRANS_S2))) { |
45ae7cff WD |
1874 | dev_err(smmu->dev, "\tno translation support!\n"); |
1875 | return -ENODEV; | |
1876 | } | |
1877 | ||
b7862e35 RM |
1878 | if ((id & ID0_S1TS) && |
1879 | ((smmu->version < ARM_SMMU_V2) || !(id & ID0_ATOSNS))) { | |
859a732e MH |
1880 | smmu->features |= ARM_SMMU_FEAT_TRANS_OPS; |
1881 | dev_notice(smmu->dev, "\taddress translation ops\n"); | |
1882 | } | |
1883 | ||
bae2c2d4 RM |
1884 | /* |
1885 | * In order for DMA API calls to work properly, we must defer to what | |
bbb8a184 | 1886 | * the FW says about coherency, regardless of what the hardware claims. |
bae2c2d4 RM |
1887 | * Fortunately, this also opens up a workaround for systems where the |
1888 | * ID register value has ended up configured incorrectly. | |
1889 | */ | |
bae2c2d4 | 1890 | cttw_reg = !!(id & ID0_CTTW); |
bbb8a184 | 1891 | if (cttw_fw || cttw_reg) |
bae2c2d4 | 1892 | dev_notice(smmu->dev, "\t%scoherent table walk\n", |
bbb8a184 LP |
1893 | cttw_fw ? "" : "non-"); |
1894 | if (cttw_fw != cttw_reg) | |
bae2c2d4 | 1895 | dev_notice(smmu->dev, |
bbb8a184 | 1896 | "\t(IDR0.CTTW overridden by FW configuration)\n"); |
45ae7cff | 1897 | |
21174240 | 1898 | /* Max. number of entries we have for stream matching/indexing */ |
dc0eaa4e AM |
1899 | if (smmu->version == ARM_SMMU_V2 && id & ID0_EXIDS) { |
1900 | smmu->features |= ARM_SMMU_FEAT_EXIDS; | |
1901 | size = 1 << 16; | |
1902 | } else { | |
1903 | size = 1 << ((id >> ID0_NUMSIDB_SHIFT) & ID0_NUMSIDB_MASK); | |
1904 | } | |
21174240 | 1905 | smmu->streamid_mask = size - 1; |
45ae7cff | 1906 | if (id & ID0_SMS) { |
45ae7cff | 1907 | smmu->features |= ARM_SMMU_FEAT_STREAM_MATCH; |
21174240 RM |
1908 | size = (id >> ID0_NUMSMRG_SHIFT) & ID0_NUMSMRG_MASK; |
1909 | if (size == 0) { | |
45ae7cff WD |
1910 | dev_err(smmu->dev, |
1911 | "stream-matching supported, but no SMRs present!\n"); | |
1912 | return -ENODEV; | |
1913 | } | |
1914 | ||
1f3d5ca4 RM |
1915 | /* Zero-initialised to mark as invalid */ |
1916 | smmu->smrs = devm_kcalloc(smmu->dev, size, sizeof(*smmu->smrs), | |
1917 | GFP_KERNEL); | |
1918 | if (!smmu->smrs) | |
1919 | return -ENOMEM; | |
1920 | ||
45ae7cff | 1921 | dev_notice(smmu->dev, |
dc0eaa4e | 1922 | "\tstream matching with %lu register groups", size); |
45ae7cff | 1923 | } |
8e8b203e RM |
1924 | /* s2cr->type == 0 means translation, so initialise explicitly */ |
1925 | smmu->s2crs = devm_kmalloc_array(smmu->dev, size, sizeof(*smmu->s2crs), | |
1926 | GFP_KERNEL); | |
1927 | if (!smmu->s2crs) | |
1928 | return -ENOMEM; | |
1929 | for (i = 0; i < size; i++) | |
1930 | smmu->s2crs[i] = s2cr_init_val; | |
1931 | ||
21174240 | 1932 | smmu->num_mapping_groups = size; |
588888a7 | 1933 | mutex_init(&smmu->stream_map_mutex); |
45ae7cff | 1934 | |
7602b871 RM |
1935 | if (smmu->version < ARM_SMMU_V2 || !(id & ID0_PTFS_NO_AARCH32)) { |
1936 | smmu->features |= ARM_SMMU_FEAT_FMT_AARCH32_L; | |
1937 | if (!(id & ID0_PTFS_NO_AARCH32S)) | |
1938 | smmu->features |= ARM_SMMU_FEAT_FMT_AARCH32_S; | |
1939 | } | |
1940 | ||
45ae7cff WD |
1941 | /* ID1 */ |
1942 | id = readl_relaxed(gr0_base + ARM_SMMU_GR0_ID1); | |
c757e852 | 1943 | smmu->pgshift = (id & ID1_PAGESIZE) ? 16 : 12; |
45ae7cff | 1944 | |
c55af7f7 | 1945 | /* Check for size mismatch of SMMU address space from mapped region */ |
518f7136 | 1946 | size = 1 << (((id >> ID1_NUMPAGENDXB_SHIFT) & ID1_NUMPAGENDXB_MASK) + 1); |
452107c7 RM |
1947 | size <<= smmu->pgshift; |
1948 | if (smmu->cb_base != gr0_base + size) | |
2907320d | 1949 | dev_warn(smmu->dev, |
452107c7 RM |
1950 | "SMMU address space size (0x%lx) differs from mapped region size (0x%tx)!\n", |
1951 | size * 2, (smmu->cb_base - gr0_base) * 2); | |
45ae7cff | 1952 | |
518f7136 | 1953 | smmu->num_s2_context_banks = (id >> ID1_NUMS2CB_SHIFT) & ID1_NUMS2CB_MASK; |
45ae7cff WD |
1954 | smmu->num_context_banks = (id >> ID1_NUMCB_SHIFT) & ID1_NUMCB_MASK; |
1955 | if (smmu->num_s2_context_banks > smmu->num_context_banks) { | |
1956 | dev_err(smmu->dev, "impossible number of S2 context banks!\n"); | |
1957 | return -ENODEV; | |
1958 | } | |
1959 | dev_notice(smmu->dev, "\t%u context banks (%u stage-2 only)\n", | |
1960 | smmu->num_context_banks, smmu->num_s2_context_banks); | |
e086d912 RM |
1961 | /* |
1962 | * Cavium CN88xx erratum #27704. | |
1963 | * Ensure ASID and VMID allocation is unique across all SMMUs in | |
1964 | * the system. | |
1965 | */ | |
1966 | if (smmu->model == CAVIUM_SMMUV2) { | |
1967 | smmu->cavium_id_base = | |
1968 | atomic_add_return(smmu->num_context_banks, | |
1969 | &cavium_smmu_context_count); | |
1970 | smmu->cavium_id_base -= smmu->num_context_banks; | |
53c35dce | 1971 | dev_notice(smmu->dev, "\tenabling workaround for Cavium erratum 27704\n"); |
e086d912 | 1972 | } |
45ae7cff WD |
1973 | |
1974 | /* ID2 */ | |
1975 | id = readl_relaxed(gr0_base + ARM_SMMU_GR0_ID2); | |
1976 | size = arm_smmu_id_size_to_bits((id >> ID2_IAS_SHIFT) & ID2_IAS_MASK); | |
518f7136 | 1977 | smmu->ipa_size = size; |
45ae7cff | 1978 | |
518f7136 | 1979 | /* The output mask is also applied for bypass */ |
45ae7cff | 1980 | size = arm_smmu_id_size_to_bits((id >> ID2_OAS_SHIFT) & ID2_OAS_MASK); |
518f7136 | 1981 | smmu->pa_size = size; |
45ae7cff | 1982 | |
4e3e9b69 TC |
1983 | if (id & ID2_VMID16) |
1984 | smmu->features |= ARM_SMMU_FEAT_VMID16; | |
1985 | ||
f1d84548 RM |
1986 | /* |
1987 | * What the page table walker can address actually depends on which | |
1988 | * descriptor format is in use, but since a) we don't know that yet, | |
1989 | * and b) it can vary per context bank, this will have to do... | |
1990 | */ | |
1991 | if (dma_set_mask_and_coherent(smmu->dev, DMA_BIT_MASK(size))) | |
1992 | dev_warn(smmu->dev, | |
1993 | "failed to set DMA mask for table walker\n"); | |
1994 | ||
b7862e35 | 1995 | if (smmu->version < ARM_SMMU_V2) { |
518f7136 | 1996 | smmu->va_size = smmu->ipa_size; |
b7862e35 RM |
1997 | if (smmu->version == ARM_SMMU_V1_64K) |
1998 | smmu->features |= ARM_SMMU_FEAT_FMT_AARCH64_64K; | |
45ae7cff | 1999 | } else { |
45ae7cff | 2000 | size = (id >> ID2_UBS_SHIFT) & ID2_UBS_MASK; |
518f7136 | 2001 | smmu->va_size = arm_smmu_id_size_to_bits(size); |
518f7136 | 2002 | if (id & ID2_PTFS_4K) |
7602b871 | 2003 | smmu->features |= ARM_SMMU_FEAT_FMT_AARCH64_4K; |
518f7136 | 2004 | if (id & ID2_PTFS_16K) |
7602b871 | 2005 | smmu->features |= ARM_SMMU_FEAT_FMT_AARCH64_16K; |
518f7136 | 2006 | if (id & ID2_PTFS_64K) |
7602b871 | 2007 | smmu->features |= ARM_SMMU_FEAT_FMT_AARCH64_64K; |
45ae7cff WD |
2008 | } |
2009 | ||
7602b871 | 2010 | /* Now we've corralled the various formats, what'll it do? */ |
7602b871 | 2011 | if (smmu->features & ARM_SMMU_FEAT_FMT_AARCH32_S) |
d5466357 | 2012 | smmu->pgsize_bitmap |= SZ_4K | SZ_64K | SZ_1M | SZ_16M; |
7602b871 RM |
2013 | if (smmu->features & |
2014 | (ARM_SMMU_FEAT_FMT_AARCH32_L | ARM_SMMU_FEAT_FMT_AARCH64_4K)) | |
d5466357 | 2015 | smmu->pgsize_bitmap |= SZ_4K | SZ_2M | SZ_1G; |
7602b871 | 2016 | if (smmu->features & ARM_SMMU_FEAT_FMT_AARCH64_16K) |
d5466357 | 2017 | smmu->pgsize_bitmap |= SZ_16K | SZ_32M; |
7602b871 | 2018 | if (smmu->features & ARM_SMMU_FEAT_FMT_AARCH64_64K) |
d5466357 RM |
2019 | smmu->pgsize_bitmap |= SZ_64K | SZ_512M; |
2020 | ||
2021 | if (arm_smmu_ops.pgsize_bitmap == -1UL) | |
2022 | arm_smmu_ops.pgsize_bitmap = smmu->pgsize_bitmap; | |
2023 | else | |
2024 | arm_smmu_ops.pgsize_bitmap |= smmu->pgsize_bitmap; | |
2025 | dev_notice(smmu->dev, "\tSupported page sizes: 0x%08lx\n", | |
2026 | smmu->pgsize_bitmap); | |
7602b871 | 2027 | |
518f7136 | 2028 | |
28d6007b WD |
2029 | if (smmu->features & ARM_SMMU_FEAT_TRANS_S1) |
2030 | dev_notice(smmu->dev, "\tStage-1: %lu-bit VA -> %lu-bit IPA\n", | |
518f7136 | 2031 | smmu->va_size, smmu->ipa_size); |
28d6007b WD |
2032 | |
2033 | if (smmu->features & ARM_SMMU_FEAT_TRANS_S2) | |
2034 | dev_notice(smmu->dev, "\tStage-2: %lu-bit IPA -> %lu-bit PA\n", | |
518f7136 | 2035 | smmu->ipa_size, smmu->pa_size); |
28d6007b | 2036 | |
45ae7cff WD |
2037 | return 0; |
2038 | } | |
2039 | ||
67b65a3f RM |
2040 | struct arm_smmu_match_data { |
2041 | enum arm_smmu_arch_version version; | |
2042 | enum arm_smmu_implementation model; | |
2043 | }; | |
2044 | ||
2045 | #define ARM_SMMU_MATCH_DATA(name, ver, imp) \ | |
2046 | static struct arm_smmu_match_data name = { .version = ver, .model = imp } | |
2047 | ||
2048 | ARM_SMMU_MATCH_DATA(smmu_generic_v1, ARM_SMMU_V1, GENERIC_SMMU); | |
2049 | ARM_SMMU_MATCH_DATA(smmu_generic_v2, ARM_SMMU_V2, GENERIC_SMMU); | |
b7862e35 | 2050 | ARM_SMMU_MATCH_DATA(arm_mmu401, ARM_SMMU_V1_64K, GENERIC_SMMU); |
f0cfffc4 | 2051 | ARM_SMMU_MATCH_DATA(arm_mmu500, ARM_SMMU_V2, ARM_MMU500); |
e086d912 | 2052 | ARM_SMMU_MATCH_DATA(cavium_smmuv2, ARM_SMMU_V2, CAVIUM_SMMUV2); |
67b65a3f | 2053 | |
09b5269a | 2054 | static const struct of_device_id arm_smmu_of_match[] = { |
67b65a3f RM |
2055 | { .compatible = "arm,smmu-v1", .data = &smmu_generic_v1 }, |
2056 | { .compatible = "arm,smmu-v2", .data = &smmu_generic_v2 }, | |
2057 | { .compatible = "arm,mmu-400", .data = &smmu_generic_v1 }, | |
b7862e35 | 2058 | { .compatible = "arm,mmu-401", .data = &arm_mmu401 }, |
f0cfffc4 | 2059 | { .compatible = "arm,mmu-500", .data = &arm_mmu500 }, |
e086d912 | 2060 | { .compatible = "cavium,smmu-v2", .data = &cavium_smmuv2 }, |
09360403 RM |
2061 | { }, |
2062 | }; | |
2063 | MODULE_DEVICE_TABLE(of, arm_smmu_of_match); | |
2064 | ||
d6fcd3b1 LP |
2065 | #ifdef CONFIG_ACPI |
2066 | static int acpi_smmu_get_data(u32 model, struct arm_smmu_device *smmu) | |
2067 | { | |
2068 | int ret = 0; | |
2069 | ||
2070 | switch (model) { | |
2071 | case ACPI_IORT_SMMU_V1: | |
2072 | case ACPI_IORT_SMMU_CORELINK_MMU400: | |
2073 | smmu->version = ARM_SMMU_V1; | |
2074 | smmu->model = GENERIC_SMMU; | |
2075 | break; | |
2076 | case ACPI_IORT_SMMU_V2: | |
2077 | smmu->version = ARM_SMMU_V2; | |
2078 | smmu->model = GENERIC_SMMU; | |
2079 | break; | |
2080 | case ACPI_IORT_SMMU_CORELINK_MMU500: | |
2081 | smmu->version = ARM_SMMU_V2; | |
2082 | smmu->model = ARM_MMU500; | |
2083 | break; | |
2084 | default: | |
2085 | ret = -ENODEV; | |
2086 | } | |
2087 | ||
2088 | return ret; | |
2089 | } | |
2090 | ||
2091 | static int arm_smmu_device_acpi_probe(struct platform_device *pdev, | |
2092 | struct arm_smmu_device *smmu) | |
2093 | { | |
2094 | struct device *dev = smmu->dev; | |
2095 | struct acpi_iort_node *node = | |
2096 | *(struct acpi_iort_node **)dev_get_platdata(dev); | |
2097 | struct acpi_iort_smmu *iort_smmu; | |
2098 | int ret; | |
2099 | ||
2100 | /* Retrieve SMMU1/2 specific data */ | |
2101 | iort_smmu = (struct acpi_iort_smmu *)node->node_data; | |
2102 | ||
2103 | ret = acpi_smmu_get_data(iort_smmu->model, smmu); | |
2104 | if (ret < 0) | |
2105 | return ret; | |
2106 | ||
2107 | /* Ignore the configuration access interrupt */ | |
2108 | smmu->num_global_irqs = 1; | |
2109 | ||
2110 | if (iort_smmu->flags & ACPI_IORT_SMMU_COHERENT_WALK) | |
2111 | smmu->features |= ARM_SMMU_FEAT_COHERENT_WALK; | |
2112 | ||
2113 | return 0; | |
2114 | } | |
2115 | #else | |
2116 | static inline int arm_smmu_device_acpi_probe(struct platform_device *pdev, | |
2117 | struct arm_smmu_device *smmu) | |
2118 | { | |
2119 | return -ENODEV; | |
2120 | } | |
2121 | #endif | |
2122 | ||
bbb8a184 LP |
2123 | static int arm_smmu_device_dt_probe(struct platform_device *pdev, |
2124 | struct arm_smmu_device *smmu) | |
45ae7cff | 2125 | { |
67b65a3f | 2126 | const struct arm_smmu_match_data *data; |
45ae7cff | 2127 | struct device *dev = &pdev->dev; |
021bb842 RM |
2128 | bool legacy_binding; |
2129 | ||
bbb8a184 LP |
2130 | if (of_property_read_u32(dev->of_node, "#global-interrupts", |
2131 | &smmu->num_global_irqs)) { | |
2132 | dev_err(dev, "missing #global-interrupts property\n"); | |
2133 | return -ENODEV; | |
2134 | } | |
2135 | ||
2136 | data = of_device_get_match_data(dev); | |
2137 | smmu->version = data->version; | |
2138 | smmu->model = data->model; | |
2139 | ||
2140 | parse_driver_options(smmu); | |
2141 | ||
021bb842 RM |
2142 | legacy_binding = of_find_property(dev->of_node, "mmu-masters", NULL); |
2143 | if (legacy_binding && !using_generic_binding) { | |
2144 | if (!using_legacy_binding) | |
2145 | pr_notice("deprecated \"mmu-masters\" DT property in use; DMA API support unavailable\n"); | |
2146 | using_legacy_binding = true; | |
2147 | } else if (!legacy_binding && !using_legacy_binding) { | |
2148 | using_generic_binding = true; | |
2149 | } else { | |
2150 | dev_err(dev, "not probing due to mismatched DT properties\n"); | |
2151 | return -ENODEV; | |
2152 | } | |
45ae7cff | 2153 | |
bbb8a184 LP |
2154 | if (of_dma_is_coherent(dev->of_node)) |
2155 | smmu->features |= ARM_SMMU_FEAT_COHERENT_WALK; | |
2156 | ||
2157 | return 0; | |
2158 | } | |
2159 | ||
f6810c15 RM |
2160 | static void arm_smmu_bus_init(void) |
2161 | { | |
2162 | /* Oh, for a proper bus abstraction */ | |
2163 | if (!iommu_present(&platform_bus_type)) | |
2164 | bus_set_iommu(&platform_bus_type, &arm_smmu_ops); | |
2165 | #ifdef CONFIG_ARM_AMBA | |
2166 | if (!iommu_present(&amba_bustype)) | |
2167 | bus_set_iommu(&amba_bustype, &arm_smmu_ops); | |
2168 | #endif | |
2169 | #ifdef CONFIG_PCI | |
2170 | if (!iommu_present(&pci_bus_type)) { | |
2171 | pci_request_acs(); | |
2172 | bus_set_iommu(&pci_bus_type, &arm_smmu_ops); | |
2173 | } | |
2174 | #endif | |
2175 | } | |
2176 | ||
bbb8a184 LP |
2177 | static int arm_smmu_device_probe(struct platform_device *pdev) |
2178 | { | |
2179 | struct resource *res; | |
9648cbc9 | 2180 | resource_size_t ioaddr; |
bbb8a184 LP |
2181 | struct arm_smmu_device *smmu; |
2182 | struct device *dev = &pdev->dev; | |
2183 | int num_irqs, i, err; | |
2184 | ||
45ae7cff WD |
2185 | smmu = devm_kzalloc(dev, sizeof(*smmu), GFP_KERNEL); |
2186 | if (!smmu) { | |
2187 | dev_err(dev, "failed to allocate arm_smmu_device\n"); | |
2188 | return -ENOMEM; | |
2189 | } | |
2190 | smmu->dev = dev; | |
2191 | ||
d6fcd3b1 LP |
2192 | if (dev->of_node) |
2193 | err = arm_smmu_device_dt_probe(pdev, smmu); | |
2194 | else | |
2195 | err = arm_smmu_device_acpi_probe(pdev, smmu); | |
2196 | ||
bbb8a184 LP |
2197 | if (err) |
2198 | return err; | |
09360403 | 2199 | |
45ae7cff | 2200 | res = platform_get_resource(pdev, IORESOURCE_MEM, 0); |
9648cbc9 | 2201 | ioaddr = res->start; |
8a7f4312 JL |
2202 | smmu->base = devm_ioremap_resource(dev, res); |
2203 | if (IS_ERR(smmu->base)) | |
2204 | return PTR_ERR(smmu->base); | |
452107c7 | 2205 | smmu->cb_base = smmu->base + resource_size(res) / 2; |
45ae7cff | 2206 | |
45ae7cff WD |
2207 | num_irqs = 0; |
2208 | while ((res = platform_get_resource(pdev, IORESOURCE_IRQ, num_irqs))) { | |
2209 | num_irqs++; | |
2210 | if (num_irqs > smmu->num_global_irqs) | |
2211 | smmu->num_context_irqs++; | |
2212 | } | |
2213 | ||
44a08de2 AH |
2214 | if (!smmu->num_context_irqs) { |
2215 | dev_err(dev, "found %d interrupts but expected at least %d\n", | |
2216 | num_irqs, smmu->num_global_irqs + 1); | |
2217 | return -ENODEV; | |
45ae7cff | 2218 | } |
45ae7cff WD |
2219 | |
2220 | smmu->irqs = devm_kzalloc(dev, sizeof(*smmu->irqs) * num_irqs, | |
2221 | GFP_KERNEL); | |
2222 | if (!smmu->irqs) { | |
2223 | dev_err(dev, "failed to allocate %d irqs\n", num_irqs); | |
2224 | return -ENOMEM; | |
2225 | } | |
2226 | ||
2227 | for (i = 0; i < num_irqs; ++i) { | |
2228 | int irq = platform_get_irq(pdev, i); | |
2907320d | 2229 | |
45ae7cff WD |
2230 | if (irq < 0) { |
2231 | dev_err(dev, "failed to get irq index %d\n", i); | |
2232 | return -ENODEV; | |
2233 | } | |
2234 | smmu->irqs[i] = irq; | |
2235 | } | |
2236 | ||
3c8766d0 OH |
2237 | err = arm_smmu_device_cfg_probe(smmu); |
2238 | if (err) | |
2239 | return err; | |
2240 | ||
b7862e35 | 2241 | if (smmu->version == ARM_SMMU_V2 && |
45ae7cff WD |
2242 | smmu->num_context_banks != smmu->num_context_irqs) { |
2243 | dev_err(dev, | |
2244 | "found only %d context interrupt(s) but %d required\n", | |
2245 | smmu->num_context_irqs, smmu->num_context_banks); | |
f80cd885 | 2246 | return -ENODEV; |
45ae7cff WD |
2247 | } |
2248 | ||
45ae7cff | 2249 | for (i = 0; i < smmu->num_global_irqs; ++i) { |
bee14004 PF |
2250 | err = devm_request_irq(smmu->dev, smmu->irqs[i], |
2251 | arm_smmu_global_fault, | |
2252 | IRQF_SHARED, | |
2253 | "arm-smmu global fault", | |
2254 | smmu); | |
45ae7cff WD |
2255 | if (err) { |
2256 | dev_err(dev, "failed to request global IRQ %d (%u)\n", | |
2257 | i, smmu->irqs[i]); | |
f80cd885 | 2258 | return err; |
45ae7cff WD |
2259 | } |
2260 | } | |
2261 | ||
9648cbc9 JR |
2262 | err = iommu_device_sysfs_add(&smmu->iommu, smmu->dev, NULL, |
2263 | "smmu.%pa", &ioaddr); | |
2264 | if (err) { | |
2265 | dev_err(dev, "Failed to register iommu in sysfs\n"); | |
2266 | return err; | |
2267 | } | |
2268 | ||
2269 | iommu_device_set_ops(&smmu->iommu, &arm_smmu_ops); | |
2270 | iommu_device_set_fwnode(&smmu->iommu, dev->fwnode); | |
2271 | ||
2272 | err = iommu_device_register(&smmu->iommu); | |
2273 | if (err) { | |
2274 | dev_err(dev, "Failed to register iommu\n"); | |
2275 | return err; | |
2276 | } | |
2277 | ||
d6fc5d97 | 2278 | platform_set_drvdata(pdev, smmu); |
fd90cecb | 2279 | arm_smmu_device_reset(smmu); |
dc0eaa4e | 2280 | arm_smmu_test_smr_masks(smmu); |
021bb842 | 2281 | |
f6810c15 RM |
2282 | /* |
2283 | * For ACPI and generic DT bindings, an SMMU will be probed before | |
2284 | * any device which might need it, so we want the bus ops in place | |
2285 | * ready to handle default domain setup as soon as any SMMU exists. | |
2286 | */ | |
2287 | if (!using_legacy_binding) | |
2288 | arm_smmu_bus_init(); | |
2289 | ||
45ae7cff | 2290 | return 0; |
45ae7cff WD |
2291 | } |
2292 | ||
f6810c15 RM |
2293 | /* |
2294 | * With the legacy DT binding in play, though, we have no guarantees about | |
2295 | * probe order, but then we're also not doing default domains, so we can | |
2296 | * delay setting bus ops until we're sure every possible SMMU is ready, | |
2297 | * and that way ensure that no add_device() calls get missed. | |
2298 | */ | |
2299 | static int arm_smmu_legacy_bus_init(void) | |
2300 | { | |
2301 | if (using_legacy_binding) | |
2302 | arm_smmu_bus_init(); | |
45ae7cff | 2303 | return 0; |
45ae7cff | 2304 | } |
f6810c15 | 2305 | device_initcall_sync(arm_smmu_legacy_bus_init); |
45ae7cff WD |
2306 | |
2307 | static int arm_smmu_device_remove(struct platform_device *pdev) | |
2308 | { | |
d6fc5d97 | 2309 | struct arm_smmu_device *smmu = platform_get_drvdata(pdev); |
45ae7cff WD |
2310 | |
2311 | if (!smmu) | |
2312 | return -ENODEV; | |
2313 | ||
ecfadb6e | 2314 | if (!bitmap_empty(smmu->context_map, ARM_SMMU_MAX_CBS)) |
d6fc5d97 | 2315 | dev_err(&pdev->dev, "removing device with active domains!\n"); |
45ae7cff | 2316 | |
45ae7cff | 2317 | /* Turn the thing off */ |
2907320d | 2318 | writel(sCR0_CLIENTPD, ARM_SMMU_GR0_NS(smmu) + ARM_SMMU_GR0_sCR0); |
45ae7cff WD |
2319 | return 0; |
2320 | } | |
2321 | ||
45ae7cff WD |
2322 | static struct platform_driver arm_smmu_driver = { |
2323 | .driver = { | |
45ae7cff WD |
2324 | .name = "arm-smmu", |
2325 | .of_match_table = of_match_ptr(arm_smmu_of_match), | |
2326 | }, | |
bbb8a184 | 2327 | .probe = arm_smmu_device_probe, |
45ae7cff WD |
2328 | .remove = arm_smmu_device_remove, |
2329 | }; | |
f6810c15 RM |
2330 | module_platform_driver(arm_smmu_driver); |
2331 | ||
2332 | IOMMU_OF_DECLARE(arm_smmuv1, "arm,smmu-v1", NULL); | |
2333 | IOMMU_OF_DECLARE(arm_smmuv2, "arm,smmu-v2", NULL); | |
2334 | IOMMU_OF_DECLARE(arm_mmu400, "arm,mmu-400", NULL); | |
2335 | IOMMU_OF_DECLARE(arm_mmu401, "arm,mmu-401", NULL); | |
2336 | IOMMU_OF_DECLARE(arm_mmu500, "arm,mmu-500", NULL); | |
2337 | IOMMU_OF_DECLARE(cavium_smmuv2, "cavium,smmu-v2", NULL); | |
d6fcd3b1 | 2338 | |
45ae7cff WD |
2339 | MODULE_DESCRIPTION("IOMMU API for ARM architected SMMU implementations"); |
2340 | MODULE_AUTHOR("Will Deacon <will.deacon@arm.com>"); | |
2341 | MODULE_LICENSE("GPL v2"); |