Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-only
2 : : /*
3 : : * Copyright (c) 2006, Intel Corporation.
4 : : *
5 : : * Copyright (C) 2006-2008 Intel Corporation
6 : : * Author: Ashok Raj <ashok.raj@intel.com>
7 : : * Author: Shaohua Li <shaohua.li@intel.com>
8 : : * Author: Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com>
9 : : *
10 : : * This file implements early detection/parsing of Remapping Devices
11 : : * reported to OS through BIOS via DMA remapping reporting (DMAR) ACPI
12 : : * tables.
13 : : *
14 : : * These routines are used by both DMA-remapping and Interrupt-remapping
15 : : */
16 : :
17 : : #define pr_fmt(fmt) "DMAR: " fmt
18 : :
19 : : #include <linux/pci.h>
20 : : #include <linux/dmar.h>
21 : : #include <linux/iova.h>
22 : : #include <linux/intel-iommu.h>
23 : : #include <linux/timer.h>
24 : : #include <linux/irq.h>
25 : : #include <linux/interrupt.h>
26 : : #include <linux/tboot.h>
27 : : #include <linux/dmi.h>
28 : : #include <linux/slab.h>
29 : : #include <linux/iommu.h>
30 : : #include <linux/numa.h>
31 : : #include <linux/limits.h>
32 : : #include <asm/irq_remapping.h>
33 : : #include <asm/iommu_table.h>
34 : :
35 : : #include "irq_remapping.h"
36 : :
37 : : typedef int (*dmar_res_handler_t)(struct acpi_dmar_header *, void *);
38 : : struct dmar_res_callback {
39 : : dmar_res_handler_t cb[ACPI_DMAR_TYPE_RESERVED];
40 : : void *arg[ACPI_DMAR_TYPE_RESERVED];
41 : : bool ignore_unhandled;
42 : : bool print_entry;
43 : : };
44 : :
45 : : /*
46 : : * Assumptions:
47 : : * 1) The hotplug framework guarentees that DMAR unit will be hot-added
48 : : * before IO devices managed by that unit.
49 : : * 2) The hotplug framework guarantees that DMAR unit will be hot-removed
50 : : * after IO devices managed by that unit.
51 : : * 3) Hotplug events are rare.
52 : : *
53 : : * Locking rules for DMA and interrupt remapping related global data structures:
54 : : * 1) Use dmar_global_lock in process context
55 : : * 2) Use RCU in interrupt context
56 : : */
57 : : DECLARE_RWSEM(dmar_global_lock);
58 : : LIST_HEAD(dmar_drhd_units);
59 : :
60 : : struct acpi_table_header * __initdata dmar_tbl;
61 : : static int dmar_dev_scope_status = 1;
62 : : static unsigned long dmar_seq_ids[BITS_TO_LONGS(DMAR_UNITS_SUPPORTED)];
63 : :
64 : : static int alloc_iommu(struct dmar_drhd_unit *drhd);
65 : : static void free_iommu(struct intel_iommu *iommu);
66 : :
67 : : extern const struct iommu_ops intel_iommu_ops;
68 : :
69 : 0 : static void dmar_register_drhd_unit(struct dmar_drhd_unit *drhd)
70 : : {
71 : : /*
72 : : * add INCLUDE_ALL at the tail, so scan the list will find it at
73 : : * the very end.
74 : : */
75 : 0 : if (drhd->include_all)
76 : 0 : list_add_tail_rcu(&drhd->list, &dmar_drhd_units);
77 : : else
78 : 0 : list_add_rcu(&drhd->list, &dmar_drhd_units);
79 : : }
80 : :
81 : 0 : void *dmar_alloc_dev_scope(void *start, void *end, int *cnt)
82 : : {
83 : 0 : struct acpi_dmar_device_scope *scope;
84 : :
85 : 0 : *cnt = 0;
86 [ # # ]: 0 : while (start < end) {
87 : 0 : scope = start;
88 [ # # ]: 0 : if (scope->entry_type == ACPI_DMAR_SCOPE_TYPE_NAMESPACE ||
89 [ # # ]: 0 : scope->entry_type == ACPI_DMAR_SCOPE_TYPE_ENDPOINT ||
90 : : scope->entry_type == ACPI_DMAR_SCOPE_TYPE_BRIDGE)
91 : 0 : (*cnt)++;
92 [ # # ]: 0 : else if (scope->entry_type != ACPI_DMAR_SCOPE_TYPE_IOAPIC &&
93 : : scope->entry_type != ACPI_DMAR_SCOPE_TYPE_HPET) {
94 : 0 : pr_warn("Unsupported device scope\n");
95 : : }
96 : 0 : start += scope->length;
97 : : }
98 [ # # ]: 0 : if (*cnt == 0)
99 : : return NULL;
100 : :
101 : 0 : return kcalloc(*cnt, sizeof(struct dmar_dev_scope), GFP_KERNEL);
102 : : }
103 : :
104 : 0 : void dmar_free_dev_scope(struct dmar_dev_scope **devices, int *cnt)
105 : : {
106 : 0 : int i;
107 : 0 : struct device *tmp_dev;
108 : :
109 [ # # # # ]: 0 : if (*devices && *cnt) {
110 [ # # # # : 0 : for_each_active_dev_scope(*devices, *cnt, i, tmp_dev)
# # ]
111 : 0 : put_device(tmp_dev);
112 : 0 : kfree(*devices);
113 : : }
114 : :
115 : 0 : *devices = NULL;
116 : 0 : *cnt = 0;
117 : 0 : }
118 : :
119 : : /* Optimize out kzalloc()/kfree() for normal cases */
120 : : static char dmar_pci_notify_info_buf[64];
121 : :
122 : : static struct dmar_pci_notify_info *
123 : 0 : dmar_alloc_pci_notify_info(struct pci_dev *dev, unsigned long event)
124 : : {
125 : 0 : int level = 0;
126 : 0 : size_t size;
127 : 0 : struct pci_dev *tmp;
128 : 0 : struct dmar_pci_notify_info *info;
129 : :
130 [ # # ]: 0 : BUG_ON(dev->is_virtfn);
131 : :
132 : : /*
133 : : * Ignore devices that have a domain number higher than what can
134 : : * be looked up in DMAR, e.g. VMD subdevices with domain 0x10000
135 : : */
136 [ # # ]: 0 : if (pci_domain_nr(dev->bus) > U16_MAX)
137 : : return NULL;
138 : :
139 : : /* Only generate path[] for device addition event */
140 [ # # ]: 0 : if (event == BUS_NOTIFY_ADD_DEVICE)
141 [ # # ]: 0 : for (tmp = dev; tmp; tmp = tmp->bus->self)
142 : 0 : level++;
143 : :
144 [ # # ]: 0 : size = struct_size(info, path, level);
145 [ # # ]: 0 : if (size <= sizeof(dmar_pci_notify_info_buf)) {
146 : : info = (struct dmar_pci_notify_info *)dmar_pci_notify_info_buf;
147 : : } else {
148 : 0 : info = kzalloc(size, GFP_KERNEL);
149 [ # # ]: 0 : if (!info) {
150 [ # # ]: 0 : pr_warn("Out of memory when allocating notify_info "
151 : : "for %s.\n", pci_name(dev));
152 [ # # ]: 0 : if (dmar_dev_scope_status == 0)
153 : 0 : dmar_dev_scope_status = -ENOMEM;
154 : 0 : return NULL;
155 : : }
156 : : }
157 : :
158 : 0 : info->event = event;
159 : 0 : info->dev = dev;
160 [ # # ]: 0 : info->seg = pci_domain_nr(dev->bus);
161 : 0 : info->level = level;
162 [ # # ]: 0 : if (event == BUS_NOTIFY_ADD_DEVICE) {
163 [ # # ]: 0 : for (tmp = dev; tmp; tmp = tmp->bus->self) {
164 : 0 : level--;
165 : 0 : info->path[level].bus = tmp->bus->number;
166 : 0 : info->path[level].device = PCI_SLOT(tmp->devfn);
167 : 0 : info->path[level].function = PCI_FUNC(tmp->devfn);
168 [ # # ]: 0 : if (pci_is_root_bus(tmp->bus))
169 : 0 : info->bus = tmp->bus->number;
170 : : }
171 : : }
172 : :
173 : : return info;
174 : : }
175 : :
176 : 0 : static inline void dmar_free_pci_notify_info(struct dmar_pci_notify_info *info)
177 : : {
178 : 0 : if ((void *)info != dmar_pci_notify_info_buf)
179 : 0 : kfree(info);
180 : : }
181 : :
182 : 0 : static bool dmar_match_pci_path(struct dmar_pci_notify_info *info, int bus,
183 : : struct acpi_dmar_pci_path *path, int count)
184 : : {
185 : 0 : int i;
186 : :
187 [ # # ]: 0 : if (info->bus != bus)
188 : 0 : goto fallback;
189 [ # # ]: 0 : if (info->level != count)
190 : 0 : goto fallback;
191 : :
192 [ # # ]: 0 : for (i = 0; i < count; i++) {
193 [ # # ]: 0 : if (path[i].device != info->path[i].device ||
194 [ # # ]: 0 : path[i].function != info->path[i].function)
195 : 0 : goto fallback;
196 : : }
197 : :
198 : : return true;
199 : :
200 : 0 : fallback:
201 : :
202 [ # # ]: 0 : if (count != 1)
203 : : return false;
204 : :
205 : 0 : i = info->level - 1;
206 [ # # ]: 0 : if (bus == info->path[i].bus &&
207 [ # # ]: 0 : path[0].device == info->path[i].device &&
208 [ # # ]: 0 : path[0].function == info->path[i].function) {
209 : 0 : pr_info(FW_BUG "RMRR entry for device %02x:%02x.%x is broken - applying workaround\n",
210 : : bus, path[0].device, path[0].function);
211 : 0 : return true;
212 : : }
213 : :
214 : : return false;
215 : : }
216 : :
217 : : /* Return: > 0 if match found, 0 if no match found, < 0 if error happens */
218 : 0 : int dmar_insert_dev_scope(struct dmar_pci_notify_info *info,
219 : : void *start, void*end, u16 segment,
220 : : struct dmar_dev_scope *devices,
221 : : int devices_cnt)
222 : : {
223 : 0 : int i, level;
224 : 0 : struct device *tmp, *dev = &info->dev->dev;
225 : 0 : struct acpi_dmar_device_scope *scope;
226 : 0 : struct acpi_dmar_pci_path *path;
227 : :
228 [ # # ]: 0 : if (segment != info->seg)
229 : : return 0;
230 : :
231 [ # # ]: 0 : for (; start < end; start += scope->length) {
232 : 0 : scope = start;
233 [ # # ]: 0 : if (scope->entry_type != ACPI_DMAR_SCOPE_TYPE_ENDPOINT &&
234 : : scope->entry_type != ACPI_DMAR_SCOPE_TYPE_BRIDGE)
235 : 0 : continue;
236 : :
237 : 0 : path = (struct acpi_dmar_pci_path *)(scope + 1);
238 : 0 : level = (scope->length - sizeof(*scope)) / sizeof(*path);
239 [ # # ]: 0 : if (!dmar_match_pci_path(info, scope->bus, path, level))
240 : 0 : continue;
241 : :
242 : : /*
243 : : * We expect devices with endpoint scope to have normal PCI
244 : : * headers, and devices with bridge scope to have bridge PCI
245 : : * headers. However PCI NTB devices may be listed in the
246 : : * DMAR table with bridge scope, even though they have a
247 : : * normal PCI header. NTB devices are identified by class
248 : : * "BRIDGE_OTHER" (0680h) - we don't declare a socpe mismatch
249 : : * for this special case.
250 : : */
251 [ # # ]: 0 : if ((scope->entry_type == ACPI_DMAR_SCOPE_TYPE_ENDPOINT &&
252 [ # # # # ]: 0 : info->dev->hdr_type != PCI_HEADER_TYPE_NORMAL) ||
253 : 0 : (scope->entry_type == ACPI_DMAR_SCOPE_TYPE_BRIDGE &&
254 [ # # ]: 0 : (info->dev->hdr_type == PCI_HEADER_TYPE_NORMAL &&
255 [ # # ]: 0 : info->dev->class >> 16 != PCI_BASE_CLASS_BRIDGE))) {
256 [ # # ]: 0 : pr_warn("Device scope type does not match for %s\n",
257 : : pci_name(info->dev));
258 : 0 : return -EINVAL;
259 : : }
260 : :
261 [ # # # # ]: 0 : for_each_dev_scope(devices, devices_cnt, i, tmp)
262 [ # # ]: 0 : if (tmp == NULL) {
263 : 0 : devices[i].bus = info->dev->bus->number;
264 : 0 : devices[i].devfn = info->dev->devfn;
265 : 0 : rcu_assign_pointer(devices[i].dev,
266 : : get_device(dev));
267 : 0 : return 1;
268 : : }
269 : 0 : BUG_ON(i >= devices_cnt);
270 : : }
271 : :
272 : : return 0;
273 : : }
274 : :
275 : 0 : int dmar_remove_dev_scope(struct dmar_pci_notify_info *info, u16 segment,
276 : : struct dmar_dev_scope *devices, int count)
277 : : {
278 : 0 : int index;
279 : 0 : struct device *tmp;
280 : :
281 [ # # ]: 0 : if (info->seg != segment)
282 : : return 0;
283 : :
284 [ # # # # : 0 : for_each_active_dev_scope(devices, count, index, tmp)
# # ]
285 [ # # ]: 0 : if (tmp == &info->dev->dev) {
286 : 0 : RCU_INIT_POINTER(devices[index].dev, NULL);
287 : 0 : synchronize_rcu();
288 : 0 : put_device(tmp);
289 : 0 : return 1;
290 : : }
291 : :
292 : : return 0;
293 : : }
294 : :
295 : 0 : static int dmar_pci_bus_add_dev(struct dmar_pci_notify_info *info)
296 : : {
297 : 0 : int ret = 0;
298 : 0 : struct dmar_drhd_unit *dmaru;
299 : 0 : struct acpi_dmar_hardware_unit *drhd;
300 : :
301 [ # # ]: 0 : for_each_drhd_unit(dmaru) {
302 [ # # ]: 0 : if (dmaru->include_all)
303 : 0 : continue;
304 : :
305 : 0 : drhd = container_of(dmaru->hdr,
306 : : struct acpi_dmar_hardware_unit, header);
307 : 0 : ret = dmar_insert_dev_scope(info, (void *)(drhd + 1),
308 : 0 : ((void *)drhd) + drhd->header.length,
309 : 0 : dmaru->segment,
310 : : dmaru->devices, dmaru->devices_cnt);
311 [ # # ]: 0 : if (ret)
312 : : break;
313 : : }
314 [ # # ]: 0 : if (ret >= 0)
315 : 0 : ret = dmar_iommu_notify_scope_dev(info);
316 [ # # # # ]: 0 : if (ret < 0 && dmar_dev_scope_status == 0)
317 : 0 : dmar_dev_scope_status = ret;
318 : :
319 : 0 : return ret;
320 : : }
321 : :
322 : 0 : static void dmar_pci_bus_del_dev(struct dmar_pci_notify_info *info)
323 : : {
324 : 0 : struct dmar_drhd_unit *dmaru;
325 : :
326 [ # # ]: 0 : for_each_drhd_unit(dmaru)
327 [ # # ]: 0 : if (dmar_remove_dev_scope(info, dmaru->segment,
328 : : dmaru->devices, dmaru->devices_cnt))
329 : : break;
330 : 0 : dmar_iommu_notify_scope_dev(info);
331 : 0 : }
332 : :
333 : 0 : static int dmar_pci_bus_notifier(struct notifier_block *nb,
334 : : unsigned long action, void *data)
335 : : {
336 : 0 : struct pci_dev *pdev = to_pci_dev(data);
337 : 0 : struct dmar_pci_notify_info *info;
338 : :
339 : : /* Only care about add/remove events for physical functions.
340 : : * For VFs we actually do the lookup based on the corresponding
341 : : * PF in device_to_iommu() anyway. */
342 [ # # ]: 0 : if (pdev->is_virtfn)
343 : : return NOTIFY_DONE;
344 : 0 : if (action != BUS_NOTIFY_ADD_DEVICE &&
345 [ # # ]: 0 : action != BUS_NOTIFY_REMOVED_DEVICE)
346 : : return NOTIFY_DONE;
347 : :
348 : 0 : info = dmar_alloc_pci_notify_info(pdev, action);
349 [ # # ]: 0 : if (!info)
350 : : return NOTIFY_DONE;
351 : :
352 : 0 : down_write(&dmar_global_lock);
353 [ # # ]: 0 : if (action == BUS_NOTIFY_ADD_DEVICE)
354 : 0 : dmar_pci_bus_add_dev(info);
355 [ # # ]: 0 : else if (action == BUS_NOTIFY_REMOVED_DEVICE)
356 : 0 : dmar_pci_bus_del_dev(info);
357 : 0 : up_write(&dmar_global_lock);
358 : :
359 [ # # ]: 0 : dmar_free_pci_notify_info(info);
360 : :
361 : : return NOTIFY_OK;
362 : : }
363 : :
364 : : static struct notifier_block dmar_pci_bus_nb = {
365 : : .notifier_call = dmar_pci_bus_notifier,
366 : : .priority = INT_MIN,
367 : : };
368 : :
369 : : static struct dmar_drhd_unit *
370 : 0 : dmar_find_dmaru(struct acpi_dmar_hardware_unit *drhd)
371 : : {
372 : 0 : struct dmar_drhd_unit *dmaru;
373 : :
374 [ # # # # : 0 : list_for_each_entry_rcu(dmaru, &dmar_drhd_units, list,
# # # # ]
375 : : dmar_rcu_check())
376 [ # # # # : 0 : if (dmaru->segment == drhd->segment &&
# # # # ]
377 [ # # # # : 0 : dmaru->reg_base_addr == drhd->address)
# # # # ]
378 : : return dmaru;
379 : :
380 : : return NULL;
381 : : }
382 : :
383 : : /**
384 : : * dmar_parse_one_drhd - parses exactly one DMA remapping hardware definition
385 : : * structure which uniquely represent one DMA remapping hardware unit
386 : : * present in the platform
387 : : */
388 : 0 : static int dmar_parse_one_drhd(struct acpi_dmar_header *header, void *arg)
389 : : {
390 : 0 : struct acpi_dmar_hardware_unit *drhd;
391 : 0 : struct dmar_drhd_unit *dmaru;
392 : 0 : int ret;
393 : :
394 : 0 : drhd = (struct acpi_dmar_hardware_unit *)header;
395 : 0 : dmaru = dmar_find_dmaru(drhd);
396 [ # # ]: 0 : if (dmaru)
397 : 0 : goto out;
398 : :
399 : 0 : dmaru = kzalloc(sizeof(*dmaru) + header->length, GFP_KERNEL);
400 [ # # ]: 0 : if (!dmaru)
401 : : return -ENOMEM;
402 : :
403 : : /*
404 : : * If header is allocated from slab by ACPI _DSM method, we need to
405 : : * copy the content because the memory buffer will be freed on return.
406 : : */
407 : 0 : dmaru->hdr = (void *)(dmaru + 1);
408 : 0 : memcpy(dmaru->hdr, header, header->length);
409 : 0 : dmaru->reg_base_addr = drhd->address;
410 : 0 : dmaru->segment = drhd->segment;
411 : 0 : dmaru->include_all = drhd->flags & 0x1; /* BIT0: INCLUDE_ALL */
412 : 0 : dmaru->devices = dmar_alloc_dev_scope((void *)(drhd + 1),
413 : 0 : ((void *)drhd) + drhd->header.length,
414 : : &dmaru->devices_cnt);
415 [ # # # # ]: 0 : if (dmaru->devices_cnt && dmaru->devices == NULL) {
416 : 0 : kfree(dmaru);
417 : 0 : return -ENOMEM;
418 : : }
419 : :
420 : 0 : ret = alloc_iommu(dmaru);
421 [ # # ]: 0 : if (ret) {
422 : 0 : dmar_free_dev_scope(&dmaru->devices,
423 : : &dmaru->devices_cnt);
424 : 0 : kfree(dmaru);
425 : 0 : return ret;
426 : : }
427 [ # # ]: 0 : dmar_register_drhd_unit(dmaru);
428 : :
429 : 0 : out:
430 [ # # ]: 0 : if (arg)
431 : 0 : (*(int *)arg)++;
432 : :
433 : : return 0;
434 : : }
435 : :
436 : 0 : static void dmar_free_drhd(struct dmar_drhd_unit *dmaru)
437 : : {
438 [ # # # # ]: 0 : if (dmaru->devices && dmaru->devices_cnt)
439 : 0 : dmar_free_dev_scope(&dmaru->devices, &dmaru->devices_cnt);
440 [ # # ]: 0 : if (dmaru->iommu)
441 : 0 : free_iommu(dmaru->iommu);
442 : 0 : kfree(dmaru);
443 : 0 : }
444 : :
445 : 0 : static int __init dmar_parse_one_andd(struct acpi_dmar_header *header,
446 : : void *arg)
447 : : {
448 : 0 : struct acpi_dmar_andd *andd = (void *)header;
449 : :
450 : : /* Check for NUL termination within the designated length */
451 [ # # ]: 0 : if (strnlen(andd->device_name, header->length - 8) == header->length - 8) {
452 : 0 : pr_warn(FW_BUG
453 : : "Your BIOS is broken; ANDD object name is not NUL-terminated\n"
454 : : "BIOS vendor: %s; Ver: %s; Product Version: %s\n",
455 : : dmi_get_system_info(DMI_BIOS_VENDOR),
456 : : dmi_get_system_info(DMI_BIOS_VERSION),
457 : : dmi_get_system_info(DMI_PRODUCT_VERSION));
458 : 0 : add_taint(TAINT_FIRMWARE_WORKAROUND, LOCKDEP_STILL_OK);
459 : 0 : return -EINVAL;
460 : : }
461 : 0 : pr_info("ANDD device: %x name: %s\n", andd->device_number,
462 : : andd->device_name);
463 : :
464 : 0 : return 0;
465 : : }
466 : :
467 : : #ifdef CONFIG_ACPI_NUMA
468 : 0 : static int dmar_parse_one_rhsa(struct acpi_dmar_header *header, void *arg)
469 : : {
470 : 0 : struct acpi_dmar_rhsa *rhsa;
471 : 0 : struct dmar_drhd_unit *drhd;
472 : :
473 : 0 : rhsa = (struct acpi_dmar_rhsa *)header;
474 [ # # ]: 0 : for_each_drhd_unit(drhd) {
475 [ # # ]: 0 : if (drhd->reg_base_addr == rhsa->base_address) {
476 : 0 : int node = acpi_map_pxm_to_node(rhsa->proximity_domain);
477 : :
478 [ # # ]: 0 : if (!node_online(node))
479 : 0 : node = NUMA_NO_NODE;
480 : 0 : drhd->iommu->node = node;
481 : 0 : return 0;
482 : : }
483 : : }
484 : 0 : pr_warn(FW_BUG
485 : : "Your BIOS is broken; RHSA refers to non-existent DMAR unit at %llx\n"
486 : : "BIOS vendor: %s; Ver: %s; Product Version: %s\n",
487 : : rhsa->base_address,
488 : : dmi_get_system_info(DMI_BIOS_VENDOR),
489 : : dmi_get_system_info(DMI_BIOS_VERSION),
490 : : dmi_get_system_info(DMI_PRODUCT_VERSION));
491 : 0 : add_taint(TAINT_FIRMWARE_WORKAROUND, LOCKDEP_STILL_OK);
492 : :
493 : 0 : return 0;
494 : : }
495 : : #else
496 : : #define dmar_parse_one_rhsa dmar_res_noop
497 : : #endif
498 : :
499 : : static void
500 : 0 : dmar_table_print_dmar_entry(struct acpi_dmar_header *header)
501 : : {
502 : 0 : struct acpi_dmar_hardware_unit *drhd;
503 : 0 : struct acpi_dmar_reserved_memory *rmrr;
504 : 0 : struct acpi_dmar_atsr *atsr;
505 : 0 : struct acpi_dmar_rhsa *rhsa;
506 : :
507 [ # # # # : 0 : switch (header->type) {
# ]
508 : 0 : case ACPI_DMAR_TYPE_HARDWARE_UNIT:
509 : 0 : drhd = container_of(header, struct acpi_dmar_hardware_unit,
510 : : header);
511 : 0 : pr_info("DRHD base: %#016Lx flags: %#x\n",
512 : : (unsigned long long)drhd->address, drhd->flags);
513 : 0 : break;
514 : 0 : case ACPI_DMAR_TYPE_RESERVED_MEMORY:
515 : 0 : rmrr = container_of(header, struct acpi_dmar_reserved_memory,
516 : : header);
517 : 0 : pr_info("RMRR base: %#016Lx end: %#016Lx\n",
518 : : (unsigned long long)rmrr->base_address,
519 : : (unsigned long long)rmrr->end_address);
520 : 0 : break;
521 : 0 : case ACPI_DMAR_TYPE_ROOT_ATS:
522 : 0 : atsr = container_of(header, struct acpi_dmar_atsr, header);
523 : 0 : pr_info("ATSR flags: %#x\n", atsr->flags);
524 : 0 : break;
525 : 0 : case ACPI_DMAR_TYPE_HARDWARE_AFFINITY:
526 : 0 : rhsa = container_of(header, struct acpi_dmar_rhsa, header);
527 : 0 : pr_info("RHSA base: %#016Lx proximity domain: %#x\n",
528 : : (unsigned long long)rhsa->base_address,
529 : : rhsa->proximity_domain);
530 : 0 : break;
531 : : case ACPI_DMAR_TYPE_NAMESPACE:
532 : : /* We don't print this here because we need to sanity-check
533 : : it first. So print it in dmar_parse_one_andd() instead. */
534 : : break;
535 : : }
536 : 0 : }
537 : :
538 : : /**
539 : : * dmar_table_detect - checks to see if the platform supports DMAR devices
540 : : */
541 : 30 : static int __init dmar_table_detect(void)
542 : : {
543 : 30 : acpi_status status = AE_OK;
544 : :
545 : : /* if we could find DMAR table, then there are DMAR devices */
546 : 30 : status = acpi_get_table(ACPI_SIG_DMAR, 0, &dmar_tbl);
547 : :
548 [ - + - - ]: 30 : if (ACPI_SUCCESS(status) && !dmar_tbl) {
549 : 0 : pr_warn("Unable to map DMAR\n");
550 : 0 : status = AE_NOT_FOUND;
551 : : }
552 : :
553 [ + - ]: 30 : return ACPI_SUCCESS(status) ? 0 : -ENOENT;
554 : : }
555 : :
556 : 0 : static int dmar_walk_remapping_entries(struct acpi_dmar_header *start,
557 : : size_t len, struct dmar_res_callback *cb)
558 : : {
559 : 0 : struct acpi_dmar_header *iter, *next;
560 : 0 : struct acpi_dmar_header *end = ((void *)start) + len;
561 : :
562 [ # # ]: 0 : for (iter = start; iter < end; iter = next) {
563 : 0 : next = (void *)iter + iter->length;
564 [ # # ]: 0 : if (iter->length == 0) {
565 : : /* Avoid looping forever on bad ACPI tables */
566 : : pr_debug(FW_BUG "Invalid 0-length structure\n");
567 : : break;
568 [ # # ]: 0 : } else if (next > end) {
569 : : /* Avoid passing table end */
570 : 0 : pr_warn(FW_BUG "Record passes table end\n");
571 : 0 : return -EINVAL;
572 : : }
573 : :
574 [ # # ]: 0 : if (cb->print_entry)
575 : 0 : dmar_table_print_dmar_entry(iter);
576 : :
577 [ # # ]: 0 : if (iter->type >= ACPI_DMAR_TYPE_RESERVED) {
578 : : /* continue for forward compatibility */
579 : : pr_debug("Unknown DMAR structure type %d\n",
580 : : iter->type);
581 [ # # ]: 0 : } else if (cb->cb[iter->type]) {
582 : 0 : int ret;
583 : :
584 : 0 : ret = cb->cb[iter->type](iter, cb->arg[iter->type]);
585 [ # # ]: 0 : if (ret)
586 : 0 : return ret;
587 [ # # ]: 0 : } else if (!cb->ignore_unhandled) {
588 : 0 : pr_warn("No handler for DMAR structure type %d\n",
589 : : iter->type);
590 : 0 : return -EINVAL;
591 : : }
592 : : }
593 : :
594 : : return 0;
595 : : }
596 : :
597 : 0 : static inline int dmar_walk_dmar_table(struct acpi_table_dmar *dmar,
598 : : struct dmar_res_callback *cb)
599 : : {
600 : 0 : return dmar_walk_remapping_entries((void *)(dmar + 1),
601 : 0 : dmar->header.length - sizeof(*dmar), cb);
602 : : }
603 : :
604 : : /**
605 : : * parse_dmar_table - parses the DMA reporting table
606 : : */
607 : : static int __init
608 : 0 : parse_dmar_table(void)
609 : : {
610 : 0 : struct acpi_table_dmar *dmar;
611 : 0 : int drhd_count = 0;
612 : 0 : int ret;
613 : 0 : struct dmar_res_callback cb = {
614 : : .print_entry = true,
615 : : .ignore_unhandled = true,
616 : : .arg[ACPI_DMAR_TYPE_HARDWARE_UNIT] = &drhd_count,
617 : : .cb[ACPI_DMAR_TYPE_HARDWARE_UNIT] = &dmar_parse_one_drhd,
618 : : .cb[ACPI_DMAR_TYPE_RESERVED_MEMORY] = &dmar_parse_one_rmrr,
619 : : .cb[ACPI_DMAR_TYPE_ROOT_ATS] = &dmar_parse_one_atsr,
620 : : .cb[ACPI_DMAR_TYPE_HARDWARE_AFFINITY] = &dmar_parse_one_rhsa,
621 : : .cb[ACPI_DMAR_TYPE_NAMESPACE] = &dmar_parse_one_andd,
622 : : };
623 : :
624 : : /*
625 : : * Do it again, earlier dmar_tbl mapping could be mapped with
626 : : * fixed map.
627 : : */
628 : 0 : dmar_table_detect();
629 : :
630 : : /*
631 : : * ACPI tables may not be DMA protected by tboot, so use DMAR copy
632 : : * SINIT saved in SinitMleData in TXT heap (which is DMA protected)
633 : : */
634 : 0 : dmar_tbl = tboot_get_dmar_table(dmar_tbl);
635 : :
636 : 0 : dmar = (struct acpi_table_dmar *)dmar_tbl;
637 [ # # ]: 0 : if (!dmar)
638 : : return -ENODEV;
639 : :
640 [ # # ]: 0 : if (dmar->width < PAGE_SHIFT - 1) {
641 : 0 : pr_warn("Invalid DMAR haw\n");
642 : 0 : return -EINVAL;
643 : : }
644 : :
645 : 0 : pr_info("Host address width %d\n", dmar->width + 1);
646 : 0 : ret = dmar_walk_dmar_table(dmar, &cb);
647 [ # # # # ]: 0 : if (ret == 0 && drhd_count == 0)
648 : 0 : pr_warn(FW_BUG "No DRHD structure found in DMAR table\n");
649 : :
650 : : return ret;
651 : : }
652 : :
653 : 0 : static int dmar_pci_device_match(struct dmar_dev_scope devices[],
654 : : int cnt, struct pci_dev *dev)
655 : : {
656 : 0 : int index;
657 : 0 : struct device *tmp;
658 : :
659 [ # # ]: 0 : while (dev) {
660 [ # # # # : 0 : for_each_active_dev_scope(devices, cnt, index, tmp)
# # ]
661 [ # # # # ]: 0 : if (dev_is_pci(tmp) && dev == to_pci_dev(tmp))
662 : : return 1;
663 : :
664 : : /* Check our parent */
665 : 0 : dev = dev->bus->self;
666 : : }
667 : :
668 : : return 0;
669 : : }
670 : :
671 : : struct dmar_drhd_unit *
672 : 0 : dmar_find_matched_drhd_unit(struct pci_dev *dev)
673 : : {
674 : 0 : struct dmar_drhd_unit *dmaru;
675 : 0 : struct acpi_dmar_hardware_unit *drhd;
676 : :
677 : 0 : dev = pci_physfn(dev);
678 : :
679 : 0 : rcu_read_lock();
680 [ # # ]: 0 : for_each_drhd_unit(dmaru) {
681 : 0 : drhd = container_of(dmaru->hdr,
682 : : struct acpi_dmar_hardware_unit,
683 : : header);
684 : :
685 [ # # # # ]: 0 : if (dmaru->include_all &&
686 [ # # ]: 0 : drhd->segment == pci_domain_nr(dev->bus))
687 : 0 : goto out;
688 : :
689 [ # # ]: 0 : if (dmar_pci_device_match(dmaru->devices,
690 : : dmaru->devices_cnt, dev))
691 : 0 : goto out;
692 : : }
693 : : dmaru = NULL;
694 : 0 : out:
695 : 0 : rcu_read_unlock();
696 : :
697 : 0 : return dmaru;
698 : : }
699 : :
700 : 0 : static void __init dmar_acpi_insert_dev_scope(u8 device_number,
701 : : struct acpi_device *adev)
702 : : {
703 : 0 : struct dmar_drhd_unit *dmaru;
704 : 0 : struct acpi_dmar_hardware_unit *drhd;
705 : 0 : struct acpi_dmar_device_scope *scope;
706 : 0 : struct device *tmp;
707 : 0 : int i;
708 : 0 : struct acpi_dmar_pci_path *path;
709 : :
710 [ # # ]: 0 : for_each_drhd_unit(dmaru) {
711 : 0 : drhd = container_of(dmaru->hdr,
712 : : struct acpi_dmar_hardware_unit,
713 : : header);
714 : :
715 : 0 : for (scope = (void *)(drhd + 1);
716 [ # # ]: 0 : (unsigned long)scope < ((unsigned long)drhd) + drhd->header.length;
717 : 0 : scope = ((void *)scope) + scope->length) {
718 [ # # ]: 0 : if (scope->entry_type != ACPI_DMAR_SCOPE_TYPE_NAMESPACE)
719 : 0 : continue;
720 [ # # ]: 0 : if (scope->enumeration_id != device_number)
721 : 0 : continue;
722 : :
723 : 0 : path = (void *)(scope + 1);
724 [ # # ]: 0 : pr_info("ACPI device \"%s\" under DMAR at %llx as %02x:%02x.%d\n",
725 : : dev_name(&adev->dev), dmaru->reg_base_addr,
726 : : scope->bus, path->device, path->function);
727 [ # # # # ]: 0 : for_each_dev_scope(dmaru->devices, dmaru->devices_cnt, i, tmp)
728 [ # # ]: 0 : if (tmp == NULL) {
729 : 0 : dmaru->devices[i].bus = scope->bus;
730 : 0 : dmaru->devices[i].devfn = PCI_DEVFN(path->device,
731 : : path->function);
732 : 0 : rcu_assign_pointer(dmaru->devices[i].dev,
733 : : get_device(&adev->dev));
734 : 0 : return;
735 : : }
736 : 0 : BUG_ON(i >= dmaru->devices_cnt);
737 : : }
738 : : }
739 [ # # ]: 0 : pr_warn("No IOMMU scope found for ANDD enumeration ID %d (%s)\n",
740 : : device_number, dev_name(&adev->dev));
741 : : }
742 : :
743 : 0 : static int __init dmar_acpi_dev_scope_init(void)
744 : : {
745 : 0 : struct acpi_dmar_andd *andd;
746 : :
747 [ # # ]: 0 : if (dmar_tbl == NULL)
748 : : return -ENODEV;
749 : :
750 : 0 : for (andd = (void *)dmar_tbl + sizeof(struct acpi_table_dmar);
751 [ # # ]: 0 : ((unsigned long)andd) < ((unsigned long)dmar_tbl) + dmar_tbl->length;
752 : 0 : andd = ((void *)andd) + andd->header.length) {
753 [ # # ]: 0 : if (andd->header.type == ACPI_DMAR_TYPE_NAMESPACE) {
754 : 0 : acpi_handle h;
755 : 0 : struct acpi_device *adev;
756 : :
757 [ # # ]: 0 : if (!ACPI_SUCCESS(acpi_get_handle(ACPI_ROOT_OBJECT,
758 : : andd->device_name,
759 : : &h))) {
760 : 0 : pr_err("Failed to find handle for ACPI object %s\n",
761 : : andd->device_name);
762 : 0 : continue;
763 : : }
764 [ # # ]: 0 : if (acpi_bus_get_device(h, &adev)) {
765 : 0 : pr_err("Failed to get device for ACPI object %s\n",
766 : : andd->device_name);
767 : 0 : continue;
768 : : }
769 : 0 : dmar_acpi_insert_dev_scope(andd->device_number, adev);
770 : : }
771 : : }
772 : : return 0;
773 : : }
774 : :
775 : 0 : int __init dmar_dev_scope_init(void)
776 : : {
777 : 0 : struct pci_dev *dev = NULL;
778 : 0 : struct dmar_pci_notify_info *info;
779 : :
780 [ # # ]: 0 : if (dmar_dev_scope_status != 1)
781 : : return dmar_dev_scope_status;
782 : :
783 [ # # ]: 0 : if (list_empty(&dmar_drhd_units)) {
784 : 0 : dmar_dev_scope_status = -ENODEV;
785 : : } else {
786 : 0 : dmar_dev_scope_status = 0;
787 : :
788 : 0 : dmar_acpi_dev_scope_init();
789 : :
790 [ # # ]: 0 : for_each_pci_dev(dev) {
791 [ # # ]: 0 : if (dev->is_virtfn)
792 : 0 : continue;
793 : :
794 : 0 : info = dmar_alloc_pci_notify_info(dev,
795 : : BUS_NOTIFY_ADD_DEVICE);
796 [ # # ]: 0 : if (!info) {
797 : 0 : return dmar_dev_scope_status;
798 : : } else {
799 : 0 : dmar_pci_bus_add_dev(info);
800 [ # # ]: 0 : dmar_free_pci_notify_info(info);
801 : : }
802 : : }
803 : : }
804 : :
805 : 0 : return dmar_dev_scope_status;
806 : : }
807 : :
808 : 0 : void __init dmar_register_bus_notifier(void)
809 : : {
810 : 0 : bus_register_notifier(&pci_bus_type, &dmar_pci_bus_nb);
811 : 0 : }
812 : :
813 : :
814 : 0 : int __init dmar_table_init(void)
815 : : {
816 : 0 : static int dmar_table_initialized;
817 : 0 : int ret;
818 : :
819 [ # # ]: 0 : if (dmar_table_initialized == 0) {
820 : 0 : ret = parse_dmar_table();
821 [ # # ]: 0 : if (ret < 0) {
822 [ # # ]: 0 : if (ret != -ENODEV)
823 : 0 : pr_info("Parse DMAR table failure.\n");
824 [ # # ]: 0 : } else if (list_empty(&dmar_drhd_units)) {
825 : 0 : pr_info("No DMAR devices found\n");
826 : 0 : ret = -ENODEV;
827 : : }
828 : :
829 [ # # ]: 0 : if (ret < 0)
830 : 0 : dmar_table_initialized = ret;
831 : : else
832 : 0 : dmar_table_initialized = 1;
833 : : }
834 : :
835 : 0 : return dmar_table_initialized < 0 ? dmar_table_initialized : 0;
836 : : }
837 : :
838 : 0 : static void warn_invalid_dmar(u64 addr, const char *message)
839 : : {
840 [ # # ]: 0 : pr_warn_once(FW_BUG
841 : : "Your BIOS is broken; DMAR reported at address %llx%s!\n"
842 : : "BIOS vendor: %s; Ver: %s; Product Version: %s\n",
843 : : addr, message,
844 : : dmi_get_system_info(DMI_BIOS_VENDOR),
845 : : dmi_get_system_info(DMI_BIOS_VERSION),
846 : : dmi_get_system_info(DMI_PRODUCT_VERSION));
847 : 0 : add_taint(TAINT_FIRMWARE_WORKAROUND, LOCKDEP_STILL_OK);
848 : 0 : }
849 : :
850 : : static int __ref
851 : 0 : dmar_validate_one_drhd(struct acpi_dmar_header *entry, void *arg)
852 : : {
853 : 0 : struct acpi_dmar_hardware_unit *drhd;
854 : 0 : void __iomem *addr;
855 : 0 : u64 cap, ecap;
856 : :
857 : 0 : drhd = (void *)entry;
858 [ # # ]: 0 : if (!drhd->address) {
859 : 0 : warn_invalid_dmar(0, "");
860 : 0 : return -EINVAL;
861 : : }
862 : :
863 [ # # ]: 0 : if (arg)
864 : 0 : addr = ioremap(drhd->address, VTD_PAGE_SIZE);
865 : : else
866 : 0 : addr = early_ioremap(drhd->address, VTD_PAGE_SIZE);
867 [ # # ]: 0 : if (!addr) {
868 : 0 : pr_warn("Can't validate DRHD address: %llx\n", drhd->address);
869 : 0 : return -EINVAL;
870 : : }
871 : :
872 : 0 : cap = dmar_readq(addr + DMAR_CAP_REG);
873 : 0 : ecap = dmar_readq(addr + DMAR_ECAP_REG);
874 : :
875 [ # # ]: 0 : if (arg)
876 : 0 : iounmap(addr);
877 : : else
878 : 0 : early_iounmap(addr, VTD_PAGE_SIZE);
879 : :
880 [ # # ]: 0 : if (cap == (uint64_t)-1 && ecap == (uint64_t)-1) {
881 : 0 : warn_invalid_dmar(drhd->address, " returns all ones");
882 : 0 : return -EINVAL;
883 : : }
884 : :
885 : : return 0;
886 : : }
887 : :
888 : 30 : int __init detect_intel_iommu(void)
889 : : {
890 : 30 : int ret;
891 : 30 : struct dmar_res_callback validate_drhd_cb = {
892 : : .cb[ACPI_DMAR_TYPE_HARDWARE_UNIT] = &dmar_validate_one_drhd,
893 : : .ignore_unhandled = true,
894 : : };
895 : :
896 : 30 : down_write(&dmar_global_lock);
897 : 30 : ret = dmar_table_detect();
898 [ - + ]: 30 : if (!ret)
899 : 0 : ret = dmar_walk_dmar_table((struct acpi_table_dmar *)dmar_tbl,
900 : : &validate_drhd_cb);
901 [ - + - - : 30 : if (!ret && !no_iommu && !iommu_detected && !dmar_disabled) {
- - - - ]
902 : 0 : iommu_detected = 1;
903 : : /* Make sure ACS will be enabled */
904 : 0 : pci_request_acs();
905 : : }
906 : :
907 : : #ifdef CONFIG_X86
908 [ - + ]: 30 : if (!ret) {
909 : 0 : x86_init.iommu.iommu_init = intel_iommu_init;
910 : 0 : x86_platform.iommu_shutdown = intel_iommu_shutdown;
911 : : }
912 : :
913 : : #endif
914 : :
915 [ - + ]: 30 : if (dmar_tbl) {
916 : 0 : acpi_put_table(dmar_tbl);
917 : 0 : dmar_tbl = NULL;
918 : : }
919 : 30 : up_write(&dmar_global_lock);
920 : :
921 [ - + ]: 30 : return ret ? ret : 1;
922 : : }
923 : :
924 : 0 : static void unmap_iommu(struct intel_iommu *iommu)
925 : : {
926 : 0 : iounmap(iommu->reg);
927 : 0 : release_mem_region(iommu->reg_phys, iommu->reg_size);
928 : 0 : }
929 : :
930 : : /**
931 : : * map_iommu: map the iommu's registers
932 : : * @iommu: the iommu to map
933 : : * @phys_addr: the physical address of the base resgister
934 : : *
935 : : * Memory map the iommu's registers. Start w/ a single page, and
936 : : * possibly expand if that turns out to be insufficent.
937 : : */
938 : 0 : static int map_iommu(struct intel_iommu *iommu, u64 phys_addr)
939 : : {
940 : 0 : int map_size, err=0;
941 : :
942 : 0 : iommu->reg_phys = phys_addr;
943 : 0 : iommu->reg_size = VTD_PAGE_SIZE;
944 : :
945 [ # # ]: 0 : if (!request_mem_region(iommu->reg_phys, iommu->reg_size, iommu->name)) {
946 : 0 : pr_err("Can't reserve memory\n");
947 : 0 : err = -EBUSY;
948 : 0 : goto out;
949 : : }
950 : :
951 : 0 : iommu->reg = ioremap(iommu->reg_phys, iommu->reg_size);
952 [ # # ]: 0 : if (!iommu->reg) {
953 : 0 : pr_err("Can't map the region\n");
954 : 0 : err = -ENOMEM;
955 : 0 : goto release;
956 : : }
957 : :
958 : 0 : iommu->cap = dmar_readq(iommu->reg + DMAR_CAP_REG);
959 : 0 : iommu->ecap = dmar_readq(iommu->reg + DMAR_ECAP_REG);
960 : :
961 [ # # # # ]: 0 : if (iommu->cap == (uint64_t)-1 && iommu->ecap == (uint64_t)-1) {
962 : 0 : err = -EINVAL;
963 : 0 : warn_invalid_dmar(phys_addr, " returns all ones");
964 : 0 : goto unmap;
965 : : }
966 : :
967 : : /* the registers might be more than one page */
968 : 0 : map_size = max_t(int, ecap_max_iotlb_offset(iommu->ecap),
969 : : cap_max_fault_reg_offset(iommu->cap));
970 : 0 : map_size = VTD_PAGE_ALIGN(map_size);
971 [ # # ]: 0 : if (map_size > iommu->reg_size) {
972 : 0 : iounmap(iommu->reg);
973 : 0 : release_mem_region(iommu->reg_phys, iommu->reg_size);
974 : 0 : iommu->reg_size = map_size;
975 [ # # ]: 0 : if (!request_mem_region(iommu->reg_phys, iommu->reg_size,
976 : : iommu->name)) {
977 : 0 : pr_err("Can't reserve memory\n");
978 : 0 : err = -EBUSY;
979 : 0 : goto out;
980 : : }
981 : 0 : iommu->reg = ioremap(iommu->reg_phys, iommu->reg_size);
982 [ # # ]: 0 : if (!iommu->reg) {
983 : 0 : pr_err("Can't map the region\n");
984 : 0 : err = -ENOMEM;
985 : 0 : goto release;
986 : : }
987 : : }
988 : 0 : err = 0;
989 : 0 : goto out;
990 : :
991 : : unmap:
992 : 0 : iounmap(iommu->reg);
993 : 0 : release:
994 : 0 : release_mem_region(iommu->reg_phys, iommu->reg_size);
995 : 0 : out:
996 : 0 : return err;
997 : : }
998 : :
999 : 0 : static int dmar_alloc_seq_id(struct intel_iommu *iommu)
1000 : : {
1001 : 0 : iommu->seq_id = find_first_zero_bit(dmar_seq_ids,
1002 : : DMAR_UNITS_SUPPORTED);
1003 [ # # ]: 0 : if (iommu->seq_id >= DMAR_UNITS_SUPPORTED) {
1004 : 0 : iommu->seq_id = -1;
1005 : : } else {
1006 : 0 : set_bit(iommu->seq_id, dmar_seq_ids);
1007 : 0 : sprintf(iommu->name, "dmar%d", iommu->seq_id);
1008 : : }
1009 : :
1010 : 0 : return iommu->seq_id;
1011 : : }
1012 : :
1013 : 0 : static void dmar_free_seq_id(struct intel_iommu *iommu)
1014 : : {
1015 : 0 : if (iommu->seq_id >= 0) {
1016 : 0 : clear_bit(iommu->seq_id, dmar_seq_ids);
1017 : 0 : iommu->seq_id = -1;
1018 : : }
1019 : : }
1020 : :
1021 : 0 : static int alloc_iommu(struct dmar_drhd_unit *drhd)
1022 : : {
1023 : 0 : struct intel_iommu *iommu;
1024 : 0 : u32 ver, sts;
1025 : 0 : int agaw = 0;
1026 : 0 : int msagaw = 0;
1027 : 0 : int err;
1028 : :
1029 [ # # ]: 0 : if (!drhd->reg_base_addr) {
1030 : 0 : warn_invalid_dmar(0, "");
1031 : 0 : return -EINVAL;
1032 : : }
1033 : :
1034 : 0 : iommu = kzalloc(sizeof(*iommu), GFP_KERNEL);
1035 [ # # ]: 0 : if (!iommu)
1036 : : return -ENOMEM;
1037 : :
1038 [ # # ]: 0 : if (dmar_alloc_seq_id(iommu) < 0) {
1039 : 0 : pr_err("Failed to allocate seq_id\n");
1040 : 0 : err = -ENOSPC;
1041 : 0 : goto error;
1042 : : }
1043 : :
1044 : 0 : err = map_iommu(iommu, drhd->reg_base_addr);
1045 [ # # ]: 0 : if (err) {
1046 : 0 : pr_err("Failed to map %s\n", iommu->name);
1047 : 0 : goto error_free_seq_id;
1048 : : }
1049 : :
1050 : 0 : err = -EINVAL;
1051 : 0 : agaw = iommu_calculate_agaw(iommu);
1052 [ # # ]: 0 : if (agaw < 0) {
1053 : 0 : pr_err("Cannot get a valid agaw for iommu (seq_id = %d)\n",
1054 : : iommu->seq_id);
1055 : 0 : goto err_unmap;
1056 : : }
1057 : 0 : msagaw = iommu_calculate_max_sagaw(iommu);
1058 [ # # ]: 0 : if (msagaw < 0) {
1059 : 0 : pr_err("Cannot get a valid max agaw for iommu (seq_id = %d)\n",
1060 : : iommu->seq_id);
1061 : 0 : goto err_unmap;
1062 : : }
1063 : 0 : iommu->agaw = agaw;
1064 : 0 : iommu->msagaw = msagaw;
1065 : 0 : iommu->segment = drhd->segment;
1066 : :
1067 : 0 : iommu->node = NUMA_NO_NODE;
1068 : :
1069 : 0 : ver = readl(iommu->reg + DMAR_VER_REG);
1070 : 0 : pr_info("%s: reg_base_addr %llx ver %d:%d cap %llx ecap %llx\n",
1071 : : iommu->name,
1072 : : (unsigned long long)drhd->reg_base_addr,
1073 : : DMAR_VER_MAJOR(ver), DMAR_VER_MINOR(ver),
1074 : : (unsigned long long)iommu->cap,
1075 : : (unsigned long long)iommu->ecap);
1076 : :
1077 : : /* Reflect status in gcmd */
1078 : 0 : sts = readl(iommu->reg + DMAR_GSTS_REG);
1079 [ # # ]: 0 : if (sts & DMA_GSTS_IRES)
1080 : 0 : iommu->gcmd |= DMA_GCMD_IRE;
1081 [ # # ]: 0 : if (sts & DMA_GSTS_TES)
1082 : 0 : iommu->gcmd |= DMA_GCMD_TE;
1083 [ # # ]: 0 : if (sts & DMA_GSTS_QIES)
1084 : 0 : iommu->gcmd |= DMA_GCMD_QIE;
1085 : :
1086 : 0 : raw_spin_lock_init(&iommu->register_lock);
1087 : :
1088 [ # # ]: 0 : if (intel_iommu_enabled) {
1089 : 0 : err = iommu_device_sysfs_add(&iommu->iommu, NULL,
1090 : : intel_iommu_groups,
1091 : : "%s", iommu->name);
1092 [ # # ]: 0 : if (err)
1093 : 0 : goto err_unmap;
1094 : :
1095 : 0 : iommu_device_set_ops(&iommu->iommu, &intel_iommu_ops);
1096 : :
1097 : 0 : err = iommu_device_register(&iommu->iommu);
1098 [ # # ]: 0 : if (err)
1099 : 0 : goto err_unmap;
1100 : : }
1101 : :
1102 : 0 : drhd->iommu = iommu;
1103 : :
1104 : 0 : return 0;
1105 : :
1106 : 0 : err_unmap:
1107 : 0 : unmap_iommu(iommu);
1108 : 0 : error_free_seq_id:
1109 [ # # ]: 0 : dmar_free_seq_id(iommu);
1110 : 0 : error:
1111 : 0 : kfree(iommu);
1112 : 0 : return err;
1113 : : }
1114 : :
1115 : 0 : static void free_iommu(struct intel_iommu *iommu)
1116 : : {
1117 [ # # ]: 0 : if (intel_iommu_enabled) {
1118 : 0 : iommu_device_unregister(&iommu->iommu);
1119 : 0 : iommu_device_sysfs_remove(&iommu->iommu);
1120 : : }
1121 : :
1122 [ # # ]: 0 : if (iommu->irq) {
1123 [ # # ]: 0 : if (iommu->pr_irq) {
1124 : 0 : free_irq(iommu->pr_irq, iommu);
1125 : 0 : dmar_free_hwirq(iommu->pr_irq);
1126 : 0 : iommu->pr_irq = 0;
1127 : : }
1128 : 0 : free_irq(iommu->irq, iommu);
1129 : 0 : dmar_free_hwirq(iommu->irq);
1130 : 0 : iommu->irq = 0;
1131 : : }
1132 : :
1133 [ # # ]: 0 : if (iommu->qi) {
1134 : 0 : free_page((unsigned long)iommu->qi->desc);
1135 : 0 : kfree(iommu->qi->desc_status);
1136 : 0 : kfree(iommu->qi);
1137 : : }
1138 : :
1139 [ # # ]: 0 : if (iommu->reg)
1140 : 0 : unmap_iommu(iommu);
1141 : :
1142 [ # # ]: 0 : dmar_free_seq_id(iommu);
1143 : 0 : kfree(iommu);
1144 : 0 : }
1145 : :
1146 : : /*
1147 : : * Reclaim all the submitted descriptors which have completed its work.
1148 : : */
1149 : 0 : static inline void reclaim_free_desc(struct q_inval *qi)
1150 : : {
1151 [ # # ]: 0 : while (qi->desc_status[qi->free_tail] == QI_DONE ||
1152 : : qi->desc_status[qi->free_tail] == QI_ABORT) {
1153 : 0 : qi->desc_status[qi->free_tail] = QI_FREE;
1154 : 0 : qi->free_tail = (qi->free_tail + 1) % QI_LENGTH;
1155 : 0 : qi->free_cnt++;
1156 : : }
1157 : : }
1158 : :
1159 : 0 : static int qi_check_fault(struct intel_iommu *iommu, int index)
1160 : : {
1161 : 0 : u32 fault;
1162 : 0 : int head, tail;
1163 : 0 : struct q_inval *qi = iommu->qi;
1164 : 0 : int wait_index = (index + 1) % QI_LENGTH;
1165 [ # # ]: 0 : int shift = qi_shift(iommu);
1166 : :
1167 [ # # ]: 0 : if (qi->desc_status[wait_index] == QI_ABORT)
1168 : : return -EAGAIN;
1169 : :
1170 : 0 : fault = readl(iommu->reg + DMAR_FSTS_REG);
1171 : :
1172 : : /*
1173 : : * If IQE happens, the head points to the descriptor associated
1174 : : * with the error. No new descriptors are fetched until the IQE
1175 : : * is cleared.
1176 : : */
1177 [ # # ]: 0 : if (fault & DMA_FSTS_IQE) {
1178 : 0 : head = readl(iommu->reg + DMAR_IQH_REG);
1179 [ # # ]: 0 : if ((head >> shift) == index) {
1180 : 0 : struct qi_desc *desc = qi->desc + head;
1181 : :
1182 : : /*
1183 : : * desc->qw2 and desc->qw3 are either reserved or
1184 : : * used by software as private data. We won't print
1185 : : * out these two qw's for security consideration.
1186 : : */
1187 : 0 : pr_err("VT-d detected invalid descriptor: qw0 = %llx, qw1 = %llx\n",
1188 : : (unsigned long long)desc->qw0,
1189 : : (unsigned long long)desc->qw1);
1190 : 0 : memcpy(desc, qi->desc + (wait_index << shift),
1191 : 0 : 1 << shift);
1192 : 0 : writel(DMA_FSTS_IQE, iommu->reg + DMAR_FSTS_REG);
1193 : 0 : return -EINVAL;
1194 : : }
1195 : : }
1196 : :
1197 : : /*
1198 : : * If ITE happens, all pending wait_desc commands are aborted.
1199 : : * No new descriptors are fetched until the ITE is cleared.
1200 : : */
1201 [ # # ]: 0 : if (fault & DMA_FSTS_ITE) {
1202 : 0 : head = readl(iommu->reg + DMAR_IQH_REG);
1203 : 0 : head = ((head >> shift) - 1 + QI_LENGTH) % QI_LENGTH;
1204 : 0 : head |= 1;
1205 : 0 : tail = readl(iommu->reg + DMAR_IQT_REG);
1206 : 0 : tail = ((tail >> shift) - 1 + QI_LENGTH) % QI_LENGTH;
1207 : :
1208 : 0 : writel(DMA_FSTS_ITE, iommu->reg + DMAR_FSTS_REG);
1209 : :
1210 : 0 : do {
1211 [ # # ]: 0 : if (qi->desc_status[head] == QI_IN_USE)
1212 : 0 : qi->desc_status[head] = QI_ABORT;
1213 : 0 : head = (head - 2 + QI_LENGTH) % QI_LENGTH;
1214 [ # # ]: 0 : } while (head != tail);
1215 : :
1216 [ # # ]: 0 : if (qi->desc_status[wait_index] == QI_ABORT)
1217 : : return -EAGAIN;
1218 : : }
1219 : :
1220 [ # # ]: 0 : if (fault & DMA_FSTS_ICE)
1221 : 0 : writel(DMA_FSTS_ICE, iommu->reg + DMAR_FSTS_REG);
1222 : :
1223 : : return 0;
1224 : : }
1225 : :
1226 : : /*
1227 : : * Submit the queued invalidation descriptor to the remapping
1228 : : * hardware unit and wait for its completion.
1229 : : */
1230 : 0 : int qi_submit_sync(struct qi_desc *desc, struct intel_iommu *iommu)
1231 : : {
1232 : 0 : int rc;
1233 : 0 : struct q_inval *qi = iommu->qi;
1234 : 0 : int offset, shift, length;
1235 : 0 : struct qi_desc wait_desc;
1236 : 0 : int wait_index, index;
1237 : 0 : unsigned long flags;
1238 : :
1239 [ # # ]: 0 : if (!qi)
1240 : : return 0;
1241 : :
1242 : 0 : restart:
1243 : 0 : rc = 0;
1244 : :
1245 : 0 : raw_spin_lock_irqsave(&qi->q_lock, flags);
1246 : 0 : while (qi->free_cnt < 3) {
1247 : 0 : raw_spin_unlock_irqrestore(&qi->q_lock, flags);
1248 : 0 : cpu_relax();
1249 [ # # ]: 0 : raw_spin_lock_irqsave(&qi->q_lock, flags);
1250 : : }
1251 : :
1252 : 0 : index = qi->free_head;
1253 : 0 : wait_index = (index + 1) % QI_LENGTH;
1254 [ # # ]: 0 : shift = qi_shift(iommu);
1255 : 0 : length = 1 << shift;
1256 : :
1257 : 0 : qi->desc_status[index] = qi->desc_status[wait_index] = QI_IN_USE;
1258 : :
1259 : 0 : offset = index << shift;
1260 : 0 : memcpy(qi->desc + offset, desc, length);
1261 : 0 : wait_desc.qw0 = QI_IWD_STATUS_DATA(QI_DONE) |
1262 : : QI_IWD_STATUS_WRITE | QI_IWD_TYPE;
1263 [ # # ]: 0 : wait_desc.qw1 = virt_to_phys(&qi->desc_status[wait_index]);
1264 : 0 : wait_desc.qw2 = 0;
1265 : 0 : wait_desc.qw3 = 0;
1266 : :
1267 : 0 : offset = wait_index << shift;
1268 : 0 : memcpy(qi->desc + offset, &wait_desc, length);
1269 : :
1270 : 0 : qi->free_head = (qi->free_head + 2) % QI_LENGTH;
1271 : 0 : qi->free_cnt -= 2;
1272 : :
1273 : : /*
1274 : : * update the HW tail register indicating the presence of
1275 : : * new descriptors.
1276 : : */
1277 : 0 : writel(qi->free_head << shift, iommu->reg + DMAR_IQT_REG);
1278 : :
1279 [ # # ]: 0 : while (qi->desc_status[wait_index] != QI_DONE) {
1280 : : /*
1281 : : * We will leave the interrupts disabled, to prevent interrupt
1282 : : * context to queue another cmd while a cmd is already submitted
1283 : : * and waiting for completion on this cpu. This is to avoid
1284 : : * a deadlock where the interrupt context can wait indefinitely
1285 : : * for free slots in the queue.
1286 : : */
1287 : 0 : rc = qi_check_fault(iommu, index);
1288 [ # # ]: 0 : if (rc)
1289 : : break;
1290 : :
1291 : 0 : raw_spin_unlock(&qi->q_lock);
1292 : 0 : cpu_relax();
1293 : 0 : raw_spin_lock(&qi->q_lock);
1294 : : }
1295 : :
1296 : 0 : qi->desc_status[index] = QI_DONE;
1297 : :
1298 : 0 : reclaim_free_desc(qi);
1299 : 0 : raw_spin_unlock_irqrestore(&qi->q_lock, flags);
1300 : :
1301 [ # # ]: 0 : if (rc == -EAGAIN)
1302 : 0 : goto restart;
1303 : :
1304 : : return rc;
1305 : : }
1306 : :
1307 : : /*
1308 : : * Flush the global interrupt entry cache.
1309 : : */
1310 : 0 : void qi_global_iec(struct intel_iommu *iommu)
1311 : : {
1312 : 0 : struct qi_desc desc;
1313 : :
1314 : 0 : desc.qw0 = QI_IEC_TYPE;
1315 : 0 : desc.qw1 = 0;
1316 : 0 : desc.qw2 = 0;
1317 : 0 : desc.qw3 = 0;
1318 : :
1319 : : /* should never fail */
1320 : 0 : qi_submit_sync(&desc, iommu);
1321 : 0 : }
1322 : :
1323 : 0 : void qi_flush_context(struct intel_iommu *iommu, u16 did, u16 sid, u8 fm,
1324 : : u64 type)
1325 : : {
1326 : 0 : struct qi_desc desc;
1327 : :
1328 : 0 : desc.qw0 = QI_CC_FM(fm) | QI_CC_SID(sid) | QI_CC_DID(did)
1329 : 0 : | QI_CC_GRAN(type) | QI_CC_TYPE;
1330 : 0 : desc.qw1 = 0;
1331 : 0 : desc.qw2 = 0;
1332 : 0 : desc.qw3 = 0;
1333 : :
1334 : 0 : qi_submit_sync(&desc, iommu);
1335 : 0 : }
1336 : :
1337 : 0 : void qi_flush_iotlb(struct intel_iommu *iommu, u16 did, u64 addr,
1338 : : unsigned int size_order, u64 type)
1339 : : {
1340 : 0 : u8 dw = 0, dr = 0;
1341 : :
1342 : 0 : struct qi_desc desc;
1343 : 0 : int ih = 0;
1344 : :
1345 [ # # ]: 0 : if (cap_write_drain(iommu->cap))
1346 : 0 : dw = 1;
1347 : :
1348 [ # # ]: 0 : if (cap_read_drain(iommu->cap))
1349 : 0 : dr = 1;
1350 : :
1351 : 0 : desc.qw0 = QI_IOTLB_DID(did) | QI_IOTLB_DR(dr) | QI_IOTLB_DW(dw)
1352 : 0 : | QI_IOTLB_GRAN(type) | QI_IOTLB_TYPE;
1353 : 0 : desc.qw1 = QI_IOTLB_ADDR(addr) | QI_IOTLB_IH(ih)
1354 : 0 : | QI_IOTLB_AM(size_order);
1355 : 0 : desc.qw2 = 0;
1356 : 0 : desc.qw3 = 0;
1357 : :
1358 : 0 : qi_submit_sync(&desc, iommu);
1359 : 0 : }
1360 : :
1361 : 0 : void qi_flush_dev_iotlb(struct intel_iommu *iommu, u16 sid, u16 pfsid,
1362 : : u16 qdep, u64 addr, unsigned mask)
1363 : : {
1364 : 0 : struct qi_desc desc;
1365 : :
1366 [ # # ]: 0 : if (mask) {
1367 : 0 : addr |= (1ULL << (VTD_PAGE_SHIFT + mask - 1)) - 1;
1368 : 0 : desc.qw1 = QI_DEV_IOTLB_ADDR(addr) | QI_DEV_IOTLB_SIZE;
1369 : : } else
1370 : 0 : desc.qw1 = QI_DEV_IOTLB_ADDR(addr);
1371 : :
1372 [ # # ]: 0 : if (qdep >= QI_DEV_IOTLB_MAX_INVS)
1373 : 0 : qdep = 0;
1374 : :
1375 : 0 : desc.qw0 = QI_DEV_IOTLB_SID(sid) | QI_DEV_IOTLB_QDEP(qdep) |
1376 : 0 : QI_DIOTLB_TYPE | QI_DEV_IOTLB_PFSID(pfsid);
1377 : 0 : desc.qw2 = 0;
1378 : 0 : desc.qw3 = 0;
1379 : :
1380 : 0 : qi_submit_sync(&desc, iommu);
1381 : 0 : }
1382 : :
1383 : : /* PASID-based IOTLB invalidation */
1384 : 0 : void qi_flush_piotlb(struct intel_iommu *iommu, u16 did, u32 pasid, u64 addr,
1385 : : unsigned long npages, bool ih)
1386 : : {
1387 : 0 : struct qi_desc desc = {.qw2 = 0, .qw3 = 0};
1388 : :
1389 : : /*
1390 : : * npages == -1 means a PASID-selective invalidation, otherwise,
1391 : : * a positive value for Page-selective-within-PASID invalidation.
1392 : : * 0 is not a valid input.
1393 : : */
1394 [ # # # # ]: 0 : if (WARN_ON(!npages)) {
1395 : 0 : pr_err("Invalid input npages = %ld\n", npages);
1396 : 0 : return;
1397 : : }
1398 : :
1399 [ # # ]: 0 : if (npages == -1) {
1400 : 0 : desc.qw0 = QI_EIOTLB_PASID(pasid) |
1401 : 0 : QI_EIOTLB_DID(did) |
1402 : 0 : QI_EIOTLB_GRAN(QI_GRAN_NONG_PASID) |
1403 : : QI_EIOTLB_TYPE;
1404 : 0 : desc.qw1 = 0;
1405 : : } else {
1406 [ # # # # : 0 : int mask = ilog2(__roundup_pow_of_two(npages));
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # ]
1407 : 0 : unsigned long align = (1ULL << (VTD_PAGE_SHIFT + mask));
1408 : :
1409 [ # # # # ]: 0 : if (WARN_ON_ONCE(!ALIGN(addr, align)))
1410 : 0 : addr &= ~(align - 1);
1411 : :
1412 : 0 : desc.qw0 = QI_EIOTLB_PASID(pasid) |
1413 : 0 : QI_EIOTLB_DID(did) |
1414 : 0 : QI_EIOTLB_GRAN(QI_GRAN_PSI_PASID) |
1415 : : QI_EIOTLB_TYPE;
1416 : 0 : desc.qw1 = QI_EIOTLB_ADDR(addr) |
1417 : 0 : QI_EIOTLB_IH(ih) |
1418 : 0 : QI_EIOTLB_AM(mask);
1419 : : }
1420 : :
1421 : 0 : qi_submit_sync(&desc, iommu);
1422 : : }
1423 : :
1424 : : /*
1425 : : * Disable Queued Invalidation interface.
1426 : : */
1427 : 0 : void dmar_disable_qi(struct intel_iommu *iommu)
1428 : : {
1429 : 0 : unsigned long flags;
1430 : 0 : u32 sts;
1431 : 0 : cycles_t start_time = get_cycles();
1432 : :
1433 [ # # ]: 0 : if (!ecap_qis(iommu->ecap))
1434 : : return;
1435 : :
1436 : 0 : raw_spin_lock_irqsave(&iommu->register_lock, flags);
1437 : :
1438 : 0 : sts = readl(iommu->reg + DMAR_GSTS_REG);
1439 [ # # ]: 0 : if (!(sts & DMA_GSTS_QIES))
1440 : 0 : goto end;
1441 : :
1442 : : /*
1443 : : * Give a chance to HW to complete the pending invalidation requests.
1444 : : */
1445 [ # # ]: 0 : while ((readl(iommu->reg + DMAR_IQT_REG) !=
1446 : 0 : readl(iommu->reg + DMAR_IQH_REG)) &&
1447 [ # # ]: 0 : (DMAR_OPERATION_TIMEOUT > (get_cycles() - start_time)))
1448 : 0 : cpu_relax();
1449 : :
1450 : 0 : iommu->gcmd &= ~DMA_GCMD_QIE;
1451 : 0 : writel(iommu->gcmd, iommu->reg + DMAR_GCMD_REG);
1452 : :
1453 [ # # # # ]: 0 : IOMMU_WAIT_OP(iommu, DMAR_GSTS_REG, readl,
1454 : : !(sts & DMA_GSTS_QIES), sts);
1455 : 0 : end:
1456 : 0 : raw_spin_unlock_irqrestore(&iommu->register_lock, flags);
1457 : : }
1458 : :
1459 : : /*
1460 : : * Enable queued invalidation.
1461 : : */
1462 : 0 : static void __dmar_enable_qi(struct intel_iommu *iommu)
1463 : : {
1464 : 0 : u32 sts;
1465 : 0 : unsigned long flags;
1466 : 0 : struct q_inval *qi = iommu->qi;
1467 [ # # ]: 0 : u64 val = virt_to_phys(qi->desc);
1468 : :
1469 : 0 : qi->free_head = qi->free_tail = 0;
1470 : 0 : qi->free_cnt = QI_LENGTH;
1471 : :
1472 : : /*
1473 : : * Set DW=1 and QS=1 in IQA_REG when Scalable Mode capability
1474 : : * is present.
1475 : : */
1476 [ # # ]: 0 : if (ecap_smts(iommu->ecap))
1477 : 0 : val |= (1 << 11) | 1;
1478 : :
1479 : 0 : raw_spin_lock_irqsave(&iommu->register_lock, flags);
1480 : :
1481 : : /* write zero to the tail reg */
1482 : 0 : writel(0, iommu->reg + DMAR_IQT_REG);
1483 : :
1484 : 0 : dmar_writeq(iommu->reg + DMAR_IQA_REG, val);
1485 : :
1486 : 0 : iommu->gcmd |= DMA_GCMD_QIE;
1487 : 0 : writel(iommu->gcmd, iommu->reg + DMAR_GCMD_REG);
1488 : :
1489 : : /* Make sure hardware complete it */
1490 [ # # # # ]: 0 : IOMMU_WAIT_OP(iommu, DMAR_GSTS_REG, readl, (sts & DMA_GSTS_QIES), sts);
1491 : :
1492 : 0 : raw_spin_unlock_irqrestore(&iommu->register_lock, flags);
1493 : 0 : }
1494 : :
1495 : : /*
1496 : : * Enable Queued Invalidation interface. This is a must to support
1497 : : * interrupt-remapping. Also used by DMA-remapping, which replaces
1498 : : * register based IOTLB invalidation.
1499 : : */
1500 : 0 : int dmar_enable_qi(struct intel_iommu *iommu)
1501 : : {
1502 : 0 : struct q_inval *qi;
1503 : 0 : struct page *desc_page;
1504 : :
1505 [ # # ]: 0 : if (!ecap_qis(iommu->ecap))
1506 : : return -ENOENT;
1507 : :
1508 : : /*
1509 : : * queued invalidation is already setup and enabled.
1510 : : */
1511 [ # # ]: 0 : if (iommu->qi)
1512 : : return 0;
1513 : :
1514 : 0 : iommu->qi = kmalloc(sizeof(*qi), GFP_ATOMIC);
1515 [ # # ]: 0 : if (!iommu->qi)
1516 : : return -ENOMEM;
1517 : :
1518 : 0 : qi = iommu->qi;
1519 : :
1520 : : /*
1521 : : * Need two pages to accommodate 256 descriptors of 256 bits each
1522 : : * if the remapping hardware supports scalable mode translation.
1523 : : */
1524 : 0 : desc_page = alloc_pages_node(iommu->node, GFP_ATOMIC | __GFP_ZERO,
1525 [ # # ]: 0 : !!ecap_smts(iommu->ecap));
1526 [ # # ]: 0 : if (!desc_page) {
1527 : 0 : kfree(qi);
1528 : 0 : iommu->qi = NULL;
1529 : 0 : return -ENOMEM;
1530 : : }
1531 : :
1532 : 0 : qi->desc = page_address(desc_page);
1533 : :
1534 : 0 : qi->desc_status = kcalloc(QI_LENGTH, sizeof(int), GFP_ATOMIC);
1535 [ # # ]: 0 : if (!qi->desc_status) {
1536 : 0 : free_page((unsigned long) qi->desc);
1537 : 0 : kfree(qi);
1538 : 0 : iommu->qi = NULL;
1539 : 0 : return -ENOMEM;
1540 : : }
1541 : :
1542 : 0 : raw_spin_lock_init(&qi->q_lock);
1543 : :
1544 : 0 : __dmar_enable_qi(iommu);
1545 : :
1546 : 0 : return 0;
1547 : : }
1548 : :
1549 : : /* iommu interrupt handling. Most stuff are MSI-like. */
1550 : :
1551 : : enum faulttype {
1552 : : DMA_REMAP,
1553 : : INTR_REMAP,
1554 : : UNKNOWN,
1555 : : };
1556 : :
1557 : : static const char *dma_remap_fault_reasons[] =
1558 : : {
1559 : : "Software",
1560 : : "Present bit in root entry is clear",
1561 : : "Present bit in context entry is clear",
1562 : : "Invalid context entry",
1563 : : "Access beyond MGAW",
1564 : : "PTE Write access is not set",
1565 : : "PTE Read access is not set",
1566 : : "Next page table ptr is invalid",
1567 : : "Root table address invalid",
1568 : : "Context table ptr is invalid",
1569 : : "non-zero reserved fields in RTP",
1570 : : "non-zero reserved fields in CTP",
1571 : : "non-zero reserved fields in PTE",
1572 : : "PCE for translation request specifies blocking",
1573 : : };
1574 : :
1575 : : static const char * const dma_remap_sm_fault_reasons[] = {
1576 : : "SM: Invalid Root Table Address",
1577 : : "SM: TTM 0 for request with PASID",
1578 : : "SM: TTM 0 for page group request",
1579 : : "Unknown", "Unknown", "Unknown", "Unknown", "Unknown", /* 0x33-0x37 */
1580 : : "SM: Error attempting to access Root Entry",
1581 : : "SM: Present bit in Root Entry is clear",
1582 : : "SM: Non-zero reserved field set in Root Entry",
1583 : : "Unknown", "Unknown", "Unknown", "Unknown", "Unknown", /* 0x3B-0x3F */
1584 : : "SM: Error attempting to access Context Entry",
1585 : : "SM: Present bit in Context Entry is clear",
1586 : : "SM: Non-zero reserved field set in the Context Entry",
1587 : : "SM: Invalid Context Entry",
1588 : : "SM: DTE field in Context Entry is clear",
1589 : : "SM: PASID Enable field in Context Entry is clear",
1590 : : "SM: PASID is larger than the max in Context Entry",
1591 : : "SM: PRE field in Context-Entry is clear",
1592 : : "SM: RID_PASID field error in Context-Entry",
1593 : : "Unknown", "Unknown", "Unknown", "Unknown", "Unknown", "Unknown", "Unknown", /* 0x49-0x4F */
1594 : : "SM: Error attempting to access the PASID Directory Entry",
1595 : : "SM: Present bit in Directory Entry is clear",
1596 : : "SM: Non-zero reserved field set in PASID Directory Entry",
1597 : : "Unknown", "Unknown", "Unknown", "Unknown", "Unknown", /* 0x53-0x57 */
1598 : : "SM: Error attempting to access PASID Table Entry",
1599 : : "SM: Present bit in PASID Table Entry is clear",
1600 : : "SM: Non-zero reserved field set in PASID Table Entry",
1601 : : "SM: Invalid Scalable-Mode PASID Table Entry",
1602 : : "SM: ERE field is clear in PASID Table Entry",
1603 : : "SM: SRE field is clear in PASID Table Entry",
1604 : : "Unknown", "Unknown",/* 0x5E-0x5F */
1605 : : "Unknown", "Unknown", "Unknown", "Unknown", "Unknown", "Unknown", "Unknown", "Unknown", /* 0x60-0x67 */
1606 : : "Unknown", "Unknown", "Unknown", "Unknown", "Unknown", "Unknown", "Unknown", "Unknown", /* 0x68-0x6F */
1607 : : "SM: Error attempting to access first-level paging entry",
1608 : : "SM: Present bit in first-level paging entry is clear",
1609 : : "SM: Non-zero reserved field set in first-level paging entry",
1610 : : "SM: Error attempting to access FL-PML4 entry",
1611 : : "SM: First-level entry address beyond MGAW in Nested translation",
1612 : : "SM: Read permission error in FL-PML4 entry in Nested translation",
1613 : : "SM: Read permission error in first-level paging entry in Nested translation",
1614 : : "SM: Write permission error in first-level paging entry in Nested translation",
1615 : : "SM: Error attempting to access second-level paging entry",
1616 : : "SM: Read/Write permission error in second-level paging entry",
1617 : : "SM: Non-zero reserved field set in second-level paging entry",
1618 : : "SM: Invalid second-level page table pointer",
1619 : : "SM: A/D bit update needed in second-level entry when set up in no snoop",
1620 : : "Unknown", "Unknown", "Unknown", /* 0x7D-0x7F */
1621 : : "SM: Address in first-level translation is not canonical",
1622 : : "SM: U/S set 0 for first-level translation with user privilege",
1623 : : "SM: No execute permission for request with PASID and ER=1",
1624 : : "SM: Address beyond the DMA hardware max",
1625 : : "SM: Second-level entry address beyond the max",
1626 : : "SM: No write permission for Write/AtomicOp request",
1627 : : "SM: No read permission for Read/AtomicOp request",
1628 : : "SM: Invalid address-interrupt address",
1629 : : "Unknown", "Unknown", "Unknown", "Unknown", "Unknown", "Unknown", "Unknown", "Unknown", /* 0x88-0x8F */
1630 : : "SM: A/D bit update needed in first-level entry when set up in no snoop",
1631 : : };
1632 : :
1633 : : static const char *irq_remap_fault_reasons[] =
1634 : : {
1635 : : "Detected reserved fields in the decoded interrupt-remapped request",
1636 : : "Interrupt index exceeded the interrupt-remapping table size",
1637 : : "Present field in the IRTE entry is clear",
1638 : : "Error accessing interrupt-remapping table pointed by IRTA_REG",
1639 : : "Detected reserved fields in the IRTE entry",
1640 : : "Blocked a compatibility format interrupt request",
1641 : : "Blocked an interrupt request due to source-id verification failure",
1642 : : };
1643 : :
1644 : 0 : static const char *dmar_get_fault_reason(u8 fault_reason, int *fault_type)
1645 : : {
1646 [ # # ]: 0 : if (fault_reason >= 0x20 && (fault_reason - 0x20 <
1647 : : ARRAY_SIZE(irq_remap_fault_reasons))) {
1648 : 0 : *fault_type = INTR_REMAP;
1649 : 0 : return irq_remap_fault_reasons[fault_reason - 0x20];
1650 [ # # # # ]: 0 : } else if (fault_reason >= 0x30 && (fault_reason - 0x30 <
1651 : : ARRAY_SIZE(dma_remap_sm_fault_reasons))) {
1652 : 0 : *fault_type = DMA_REMAP;
1653 : 0 : return dma_remap_sm_fault_reasons[fault_reason - 0x30];
1654 [ # # ]: 0 : } else if (fault_reason < ARRAY_SIZE(dma_remap_fault_reasons)) {
1655 : 0 : *fault_type = DMA_REMAP;
1656 : 0 : return dma_remap_fault_reasons[fault_reason];
1657 : : } else {
1658 : : *fault_type = UNKNOWN;
1659 : : return "Unknown";
1660 : : }
1661 : : }
1662 : :
1663 : :
1664 : 0 : static inline int dmar_msi_reg(struct intel_iommu *iommu, int irq)
1665 : : {
1666 : 0 : if (iommu->irq == irq)
1667 : : return DMAR_FECTL_REG;
1668 [ # # # # : 0 : else if (iommu->pr_irq == irq)
# # # # ]
1669 : : return DMAR_PECTL_REG;
1670 : : else
1671 : 0 : BUG();
1672 : : }
1673 : :
1674 : 0 : void dmar_msi_unmask(struct irq_data *data)
1675 : : {
1676 [ # # ]: 0 : struct intel_iommu *iommu = irq_data_get_irq_handler_data(data);
1677 [ # # ]: 0 : int reg = dmar_msi_reg(iommu, data->irq);
1678 : 0 : unsigned long flag;
1679 : :
1680 : : /* unmask it */
1681 : 0 : raw_spin_lock_irqsave(&iommu->register_lock, flag);
1682 : 0 : writel(0, iommu->reg + reg);
1683 : : /* Read a reg to force flush the post write */
1684 : 0 : readl(iommu->reg + reg);
1685 : 0 : raw_spin_unlock_irqrestore(&iommu->register_lock, flag);
1686 : 0 : }
1687 : :
1688 : 0 : void dmar_msi_mask(struct irq_data *data)
1689 : : {
1690 [ # # ]: 0 : struct intel_iommu *iommu = irq_data_get_irq_handler_data(data);
1691 [ # # ]: 0 : int reg = dmar_msi_reg(iommu, data->irq);
1692 : 0 : unsigned long flag;
1693 : :
1694 : : /* mask it */
1695 : 0 : raw_spin_lock_irqsave(&iommu->register_lock, flag);
1696 : 0 : writel(DMA_FECTL_IM, iommu->reg + reg);
1697 : : /* Read a reg to force flush the post write */
1698 : 0 : readl(iommu->reg + reg);
1699 : 0 : raw_spin_unlock_irqrestore(&iommu->register_lock, flag);
1700 : 0 : }
1701 : :
1702 : 0 : void dmar_msi_write(int irq, struct msi_msg *msg)
1703 : : {
1704 : 0 : struct intel_iommu *iommu = irq_get_handler_data(irq);
1705 [ # # ]: 0 : int reg = dmar_msi_reg(iommu, irq);
1706 : 0 : unsigned long flag;
1707 : :
1708 : 0 : raw_spin_lock_irqsave(&iommu->register_lock, flag);
1709 : 0 : writel(msg->data, iommu->reg + reg + 4);
1710 : 0 : writel(msg->address_lo, iommu->reg + reg + 8);
1711 : 0 : writel(msg->address_hi, iommu->reg + reg + 12);
1712 : 0 : raw_spin_unlock_irqrestore(&iommu->register_lock, flag);
1713 : 0 : }
1714 : :
1715 : 0 : void dmar_msi_read(int irq, struct msi_msg *msg)
1716 : : {
1717 : 0 : struct intel_iommu *iommu = irq_get_handler_data(irq);
1718 [ # # ]: 0 : int reg = dmar_msi_reg(iommu, irq);
1719 : 0 : unsigned long flag;
1720 : :
1721 : 0 : raw_spin_lock_irqsave(&iommu->register_lock, flag);
1722 : 0 : msg->data = readl(iommu->reg + reg + 4);
1723 : 0 : msg->address_lo = readl(iommu->reg + reg + 8);
1724 : 0 : msg->address_hi = readl(iommu->reg + reg + 12);
1725 : 0 : raw_spin_unlock_irqrestore(&iommu->register_lock, flag);
1726 : 0 : }
1727 : :
1728 : 0 : static int dmar_fault_do_one(struct intel_iommu *iommu, int type,
1729 : : u8 fault_reason, int pasid, u16 source_id,
1730 : : unsigned long long addr)
1731 : : {
1732 : 0 : const char *reason;
1733 : 0 : int fault_type;
1734 : :
1735 [ # # ]: 0 : reason = dmar_get_fault_reason(fault_reason, &fault_type);
1736 : :
1737 : 0 : if (fault_type == INTR_REMAP)
1738 : 0 : pr_err("[INTR-REMAP] Request device [%02x:%02x.%d] fault index %llx [fault reason %02d] %s\n",
1739 : : source_id >> 8, PCI_SLOT(source_id & 0xFF),
1740 : : PCI_FUNC(source_id & 0xFF), addr >> 48,
1741 : : fault_reason, reason);
1742 : : else
1743 [ # # ]: 0 : pr_err("[%s] Request device [%02x:%02x.%d] PASID %x fault addr %llx [fault reason %02d] %s\n",
1744 : : type ? "DMA Read" : "DMA Write",
1745 : : source_id >> 8, PCI_SLOT(source_id & 0xFF),
1746 : : PCI_FUNC(source_id & 0xFF), pasid, addr,
1747 : : fault_reason, reason);
1748 : 0 : return 0;
1749 : : }
1750 : :
1751 : : #define PRIMARY_FAULT_REG_LEN (16)
1752 : 0 : irqreturn_t dmar_fault(int irq, void *dev_id)
1753 : : {
1754 : 0 : struct intel_iommu *iommu = dev_id;
1755 : 0 : int reg, fault_index;
1756 : 0 : u32 fault_status;
1757 : 0 : unsigned long flag;
1758 : 0 : static DEFINE_RATELIMIT_STATE(rs,
1759 : : DEFAULT_RATELIMIT_INTERVAL,
1760 : : DEFAULT_RATELIMIT_BURST);
1761 : :
1762 : 0 : raw_spin_lock_irqsave(&iommu->register_lock, flag);
1763 : 0 : fault_status = readl(iommu->reg + DMAR_FSTS_REG);
1764 [ # # # # ]: 0 : if (fault_status && __ratelimit(&rs))
1765 : 0 : pr_err("DRHD: handling fault status reg %x\n", fault_status);
1766 : :
1767 : : /* TBD: ignore advanced fault log currently */
1768 [ # # ]: 0 : if (!(fault_status & DMA_FSTS_PPF))
1769 : 0 : goto unlock_exit;
1770 : :
1771 : 0 : fault_index = dma_fsts_fault_record_index(fault_status);
1772 : 0 : reg = cap_fault_reg_offset(iommu->cap);
1773 : 0 : while (1) {
1774 : : /* Disable printing, simply clear the fault when ratelimited */
1775 : 0 : bool ratelimited = !__ratelimit(&rs);
1776 : 0 : u8 fault_reason;
1777 : 0 : u16 source_id;
1778 : 0 : u64 guest_addr;
1779 : 0 : int type, pasid;
1780 : 0 : u32 data;
1781 : 0 : bool pasid_present;
1782 : :
1783 : : /* highest 32 bits */
1784 : 0 : data = readl(iommu->reg + reg +
1785 : 0 : fault_index * PRIMARY_FAULT_REG_LEN + 12);
1786 [ # # ]: 0 : if (!(data & DMA_FRCD_F))
1787 : : break;
1788 : :
1789 [ # # ]: 0 : if (!ratelimited) {
1790 : 0 : fault_reason = dma_frcd_fault_reason(data);
1791 : 0 : type = dma_frcd_type(data);
1792 : :
1793 : 0 : pasid = dma_frcd_pasid_value(data);
1794 : 0 : data = readl(iommu->reg + reg +
1795 : 0 : fault_index * PRIMARY_FAULT_REG_LEN + 8);
1796 : 0 : source_id = dma_frcd_source_id(data);
1797 : :
1798 : 0 : pasid_present = dma_frcd_pasid_present(data);
1799 : 0 : guest_addr = dmar_readq(iommu->reg + reg +
1800 : : fault_index * PRIMARY_FAULT_REG_LEN);
1801 : 0 : guest_addr = dma_frcd_page_addr(guest_addr);
1802 : : }
1803 : :
1804 : : /* clear the fault */
1805 : 0 : writel(DMA_FRCD_F, iommu->reg + reg +
1806 : 0 : fault_index * PRIMARY_FAULT_REG_LEN + 12);
1807 : :
1808 : 0 : raw_spin_unlock_irqrestore(&iommu->register_lock, flag);
1809 : :
1810 [ # # ]: 0 : if (!ratelimited)
1811 : : /* Using pasid -1 if pasid is not present */
1812 [ # # ]: 0 : dmar_fault_do_one(iommu, type, fault_reason,
1813 : : pasid_present ? pasid : -1,
1814 : : source_id, guest_addr);
1815 : :
1816 : 0 : fault_index++;
1817 [ # # ]: 0 : if (fault_index >= cap_num_fault_regs(iommu->cap))
1818 : 0 : fault_index = 0;
1819 : 0 : raw_spin_lock_irqsave(&iommu->register_lock, flag);
1820 : : }
1821 : :
1822 : 0 : writel(DMA_FSTS_PFO | DMA_FSTS_PPF | DMA_FSTS_PRO,
1823 : 0 : iommu->reg + DMAR_FSTS_REG);
1824 : :
1825 : 0 : unlock_exit:
1826 : 0 : raw_spin_unlock_irqrestore(&iommu->register_lock, flag);
1827 : 0 : return IRQ_HANDLED;
1828 : : }
1829 : :
1830 : 0 : int dmar_set_interrupt(struct intel_iommu *iommu)
1831 : : {
1832 : 0 : int irq, ret;
1833 : :
1834 : : /*
1835 : : * Check if the fault interrupt is already initialized.
1836 : : */
1837 [ # # ]: 0 : if (iommu->irq)
1838 : : return 0;
1839 : :
1840 : 0 : irq = dmar_alloc_hwirq(iommu->seq_id, iommu->node, iommu);
1841 [ # # ]: 0 : if (irq > 0) {
1842 : 0 : iommu->irq = irq;
1843 : : } else {
1844 : 0 : pr_err("No free IRQ vectors\n");
1845 : 0 : return -EINVAL;
1846 : : }
1847 : :
1848 : 0 : ret = request_irq(irq, dmar_fault, IRQF_NO_THREAD, iommu->name, iommu);
1849 [ # # ]: 0 : if (ret)
1850 : 0 : pr_err("Can't request irq\n");
1851 : : return ret;
1852 : : }
1853 : :
1854 : 0 : int __init enable_drhd_fault_handling(void)
1855 : : {
1856 : 0 : struct dmar_drhd_unit *drhd;
1857 : 0 : struct intel_iommu *iommu;
1858 : :
1859 : : /*
1860 : : * Enable fault control interrupt.
1861 : : */
1862 [ # # ]: 0 : for_each_iommu(iommu, drhd) {
1863 : 0 : u32 fault_status;
1864 : 0 : int ret = dmar_set_interrupt(iommu);
1865 : :
1866 [ # # ]: 0 : if (ret) {
1867 : 0 : pr_err("DRHD %Lx: failed to enable fault, interrupt, ret %d\n",
1868 : : (unsigned long long)drhd->reg_base_addr, ret);
1869 : 0 : return -1;
1870 : : }
1871 : :
1872 : : /*
1873 : : * Clear any previous faults.
1874 : : */
1875 : 0 : dmar_fault(iommu->irq, iommu);
1876 : 0 : fault_status = readl(iommu->reg + DMAR_FSTS_REG);
1877 : 0 : writel(fault_status, iommu->reg + DMAR_FSTS_REG);
1878 : : }
1879 : :
1880 : : return 0;
1881 : : }
1882 : :
1883 : : /*
1884 : : * Re-enable Queued Invalidation interface.
1885 : : */
1886 : 0 : int dmar_reenable_qi(struct intel_iommu *iommu)
1887 : : {
1888 [ # # ]: 0 : if (!ecap_qis(iommu->ecap))
1889 : : return -ENOENT;
1890 : :
1891 [ # # ]: 0 : if (!iommu->qi)
1892 : : return -ENOENT;
1893 : :
1894 : : /*
1895 : : * First disable queued invalidation.
1896 : : */
1897 : 0 : dmar_disable_qi(iommu);
1898 : : /*
1899 : : * Then enable queued invalidation again. Since there is no pending
1900 : : * invalidation requests now, it's safe to re-enable queued
1901 : : * invalidation.
1902 : : */
1903 : 0 : __dmar_enable_qi(iommu);
1904 : :
1905 : 0 : return 0;
1906 : : }
1907 : :
1908 : : /*
1909 : : * Check interrupt remapping support in DMAR table description.
1910 : : */
1911 : 0 : int __init dmar_ir_support(void)
1912 : : {
1913 : 0 : struct acpi_table_dmar *dmar;
1914 : 0 : dmar = (struct acpi_table_dmar *)dmar_tbl;
1915 [ # # ]: 0 : if (!dmar)
1916 : : return 0;
1917 : 0 : return dmar->flags & 0x1;
1918 : : }
1919 : :
1920 : : /* Check whether DMAR units are in use */
1921 : 30 : static inline bool dmar_in_use(void)
1922 : : {
1923 : 30 : return irq_remapping_enabled || intel_iommu_enabled;
1924 : : }
1925 : :
1926 : 30 : static int __init dmar_free_unused_resources(void)
1927 : : {
1928 : 30 : struct dmar_drhd_unit *dmaru, *dmaru_n;
1929 : :
1930 [ + - ]: 30 : if (dmar_in_use())
1931 : : return 0;
1932 : :
1933 [ - + - - ]: 30 : if (dmar_dev_scope_status != 1 && !list_empty(&dmar_drhd_units))
1934 : 0 : bus_unregister_notifier(&pci_bus_type, &dmar_pci_bus_nb);
1935 : :
1936 : 30 : down_write(&dmar_global_lock);
1937 [ - + ]: 30 : list_for_each_entry_safe(dmaru, dmaru_n, &dmar_drhd_units, list) {
1938 : 0 : list_del(&dmaru->list);
1939 : 0 : dmar_free_drhd(dmaru);
1940 : : }
1941 : 30 : up_write(&dmar_global_lock);
1942 : :
1943 : 30 : return 0;
1944 : : }
1945 : :
1946 : : late_initcall(dmar_free_unused_resources);
1947 : : IOMMU_INIT_POST(detect_intel_iommu);
1948 : :
1949 : : /*
1950 : : * DMAR Hotplug Support
1951 : : * For more details, please refer to Intel(R) Virtualization Technology
1952 : : * for Directed-IO Architecture Specifiction, Rev 2.2, Section 8.8
1953 : : * "Remapping Hardware Unit Hot Plug".
1954 : : */
1955 : : static guid_t dmar_hp_guid =
1956 : : GUID_INIT(0xD8C1A3A6, 0xBE9B, 0x4C9B,
1957 : : 0x91, 0xBF, 0xC3, 0xCB, 0x81, 0xFC, 0x5D, 0xAF);
1958 : :
1959 : : /*
1960 : : * Currently there's only one revision and BIOS will not check the revision id,
1961 : : * so use 0 for safety.
1962 : : */
1963 : : #define DMAR_DSM_REV_ID 0
1964 : : #define DMAR_DSM_FUNC_DRHD 1
1965 : : #define DMAR_DSM_FUNC_ATSR 2
1966 : : #define DMAR_DSM_FUNC_RHSA 3
1967 : :
1968 : 0 : static inline bool dmar_detect_dsm(acpi_handle handle, int func)
1969 : : {
1970 : 0 : return acpi_check_dsm(handle, &dmar_hp_guid, DMAR_DSM_REV_ID, 1 << func);
1971 : : }
1972 : :
1973 : 0 : static int dmar_walk_dsm_resource(acpi_handle handle, int func,
1974 : : dmar_res_handler_t handler, void *arg)
1975 : : {
1976 : 0 : int ret = -ENODEV;
1977 : 0 : union acpi_object *obj;
1978 : 0 : struct acpi_dmar_header *start;
1979 : 0 : struct dmar_res_callback callback;
1980 : 0 : static int res_type[] = {
1981 : : [DMAR_DSM_FUNC_DRHD] = ACPI_DMAR_TYPE_HARDWARE_UNIT,
1982 : : [DMAR_DSM_FUNC_ATSR] = ACPI_DMAR_TYPE_ROOT_ATS,
1983 : : [DMAR_DSM_FUNC_RHSA] = ACPI_DMAR_TYPE_HARDWARE_AFFINITY,
1984 : : };
1985 : :
1986 [ # # ]: 0 : if (!dmar_detect_dsm(handle, func))
1987 : : return 0;
1988 : :
1989 : 0 : obj = acpi_evaluate_dsm_typed(handle, &dmar_hp_guid, DMAR_DSM_REV_ID,
1990 : : func, NULL, ACPI_TYPE_BUFFER);
1991 [ # # ]: 0 : if (!obj)
1992 : : return -ENODEV;
1993 : :
1994 : 0 : memset(&callback, 0, sizeof(callback));
1995 : 0 : callback.cb[res_type[func]] = handler;
1996 : 0 : callback.arg[res_type[func]] = arg;
1997 : 0 : start = (struct acpi_dmar_header *)obj->buffer.pointer;
1998 : 0 : ret = dmar_walk_remapping_entries(start, obj->buffer.length, &callback);
1999 : :
2000 : 0 : ACPI_FREE(obj);
2001 : :
2002 : 0 : return ret;
2003 : : }
2004 : :
2005 : 0 : static int dmar_hp_add_drhd(struct acpi_dmar_header *header, void *arg)
2006 : : {
2007 : 0 : int ret;
2008 : 0 : struct dmar_drhd_unit *dmaru;
2009 : :
2010 : 0 : dmaru = dmar_find_dmaru((struct acpi_dmar_hardware_unit *)header);
2011 [ # # ]: 0 : if (!dmaru)
2012 : : return -ENODEV;
2013 : :
2014 : 0 : ret = dmar_ir_hotplug(dmaru, true);
2015 : 0 : if (ret == 0)
2016 : 0 : ret = dmar_iommu_hotplug(dmaru, true);
2017 : :
2018 : 0 : return ret;
2019 : : }
2020 : :
2021 : 0 : static int dmar_hp_remove_drhd(struct acpi_dmar_header *header, void *arg)
2022 : : {
2023 : 0 : int i, ret;
2024 : 0 : struct device *dev;
2025 : 0 : struct dmar_drhd_unit *dmaru;
2026 : :
2027 : 0 : dmaru = dmar_find_dmaru((struct acpi_dmar_hardware_unit *)header);
2028 [ # # ]: 0 : if (!dmaru)
2029 : : return 0;
2030 : :
2031 : : /*
2032 : : * All PCI devices managed by this unit should have been destroyed.
2033 : : */
2034 [ # # # # : 0 : if (!dmaru->include_all && dmaru->devices && dmaru->devices_cnt) {
# # ]
2035 [ # # # # : 0 : for_each_active_dev_scope(dmaru->devices,
# # ]
2036 : : dmaru->devices_cnt, i, dev)
2037 : : return -EBUSY;
2038 : : }
2039 : :
2040 : 0 : ret = dmar_ir_hotplug(dmaru, false);
2041 : 0 : if (ret == 0)
2042 : 0 : ret = dmar_iommu_hotplug(dmaru, false);
2043 : :
2044 : 0 : return ret;
2045 : : }
2046 : :
2047 : 0 : static int dmar_hp_release_drhd(struct acpi_dmar_header *header, void *arg)
2048 : : {
2049 : 0 : struct dmar_drhd_unit *dmaru;
2050 : :
2051 : 0 : dmaru = dmar_find_dmaru((struct acpi_dmar_hardware_unit *)header);
2052 [ # # ]: 0 : if (dmaru) {
2053 : 0 : list_del_rcu(&dmaru->list);
2054 : 0 : synchronize_rcu();
2055 : 0 : dmar_free_drhd(dmaru);
2056 : : }
2057 : :
2058 : 0 : return 0;
2059 : : }
2060 : :
2061 : 0 : static int dmar_hotplug_insert(acpi_handle handle)
2062 : : {
2063 : 0 : int ret;
2064 : 0 : int drhd_count = 0;
2065 : :
2066 : 0 : ret = dmar_walk_dsm_resource(handle, DMAR_DSM_FUNC_DRHD,
2067 : : &dmar_validate_one_drhd, (void *)1);
2068 [ # # ]: 0 : if (ret)
2069 : 0 : goto out;
2070 : :
2071 : 0 : ret = dmar_walk_dsm_resource(handle, DMAR_DSM_FUNC_DRHD,
2072 : : &dmar_parse_one_drhd, (void *)&drhd_count);
2073 [ # # # # ]: 0 : if (ret == 0 && drhd_count == 0) {
2074 : 0 : pr_warn(FW_BUG "No DRHD structures in buffer returned by _DSM method\n");
2075 : 0 : goto out;
2076 [ # # ]: 0 : } else if (ret) {
2077 : 0 : goto release_drhd;
2078 : : }
2079 : :
2080 : 0 : ret = dmar_walk_dsm_resource(handle, DMAR_DSM_FUNC_RHSA,
2081 : : &dmar_parse_one_rhsa, NULL);
2082 [ # # ]: 0 : if (ret)
2083 : 0 : goto release_drhd;
2084 : :
2085 : 0 : ret = dmar_walk_dsm_resource(handle, DMAR_DSM_FUNC_ATSR,
2086 : : &dmar_parse_one_atsr, NULL);
2087 [ # # ]: 0 : if (ret)
2088 : 0 : goto release_atsr;
2089 : :
2090 : 0 : ret = dmar_walk_dsm_resource(handle, DMAR_DSM_FUNC_DRHD,
2091 : : &dmar_hp_add_drhd, NULL);
2092 [ # # ]: 0 : if (!ret)
2093 : : return 0;
2094 : :
2095 : 0 : dmar_walk_dsm_resource(handle, DMAR_DSM_FUNC_DRHD,
2096 : : &dmar_hp_remove_drhd, NULL);
2097 : 0 : release_atsr:
2098 : 0 : dmar_walk_dsm_resource(handle, DMAR_DSM_FUNC_ATSR,
2099 : : &dmar_release_one_atsr, NULL);
2100 : 0 : release_drhd:
2101 : 0 : dmar_walk_dsm_resource(handle, DMAR_DSM_FUNC_DRHD,
2102 : : &dmar_hp_release_drhd, NULL);
2103 : : out:
2104 : : return ret;
2105 : : }
2106 : :
2107 : 0 : static int dmar_hotplug_remove(acpi_handle handle)
2108 : : {
2109 : 0 : int ret;
2110 : :
2111 : 0 : ret = dmar_walk_dsm_resource(handle, DMAR_DSM_FUNC_ATSR,
2112 : : &dmar_check_one_atsr, NULL);
2113 [ # # ]: 0 : if (ret)
2114 : : return ret;
2115 : :
2116 : 0 : ret = dmar_walk_dsm_resource(handle, DMAR_DSM_FUNC_DRHD,
2117 : : &dmar_hp_remove_drhd, NULL);
2118 [ # # ]: 0 : if (ret == 0) {
2119 [ # # ]: 0 : WARN_ON(dmar_walk_dsm_resource(handle, DMAR_DSM_FUNC_ATSR,
2120 : : &dmar_release_one_atsr, NULL));
2121 [ # # ]: 0 : WARN_ON(dmar_walk_dsm_resource(handle, DMAR_DSM_FUNC_DRHD,
2122 : : &dmar_hp_release_drhd, NULL));
2123 : : } else {
2124 : 0 : dmar_walk_dsm_resource(handle, DMAR_DSM_FUNC_DRHD,
2125 : : &dmar_hp_add_drhd, NULL);
2126 : : }
2127 : :
2128 : : return ret;
2129 : : }
2130 : :
2131 : 0 : static acpi_status dmar_get_dsm_handle(acpi_handle handle, u32 lvl,
2132 : : void *context, void **retval)
2133 : : {
2134 : 0 : acpi_handle *phdl = retval;
2135 : :
2136 [ # # ]: 0 : if (dmar_detect_dsm(handle, DMAR_DSM_FUNC_DRHD)) {
2137 : 0 : *phdl = handle;
2138 : 0 : return AE_CTRL_TERMINATE;
2139 : : }
2140 : :
2141 : : return AE_OK;
2142 : : }
2143 : :
2144 : 0 : static int dmar_device_hotplug(acpi_handle handle, bool insert)
2145 : : {
2146 : 0 : int ret;
2147 : 0 : acpi_handle tmp = NULL;
2148 : 0 : acpi_status status;
2149 : :
2150 [ # # ]: 0 : if (!dmar_in_use())
2151 : : return 0;
2152 : :
2153 [ # # ]: 0 : if (dmar_detect_dsm(handle, DMAR_DSM_FUNC_DRHD)) {
2154 : 0 : tmp = handle;
2155 : : } else {
2156 : 0 : status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle,
2157 : : ACPI_UINT32_MAX,
2158 : : dmar_get_dsm_handle,
2159 : : NULL, NULL, &tmp);
2160 [ # # ]: 0 : if (ACPI_FAILURE(status)) {
2161 : 0 : pr_warn("Failed to locate _DSM method.\n");
2162 : 0 : return -ENXIO;
2163 : : }
2164 : : }
2165 [ # # ]: 0 : if (tmp == NULL)
2166 : : return 0;
2167 : :
2168 : 0 : down_write(&dmar_global_lock);
2169 [ # # ]: 0 : if (insert)
2170 : 0 : ret = dmar_hotplug_insert(tmp);
2171 : : else
2172 : 0 : ret = dmar_hotplug_remove(tmp);
2173 : 0 : up_write(&dmar_global_lock);
2174 : :
2175 : 0 : return ret;
2176 : : }
2177 : :
2178 : 0 : int dmar_device_add(acpi_handle handle)
2179 : : {
2180 : 0 : return dmar_device_hotplug(handle, true);
2181 : : }
2182 : :
2183 : 0 : int dmar_device_remove(acpi_handle handle)
2184 : : {
2185 : 0 : return dmar_device_hotplug(handle, false);
2186 : : }
2187 : :
2188 : : /*
2189 : : * dmar_platform_optin - Is %DMA_CTRL_PLATFORM_OPT_IN_FLAG set in DMAR table
2190 : : *
2191 : : * Returns true if the platform has %DMA_CTRL_PLATFORM_OPT_IN_FLAG set in
2192 : : * the ACPI DMAR table. This means that the platform boot firmware has made
2193 : : * sure no device can issue DMA outside of RMRR regions.
2194 : : */
2195 : 0 : bool dmar_platform_optin(void)
2196 : : {
2197 : 0 : struct acpi_table_dmar *dmar;
2198 : 0 : acpi_status status;
2199 : 0 : bool ret;
2200 : :
2201 : 0 : status = acpi_get_table(ACPI_SIG_DMAR, 0,
2202 : : (struct acpi_table_header **)&dmar);
2203 [ # # ]: 0 : if (ACPI_FAILURE(status))
2204 : : return false;
2205 : :
2206 : 0 : ret = !!(dmar->flags & DMAR_PLATFORM_OPT_IN);
2207 : 0 : acpi_put_table((struct acpi_table_header *)dmar);
2208 : :
2209 : 0 : return ret;
2210 : : }
2211 : : EXPORT_SYMBOL_GPL(dmar_platform_optin);
|
