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