LCOV - code coverage report
Current view: top level - sound/core - pcm_memory.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 6 137 4.4 %
Date: 2014-02-18 Functions: 2 15 13.3 %
Branches: 0 104 0.0 %

           Branch data     Line data    Source code
       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                 :            : 
      34                 :            : static int preallocate_dma = 1;
      35                 :            : module_param(preallocate_dma, int, 0444);
      36                 :            : MODULE_PARM_DESC(preallocate_dma, "Preallocate DMA memory when the PCM devices are initialized.");
      37                 :            : 
      38                 :            : static int maximum_substreams = 4;
      39                 :            : module_param(maximum_substreams, int, 0444);
      40                 :            : MODULE_PARM_DESC(maximum_substreams, "Maximum substreams with preallocated DMA memory.");
      41                 :            : 
      42                 :            : static 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                 :            :  */
      51                 :          0 : static int preallocate_pcm_pages(struct snd_pcm_substream *substream, size_t size)
      52                 :            : {
      53                 :          0 :         struct snd_dma_buffer *dmab = &substream->dma_buffer;
      54                 :            :         int err;
      55                 :            : 
      56                 :            :         /* already reserved? */
      57         [ #  # ]:          0 :         if (snd_dma_get_reserved_buf(dmab, substream->dma_buf_id) > 0) {
      58         [ #  # ]:          0 :                 if (dmab->bytes >= size)
      59                 :            :                         return 0; /* yes */
      60                 :            :                 /* no, free the reserved block */
      61                 :          0 :                 snd_dma_free_pages(dmab);
      62                 :          0 :                 dmab->bytes = 0;
      63                 :            :         }
      64                 :            : 
      65                 :            :         do {
      66         [ #  # ]:          0 :                 if ((err = snd_dma_alloc_pages(dmab->dev.type, dmab->dev.dev,
      67                 :            :                                                size, dmab)) < 0) {
      68         [ #  # ]:          0 :                         if (err != -ENOMEM)
      69                 :            :                                 return err; /* fatal error */
      70                 :            :                 } else
      71                 :            :                         return 0;
      72                 :          0 :                 size >>= 1;
      73         [ #  # ]:          0 :         } while (size >= snd_minimum_buffer);
      74                 :          0 :         dmab->bytes = 0; /* tell error */
      75                 :          0 :         return 0;
      76                 :            : }
      77                 :            : 
      78                 :            : /*
      79                 :            :  * release the preallocated buffer if not yet done.
      80                 :            :  */
      81                 :          0 : static void snd_pcm_lib_preallocate_dma_free(struct snd_pcm_substream *substream)
      82                 :            : {
      83         [ #  # ]:          0 :         if (substream->dma_buffer.area == NULL)
      84                 :          0 :                 return;
      85         [ #  # ]:          0 :         if (substream->dma_buf_id)
      86                 :          0 :                 snd_dma_reserve_buf(&substream->dma_buffer, substream->dma_buf_id);
      87                 :            :         else
      88                 :          0 :                 snd_dma_free_pages(&substream->dma_buffer);
      89                 :          0 :         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                 :            :  * Return: Zero if successful, or a negative error code on failure.
      99                 :            :  */
     100                 :          0 : int snd_pcm_lib_preallocate_free(struct snd_pcm_substream *substream)
     101                 :            : {
     102                 :          0 :         snd_pcm_lib_preallocate_dma_free(substream);
     103                 :            : #ifdef CONFIG_SND_VERBOSE_PROCFS
     104                 :          0 :         snd_info_free_entry(substream->proc_prealloc_max_entry);
     105                 :          0 :         substream->proc_prealloc_max_entry = NULL;
     106                 :          0 :         snd_info_free_entry(substream->proc_prealloc_entry);
     107                 :          0 :         substream->proc_prealloc_entry = NULL;
     108                 :            : #endif
     109                 :          0 :         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                 :            :  * Return: Zero if successful, or a negative error code on failure.
     119                 :            :  */
     120                 :          0 : int snd_pcm_lib_preallocate_free_for_all(struct snd_pcm *pcm)
     121                 :            : {
     122                 :            :         struct snd_pcm_substream *substream;
     123                 :            :         int stream;
     124                 :            : 
     125         [ #  # ]:          0 :         for (stream = 0; stream < 2; stream++)
     126         [ #  # ]:          0 :                 for (substream = pcm->streams[stream].substream; substream; substream = substream->next)
     127                 :          0 :                         snd_pcm_lib_preallocate_free(substream);
     128                 :          0 :         return 0;
     129                 :            : }
     130                 :            : 
     131                 :            : EXPORT_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                 :            :  */
     139                 :          0 : static void snd_pcm_lib_preallocate_proc_read(struct snd_info_entry *entry,
     140                 :            :                                               struct snd_info_buffer *buffer)
     141                 :            : {
     142                 :          2 :         struct snd_pcm_substream *substream = entry->private_data;
     143                 :          2 :         snd_iprintf(buffer, "%lu\n", (unsigned long) substream->dma_buffer.bytes / 1024);
     144                 :          2 : }
     145                 :            : 
     146                 :            : /*
     147                 :            :  * read callback for prealloc_max proc file
     148                 :            :  *
     149                 :            :  * prints the maximum allowed size in kB.
     150                 :            :  */
     151                 :          0 : static void snd_pcm_lib_preallocate_max_proc_read(struct snd_info_entry *entry,
     152                 :            :                                                   struct snd_info_buffer *buffer)
     153                 :            : {
     154                 :          2 :         struct snd_pcm_substream *substream = entry->private_data;
     155                 :          2 :         snd_iprintf(buffer, "%lu\n", (unsigned long) substream->dma_max / 1024);
     156                 :          2 : }
     157                 :            : 
     158                 :            : /*
     159                 :            :  * write callback for prealloc proc file
     160                 :            :  *
     161                 :            :  * accepts the preallocation size in kB.
     162                 :            :  */
     163                 :          0 : static void snd_pcm_lib_preallocate_proc_write(struct snd_info_entry *entry,
     164                 :            :                                                struct snd_info_buffer *buffer)
     165                 :            : {
     166                 :          0 :         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         [ #  # ]:          0 :         if (substream->runtime) {
     172                 :          0 :                 buffer->error = -EBUSY;
     173                 :          0 :                 return;
     174                 :            :         }
     175         [ #  # ]:          0 :         if (!snd_info_get_line(buffer, line, sizeof(line))) {
     176                 :          0 :                 snd_info_get_str(str, line, sizeof(str));
     177                 :          0 :                 size = simple_strtoul(str, NULL, 10) * 1024;
     178 [ #  # ][ #  # ]:          0 :                 if ((size != 0 && size < 8192) || size > substream->dma_max) {
     179                 :          0 :                         buffer->error = -EINVAL;
     180                 :          0 :                         return;
     181                 :            :                 }
     182         [ #  # ]:          0 :                 if (substream->dma_buffer.bytes == size)
     183                 :            :                         return;
     184                 :          0 :                 memset(&new_dmab, 0, sizeof(new_dmab));
     185                 :          0 :                 new_dmab.dev = substream->dma_buffer.dev;
     186         [ #  # ]:          0 :                 if (size > 0) {
     187         [ #  # ]:          0 :                         if (snd_dma_alloc_pages(substream->dma_buffer.dev.type,
     188                 :            :                                                 substream->dma_buffer.dev.dev,
     189                 :            :                                                 size, &new_dmab) < 0) {
     190                 :          0 :                                 buffer->error = -ENOMEM;
     191                 :          0 :                                 return;
     192                 :            :                         }
     193                 :          0 :                         substream->buffer_bytes_max = size;
     194                 :            :                 } else {
     195                 :          0 :                         substream->buffer_bytes_max = UINT_MAX;
     196                 :            :                 }
     197         [ #  # ]:          0 :                 if (substream->dma_buffer.area)
     198                 :          0 :                         snd_dma_free_pages(&substream->dma_buffer);
     199                 :          0 :                 substream->dma_buffer = new_dmab;
     200                 :            :         } else {
     201                 :          0 :                 buffer->error = -EINVAL;
     202                 :            :         }
     203                 :            : }
     204                 :            : 
     205                 :            : static inline void preallocate_info_init(struct snd_pcm_substream *substream)
     206                 :            : {
     207                 :            :         struct snd_info_entry *entry;
     208                 :            : 
     209         [ #  # ]:          0 :         if ((entry = snd_info_create_card_entry(substream->pcm->card, "prealloc", substream->proc_root)) != NULL) {
     210                 :          0 :                 entry->c.text.read = snd_pcm_lib_preallocate_proc_read;
     211                 :          0 :                 entry->c.text.write = snd_pcm_lib_preallocate_proc_write;
     212                 :          0 :                 entry->mode |= S_IWUSR;
     213                 :          0 :                 entry->private_data = substream;
     214         [ #  # ]:          0 :                 if (snd_info_register(entry) < 0) {
     215                 :          0 :                         snd_info_free_entry(entry);
     216                 :            :                         entry = NULL;
     217                 :            :                 }
     218                 :            :         }
     219                 :          0 :         substream->proc_prealloc_entry = entry;
     220         [ #  # ]:          0 :         if ((entry = snd_info_create_card_entry(substream->pcm->card, "prealloc_max", substream->proc_root)) != NULL) {
     221                 :          0 :                 entry->c.text.read = snd_pcm_lib_preallocate_max_proc_read;
     222                 :          0 :                 entry->private_data = substream;
     223         [ #  # ]:          0 :                 if (snd_info_register(entry) < 0) {
     224                 :          0 :                         snd_info_free_entry(entry);
     225                 :            :                         entry = NULL;
     226                 :            :                 }
     227                 :            :         }
     228                 :          0 :         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                 :            :  */
     238                 :          0 : static int snd_pcm_lib_preallocate_pages1(struct snd_pcm_substream *substream,
     239                 :            :                                           size_t size, size_t max)
     240                 :            : {
     241                 :            : 
     242 [ #  # ][ #  # ]:          0 :         if (size > 0 && preallocate_dma && substream->number < maximum_substreams)
                 [ #  # ]
     243                 :          0 :                 preallocate_pcm_pages(substream, size);
     244                 :            : 
     245         [ #  # ]:          0 :         if (substream->dma_buffer.bytes > 0)
     246                 :          0 :                 substream->buffer_bytes_max = substream->dma_buffer.bytes;
     247                 :          0 :         substream->dma_max = max;
     248                 :            :         preallocate_info_init(substream);
     249                 :          0 :         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                 :            :  * Return: Zero if successful, or a negative error code on failure.
     269                 :            :  */
     270                 :          0 : int 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                 :          0 :         substream->dma_buffer.dev.type = type;
     275                 :          0 :         substream->dma_buffer.dev.dev = data;
     276                 :          0 :         return snd_pcm_lib_preallocate_pages1(substream, size, max);
     277                 :            : }
     278                 :            : 
     279                 :            : EXPORT_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                 :            :  * Return: Zero if successful, or a negative error code on failure.
     293                 :            :  */
     294                 :          0 : int 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         [ #  # ]:          0 :         for (stream = 0; stream < 2; stream++)
     302         [ #  # ]:          0 :                 for (substream = pcm->streams[stream].substream; substream; substream = substream->next)
     303         [ #  # ]:          0 :                         if ((err = snd_pcm_lib_preallocate_pages(substream, type, data, size, max)) < 0)
     304                 :            :                                 return err;
     305                 :            :         return 0;
     306                 :            : }
     307                 :            : 
     308                 :            : EXPORT_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                 :            :  * Used as the page callback of PCM ops.
     317                 :            :  *
     318                 :            :  * Return: The page struct at the given buffer offset. %NULL on failure.
     319                 :            :  */
     320                 :            : struct page *snd_pcm_sgbuf_ops_page(struct snd_pcm_substream *substream, unsigned long offset)
     321                 :            : {
     322                 :            :         struct snd_sg_buf *sgbuf = snd_pcm_substream_sgbuf(substream);
     323                 :            : 
     324                 :            :         unsigned int idx = offset >> PAGE_SHIFT;
     325                 :            :         if (idx >= (unsigned int)sgbuf->pages)
     326                 :            :                 return NULL;
     327                 :            :         return sgbuf->page_table[idx];
     328                 :            : }
     329                 :            : 
     330                 :            : EXPORT_SYMBOL(snd_pcm_sgbuf_ops_page);
     331                 :            : #endif /* CONFIG_SND_DMA_SGBUF */
     332                 :            : 
     333                 :            : /**
     334                 :            :  * snd_pcm_lib_malloc_pages - allocate the DMA buffer
     335                 :            :  * @substream: the substream to allocate the DMA buffer to
     336                 :            :  * @size: the requested buffer size in bytes
     337                 :            :  *
     338                 :            :  * Allocates the DMA buffer on the BUS type given earlier to
     339                 :            :  * snd_pcm_lib_preallocate_xxx_pages().
     340                 :            :  *
     341                 :            :  * Return: 1 if the buffer is changed, 0 if not changed, or a negative
     342                 :            :  * code on failure.
     343                 :            :  */
     344                 :          0 : int snd_pcm_lib_malloc_pages(struct snd_pcm_substream *substream, size_t size)
     345                 :            : {
     346                 :            :         struct snd_pcm_runtime *runtime;
     347                 :            :         struct snd_dma_buffer *dmab = NULL;
     348                 :            : 
     349 [ #  # ][ #  # ]:          0 :         if (PCM_RUNTIME_CHECK(substream))
                 [ #  # ]
     350                 :            :                 return -EINVAL;
     351         [ #  # ]:          0 :         if (snd_BUG_ON(substream->dma_buffer.dev.type ==
     352                 :            :                        SNDRV_DMA_TYPE_UNKNOWN))
     353                 :            :                 return -EINVAL;
     354                 :          0 :         runtime = substream->runtime;
     355                 :            : 
     356         [ #  # ]:          0 :         if (runtime->dma_buffer_p) {
     357                 :            :                 /* perphaps, we might free the large DMA memory region
     358                 :            :                    to save some space here, but the actual solution
     359                 :            :                    costs us less time */
     360         [ #  # ]:          0 :                 if (runtime->dma_buffer_p->bytes >= size) {
     361                 :          0 :                         runtime->dma_bytes = size;
     362                 :          0 :                         return 0;       /* ok, do not change */
     363                 :            :                 }
     364                 :          0 :                 snd_pcm_lib_free_pages(substream);
     365                 :            :         }
     366 [ #  # ][ #  # ]:          0 :         if (substream->dma_buffer.area != NULL &&
     367                 :          0 :             substream->dma_buffer.bytes >= size) {
     368                 :          0 :                 dmab = &substream->dma_buffer; /* use the pre-allocated buffer */
     369                 :            :         } else {
     370                 :            :                 dmab = kzalloc(sizeof(*dmab), GFP_KERNEL);
     371         [ #  # ]:          0 :                 if (! dmab)
     372                 :            :                         return -ENOMEM;
     373                 :          0 :                 dmab->dev = substream->dma_buffer.dev;
     374         [ #  # ]:          0 :                 if (snd_dma_alloc_pages(substream->dma_buffer.dev.type,
     375                 :            :                                         substream->dma_buffer.dev.dev,
     376                 :            :                                         size, dmab) < 0) {
     377                 :          0 :                         kfree(dmab);
     378                 :          0 :                         return -ENOMEM;
     379                 :            :                 }
     380                 :            :         }
     381                 :            :         snd_pcm_set_runtime_buffer(substream, dmab);
     382                 :          0 :         runtime->dma_bytes = size;
     383                 :          0 :         return 1;                       /* area was changed */
     384                 :            : }
     385                 :            : 
     386                 :            : EXPORT_SYMBOL(snd_pcm_lib_malloc_pages);
     387                 :            : 
     388                 :            : /**
     389                 :            :  * snd_pcm_lib_free_pages - release the allocated DMA buffer.
     390                 :            :  * @substream: the substream to release the DMA buffer
     391                 :            :  *
     392                 :            :  * Releases the DMA buffer allocated via snd_pcm_lib_malloc_pages().
     393                 :            :  *
     394                 :            :  * Return: Zero if successful, or a negative error code on failure.
     395                 :            :  */
     396                 :          0 : int snd_pcm_lib_free_pages(struct snd_pcm_substream *substream)
     397                 :            : {
     398                 :            :         struct snd_pcm_runtime *runtime;
     399                 :            : 
     400 [ #  # ][ #  # ]:          0 :         if (PCM_RUNTIME_CHECK(substream))
                 [ #  # ]
     401                 :            :                 return -EINVAL;
     402                 :          0 :         runtime = substream->runtime;
     403         [ #  # ]:          0 :         if (runtime->dma_area == NULL)
     404                 :            :                 return 0;
     405         [ #  # ]:          0 :         if (runtime->dma_buffer_p != &substream->dma_buffer) {
     406                 :            :                 /* it's a newly allocated buffer.  release it now. */
     407                 :          0 :                 snd_dma_free_pages(runtime->dma_buffer_p);
     408                 :          0 :                 kfree(runtime->dma_buffer_p);
     409                 :            :         }
     410                 :            :         snd_pcm_set_runtime_buffer(substream, NULL);
     411                 :          0 :         return 0;
     412                 :            : }
     413                 :            : 
     414                 :            : EXPORT_SYMBOL(snd_pcm_lib_free_pages);
     415                 :            : 
     416                 :          0 : int _snd_pcm_lib_alloc_vmalloc_buffer(struct snd_pcm_substream *substream,
     417                 :            :                                       size_t size, gfp_t gfp_flags)
     418                 :            : {
     419                 :            :         struct snd_pcm_runtime *runtime;
     420                 :            : 
     421 [ #  # ][ #  # ]:          0 :         if (PCM_RUNTIME_CHECK(substream))
                 [ #  # ]
     422                 :            :                 return -EINVAL;
     423                 :          0 :         runtime = substream->runtime;
     424         [ #  # ]:          0 :         if (runtime->dma_area) {
     425         [ #  # ]:          0 :                 if (runtime->dma_bytes >= size)
     426                 :            :                         return 0; /* already large enough */
     427                 :          0 :                 vfree(runtime->dma_area);
     428                 :            :         }
     429                 :          0 :         runtime->dma_area = __vmalloc(size, gfp_flags, PAGE_KERNEL);
     430         [ #  # ]:          0 :         if (!runtime->dma_area)
     431                 :            :                 return -ENOMEM;
     432                 :          0 :         runtime->dma_bytes = size;
     433                 :          0 :         return 1;
     434                 :            : }
     435                 :            : EXPORT_SYMBOL(_snd_pcm_lib_alloc_vmalloc_buffer);
     436                 :            : 
     437                 :            : /**
     438                 :            :  * snd_pcm_lib_free_vmalloc_buffer - free vmalloc buffer
     439                 :            :  * @substream: the substream with a buffer allocated by
     440                 :            :  *      snd_pcm_lib_alloc_vmalloc_buffer()
     441                 :            :  *
     442                 :            :  * Return: Zero if successful, or a negative error code on failure.
     443                 :            :  */
     444                 :          0 : int snd_pcm_lib_free_vmalloc_buffer(struct snd_pcm_substream *substream)
     445                 :            : {
     446                 :            :         struct snd_pcm_runtime *runtime;
     447                 :            : 
     448 [ #  # ][ #  # ]:          0 :         if (PCM_RUNTIME_CHECK(substream))
                 [ #  # ]
     449                 :            :                 return -EINVAL;
     450                 :          0 :         runtime = substream->runtime;
     451                 :          0 :         vfree(runtime->dma_area);
     452                 :          0 :         runtime->dma_area = NULL;
     453                 :          0 :         return 0;
     454                 :            : }
     455                 :            : EXPORT_SYMBOL(snd_pcm_lib_free_vmalloc_buffer);
     456                 :            : 
     457                 :            : /**
     458                 :            :  * snd_pcm_lib_get_vmalloc_page - map vmalloc buffer offset to page struct
     459                 :            :  * @substream: the substream with a buffer allocated by
     460                 :            :  *      snd_pcm_lib_alloc_vmalloc_buffer()
     461                 :            :  * @offset: offset in the buffer
     462                 :            :  *
     463                 :            :  * This function is to be used as the page callback in the PCM ops.
     464                 :            :  *
     465                 :            :  * Return: The page struct, or %NULL on failure.
     466                 :            :  */
     467                 :          0 : struct page *snd_pcm_lib_get_vmalloc_page(struct snd_pcm_substream *substream,
     468                 :            :                                           unsigned long offset)
     469                 :            : {
     470                 :          0 :         return vmalloc_to_page(substream->runtime->dma_area + offset);
     471                 :            : }
     472                 :            : EXPORT_SYMBOL(snd_pcm_lib_get_vmalloc_page);

Generated by: LCOV version 1.9