linux/sound/core/pcm_memory.c
<<
>>
Prefs
   1/*
   2 *  Digital Audio (PCM) abstract layer
   3 *  Copyright (c) by Jaroslav Kysela <perex@perex.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 */
  49static int preallocate_pcm_pages(struct snd_pcm_substream *substream, size_t size)
  50{
  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 */
  81static void snd_pcm_lib_preallocate_dma_free(struct snd_pcm_substream *substream)
  82{
  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 */
 100int snd_pcm_lib_preallocate_free(struct snd_pcm_substream *substream)
 101{
 102        snd_pcm_lib_preallocate_dma_free(substream);
 103#ifdef CONFIG_SND_VERBOSE_PROCFS
 104        snd_info_free_entry(substream->proc_prealloc_max_entry);
 105        substream->proc_prealloc_max_entry = NULL;
 106        snd_info_free_entry(substream->proc_prealloc_entry);
 107        substream->proc_prealloc_entry = NULL;
 108#endif
 109        return 0;
 110}
 111
 112/**
 113 * snd_pcm_lib_preallocate_free_for_all - release all pre-allocated buffers on the pcm
 114 * @pcm: the pcm instance
 115 *
 116 * Releases all the pre-allocated buffers on the given pcm.
 117 *
 118 * Returns zero if successful, or a negative error code on failure.
 119 */
 120int snd_pcm_lib_preallocate_free_for_all(struct snd_pcm *pcm)
 121{
 122        struct snd_pcm_substream *substream;
 123        int stream;
 124
 125        for (stream = 0; stream < 2; stream++)
 126                for (substream = pcm->streams[stream].substream; substream; substream = substream->next)
 127                        snd_pcm_lib_preallocate_free(substream);
 128        return 0;
 129}
 130
 131EXPORT_SYMBOL(snd_pcm_lib_preallocate_free_for_all);
 132
 133#ifdef CONFIG_SND_VERBOSE_PROCFS
 134/*
 135 * read callback for prealloc proc file
 136 *
 137 * prints the current allocated size in kB.
 138 */
 139static void snd_pcm_lib_preallocate_proc_read(struct snd_info_entry *entry,
 140                                              struct snd_info_buffer *buffer)
 141{
 142        struct snd_pcm_substream *substream = entry->private_data;
 143        snd_iprintf(buffer, "%lu\n", (unsigned long) substream->dma_buffer.bytes / 1024);
 144}
 145
 146/*
 147 * read callback for prealloc_max proc file
 148 *
 149 * prints the maximum allowed size in kB.
 150 */
 151static void snd_pcm_lib_preallocate_max_proc_read(struct snd_info_entry *entry,
 152                                                  struct snd_info_buffer *buffer)
 153{
 154        struct snd_pcm_substream *substream = entry->private_data;
 155        snd_iprintf(buffer, "%lu\n", (unsigned long) substream->dma_max / 1024);
 156}
 157
 158/*
 159 * write callback for prealloc proc file
 160 *
 161 * accepts the preallocation size in kB.
 162 */
 163static void snd_pcm_lib_preallocate_proc_write(struct snd_info_entry *entry,
 164                                               struct snd_info_buffer *buffer)
 165{
 166        struct snd_pcm_substream *substream = entry->private_data;
 167        char line[64], str[64];
 168        size_t size;
 169        struct snd_dma_buffer new_dmab;
 170
 171        if (substream->runtime) {
 172                buffer->error = -EBUSY;
 173                return;
 174        }
 175        if (!snd_info_get_line(buffer, line, sizeof(line))) {
 176                snd_info_get_str(str, line, sizeof(str));
 177                size = simple_strtoul(str, NULL, 10) * 1024;
 178                if ((size != 0 && size < 8192) || size > substream->dma_max) {
 179                        buffer->error = -EINVAL;
 180                        return;
 181                }
 182                if (substream->dma_buffer.bytes == size)
 183                        return;
 184                memset(&new_dmab, 0, sizeof(new_dmab));
 185                new_dmab.dev = substream->dma_buffer.dev;
 186                if (size > 0) {
 187                        if (snd_dma_alloc_pages(substream->dma_buffer.dev.type,
 188                                                substream->dma_buffer.dev.dev,
 189                                                size, &new_dmab) < 0) {
 190                                buffer->error = -ENOMEM;
 191                                return;
 192                        }
 193                        substream->buffer_bytes_max = size;
 194                } else {
 195                        substream->buffer_bytes_max = UINT_MAX;
 196                }
 197                if (substream->dma_buffer.area)
 198                        snd_dma_free_pages(&substream->dma_buffer);
 199                substream->dma_buffer = new_dmab;
 200        } else {
 201                buffer->error = -EINVAL;
 202        }
 203}
 204
 205static inline void preallocate_info_init(struct snd_pcm_substream *substream)
 206{
 207        struct snd_info_entry *entry;
 208
 209        if ((entry = snd_info_create_card_entry(substream->pcm->card, "prealloc", substream->proc_root)) != NULL) {
 210                entry->c.text.read = snd_pcm_lib_preallocate_proc_read;
 211                entry->c.text.write = snd_pcm_lib_preallocate_proc_write;
 212                entry->mode |= S_IWUSR;
 213                entry->private_data = substream;
 214                if (snd_info_register(entry) < 0) {
 215                        snd_info_free_entry(entry);
 216                        entry = NULL;
 217                }
 218        }
 219        substream->proc_prealloc_entry = entry;
 220        if ((entry = snd_info_create_card_entry(substream->pcm->card, "prealloc_max", substream->proc_root)) != NULL) {
 221                entry->c.text.read = snd_pcm_lib_preallocate_max_proc_read;
 222                entry->private_data = substream;
 223                if (snd_info_register(entry) < 0) {
 224                        snd_info_free_entry(entry);
 225                        entry = NULL;
 226                }
 227        }
 228        substream->proc_prealloc_max_entry = entry;
 229}
 230
 231#else /* !CONFIG_SND_VERBOSE_PROCFS */
 232#define preallocate_info_init(s)
 233#endif /* CONFIG_SND_VERBOSE_PROCFS */
 234
 235/*
 236 * pre-allocate the buffer and create a proc file for the substream
 237 */
 238static int snd_pcm_lib_preallocate_pages1(struct snd_pcm_substream *substream,
 239                                          size_t size, size_t max)
 240{
 241
 242        if (size > 0 && preallocate_dma && substream->number < maximum_substreams)
 243                preallocate_pcm_pages(substream, size);
 244
 245        if (substream->dma_buffer.bytes > 0)
 246                substream->buffer_bytes_max = substream->dma_buffer.bytes;
 247        substream->dma_max = max;
 248        preallocate_info_init(substream);
 249        return 0;
 250}
 251
 252
 253/**
 254 * snd_pcm_lib_preallocate_pages - pre-allocation for the given DMA type
 255 * @substream: the pcm substream instance
 256 * @type: DMA type (SNDRV_DMA_TYPE_*)
 257 * @data: DMA type dependant data
 258 * @size: the requested pre-allocation size in bytes
 259 * @max: the max. allowed pre-allocation size
 260 *
 261 * Do pre-allocation for the given DMA buffer type.
 262 *
 263 * When substream->dma_buf_id is set, the function tries to look for
 264 * the reserved buffer, and the buffer is not freed but reserved at
 265 * destruction time.  The dma_buf_id must be unique for all systems
 266 * (in the same DMA buffer type) e.g. using snd_dma_pci_buf_id().
 267 *
 268 * Returns zero if successful, or a negative error code on failure.
 269 */
 270int snd_pcm_lib_preallocate_pages(struct snd_pcm_substream *substream,
 271                                  int type, struct device *data,
 272                                  size_t size, size_t max)
 273{
 274        substream->dma_buffer.dev.type = type;
 275        substream->dma_buffer.dev.dev = data;
 276        return snd_pcm_lib_preallocate_pages1(substream, size, max);
 277}
 278
 279EXPORT_SYMBOL(snd_pcm_lib_preallocate_pages);
 280
 281/**
 282 * snd_pcm_lib_preallocate_pages_for_all - pre-allocation for continous memory type (all substreams)
 283 * @pcm: the pcm instance
 284 * @type: DMA type (SNDRV_DMA_TYPE_*)
 285 * @data: DMA type dependant data
 286 * @size: the requested pre-allocation size in bytes
 287 * @max: the max. allowed pre-allocation size
 288 *
 289 * Do pre-allocation to all substreams of the given pcm for the
 290 * specified DMA type.
 291 *
 292 * Returns zero if successful, or a negative error code on failure.
 293 */
 294int snd_pcm_lib_preallocate_pages_for_all(struct snd_pcm *pcm,
 295                                          int type, void *data,
 296                                          size_t size, size_t max)
 297{
 298        struct snd_pcm_substream *substream;
 299        int stream, err;
 300
 301        for (stream = 0; stream < 2; stream++)
 302                for (substream = pcm->streams[stream].substream; substream; substream = substream->next)
 303                        if ((err = snd_pcm_lib_preallocate_pages(substream, type, data, size, max)) < 0)
 304                                return err;
 305        return 0;
 306}
 307
 308EXPORT_SYMBOL(snd_pcm_lib_preallocate_pages_for_all);
 309
 310/**
 311 * snd_pcm_sgbuf_ops_page - get the page struct at the given offset
 312 * @substream: the pcm substream instance
 313 * @offset: the buffer offset
 314 *
 315 * Returns the page struct at the given buffer offset.
 316 * Used as the page callback of PCM ops.
 317 */
 318struct page *snd_pcm_sgbuf_ops_page(struct snd_pcm_substream *substream, unsigned long offset)
 319{
 320        struct snd_sg_buf *sgbuf = snd_pcm_substream_sgbuf(substream);
 321
 322        unsigned int idx = offset >> PAGE_SHIFT;
 323        if (idx >= (unsigned int)sgbuf->pages)
 324                return NULL;
 325        return sgbuf->page_table[idx];
 326}
 327
 328EXPORT_SYMBOL(snd_pcm_sgbuf_ops_page);
 329
 330/**
 331 * snd_pcm_lib_malloc_pages - allocate the DMA buffer
 332 * @substream: the substream to allocate the DMA buffer to
 333 * @size: the requested buffer size in bytes
 334 *
 335 * Allocates the DMA buffer on the BUS type given earlier to
 336 * snd_pcm_lib_preallocate_xxx_pages().
 337 *
 338 * Returns 1 if the buffer is changed, 0 if not changed, or a negative
 339 * code on failure.
 340 */
 341int snd_pcm_lib_malloc_pages(struct snd_pcm_substream *substream, size_t size)
 342{
 343        struct snd_pcm_runtime *runtime;
 344        struct snd_dma_buffer *dmab = NULL;
 345
 346        snd_assert(substream->dma_buffer.dev.type != SNDRV_DMA_TYPE_UNKNOWN, return -EINVAL);
 347        snd_assert(substream != NULL, return -EINVAL);
 348        runtime = substream->runtime;
 349        snd_assert(runtime != NULL, return -EINVAL);
 350
 351        if (runtime->dma_buffer_p) {
 352                /* perphaps, we might free the large DMA memory region
 353                   to save some space here, but the actual solution
 354                   costs us less time */
 355                if (runtime->dma_buffer_p->bytes >= size) {
 356                        runtime->dma_bytes = size;
 357                        return 0;       /* ok, do not change */
 358                }
 359                snd_pcm_lib_free_pages(substream);
 360        }
 361        if (substream->dma_buffer.area != NULL &&
 362            substream->dma_buffer.bytes >= size) {
 363                dmab = &substream->dma_buffer; /* use the pre-allocated buffer */
 364        } else {
 365                dmab = kzalloc(sizeof(*dmab), GFP_KERNEL);
 366                if (! dmab)
 367                        return -ENOMEM;
 368                dmab->dev = substream->dma_buffer.dev;
 369                if (snd_dma_alloc_pages(substream->dma_buffer.dev.type,
 370                                        substream->dma_buffer.dev.dev,
 371                                        size, dmab) < 0) {
 372                        kfree(dmab);
 373                        return -ENOMEM;
 374                }
 375        }
 376        snd_pcm_set_runtime_buffer(substream, dmab);
 377        runtime->dma_bytes = size;
 378        return 1;                       /* area was changed */
 379}
 380
 381EXPORT_SYMBOL(snd_pcm_lib_malloc_pages);
 382
 383/**
 384 * snd_pcm_lib_free_pages - release the allocated DMA buffer.
 385 * @substream: the substream to release the DMA buffer
 386 *
 387 * Releases the DMA buffer allocated via snd_pcm_lib_malloc_pages().
 388 *
 389 * Returns zero if successful, or a negative error code on failure.
 390 */
 391int snd_pcm_lib_free_pages(struct snd_pcm_substream *substream)
 392{
 393        struct snd_pcm_runtime *runtime;
 394
 395        snd_assert(substream != NULL, return -EINVAL);
 396        runtime = substream->runtime;
 397        snd_assert(runtime != NULL, return -EINVAL);
 398        if (runtime->dma_area == NULL)
 399                return 0;
 400        if (runtime->dma_buffer_p != &substream->dma_buffer) {
 401                /* it's a newly allocated buffer.  release it now. */
 402                snd_dma_free_pages(runtime->dma_buffer_p);
 403                kfree(runtime->dma_buffer_p);
 404        }
 405        snd_pcm_set_runtime_buffer(substream, NULL);
 406        return 0;
 407}
 408
 409EXPORT_SYMBOL(snd_pcm_lib_free_pages);
 410