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