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