blob: a0119ae67dcd709fd870b986cb21ac4be2874ed6 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Digital Audio (PCM) abstract layer
3 * Copyright (c) by Jaroslav Kysela <perex@suse.cz>
4 *
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 *
20 */
21
22#include <sound/driver.h>
23#include <asm/io.h>
24#include <linux/time.h>
25#include <linux/init.h>
26#include <linux/moduleparam.h>
27#include <sound/core.h>
28#include <sound/pcm.h>
29#include <sound/info.h>
30#include <sound/initval.h>
31
32static int preallocate_dma = 1;
33module_param(preallocate_dma, int, 0444);
34MODULE_PARM_DESC(preallocate_dma, "Preallocate DMA memory when the PCM devices are initialized.");
35
36static int maximum_substreams = 4;
37module_param(maximum_substreams, int, 0444);
38MODULE_PARM_DESC(maximum_substreams, "Maximum substreams with preallocated DMA memory.");
39
40static const size_t snd_minimum_buffer = 16384;
41
42
43/*
44 * try to allocate as the large pages as possible.
45 * stores the resultant memory size in *res_size.
46 *
47 * the minimum size is snd_minimum_buffer. it should be power of 2.
48 */
Takashi Iwai877211f2005-11-17 13:59:38 +010049static int preallocate_pcm_pages(struct snd_pcm_substream *substream, size_t size)
Linus Torvalds1da177e2005-04-16 15:20:36 -070050{
51 struct snd_dma_buffer *dmab = &substream->dma_buffer;
52 int err;
53
54 snd_assert(size > 0, return -EINVAL);
55
56 /* already reserved? */
57 if (snd_dma_get_reserved_buf(dmab, substream->dma_buf_id) > 0) {
58 if (dmab->bytes >= size)
59 return 0; /* yes */
60 /* no, free the reserved block */
61 snd_dma_free_pages(dmab);
62 dmab->bytes = 0;
63 }
64
65 do {
66 if ((err = snd_dma_alloc_pages(dmab->dev.type, dmab->dev.dev,
67 size, dmab)) < 0) {
68 if (err != -ENOMEM)
69 return err; /* fatal error */
70 } else
71 return 0;
72 size >>= 1;
73 } while (size >= snd_minimum_buffer);
74 dmab->bytes = 0; /* tell error */
75 return 0;
76}
77
78/*
79 * release the preallocated buffer if not yet done.
80 */
Takashi Iwai877211f2005-11-17 13:59:38 +010081static void snd_pcm_lib_preallocate_dma_free(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -070082{
83 if (substream->dma_buffer.area == NULL)
84 return;
85 if (substream->dma_buf_id)
86 snd_dma_reserve_buf(&substream->dma_buffer, substream->dma_buf_id);
87 else
88 snd_dma_free_pages(&substream->dma_buffer);
89 substream->dma_buffer.area = NULL;
90}
91
92/**
93 * snd_pcm_lib_preallocate_free - release the preallocated buffer of the specified substream.
94 * @substream: the pcm substream instance
95 *
96 * Releases the pre-allocated buffer of the given substream.
97 *
98 * Returns zero if successful, or a negative error code on failure.
99 */
Takashi Iwai877211f2005-11-17 13:59:38 +0100100int snd_pcm_lib_preallocate_free(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101{
102 snd_pcm_lib_preallocate_dma_free(substream);
Takashi Iwaie28563c2005-12-01 10:42:42 +0100103 snd_info_unregister(substream->proc_prealloc_entry);
104 substream->proc_prealloc_entry = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 return 0;
106}
107
108/**
109 * snd_pcm_lib_preallocate_free_for_all - release all pre-allocated buffers on the pcm
110 * @pcm: the pcm instance
111 *
112 * Releases all the pre-allocated buffers on the given pcm.
113 *
114 * Returns zero if successful, or a negative error code on failure.
115 */
Takashi Iwai877211f2005-11-17 13:59:38 +0100116int snd_pcm_lib_preallocate_free_for_all(struct snd_pcm *pcm)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117{
Takashi Iwai877211f2005-11-17 13:59:38 +0100118 struct snd_pcm_substream *substream;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 int stream;
120
121 for (stream = 0; stream < 2; stream++)
122 for (substream = pcm->streams[stream].substream; substream; substream = substream->next)
123 snd_pcm_lib_preallocate_free(substream);
124 return 0;
125}
126
Takashi Iwaie28563c2005-12-01 10:42:42 +0100127#ifdef CONFIG_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128/*
129 * read callback for prealloc proc file
130 *
131 * prints the current allocated size in kB.
132 */
Takashi Iwai877211f2005-11-17 13:59:38 +0100133static void snd_pcm_lib_preallocate_proc_read(struct snd_info_entry *entry,
134 struct snd_info_buffer *buffer)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135{
Takashi Iwai877211f2005-11-17 13:59:38 +0100136 struct snd_pcm_substream *substream = entry->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 snd_iprintf(buffer, "%lu\n", (unsigned long) substream->dma_buffer.bytes / 1024);
138}
139
140/*
141 * write callback for prealloc proc file
142 *
143 * accepts the preallocation size in kB.
144 */
Takashi Iwai877211f2005-11-17 13:59:38 +0100145static void snd_pcm_lib_preallocate_proc_write(struct snd_info_entry *entry,
146 struct snd_info_buffer *buffer)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147{
Takashi Iwai877211f2005-11-17 13:59:38 +0100148 struct snd_pcm_substream *substream = entry->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 char line[64], str[64];
150 size_t size;
151 struct snd_dma_buffer new_dmab;
152
153 if (substream->runtime) {
154 buffer->error = -EBUSY;
155 return;
156 }
157 if (!snd_info_get_line(buffer, line, sizeof(line))) {
158 snd_info_get_str(str, line, sizeof(str));
159 size = simple_strtoul(str, NULL, 10) * 1024;
160 if ((size != 0 && size < 8192) || size > substream->dma_max) {
161 buffer->error = -EINVAL;
162 return;
163 }
164 if (substream->dma_buffer.bytes == size)
165 return;
166 memset(&new_dmab, 0, sizeof(new_dmab));
167 new_dmab.dev = substream->dma_buffer.dev;
168 if (size > 0) {
169 if (snd_dma_alloc_pages(substream->dma_buffer.dev.type,
170 substream->dma_buffer.dev.dev,
171 size, &new_dmab) < 0) {
172 buffer->error = -ENOMEM;
173 return;
174 }
175 substream->buffer_bytes_max = size;
176 } else {
177 substream->buffer_bytes_max = UINT_MAX;
178 }
179 if (substream->dma_buffer.area)
180 snd_dma_free_pages(&substream->dma_buffer);
181 substream->dma_buffer = new_dmab;
182 } else {
183 buffer->error = -EINVAL;
184 }
185}
186
Takashi Iwaie28563c2005-12-01 10:42:42 +0100187static inline void preallocate_info_init(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188{
Takashi Iwai877211f2005-11-17 13:59:38 +0100189 struct snd_info_entry *entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 if ((entry = snd_info_create_card_entry(substream->pcm->card, "prealloc", substream->proc_root)) != NULL) {
192 entry->c.text.read_size = 64;
193 entry->c.text.read = snd_pcm_lib_preallocate_proc_read;
194 entry->c.text.write_size = 64;
195 entry->c.text.write = snd_pcm_lib_preallocate_proc_write;
Takashi Iwaibd7bf042005-04-12 16:27:28 +0200196 entry->mode |= S_IWUSR;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 entry->private_data = substream;
198 if (snd_info_register(entry) < 0) {
199 snd_info_free_entry(entry);
200 entry = NULL;
201 }
202 }
203 substream->proc_prealloc_entry = entry;
Takashi Iwaie28563c2005-12-01 10:42:42 +0100204}
205
206#else /* !CONFIG_PROC_FS */
207#define preallocate_info_init(s)
208#endif
209
210/*
211 * pre-allocate the buffer and create a proc file for the substream
212 */
213static int snd_pcm_lib_preallocate_pages1(struct snd_pcm_substream *substream,
214 size_t size, size_t max)
215{
216
217 if (size > 0 && preallocate_dma && substream->number < maximum_substreams)
218 preallocate_pcm_pages(substream, size);
219
220 if (substream->dma_buffer.bytes > 0)
221 substream->buffer_bytes_max = substream->dma_buffer.bytes;
222 substream->dma_max = max;
223 preallocate_info_init(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 return 0;
225}
226
227
228/**
229 * snd_pcm_lib_preallocate_pages - pre-allocation for the given DMA type
230 * @substream: the pcm substream instance
231 * @type: DMA type (SNDRV_DMA_TYPE_*)
232 * @data: DMA type dependant data
233 * @size: the requested pre-allocation size in bytes
234 * @max: the max. allowed pre-allocation size
235 *
236 * Do pre-allocation for the given DMA buffer type.
237 *
238 * When substream->dma_buf_id is set, the function tries to look for
239 * the reserved buffer, and the buffer is not freed but reserved at
240 * destruction time. The dma_buf_id must be unique for all systems
241 * (in the same DMA buffer type) e.g. using snd_dma_pci_buf_id().
242 *
243 * Returns zero if successful, or a negative error code on failure.
244 */
Takashi Iwai877211f2005-11-17 13:59:38 +0100245int snd_pcm_lib_preallocate_pages(struct snd_pcm_substream *substream,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 int type, struct device *data,
247 size_t size, size_t max)
248{
249 substream->dma_buffer.dev.type = type;
250 substream->dma_buffer.dev.dev = data;
251 return snd_pcm_lib_preallocate_pages1(substream, size, max);
252}
253
254/**
255 * snd_pcm_lib_preallocate_pages_for_all - pre-allocation for continous memory type (all substreams)
Takashi Iwaidf8db932005-09-07 13:38:19 +0200256 * @pcm: the pcm instance
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 * @type: DMA type (SNDRV_DMA_TYPE_*)
258 * @data: DMA type dependant data
259 * @size: the requested pre-allocation size in bytes
260 * @max: the max. allowed pre-allocation size
261 *
262 * Do pre-allocation to all substreams of the given pcm for the
263 * specified DMA type.
264 *
265 * Returns zero if successful, or a negative error code on failure.
266 */
Takashi Iwai877211f2005-11-17 13:59:38 +0100267int snd_pcm_lib_preallocate_pages_for_all(struct snd_pcm *pcm,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 int type, void *data,
269 size_t size, size_t max)
270{
Takashi Iwai877211f2005-11-17 13:59:38 +0100271 struct snd_pcm_substream *substream;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 int stream, err;
273
274 for (stream = 0; stream < 2; stream++)
275 for (substream = pcm->streams[stream].substream; substream; substream = substream->next)
276 if ((err = snd_pcm_lib_preallocate_pages(substream, type, data, size, max)) < 0)
277 return err;
278 return 0;
279}
280
281/**
282 * snd_pcm_sgbuf_ops_page - get the page struct at the given offset
283 * @substream: the pcm substream instance
284 * @offset: the buffer offset
285 *
286 * Returns the page struct at the given buffer offset.
287 * Used as the page callback of PCM ops.
288 */
Takashi Iwai877211f2005-11-17 13:59:38 +0100289struct page *snd_pcm_sgbuf_ops_page(struct snd_pcm_substream *substream, unsigned long offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290{
291 struct snd_sg_buf *sgbuf = snd_pcm_substream_sgbuf(substream);
292
293 unsigned int idx = offset >> PAGE_SHIFT;
294 if (idx >= (unsigned int)sgbuf->pages)
295 return NULL;
296 return sgbuf->page_table[idx];
297}
298
299/**
300 * snd_pcm_lib_malloc_pages - allocate the DMA buffer
301 * @substream: the substream to allocate the DMA buffer to
302 * @size: the requested buffer size in bytes
303 *
304 * Allocates the DMA buffer on the BUS type given earlier to
305 * snd_pcm_lib_preallocate_xxx_pages().
306 *
307 * Returns 1 if the buffer is changed, 0 if not changed, or a negative
308 * code on failure.
309 */
Takashi Iwai877211f2005-11-17 13:59:38 +0100310int snd_pcm_lib_malloc_pages(struct snd_pcm_substream *substream, size_t size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311{
Takashi Iwai877211f2005-11-17 13:59:38 +0100312 struct snd_pcm_runtime *runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 struct snd_dma_buffer *dmab = NULL;
314
315 snd_assert(substream->dma_buffer.dev.type != SNDRV_DMA_TYPE_UNKNOWN, return -EINVAL);
316 snd_assert(substream != NULL, return -EINVAL);
317 runtime = substream->runtime;
318 snd_assert(runtime != NULL, return -EINVAL);
319
320 if (runtime->dma_buffer_p) {
321 /* perphaps, we might free the large DMA memory region
322 to save some space here, but the actual solution
323 costs us less time */
324 if (runtime->dma_buffer_p->bytes >= size) {
325 runtime->dma_bytes = size;
326 return 0; /* ok, do not change */
327 }
328 snd_pcm_lib_free_pages(substream);
329 }
Takashi Iwai877211f2005-11-17 13:59:38 +0100330 if (substream->dma_buffer.area != NULL &&
331 substream->dma_buffer.bytes >= size) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 dmab = &substream->dma_buffer; /* use the pre-allocated buffer */
333 } else {
Takashi Iwaica2c0962005-09-09 14:20:23 +0200334 dmab = kzalloc(sizeof(*dmab), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 if (! dmab)
336 return -ENOMEM;
337 dmab->dev = substream->dma_buffer.dev;
338 if (snd_dma_alloc_pages(substream->dma_buffer.dev.type,
339 substream->dma_buffer.dev.dev,
340 size, dmab) < 0) {
341 kfree(dmab);
342 return -ENOMEM;
343 }
344 }
345 snd_pcm_set_runtime_buffer(substream, dmab);
346 runtime->dma_bytes = size;
347 return 1; /* area was changed */
348}
349
350/**
351 * snd_pcm_lib_free_pages - release the allocated DMA buffer.
352 * @substream: the substream to release the DMA buffer
353 *
354 * Releases the DMA buffer allocated via snd_pcm_lib_malloc_pages().
355 *
356 * Returns zero if successful, or a negative error code on failure.
357 */
Takashi Iwai877211f2005-11-17 13:59:38 +0100358int snd_pcm_lib_free_pages(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359{
Takashi Iwai877211f2005-11-17 13:59:38 +0100360 struct snd_pcm_runtime *runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361
362 snd_assert(substream != NULL, return -EINVAL);
363 runtime = substream->runtime;
364 snd_assert(runtime != NULL, return -EINVAL);
365 if (runtime->dma_area == NULL)
366 return 0;
367 if (runtime->dma_buffer_p != &substream->dma_buffer) {
368 /* it's a newly allocated buffer. release it now. */
369 snd_dma_free_pages(runtime->dma_buffer_p);
370 kfree(runtime->dma_buffer_p);
371 }
372 snd_pcm_set_runtime_buffer(substream, NULL);
373 return 0;
374}