Merge branch 'work.iov_iter' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs
[muen/linux.git] / sound / core / memalloc.c
1 /*
2  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
3  *                   Takashi Iwai <tiwai@suse.de>
4  * 
5  *  Generic memory allocators
6  *
7  *
8  *   This program is free software; you can redistribute it and/or modify
9  *   it under the terms of the GNU General Public License as published by
10  *   the Free Software Foundation; either version 2 of the License, or
11  *   (at your option) any later version.
12  *
13  *   This program is distributed in the hope that it will be useful,
14  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
15  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  *   GNU General Public License for more details.
17  *
18  *   You should have received a copy of the GNU General Public License
19  *   along with this program; if not, write to the Free Software
20  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
21  *
22  */
23
24 #include <linux/slab.h>
25 #include <linux/mm.h>
26 #include <linux/dma-mapping.h>
27 #include <linux/genalloc.h>
28 #include <sound/memalloc.h>
29
30 /*
31  *
32  *  Generic memory allocators
33  *
34  */
35
36 /**
37  * snd_malloc_pages - allocate pages with the given size
38  * @size: the size to allocate in bytes
39  * @gfp_flags: the allocation conditions, GFP_XXX
40  *
41  * Allocates the physically contiguous pages with the given size.
42  *
43  * Return: The pointer of the buffer, or %NULL if no enough memory.
44  */
45 void *snd_malloc_pages(size_t size, gfp_t gfp_flags)
46 {
47         int pg;
48
49         if (WARN_ON(!size))
50                 return NULL;
51         if (WARN_ON(!gfp_flags))
52                 return NULL;
53         gfp_flags |= __GFP_COMP;        /* compound page lets parts be mapped */
54         pg = get_order(size);
55         return (void *) __get_free_pages(gfp_flags, pg);
56 }
57
58 /**
59  * snd_free_pages - release the pages
60  * @ptr: the buffer pointer to release
61  * @size: the allocated buffer size
62  *
63  * Releases the buffer allocated via snd_malloc_pages().
64  */
65 void snd_free_pages(void *ptr, size_t size)
66 {
67         int pg;
68
69         if (ptr == NULL)
70                 return;
71         pg = get_order(size);
72         free_pages((unsigned long) ptr, pg);
73 }
74
75 /*
76  *
77  *  Bus-specific memory allocators
78  *
79  */
80
81 #ifdef CONFIG_HAS_DMA
82 /* allocate the coherent DMA pages */
83 static void *snd_malloc_dev_pages(struct device *dev, size_t size, dma_addr_t *dma)
84 {
85         int pg;
86         gfp_t gfp_flags;
87
88         if (WARN_ON(!dma))
89                 return NULL;
90         pg = get_order(size);
91         gfp_flags = GFP_KERNEL
92                 | __GFP_COMP    /* compound page lets parts be mapped */
93                 | __GFP_NORETRY /* don't trigger OOM-killer */
94                 | __GFP_NOWARN; /* no stack trace print - this call is non-critical */
95         return dma_alloc_coherent(dev, PAGE_SIZE << pg, dma, gfp_flags);
96 }
97
98 /* free the coherent DMA pages */
99 static void snd_free_dev_pages(struct device *dev, size_t size, void *ptr,
100                                dma_addr_t dma)
101 {
102         int pg;
103
104         if (ptr == NULL)
105                 return;
106         pg = get_order(size);
107         dma_free_coherent(dev, PAGE_SIZE << pg, ptr, dma);
108 }
109
110 #ifdef CONFIG_GENERIC_ALLOCATOR
111 /**
112  * snd_malloc_dev_iram - allocate memory from on-chip internal ram
113  * @dmab: buffer allocation record to store the allocated data
114  * @size: number of bytes to allocate from the iram
115  *
116  * This function requires iram phandle provided via of_node
117  */
118 static void snd_malloc_dev_iram(struct snd_dma_buffer *dmab, size_t size)
119 {
120         struct device *dev = dmab->dev.dev;
121         struct gen_pool *pool = NULL;
122
123         dmab->area = NULL;
124         dmab->addr = 0;
125
126         if (dev->of_node)
127                 pool = of_gen_pool_get(dev->of_node, "iram", 0);
128
129         if (!pool)
130                 return;
131
132         /* Assign the pool into private_data field */
133         dmab->private_data = pool;
134
135         dmab->area = gen_pool_dma_alloc(pool, size, &dmab->addr);
136 }
137
138 /**
139  * snd_free_dev_iram - free allocated specific memory from on-chip internal ram
140  * @dmab: buffer allocation record to store the allocated data
141  */
142 static void snd_free_dev_iram(struct snd_dma_buffer *dmab)
143 {
144         struct gen_pool *pool = dmab->private_data;
145
146         if (pool && dmab->area)
147                 gen_pool_free(pool, (unsigned long)dmab->area, dmab->bytes);
148 }
149 #endif /* CONFIG_GENERIC_ALLOCATOR */
150 #endif /* CONFIG_HAS_DMA */
151
152 /*
153  *
154  *  ALSA generic memory management
155  *
156  */
157
158
159 /**
160  * snd_dma_alloc_pages - allocate the buffer area according to the given type
161  * @type: the DMA buffer type
162  * @device: the device pointer
163  * @size: the buffer size to allocate
164  * @dmab: buffer allocation record to store the allocated data
165  *
166  * Calls the memory-allocator function for the corresponding
167  * buffer type.
168  *
169  * Return: Zero if the buffer with the given size is allocated successfully,
170  * otherwise a negative value on error.
171  */
172 int snd_dma_alloc_pages(int type, struct device *device, size_t size,
173                         struct snd_dma_buffer *dmab)
174 {
175         if (WARN_ON(!size))
176                 return -ENXIO;
177         if (WARN_ON(!dmab))
178                 return -ENXIO;
179
180         dmab->dev.type = type;
181         dmab->dev.dev = device;
182         dmab->bytes = 0;
183         switch (type) {
184         case SNDRV_DMA_TYPE_CONTINUOUS:
185                 dmab->area = snd_malloc_pages(size,
186                                         (__force gfp_t)(unsigned long)device);
187                 dmab->addr = 0;
188                 break;
189 #ifdef CONFIG_HAS_DMA
190 #ifdef CONFIG_GENERIC_ALLOCATOR
191         case SNDRV_DMA_TYPE_DEV_IRAM:
192                 snd_malloc_dev_iram(dmab, size);
193                 if (dmab->area)
194                         break;
195                 /* Internal memory might have limited size and no enough space,
196                  * so if we fail to malloc, try to fetch memory traditionally.
197                  */
198                 dmab->dev.type = SNDRV_DMA_TYPE_DEV;
199 #endif /* CONFIG_GENERIC_ALLOCATOR */
200         case SNDRV_DMA_TYPE_DEV:
201                 dmab->area = snd_malloc_dev_pages(device, size, &dmab->addr);
202                 break;
203 #endif
204 #ifdef CONFIG_SND_DMA_SGBUF
205         case SNDRV_DMA_TYPE_DEV_SG:
206                 snd_malloc_sgbuf_pages(device, size, dmab, NULL);
207                 break;
208 #endif
209         default:
210                 pr_err("snd-malloc: invalid device type %d\n", type);
211                 dmab->area = NULL;
212                 dmab->addr = 0;
213                 return -ENXIO;
214         }
215         if (! dmab->area)
216                 return -ENOMEM;
217         dmab->bytes = size;
218         return 0;
219 }
220
221 /**
222  * snd_dma_alloc_pages_fallback - allocate the buffer area according to the given type with fallback
223  * @type: the DMA buffer type
224  * @device: the device pointer
225  * @size: the buffer size to allocate
226  * @dmab: buffer allocation record to store the allocated data
227  *
228  * Calls the memory-allocator function for the corresponding
229  * buffer type.  When no space is left, this function reduces the size and
230  * tries to allocate again.  The size actually allocated is stored in
231  * res_size argument.
232  *
233  * Return: Zero if the buffer with the given size is allocated successfully,
234  * otherwise a negative value on error.
235  */
236 int snd_dma_alloc_pages_fallback(int type, struct device *device, size_t size,
237                                  struct snd_dma_buffer *dmab)
238 {
239         int err;
240
241         while ((err = snd_dma_alloc_pages(type, device, size, dmab)) < 0) {
242                 size_t aligned_size;
243                 if (err != -ENOMEM)
244                         return err;
245                 if (size <= PAGE_SIZE)
246                         return -ENOMEM;
247                 aligned_size = PAGE_SIZE << get_order(size);
248                 if (size != aligned_size)
249                         size = aligned_size;
250                 else
251                         size >>= 1;
252         }
253         if (! dmab->area)
254                 return -ENOMEM;
255         return 0;
256 }
257
258
259 /**
260  * snd_dma_free_pages - release the allocated buffer
261  * @dmab: the buffer allocation record to release
262  *
263  * Releases the allocated buffer via snd_dma_alloc_pages().
264  */
265 void snd_dma_free_pages(struct snd_dma_buffer *dmab)
266 {
267         switch (dmab->dev.type) {
268         case SNDRV_DMA_TYPE_CONTINUOUS:
269                 snd_free_pages(dmab->area, dmab->bytes);
270                 break;
271 #ifdef CONFIG_HAS_DMA
272 #ifdef CONFIG_GENERIC_ALLOCATOR
273         case SNDRV_DMA_TYPE_DEV_IRAM:
274                 snd_free_dev_iram(dmab);
275                 break;
276 #endif /* CONFIG_GENERIC_ALLOCATOR */
277         case SNDRV_DMA_TYPE_DEV:
278                 snd_free_dev_pages(dmab->dev.dev, dmab->bytes, dmab->area, dmab->addr);
279                 break;
280 #endif
281 #ifdef CONFIG_SND_DMA_SGBUF
282         case SNDRV_DMA_TYPE_DEV_SG:
283                 snd_free_sgbuf_pages(dmab);
284                 break;
285 #endif
286         default:
287                 pr_err("snd-malloc: invalid device type %d\n", dmab->dev.type);
288         }
289 }
290
291 /*
292  * exports
293  */
294 EXPORT_SYMBOL(snd_dma_alloc_pages);
295 EXPORT_SYMBOL(snd_dma_alloc_pages_fallback);
296 EXPORT_SYMBOL(snd_dma_free_pages);
297
298 EXPORT_SYMBOL(snd_malloc_pages);
299 EXPORT_SYMBOL(snd_free_pages);