git.oblomov.eu Git - linux-2.6/blob - arch/x86_64/kernel/pci-gart.c

   1 /*
   2  * Dynamic DMA mapping support for AMD Hammer.
   3  *
   4  * Use the integrated AGP GART in the Hammer northbridge as an IOMMU for PCI.
   5  * This allows to use PCI devices that only support 32bit addresses on systems
   6  * with more than 4GB.
   7  *
   8  * See Documentation/DMA-mapping.txt for the interface specification.
   9  *
  10  * Copyright 2002 Andi Kleen, SuSE Labs.
  11  */
  12
  13 #include <linux/config.h>
  14 #include <linux/types.h>
  15 #include <linux/ctype.h>
  16 #include <linux/agp_backend.h>
  17 #include <linux/init.h>
  18 #include <linux/mm.h>
  19 #include <linux/string.h>
  20 #include <linux/spinlock.h>
  21 #include <linux/pci.h>
  22 #include <linux/module.h>
  23 #include <linux/topology.h>
  24 #include <linux/interrupt.h>
  25 #include <linux/bitops.h>
  26 #include <asm/atomic.h>
  27 #include <asm/io.h>
  28 #include <asm/mtrr.h>
  29 #include <asm/pgtable.h>
  30 #include <asm/proto.h>
  31 #include <asm/cacheflush.h>
  32 #include <asm/kdebug.h>
  33 #include <asm/swiotlb.h>
  34 #include <asm/dma.h>
  35 #include <asm/k8.h>
  36
  37 unsigned long iommu_bus_base;   /* GART remapping area (physical) */
  38 static unsigned long iommu_size;        /* size of remapping area bytes */
  39 static unsigned long iommu_pages;       /* .. and in pages */
  40
  41 u32 *iommu_gatt_base;           /* Remapping table */
  42
  43 /* If this is disabled the IOMMU will use an optimized flushing strategy
  44    of only flushing when an mapping is reused. With it true the GART is flushed
  45    for every mapping. Problem is that doing the lazy flush seems to trigger
  46    bugs with some popular PCI cards, in particular 3ware (but has been also
  47    also seen with Qlogic at least). */
  48 int iommu_fullflush = 1;
  49
  50 /* Allocation bitmap for the remapping area */
  51 static DEFINE_SPINLOCK(iommu_bitmap_lock);
  52 static unsigned long *iommu_gart_bitmap; /* guarded by iommu_bitmap_lock */
  53
  54 static u32 gart_unmapped_entry;
  55
  56 #define GPTE_VALID    1
  57 #define GPTE_COHERENT 2
  58 #define GPTE_ENCODE(x) \
  59         (((x) & 0xfffff000) | (((x) >> 32) << 4) | GPTE_VALID | GPTE_COHERENT)
  60 #define GPTE_DECODE(x) (((x) & 0xfffff000) | (((u64)(x) & 0xff0) << 28))
  61
  62 #define to_pages(addr,size) \
  63         (round_up(((addr) & ~PAGE_MASK) + (size), PAGE_SIZE) >> PAGE_SHIFT)
  64
  65 #define EMERGENCY_PAGES 32 /* = 128KB */
  66
  67 #ifdef CONFIG_AGP
  68 #define AGPEXTERN extern
  69 #else
  70 #define AGPEXTERN
  71 #endif
  72
  73 /* backdoor interface to AGP driver */
  74 AGPEXTERN int agp_memory_reserved;
  75 AGPEXTERN __u32 *agp_gatt_table;
  76
  77 static unsigned long next_bit;  /* protected by iommu_bitmap_lock */
  78 static int need_flush;          /* global flush state. set for each gart wrap */
  79
  80 static unsigned long alloc_iommu(int size)
  81 {
  82         unsigned long offset, flags;
  83
  84         spin_lock_irqsave(&iommu_bitmap_lock, flags);
  85         offset = find_next_zero_string(iommu_gart_bitmap,next_bit,iommu_pages,size);
  86         if (offset == -1) {
  87                 need_flush = 1;
  88                 offset = find_next_zero_string(iommu_gart_bitmap,0,iommu_pages,size);
  89         }
  90         if (offset != -1) {
  91                 set_bit_string(iommu_gart_bitmap, offset, size);
  92                 next_bit = offset+size;
  93                 if (next_bit >= iommu_pages) {
  94                         next_bit = 0;
  95                         need_flush = 1;
  96                 }
  97         }
  98         if (iommu_fullflush)
  99                 need_flush = 1;
 100         spin_unlock_irqrestore(&iommu_bitmap_lock, flags);
 101         return offset;
 102 }
 103
 104 static void free_iommu(unsigned long offset, int size)
 105 {
 106         unsigned long flags;
 107         spin_lock_irqsave(&iommu_bitmap_lock, flags);
 108         __clear_bit_string(iommu_gart_bitmap, offset, size);
 109         spin_unlock_irqrestore(&iommu_bitmap_lock, flags);
 110 }
 111
 112 /*
 113  * Use global flush state to avoid races with multiple flushers.
 114  */
 115 static void flush_gart(void)
 116 {
 117         unsigned long flags;
 118         spin_lock_irqsave(&iommu_bitmap_lock, flags);
 119         if (need_flush) {
 120                 k8_flush_garts();
 121                 need_flush = 0;
 122         }
 123         spin_unlock_irqrestore(&iommu_bitmap_lock, flags);
 124 }
 125
 126 #ifdef CONFIG_IOMMU_LEAK
 127
 128 #define SET_LEAK(x) if (iommu_leak_tab) \
 129                         iommu_leak_tab[x] = __builtin_return_address(0);
 130 #define CLEAR_LEAK(x) if (iommu_leak_tab) \
 131                         iommu_leak_tab[x] = NULL;
 132
 133 /* Debugging aid for drivers that don't free their IOMMU tables */
 134 static void **iommu_leak_tab;
 135 static int leak_trace;
 136 int iommu_leak_pages = 20;
 137 void dump_leak(void)
 138 {
 139         int i;
 140         static int dump;
 141         if (dump || !iommu_leak_tab) return;
 142         dump = 1;
 143         show_stack(NULL,NULL);
 144         /* Very crude. dump some from the end of the table too */
 145         printk("Dumping %d pages from end of IOMMU:\n", iommu_leak_pages);
 146         for (i = 0; i < iommu_leak_pages; i+=2) {
 147                 printk("%lu: ", iommu_pages-i);
 148                 printk_address((unsigned long) iommu_leak_tab[iommu_pages-i]);
 149                 printk("%c", (i+1)%2 == 0 ? '\n' : ' ');
 150         }
 151         printk("\n");
 152 }
 153 #else
 154 #define SET_LEAK(x)
 155 #define CLEAR_LEAK(x)
 156 #endif
 157
 158 static void iommu_full(struct device *dev, size_t size, int dir)
 159 {
 160         /*
 161          * Ran out of IOMMU space for this operation. This is very bad.
 162          * Unfortunately the drivers cannot handle this operation properly.
 163          * Return some non mapped prereserved space in the aperture and
 164          * let the Northbridge deal with it. This will result in garbage
 165          * in the IO operation. When the size exceeds the prereserved space
 166          * memory corruption will occur or random memory will be DMAed
 167          * out. Hopefully no network devices use single mappings that big.
 168          */
 169
 170         printk(KERN_ERR
 171   "PCI-DMA: Out of IOMMU space for %lu bytes at device %s\n",
 172                size, dev->bus_id);
 173
 174         if (size > PAGE_SIZE*EMERGENCY_PAGES) {
 175                 if (dir == PCI_DMA_FROMDEVICE || dir == PCI_DMA_BIDIRECTIONAL)
 176                         panic("PCI-DMA: Memory would be corrupted\n");
 177                 if (dir == PCI_DMA_TODEVICE || dir == PCI_DMA_BIDIRECTIONAL)
 178                         panic(KERN_ERR "PCI-DMA: Random memory would be DMAed\n");
 179         }
 180
 181 #ifdef CONFIG_IOMMU_LEAK
 182         dump_leak();
 183 #endif
 184 }
 185
 186 static inline int need_iommu(struct device *dev, unsigned long addr, size_t size)
 187 {
 188         u64 mask = *dev->dma_mask;
 189         int high = addr + size >= mask;
 190         int mmu = high;
 191         if (force_iommu)
 192                 mmu = 1;
 193         return mmu;
 194 }
 195
 196 static inline int nonforced_iommu(struct device *dev, unsigned long addr, size_t size)
 197 {
 198         u64 mask = *dev->dma_mask;
 199         int high = addr + size >= mask;
 200         int mmu = high;
 201         return mmu;
 202 }
 203
 204 /* Map a single continuous physical area into the IOMMU.
 205  * Caller needs to check if the iommu is needed and flush.
 206  */
 207 static dma_addr_t dma_map_area(struct device *dev, dma_addr_t phys_mem,
 208                                 size_t size, int dir)
 209 {
 210         unsigned long npages = to_pages(phys_mem, size);
 211         unsigned long iommu_page = alloc_iommu(npages);
 212         int i;
 213         if (iommu_page == -1) {
 214                 if (!nonforced_iommu(dev, phys_mem, size))
 215                         return phys_mem;
 216                 if (panic_on_overflow)
 217                         panic("dma_map_area overflow %lu bytes\n", size);
 218                 iommu_full(dev, size, dir);
 219                 return bad_dma_address;
 220         }
 221
 222         for (i = 0; i < npages; i++) {
 223                 iommu_gatt_base[iommu_page + i] = GPTE_ENCODE(phys_mem);
 224                 SET_LEAK(iommu_page + i);
 225                 phys_mem += PAGE_SIZE;
 226         }
 227         return iommu_bus_base + iommu_page*PAGE_SIZE + (phys_mem & ~PAGE_MASK);
 228 }
 229
 230 static dma_addr_t gart_map_simple(struct device *dev, char *buf,
 231                                  size_t size, int dir)
 232 {
 233         dma_addr_t map = dma_map_area(dev, virt_to_bus(buf), size, dir);
 234         flush_gart();
 235         return map;
 236 }
 237
 238 /* Map a single area into the IOMMU */
 239 dma_addr_t gart_map_single(struct device *dev, void *addr, size_t size, int dir)
 240 {
 241         unsigned long phys_mem, bus;
 242
 243         BUG_ON(dir == DMA_NONE);
 244
 245         if (!dev)
 246                 dev = &fallback_dev;
 247
 248         phys_mem = virt_to_phys(addr);
 249         if (!need_iommu(dev, phys_mem, size))
 250                 return phys_mem;
 251
 252         bus = gart_map_simple(dev, addr, size, dir);
 253         return bus;
 254 }
 255
 256 /*
 257  * Free a DMA mapping.
 258  */
 259 void gart_unmap_single(struct device *dev, dma_addr_t dma_addr,
 260                       size_t size, int direction)
 261 {
 262         unsigned long iommu_page;
 263         int npages;
 264         int i;
 265
 266         if (dma_addr < iommu_bus_base + EMERGENCY_PAGES*PAGE_SIZE ||
 267             dma_addr >= iommu_bus_base + iommu_size)
 268                 return;
 269         iommu_page = (dma_addr - iommu_bus_base)>>PAGE_SHIFT;
 270         npages = to_pages(dma_addr, size);
 271         for (i = 0; i < npages; i++) {
 272                 iommu_gatt_base[iommu_page + i] = gart_unmapped_entry;
 273                 CLEAR_LEAK(iommu_page + i);
 274         }
 275         free_iommu(iommu_page, npages);
 276 }
 277
 278 /*
 279  * Wrapper for pci_unmap_single working with scatterlists.
 280  */
 281 void gart_unmap_sg(struct device *dev, struct scatterlist *sg, int nents, int dir)
 282 {
 283         int i;
 284
 285         for (i = 0; i < nents; i++) {
 286                 struct scatterlist *s = &sg[i];
 287                 if (!s->dma_length || !s->length)
 288                         break;
 289                 gart_unmap_single(dev, s->dma_address, s->dma_length, dir);
 290         }
 291 }
 292
 293 /* Fallback for dma_map_sg in case of overflow */
 294 static int dma_map_sg_nonforce(struct device *dev, struct scatterlist *sg,
 295                                int nents, int dir)
 296 {
 297         int i;
 298
 299 #ifdef CONFIG_IOMMU_DEBUG
 300         printk(KERN_DEBUG "dma_map_sg overflow\n");
 301 #endif
 302
 303         for (i = 0; i < nents; i++ ) {
 304                 struct scatterlist *s = &sg[i];
 305                 unsigned long addr = page_to_phys(s->page) + s->offset;
 306                 if (nonforced_iommu(dev, addr, s->length)) {
 307                         addr = dma_map_area(dev, addr, s->length, dir);
 308                         if (addr == bad_dma_address) {
 309                                 if (i > 0)
 310                                         gart_unmap_sg(dev, sg, i, dir);
 311                                 nents = 0;
 312                                 sg[0].dma_length = 0;
 313                                 break;
 314                         }
 315                 }
 316                 s->dma_address = addr;
 317                 s->dma_length = s->length;
 318         }
 319         flush_gart();
 320         return nents;
 321 }
 322
 323 /* Map multiple scatterlist entries continuous into the first. */
 324 static int __dma_map_cont(struct scatterlist *sg, int start, int stopat,
 325                       struct scatterlist *sout, unsigned long pages)
 326 {
 327         unsigned long iommu_start = alloc_iommu(pages);
 328         unsigned long iommu_page = iommu_start;
 329         int i;
 330
 331         if (iommu_start == -1)
 332                 return -1;
 333
 334         for (i = start; i < stopat; i++) {
 335                 struct scatterlist *s = &sg[i];
 336                 unsigned long pages, addr;
 337                 unsigned long phys_addr = s->dma_address;
 338
 339                 BUG_ON(i > start && s->offset);
 340                 if (i == start) {
 341                         *sout = *s;
 342                         sout->dma_address = iommu_bus_base;
 343                         sout->dma_address += iommu_page*PAGE_SIZE + s->offset;
 344                         sout->dma_length = s->length;
 345                 } else {
 346                         sout->dma_length += s->length;
 347                 }
 348
 349                 addr = phys_addr;
 350                 pages = to_pages(s->offset, s->length);
 351                 while (pages--) {
 352                         iommu_gatt_base[iommu_page] = GPTE_ENCODE(addr);
 353                         SET_LEAK(iommu_page);
 354                         addr += PAGE_SIZE;
 355                         iommu_page++;
 356                 }
 357         }
 358         BUG_ON(iommu_page - iommu_start != pages);
 359         return 0;
 360 }
 361
 362 static inline int dma_map_cont(struct scatterlist *sg, int start, int stopat,
 363                       struct scatterlist *sout,
 364                       unsigned long pages, int need)
 365 {
 366         if (!need) {
 367                 BUG_ON(stopat - start != 1);
 368                 *sout = sg[start];
 369                 sout->dma_length = sg[start].length;
 370                 return 0;
 371         }
 372         return __dma_map_cont(sg, start, stopat, sout, pages);
 373 }
 374
 375 /*
 376  * DMA map all entries in a scatterlist.
 377  * Merge chunks that have page aligned sizes into a continuous mapping.
 378  */
 379 int gart_map_sg(struct device *dev, struct scatterlist *sg, int nents, int dir)
 380 {
 381         int i;
 382         int out;
 383         int start;
 384         unsigned long pages = 0;
 385         int need = 0, nextneed;
 386
 387         BUG_ON(dir == DMA_NONE);
 388         if (nents == 0)
 389                 return 0;
 390
 391         if (!dev)
 392                 dev = &fallback_dev;
 393
 394         out = 0;
 395         start = 0;
 396         for (i = 0; i < nents; i++) {
 397                 struct scatterlist *s = &sg[i];
 398                 dma_addr_t addr = page_to_phys(s->page) + s->offset;
 399                 s->dma_address = addr;
 400                 BUG_ON(s->length == 0);
 401
 402                 nextneed = need_iommu(dev, addr, s->length);
 403
 404                 /* Handle the previous not yet processed entries */
 405                 if (i > start) {
 406                         struct scatterlist *ps = &sg[i-1];
 407                         /* Can only merge when the last chunk ends on a page
 408                            boundary and the new one doesn't have an offset. */
 409                         if (!iommu_merge || !nextneed || !need || s->offset ||
 410                             (ps->offset + ps->length) % PAGE_SIZE) {
 411                                 if (dma_map_cont(sg, start, i, sg+out, pages,
 412                                                  need) < 0)
 413                                         goto error;
 414                                 out++;
 415                                 pages = 0;
 416                                 start = i;
 417                         }
 418                 }
 419
 420                 need = nextneed;
 421                 pages += to_pages(s->offset, s->length);
 422         }
 423         if (dma_map_cont(sg, start, i, sg+out, pages, need) < 0)
 424                 goto error;
 425         out++;
 426         flush_gart();
 427         if (out < nents)
 428                 sg[out].dma_length = 0;
 429         return out;
 430
 431 error:
 432         flush_gart();
 433         gart_unmap_sg(dev, sg, nents, dir);
 434         /* When it was forced or merged try again in a dumb way */
 435         if (force_iommu || iommu_merge) {
 436                 out = dma_map_sg_nonforce(dev, sg, nents, dir);
 437                 if (out > 0)
 438                         return out;
 439         }
 440         if (panic_on_overflow)
 441                 panic("dma_map_sg: overflow on %lu pages\n", pages);
 442         iommu_full(dev, pages << PAGE_SHIFT, dir);
 443         for (i = 0; i < nents; i++)
 444                 sg[i].dma_address = bad_dma_address;
 445         return 0;
 446 }
 447
 448 static int no_agp;
 449
 450 static __init unsigned long check_iommu_size(unsigned long aper, u64 aper_size)
 451 {
 452         unsigned long a;
 453         if (!iommu_size) {
 454                 iommu_size = aper_size;
 455                 if (!no_agp)
 456                         iommu_size /= 2;
 457         }
 458
 459         a = aper + iommu_size;
 460         iommu_size -= round_up(a, LARGE_PAGE_SIZE) - a;
 461
 462         if (iommu_size < 64*1024*1024)
 463                 printk(KERN_WARNING
 464   "PCI-DMA: Warning: Small IOMMU %luMB. Consider increasing the AGP aperture in BIOS\n",iommu_size>>20);
 465
 466         return iommu_size;
 467 }
 468
 469 static __init unsigned read_aperture(struct pci_dev *dev, u32 *size)
 470 {
 471         unsigned aper_size = 0, aper_base_32;
 472         u64 aper_base;
 473         unsigned aper_order;
 474
 475         pci_read_config_dword(dev, 0x94, &aper_base_32);
 476         pci_read_config_dword(dev, 0x90, &aper_order);
 477         aper_order = (aper_order >> 1) & 7;
 478
 479         aper_base = aper_base_32 & 0x7fff;
 480         aper_base <<= 25;
 481
 482         aper_size = (32 * 1024 * 1024) << aper_order;
 483         if (aper_base + aper_size >= 0xffffffff || !aper_size)
 484                 aper_base = 0;
 485
 486         *size = aper_size;
 487         return aper_base;
 488 }
 489
 490 /*
 491  * Private Northbridge GATT initialization in case we cannot use the
 492  * AGP driver for some reason.
 493  */
 494 static __init int init_k8_gatt(struct agp_kern_info *info)
 495 {
 496         struct pci_dev *dev;
 497         void *gatt;
 498         unsigned aper_base, new_aper_base;
 499         unsigned aper_size, gatt_size, new_aper_size;
 500         int i;
 501
 502         printk(KERN_INFO "PCI-DMA: Disabling AGP.\n");
 503         aper_size = aper_base = info->aper_size = 0;
 504         dev = NULL;
 505         for (i = 0; i < num_k8_northbridges; i++) {
 506                 dev = k8_northbridges[i];
 507                 new_aper_base = read_aperture(dev, &new_aper_size);
 508                 if (!new_aper_base)
 509                         goto nommu;
 510
 511                 if (!aper_base) {
 512                         aper_size = new_aper_size;
 513                         aper_base = new_aper_base;
 514                 }
 515                 if (aper_size != new_aper_size || aper_base != new_aper_base)
 516                         goto nommu;
 517         }
 518         if (!aper_base)
 519                 goto nommu;
 520         info->aper_base = aper_base;
 521         info->aper_size = aper_size>>20;
 522
 523         gatt_size = (aper_size >> PAGE_SHIFT) * sizeof(u32);
 524         gatt = (void *)__get_free_pages(GFP_KERNEL, get_order(gatt_size));
 525         if (!gatt)
 526                 panic("Cannot allocate GATT table");
 527         memset(gatt, 0, gatt_size);
 528         agp_gatt_table = gatt;
 529
 530         for (i = 0; i < num_k8_northbridges; i++) {
 531                 u32 ctl;
 532                 u32 gatt_reg;
 533
 534                 dev = k8_northbridges[i];
 535                 gatt_reg = __pa(gatt) >> 12;
 536                 gatt_reg <<= 4;
 537                 pci_write_config_dword(dev, 0x98, gatt_reg);
 538                 pci_read_config_dword(dev, 0x90, &ctl);
 539
 540                 ctl |= 1;
 541                 ctl &= ~((1<<4) | (1<<5));
 542
 543                 pci_write_config_dword(dev, 0x90, ctl);
 544         }
 545         flush_gart();
 546
 547         printk("PCI-DMA: aperture base @ %x size %u KB\n",aper_base, aper_size>>10);
 548         return 0;
 549
 550  nommu:
 551         /* Should not happen anymore */
 552         printk(KERN_ERR "PCI-DMA: More than 4GB of RAM and no IOMMU\n"
 553                KERN_ERR "PCI-DMA: 32bit PCI IO may malfunction.\n");
 554         return -1;
 555 }
 556
 557 extern int agp_amd64_init(void);
 558
 559 static struct dma_mapping_ops gart_dma_ops = {
 560         .mapping_error = NULL,
 561         .map_single = gart_map_single,
 562         .map_simple = gart_map_simple,
 563         .unmap_single = gart_unmap_single,
 564         .sync_single_for_cpu = NULL,
 565         .sync_single_for_device = NULL,
 566         .sync_single_range_for_cpu = NULL,
 567         .sync_single_range_for_device = NULL,
 568         .sync_sg_for_cpu = NULL,
 569         .sync_sg_for_device = NULL,
 570         .map_sg = gart_map_sg,
 571         .unmap_sg = gart_unmap_sg,
 572 };
 573
 574 void __init gart_iommu_init(void)
 575 {
 576         struct agp_kern_info info;
 577         unsigned long aper_size;
 578         unsigned long iommu_start;
 579         unsigned long scratch;
 580         long i;
 581
 582         if (cache_k8_northbridges() < 0 || num_k8_northbridges == 0) {
 583                 printk(KERN_INFO "PCI-GART: No AMD northbridge found.\n");
 584                 return;
 585         }
 586
 587 #ifndef CONFIG_AGP_AMD64
 588         no_agp = 1;
 589 #else
 590         /* Makefile puts PCI initialization via subsys_initcall first. */
 591         /* Add other K8 AGP bridge drivers here */
 592         no_agp = no_agp ||
 593                 (agp_amd64_init() < 0) ||
 594                 (agp_copy_info(agp_bridge, &info) < 0);
 595 #endif
 596
 597         if (swiotlb)
 598                 return;
 599
 600         /* Did we detect a different HW IOMMU? */
 601         if (iommu_detected && !iommu_aperture)
 602                 return;
 603
 604         if (no_iommu ||
 605             (!force_iommu && end_pfn <= MAX_DMA32_PFN) ||
 606             !iommu_aperture ||
 607             (no_agp && init_k8_gatt(&info) < 0)) {
 608                 printk(KERN_INFO "PCI-DMA: Disabling IOMMU.\n");
 609                 if (end_pfn > MAX_DMA32_PFN) {
 610                         printk(KERN_ERR "WARNING more than 4GB of memory "
 611                                         "but IOMMU not available.\n"
 612                                KERN_ERR "WARNING 32bit PCI may malfunction.\n");
 613                 }
 614                 return;
 615         }
 616
 617         printk(KERN_INFO "PCI-DMA: using GART IOMMU.\n");
 618         aper_size = info.aper_size * 1024 * 1024;
 619         iommu_size = check_iommu_size(info.aper_base, aper_size);
 620         iommu_pages = iommu_size >> PAGE_SHIFT;
 621
 622         iommu_gart_bitmap = (void*)__get_free_pages(GFP_KERNEL,
 623                                                     get_order(iommu_pages/8));
 624         if (!iommu_gart_bitmap)
 625                 panic("Cannot allocate iommu bitmap\n");
 626         memset(iommu_gart_bitmap, 0, iommu_pages/8);
 627
 628 #ifdef CONFIG_IOMMU_LEAK
 629         if (leak_trace) {
 630                 iommu_leak_tab = (void *)__get_free_pages(GFP_KERNEL,
 631                                   get_order(iommu_pages*sizeof(void *)));
 632                 if (iommu_leak_tab)
 633                         memset(iommu_leak_tab, 0, iommu_pages * 8);
 634                 else
 635                         printk("PCI-DMA: Cannot allocate leak trace area\n");
 636         }
 637 #endif
 638
 639         /*
 640          * Out of IOMMU space handling.
 641          * Reserve some invalid pages at the beginning of the GART.
 642          */
 643         set_bit_string(iommu_gart_bitmap, 0, EMERGENCY_PAGES);
 644
 645         agp_memory_reserved = iommu_size;
 646         printk(KERN_INFO
 647                "PCI-DMA: Reserving %luMB of IOMMU area in the AGP aperture\n",
 648                iommu_size>>20);
 649
 650         iommu_start = aper_size - iommu_size;
 651         iommu_bus_base = info.aper_base + iommu_start;
 652         bad_dma_address = iommu_bus_base;
 653         iommu_gatt_base = agp_gatt_table + (iommu_start>>PAGE_SHIFT);
 654
 655         /*
 656          * Unmap the IOMMU part of the GART. The alias of the page is
 657          * always mapped with cache enabled and there is no full cache
 658          * coherency across the GART remapping. The unmapping avoids
 659          * automatic prefetches from the CPU allocating cache lines in
 660          * there. All CPU accesses are done via the direct mapping to
 661          * the backing memory. The GART address is only used by PCI
 662          * devices.
 663          */
 664         clear_kernel_mapping((unsigned long)__va(iommu_bus_base), iommu_size);
 665
 666         /*
 667          * Try to workaround a bug (thanks to BenH)
 668          * Set unmapped entries to a scratch page instead of 0.
 669          * Any prefetches that hit unmapped entries won't get an bus abort
 670          * then.
 671          */
 672         scratch = get_zeroed_page(GFP_KERNEL);
 673         if (!scratch)
 674                 panic("Cannot allocate iommu scratch page");
 675         gart_unmapped_entry = GPTE_ENCODE(__pa(scratch));
 676         for (i = EMERGENCY_PAGES; i < iommu_pages; i++)
 677                 iommu_gatt_base[i] = gart_unmapped_entry;
 678
 679         flush_gart();
 680         dma_ops = &gart_dma_ops;
 681 }
 682
 683 void gart_parse_options(char *p)
 684 {
 685         int arg;
 686
 687 #ifdef CONFIG_IOMMU_LEAK
 688         if (!strncmp(p,"leak",4)) {
 689                 leak_trace = 1;
 690                 p += 4;
 691                 if (*p == '=') ++p;
 692                 if (isdigit(*p) && get_option(&p, &arg))
 693                         iommu_leak_pages = arg;
 694         }
 695 #endif
 696         if (isdigit(*p) && get_option(&p, &arg))
 697                 iommu_size = arg;
 698         if (!strncmp(p, "fullflush",8))
 699                 iommu_fullflush = 1;
 700         if (!strncmp(p, "nofullflush",11))
 701                 iommu_fullflush = 0;
 702         if (!strncmp(p,"noagp",5))
 703                 no_agp = 1;
 704         if (!strncmp(p, "noaperture",10))
 705                 fix_aperture = 0;
 706         /* duplicated from pci-dma.c */
 707         if (!strncmp(p,"force",5))
 708                 iommu_aperture_allowed = 1;
 709         if (!strncmp(p,"allowed",7))
 710                 iommu_aperture_allowed = 1;
 711         if (!strncmp(p, "memaper", 7)) {
 712                 fallback_aper_force = 1;
 713                 p += 7;
 714                 if (*p == '=') {
 715                         ++p;
 716                         if (get_option(&p, &arg))
 717                                 fallback_aper_order = arg;
 718                 }
 719         }
 720 }