drivers/pci/dmar.c

   1 /*
   2  * Copyright (c) 2006, Intel Corporation.
   3  *
   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.
   7  *
   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
  11  * more details.
  12  *
  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.
  16  *
  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>
  21  *
  22  * This file implements early detection/parsing of Remapping Devices
  23  * reported to OS through BIOS via DMA remapping reporting (DMAR) ACPI
  24  * tables.
  25  *
  26  * These routines are used by both DMA-remapping and Interrupt-remapping
  27  */
  28
  29 #include <linux/pci.h>
  30 #include <linux/dmar.h>
  31 #include "iova.h"
  32 #include "intel-iommu.h"
  33
  34 #undef PREFIX
  35 #define PREFIX "DMAR:"
  36
  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.
  40  */
  41 LIST_HEAD(dmar_drhd_units);
  42 LIST_HEAD(dmar_rmrr_units);
  43
  44 static struct acpi_table_header * __initdata dmar_tbl;
  45
  46 static void __init dmar_register_drhd_unit(struct dmar_drhd_unit *drhd)
  47 {
  48         /*
  49          * add INCLUDE_ALL at the tail, so scan the list will find it at
  50          * the very end.
  51          */
  52         if (drhd->include_all)
  53                 list_add_tail(&drhd->list, &dmar_drhd_units);
  54         else
  55                 list_add(&drhd->list, &dmar_drhd_units);
  56 }
  57
  58 static void __init dmar_register_rmrr_unit(struct dmar_rmrr_unit *rmrr)
  59 {
  60         list_add(&rmrr->list, &dmar_rmrr_units);
  61 }
  62
  63 static int __init dmar_parse_one_dev_scope(struct acpi_dmar_device_scope *scope,
  64                                            struct pci_dev **dev, u16 segment)
  65 {
  66         struct pci_bus *bus;
  67         struct pci_dev *pdev = NULL;
  68         struct acpi_dmar_pci_path *path;
  69         int count;
  70
  71         bus = pci_find_bus(segment, scope->bus);
  72         path = (struct acpi_dmar_pci_path *)(scope + 1);
  73         count = (scope->length - sizeof(struct acpi_dmar_device_scope))
  74                 / sizeof(struct acpi_dmar_pci_path);
  75
  76         while (count) {
  77                 if (pdev)
  78                         pci_dev_put(pdev);
  79                 /*
  80                  * Some BIOSes list non-exist devices in DMAR table, just
  81                  * ignore it
  82                  */
  83                 if (!bus) {
  84                         printk(KERN_WARNING
  85                         PREFIX "Device scope bus [%d] not found\n",
  86                         scope->bus);
  87                         break;
  88                 }
  89                 pdev = pci_get_slot(bus, PCI_DEVFN(path->dev, path->fn));
  90                 if (!pdev) {
  91                         printk(KERN_WARNING PREFIX
  92                         "Device scope device [%04x:%02x:%02x.%02x] not found\n",
  93                                 segment, bus->number, path->dev, path->fn);
  94                         break;
  95                 }
  96                 path ++;
  97                 count --;
  98                 bus = pdev->subordinate;
  99         }
 100         if (!pdev) {
 101                 printk(KERN_WARNING PREFIX
 102                 "Device scope device [%04x:%02x:%02x.%02x] not found\n",
 103                 segment, scope->bus, path->dev, path->fn);
 104                 *dev = NULL;
 105                 return 0;
 106         }
 107         if ((scope->entry_type == ACPI_DMAR_SCOPE_TYPE_ENDPOINT && \
 108                         pdev->subordinate) || (scope->entry_type == \
 109                         ACPI_DMAR_SCOPE_TYPE_BRIDGE && !pdev->subordinate)) {
 110                 pci_dev_put(pdev);
 111                 printk(KERN_WARNING PREFIX
 112                         "Device scope type does not match for %s\n",
 113                          pci_name(pdev));
 114                 return -EINVAL;
 115         }
 116         *dev = pdev;
 117         return 0;
 118 }
 119
 120 static int __init dmar_parse_dev_scope(void *start, void *end, int *cnt,
 121                                        struct pci_dev ***devices, u16 segment)
 122 {
 123         struct acpi_dmar_device_scope *scope;
 124         void * tmp = start;
 125         int index;
 126         int ret;
 127
 128         *cnt = 0;
 129         while (start < end) {
 130                 scope = start;
 131                 if (scope->entry_type == ACPI_DMAR_SCOPE_TYPE_ENDPOINT ||
 132                     scope->entry_type == ACPI_DMAR_SCOPE_TYPE_BRIDGE)
 133                         (*cnt)++;
 134                 else
 135                         printk(KERN_WARNING PREFIX
 136                                 "Unsupported device scope\n");
 137                 start += scope->length;
 138         }
 139         if (*cnt == 0)
 140                 return 0;
 141
 142         *devices = kcalloc(*cnt, sizeof(struct pci_dev *), GFP_KERNEL);
 143         if (!*devices)
 144                 return -ENOMEM;
 145
 146         start = tmp;
 147         index = 0;
 148         while (start < end) {
 149                 scope = start;
 150                 if (scope->entry_type == ACPI_DMAR_SCOPE_TYPE_ENDPOINT ||
 151                     scope->entry_type == ACPI_DMAR_SCOPE_TYPE_BRIDGE) {
 152                         ret = dmar_parse_one_dev_scope(scope,
 153                                 &(*devices)[index], segment);
 154                         if (ret) {
 155                                 kfree(*devices);
 156                                 return ret;
 157                         }
 158                         index ++;
 159                 }
 160                 start += scope->length;
 161         }
 162
 163         return 0;
 164 }
 165
 166 /**
 167  * dmar_parse_one_drhd - parses exactly one DMA remapping hardware definition
 168  * structure which uniquely represent one DMA remapping hardware unit
 169  * present in the platform
 170  */
 171 static int __init
 172 dmar_parse_one_drhd(struct acpi_dmar_header *header)
 173 {
 174         struct acpi_dmar_hardware_unit *drhd;
 175         struct dmar_drhd_unit *dmaru;
 176         int ret = 0;
 177         static int include_all;
 178
 179         dmaru = kzalloc(sizeof(*dmaru), GFP_KERNEL);
 180         if (!dmaru)
 181                 return -ENOMEM;
 182
 183         drhd = (struct acpi_dmar_hardware_unit *)header;
 184         dmaru->reg_base_addr = drhd->address;
 185         dmaru->include_all = drhd->flags & 0x1; /* BIT0: INCLUDE_ALL */
 186
 187         if (!dmaru->include_all)
 188                 ret = dmar_parse_dev_scope((void *)(drhd + 1),
 189                                 ((void *)drhd) + header->length,
 190                                 &dmaru->devices_cnt, &dmaru->devices,
 191                                 drhd->segment);
 192         else {
 193                 /* Only allow one INCLUDE_ALL */
 194                 if (include_all) {
 195                         printk(KERN_WARNING PREFIX "Only one INCLUDE_ALL "
 196                                 "device scope is allowed\n");
 197                         ret = -EINVAL;
 198                 }
 199                 include_all = 1;
 200         }
 201
 202         if (ret || (dmaru->devices_cnt == 0 && !dmaru->include_all))
 203                 kfree(dmaru);
 204         else
 205                 dmar_register_drhd_unit(dmaru);
 206         return ret;
 207 }
 208
 209 static int __init
 210 dmar_parse_one_rmrr(struct acpi_dmar_header *header)
 211 {
 212         struct acpi_dmar_reserved_memory *rmrr;
 213         struct dmar_rmrr_unit *rmrru;
 214         int ret = 0;
 215
 216         rmrru = kzalloc(sizeof(*rmrru), GFP_KERNEL);
 217         if (!rmrru)
 218                 return -ENOMEM;
 219
 220         rmrr = (struct acpi_dmar_reserved_memory *)header;
 221         rmrru->base_address = rmrr->base_address;
 222         rmrru->end_address = rmrr->end_address;
 223         ret = dmar_parse_dev_scope((void *)(rmrr + 1),
 224                 ((void *)rmrr) + header->length,
 225                 &rmrru->devices_cnt, &rmrru->devices, rmrr->segment);
 226
 227         if (ret || (rmrru->devices_cnt == 0))
 228                 kfree(rmrru);
 229         else
 230                 dmar_register_rmrr_unit(rmrru);
 231         return ret;
 232 }
 233
 234 static void __init
 235 dmar_table_print_dmar_entry(struct acpi_dmar_header *header)
 236 {
 237         struct acpi_dmar_hardware_unit *drhd;
 238         struct acpi_dmar_reserved_memory *rmrr;
 239
 240         switch (header->type) {
 241         case ACPI_DMAR_TYPE_HARDWARE_UNIT:
 242                 drhd = (struct acpi_dmar_hardware_unit *)header;
 243                 printk (KERN_INFO PREFIX
 244                         "DRHD (flags: 0x%08x)base: 0x%016Lx\n",
 245                         drhd->flags, drhd->address);
 246                 break;
 247         case ACPI_DMAR_TYPE_RESERVED_MEMORY:
 248                 rmrr = (struct acpi_dmar_reserved_memory *)header;
 249
 250                 printk (KERN_INFO PREFIX
 251                         "RMRR base: 0x%016Lx end: 0x%016Lx\n",
 252                         rmrr->base_address, rmrr->end_address);
 253                 break;
 254         }
 255 }
 256
 257 /**
 258  * parse_dmar_table - parses the DMA reporting table
 259  */
 260 static int __init
 261 parse_dmar_table(void)
 262 {
 263         struct acpi_table_dmar *dmar;
 264         struct acpi_dmar_header *entry_header;
 265         int ret = 0;
 266
 267         dmar = (struct acpi_table_dmar *)dmar_tbl;
 268         if (!dmar)
 269                 return -ENODEV;
 270
 271         if (dmar->width < PAGE_SHIFT_4K - 1) {
 272                 printk(KERN_WARNING PREFIX "Invalid DMAR haw\n");
 273                 return -EINVAL;
 274         }
 275
 276         printk (KERN_INFO PREFIX "Host address width %d\n",
 277                 dmar->width + 1);
 278
 279         entry_header = (struct acpi_dmar_header *)(dmar + 1);
 280         while (((unsigned long)entry_header) <
 281                         (((unsigned long)dmar) + dmar_tbl->length)) {
 282                 dmar_table_print_dmar_entry(entry_header);
 283
 284                 switch (entry_header->type) {
 285                 case ACPI_DMAR_TYPE_HARDWARE_UNIT:
 286                         ret = dmar_parse_one_drhd(entry_header);
 287                         break;
 288                 case ACPI_DMAR_TYPE_RESERVED_MEMORY:
 289                         ret = dmar_parse_one_rmrr(entry_header);
 290                         break;
 291                 default:
 292                         printk(KERN_WARNING PREFIX
 293                                 "Unknown DMAR structure type\n");
 294                         ret = 0; /* for forward compatibility */
 295                         break;
 296                 }
 297                 if (ret)
 298                         break;
 299
 300                 entry_header = ((void *)entry_header + entry_header->length);
 301         }
 302         return ret;
 303 }
 304
 305 int dmar_pci_device_match(struct pci_dev *devices[], int cnt,
 306                           struct pci_dev *dev)
 307 {
 308         int index;
 309
 310         while (dev) {
 311                 for (index = 0; index < cnt; index++)
 312                         if (dev == devices[index])
 313                                 return 1;
 314
 315                 /* Check our parent */
 316                 dev = dev->bus->self;
 317         }
 318
 319         return 0;
 320 }
 321
 322 struct dmar_drhd_unit *
 323 dmar_find_matched_drhd_unit(struct pci_dev *dev)
 324 {
 325         struct dmar_drhd_unit *drhd = NULL;
 326
 327         list_for_each_entry(drhd, &dmar_drhd_units, list) {
 328                 if (drhd->include_all || dmar_pci_device_match(drhd->devices,
 329                                                 drhd->devices_cnt, dev))
 330                         return drhd;
 331         }
 332
 333         return NULL;
 334 }
 335
 336
 337 int __init dmar_table_init(void)
 338 {
 339
 340         int ret;
 341
 342         ret = parse_dmar_table();
 343         if (ret) {
 344                 printk(KERN_INFO PREFIX "parse DMAR table failure.\n");
 345                 return ret;
 346         }
 347
 348         if (list_empty(&dmar_drhd_units)) {
 349                 printk(KERN_INFO PREFIX "No DMAR devices found\n");
 350                 return -ENODEV;
 351         }
 352
 353         if (list_empty(&dmar_rmrr_units)) {
 354                 printk(KERN_INFO PREFIX "No RMRR found\n");
 355                 return -ENODEV;
 356         }
 357
 358         return 0;
 359 }
 360
 361 /**
 362  * early_dmar_detect - checks to see if the platform supports DMAR devices
 363  */
 364 int __init early_dmar_detect(void)
 365 {
 366         acpi_status status = AE_OK;
 367
 368         /* if we could find DMAR table, then there are DMAR devices */
 369         status = acpi_get_table(ACPI_SIG_DMAR, 0,
 370                                 (struct acpi_table_header **)&dmar_tbl);
 371
 372         if (ACPI_SUCCESS(status) && !dmar_tbl) {
 373                 printk (KERN_WARNING PREFIX "Unable to map DMAR\n");
 374                 status = AE_NOT_FOUND;
 375         }
 376
 377         return (ACPI_SUCCESS(status) ? 1 : 0);
 378 }
 379
 380 struct intel_iommu *alloc_iommu(struct dmar_drhd_unit *drhd)
 381 {
 382         struct intel_iommu *iommu;
 383         int map_size;
 384         u32 ver;
 385         static int iommu_allocated = 0;
 386
 387         iommu = kzalloc(sizeof(*iommu), GFP_KERNEL);
 388         if (!iommu)
 389                 return NULL;
 390
 391         iommu->seq_id = iommu_allocated++;
 392
 393         iommu->reg = ioremap(drhd->reg_base_addr, PAGE_SIZE_4K);
 394         if (!iommu->reg) {
 395                 printk(KERN_ERR "IOMMU: can't map the region\n");
 396                 goto error;
 397         }
 398         iommu->cap = dmar_readq(iommu->reg + DMAR_CAP_REG);
 399         iommu->ecap = dmar_readq(iommu->reg + DMAR_ECAP_REG);
 400
 401         /* the registers might be more than one page */
 402         map_size = max_t(int, ecap_max_iotlb_offset(iommu->ecap),
 403                 cap_max_fault_reg_offset(iommu->cap));
 404         map_size = PAGE_ALIGN_4K(map_size);
 405         if (map_size > PAGE_SIZE_4K) {
 406                 iounmap(iommu->reg);
 407                 iommu->reg = ioremap(drhd->reg_base_addr, map_size);
 408                 if (!iommu->reg) {
 409                         printk(KERN_ERR "IOMMU: can't map the region\n");
 410                         goto error;
 411                 }
 412         }
 413
 414         ver = readl(iommu->reg + DMAR_VER_REG);
 415         pr_debug("IOMMU %llx: ver %d:%d cap %llx ecap %llx\n",
 416                 drhd->reg_base_addr, DMAR_VER_MAJOR(ver), DMAR_VER_MINOR(ver),
 417                 iommu->cap, iommu->ecap);
 418
 419         spin_lock_init(&iommu->register_lock);
 420
 421         drhd->iommu = iommu;
 422         return iommu;
 423 error:
 424         kfree(iommu);
 425         return NULL;
 426 }
 427
 428 void free_iommu(struct intel_iommu *iommu)
 429 {
 430         if (!iommu)
 431                 return;
 432
 433 #ifdef CONFIG_DMAR
 434         free_dmar_iommu(iommu);
 435 #endif
 436
 437         if (iommu->reg)
 438                 iounmap(iommu->reg);
 439         kfree(iommu);
 440 }