Linux-2.6.12-rc2
[linux-2.6.git] / arch / alpha / kernel / pci_iommu.c
1 /*
2  *      linux/arch/alpha/kernel/pci_iommu.c
3  */
4
5 #include <linux/kernel.h>
6 #include <linux/mm.h>
7 #include <linux/pci.h>
8 #include <linux/slab.h>
9 #include <linux/bootmem.h>
10
11 #include <asm/io.h>
12 #include <asm/hwrpb.h>
13
14 #include "proto.h"
15 #include "pci_impl.h"
16
17
18 #define DEBUG_ALLOC 0
19 #if DEBUG_ALLOC > 0
20 # define DBGA(args...)          printk(KERN_DEBUG args)
21 #else
22 # define DBGA(args...)
23 #endif
24 #if DEBUG_ALLOC > 1
25 # define DBGA2(args...)         printk(KERN_DEBUG args)
26 #else
27 # define DBGA2(args...)
28 #endif
29
30 #define DEBUG_NODIRECT 0
31 #define DEBUG_FORCEDAC 0
32
33 #define ISA_DMA_MASK            0x00ffffff
34
35 static inline unsigned long
36 mk_iommu_pte(unsigned long paddr)
37 {
38         return (paddr >> (PAGE_SHIFT-1)) | 1;
39 }
40
41 static inline long
42 calc_npages(long bytes)
43 {
44         return (bytes + PAGE_SIZE - 1) >> PAGE_SHIFT;
45 }
46 \f
47
48 /* Return the minimum of MAX or the first power of two larger
49    than main memory.  */
50
51 unsigned long
52 size_for_memory(unsigned long max)
53 {
54         unsigned long mem = max_low_pfn << PAGE_SHIFT;
55         if (mem < max)
56                 max = 1UL << ceil_log2(mem);
57         return max;
58 }
59 \f
60 struct pci_iommu_arena *
61 iommu_arena_new_node(int nid, struct pci_controller *hose, dma_addr_t base,
62                      unsigned long window_size, unsigned long align)
63 {
64         unsigned long mem_size;
65         struct pci_iommu_arena *arena;
66
67         mem_size = window_size / (PAGE_SIZE / sizeof(unsigned long));
68
69         /* Note that the TLB lookup logic uses bitwise concatenation,
70            not addition, so the required arena alignment is based on
71            the size of the window.  Retain the align parameter so that
72            particular systems can over-align the arena.  */
73         if (align < mem_size)
74                 align = mem_size;
75
76
77 #ifdef CONFIG_DISCONTIGMEM
78
79         if (!NODE_DATA(nid) ||
80             (NULL == (arena = alloc_bootmem_node(NODE_DATA(nid),
81                                                  sizeof(*arena))))) {
82                 printk("%s: couldn't allocate arena from node %d\n"
83                        "    falling back to system-wide allocation\n",
84                        __FUNCTION__, nid);
85                 arena = alloc_bootmem(sizeof(*arena));
86         }
87
88         if (!NODE_DATA(nid) ||
89             (NULL == (arena->ptes = __alloc_bootmem_node(NODE_DATA(nid),
90                                                          mem_size,
91                                                          align,
92                                                          0)))) {
93                 printk("%s: couldn't allocate arena ptes from node %d\n"
94                        "    falling back to system-wide allocation\n",
95                        __FUNCTION__, nid);
96                 arena->ptes = __alloc_bootmem(mem_size, align, 0);
97         }
98
99 #else /* CONFIG_DISCONTIGMEM */
100
101         arena = alloc_bootmem(sizeof(*arena));
102         arena->ptes = __alloc_bootmem(mem_size, align, 0);
103
104 #endif /* CONFIG_DISCONTIGMEM */
105
106         spin_lock_init(&arena->lock);
107         arena->hose = hose;
108         arena->dma_base = base;
109         arena->size = window_size;
110         arena->next_entry = 0;
111
112         /* Align allocations to a multiple of a page size.  Not needed
113            unless there are chip bugs.  */
114         arena->align_entry = 1;
115
116         return arena;
117 }
118
119 struct pci_iommu_arena *
120 iommu_arena_new(struct pci_controller *hose, dma_addr_t base,
121                 unsigned long window_size, unsigned long align)
122 {
123         return iommu_arena_new_node(0, hose, base, window_size, align);
124 }
125
126 /* Must be called with the arena lock held */
127 static long
128 iommu_arena_find_pages(struct pci_iommu_arena *arena, long n, long mask)
129 {
130         unsigned long *ptes;
131         long i, p, nent;
132
133         /* Search forward for the first mask-aligned sequence of N free ptes */
134         ptes = arena->ptes;
135         nent = arena->size >> PAGE_SHIFT;
136         p = (arena->next_entry + mask) & ~mask;
137         i = 0;
138         while (i < n && p+i < nent) {
139                 if (ptes[p+i])
140                         p = (p + i + 1 + mask) & ~mask, i = 0;
141                 else
142                         i = i + 1;
143         }
144
145         if (i < n) {
146                 /* Reached the end.  Flush the TLB and restart the
147                    search from the beginning.  */
148                 alpha_mv.mv_pci_tbi(arena->hose, 0, -1);
149
150                 p = 0, i = 0;
151                 while (i < n && p+i < nent) {
152                         if (ptes[p+i])
153                                 p = (p + i + 1 + mask) & ~mask, i = 0;
154                         else
155                                 i = i + 1;
156                 }
157
158                 if (i < n)
159                         return -1;
160         }
161
162         /* Success. It's the responsibility of the caller to mark them
163            in use before releasing the lock */
164         return p;
165 }
166
167 static long
168 iommu_arena_alloc(struct pci_iommu_arena *arena, long n, unsigned int align)
169 {
170         unsigned long flags;
171         unsigned long *ptes;
172         long i, p, mask;
173
174         spin_lock_irqsave(&arena->lock, flags);
175
176         /* Search for N empty ptes */
177         ptes = arena->ptes;
178         mask = max(align, arena->align_entry) - 1;
179         p = iommu_arena_find_pages(arena, n, mask);
180         if (p < 0) {
181                 spin_unlock_irqrestore(&arena->lock, flags);
182                 return -1;
183         }
184
185         /* Success.  Mark them all in use, ie not zero and invalid
186            for the iommu tlb that could load them from under us.
187            The chip specific bits will fill this in with something
188            kosher when we return.  */
189         for (i = 0; i < n; ++i)
190                 ptes[p+i] = IOMMU_INVALID_PTE;
191
192         arena->next_entry = p + n;
193         spin_unlock_irqrestore(&arena->lock, flags);
194
195         return p;
196 }
197
198 static void
199 iommu_arena_free(struct pci_iommu_arena *arena, long ofs, long n)
200 {
201         unsigned long *p;
202         long i;
203
204         p = arena->ptes + ofs;
205         for (i = 0; i < n; ++i)
206                 p[i] = 0;
207 }
208 \f
209 /* Map a single buffer of the indicated size for PCI DMA in streaming
210    mode.  The 32-bit PCI bus mastering address to use is returned.
211    Once the device is given the dma address, the device owns this memory
212    until either pci_unmap_single or pci_dma_sync_single is performed.  */
213
214 static dma_addr_t
215 pci_map_single_1(struct pci_dev *pdev, void *cpu_addr, size_t size,
216                  int dac_allowed)
217 {
218         struct pci_controller *hose = pdev ? pdev->sysdata : pci_isa_hose;
219         dma_addr_t max_dma = pdev ? pdev->dma_mask : ISA_DMA_MASK;
220         struct pci_iommu_arena *arena;
221         long npages, dma_ofs, i;
222         unsigned long paddr;
223         dma_addr_t ret;
224         unsigned int align = 0;
225
226         paddr = __pa(cpu_addr);
227
228 #if !DEBUG_NODIRECT
229         /* First check to see if we can use the direct map window.  */
230         if (paddr + size + __direct_map_base - 1 <= max_dma
231             && paddr + size <= __direct_map_size) {
232                 ret = paddr + __direct_map_base;
233
234                 DBGA2("pci_map_single: [%p,%lx] -> direct %lx from %p\n",
235                       cpu_addr, size, ret, __builtin_return_address(0));
236
237                 return ret;
238         }
239 #endif
240
241         /* Next, use DAC if selected earlier.  */
242         if (dac_allowed) {
243                 ret = paddr + alpha_mv.pci_dac_offset;
244
245                 DBGA2("pci_map_single: [%p,%lx] -> DAC %lx from %p\n",
246                       cpu_addr, size, ret, __builtin_return_address(0));
247
248                 return ret;
249         }
250
251         /* If the machine doesn't define a pci_tbi routine, we have to
252            assume it doesn't support sg mapping, and, since we tried to
253            use direct_map above, it now must be considered an error. */
254         if (! alpha_mv.mv_pci_tbi) {
255                 static int been_here = 0; /* Only print the message once. */
256                 if (!been_here) {
257                     printk(KERN_WARNING "pci_map_single: no HW sg\n");
258                     been_here = 1;
259                 }
260                 return 0;
261         }
262
263         arena = hose->sg_pci;
264         if (!arena || arena->dma_base + arena->size - 1 > max_dma)
265                 arena = hose->sg_isa;
266
267         npages = calc_npages((paddr & ~PAGE_MASK) + size);
268
269         /* Force allocation to 64KB boundary for ISA bridges. */
270         if (pdev && pdev == isa_bridge)
271                 align = 8;
272         dma_ofs = iommu_arena_alloc(arena, npages, align);
273         if (dma_ofs < 0) {
274                 printk(KERN_WARNING "pci_map_single failed: "
275                        "could not allocate dma page tables\n");
276                 return 0;
277         }
278
279         paddr &= PAGE_MASK;
280         for (i = 0; i < npages; ++i, paddr += PAGE_SIZE)
281                 arena->ptes[i + dma_ofs] = mk_iommu_pte(paddr);
282
283         ret = arena->dma_base + dma_ofs * PAGE_SIZE;
284         ret += (unsigned long)cpu_addr & ~PAGE_MASK;
285
286         DBGA2("pci_map_single: [%p,%lx] np %ld -> sg %lx from %p\n",
287               cpu_addr, size, npages, ret, __builtin_return_address(0));
288
289         return ret;
290 }
291
292 dma_addr_t
293 pci_map_single(struct pci_dev *pdev, void *cpu_addr, size_t size, int dir)
294 {
295         int dac_allowed; 
296
297         if (dir == PCI_DMA_NONE)
298                 BUG();
299
300         dac_allowed = pdev ? pci_dac_dma_supported(pdev, pdev->dma_mask) : 0; 
301         return pci_map_single_1(pdev, cpu_addr, size, dac_allowed);
302 }
303
304 dma_addr_t
305 pci_map_page(struct pci_dev *pdev, struct page *page, unsigned long offset,
306              size_t size, int dir)
307 {
308         int dac_allowed;
309
310         if (dir == PCI_DMA_NONE)
311                 BUG();
312
313         dac_allowed = pdev ? pci_dac_dma_supported(pdev, pdev->dma_mask) : 0; 
314         return pci_map_single_1(pdev, (char *)page_address(page) + offset, 
315                                 size, dac_allowed);
316 }
317
318 /* Unmap a single streaming mode DMA translation.  The DMA_ADDR and
319    SIZE must match what was provided for in a previous pci_map_single
320    call.  All other usages are undefined.  After this call, reads by
321    the cpu to the buffer are guaranteed to see whatever the device
322    wrote there.  */
323
324 void
325 pci_unmap_single(struct pci_dev *pdev, dma_addr_t dma_addr, size_t size,
326                  int direction)
327 {
328         unsigned long flags;
329         struct pci_controller *hose = pdev ? pdev->sysdata : pci_isa_hose;
330         struct pci_iommu_arena *arena;
331         long dma_ofs, npages;
332
333         if (direction == PCI_DMA_NONE)
334                 BUG();
335
336         if (dma_addr >= __direct_map_base
337             && dma_addr < __direct_map_base + __direct_map_size) {
338                 /* Nothing to do.  */
339
340                 DBGA2("pci_unmap_single: direct [%lx,%lx] from %p\n",
341                       dma_addr, size, __builtin_return_address(0));
342
343                 return;
344         }
345
346         if (dma_addr > 0xffffffff) {
347                 DBGA2("pci64_unmap_single: DAC [%lx,%lx] from %p\n",
348                       dma_addr, size, __builtin_return_address(0));
349                 return;
350         }
351
352         arena = hose->sg_pci;
353         if (!arena || dma_addr < arena->dma_base)
354                 arena = hose->sg_isa;
355
356         dma_ofs = (dma_addr - arena->dma_base) >> PAGE_SHIFT;
357         if (dma_ofs * PAGE_SIZE >= arena->size) {
358                 printk(KERN_ERR "Bogus pci_unmap_single: dma_addr %lx "
359                        " base %lx size %x\n", dma_addr, arena->dma_base,
360                        arena->size);
361                 return;
362                 BUG();
363         }
364
365         npages = calc_npages((dma_addr & ~PAGE_MASK) + size);
366
367         spin_lock_irqsave(&arena->lock, flags);
368
369         iommu_arena_free(arena, dma_ofs, npages);
370
371         /* If we're freeing ptes above the `next_entry' pointer (they
372            may have snuck back into the TLB since the last wrap flush),
373            we need to flush the TLB before reallocating the latter.  */
374         if (dma_ofs >= arena->next_entry)
375                 alpha_mv.mv_pci_tbi(hose, dma_addr, dma_addr + size - 1);
376
377         spin_unlock_irqrestore(&arena->lock, flags);
378
379         DBGA2("pci_unmap_single: sg [%lx,%lx] np %ld from %p\n",
380               dma_addr, size, npages, __builtin_return_address(0));
381 }
382
383 void
384 pci_unmap_page(struct pci_dev *pdev, dma_addr_t dma_addr,
385                size_t size, int direction)
386 {
387         pci_unmap_single(pdev, dma_addr, size, direction);
388 }
389
390 /* Allocate and map kernel buffer using consistent mode DMA for PCI
391    device.  Returns non-NULL cpu-view pointer to the buffer if
392    successful and sets *DMA_ADDRP to the pci side dma address as well,
393    else DMA_ADDRP is undefined.  */
394
395 void *
396 pci_alloc_consistent(struct pci_dev *pdev, size_t size, dma_addr_t *dma_addrp)
397 {
398         void *cpu_addr;
399         long order = get_order(size);
400         int gfp = GFP_ATOMIC;
401
402 try_again:
403         cpu_addr = (void *)__get_free_pages(gfp, order);
404         if (! cpu_addr) {
405                 printk(KERN_INFO "pci_alloc_consistent: "
406                        "get_free_pages failed from %p\n",
407                         __builtin_return_address(0));
408                 /* ??? Really atomic allocation?  Otherwise we could play
409                    with vmalloc and sg if we can't find contiguous memory.  */
410                 return NULL;
411         }
412         memset(cpu_addr, 0, size);
413
414         *dma_addrp = pci_map_single_1(pdev, cpu_addr, size, 0);
415         if (*dma_addrp == 0) {
416                 free_pages((unsigned long)cpu_addr, order);
417                 if (alpha_mv.mv_pci_tbi || (gfp & GFP_DMA))
418                         return NULL;
419                 /* The address doesn't fit required mask and we
420                    do not have iommu. Try again with GFP_DMA. */
421                 gfp |= GFP_DMA;
422                 goto try_again;
423         }
424                 
425         DBGA2("pci_alloc_consistent: %lx -> [%p,%x] from %p\n",
426               size, cpu_addr, *dma_addrp, __builtin_return_address(0));
427
428         return cpu_addr;
429 }
430
431 /* Free and unmap a consistent DMA buffer.  CPU_ADDR and DMA_ADDR must
432    be values that were returned from pci_alloc_consistent.  SIZE must
433    be the same as what as passed into pci_alloc_consistent.
434    References to the memory and mappings associated with CPU_ADDR or
435    DMA_ADDR past this call are illegal.  */
436
437 void
438 pci_free_consistent(struct pci_dev *pdev, size_t size, void *cpu_addr,
439                     dma_addr_t dma_addr)
440 {
441         pci_unmap_single(pdev, dma_addr, size, PCI_DMA_BIDIRECTIONAL);
442         free_pages((unsigned long)cpu_addr, get_order(size));
443
444         DBGA2("pci_free_consistent: [%x,%lx] from %p\n",
445               dma_addr, size, __builtin_return_address(0));
446 }
447
448
449 /* Classify the elements of the scatterlist.  Write dma_address
450    of each element with:
451         0   : Followers all physically adjacent.
452         1   : Followers all virtually adjacent.
453         -1  : Not leader, physically adjacent to previous.
454         -2  : Not leader, virtually adjacent to previous.
455    Write dma_length of each leader with the combined lengths of
456    the mergable followers.  */
457
458 #define SG_ENT_VIRT_ADDRESS(SG) (page_address((SG)->page) + (SG)->offset)
459 #define SG_ENT_PHYS_ADDRESS(SG) __pa(SG_ENT_VIRT_ADDRESS(SG))
460
461 static void
462 sg_classify(struct scatterlist *sg, struct scatterlist *end, int virt_ok)
463 {
464         unsigned long next_paddr;
465         struct scatterlist *leader;
466         long leader_flag, leader_length;
467
468         leader = sg;
469         leader_flag = 0;
470         leader_length = leader->length;
471         next_paddr = SG_ENT_PHYS_ADDRESS(leader) + leader_length;
472
473         for (++sg; sg < end; ++sg) {
474                 unsigned long addr, len;
475                 addr = SG_ENT_PHYS_ADDRESS(sg);
476                 len = sg->length;
477
478                 if (next_paddr == addr) {
479                         sg->dma_address = -1;
480                         leader_length += len;
481                 } else if (((next_paddr | addr) & ~PAGE_MASK) == 0 && virt_ok) {
482                         sg->dma_address = -2;
483                         leader_flag = 1;
484                         leader_length += len;
485                 } else {
486                         leader->dma_address = leader_flag;
487                         leader->dma_length = leader_length;
488                         leader = sg;
489                         leader_flag = 0;
490                         leader_length = len;
491                 }
492
493                 next_paddr = addr + len;
494         }
495
496         leader->dma_address = leader_flag;
497         leader->dma_length = leader_length;
498 }
499
500 /* Given a scatterlist leader, choose an allocation method and fill
501    in the blanks.  */
502
503 static int
504 sg_fill(struct scatterlist *leader, struct scatterlist *end,
505         struct scatterlist *out, struct pci_iommu_arena *arena,
506         dma_addr_t max_dma, int dac_allowed)
507 {
508         unsigned long paddr = SG_ENT_PHYS_ADDRESS(leader);
509         long size = leader->dma_length;
510         struct scatterlist *sg;
511         unsigned long *ptes;
512         long npages, dma_ofs, i;
513
514 #if !DEBUG_NODIRECT
515         /* If everything is physically contiguous, and the addresses
516            fall into the direct-map window, use it.  */
517         if (leader->dma_address == 0
518             && paddr + size + __direct_map_base - 1 <= max_dma
519             && paddr + size <= __direct_map_size) {
520                 out->dma_address = paddr + __direct_map_base;
521                 out->dma_length = size;
522
523                 DBGA("    sg_fill: [%p,%lx] -> direct %lx\n",
524                      __va(paddr), size, out->dma_address);
525
526                 return 0;
527         }
528 #endif
529
530         /* If physically contiguous and DAC is available, use it.  */
531         if (leader->dma_address == 0 && dac_allowed) {
532                 out->dma_address = paddr + alpha_mv.pci_dac_offset;
533                 out->dma_length = size;
534
535                 DBGA("    sg_fill: [%p,%lx] -> DAC %lx\n",
536                      __va(paddr), size, out->dma_address);
537
538                 return 0;
539         }
540
541         /* Otherwise, we'll use the iommu to make the pages virtually
542            contiguous.  */
543
544         paddr &= ~PAGE_MASK;
545         npages = calc_npages(paddr + size);
546         dma_ofs = iommu_arena_alloc(arena, npages, 0);
547         if (dma_ofs < 0) {
548                 /* If we attempted a direct map above but failed, die.  */
549                 if (leader->dma_address == 0)
550                         return -1;
551
552                 /* Otherwise, break up the remaining virtually contiguous
553                    hunks into individual direct maps and retry.  */
554                 sg_classify(leader, end, 0);
555                 return sg_fill(leader, end, out, arena, max_dma, dac_allowed);
556         }
557
558         out->dma_address = arena->dma_base + dma_ofs*PAGE_SIZE + paddr;
559         out->dma_length = size;
560
561         DBGA("    sg_fill: [%p,%lx] -> sg %lx np %ld\n",
562              __va(paddr), size, out->dma_address, npages);
563
564         /* All virtually contiguous.  We need to find the length of each
565            physically contiguous subsegment to fill in the ptes.  */
566         ptes = &arena->ptes[dma_ofs];
567         sg = leader;
568         do {
569 #if DEBUG_ALLOC > 0
570                 struct scatterlist *last_sg = sg;
571 #endif
572
573                 size = sg->length;
574                 paddr = SG_ENT_PHYS_ADDRESS(sg);
575
576                 while (sg+1 < end && (int) sg[1].dma_address == -1) {
577                         size += sg[1].length;
578                         sg++;
579                 }
580
581                 npages = calc_npages((paddr & ~PAGE_MASK) + size);
582
583                 paddr &= PAGE_MASK;
584                 for (i = 0; i < npages; ++i, paddr += PAGE_SIZE)
585                         *ptes++ = mk_iommu_pte(paddr);
586
587 #if DEBUG_ALLOC > 0
588                 DBGA("    (%ld) [%p,%x] np %ld\n",
589                      last_sg - leader, SG_ENT_VIRT_ADDRESS(last_sg),
590                      last_sg->length, npages);
591                 while (++last_sg <= sg) {
592                         DBGA("        (%ld) [%p,%x] cont\n",
593                              last_sg - leader, SG_ENT_VIRT_ADDRESS(last_sg),
594                              last_sg->length);
595                 }
596 #endif
597         } while (++sg < end && (int) sg->dma_address < 0);
598
599         return 1;
600 }
601
602 int
603 pci_map_sg(struct pci_dev *pdev, struct scatterlist *sg, int nents,
604            int direction)
605 {
606         struct scatterlist *start, *end, *out;
607         struct pci_controller *hose;
608         struct pci_iommu_arena *arena;
609         dma_addr_t max_dma;
610         int dac_allowed;
611
612         if (direction == PCI_DMA_NONE)
613                 BUG();
614
615         dac_allowed = pdev ? pci_dac_dma_supported(pdev, pdev->dma_mask) : 0;
616
617         /* Fast path single entry scatterlists.  */
618         if (nents == 1) {
619                 sg->dma_length = sg->length;
620                 sg->dma_address
621                   = pci_map_single_1(pdev, SG_ENT_VIRT_ADDRESS(sg),
622                                      sg->length, dac_allowed);
623                 return sg->dma_address != 0;
624         }
625
626         start = sg;
627         end = sg + nents;
628
629         /* First, prepare information about the entries.  */
630         sg_classify(sg, end, alpha_mv.mv_pci_tbi != 0);
631
632         /* Second, figure out where we're going to map things.  */
633         if (alpha_mv.mv_pci_tbi) {
634                 hose = pdev ? pdev->sysdata : pci_isa_hose;
635                 max_dma = pdev ? pdev->dma_mask : ISA_DMA_MASK;
636                 arena = hose->sg_pci;
637                 if (!arena || arena->dma_base + arena->size - 1 > max_dma)
638                         arena = hose->sg_isa;
639         } else {
640                 max_dma = -1;
641                 arena = NULL;
642                 hose = NULL;
643         }
644
645         /* Third, iterate over the scatterlist leaders and allocate
646            dma space as needed.  */
647         for (out = sg; sg < end; ++sg) {
648                 if ((int) sg->dma_address < 0)
649                         continue;
650                 if (sg_fill(sg, end, out, arena, max_dma, dac_allowed) < 0)
651                         goto error;
652                 out++;
653         }
654
655         /* Mark the end of the list for pci_unmap_sg.  */
656         if (out < end)
657                 out->dma_length = 0;
658
659         if (out - start == 0)
660                 printk(KERN_WARNING "pci_map_sg failed: no entries?\n");
661         DBGA("pci_map_sg: %ld entries\n", out - start);
662
663         return out - start;
664
665  error:
666         printk(KERN_WARNING "pci_map_sg failed: "
667                "could not allocate dma page tables\n");
668
669         /* Some allocation failed while mapping the scatterlist
670            entries.  Unmap them now.  */
671         if (out > start)
672                 pci_unmap_sg(pdev, start, out - start, direction);
673         return 0;
674 }
675
676 /* Unmap a set of streaming mode DMA translations.  Again, cpu read
677    rules concerning calls here are the same as for pci_unmap_single()
678    above.  */
679
680 void
681 pci_unmap_sg(struct pci_dev *pdev, struct scatterlist *sg, int nents,
682              int direction)
683 {
684         unsigned long flags;
685         struct pci_controller *hose;
686         struct pci_iommu_arena *arena;
687         struct scatterlist *end;
688         dma_addr_t max_dma;
689         dma_addr_t fbeg, fend;
690
691         if (direction == PCI_DMA_NONE)
692                 BUG();
693
694         if (! alpha_mv.mv_pci_tbi)
695                 return;
696
697         hose = pdev ? pdev->sysdata : pci_isa_hose;
698         max_dma = pdev ? pdev->dma_mask : ISA_DMA_MASK;
699         arena = hose->sg_pci;
700         if (!arena || arena->dma_base + arena->size - 1 > max_dma)
701                 arena = hose->sg_isa;
702
703         fbeg = -1, fend = 0;
704
705         spin_lock_irqsave(&arena->lock, flags);
706
707         for (end = sg + nents; sg < end; ++sg) {
708                 dma64_addr_t addr;
709                 size_t size;
710                 long npages, ofs;
711                 dma_addr_t tend;
712
713                 addr = sg->dma_address;
714                 size = sg->dma_length;
715                 if (!size)
716                         break;
717
718                 if (addr > 0xffffffff) {
719                         /* It's a DAC address -- nothing to do.  */
720                         DBGA("    (%ld) DAC [%lx,%lx]\n",
721                               sg - end + nents, addr, size);
722                         continue;
723                 }
724
725                 if (addr >= __direct_map_base
726                     && addr < __direct_map_base + __direct_map_size) {
727                         /* Nothing to do.  */
728                         DBGA("    (%ld) direct [%lx,%lx]\n",
729                               sg - end + nents, addr, size);
730                         continue;
731                 }
732
733                 DBGA("    (%ld) sg [%lx,%lx]\n",
734                      sg - end + nents, addr, size);
735
736                 npages = calc_npages((addr & ~PAGE_MASK) + size);
737                 ofs = (addr - arena->dma_base) >> PAGE_SHIFT;
738                 iommu_arena_free(arena, ofs, npages);
739
740                 tend = addr + size - 1;
741                 if (fbeg > addr) fbeg = addr;
742                 if (fend < tend) fend = tend;
743         }
744
745         /* If we're freeing ptes above the `next_entry' pointer (they
746            may have snuck back into the TLB since the last wrap flush),
747            we need to flush the TLB before reallocating the latter.  */
748         if ((fend - arena->dma_base) >> PAGE_SHIFT >= arena->next_entry)
749                 alpha_mv.mv_pci_tbi(hose, fbeg, fend);
750
751         spin_unlock_irqrestore(&arena->lock, flags);
752
753         DBGA("pci_unmap_sg: %ld entries\n", nents - (end - sg));
754 }
755
756
757 /* Return whether the given PCI device DMA address mask can be
758    supported properly.  */
759
760 int
761 pci_dma_supported(struct pci_dev *pdev, u64 mask)
762 {
763         struct pci_controller *hose;
764         struct pci_iommu_arena *arena;
765
766         /* If there exists a direct map, and the mask fits either
767            the entire direct mapped space or the total system memory as
768            shifted by the map base */
769         if (__direct_map_size != 0
770             && (__direct_map_base + __direct_map_size - 1 <= mask ||
771                 __direct_map_base + (max_low_pfn << PAGE_SHIFT) - 1 <= mask))
772                 return 1;
773
774         /* Check that we have a scatter-gather arena that fits.  */
775         hose = pdev ? pdev->sysdata : pci_isa_hose;
776         arena = hose->sg_isa;
777         if (arena && arena->dma_base + arena->size - 1 <= mask)
778                 return 1;
779         arena = hose->sg_pci;
780         if (arena && arena->dma_base + arena->size - 1 <= mask)
781                 return 1;
782
783         /* As last resort try ZONE_DMA.  */
784         if (!__direct_map_base && MAX_DMA_ADDRESS - IDENT_ADDR - 1 <= mask)
785                 return 1;
786
787         return 0;
788 }
789
790 \f
791 /*
792  * AGP GART extensions to the IOMMU
793  */
794 int
795 iommu_reserve(struct pci_iommu_arena *arena, long pg_count, long align_mask) 
796 {
797         unsigned long flags;
798         unsigned long *ptes;
799         long i, p;
800
801         if (!arena) return -EINVAL;
802
803         spin_lock_irqsave(&arena->lock, flags);
804
805         /* Search for N empty ptes.  */
806         ptes = arena->ptes;
807         p = iommu_arena_find_pages(arena, pg_count, align_mask);
808         if (p < 0) {
809                 spin_unlock_irqrestore(&arena->lock, flags);
810                 return -1;
811         }
812
813         /* Success.  Mark them all reserved (ie not zero and invalid)
814            for the iommu tlb that could load them from under us.
815            They will be filled in with valid bits by _bind() */
816         for (i = 0; i < pg_count; ++i)
817                 ptes[p+i] = IOMMU_RESERVED_PTE;
818
819         arena->next_entry = p + pg_count;
820         spin_unlock_irqrestore(&arena->lock, flags);
821
822         return p;
823 }
824
825 int 
826 iommu_release(struct pci_iommu_arena *arena, long pg_start, long pg_count)
827 {
828         unsigned long *ptes;
829         long i;
830
831         if (!arena) return -EINVAL;
832
833         ptes = arena->ptes;
834
835         /* Make sure they're all reserved first... */
836         for(i = pg_start; i < pg_start + pg_count; i++)
837                 if (ptes[i] != IOMMU_RESERVED_PTE)
838                         return -EBUSY;
839
840         iommu_arena_free(arena, pg_start, pg_count);
841         return 0;
842 }
843
844 int
845 iommu_bind(struct pci_iommu_arena *arena, long pg_start, long pg_count, 
846            unsigned long *physaddrs)
847 {
848         unsigned long flags;
849         unsigned long *ptes;
850         long i, j;
851
852         if (!arena) return -EINVAL;
853         
854         spin_lock_irqsave(&arena->lock, flags);
855
856         ptes = arena->ptes;
857
858         for(j = pg_start; j < pg_start + pg_count; j++) {
859                 if (ptes[j] != IOMMU_RESERVED_PTE) {
860                         spin_unlock_irqrestore(&arena->lock, flags);
861                         return -EBUSY;
862                 }
863         }
864                 
865         for(i = 0, j = pg_start; i < pg_count; i++, j++)
866                 ptes[j] = mk_iommu_pte(physaddrs[i]);
867
868         spin_unlock_irqrestore(&arena->lock, flags);
869
870         return 0;
871 }
872
873 int
874 iommu_unbind(struct pci_iommu_arena *arena, long pg_start, long pg_count)
875 {
876         unsigned long *p;
877         long i;
878
879         if (!arena) return -EINVAL;
880
881         p = arena->ptes + pg_start;
882         for(i = 0; i < pg_count; i++)
883                 p[i] = IOMMU_RESERVED_PTE;
884
885         return 0;
886 }
887
888 /* True if the machine supports DAC addressing, and DEV can
889    make use of it given MASK.  */
890
891 int
892 pci_dac_dma_supported(struct pci_dev *dev, u64 mask)
893 {
894         dma64_addr_t dac_offset = alpha_mv.pci_dac_offset;
895         int ok = 1;
896
897         /* If this is not set, the machine doesn't support DAC at all.  */
898         if (dac_offset == 0)
899                 ok = 0;
900
901         /* The device has to be able to address our DAC bit.  */
902         if ((dac_offset & dev->dma_mask) != dac_offset)
903                 ok = 0;
904
905         /* If both conditions above are met, we are fine. */
906         DBGA("pci_dac_dma_supported %s from %p\n",
907              ok ? "yes" : "no", __builtin_return_address(0));
908
909         return ok;
910 }
911
912 dma64_addr_t
913 pci_dac_page_to_dma(struct pci_dev *pdev, struct page *page,
914                     unsigned long offset, int direction)
915 {
916         return (alpha_mv.pci_dac_offset
917                 + __pa(page_address(page)) 
918                 + (dma64_addr_t) offset);
919 }
920
921 struct page *
922 pci_dac_dma_to_page(struct pci_dev *pdev, dma64_addr_t dma_addr)
923 {
924         unsigned long paddr = (dma_addr & PAGE_MASK) - alpha_mv.pci_dac_offset;
925         return virt_to_page(__va(paddr));
926 }
927
928 unsigned long
929 pci_dac_dma_to_offset(struct pci_dev *pdev, dma64_addr_t dma_addr)
930 {
931         return (dma_addr & ~PAGE_MASK);
932 }
933
934
935 /* Helper for generic DMA-mapping functions. */
936
937 struct pci_dev *
938 alpha_gendev_to_pci(struct device *dev)
939 {
940         if (dev && dev->bus == &pci_bus_type)
941                 return to_pci_dev(dev);
942
943         /* Assume that non-PCI devices asking for DMA are either ISA or EISA,
944            BUG() otherwise. */
945         BUG_ON(!isa_bridge);
946
947         /* Assume non-busmaster ISA DMA when dma_mask is not set (the ISA
948            bridge is bus master then). */
949         if (!dev || !dev->dma_mask || !*dev->dma_mask)
950                 return isa_bridge;
951
952         /* For EISA bus masters, return isa_bridge (it might have smaller
953            dma_mask due to wiring limitations). */
954         if (*dev->dma_mask >= isa_bridge->dma_mask)
955                 return isa_bridge;
956
957         /* This assumes ISA bus master with dma_mask 0xffffff. */
958         return NULL;
959 }
960
961 int
962 dma_set_mask(struct device *dev, u64 mask)
963 {
964         if (!dev->dma_mask ||
965             !pci_dma_supported(alpha_gendev_to_pci(dev), mask))
966                 return -EIO;
967
968         *dev->dma_mask = mask;
969
970         return 0;
971 }