005a28d380af9c94528437d7f6c0940c08085744
[sfrench/cifs-2.6.git] / arch / powerpc / lib / dma-noncoherent.c
1 /*
2  *  PowerPC version derived from arch/arm/mm/consistent.c
3  *    Copyright (C) 2001 Dan Malek (dmalek@jlc.net)
4  *
5  *  Copyright (C) 2000 Russell King
6  *
7  * Consistent memory allocators.  Used for DMA devices that want to
8  * share uncached memory with the processor core.  The function return
9  * is the virtual address and 'dma_handle' is the physical address.
10  * Mostly stolen from the ARM port, with some changes for PowerPC.
11  *                                              -- Dan
12  *
13  * Reorganized to get rid of the arch-specific consistent_* functions
14  * and provide non-coherent implementations for the DMA API. -Matt
15  *
16  * Added in_interrupt() safe dma_alloc_coherent()/dma_free_coherent()
17  * implementation. This is pulled straight from ARM and barely
18  * modified. -Matt
19  *
20  * This program is free software; you can redistribute it and/or modify
21  * it under the terms of the GNU General Public License version 2 as
22  * published by the Free Software Foundation.
23  */
24
25 #include <linux/sched.h>
26 #include <linux/kernel.h>
27 #include <linux/errno.h>
28 #include <linux/string.h>
29 #include <linux/types.h>
30 #include <linux/highmem.h>
31 #include <linux/dma-mapping.h>
32 #include <linux/vmalloc.h>
33
34 #include <asm/tlbflush.h>
35
36 /*
37  * Allocate DMA-coherent memory space and return both the kernel remapped
38  * virtual and bus address for that space.
39  */
40 void *
41 __dma_alloc_coherent(size_t size, dma_addr_t *handle, gfp_t gfp)
42 {
43         struct page *page;
44         unsigned long order;
45         int i;
46         unsigned int nr_pages = PAGE_ALIGN(size)>>PAGE_SHIFT;
47         unsigned int array_size = nr_pages * sizeof(struct page *);
48         struct page **pages;
49         struct page *end;
50         u64 mask = 0x00ffffff, limit; /* ISA default */
51         struct vm_struct *area;
52
53         BUG_ON(!mem_init_done);
54         size = PAGE_ALIGN(size);
55         limit = (mask + 1) & ~mask;
56         if (limit && size >= limit) {
57                 printk(KERN_WARNING "coherent allocation too big (requested "
58                                 "%#x mask %#Lx)\n", size, mask);
59                 return NULL;
60         }
61
62         order = get_order(size);
63
64         if (mask != 0xffffffff)
65                 gfp |= GFP_DMA;
66
67         page = alloc_pages(gfp, order);
68         if (!page)
69                 goto no_page;
70
71         end = page + (1 << order);
72
73         /*
74          * Invalidate any data that might be lurking in the
75          * kernel direct-mapped region for device DMA.
76          */
77         {
78                 unsigned long kaddr = (unsigned long)page_address(page);
79                 memset(page_address(page), 0, size);
80                 flush_dcache_range(kaddr, kaddr + size);
81         }
82
83         split_page(page, order);
84
85         /*
86          * Set the "dma handle"
87          */
88         *handle = page_to_phys(page);
89
90         area = get_vm_area_caller(size, VM_IOREMAP,
91                         __builtin_return_address(1));
92         if (!area)
93                 goto out_free_pages;
94
95         if (array_size > PAGE_SIZE) {
96                 pages = vmalloc(array_size);
97                 area->flags |= VM_VPAGES;
98         } else {
99                 pages = kmalloc(array_size, GFP_KERNEL);
100         }
101         if (!pages)
102                 goto out_free_area;
103
104         area->pages = pages;
105         area->nr_pages = nr_pages;
106
107         for (i = 0; i < nr_pages; i++)
108                 pages[i] = page + i;
109
110         if (map_vm_area(area, pgprot_noncached(PAGE_KERNEL), &pages))
111                 goto out_unmap;
112
113         /*
114          * Free the otherwise unused pages.
115          */
116         page += nr_pages;
117         while (page < end) {
118                 __free_page(page);
119                 page++;
120         }
121
122         return area->addr;
123 out_unmap:
124         vunmap(area->addr);
125         if (array_size > PAGE_SIZE)
126                 vfree(pages);
127         else
128                 kfree(pages);
129         goto out_free_pages;
130 out_free_area:
131         free_vm_area(area);
132 out_free_pages:
133         if (page)
134                 __free_pages(page, order);
135 no_page:
136         return NULL;
137 }
138 EXPORT_SYMBOL(__dma_alloc_coherent);
139
140 /*
141  * free a page as defined by the above mapping.
142  */
143 void __dma_free_coherent(size_t size, void *vaddr)
144 {
145         vfree(vaddr);
146
147 }
148 EXPORT_SYMBOL(__dma_free_coherent);
149
150 /*
151  * make an area consistent.
152  */
153 void __dma_sync(void *vaddr, size_t size, int direction)
154 {
155         unsigned long start = (unsigned long)vaddr;
156         unsigned long end   = start + size;
157
158         switch (direction) {
159         case DMA_NONE:
160                 BUG();
161         case DMA_FROM_DEVICE:
162                 /*
163                  * invalidate only when cache-line aligned otherwise there is
164                  * the potential for discarding uncommitted data from the cache
165                  */
166                 if ((start & (L1_CACHE_BYTES - 1)) || (size & (L1_CACHE_BYTES - 1)))
167                         flush_dcache_range(start, end);
168                 else
169                         invalidate_dcache_range(start, end);
170                 break;
171         case DMA_TO_DEVICE:             /* writeback only */
172                 clean_dcache_range(start, end);
173                 break;
174         case DMA_BIDIRECTIONAL: /* writeback and invalidate */
175                 flush_dcache_range(start, end);
176                 break;
177         }
178 }
179 EXPORT_SYMBOL(__dma_sync);
180
181 #ifdef CONFIG_HIGHMEM
182 /*
183  * __dma_sync_page() implementation for systems using highmem.
184  * In this case, each page of a buffer must be kmapped/kunmapped
185  * in order to have a virtual address for __dma_sync(). This must
186  * not sleep so kmap_atomic()/kunmap_atomic() are used.
187  *
188  * Note: yes, it is possible and correct to have a buffer extend
189  * beyond the first page.
190  */
191 static inline void __dma_sync_page_highmem(struct page *page,
192                 unsigned long offset, size_t size, int direction)
193 {
194         size_t seg_size = min((size_t)(PAGE_SIZE - offset), size);
195         size_t cur_size = seg_size;
196         unsigned long flags, start, seg_offset = offset;
197         int nr_segs = 1 + ((size - seg_size) + PAGE_SIZE - 1)/PAGE_SIZE;
198         int seg_nr = 0;
199
200         local_irq_save(flags);
201
202         do {
203                 start = (unsigned long)kmap_atomic(page + seg_nr,
204                                 KM_PPC_SYNC_PAGE) + seg_offset;
205
206                 /* Sync this buffer segment */
207                 __dma_sync((void *)start, seg_size, direction);
208                 kunmap_atomic((void *)start, KM_PPC_SYNC_PAGE);
209                 seg_nr++;
210
211                 /* Calculate next buffer segment size */
212                 seg_size = min((size_t)PAGE_SIZE, size - cur_size);
213
214                 /* Add the segment size to our running total */
215                 cur_size += seg_size;
216                 seg_offset = 0;
217         } while (seg_nr < nr_segs);
218
219         local_irq_restore(flags);
220 }
221 #endif /* CONFIG_HIGHMEM */
222
223 /*
224  * __dma_sync_page makes memory consistent. identical to __dma_sync, but
225  * takes a struct page instead of a virtual address
226  */
227 void __dma_sync_page(struct page *page, unsigned long offset,
228         size_t size, int direction)
229 {
230 #ifdef CONFIG_HIGHMEM
231         __dma_sync_page_highmem(page, offset, size, direction);
232 #else
233         unsigned long start = (unsigned long)page_address(page) + offset;
234         __dma_sync((void *)start, size, direction);
235 #endif
236 }
237 EXPORT_SYMBOL(__dma_sync_page);