[PATCH] x86_64: Use function pointers to call DMA mapping functions
[linux-2.6.git] / 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 || !s->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 = *s; 
368                         sout->dma_address = iommu_bus_base;
369                         sout->dma_address += iommu_page*PAGE_SIZE + s->offset;
370                         sout->dma_length = s->length;
371                 } else { 
372                         sout->dma_length += s->length; 
373                 }
374
375                 addr = phys_addr;
376                 pages = to_pages(s->offset, s->length); 
377                 while (pages--) { 
378                         iommu_gatt_base[iommu_page] = GPTE_ENCODE(addr); 
379                         SET_LEAK(iommu_page);
380                         addr += PAGE_SIZE;
381                         iommu_page++;
382         } 
383         } 
384         BUG_ON(iommu_page - iommu_start != pages);      
385         return 0;
386 }
387
388 static inline int dma_map_cont(struct scatterlist *sg, int start, int stopat,
389                       struct scatterlist *sout,
390                       unsigned long pages, int need)
391 {
392         if (!need) { 
393                 BUG_ON(stopat - start != 1);
394                 *sout = sg[start]; 
395                 sout->dma_length = sg[start].length; 
396                 return 0;
397         } 
398         return __dma_map_cont(sg, start, stopat, sout, pages);
399 }
400                 
401 /*
402  * DMA map all entries in a scatterlist.
403  * Merge chunks that have page aligned sizes into a continuous mapping. 
404  */
405 int gart_map_sg(struct device *dev, struct scatterlist *sg, int nents, int dir)
406 {
407         int i;
408         int out;
409         int start;
410         unsigned long pages = 0;
411         int need = 0, nextneed;
412
413         BUG_ON(dir == DMA_NONE);
414         if (nents == 0) 
415                 return 0;
416
417         if (!dev)
418                 dev = &fallback_dev;
419
420         out = 0;
421         start = 0;
422         for (i = 0; i < nents; i++) {
423                 struct scatterlist *s = &sg[i];
424                 dma_addr_t addr = page_to_phys(s->page) + s->offset;
425                 s->dma_address = addr;
426                 BUG_ON(s->length == 0); 
427
428                 nextneed = need_iommu(dev, addr, s->length); 
429
430                 /* Handle the previous not yet processed entries */
431                 if (i > start) {
432                         struct scatterlist *ps = &sg[i-1];
433                         /* Can only merge when the last chunk ends on a page 
434                            boundary and the new one doesn't have an offset. */
435                         if (!iommu_merge || !nextneed || !need || s->offset ||
436                             (ps->offset + ps->length) % PAGE_SIZE) { 
437                                 if (dma_map_cont(sg, start, i, sg+out, pages,
438                                                  need) < 0)
439                                         goto error;
440                                 out++;
441                                 pages = 0;
442                                 start = i;      
443                         }
444                 }
445
446                 need = nextneed;
447                 pages += to_pages(s->offset, s->length);
448         }
449         if (dma_map_cont(sg, start, i, sg+out, pages, need) < 0)
450                 goto error;
451         out++;
452         flush_gart(dev);
453         if (out < nents) 
454                 sg[out].dma_length = 0; 
455         return out;
456
457 error:
458         flush_gart(NULL);
459         gart_unmap_sg(dev, sg, nents, dir);
460         /* When it was forced try again unforced */
461         if (force_iommu) 
462                 return dma_map_sg_nonforce(dev, sg, nents, dir);
463         if (panic_on_overflow)
464                 panic("dma_map_sg: overflow on %lu pages\n", pages);
465         iommu_full(dev, pages << PAGE_SHIFT, dir);
466         for (i = 0; i < nents; i++)
467                 sg[i].dma_address = bad_dma_address;
468         return 0;
469
470
471 /*
472  * Free a DMA mapping.
473  */ 
474 void gart_unmap_single(struct device *dev, dma_addr_t dma_addr,
475                       size_t size, int direction)
476 {
477         unsigned long iommu_page; 
478         int npages;
479         int i;
480
481         if (dma_addr < iommu_bus_base + EMERGENCY_PAGES*PAGE_SIZE || 
482             dma_addr >= iommu_bus_base + iommu_size)
483                 return;
484         iommu_page = (dma_addr - iommu_bus_base)>>PAGE_SHIFT;   
485         npages = to_pages(dma_addr, size);
486         for (i = 0; i < npages; i++) { 
487                 iommu_gatt_base[iommu_page + i] = gart_unmapped_entry; 
488                 CLEAR_LEAK(iommu_page + i);
489         }
490         free_iommu(iommu_page, npages);
491 }
492
493 static int no_agp;
494
495 static __init unsigned long check_iommu_size(unsigned long aper, u64 aper_size)
496
497         unsigned long a; 
498         if (!iommu_size) { 
499                 iommu_size = aper_size; 
500                 if (!no_agp) 
501                         iommu_size /= 2; 
502         } 
503
504         a = aper + iommu_size; 
505         iommu_size -= round_up(a, LARGE_PAGE_SIZE) - a;
506
507         if (iommu_size < 64*1024*1024) 
508                 printk(KERN_WARNING
509   "PCI-DMA: Warning: Small IOMMU %luMB. Consider increasing the AGP aperture in BIOS\n",iommu_size>>20); 
510         
511         return iommu_size;
512
513
514 static __init unsigned read_aperture(struct pci_dev *dev, u32 *size) 
515
516         unsigned aper_size = 0, aper_base_32;
517         u64 aper_base;
518         unsigned aper_order;
519
520         pci_read_config_dword(dev, 0x94, &aper_base_32); 
521         pci_read_config_dword(dev, 0x90, &aper_order);
522         aper_order = (aper_order >> 1) & 7;     
523
524         aper_base = aper_base_32 & 0x7fff; 
525         aper_base <<= 25;
526
527         aper_size = (32 * 1024 * 1024) << aper_order; 
528         if (aper_base + aper_size >= 0xffffffff || !aper_size)
529                 aper_base = 0;
530
531         *size = aper_size;
532         return aper_base;
533
534
535 /* 
536  * Private Northbridge GATT initialization in case we cannot use the
537  * AGP driver for some reason.  
538  */
539 static __init int init_k8_gatt(struct agp_kern_info *info)
540
541         struct pci_dev *dev;
542         void *gatt;
543         unsigned aper_base, new_aper_base;
544         unsigned aper_size, gatt_size, new_aper_size;
545         
546         printk(KERN_INFO "PCI-DMA: Disabling AGP.\n");
547         aper_size = aper_base = info->aper_size = 0;
548         for_all_nb(dev) { 
549                 new_aper_base = read_aperture(dev, &new_aper_size); 
550                 if (!new_aper_base) 
551                         goto nommu; 
552                 
553                 if (!aper_base) { 
554                         aper_size = new_aper_size;
555                         aper_base = new_aper_base;
556                 } 
557                 if (aper_size != new_aper_size || aper_base != new_aper_base) 
558                         goto nommu;
559         }
560         if (!aper_base)
561                 goto nommu; 
562         info->aper_base = aper_base;
563         info->aper_size = aper_size>>20; 
564
565         gatt_size = (aper_size >> PAGE_SHIFT) * sizeof(u32); 
566         gatt = (void *)__get_free_pages(GFP_KERNEL, get_order(gatt_size)); 
567         if (!gatt) 
568                 panic("Cannot allocate GATT table"); 
569         memset(gatt, 0, gatt_size); 
570         agp_gatt_table = gatt;
571         
572         for_all_nb(dev) { 
573                 u32 ctl; 
574                 u32 gatt_reg; 
575
576                 gatt_reg = __pa(gatt) >> 12; 
577                 gatt_reg <<= 4; 
578                 pci_write_config_dword(dev, 0x98, gatt_reg);
579                 pci_read_config_dword(dev, 0x90, &ctl); 
580
581                 ctl |= 1;
582                 ctl &= ~((1<<4) | (1<<5));
583
584                 pci_write_config_dword(dev, 0x90, ctl); 
585         }
586         flush_gart(NULL); 
587         
588         printk("PCI-DMA: aperture base @ %x size %u KB\n",aper_base, aper_size>>10); 
589         return 0;
590
591  nommu:
592         /* Should not happen anymore */
593         printk(KERN_ERR "PCI-DMA: More than 4GB of RAM and no IOMMU\n"
594                KERN_ERR "PCI-DMA: 32bit PCI IO may malfunction.\n");
595         return -1; 
596
597
598 extern int agp_amd64_init(void);
599
600 static struct dma_mapping_ops gart_dma_ops = {
601         .mapping_error = NULL,
602         .map_single = gart_map_single,
603         .map_simple = gart_map_simple,
604         .unmap_single = gart_unmap_single,
605         .sync_single_for_cpu = NULL,
606         .sync_single_for_device = NULL,
607         .sync_single_range_for_cpu = NULL,
608         .sync_single_range_for_device = NULL,
609         .sync_sg_for_cpu = NULL,
610         .sync_sg_for_device = NULL,
611         .map_sg = gart_map_sg,
612         .unmap_sg = gart_unmap_sg,
613 };
614
615 static int __init pci_iommu_init(void)
616
617         struct agp_kern_info info;
618         unsigned long aper_size;
619         unsigned long iommu_start;
620         struct pci_dev *dev;
621         unsigned long scratch;
622         long i;
623
624 #ifndef CONFIG_AGP_AMD64
625         no_agp = 1; 
626 #else
627         /* Makefile puts PCI initialization via subsys_initcall first. */
628         /* Add other K8 AGP bridge drivers here */
629         no_agp = no_agp || 
630                 (agp_amd64_init() < 0) || 
631                 (agp_copy_info(agp_bridge, &info) < 0);
632 #endif  
633
634         if (swiotlb) { 
635                 no_iommu = 1;
636                 return -1; 
637         } 
638         
639         if (no_iommu ||
640             (!force_iommu && end_pfn <= MAX_DMA32_PFN) ||
641             !iommu_aperture ||
642             (no_agp && init_k8_gatt(&info) < 0)) {
643                 no_iommu = 1;
644                 no_iommu_init();
645                 return -1;
646         }
647
648         aper_size = info.aper_size * 1024 * 1024;       
649         iommu_size = check_iommu_size(info.aper_base, aper_size); 
650         iommu_pages = iommu_size >> PAGE_SHIFT; 
651
652         iommu_gart_bitmap = (void*)__get_free_pages(GFP_KERNEL, 
653                                                     get_order(iommu_pages/8)); 
654         if (!iommu_gart_bitmap) 
655                 panic("Cannot allocate iommu bitmap\n"); 
656         memset(iommu_gart_bitmap, 0, iommu_pages/8);
657
658 #ifdef CONFIG_IOMMU_LEAK
659         if (leak_trace) { 
660                 iommu_leak_tab = (void *)__get_free_pages(GFP_KERNEL, 
661                                   get_order(iommu_pages*sizeof(void *)));
662                 if (iommu_leak_tab) 
663                         memset(iommu_leak_tab, 0, iommu_pages * 8); 
664                 else
665                         printk("PCI-DMA: Cannot allocate leak trace area\n"); 
666         } 
667 #endif
668
669         /* 
670          * Out of IOMMU space handling.
671          * Reserve some invalid pages at the beginning of the GART. 
672          */ 
673         set_bit_string(iommu_gart_bitmap, 0, EMERGENCY_PAGES); 
674
675         agp_memory_reserved = iommu_size;       
676         printk(KERN_INFO
677                "PCI-DMA: Reserving %luMB of IOMMU area in the AGP aperture\n",
678                iommu_size>>20); 
679
680         iommu_start = aper_size - iommu_size;   
681         iommu_bus_base = info.aper_base + iommu_start; 
682         bad_dma_address = iommu_bus_base;
683         iommu_gatt_base = agp_gatt_table + (iommu_start>>PAGE_SHIFT);
684
685         /* 
686          * Unmap the IOMMU part of the GART. The alias of the page is
687          * always mapped with cache enabled and there is no full cache
688          * coherency across the GART remapping. The unmapping avoids
689          * automatic prefetches from the CPU allocating cache lines in
690          * there. All CPU accesses are done via the direct mapping to
691          * the backing memory. The GART address is only used by PCI
692          * devices. 
693          */
694         clear_kernel_mapping((unsigned long)__va(iommu_bus_base), iommu_size);
695
696         /* 
697          * Try to workaround a bug (thanks to BenH) 
698          * Set unmapped entries to a scratch page instead of 0. 
699          * Any prefetches that hit unmapped entries won't get an bus abort
700          * then.
701          */
702         scratch = get_zeroed_page(GFP_KERNEL); 
703         if (!scratch) 
704                 panic("Cannot allocate iommu scratch page");
705         gart_unmapped_entry = GPTE_ENCODE(__pa(scratch));
706         for (i = EMERGENCY_PAGES; i < iommu_pages; i++) 
707                 iommu_gatt_base[i] = gart_unmapped_entry;
708
709         for_all_nb(dev) {
710                 u32 flag; 
711                 int cpu = PCI_SLOT(dev->devfn) - 24;
712                 if (cpu >= MAX_NB)
713                         continue;
714                 northbridges[cpu] = dev;
715                 pci_read_config_dword(dev, 0x9c, &flag); /* cache flush word */
716                 northbridge_flush_word[cpu] = flag; 
717         }
718                      
719         flush_gart(NULL);
720
721         printk(KERN_INFO "PCI-DMA: using GART IOMMU.\n");
722         dma_ops = &gart_dma_ops;
723
724         return 0;
725
726
727 /* Must execute after PCI subsystem */
728 fs_initcall(pci_iommu_init);
729
730 void gart_parse_options(char *p)
731 {
732         int arg;
733
734 #ifdef CONFIG_IOMMU_LEAK
735         if (!strncmp(p,"leak",4)) {
736                 leak_trace = 1;
737                 p += 4;
738                 if (*p == '=') ++p;
739                 if (isdigit(*p) && get_option(&p, &arg))
740                         iommu_leak_pages = arg;
741         }
742 #endif
743         if (isdigit(*p) && get_option(&p, &arg))
744                 iommu_size = arg;
745         if (!strncmp(p, "fullflush",8))
746                 iommu_fullflush = 1;
747         if (!strncmp(p, "nofullflush",11))
748                 iommu_fullflush = 0;
749         if (!strncmp(p,"noagp",5))
750                 no_agp = 1;
751         if (!strncmp(p, "noaperture",10))
752                 fix_aperture = 0;
753         /* duplicated from pci-dma.c */
754         if (!strncmp(p,"force",5))
755                 iommu_aperture_allowed = 1;
756         if (!strncmp(p,"allowed",7))
757                 iommu_aperture_allowed = 1;
758         if (!strncmp(p, "memaper", 7)) {
759                 fallback_aper_force = 1;
760                 p += 7;
761                 if (*p == '=') {
762                         ++p;
763                         if (get_option(&p, &arg))
764                                 fallback_aper_order = arg;
765                 }
766         }
767 }