/* * Copyright (c) 2006, Intel Corporation. * * This program is free software; you can redistribute it and/or modify it * under the terms and conditions of the GNU General Public License, * version 2, as published by the Free Software Foundation. * * This program is distributed in the hope it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for * more details. * * You should have received a copy of the GNU General Public License along with * this program; if not, write to the Free Software Foundation, Inc., 59 Temple * Place - Suite 330, Boston, MA 02111-1307 USA. * * Copyright (C) Ashok Raj <ashok.raj@intel.com> * Copyright (C) Shaohua Li <shaohua.li@intel.com> * Copyright (C) Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com> * * This file implements early detection/parsing of DMA Remapping Devices * reported to OS through BIOS via DMA remapping reporting (DMAR) ACPI * tables. */ #include <linux/pci.h> #include <linux/dmar.h> #undef PREFIX #define PREFIX "DMAR:" /* No locks are needed as DMA remapping hardware unit * list is constructed at boot time and hotplug of * these units are not supported by the architecture. */ LIST_HEAD(dmar_drhd_units); LIST_HEAD(dmar_rmrr_units); static struct acpi_table_header * __initdata dmar_tbl; static void __init dmar_register_drhd_unit(struct dmar_drhd_unit *drhd) { /* * add INCLUDE_ALL at the tail, so scan the list will find it at * the very end. */ if (drhd->include_all) list_add_tail(&drhd->list, &dmar_drhd_units); else list_add(&drhd->list, &dmar_drhd_units); } static void __init dmar_register_rmrr_unit(struct dmar_rmrr_unit *rmrr) { list_add(&rmrr->list, &dmar_rmrr_units); } static int __init dmar_parse_one_dev_scope(struct acpi_dmar_device_scope *scope, struct pci_dev **dev, u16 segment) { struct pci_bus *bus; struct pci_dev *pdev = NULL; struct acpi_dmar_pci_path *path; int count; bus = pci_find_bus(segment, scope->bus); path = (struct acpi_dmar_pci_path *)(scope + 1); count = (scope->length - sizeof(struct acpi_dmar_device_scope)) / sizeof(struct acpi_dmar_pci_path); while (count) { if (pdev) pci_dev_put(pdev); /* * Some BIOSes list non-exist devices in DMAR table, just * ignore it */ if (!bus) { printk(KERN_WARNING PREFIX "Device scope bus [%d] not found\n", scope->bus); break; } pdev = pci_get_slot(bus, PCI_DEVFN(path->dev, path->fn)); if (!pdev) { printk(KERN_WARNING PREFIX "Device scope device [%04x:%02x:%02x.%02x] not found\n", segment, bus->number, path->dev, path->fn); break; } path ++; count --; bus = pdev->subordinate; } if (!pdev) { printk(KERN_WARNING PREFIX "Device scope device [%04x:%02x:%02x.%02x] not found\n", segment, scope->bus, path->dev, path->fn); *dev = NULL; return 0; } if ((scope->entry_type == ACPI_DMAR_SCOPE_TYPE_ENDPOINT && \ pdev->subordinate) || (scope->entry_type == \ ACPI_DMAR_SCOPE_TYPE_BRIDGE && !pdev->subordinate)) { pci_dev_put(pdev); printk(KERN_WARNING PREFIX "Device scope type does not match for %s\n", pci_name(pdev)); return -EINVAL; } *dev = pdev; return 0; } static int __init dmar_parse_dev_scope(void *start, void *end, int *cnt, struct pci_dev ***devices, u16 segment) { struct acpi_dmar_device_scope *scope; void * tmp = start; int index; int ret; *cnt = 0; while (start < end) { scope = start; if (scope->entry_type == ACPI_DMAR_SCOPE_TYPE_ENDPOINT || scope->entry_type == ACPI_DMAR_SCOPE_TYPE_BRIDGE) (*cnt)++; else printk(KERN_WARNING PREFIX "Unsupported device scope\n"); start += scope->length; } if (*cnt == 0) return 0; *devices = kcalloc(*cnt, sizeof(struct pci_dev *), GFP_KERNEL); if (!*devices) return -ENOMEM; start = tmp; index = 0; while (start < end) { scope = start; if (scope->entry_type == ACPI_DMAR_SCOPE_TYPE_ENDPOINT || scope->entry_type == ACPI_DMAR_SCOPE_TYPE_BRIDGE) { ret = dmar_parse_one_dev_scope(scope, &(*devices)[index], segment); if (ret) { kfree(*devices); return ret; } index ++; } start += scope->length; } return 0; } /** * dmar_parse_one_drhd - parses exactly one DMA remapping hardware definition * structure which uniquely represent one DMA remapping hardware unit * present in the platform */ static int __init dmar_parse_one_drhd(struct acpi_dmar_header *header) { struct acpi_dmar_hardware_unit *drhd; struct dmar_drhd_unit *dmaru; int ret = 0; static int include_all; dmaru = kzalloc(sizeof(*dmaru), GFP_KERNEL); if (!dmaru) return -ENOMEM; drhd = (struct acpi_dmar_hardware_unit *)header; dmaru->reg_base_addr = drhd->address; dmaru->include_all = drhd->flags & 0x1; /* BIT0: INCLUDE_ALL */ if (!dmaru->include_all) ret = dmar_parse_dev_scope((void *)(drhd + 1), ((void *)drhd) + header->length, &dmaru->devices_cnt, &dmaru->devices, drhd->segment); else { /* Only allow one INCLUDE_ALL */ if (include_all) { printk(KERN_WARNING PREFIX "Only one INCLUDE_ALL " "device scope is allowed\n"); ret = -EINVAL; } include_all = 1; } if (ret || (dmaru->devices_cnt == 0 && !dmaru->include_all)) kfree(dmaru); else dmar_register_drhd_unit(dmaru); return ret; } static int __init dmar_parse_one_rmrr(struct acpi_dmar_header *header) { struct acpi_dmar_reserved_memory *rmrr; struct dmar_rmrr_unit *rmrru; int ret = 0; rmrru = kzalloc(sizeof(*rmrru), GFP_KERNEL); if (!rmrru) return -ENOMEM; rmrr = (struct acpi_dmar_reserved_memory *)header; rmrru->base_address = rmrr->base_address; rmrru->end_address = rmrr->end_address; ret = dmar_parse_dev_scope((void *)(rmrr + 1), ((void *)rmrr) + header->length, &rmrru->devices_cnt, &rmrru->devices, rmrr->segment); if (ret || (rmrru->devices_cnt == 0)) kfree(rmrru); else dmar_register_rmrr_unit(rmrru); return ret; } static void __init dmar_table_print_dmar_entry(struct acpi_dmar_header *header) { struct acpi_dmar_hardware_unit *drhd; struct acpi_dmar_reserved_memory *rmrr; switch (header->type) { case ACPI_DMAR_TYPE_HARDWARE_UNIT: drhd = (struct acpi_dmar_hardware_unit *)header; printk (KERN_INFO PREFIX "DRHD (flags: 0x%08x)base: 0x%016Lx\n", drhd->flags, drhd->address); break; case ACPI_DMAR_TYPE_RESERVED_MEMORY: rmrr = (struct acpi_dmar_reserved_memory *)header; printk (KERN_INFO PREFIX "RMRR base: 0x%016Lx end: 0x%016Lx\n", rmrr->base_address, rmrr->end_address); break; } } /** * parse_dmar_table - parses the DMA reporting table */ static int __init parse_dmar_table(void) { struct acpi_table_dmar *dmar; struct acpi_dmar_header *entry_header; int ret = 0; dmar = (struct acpi_table_dmar *)dmar_tbl; if (!dmar) return -ENODEV; if (!dmar->width) { printk (KERN_WARNING PREFIX "Zero: Invalid DMAR haw\n"); return -EINVAL; } printk (KERN_INFO PREFIX "Host address width %d\n", dmar->width + 1); entry_header = (struct acpi_dmar_header *)(dmar + 1); while (((unsigned long)entry_header) < (((unsigned long)dmar) + dmar_tbl->length)) { dmar_table_print_dmar_entry(entry_header); switch (entry_header->type) { case ACPI_DMAR_TYPE_HARDWARE_UNIT: ret = dmar_parse_one_drhd(entry_header); break; case ACPI_DMAR_TYPE_RESERVED_MEMORY: ret = dmar_parse_one_rmrr(entry_header); break; default: printk(KERN_WARNING PREFIX "Unknown DMAR structure type\n"); ret = 0; /* for forward compatibility */ break; } if (ret) break; entry_header = ((void *)entry_header + entry_header->length); } return ret; } int __init dmar_table_init(void) { parse_dmar_table(); if (list_empty(&dmar_drhd_units)) { printk(KERN_INFO PREFIX "No DMAR devices found\n"); return -ENODEV; } return 0; } /** * early_dmar_detect - checks to see if the platform supports DMAR devices */ int __init early_dmar_detect(void) { acpi_status status = AE_OK; /* if we could find DMAR table, then there are DMAR devices */ status = acpi_get_table(ACPI_SIG_DMAR, 0, (struct acpi_table_header **)&dmar_tbl); if (ACPI_SUCCESS(status) && !dmar_tbl) { printk (KERN_WARNING PREFIX "Unable to map DMAR\n"); status = AE_NOT_FOUND; } return (ACPI_SUCCESS(status) ? 1 : 0); }