misc: nct1008: change overheat enable message
[linux-3.10.git] / drivers / base / dma-coherent.c
1 /*
2  * Coherent per-device memory handling.
3  * Borrowed from i386
4  */
5 #include <linux/slab.h>
6 #include <linux/kernel.h>
7 #include <linux/module.h>
8 #include <linux/dma-mapping.h>
9 #include <linux/dma-attrs.h>
10
11 struct dma_coherent_mem {
12         void            *virt_base;
13         dma_addr_t      device_base;
14         phys_addr_t     pfn_base;
15         int             size;
16         int             flags;
17         unsigned long   *bitmap;
18 };
19
20 int dma_declare_coherent_memory(struct device *dev, dma_addr_t bus_addr,
21                                 dma_addr_t device_addr, size_t size, int flags)
22 {
23         void __iomem *mem_base = NULL;
24         int pages = size >> PAGE_SHIFT;
25         int bitmap_size = BITS_TO_LONGS(pages) * sizeof(long);
26
27         if ((flags &
28                 (DMA_MEMORY_MAP | DMA_MEMORY_IO | DMA_MEMORY_NOMAP)) == 0)
29                 goto out;
30         if (!size)
31                 goto out;
32         if (dev->dma_mem)
33                 goto out;
34
35         /* FIXME: this routine just ignores DMA_MEMORY_INCLUDES_CHILDREN */
36
37         dev->dma_mem = kzalloc(sizeof(struct dma_coherent_mem), GFP_KERNEL);
38         if (!dev->dma_mem)
39                 goto out;
40         dev->dma_mem->bitmap = kzalloc(bitmap_size, GFP_KERNEL);
41         if (!dev->dma_mem->bitmap)
42                 goto free1_out;
43
44         if (flags & DMA_MEMORY_NOMAP)
45                 goto skip_mapping;
46
47         mem_base = ioremap(bus_addr, size);
48         if (!mem_base)
49                 goto out;
50         dev->dma_mem->virt_base = mem_base;
51
52 skip_mapping:
53         dev->dma_mem->device_base = device_addr;
54         dev->dma_mem->pfn_base = PFN_DOWN(bus_addr);
55         dev->dma_mem->size = pages;
56         dev->dma_mem->flags = flags;
57
58         if (flags & DMA_MEMORY_MAP)
59                 return DMA_MEMORY_MAP;
60
61         if (flags & DMA_MEMORY_NOMAP)
62                 return DMA_MEMORY_NOMAP;
63
64         return DMA_MEMORY_IO;
65
66  free1_out:
67         kfree(dev->dma_mem);
68  out:
69         if (mem_base)
70                 iounmap(mem_base);
71         return 0;
72 }
73 EXPORT_SYMBOL(dma_declare_coherent_memory);
74
75 void dma_release_declared_memory(struct device *dev)
76 {
77         struct dma_coherent_mem *mem = dev->dma_mem;
78
79         if (!mem)
80                 return;
81         dev->dma_mem = NULL;
82
83         if (!(mem->flags & DMA_MEMORY_NOMAP))
84                 iounmap(mem->virt_base);
85
86         kfree(mem->bitmap);
87         kfree(mem);
88 }
89 EXPORT_SYMBOL(dma_release_declared_memory);
90
91 void *dma_mark_declared_memory_occupied(struct device *dev,
92                                         dma_addr_t device_addr, size_t size)
93 {
94         struct dma_coherent_mem *mem = dev->dma_mem;
95         int pos, err;
96
97         size += device_addr & ~PAGE_MASK;
98
99         if (!mem)
100                 return ERR_PTR(-EINVAL);
101
102         pos = (device_addr - mem->device_base) >> PAGE_SHIFT;
103         err = bitmap_allocate_region(mem->bitmap, pos, get_order(size));
104         if (err != 0)
105                 return ERR_PTR(err);
106         return mem->virt_base + (pos << PAGE_SHIFT);
107 }
108 EXPORT_SYMBOL(dma_mark_declared_memory_occupied);
109
110 /**
111  * dma_alloc_from_coherent_attr() - try to allocate memory from the per-device
112  * coherent area
113  *
114  * @dev:        device from which we allocate memory
115  * @size:       size of requested memory area
116  * @dma_handle: This will be filled with the correct dma handle
117  * @ret:        This pointer will be filled with the virtual address
118  *              to allocated area.
119  * @attrs:      DMA Attribute
120  * This function should be only called from per-arch dma_alloc_coherent()
121  * to support allocation from per-device coherent memory pools.
122  *
123  * Returns 0 if dma_alloc_coherent_attr should continue with allocating from
124  * generic memory areas, or !0 if dma_alloc_coherent should return @ret.
125  */
126 int dma_alloc_from_coherent_attr(struct device *dev, ssize_t size,
127                                        dma_addr_t *dma_handle, void **ret,
128                                        struct dma_attrs *attrs)
129 {
130         struct dma_coherent_mem *mem;
131         int order = get_order(size);
132         int pageno;
133         unsigned int count;
134         unsigned long align;
135
136         if (!dev)
137                 return 0;
138         mem = dev->dma_mem;
139         if (!mem)
140                 return 0;
141
142         *ret = NULL;
143
144         if (unlikely(size > (mem->size << PAGE_SHIFT)))
145                 goto err;
146
147         if (dma_get_attr(DMA_ATTR_ALLOC_EXACT_SIZE, attrs)) {
148                 align = 0;
149                 count = PAGE_ALIGN(size) >> PAGE_SHIFT;
150         } else  {
151                 align = (1 << order) - 1;
152                 count = 1 << order;
153         }
154
155         pageno = bitmap_find_next_zero_area(mem->bitmap, mem->size,
156                         0, count, align);
157
158         if (pageno >= mem->size)
159                 goto err;
160
161         bitmap_set(mem->bitmap, pageno, count);
162
163         /*
164          * Memory was found in the per-device area.
165          */
166         *dma_handle = mem->device_base + (pageno << PAGE_SHIFT);
167         if (!(mem->flags & DMA_MEMORY_NOMAP)) {
168                 *ret = mem->virt_base + (pageno << PAGE_SHIFT);
169                 memset(*ret, 0, size);
170         }
171
172         return 1;
173
174 err:
175         /*
176          * In the case where the allocation can not be satisfied from the
177          * per-device area, try to fall back to generic memory if the
178          * constraints allow it.
179          */
180         return mem->flags & DMA_MEMORY_EXCLUSIVE;
181 }
182 EXPORT_SYMBOL(dma_alloc_from_coherent_attr);
183
184 /**
185  * dma_release_from_coherent_attr() - try to free the memory allocated from
186  * per-device coherent memory pool
187  * @dev:        device from which the memory was allocated
188  * @size:       size of the memory area to free
189  * @vaddr:      virtual address of allocated pages
190  * @attrs:      DMA Attribute
191  *
192  * This checks whether the memory was allocated from the per-device
193  * coherent memory pool and if so, releases that memory.
194  *
195  * Returns 1 if we correctly released the memory, or 0 if
196  * dma_release_coherent_attr() should proceed with releasing memory from
197  * generic pools.
198  */
199 int dma_release_from_coherent_attr(struct device *dev, size_t size, void *vaddr,
200                                 struct dma_attrs *attrs)
201 {
202         struct dma_coherent_mem *mem = dev ? dev->dma_mem : NULL;
203         void *mem_addr;
204         unsigned int count;
205         unsigned int pageno;
206
207         if (!mem)
208                 return 0;
209
210         if (mem->flags & DMA_MEMORY_NOMAP)
211                 mem_addr =  (void *)mem->device_base;
212         else
213                 mem_addr =  mem->virt_base;
214
215
216         if (mem && vaddr >= mem_addr &&
217             vaddr - mem_addr < mem->size << PAGE_SHIFT) {
218
219                 pageno = (vaddr - mem_addr) >> PAGE_SHIFT;
220
221                 if (dma_get_attr(DMA_ATTR_ALLOC_EXACT_SIZE, attrs))
222                         count = PAGE_ALIGN(size) >> PAGE_SHIFT;
223                 else
224                         count = 1 << get_order(size);
225
226                 bitmap_clear(mem->bitmap, pageno, count);
227
228                 return 1;
229         }
230         return 0;
231 }
232 EXPORT_SYMBOL(dma_release_from_coherent_attr);
233
234 /**
235  * dma_mmap_from_coherent() - try to mmap the memory allocated from
236  * per-device coherent memory pool to userspace
237  * @dev:        device from which the memory was allocated
238  * @vma:        vm_area for the userspace memory
239  * @vaddr:      cpu address returned by dma_alloc_from_coherent
240  * @size:       size of the memory buffer allocated by dma_alloc_from_coherent
241  * @ret:        result from remap_pfn_range()
242  *
243  * This checks whether the memory was allocated from the per-device
244  * coherent memory pool and if so, maps that memory to the provided vma.
245  *
246  * Returns 1 if we correctly mapped the memory, or 0 if the caller should
247  * proceed with mapping memory from generic pools.
248  */
249 int dma_mmap_from_coherent(struct device *dev, struct vm_area_struct *vma,
250                            void *vaddr, size_t size, int *ret)
251 {
252         struct dma_coherent_mem *mem = dev ? dev->dma_mem : NULL;
253         void *mem_addr;
254
255         if (!mem)
256                 return 0;
257
258         if (mem->flags & DMA_MEMORY_NOMAP)
259                 mem_addr =  (void *)mem->device_base;
260         else
261                 mem_addr =  mem->virt_base;
262
263         if (mem && vaddr >= mem_addr && vaddr + size <=
264                    (mem_addr + (mem->size << PAGE_SHIFT))) {
265                 unsigned long off = vma->vm_pgoff;
266                 int start = (vaddr - mem_addr) >> PAGE_SHIFT;
267                 int user_count = (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;
268                 int count = size >> PAGE_SHIFT;
269
270                 *ret = -ENXIO;
271                 if (off < count && user_count <= count - off) {
272                         unsigned pfn = mem->pfn_base + start + off;
273                         *ret = remap_pfn_range(vma, vma->vm_start, pfn,
274                                                user_count << PAGE_SHIFT,
275                                                vma->vm_page_prot);
276                 }
277                 return 1;
278         }
279         return 0;
280 }
281 EXPORT_SYMBOL(dma_mmap_from_coherent);