2 * Copyright (c) 2006, Intel Corporation.
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms and conditions of the GNU General Public License,
6 * version 2, as published by the Free Software Foundation.
8 * This program is distributed in the hope it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * You should have received a copy of the GNU General Public License along with
14 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
15 * Place - Suite 330, Boston, MA 02111-1307 USA.
17 * Copyright (C) 2006-2008 Intel Corporation
18 * Author: Ashok Raj <ashok.raj@intel.com>
19 * Author: Shaohua Li <shaohua.li@intel.com>
20 * Author: Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com>
22 * This file implements early detection/parsing of Remapping Devices
23 * reported to OS through BIOS via DMA remapping reporting (DMAR) ACPI
26 * These routines are used by both DMA-remapping and Interrupt-remapping
29 #include <linux/pci.h>
30 #include <linux/dmar.h>
32 #include "intel-iommu.h"
35 #define PREFIX "DMAR:"
37 /* No locks are needed as DMA remapping hardware unit
38 * list is constructed at boot time and hotplug of
39 * these units are not supported by the architecture.
41 LIST_HEAD(dmar_drhd_units);
43 static struct acpi_table_header * __initdata dmar_tbl;
45 static void __init dmar_register_drhd_unit(struct dmar_drhd_unit *drhd)
48 * add INCLUDE_ALL at the tail, so scan the list will find it at
51 if (drhd->include_all)
52 list_add_tail(&drhd->list, &dmar_drhd_units);
54 list_add(&drhd->list, &dmar_drhd_units);
57 static int __init dmar_parse_one_dev_scope(struct acpi_dmar_device_scope *scope,
58 struct pci_dev **dev, u16 segment)
61 struct pci_dev *pdev = NULL;
62 struct acpi_dmar_pci_path *path;
65 bus = pci_find_bus(segment, scope->bus);
66 path = (struct acpi_dmar_pci_path *)(scope + 1);
67 count = (scope->length - sizeof(struct acpi_dmar_device_scope))
68 / sizeof(struct acpi_dmar_pci_path);
74 * Some BIOSes list non-exist devices in DMAR table, just
79 PREFIX "Device scope bus [%d] not found\n",
83 pdev = pci_get_slot(bus, PCI_DEVFN(path->dev, path->fn));
85 printk(KERN_WARNING PREFIX
86 "Device scope device [%04x:%02x:%02x.%02x] not found\n",
87 segment, bus->number, path->dev, path->fn);
92 bus = pdev->subordinate;
95 printk(KERN_WARNING PREFIX
96 "Device scope device [%04x:%02x:%02x.%02x] not found\n",
97 segment, scope->bus, path->dev, path->fn);
101 if ((scope->entry_type == ACPI_DMAR_SCOPE_TYPE_ENDPOINT && \
102 pdev->subordinate) || (scope->entry_type == \
103 ACPI_DMAR_SCOPE_TYPE_BRIDGE && !pdev->subordinate)) {
105 printk(KERN_WARNING PREFIX
106 "Device scope type does not match for %s\n",
114 static int __init dmar_parse_dev_scope(void *start, void *end, int *cnt,
115 struct pci_dev ***devices, u16 segment)
117 struct acpi_dmar_device_scope *scope;
123 while (start < end) {
125 if (scope->entry_type == ACPI_DMAR_SCOPE_TYPE_ENDPOINT ||
126 scope->entry_type == ACPI_DMAR_SCOPE_TYPE_BRIDGE)
129 printk(KERN_WARNING PREFIX
130 "Unsupported device scope\n");
131 start += scope->length;
136 *devices = kcalloc(*cnt, sizeof(struct pci_dev *), GFP_KERNEL);
142 while (start < end) {
144 if (scope->entry_type == ACPI_DMAR_SCOPE_TYPE_ENDPOINT ||
145 scope->entry_type == ACPI_DMAR_SCOPE_TYPE_BRIDGE) {
146 ret = dmar_parse_one_dev_scope(scope,
147 &(*devices)[index], segment);
154 start += scope->length;
161 * dmar_parse_one_drhd - parses exactly one DMA remapping hardware definition
162 * structure which uniquely represent one DMA remapping hardware unit
163 * present in the platform
166 dmar_parse_one_drhd(struct acpi_dmar_header *header)
168 struct acpi_dmar_hardware_unit *drhd;
169 struct dmar_drhd_unit *dmaru;
172 dmaru = kzalloc(sizeof(*dmaru), GFP_KERNEL);
177 drhd = (struct acpi_dmar_hardware_unit *)header;
178 dmaru->reg_base_addr = drhd->address;
179 dmaru->include_all = drhd->flags & 0x1; /* BIT0: INCLUDE_ALL */
181 ret = alloc_iommu(dmaru);
186 dmar_register_drhd_unit(dmaru);
191 dmar_parse_dev(struct dmar_drhd_unit *dmaru)
193 struct acpi_dmar_hardware_unit *drhd;
194 static int include_all;
197 drhd = (struct acpi_dmar_hardware_unit *) dmaru->hdr;
199 if (!dmaru->include_all)
200 ret = dmar_parse_dev_scope((void *)(drhd + 1),
201 ((void *)drhd) + drhd->header.length,
202 &dmaru->devices_cnt, &dmaru->devices,
205 /* Only allow one INCLUDE_ALL */
207 printk(KERN_WARNING PREFIX "Only one INCLUDE_ALL "
208 "device scope is allowed\n");
214 if (ret || (dmaru->devices_cnt == 0 && !dmaru->include_all)) {
215 list_del(&dmaru->list);
222 LIST_HEAD(dmar_rmrr_units);
224 static void __init dmar_register_rmrr_unit(struct dmar_rmrr_unit *rmrr)
226 list_add(&rmrr->list, &dmar_rmrr_units);
231 dmar_parse_one_rmrr(struct acpi_dmar_header *header)
233 struct acpi_dmar_reserved_memory *rmrr;
234 struct dmar_rmrr_unit *rmrru;
236 rmrru = kzalloc(sizeof(*rmrru), GFP_KERNEL);
241 rmrr = (struct acpi_dmar_reserved_memory *)header;
242 rmrru->base_address = rmrr->base_address;
243 rmrru->end_address = rmrr->end_address;
245 dmar_register_rmrr_unit(rmrru);
250 rmrr_parse_dev(struct dmar_rmrr_unit *rmrru)
252 struct acpi_dmar_reserved_memory *rmrr;
255 rmrr = (struct acpi_dmar_reserved_memory *) rmrru->hdr;
256 ret = dmar_parse_dev_scope((void *)(rmrr + 1),
257 ((void *)rmrr) + rmrr->header.length,
258 &rmrru->devices_cnt, &rmrru->devices, rmrr->segment);
260 if (ret || (rmrru->devices_cnt == 0)) {
261 list_del(&rmrru->list);
269 dmar_table_print_dmar_entry(struct acpi_dmar_header *header)
271 struct acpi_dmar_hardware_unit *drhd;
272 struct acpi_dmar_reserved_memory *rmrr;
274 switch (header->type) {
275 case ACPI_DMAR_TYPE_HARDWARE_UNIT:
276 drhd = (struct acpi_dmar_hardware_unit *)header;
277 printk (KERN_INFO PREFIX
278 "DRHD (flags: 0x%08x)base: 0x%016Lx\n",
279 drhd->flags, drhd->address);
281 case ACPI_DMAR_TYPE_RESERVED_MEMORY:
282 rmrr = (struct acpi_dmar_reserved_memory *)header;
284 printk (KERN_INFO PREFIX
285 "RMRR base: 0x%016Lx end: 0x%016Lx\n",
286 rmrr->base_address, rmrr->end_address);
293 * parse_dmar_table - parses the DMA reporting table
296 parse_dmar_table(void)
298 struct acpi_table_dmar *dmar;
299 struct acpi_dmar_header *entry_header;
302 dmar = (struct acpi_table_dmar *)dmar_tbl;
306 if (dmar->width < PAGE_SHIFT_4K - 1) {
307 printk(KERN_WARNING PREFIX "Invalid DMAR haw\n");
311 printk (KERN_INFO PREFIX "Host address width %d\n",
314 entry_header = (struct acpi_dmar_header *)(dmar + 1);
315 while (((unsigned long)entry_header) <
316 (((unsigned long)dmar) + dmar_tbl->length)) {
317 dmar_table_print_dmar_entry(entry_header);
319 switch (entry_header->type) {
320 case ACPI_DMAR_TYPE_HARDWARE_UNIT:
321 ret = dmar_parse_one_drhd(entry_header);
323 case ACPI_DMAR_TYPE_RESERVED_MEMORY:
325 ret = dmar_parse_one_rmrr(entry_header);
329 printk(KERN_WARNING PREFIX
330 "Unknown DMAR structure type\n");
331 ret = 0; /* for forward compatibility */
337 entry_header = ((void *)entry_header + entry_header->length);
342 int dmar_pci_device_match(struct pci_dev *devices[], int cnt,
348 for (index = 0; index < cnt; index++)
349 if (dev == devices[index])
352 /* Check our parent */
353 dev = dev->bus->self;
359 struct dmar_drhd_unit *
360 dmar_find_matched_drhd_unit(struct pci_dev *dev)
362 struct dmar_drhd_unit *drhd = NULL;
364 list_for_each_entry(drhd, &dmar_drhd_units, list) {
365 if (drhd->include_all || dmar_pci_device_match(drhd->devices,
366 drhd->devices_cnt, dev))
373 int __init dmar_dev_scope_init(void)
375 struct dmar_drhd_unit *drhd;
378 for_each_drhd_unit(drhd) {
379 ret = dmar_parse_dev(drhd);
386 struct dmar_rmrr_unit *rmrr;
387 for_each_rmrr_units(rmrr) {
388 ret = rmrr_parse_dev(rmrr);
399 int __init dmar_table_init(void)
401 static int dmar_table_initialized;
404 if (dmar_table_initialized)
407 dmar_table_initialized = 1;
409 ret = parse_dmar_table();
412 printk(KERN_INFO PREFIX "parse DMAR table failure.\n");
416 if (list_empty(&dmar_drhd_units)) {
417 printk(KERN_INFO PREFIX "No DMAR devices found\n");
422 if (list_empty(&dmar_rmrr_units))
423 printk(KERN_INFO PREFIX "No RMRR found\n");
426 #ifdef CONFIG_INTR_REMAP
427 parse_ioapics_under_ir();
433 * early_dmar_detect - checks to see if the platform supports DMAR devices
435 int __init early_dmar_detect(void)
437 acpi_status status = AE_OK;
439 /* if we could find DMAR table, then there are DMAR devices */
440 status = acpi_get_table(ACPI_SIG_DMAR, 0,
441 (struct acpi_table_header **)&dmar_tbl);
443 if (ACPI_SUCCESS(status) && !dmar_tbl) {
444 printk (KERN_WARNING PREFIX "Unable to map DMAR\n");
445 status = AE_NOT_FOUND;
448 return (ACPI_SUCCESS(status) ? 1 : 0);
451 int alloc_iommu(struct dmar_drhd_unit *drhd)
453 struct intel_iommu *iommu;
456 static int iommu_allocated = 0;
458 iommu = kzalloc(sizeof(*iommu), GFP_KERNEL);
462 iommu->seq_id = iommu_allocated++;
464 iommu->reg = ioremap(drhd->reg_base_addr, PAGE_SIZE_4K);
466 printk(KERN_ERR "IOMMU: can't map the region\n");
469 iommu->cap = dmar_readq(iommu->reg + DMAR_CAP_REG);
470 iommu->ecap = dmar_readq(iommu->reg + DMAR_ECAP_REG);
472 /* the registers might be more than one page */
473 map_size = max_t(int, ecap_max_iotlb_offset(iommu->ecap),
474 cap_max_fault_reg_offset(iommu->cap));
475 map_size = PAGE_ALIGN_4K(map_size);
476 if (map_size > PAGE_SIZE_4K) {
478 iommu->reg = ioremap(drhd->reg_base_addr, map_size);
480 printk(KERN_ERR "IOMMU: can't map the region\n");
485 ver = readl(iommu->reg + DMAR_VER_REG);
486 pr_debug("IOMMU %llx: ver %d:%d cap %llx ecap %llx\n",
487 drhd->reg_base_addr, DMAR_VER_MAJOR(ver), DMAR_VER_MINOR(ver),
488 iommu->cap, iommu->ecap);
490 spin_lock_init(&iommu->register_lock);
499 void free_iommu(struct intel_iommu *iommu)
505 free_dmar_iommu(iommu);