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 <asm/io.h>
  23#include <linux/time.h>
  24#include <linux/init.h>
  25#include <linux/slab.h>
  26#include <linux/moduleparam.h>
  27#include <linux/vmalloc.h>
  28#include <linux/export.h>
  29#include <sound/core.h>
  30#include <sound/pcm.h>
  31#include <sound/info.h>
  32#include <sound/initval.h>
  33
  34static int preallocate_dma = 1;
  35module_param(preallocate_dma, int, 0444);
  36MODULE_PARM_DESC(preallocate_dma, "Preallocate DMA memory when the PCM devices are initialized.");
  37
  38static int maximum_substreams = 4;
  39module_param(maximum_substreams, int, 0444);
  40MODULE_PARM_DESC(maximum_substreams, "Maximum substreams with preallocated DMA memory.");
  41
  42static const size_t snd_minimum_buffer = 16384;
  43
  44
  45/*
  46 * try to allocate as the large pages as possible.
  47 * stores the resultant memory size in *res_size.
  48 *
  49 * the minimum size is snd_minimum_buffer.  it should be power of 2.
  50 */
  51static int preallocate_pcm_pages(struct snd_pcm_substream *substream, size_t size)
  52{
  53        struct snd_dma_buffer *dmab = &substream->dma_buffer;
  54        int err;
  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 dependent 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 continuous memory type (all substreams)
 283 * @pcm: the pcm instance
 284 * @type: DMA type (SNDRV_DMA_TYPE_*)
 285 * @data: DMA type dependent 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#ifdef CONFIG_SND_DMA_SGBUF
 311/**
 312 * snd_pcm_sgbuf_ops_page - get the page struct at the given offset
 313 * @substream: the pcm substream instance
 314 * @offset: the buffer offset
 315 *
 316 * Returns the page struct at the given buffer offset.
 317 * Used as the page callback of PCM ops.
 318 */
 319struct page *snd_pcm_sgbuf_ops_page(struct snd_pcm_substream *substream, unsigned long offset)
 320{
 321        struct snd_sg_buf *sgbuf = snd_pcm_substream_sgbuf(substream);
 322
 323        unsigned int idx = offset >> PAGE_SHIFT;
 324        if (idx >= (unsigned int)sgbuf->pages)
 325                return NULL;
 326        return sgbuf->page_table[idx];
 327}
 328
 329EXPORT_SYMBOL(snd_pcm_sgbuf_ops_page);
 330
 331/*
 332 * compute the max chunk size with continuous pages on sg-buffer
 333 */
 334unsigned int snd_pcm_sgbuf_get_chunk_size(struct snd_pcm_substream *substream,
 335                                          unsigned int ofs, unsigned int size)
 336{
 337        struct snd_sg_buf *sg = snd_pcm_substream_sgbuf(substream);
 338        unsigned int start, end, pg;
 339
 340        start = ofs >> PAGE_SHIFT;
 341        end = (ofs + size - 1) >> PAGE_SHIFT;
 342        /* check page continuity */
 343        pg = sg->table[start].addr >> PAGE_SHIFT;
 344        for (;;) {
 345                start++;
 346                if (start > end)
 347                        break;
 348                pg++;
 349                if ((sg->table[start].addr >> PAGE_SHIFT) != pg)
 350                        return (start << PAGE_SHIFT) - ofs;
 351        }
 352        /* ok, all on continuous pages */
 353        return size;
 354}
 355EXPORT_SYMBOL(snd_pcm_sgbuf_get_chunk_size);
 356#endif /* CONFIG_SND_DMA_SGBUF */
 357
 358/**
 359 * snd_pcm_lib_malloc_pages - allocate the DMA buffer
 360 * @substream: the substream to allocate the DMA buffer to
 361 * @size: the requested buffer size in bytes
 362 *
 363 * Allocates the DMA buffer on the BUS type given earlier to
 364 * snd_pcm_lib_preallocate_xxx_pages().
 365 *
 366 * Returns 1 if the buffer is changed, 0 if not changed, or a negative
 367 * code on failure.
 368 */
 369int snd_pcm_lib_malloc_pages(struct snd_pcm_substream *substream, size_t size)
 370{
 371        struct snd_pcm_runtime *runtime;
 372        struct snd_dma_buffer *dmab = NULL;
 373
 374        if (PCM_RUNTIME_CHECK(substream))
 375                return -EINVAL;
 376        if (snd_BUG_ON(substream->dma_buffer.dev.type ==
 377                       SNDRV_DMA_TYPE_UNKNOWN))
 378                return -EINVAL;
 379        runtime = substream->runtime;
 380
 381        if (runtime->dma_buffer_p) {
 382                /* perphaps, we might free the large DMA memory region
 383                   to save some space here, but the actual solution
 384                   costs us less time */
 385                if (runtime->dma_buffer_p->bytes >= size) {
 386                        runtime->dma_bytes = size;
 387                        return 0;       /* ok, do not change */
 388                }
 389                snd_pcm_lib_free_pages(substream);
 390        }
 391        if (substream->dma_buffer.area != NULL &&
 392            substream->dma_buffer.bytes >= size) {
 393                dmab = &substream->dma_buffer; /* use the pre-allocated buffer */
 394        } else {
 395                dmab = kzalloc(sizeof(*dmab), GFP_KERNEL);
 396                if (! dmab)
 397                        return -ENOMEM;
 398                dmab->dev = substream->dma_buffer.dev;
 399                if (snd_dma_alloc_pages(substream->dma_buffer.dev.type,
 400                                        substream->dma_buffer.dev.dev,
 401                                        size, dmab) < 0) {
 402                        kfree(dmab);
 403                        return -ENOMEM;
 404                }
 405        }
 406        snd_pcm_set_runtime_buffer(substream, dmab);
 407        runtime->dma_bytes = size;
 408        return 1;                       /* area was changed */
 409}
 410
 411EXPORT_SYMBOL(snd_pcm_lib_malloc_pages);
 412
 413/**
 414 * snd_pcm_lib_free_pages - release the allocated DMA buffer.
 415 * @substream: the substream to release the DMA buffer
 416 *
 417 * Releases the DMA buffer allocated via snd_pcm_lib_malloc_pages().
 418 *
 419 * Returns zero if successful, or a negative error code on failure.
 420 */
 421int snd_pcm_lib_free_pages(struct snd_pcm_substream *substream)
 422{
 423        struct snd_pcm_runtime *runtime;
 424
 425        if (PCM_RUNTIME_CHECK(substream))
 426                return -EINVAL;
 427        runtime = substream->runtime;
 428        if (runtime->dma_area == NULL)
 429                return 0;
 430        if (runtime->dma_buffer_p != &substream->dma_buffer) {
 431                /* it's a newly allocated buffer.  release it now. */
 432                snd_dma_free_pages(runtime->dma_buffer_p);
 433                kfree(runtime->dma_buffer_p);
 434        }
 435        snd_pcm_set_runtime_buffer(substream, NULL);
 436        return 0;
 437}
 438
 439EXPORT_SYMBOL(snd_pcm_lib_free_pages);
 440
 441int _snd_pcm_lib_alloc_vmalloc_buffer(struct snd_pcm_substream *substream,
 442                                      size_t size, gfp_t gfp_flags)
 443{
 444        struct snd_pcm_runtime *runtime;
 445
 446        if (PCM_RUNTIME_CHECK(substream))
 447                return -EINVAL;
 448        runtime = substream->runtime;
 449        if (runtime->dma_area) {
 450                if (runtime->dma_bytes >= size)
 451                        return 0; /* already large enough */
 452                vfree(runtime->dma_area);
 453        }
 454        runtime->dma_area = __vmalloc(size, gfp_flags, PAGE_KERNEL);
 455        if (!runtime->dma_area)
 456                return -ENOMEM;
 457        runtime->dma_bytes = size;
 458        return 1;
 459}
 460EXPORT_SYMBOL(_snd_pcm_lib_alloc_vmalloc_buffer);
 461
 462/**
 463 * snd_pcm_lib_free_vmalloc_buffer - free vmalloc buffer
 464 * @substream: the substream with a buffer allocated by
 465 *      snd_pcm_lib_alloc_vmalloc_buffer()
 466 */
 467int snd_pcm_lib_free_vmalloc_buffer(struct snd_pcm_substream *substream)
 468{
 469        struct snd_pcm_runtime *runtime;
 470
 471        if (PCM_RUNTIME_CHECK(substream))
 472                return -EINVAL;
 473        runtime = substream->runtime;
 474        vfree(runtime->dma_area);
 475        runtime->dma_area = NULL;
 476        return 0;
 477}
 478EXPORT_SYMBOL(snd_pcm_lib_free_vmalloc_buffer);
 479
 480/**
 481 * snd_pcm_lib_get_vmalloc_page - map vmalloc buffer offset to page struct
 482 * @substream: the substream with a buffer allocated by
 483 *      snd_pcm_lib_alloc_vmalloc_buffer()
 484 * @offset: offset in the buffer
 485 *
 486 * This function is to be used as the page callback in the PCM ops.
 487 */
 488struct page *snd_pcm_lib_get_vmalloc_page(struct snd_pcm_substream *substream,
 489                                          unsigned long offset)
 490{
 491        return vmalloc_to_page(substream->runtime->dma_area + offset);
 492}
 493EXPORT_SYMBOL(snd_pcm_lib_get_vmalloc_page);
 494
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.