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