Merge master.kernel.org:/home/rmk/linux-2.6-arm
[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 EXPORT_SYMBOL(pci_map_single);
304
305 dma_addr_t
306 pci_map_page(struct pci_dev *pdev, struct page *page, unsigned long offset,
307              size_t size, int dir)
308 {
309         int dac_allowed;
310
311         if (dir == PCI_DMA_NONE)
312                 BUG();
313
314         dac_allowed = pdev ? pci_dac_dma_supported(pdev, pdev->dma_mask) : 0; 
315         return pci_map_single_1(pdev, (char *)page_address(page) + offset, 
316                                 size, dac_allowed);
317 }
318 EXPORT_SYMBOL(pci_map_page);
319
320 /* Unmap a single streaming mode DMA translation.  The DMA_ADDR and
321    SIZE must match what was provided for in a previous pci_map_single
322    call.  All other usages are undefined.  After this call, reads by
323    the cpu to the buffer are guaranteed to see whatever the device
324    wrote there.  */
325
326 void
327 pci_unmap_single(struct pci_dev *pdev, dma_addr_t dma_addr, size_t size,
328                  int direction)
329 {
330         unsigned long flags;
331         struct pci_controller *hose = pdev ? pdev->sysdata : pci_isa_hose;
332         struct pci_iommu_arena *arena;
333         long dma_ofs, npages;
334
335         if (direction == PCI_DMA_NONE)
336                 BUG();
337
338         if (dma_addr >= __direct_map_base
339             && dma_addr < __direct_map_base + __direct_map_size) {
340                 /* Nothing to do.  */
341
342                 DBGA2("pci_unmap_single: direct [%lx,%lx] from %p\n",
343                       dma_addr, size, __builtin_return_address(0));
344
345                 return;
346         }
347
348         if (dma_addr > 0xffffffff) {
349                 DBGA2("pci64_unmap_single: DAC [%lx,%lx] from %p\n",
350                       dma_addr, size, __builtin_return_address(0));
351                 return;
352         }
353
354         arena = hose->sg_pci;
355         if (!arena || dma_addr < arena->dma_base)
356                 arena = hose->sg_isa;
357
358         dma_ofs = (dma_addr - arena->dma_base) >> PAGE_SHIFT;
359         if (dma_ofs * PAGE_SIZE >= arena->size) {
360                 printk(KERN_ERR "Bogus pci_unmap_single: dma_addr %lx "
361                        " base %lx size %x\n", dma_addr, arena->dma_base,
362                        arena->size);
363                 return;
364                 BUG();
365         }
366
367         npages = calc_npages((dma_addr & ~PAGE_MASK) + size);
368
369         spin_lock_irqsave(&arena->lock, flags);
370
371         iommu_arena_free(arena, dma_ofs, npages);
372
373         /* If we're freeing ptes above the `next_entry' pointer (they
374            may have snuck back into the TLB since the last wrap flush),
375            we need to flush the TLB before reallocating the latter.  */
376         if (dma_ofs >= arena->next_entry)
377                 alpha_mv.mv_pci_tbi(hose, dma_addr, dma_addr + size - 1);
378
379         spin_unlock_irqrestore(&arena->lock, flags);
380
381         DBGA2("pci_unmap_single: sg [%lx,%lx] np %ld from %p\n",
382               dma_addr, size, npages, __builtin_return_address(0));
383 }
384 EXPORT_SYMBOL(pci_unmap_single);
385
386 void
387 pci_unmap_page(struct pci_dev *pdev, dma_addr_t dma_addr,
388                size_t size, int direction)
389 {
390         pci_unmap_single(pdev, dma_addr, size, direction);
391 }
392 EXPORT_SYMBOL(pci_unmap_page);
393
394 /* Allocate and map kernel buffer using consistent mode DMA for PCI
395    device.  Returns non-NULL cpu-view pointer to the buffer if
396    successful and sets *DMA_ADDRP to the pci side dma address as well,
397    else DMA_ADDRP is undefined.  */
398
399 void *
400 pci_alloc_consistent(struct pci_dev *pdev, size_t size, dma_addr_t *dma_addrp)
401 {
402         void *cpu_addr;
403         long order = get_order(size);
404         gfp_t gfp = GFP_ATOMIC;
405
406 try_again:
407         cpu_addr = (void *)__get_free_pages(gfp, order);
408         if (! cpu_addr) {
409                 printk(KERN_INFO "pci_alloc_consistent: "
410                        "get_free_pages failed from %p\n",
411                         __builtin_return_address(0));
412                 /* ??? Really atomic allocation?  Otherwise we could play
413                    with vmalloc and sg if we can't find contiguous memory.  */
414                 return NULL;
415         }
416         memset(cpu_addr, 0, size);
417
418         *dma_addrp = pci_map_single_1(pdev, cpu_addr, size, 0);
419         if (*dma_addrp == 0) {
420                 free_pages((unsigned long)cpu_addr, order);
421                 if (alpha_mv.mv_pci_tbi || (gfp & GFP_DMA))
422                         return NULL;
423                 /* The address doesn't fit required mask and we
424                    do not have iommu. Try again with GFP_DMA. */
425                 gfp |= GFP_DMA;
426                 goto try_again;
427         }
428                 
429         DBGA2("pci_alloc_consistent: %lx -> [%p,%x] from %p\n",
430               size, cpu_addr, *dma_addrp, __builtin_return_address(0));
431
432         return cpu_addr;
433 }
434 EXPORT_SYMBOL(pci_alloc_consistent);
435
436 /* Free and unmap a consistent DMA buffer.  CPU_ADDR and DMA_ADDR must
437    be values that were returned from pci_alloc_consistent.  SIZE must
438    be the same as what as passed into pci_alloc_consistent.
439    References to the memory and mappings associated with CPU_ADDR or
440    DMA_ADDR past this call are illegal.  */
441
442 void
443 pci_free_consistent(struct pci_dev *pdev, size_t size, void *cpu_addr,
444                     dma_addr_t dma_addr)
445 {
446         pci_unmap_single(pdev, dma_addr, size, PCI_DMA_BIDIRECTIONAL);
447         free_pages((unsigned long)cpu_addr, get_order(size));
448
449         DBGA2("pci_free_consistent: [%x,%lx] from %p\n",
450               dma_addr, size, __builtin_return_address(0));
451 }
452 EXPORT_SYMBOL(pci_free_consistent);
453
454 /* Classify the elements of the scatterlist.  Write dma_address
455    of each element with:
456         0   : Followers all physically adjacent.
457         1   : Followers all virtually adjacent.
458         -1  : Not leader, physically adjacent to previous.
459         -2  : Not leader, virtually adjacent to previous.
460    Write dma_length of each leader with the combined lengths of
461    the mergable followers.  */
462
463 #define SG_ENT_VIRT_ADDRESS(SG) (page_address((SG)->page) + (SG)->offset)
464 #define SG_ENT_PHYS_ADDRESS(SG) __pa(SG_ENT_VIRT_ADDRESS(SG))
465
466 static void
467 sg_classify(struct scatterlist *sg, struct scatterlist *end, int virt_ok)
468 {
469         unsigned long next_paddr;
470         struct scatterlist *leader;
471         long leader_flag, leader_length;
472
473         leader = sg;
474         leader_flag = 0;
475         leader_length = leader->length;
476         next_paddr = SG_ENT_PHYS_ADDRESS(leader) + leader_length;
477
478         for (++sg; sg < end; ++sg) {
479                 unsigned long addr, len;
480                 addr = SG_ENT_PHYS_ADDRESS(sg);
481                 len = sg->length;
482
483                 if (next_paddr == addr) {
484                         sg->dma_address = -1;
485                         leader_length += len;
486                 } else if (((next_paddr | addr) & ~PAGE_MASK) == 0 && virt_ok) {
487                         sg->dma_address = -2;
488                         leader_flag = 1;
489                         leader_length += len;
490                 } else {
491                         leader->dma_address = leader_flag;
492                         leader->dma_length = leader_length;
493                         leader = sg;
494                         leader_flag = 0;
495                         leader_length = len;
496                 }
497
498                 next_paddr = addr + len;
499         }
500
501         leader->dma_address = leader_flag;
502         leader->dma_length = leader_length;
503 }
504
505 /* Given a scatterlist leader, choose an allocation method and fill
506    in the blanks.  */
507
508 static int
509 sg_fill(struct scatterlist *leader, struct scatterlist *end,
510         struct scatterlist *out, struct pci_iommu_arena *arena,
511         dma_addr_t max_dma, int dac_allowed)
512 {
513         unsigned long paddr = SG_ENT_PHYS_ADDRESS(leader);
514         long size = leader->dma_length;
515         struct scatterlist *sg;
516         unsigned long *ptes;
517         long npages, dma_ofs, i;
518
519 #if !DEBUG_NODIRECT
520         /* If everything is physically contiguous, and the addresses
521            fall into the direct-map window, use it.  */
522         if (leader->dma_address == 0
523             && paddr + size + __direct_map_base - 1 <= max_dma
524             && paddr + size <= __direct_map_size) {
525                 out->dma_address = paddr + __direct_map_base;
526                 out->dma_length = size;
527
528                 DBGA("    sg_fill: [%p,%lx] -> direct %lx\n",
529                      __va(paddr), size, out->dma_address);
530
531                 return 0;
532         }
533 #endif
534
535         /* If physically contiguous and DAC is available, use it.  */
536         if (leader->dma_address == 0 && dac_allowed) {
537                 out->dma_address = paddr + alpha_mv.pci_dac_offset;
538                 out->dma_length = size;
539
540                 DBGA("    sg_fill: [%p,%lx] -> DAC %lx\n",
541                      __va(paddr), size, out->dma_address);
542
543                 return 0;
544         }
545
546         /* Otherwise, we'll use the iommu to make the pages virtually
547            contiguous.  */
548
549         paddr &= ~PAGE_MASK;
550         npages = calc_npages(paddr + size);
551         dma_ofs = iommu_arena_alloc(arena, npages, 0);
552         if (dma_ofs < 0) {
553                 /* If we attempted a direct map above but failed, die.  */
554                 if (leader->dma_address == 0)
555                         return -1;
556
557                 /* Otherwise, break up the remaining virtually contiguous
558                    hunks into individual direct maps and retry.  */
559                 sg_classify(leader, end, 0);
560                 return sg_fill(leader, end, out, arena, max_dma, dac_allowed);
561         }
562
563         out->dma_address = arena->dma_base + dma_ofs*PAGE_SIZE + paddr;
564         out->dma_length = size;
565
566         DBGA("    sg_fill: [%p,%lx] -> sg %lx np %ld\n",
567              __va(paddr), size, out->dma_address, npages);
568
569         /* All virtually contiguous.  We need to find the length of each
570            physically contiguous subsegment to fill in the ptes.  */
571         ptes = &arena->ptes[dma_ofs];
572         sg = leader;
573         do {
574 #if DEBUG_ALLOC > 0
575                 struct scatterlist *last_sg = sg;
576 #endif
577
578                 size = sg->length;
579                 paddr = SG_ENT_PHYS_ADDRESS(sg);
580
581                 while (sg+1 < end && (int) sg[1].dma_address == -1) {
582                         size += sg[1].length;
583                         sg++;
584                 }
585
586                 npages = calc_npages((paddr & ~PAGE_MASK) + size);
587
588                 paddr &= PAGE_MASK;
589                 for (i = 0; i < npages; ++i, paddr += PAGE_SIZE)
590                         *ptes++ = mk_iommu_pte(paddr);
591
592 #if DEBUG_ALLOC > 0
593                 DBGA("    (%ld) [%p,%x] np %ld\n",
594                      last_sg - leader, SG_ENT_VIRT_ADDRESS(last_sg),
595                      last_sg->length, npages);
596                 while (++last_sg <= sg) {
597                         DBGA("        (%ld) [%p,%x] cont\n",
598                              last_sg - leader, SG_ENT_VIRT_ADDRESS(last_sg),
599                              last_sg->length);
600                 }
601 #endif
602         } while (++sg < end && (int) sg->dma_address < 0);
603
604         return 1;
605 }
606
607 int
608 pci_map_sg(struct pci_dev *pdev, struct scatterlist *sg, int nents,
609            int direction)
610 {
611         struct scatterlist *start, *end, *out;
612         struct pci_controller *hose;
613         struct pci_iommu_arena *arena;
614         dma_addr_t max_dma;
615         int dac_allowed;
616
617         if (direction == PCI_DMA_NONE)
618                 BUG();
619
620         dac_allowed = pdev ? pci_dac_dma_supported(pdev, pdev->dma_mask) : 0;
621
622         /* Fast path single entry scatterlists.  */
623         if (nents == 1) {
624                 sg->dma_length = sg->length;
625                 sg->dma_address
626                   = pci_map_single_1(pdev, SG_ENT_VIRT_ADDRESS(sg),
627                                      sg->length, dac_allowed);
628                 return sg->dma_address != 0;
629         }
630
631         start = sg;
632         end = sg + nents;
633
634         /* First, prepare information about the entries.  */
635         sg_classify(sg, end, alpha_mv.mv_pci_tbi != 0);
636
637         /* Second, figure out where we're going to map things.  */
638         if (alpha_mv.mv_pci_tbi) {
639                 hose = pdev ? pdev->sysdata : pci_isa_hose;
640                 max_dma = pdev ? pdev->dma_mask : ISA_DMA_MASK;
641                 arena = hose->sg_pci;
642                 if (!arena || arena->dma_base + arena->size - 1 > max_dma)
643                         arena = hose->sg_isa;
644         } else {
645                 max_dma = -1;
646                 arena = NULL;
647                 hose = NULL;
648         }
649
650         /* Third, iterate over the scatterlist leaders and allocate
651            dma space as needed.  */
652         for (out = sg; sg < end; ++sg) {
653                 if ((int) sg->dma_address < 0)
654                         continue;
655                 if (sg_fill(sg, end, out, arena, max_dma, dac_allowed) < 0)
656                         goto error;
657                 out++;
658         }
659
660         /* Mark the end of the list for pci_unmap_sg.  */
661         if (out < end)
662                 out->dma_length = 0;
663
664         if (out - start == 0)
665                 printk(KERN_WARNING "pci_map_sg failed: no entries?\n");
666         DBGA("pci_map_sg: %ld entries\n", out - start);
667
668         return out - start;
669
670  error:
671         printk(KERN_WARNING "pci_map_sg failed: "
672                "could not allocate dma page tables\n");
673
674         /* Some allocation failed while mapping the scatterlist
675            entries.  Unmap them now.  */
676         if (out > start)
677                 pci_unmap_sg(pdev, start, out - start, direction);
678         return 0;
679 }
680 EXPORT_SYMBOL(pci_map_sg);
681
682 /* Unmap a set of streaming mode DMA translations.  Again, cpu read
683    rules concerning calls here are the same as for pci_unmap_single()
684    above.  */
685
686 void
687 pci_unmap_sg(struct pci_dev *pdev, struct scatterlist *sg, int nents,
688              int direction)
689 {
690         unsigned long flags;
691         struct pci_controller *hose;
692         struct pci_iommu_arena *arena;
693         struct scatterlist *end;
694         dma_addr_t max_dma;
695         dma_addr_t fbeg, fend;
696
697         if (direction == PCI_DMA_NONE)
698                 BUG();
699
700         if (! alpha_mv.mv_pci_tbi)
701                 return;
702
703         hose = pdev ? pdev->sysdata : pci_isa_hose;
704         max_dma = pdev ? pdev->dma_mask : ISA_DMA_MASK;
705         arena = hose->sg_pci;
706         if (!arena || arena->dma_base + arena->size - 1 > max_dma)
707                 arena = hose->sg_isa;
708
709         fbeg = -1, fend = 0;
710
711         spin_lock_irqsave(&arena->lock, flags);
712
713         for (end = sg + nents; sg < end; ++sg) {
714                 dma64_addr_t addr;
715                 size_t size;
716                 long npages, ofs;
717                 dma_addr_t tend;
718
719                 addr = sg->dma_address;
720                 size = sg->dma_length;
721                 if (!size)
722                         break;
723
724                 if (addr > 0xffffffff) {
725                         /* It's a DAC address -- nothing to do.  */
726                         DBGA("    (%ld) DAC [%lx,%lx]\n",
727                               sg - end + nents, addr, size);
728                         continue;
729                 }
730
731                 if (addr >= __direct_map_base
732                     && addr < __direct_map_base + __direct_map_size) {
733                         /* Nothing to do.  */
734                         DBGA("    (%ld) direct [%lx,%lx]\n",
735                               sg - end + nents, addr, size);
736                         continue;
737                 }
738
739                 DBGA("    (%ld) sg [%lx,%lx]\n",
740                      sg - end + nents, addr, size);
741
742                 npages = calc_npages((addr & ~PAGE_MASK) + size);
743                 ofs = (addr - arena->dma_base) >> PAGE_SHIFT;
744                 iommu_arena_free(arena, ofs, npages);
745
746                 tend = addr + size - 1;
747                 if (fbeg > addr) fbeg = addr;
748                 if (fend < tend) fend = tend;
749         }
750
751         /* If we're freeing ptes above the `next_entry' pointer (they
752            may have snuck back into the TLB since the last wrap flush),
753            we need to flush the TLB before reallocating the latter.  */
754         if ((fend - arena->dma_base) >> PAGE_SHIFT >= arena->next_entry)
755                 alpha_mv.mv_pci_tbi(hose, fbeg, fend);
756
757         spin_unlock_irqrestore(&arena->lock, flags);
758
759         DBGA("pci_unmap_sg: %ld entries\n", nents - (end - sg));
760 }
761 EXPORT_SYMBOL(pci_unmap_sg);
762
763
764 /* Return whether the given PCI device DMA address mask can be
765    supported properly.  */
766
767 int
768 pci_dma_supported(struct pci_dev *pdev, u64 mask)
769 {
770         struct pci_controller *hose;
771         struct pci_iommu_arena *arena;
772
773         /* If there exists a direct map, and the mask fits either
774            the entire direct mapped space or the total system memory as
775            shifted by the map base */
776         if (__direct_map_size != 0
777             && (__direct_map_base + __direct_map_size - 1 <= mask ||
778                 __direct_map_base + (max_low_pfn << PAGE_SHIFT) - 1 <= mask))
779                 return 1;
780
781         /* Check that we have a scatter-gather arena that fits.  */
782         hose = pdev ? pdev->sysdata : pci_isa_hose;
783         arena = hose->sg_isa;
784         if (arena && arena->dma_base + arena->size - 1 <= mask)
785                 return 1;
786         arena = hose->sg_pci;
787         if (arena && arena->dma_base + arena->size - 1 <= mask)
788                 return 1;
789
790         /* As last resort try ZONE_DMA.  */
791         if (!__direct_map_base && MAX_DMA_ADDRESS - IDENT_ADDR - 1 <= mask)
792                 return 1;
793
794         return 0;
795 }
796 EXPORT_SYMBOL(pci_dma_supported);
797
798 \f
799 /*
800  * AGP GART extensions to the IOMMU
801  */
802 int
803 iommu_reserve(struct pci_iommu_arena *arena, long pg_count, long align_mask) 
804 {
805         unsigned long flags;
806         unsigned long *ptes;
807         long i, p;
808
809         if (!arena) return -EINVAL;
810
811         spin_lock_irqsave(&arena->lock, flags);
812
813         /* Search for N empty ptes.  */
814         ptes = arena->ptes;
815         p = iommu_arena_find_pages(arena, pg_count, align_mask);
816         if (p < 0) {
817                 spin_unlock_irqrestore(&arena->lock, flags);
818                 return -1;
819         }
820
821         /* Success.  Mark them all reserved (ie not zero and invalid)
822            for the iommu tlb that could load them from under us.
823            They will be filled in with valid bits by _bind() */
824         for (i = 0; i < pg_count; ++i)
825                 ptes[p+i] = IOMMU_RESERVED_PTE;
826
827         arena->next_entry = p + pg_count;
828         spin_unlock_irqrestore(&arena->lock, flags);
829
830         return p;
831 }
832
833 int 
834 iommu_release(struct pci_iommu_arena *arena, long pg_start, long pg_count)
835 {
836         unsigned long *ptes;
837         long i;
838
839         if (!arena) return -EINVAL;
840
841         ptes = arena->ptes;
842
843         /* Make sure they're all reserved first... */
844         for(i = pg_start; i < pg_start + pg_count; i++)
845                 if (ptes[i] != IOMMU_RESERVED_PTE)
846                         return -EBUSY;
847
848         iommu_arena_free(arena, pg_start, pg_count);
849         return 0;
850 }
851
852 int
853 iommu_bind(struct pci_iommu_arena *arena, long pg_start, long pg_count, 
854            unsigned long *physaddrs)
855 {
856         unsigned long flags;
857         unsigned long *ptes;
858         long i, j;
859
860         if (!arena) return -EINVAL;
861         
862         spin_lock_irqsave(&arena->lock, flags);
863
864         ptes = arena->ptes;
865
866         for(j = pg_start; j < pg_start + pg_count; j++) {
867                 if (ptes[j] != IOMMU_RESERVED_PTE) {
868                         spin_unlock_irqrestore(&arena->lock, flags);
869                         return -EBUSY;
870                 }
871         }
872                 
873         for(i = 0, j = pg_start; i < pg_count; i++, j++)
874                 ptes[j] = mk_iommu_pte(physaddrs[i]);
875
876         spin_unlock_irqrestore(&arena->lock, flags);
877
878         return 0;
879 }
880
881 int
882 iommu_unbind(struct pci_iommu_arena *arena, long pg_start, long pg_count)
883 {
884         unsigned long *p;
885         long i;
886
887         if (!arena) return -EINVAL;
888
889         p = arena->ptes + pg_start;
890         for(i = 0; i < pg_count; i++)
891                 p[i] = IOMMU_RESERVED_PTE;
892
893         return 0;
894 }
895
896 /* True if the machine supports DAC addressing, and DEV can
897    make use of it given MASK.  */
898
899 int
900 pci_dac_dma_supported(struct pci_dev *dev, u64 mask)
901 {
902         dma64_addr_t dac_offset = alpha_mv.pci_dac_offset;
903         int ok = 1;
904
905         /* If this is not set, the machine doesn't support DAC at all.  */
906         if (dac_offset == 0)
907                 ok = 0;
908
909         /* The device has to be able to address our DAC bit.  */
910         if ((dac_offset & dev->dma_mask) != dac_offset)
911                 ok = 0;
912
913         /* If both conditions above are met, we are fine. */
914         DBGA("pci_dac_dma_supported %s from %p\n",
915              ok ? "yes" : "no", __builtin_return_address(0));
916
917         return ok;
918 }
919 EXPORT_SYMBOL(pci_dac_dma_supported);
920
921 dma64_addr_t
922 pci_dac_page_to_dma(struct pci_dev *pdev, struct page *page,
923                     unsigned long offset, int direction)
924 {
925         return (alpha_mv.pci_dac_offset
926                 + __pa(page_address(page)) 
927                 + (dma64_addr_t) offset);
928 }
929 EXPORT_SYMBOL(pci_dac_page_to_dma);
930
931 struct page *
932 pci_dac_dma_to_page(struct pci_dev *pdev, dma64_addr_t dma_addr)
933 {
934         unsigned long paddr = (dma_addr & PAGE_MASK) - alpha_mv.pci_dac_offset;
935         return virt_to_page(__va(paddr));
936 }
937 EXPORT_SYMBOL(pci_dac_dma_to_page);
938
939 unsigned long
940 pci_dac_dma_to_offset(struct pci_dev *pdev, dma64_addr_t dma_addr)
941 {
942         return (dma_addr & ~PAGE_MASK);
943 }
944 EXPORT_SYMBOL(pci_dac_dma_to_offset);
945
946 /* Helper for generic DMA-mapping functions. */
947
948 struct pci_dev *
949 alpha_gendev_to_pci(struct device *dev)
950 {
951         if (dev && dev->bus == &pci_bus_type)
952                 return to_pci_dev(dev);
953
954         /* Assume that non-PCI devices asking for DMA are either ISA or EISA,
955            BUG() otherwise. */
956         BUG_ON(!isa_bridge);
957
958         /* Assume non-busmaster ISA DMA when dma_mask is not set (the ISA
959            bridge is bus master then). */
960         if (!dev || !dev->dma_mask || !*dev->dma_mask)
961                 return isa_bridge;
962
963         /* For EISA bus masters, return isa_bridge (it might have smaller
964            dma_mask due to wiring limitations). */
965         if (*dev->dma_mask >= isa_bridge->dma_mask)
966                 return isa_bridge;
967
968         /* This assumes ISA bus master with dma_mask 0xffffff. */
969         return NULL;
970 }
971 EXPORT_SYMBOL(alpha_gendev_to_pci);
972
973 int
974 dma_set_mask(struct device *dev, u64 mask)
975 {
976         if (!dev->dma_mask ||
977             !pci_dma_supported(alpha_gendev_to_pci(dev), mask))
978                 return -EIO;
979
980         *dev->dma_mask = mask;
981
982         return 0;
983 }
984 EXPORT_SYMBOL(dma_set_mask);