drivers/iommu/intel_irq_remapping.c

   1 #include <linux/interrupt.h>
   2 #include <linux/dmar.h>
   3 #include <linux/spinlock.h>
   4 #include <linux/slab.h>
   5 #include <linux/jiffies.h>
   6 #include <linux/hpet.h>
   7 #include <linux/pci.h>
   8 #include <linux/irq.h>
   9 #include <linux/intel-iommu.h>
  10 #include <linux/acpi.h>
  11 #include <asm/io_apic.h>
  12 #include <asm/smp.h>
  13 #include <asm/cpu.h>
  14 #include <asm/irq_remapping.h>
  15 #include <asm/pci-direct.h>
  16 #include <asm/msidef.h>
  17
  18 #include "irq_remapping.h"
  19
  20 struct ioapic_scope {
  21         struct intel_iommu *iommu;
  22         unsigned int id;
  23         unsigned int bus;       /* PCI bus number */
  24         unsigned int devfn;     /* PCI devfn number */
  25 };
  26
  27 struct hpet_scope {
  28         struct intel_iommu *iommu;
  29         u8 id;
  30         unsigned int bus;
  31         unsigned int devfn;
  32 };
  33
  34 #define IR_X2APIC_MODE(mode) (mode ? (1 << 11) : 0)
  35 #define IRTE_DEST(dest) ((x2apic_mode) ? dest : dest << 8)
  36
  37 static struct ioapic_scope ir_ioapic[MAX_IO_APICS];
  38 static struct hpet_scope ir_hpet[MAX_HPET_TBS];
  39
  40 /*
  41  * Lock ordering:
  42  * ->dmar_global_lock
  43  *      ->irq_2_ir_lock
  44  *              ->qi->q_lock
  45  *      ->iommu->register_lock
  46  * Note:
  47  * intel_irq_remap_ops.{supported,prepare,enable,disable,reenable} are called
  48  * in single-threaded environment with interrupt disabled, so no need to tabke
  49  * the dmar_global_lock.
  50  */
  51 static DEFINE_RAW_SPINLOCK(irq_2_ir_lock);
  52
  53 static int __init parse_ioapics_under_ir(void);
  54
  55 static struct irq_2_iommu *irq_2_iommu(unsigned int irq)
  56 {
  57         struct irq_cfg *cfg = irq_cfg(irq);
  58         return cfg ? &cfg->irq_2_iommu : NULL;
  59 }
  60
  61 static int get_irte(int irq, struct irte *entry)
  62 {
  63         struct irq_2_iommu *irq_iommu = irq_2_iommu(irq);
  64         unsigned long flags;
  65         int index;
  66
  67         if (!entry || !irq_iommu)
  68                 return -1;
  69
  70         raw_spin_lock_irqsave(&irq_2_ir_lock, flags);
  71
  72         if (unlikely(!irq_iommu->iommu)) {
  73                 raw_spin_unlock_irqrestore(&irq_2_ir_lock, flags);
  74                 return -1;
  75         }
  76
  77         index = irq_iommu->irte_index + irq_iommu->sub_handle;
  78         *entry = *(irq_iommu->iommu->ir_table->base + index);
  79
  80         raw_spin_unlock_irqrestore(&irq_2_ir_lock, flags);
  81         return 0;
  82 }
  83
  84 static int alloc_irte(struct intel_iommu *iommu, int irq, u16 count)
  85 {
  86         struct ir_table *table = iommu->ir_table;
  87         struct irq_2_iommu *irq_iommu = irq_2_iommu(irq);
  88         struct irq_cfg *cfg = irq_cfg(irq);
  89         unsigned int mask = 0;
  90         unsigned long flags;
  91         int index;
  92
  93         if (!count || !irq_iommu)
  94                 return -1;
  95
  96         if (count > 1) {
  97                 count = __roundup_pow_of_two(count);
  98                 mask = ilog2(count);
  99         }
 100
 101         if (mask > ecap_max_handle_mask(iommu->ecap)) {
 102                 printk(KERN_ERR
 103                        "Requested mask %x exceeds the max invalidation handle"
 104                        " mask value %Lx\n", mask,
 105                        ecap_max_handle_mask(iommu->ecap));
 106                 return -1;
 107         }
 108
 109         raw_spin_lock_irqsave(&irq_2_ir_lock, flags);
 110         index = bitmap_find_free_region(table->bitmap,
 111                                         INTR_REMAP_TABLE_ENTRIES, mask);
 112         if (index < 0) {
 113                 pr_warn("IR%d: can't allocate an IRTE\n", iommu->seq_id);
 114         } else {
 115                 cfg->remapped = 1;
 116                 irq_iommu->iommu = iommu;
 117                 irq_iommu->irte_index =  index;
 118                 irq_iommu->sub_handle = 0;
 119                 irq_iommu->irte_mask = mask;
 120         }
 121         raw_spin_unlock_irqrestore(&irq_2_ir_lock, flags);
 122
 123         return index;
 124 }
 125
 126 static int qi_flush_iec(struct intel_iommu *iommu, int index, int mask)
 127 {
 128         struct qi_desc desc;
 129
 130         desc.low = QI_IEC_IIDEX(index) | QI_IEC_TYPE | QI_IEC_IM(mask)
 131                    | QI_IEC_SELECTIVE;
 132         desc.high = 0;
 133
 134         return qi_submit_sync(&desc, iommu);
 135 }
 136
 137 static int map_irq_to_irte_handle(int irq, u16 *sub_handle)
 138 {
 139         struct irq_2_iommu *irq_iommu = irq_2_iommu(irq);
 140         unsigned long flags;
 141         int index;
 142
 143         if (!irq_iommu)
 144                 return -1;
 145
 146         raw_spin_lock_irqsave(&irq_2_ir_lock, flags);
 147         *sub_handle = irq_iommu->sub_handle;
 148         index = irq_iommu->irte_index;
 149         raw_spin_unlock_irqrestore(&irq_2_ir_lock, flags);
 150         return index;
 151 }
 152
 153 static int set_irte_irq(int irq, struct intel_iommu *iommu, u16 index, u16 subhandle)
 154 {
 155         struct irq_2_iommu *irq_iommu = irq_2_iommu(irq);
 156         struct irq_cfg *cfg = irq_cfg(irq);
 157         unsigned long flags;
 158
 159         if (!irq_iommu)
 160                 return -1;
 161
 162         raw_spin_lock_irqsave(&irq_2_ir_lock, flags);
 163
 164         cfg->remapped = 1;
 165         irq_iommu->iommu = iommu;
 166         irq_iommu->irte_index = index;
 167         irq_iommu->sub_handle = subhandle;
 168         irq_iommu->irte_mask = 0;
 169
 170         raw_spin_unlock_irqrestore(&irq_2_ir_lock, flags);
 171
 172         return 0;
 173 }
 174
 175 static int modify_irte(int irq, struct irte *irte_modified)
 176 {
 177         struct irq_2_iommu *irq_iommu = irq_2_iommu(irq);
 178         struct intel_iommu *iommu;
 179         unsigned long flags;
 180         struct irte *irte;
 181         int rc, index;
 182
 183         if (!irq_iommu)
 184                 return -1;
 185
 186         raw_spin_lock_irqsave(&irq_2_ir_lock, flags);
 187
 188         iommu = irq_iommu->iommu;
 189
 190         index = irq_iommu->irte_index + irq_iommu->sub_handle;
 191         irte = &iommu->ir_table->base[index];
 192
 193         set_64bit(&irte->low, irte_modified->low);
 194         set_64bit(&irte->high, irte_modified->high);
 195         __iommu_flush_cache(iommu, irte, sizeof(*irte));
 196
 197         rc = qi_flush_iec(iommu, index, 0);
 198         raw_spin_unlock_irqrestore(&irq_2_ir_lock, flags);
 199
 200         return rc;
 201 }
 202
 203 static struct intel_iommu *map_hpet_to_ir(u8 hpet_id)
 204 {
 205         int i;
 206
 207         for (i = 0; i < MAX_HPET_TBS; i++)
 208                 if (ir_hpet[i].id == hpet_id && ir_hpet[i].iommu)
 209                         return ir_hpet[i].iommu;
 210         return NULL;
 211 }
 212
 213 static struct intel_iommu *map_ioapic_to_ir(int apic)
 214 {
 215         int i;
 216
 217         for (i = 0; i < MAX_IO_APICS; i++)
 218                 if (ir_ioapic[i].id == apic && ir_ioapic[i].iommu)
 219                         return ir_ioapic[i].iommu;
 220         return NULL;
 221 }
 222
 223 static struct intel_iommu *map_dev_to_ir(struct pci_dev *dev)
 224 {
 225         struct dmar_drhd_unit *drhd;
 226
 227         drhd = dmar_find_matched_drhd_unit(dev);
 228         if (!drhd)
 229                 return NULL;
 230
 231         return drhd->iommu;
 232 }
 233
 234 static int clear_entries(struct irq_2_iommu *irq_iommu)
 235 {
 236         struct irte *start, *entry, *end;
 237         struct intel_iommu *iommu;
 238         int index;
 239
 240         if (irq_iommu->sub_handle)
 241                 return 0;
 242
 243         iommu = irq_iommu->iommu;
 244         index = irq_iommu->irte_index + irq_iommu->sub_handle;
 245
 246         start = iommu->ir_table->base + index;
 247         end = start + (1 << irq_iommu->irte_mask);
 248
 249         for (entry = start; entry < end; entry++) {
 250                 set_64bit(&entry->low, 0);
 251                 set_64bit(&entry->high, 0);
 252         }
 253         bitmap_release_region(iommu->ir_table->bitmap, index,
 254                               irq_iommu->irte_mask);
 255
 256         return qi_flush_iec(iommu, index, irq_iommu->irte_mask);
 257 }
 258
 259 static int free_irte(int irq)
 260 {
 261         struct irq_2_iommu *irq_iommu = irq_2_iommu(irq);
 262         unsigned long flags;
 263         int rc;
 264
 265         if (!irq_iommu)
 266                 return -1;
 267
 268         raw_spin_lock_irqsave(&irq_2_ir_lock, flags);
 269
 270         rc = clear_entries(irq_iommu);
 271
 272         irq_iommu->iommu = NULL;
 273         irq_iommu->irte_index = 0;
 274         irq_iommu->sub_handle = 0;
 275         irq_iommu->irte_mask = 0;
 276
 277         raw_spin_unlock_irqrestore(&irq_2_ir_lock, flags);
 278
 279         return rc;
 280 }
 281
 282 /*
 283  * source validation type
 284  */
 285 #define SVT_NO_VERIFY           0x0  /* no verification is required */
 286 #define SVT_VERIFY_SID_SQ       0x1  /* verify using SID and SQ fields */
 287 #define SVT_VERIFY_BUS          0x2  /* verify bus of request-id */
 288
 289 /*
 290  * source-id qualifier
 291  */
 292 #define SQ_ALL_16       0x0  /* verify all 16 bits of request-id */
 293 #define SQ_13_IGNORE_1  0x1  /* verify most significant 13 bits, ignore
 294                               * the third least significant bit
 295                               */
 296 #define SQ_13_IGNORE_2  0x2  /* verify most significant 13 bits, ignore
 297                               * the second and third least significant bits
 298                               */
 299 #define SQ_13_IGNORE_3  0x3  /* verify most significant 13 bits, ignore
 300                               * the least three significant bits
 301                               */
 302
 303 /*
 304  * set SVT, SQ and SID fields of irte to verify
 305  * source ids of interrupt requests
 306  */
 307 static void set_irte_sid(struct irte *irte, unsigned int svt,
 308                          unsigned int sq, unsigned int sid)
 309 {
 310         if (disable_sourceid_checking)
 311                 svt = SVT_NO_VERIFY;
 312         irte->svt = svt;
 313         irte->sq = sq;
 314         irte->sid = sid;
 315 }
 316
 317 static int set_ioapic_sid(struct irte *irte, int apic)
 318 {
 319         int i;
 320         u16 sid = 0;
 321
 322         if (!irte)
 323                 return -1;
 324
 325         down_read(&dmar_global_lock);
 326         for (i = 0; i < MAX_IO_APICS; i++) {
 327                 if (ir_ioapic[i].iommu && ir_ioapic[i].id == apic) {
 328                         sid = (ir_ioapic[i].bus << 8) | ir_ioapic[i].devfn;
 329                         break;
 330                 }
 331         }
 332         up_read(&dmar_global_lock);
 333
 334         if (sid == 0) {
 335                 pr_warning("Failed to set source-id of IOAPIC (%d)\n", apic);
 336                 return -1;
 337         }
 338
 339         set_irte_sid(irte, SVT_VERIFY_SID_SQ, SQ_ALL_16, sid);
 340
 341         return 0;
 342 }
 343
 344 static int set_hpet_sid(struct irte *irte, u8 id)
 345 {
 346         int i;
 347         u16 sid = 0;
 348
 349         if (!irte)
 350                 return -1;
 351
 352         down_read(&dmar_global_lock);
 353         for (i = 0; i < MAX_HPET_TBS; i++) {
 354                 if (ir_hpet[i].iommu && ir_hpet[i].id == id) {
 355                         sid = (ir_hpet[i].bus << 8) | ir_hpet[i].devfn;
 356                         break;
 357                 }
 358         }
 359         up_read(&dmar_global_lock);
 360
 361         if (sid == 0) {
 362                 pr_warning("Failed to set source-id of HPET block (%d)\n", id);
 363                 return -1;
 364         }
 365
 366         /*
 367          * Should really use SQ_ALL_16. Some platforms are broken.
 368          * While we figure out the right quirks for these broken platforms, use
 369          * SQ_13_IGNORE_3 for now.
 370          */
 371         set_irte_sid(irte, SVT_VERIFY_SID_SQ, SQ_13_IGNORE_3, sid);
 372
 373         return 0;
 374 }
 375
 376 struct set_msi_sid_data {
 377         struct pci_dev *pdev;
 378         u16 alias;
 379 };
 380
 381 static int set_msi_sid_cb(struct pci_dev *pdev, u16 alias, void *opaque)
 382 {
 383         struct set_msi_sid_data *data = opaque;
 384
 385         data->pdev = pdev;
 386         data->alias = alias;
 387
 388         return 0;
 389 }
 390
 391 static int set_msi_sid(struct irte *irte, struct pci_dev *dev)
 392 {
 393         struct set_msi_sid_data data;
 394
 395         if (!irte || !dev)
 396                 return -1;
 397
 398         pci_for_each_dma_alias(dev, set_msi_sid_cb, &data);
 399
 400         /*
 401          * DMA alias provides us with a PCI device and alias.  The only case
 402          * where the it will return an alias on a different bus than the
 403          * device is the case of a PCIe-to-PCI bridge, where the alias is for
 404          * the subordinate bus.  In this case we can only verify the bus.
 405          *
 406          * If the alias device is on a different bus than our source device
 407          * then we have a topology based alias, use it.
 408          *
 409          * Otherwise, the alias is for a device DMA quirk and we cannot
 410          * assume that MSI uses the same requester ID.  Therefore use the
 411          * original device.
 412          */
 413         if (PCI_BUS_NUM(data.alias) != data.pdev->bus->number)
 414                 set_irte_sid(irte, SVT_VERIFY_BUS, SQ_ALL_16,
 415                              PCI_DEVID(PCI_BUS_NUM(data.alias),
 416                                        dev->bus->number));
 417         else if (data.pdev->bus->number != dev->bus->number)
 418                 set_irte_sid(irte, SVT_VERIFY_SID_SQ, SQ_ALL_16, data.alias);
 419         else
 420                 set_irte_sid(irte, SVT_VERIFY_SID_SQ, SQ_ALL_16,
 421                              PCI_DEVID(dev->bus->number, dev->devfn));
 422
 423         return 0;
 424 }
 425
 426 static void iommu_set_irq_remapping(struct intel_iommu *iommu, int mode)
 427 {
 428         u64 addr;
 429         u32 sts;
 430         unsigned long flags;
 431
 432         addr = virt_to_phys((void *)iommu->ir_table->base);
 433
 434         raw_spin_lock_irqsave(&iommu->register_lock, flags);
 435
 436         dmar_writeq(iommu->reg + DMAR_IRTA_REG,
 437                     (addr) | IR_X2APIC_MODE(mode) | INTR_REMAP_TABLE_REG_SIZE);
 438
 439         /* Set interrupt-remapping table pointer */
 440         writel(iommu->gcmd | DMA_GCMD_SIRTP, iommu->reg + DMAR_GCMD_REG);
 441
 442         IOMMU_WAIT_OP(iommu, DMAR_GSTS_REG,
 443                       readl, (sts & DMA_GSTS_IRTPS), sts);
 444         raw_spin_unlock_irqrestore(&iommu->register_lock, flags);
 445
 446         /*
 447          * global invalidation of interrupt entry cache before enabling
 448          * interrupt-remapping.
 449          */
 450         qi_global_iec(iommu);
 451
 452         raw_spin_lock_irqsave(&iommu->register_lock, flags);
 453
 454         /* Enable interrupt-remapping */
 455         iommu->gcmd |= DMA_GCMD_IRE;
 456         iommu->gcmd &= ~DMA_GCMD_CFI;  /* Block compatibility-format MSIs */
 457         writel(iommu->gcmd, iommu->reg + DMAR_GCMD_REG);
 458
 459         IOMMU_WAIT_OP(iommu, DMAR_GSTS_REG,
 460                       readl, (sts & DMA_GSTS_IRES), sts);
 461
 462         /*
 463          * With CFI clear in the Global Command register, we should be
 464          * protected from dangerous (i.e. compatibility) interrupts
 465          * regardless of x2apic status.  Check just to be sure.
 466          */
 467         if (sts & DMA_GSTS_CFIS)
 468                 WARN(1, KERN_WARNING
 469                         "Compatibility-format IRQs enabled despite intr remapping;\n"
 470                         "you are vulnerable to IRQ injection.\n");
 471
 472         raw_spin_unlock_irqrestore(&iommu->register_lock, flags);
 473 }
 474
 475 static int intel_setup_irq_remapping(struct intel_iommu *iommu)
 476 {
 477         struct ir_table *ir_table;
 478         struct page *pages;
 479         unsigned long *bitmap;
 480
 481         if (iommu->ir_table)
 482                 return 0;
 483
 484         ir_table = kzalloc(sizeof(struct ir_table), GFP_ATOMIC);
 485         if (!ir_table)
 486                 return -ENOMEM;
 487
 488         pages = alloc_pages_node(iommu->node, GFP_ATOMIC | __GFP_ZERO,
 489                                  INTR_REMAP_PAGE_ORDER);
 490
 491         if (!pages) {
 492                 pr_err("IR%d: failed to allocate pages of order %d\n",
 493                        iommu->seq_id, INTR_REMAP_PAGE_ORDER);
 494                 goto out_free_table;
 495         }
 496
 497         bitmap = kcalloc(BITS_TO_LONGS(INTR_REMAP_TABLE_ENTRIES),
 498                          sizeof(long), GFP_ATOMIC);
 499         if (bitmap == NULL) {
 500                 pr_err("IR%d: failed to allocate bitmap\n", iommu->seq_id);
 501                 goto out_free_pages;
 502         }
 503
 504         ir_table->base = page_address(pages);
 505         ir_table->bitmap = bitmap;
 506         iommu->ir_table = ir_table;
 507         return 0;
 508
 509 out_free_pages:
 510         __free_pages(pages, INTR_REMAP_PAGE_ORDER);
 511 out_free_table:
 512         kfree(ir_table);
 513         return -ENOMEM;
 514 }
 515
 516 static void intel_teardown_irq_remapping(struct intel_iommu *iommu)
 517 {
 518         if (iommu && iommu->ir_table) {
 519                 free_pages((unsigned long)iommu->ir_table->base,
 520                            INTR_REMAP_PAGE_ORDER);
 521                 kfree(iommu->ir_table->bitmap);
 522                 kfree(iommu->ir_table);
 523                 iommu->ir_table = NULL;
 524         }
 525 }
 526
 527 /*
 528  * Disable Interrupt Remapping.
 529  */
 530 static void iommu_disable_irq_remapping(struct intel_iommu *iommu)
 531 {
 532         unsigned long flags;
 533         u32 sts;
 534
 535         if (!ecap_ir_support(iommu->ecap))
 536                 return;
 537
 538         /*
 539          * global invalidation of interrupt entry cache before disabling
 540          * interrupt-remapping.
 541          */
 542         qi_global_iec(iommu);
 543
 544         raw_spin_lock_irqsave(&iommu->register_lock, flags);
 545
 546         sts = dmar_readq(iommu->reg + DMAR_GSTS_REG);
 547         if (!(sts & DMA_GSTS_IRES))
 548                 goto end;
 549
 550         iommu->gcmd &= ~DMA_GCMD_IRE;
 551         writel(iommu->gcmd, iommu->reg + DMAR_GCMD_REG);
 552
 553         IOMMU_WAIT_OP(iommu, DMAR_GSTS_REG,
 554                       readl, !(sts & DMA_GSTS_IRES), sts);
 555
 556 end:
 557         raw_spin_unlock_irqrestore(&iommu->register_lock, flags);
 558 }
 559
 560 static int __init dmar_x2apic_optout(void)
 561 {
 562         struct acpi_table_dmar *dmar;
 563         dmar = (struct acpi_table_dmar *)dmar_tbl;
 564         if (!dmar || no_x2apic_optout)
 565                 return 0;
 566         return dmar->flags & DMAR_X2APIC_OPT_OUT;
 567 }
 568
 569 static int __init intel_irq_remapping_supported(void)
 570 {
 571         struct dmar_drhd_unit *drhd;
 572         struct intel_iommu *iommu;
 573
 574         if (disable_irq_remap)
 575                 return 0;
 576         if (irq_remap_broken) {
 577                 printk(KERN_WARNING
 578                         "This system BIOS has enabled interrupt remapping\n"
 579                         "on a chipset that contains an erratum making that\n"
 580                         "feature unstable.  To maintain system stability\n"
 581                         "interrupt remapping is being disabled.  Please\n"
 582                         "contact your BIOS vendor for an update\n");
 583                 add_taint(TAINT_FIRMWARE_WORKAROUND, LOCKDEP_STILL_OK);
 584                 disable_irq_remap = 1;
 585                 return 0;
 586         }
 587
 588         if (!dmar_ir_support())
 589                 return 0;
 590
 591         for_each_iommu(iommu, drhd)
 592                 if (!ecap_ir_support(iommu->ecap))
 593                         return 0;
 594
 595         return 1;
 596 }
 597
 598 static int __init intel_enable_irq_remapping(void)
 599 {
 600         struct dmar_drhd_unit *drhd;
 601         struct intel_iommu *iommu;
 602         bool x2apic_present;
 603         int setup = 0;
 604         int eim = 0;
 605
 606         x2apic_present = x2apic_supported();
 607
 608         if (parse_ioapics_under_ir() != 1) {
 609                 printk(KERN_INFO "Not enable interrupt remapping\n");
 610                 goto error;
 611         }
 612
 613         if (x2apic_present) {
 614                 pr_info("Queued invalidation will be enabled to support x2apic and Intr-remapping.\n");
 615
 616                 eim = !dmar_x2apic_optout();
 617                 if (!eim)
 618                         pr_info("x2apic is disabled because BIOS sets x2apic opt out bit. You can use 'intremap=no_x2apic_optout' to override the BIOS setting.\n");
 619         }
 620
 621         for_each_iommu(iommu, drhd) {
 622                 /*
 623                  * If the queued invalidation is already initialized,
 624                  * shouldn't disable it.
 625                  */
 626                 if (iommu->qi)
 627                         continue;
 628
 629                 /*
 630                  * Clear previous faults.
 631                  */
 632                 dmar_fault(-1, iommu);
 633
 634                 /*
 635                  * Disable intr remapping and queued invalidation, if already
 636                  * enabled prior to OS handover.
 637                  */
 638                 iommu_disable_irq_remapping(iommu);
 639
 640                 dmar_disable_qi(iommu);
 641         }
 642
 643         /*
 644          * check for the Interrupt-remapping support
 645          */
 646         for_each_iommu(iommu, drhd) {
 647                 if (!ecap_ir_support(iommu->ecap))
 648                         continue;
 649
 650                 if (eim && !ecap_eim_support(iommu->ecap)) {
 651                         printk(KERN_INFO "DRHD %Lx: EIM not supported by DRHD, "
 652                                " ecap %Lx\n", drhd->reg_base_addr, iommu->ecap);
 653                         goto error;
 654                 }
 655         }
 656
 657         /*
 658          * Enable queued invalidation for all the DRHD's.
 659          */
 660         for_each_iommu(iommu, drhd) {
 661                 int ret = dmar_enable_qi(iommu);
 662
 663                 if (ret) {
 664                         printk(KERN_ERR "DRHD %Lx: failed to enable queued, "
 665                                " invalidation, ecap %Lx, ret %d\n",
 666                                drhd->reg_base_addr, iommu->ecap, ret);
 667                         goto error;
 668                 }
 669         }
 670
 671         /*
 672          * Setup Interrupt-remapping for all the DRHD's now.
 673          */
 674         for_each_iommu(iommu, drhd) {
 675                 if (!ecap_ir_support(iommu->ecap))
 676                         continue;
 677
 678                 if (intel_setup_irq_remapping(iommu))
 679                         goto error;
 680
 681                 iommu_set_irq_remapping(iommu, eim);
 682                 setup = 1;
 683         }
 684
 685         if (!setup)
 686                 goto error;
 687
 688         irq_remapping_enabled = 1;
 689
 690         /*
 691          * VT-d has a different layout for IO-APIC entries when
 692          * interrupt remapping is enabled. So it needs a special routine
 693          * to print IO-APIC entries for debugging purposes too.
 694          */
 695         x86_io_apic_ops.print_entries = intel_ir_io_apic_print_entries;
 696
 697         pr_info("Enabled IRQ remapping in %s mode\n", eim ? "x2apic" : "xapic");
 698
 699         return eim ? IRQ_REMAP_X2APIC_MODE : IRQ_REMAP_XAPIC_MODE;
 700
 701 error:
 702         for_each_iommu(iommu, drhd)
 703                 if (ecap_ir_support(iommu->ecap)) {
 704                         iommu_disable_irq_remapping(iommu);
 705                         intel_teardown_irq_remapping(iommu);
 706                 }
 707
 708         if (x2apic_present)
 709                 pr_warn("Failed to enable irq remapping.  You are vulnerable to irq-injection attacks.\n");
 710
 711         return -1;
 712 }
 713
 714 static int ir_parse_one_hpet_scope(struct acpi_dmar_device_scope *scope,
 715                                    struct intel_iommu *iommu,
 716                                    struct acpi_dmar_hardware_unit *drhd)
 717 {
 718         struct acpi_dmar_pci_path *path;
 719         u8 bus;
 720         int count, free = -1;
 721
 722         bus = scope->bus;
 723         path = (struct acpi_dmar_pci_path *)(scope + 1);
 724         count = (scope->length - sizeof(struct acpi_dmar_device_scope))
 725                 / sizeof(struct acpi_dmar_pci_path);
 726
 727         while (--count > 0) {
 728                 /*
 729                  * Access PCI directly due to the PCI
 730                  * subsystem isn't initialized yet.
 731                  */
 732                 bus = read_pci_config_byte(bus, path->device, path->function,
 733                                            PCI_SECONDARY_BUS);
 734                 path++;
 735         }
 736
 737         for (count = 0; count < MAX_HPET_TBS; count++) {
 738                 if (ir_hpet[count].iommu == iommu &&
 739                     ir_hpet[count].id == scope->enumeration_id)
 740                         return 0;
 741                 else if (ir_hpet[count].iommu == NULL && free == -1)
 742                         free = count;
 743         }
 744         if (free == -1) {
 745                 pr_warn("Exceeded Max HPET blocks\n");
 746                 return -ENOSPC;
 747         }
 748
 749         ir_hpet[free].iommu = iommu;
 750         ir_hpet[free].id    = scope->enumeration_id;
 751         ir_hpet[free].bus   = bus;
 752         ir_hpet[free].devfn = PCI_DEVFN(path->device, path->function);
 753         pr_info("HPET id %d under DRHD base 0x%Lx\n",
 754                 scope->enumeration_id, drhd->address);
 755
 756         return 0;
 757 }
 758
 759 static int ir_parse_one_ioapic_scope(struct acpi_dmar_device_scope *scope,
 760                                      struct intel_iommu *iommu,
 761                                      struct acpi_dmar_hardware_unit *drhd)
 762 {
 763         struct acpi_dmar_pci_path *path;
 764         u8 bus;
 765         int count, free = -1;
 766
 767         bus = scope->bus;
 768         path = (struct acpi_dmar_pci_path *)(scope + 1);
 769         count = (scope->length - sizeof(struct acpi_dmar_device_scope))
 770                 / sizeof(struct acpi_dmar_pci_path);
 771
 772         while (--count > 0) {
 773                 /*
 774                  * Access PCI directly due to the PCI
 775                  * subsystem isn't initialized yet.
 776                  */
 777                 bus = read_pci_config_byte(bus, path->device, path->function,
 778                                            PCI_SECONDARY_BUS);
 779                 path++;
 780         }
 781
 782         for (count = 0; count < MAX_IO_APICS; count++) {
 783                 if (ir_ioapic[count].iommu == iommu &&
 784                     ir_ioapic[count].id == scope->enumeration_id)
 785                         return 0;
 786                 else if (ir_ioapic[count].iommu == NULL && free == -1)
 787                         free = count;
 788         }
 789         if (free == -1) {
 790                 pr_warn("Exceeded Max IO APICS\n");
 791                 return -ENOSPC;
 792         }
 793
 794         ir_ioapic[free].bus   = bus;
 795         ir_ioapic[free].devfn = PCI_DEVFN(path->device, path->function);
 796         ir_ioapic[free].iommu = iommu;
 797         ir_ioapic[free].id    = scope->enumeration_id;
 798         pr_info("IOAPIC id %d under DRHD base  0x%Lx IOMMU %d\n",
 799                 scope->enumeration_id, drhd->address, iommu->seq_id);
 800
 801         return 0;
 802 }
 803
 804 static int ir_parse_ioapic_hpet_scope(struct acpi_dmar_header *header,
 805                                       struct intel_iommu *iommu)
 806 {
 807         int ret = 0;
 808         struct acpi_dmar_hardware_unit *drhd;
 809         struct acpi_dmar_device_scope *scope;
 810         void *start, *end;
 811
 812         drhd = (struct acpi_dmar_hardware_unit *)header;
 813         start = (void *)(drhd + 1);
 814         end = ((void *)drhd) + header->length;
 815
 816         while (start < end && ret == 0) {
 817                 scope = start;
 818                 if (scope->entry_type == ACPI_DMAR_SCOPE_TYPE_IOAPIC)
 819                         ret = ir_parse_one_ioapic_scope(scope, iommu, drhd);
 820                 else if (scope->entry_type == ACPI_DMAR_SCOPE_TYPE_HPET)
 821                         ret = ir_parse_one_hpet_scope(scope, iommu, drhd);
 822                 start += scope->length;
 823         }
 824
 825         return ret;
 826 }
 827
 828 static void ir_remove_ioapic_hpet_scope(struct intel_iommu *iommu)
 829 {
 830         int i;
 831
 832         for (i = 0; i < MAX_HPET_TBS; i++)
 833                 if (ir_hpet[i].iommu == iommu)
 834                         ir_hpet[i].iommu = NULL;
 835
 836         for (i = 0; i < MAX_IO_APICS; i++)
 837                 if (ir_ioapic[i].iommu == iommu)
 838                         ir_ioapic[i].iommu = NULL;
 839 }
 840
 841 /*
 842  * Finds the assocaition between IOAPIC's and its Interrupt-remapping
 843  * hardware unit.
 844  */
 845 static int __init parse_ioapics_under_ir(void)
 846 {
 847         struct dmar_drhd_unit *drhd;
 848         struct intel_iommu *iommu;
 849         int ir_supported = 0;
 850         int ioapic_idx;
 851
 852         for_each_iommu(iommu, drhd)
 853                 if (ecap_ir_support(iommu->ecap)) {
 854                         if (ir_parse_ioapic_hpet_scope(drhd->hdr, iommu))
 855                                 return -1;
 856
 857                         ir_supported = 1;
 858                 }
 859
 860         if (!ir_supported)
 861                 return 0;
 862
 863         for (ioapic_idx = 0; ioapic_idx < nr_ioapics; ioapic_idx++) {
 864                 int ioapic_id = mpc_ioapic_id(ioapic_idx);
 865                 if (!map_ioapic_to_ir(ioapic_id)) {
 866                         pr_err(FW_BUG "ioapic %d has no mapping iommu, "
 867                                "interrupt remapping will be disabled\n",
 868                                ioapic_id);
 869                         return -1;
 870                 }
 871         }
 872
 873         return 1;
 874 }
 875
 876 static int __init ir_dev_scope_init(void)
 877 {
 878         int ret;
 879
 880         if (!irq_remapping_enabled)
 881                 return 0;
 882
 883         down_write(&dmar_global_lock);
 884         ret = dmar_dev_scope_init();
 885         up_write(&dmar_global_lock);
 886
 887         return ret;
 888 }
 889 rootfs_initcall(ir_dev_scope_init);
 890
 891 static void disable_irq_remapping(void)
 892 {
 893         struct dmar_drhd_unit *drhd;
 894         struct intel_iommu *iommu = NULL;
 895
 896         /*
 897          * Disable Interrupt-remapping for all the DRHD's now.
 898          */
 899         for_each_iommu(iommu, drhd) {
 900                 if (!ecap_ir_support(iommu->ecap))
 901                         continue;
 902
 903                 iommu_disable_irq_remapping(iommu);
 904         }
 905 }
 906
 907 static int reenable_irq_remapping(int eim)
 908 {
 909         struct dmar_drhd_unit *drhd;
 910         int setup = 0;
 911         struct intel_iommu *iommu = NULL;
 912
 913         for_each_iommu(iommu, drhd)
 914                 if (iommu->qi)
 915                         dmar_reenable_qi(iommu);
 916
 917         /*
 918          * Setup Interrupt-remapping for all the DRHD's now.
 919          */
 920         for_each_iommu(iommu, drhd) {
 921                 if (!ecap_ir_support(iommu->ecap))
 922                         continue;
 923
 924                 /* Set up interrupt remapping for iommu.*/
 925                 iommu_set_irq_remapping(iommu, eim);
 926                 setup = 1;
 927         }
 928
 929         if (!setup)
 930                 goto error;
 931
 932         return 0;
 933
 934 error:
 935         /*
 936          * handle error condition gracefully here!
 937          */
 938         return -1;
 939 }
 940
 941 static void prepare_irte(struct irte *irte, int vector,
 942                          unsigned int dest)
 943 {
 944         memset(irte, 0, sizeof(*irte));
 945
 946         irte->present = 1;
 947         irte->dst_mode = apic->irq_dest_mode;
 948         /*
 949          * Trigger mode in the IRTE will always be edge, and for IO-APIC, the
 950          * actual level or edge trigger will be setup in the IO-APIC
 951          * RTE. This will help simplify level triggered irq migration.
 952          * For more details, see the comments (in io_apic.c) explainig IO-APIC
 953          * irq migration in the presence of interrupt-remapping.
 954         */
 955         irte->trigger_mode = 0;
 956         irte->dlvry_mode = apic->irq_delivery_mode;
 957         irte->vector = vector;
 958         irte->dest_id = IRTE_DEST(dest);
 959         irte->redir_hint = 1;
 960 }
 961
 962 static int intel_setup_ioapic_entry(int irq,
 963                                     struct IO_APIC_route_entry *route_entry,
 964                                     unsigned int destination, int vector,
 965                                     struct io_apic_irq_attr *attr)
 966 {
 967         int ioapic_id = mpc_ioapic_id(attr->ioapic);
 968         struct intel_iommu *iommu;
 969         struct IR_IO_APIC_route_entry *entry;
 970         struct irte irte;
 971         int index;
 972
 973         down_read(&dmar_global_lock);
 974         iommu = map_ioapic_to_ir(ioapic_id);
 975         if (!iommu) {
 976                 pr_warn("No mapping iommu for ioapic %d\n", ioapic_id);
 977                 index = -ENODEV;
 978         } else {
 979                 index = alloc_irte(iommu, irq, 1);
 980                 if (index < 0) {
 981                         pr_warn("Failed to allocate IRTE for ioapic %d\n",
 982                                 ioapic_id);
 983                         index = -ENOMEM;
 984                 }
 985         }
 986         up_read(&dmar_global_lock);
 987         if (index < 0)
 988                 return index;
 989
 990         prepare_irte(&irte, vector, destination);
 991
 992         /* Set source-id of interrupt request */
 993         set_ioapic_sid(&irte, ioapic_id);
 994
 995         modify_irte(irq, &irte);
 996
 997         apic_printk(APIC_VERBOSE, KERN_DEBUG "IOAPIC[%d]: "
 998                 "Set IRTE entry (P:%d FPD:%d Dst_Mode:%d "
 999                 "Redir_hint:%d Trig_Mode:%d Dlvry_Mode:%X "
1000                 "Avail:%X Vector:%02X Dest:%08X "
1001                 "SID:%04X SQ:%X SVT:%X)\n",
1002                 attr->ioapic, irte.present, irte.fpd, irte.dst_mode,
1003                 irte.redir_hint, irte.trigger_mode, irte.dlvry_mode,
1004                 irte.avail, irte.vector, irte.dest_id,
1005                 irte.sid, irte.sq, irte.svt);
1006
1007         entry = (struct IR_IO_APIC_route_entry *)route_entry;
1008         memset(entry, 0, sizeof(*entry));
1009
1010         entry->index2   = (index >> 15) & 0x1;
1011         entry->zero     = 0;
1012         entry->format   = 1;
1013         entry->index    = (index & 0x7fff);
1014         /*
1015          * IO-APIC RTE will be configured with virtual vector.
1016          * irq handler will do the explicit EOI to the io-apic.
1017          */
1018         entry->vector   = attr->ioapic_pin;
1019         entry->mask     = 0;                    /* enable IRQ */
1020         entry->trigger  = attr->trigger;
1021         entry->polarity = attr->polarity;
1022
1023         /* Mask level triggered irqs.
1024          * Use IRQ_DELAYED_DISABLE for edge triggered irqs.
1025          */
1026         if (attr->trigger)
1027                 entry->mask = 1;
1028
1029         return 0;
1030 }
1031
1032 /*
1033  * Migrate the IO-APIC irq in the presence of intr-remapping.
1034  *
1035  * For both level and edge triggered, irq migration is a simple atomic
1036  * update(of vector and cpu destination) of IRTE and flush the hardware cache.
1037  *
1038  * For level triggered, we eliminate the io-apic RTE modification (with the
1039  * updated vector information), by using a virtual vector (io-apic pin number).
1040  * Real vector that is used for interrupting cpu will be coming from
1041  * the interrupt-remapping table entry.
1042  *
1043  * As the migration is a simple atomic update of IRTE, the same mechanism
1044  * is used to migrate MSI irq's in the presence of interrupt-remapping.
1045  */
1046 static int
1047 intel_ioapic_set_affinity(struct irq_data *data, const struct cpumask *mask,
1048                           bool force)
1049 {
1050         struct irq_cfg *cfg = irqd_cfg(data);
1051         unsigned int dest, irq = data->irq;
1052         struct irte irte;
1053         int err;
1054
1055         if (!config_enabled(CONFIG_SMP))
1056                 return -EINVAL;
1057
1058         if (!cpumask_intersects(mask, cpu_online_mask))
1059                 return -EINVAL;
1060
1061         if (get_irte(irq, &irte))
1062                 return -EBUSY;
1063
1064         err = assign_irq_vector(irq, cfg, mask);
1065         if (err)
1066                 return err;
1067
1068         err = apic->cpu_mask_to_apicid_and(cfg->domain, mask, &dest);
1069         if (err) {
1070                 if (assign_irq_vector(irq, cfg, data->affinity))
1071                         pr_err("Failed to recover vector for irq %d\n", irq);
1072                 return err;
1073         }
1074
1075         irte.vector = cfg->vector;
1076         irte.dest_id = IRTE_DEST(dest);
1077
1078         /*
1079          * Atomically updates the IRTE with the new destination, vector
1080          * and flushes the interrupt entry cache.
1081          */
1082         modify_irte(irq, &irte);
1083
1084         /*
1085          * After this point, all the interrupts will start arriving
1086          * at the new destination. So, time to cleanup the previous
1087          * vector allocation.
1088          */
1089         if (cfg->move_in_progress)
1090                 send_cleanup_vector(cfg);
1091
1092         cpumask_copy(data->affinity, mask);
1093         return 0;
1094 }
1095
1096 static void intel_compose_msi_msg(struct pci_dev *pdev,
1097                                   unsigned int irq, unsigned int dest,
1098                                   struct msi_msg *msg, u8 hpet_id)
1099 {
1100         struct irq_cfg *cfg;
1101         struct irte irte;
1102         u16 sub_handle = 0;
1103         int ir_index;
1104
1105         cfg = irq_cfg(irq);
1106
1107         ir_index = map_irq_to_irte_handle(irq, &sub_handle);
1108         BUG_ON(ir_index == -1);
1109
1110         prepare_irte(&irte, cfg->vector, dest);
1111
1112         /* Set source-id of interrupt request */
1113         if (pdev)
1114                 set_msi_sid(&irte, pdev);
1115         else
1116                 set_hpet_sid(&irte, hpet_id);
1117
1118         modify_irte(irq, &irte);
1119
1120         msg->address_hi = MSI_ADDR_BASE_HI;
1121         msg->data = sub_handle;
1122         msg->address_lo = MSI_ADDR_BASE_LO | MSI_ADDR_IR_EXT_INT |
1123                           MSI_ADDR_IR_SHV |
1124                           MSI_ADDR_IR_INDEX1(ir_index) |
1125                           MSI_ADDR_IR_INDEX2(ir_index);
1126 }
1127
1128 /*
1129  * Map the PCI dev to the corresponding remapping hardware unit
1130  * and allocate 'nvec' consecutive interrupt-remapping table entries
1131  * in it.
1132  */
1133 static int intel_msi_alloc_irq(struct pci_dev *dev, int irq, int nvec)
1134 {
1135         struct intel_iommu *iommu;
1136         int index;
1137
1138         down_read(&dmar_global_lock);
1139         iommu = map_dev_to_ir(dev);
1140         if (!iommu) {
1141                 printk(KERN_ERR
1142                        "Unable to map PCI %s to iommu\n", pci_name(dev));
1143                 index = -ENOENT;
1144         } else {
1145                 index = alloc_irte(iommu, irq, nvec);
1146                 if (index < 0) {
1147                         printk(KERN_ERR
1148                                "Unable to allocate %d IRTE for PCI %s\n",
1149                                nvec, pci_name(dev));
1150                         index = -ENOSPC;
1151                 }
1152         }
1153         up_read(&dmar_global_lock);
1154
1155         return index;
1156 }
1157
1158 static int intel_msi_setup_irq(struct pci_dev *pdev, unsigned int irq,
1159                                int index, int sub_handle)
1160 {
1161         struct intel_iommu *iommu;
1162         int ret = -ENOENT;
1163
1164         down_read(&dmar_global_lock);
1165         iommu = map_dev_to_ir(pdev);
1166         if (iommu) {
1167                 /*
1168                  * setup the mapping between the irq and the IRTE
1169                  * base index, the sub_handle pointing to the
1170                  * appropriate interrupt remap table entry.
1171                  */
1172                 set_irte_irq(irq, iommu, index, sub_handle);
1173                 ret = 0;
1174         }
1175         up_read(&dmar_global_lock);
1176
1177         return ret;
1178 }
1179
1180 static int intel_alloc_hpet_msi(unsigned int irq, unsigned int id)
1181 {
1182         int ret = -1;
1183         struct intel_iommu *iommu;
1184         int index;
1185
1186         down_read(&dmar_global_lock);
1187         iommu = map_hpet_to_ir(id);
1188         if (iommu) {
1189                 index = alloc_irte(iommu, irq, 1);
1190                 if (index >= 0)
1191                         ret = 0;
1192         }
1193         up_read(&dmar_global_lock);
1194
1195         return ret;
1196 }
1197
1198 struct irq_remap_ops intel_irq_remap_ops = {
1199         .supported              = intel_irq_remapping_supported,
1200         .prepare                = dmar_table_init,
1201         .enable                 = intel_enable_irq_remapping,
1202         .disable                = disable_irq_remapping,
1203         .reenable               = reenable_irq_remapping,
1204         .enable_faulting        = enable_drhd_fault_handling,
1205         .setup_ioapic_entry     = intel_setup_ioapic_entry,
1206         .set_affinity           = intel_ioapic_set_affinity,
1207         .free_irq               = free_irte,
1208         .compose_msi_msg        = intel_compose_msi_msg,
1209         .msi_alloc_irq          = intel_msi_alloc_irq,
1210         .msi_setup_irq          = intel_msi_setup_irq,
1211         .alloc_hpet_msi         = intel_alloc_hpet_msi,
1212 };
1213
1214 /*
1215  * Support of Interrupt Remapping Unit Hotplug
1216  */
1217 static int dmar_ir_add(struct dmar_drhd_unit *dmaru, struct intel_iommu *iommu)
1218 {
1219         int ret;
1220         int eim = x2apic_enabled();
1221
1222         if (eim && !ecap_eim_support(iommu->ecap)) {
1223                 pr_info("DRHD %Lx: EIM not supported by DRHD, ecap %Lx\n",
1224                         iommu->reg_phys, iommu->ecap);
1225                 return -ENODEV;
1226         }
1227
1228         if (ir_parse_ioapic_hpet_scope(dmaru->hdr, iommu)) {
1229                 pr_warn("DRHD %Lx: failed to parse managed IOAPIC/HPET\n",
1230                         iommu->reg_phys);
1231                 return -ENODEV;
1232         }
1233
1234         /* TODO: check all IOAPICs are covered by IOMMU */
1235
1236         /* Setup Interrupt-remapping now. */
1237         ret = intel_setup_irq_remapping(iommu);
1238         if (ret) {
1239                 pr_err("DRHD %Lx: failed to allocate resource\n",
1240                        iommu->reg_phys);
1241                 ir_remove_ioapic_hpet_scope(iommu);
1242                 return ret;
1243         }
1244
1245         if (!iommu->qi) {
1246                 /* Clear previous faults. */
1247                 dmar_fault(-1, iommu);
1248                 iommu_disable_irq_remapping(iommu);
1249                 dmar_disable_qi(iommu);
1250         }
1251
1252         /* Enable queued invalidation */
1253         ret = dmar_enable_qi(iommu);
1254         if (!ret) {
1255                 iommu_set_irq_remapping(iommu, eim);
1256         } else {
1257                 pr_err("DRHD %Lx: failed to enable queued invalidation, ecap %Lx, ret %d\n",
1258                        iommu->reg_phys, iommu->ecap, ret);
1259                 intel_teardown_irq_remapping(iommu);
1260                 ir_remove_ioapic_hpet_scope(iommu);
1261         }
1262
1263         return ret;
1264 }
1265
1266 int dmar_ir_hotplug(struct dmar_drhd_unit *dmaru, bool insert)
1267 {
1268         int ret = 0;
1269         struct intel_iommu *iommu = dmaru->iommu;
1270
1271         if (!irq_remapping_enabled)
1272                 return 0;
1273         if (iommu == NULL)
1274                 return -EINVAL;
1275         if (!ecap_ir_support(iommu->ecap))
1276                 return 0;
1277
1278         if (insert) {
1279                 if (!iommu->ir_table)
1280                         ret = dmar_ir_add(dmaru, iommu);
1281         } else {
1282                 if (iommu->ir_table) {
1283                         if (!bitmap_empty(iommu->ir_table->bitmap,
1284                                           INTR_REMAP_TABLE_ENTRIES)) {
1285                                 ret = -EBUSY;
1286                         } else {
1287                                 iommu_disable_irq_remapping(iommu);
1288                                 intel_teardown_irq_remapping(iommu);
1289                                 ir_remove_ioapic_hpet_scope(iommu);
1290                         }
1291                 }
1292         }
1293
1294         return ret;
1295 }