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);