sound/core/memalloc.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
   4  *                   Takashi Iwai <tiwai@suse.de>
   5  *
   6  *  Generic memory allocators
   7  */
   8
   9 #include <linux/slab.h>
  10 #include <linux/mm.h>
  11 #include <linux/dma-mapping.h>
  12 #include <linux/genalloc.h>
  13 #include <linux/vmalloc.h>
  14 #ifdef CONFIG_X86
  15 #include <asm/set_memory.h>
  16 #endif
  17 #include <sound/memalloc.h>
  18
  19 /*
  20  *
  21  *  Bus-specific memory allocators
  22  *
  23  */
  24
  25 #ifdef CONFIG_HAS_DMA
  26 /* allocate the coherent DMA pages */
  27 static void snd_malloc_dev_pages(struct snd_dma_buffer *dmab, size_t size)
  28 {
  29         gfp_t gfp_flags;
  30
  31         gfp_flags = GFP_KERNEL
  32                 | __GFP_COMP    /* compound page lets parts be mapped */
  33                 | __GFP_NORETRY /* don't trigger OOM-killer */
  34                 | __GFP_NOWARN; /* no stack trace print - this call is non-critical */
  35         dmab->area = dma_alloc_coherent(dmab->dev.dev, size, &dmab->addr,
  36                                         gfp_flags);
  37 #ifdef CONFIG_X86
  38         if (dmab->area && dmab->dev.type == SNDRV_DMA_TYPE_DEV_UC)
  39                 set_memory_wc((unsigned long)dmab->area,
  40                               PAGE_ALIGN(size) >> PAGE_SHIFT);
  41 #endif
  42 }
  43
  44 /* free the coherent DMA pages */
  45 static void snd_free_dev_pages(struct snd_dma_buffer *dmab)
  46 {
  47 #ifdef CONFIG_X86
  48         if (dmab->dev.type == SNDRV_DMA_TYPE_DEV_UC)
  49                 set_memory_wb((unsigned long)dmab->area,
  50                               PAGE_ALIGN(dmab->bytes) >> PAGE_SHIFT);
  51 #endif
  52         dma_free_coherent(dmab->dev.dev, dmab->bytes, dmab->area, dmab->addr);
  53 }
  54
  55 #ifdef CONFIG_GENERIC_ALLOCATOR
  56 /**
  57  * snd_malloc_dev_iram - allocate memory from on-chip internal ram
  58  * @dmab: buffer allocation record to store the allocated data
  59  * @size: number of bytes to allocate from the iram
  60  *
  61  * This function requires iram phandle provided via of_node
  62  */
  63 static void snd_malloc_dev_iram(struct snd_dma_buffer *dmab, size_t size)
  64 {
  65         struct device *dev = dmab->dev.dev;
  66         struct gen_pool *pool = NULL;
  67
  68         dmab->area = NULL;
  69         dmab->addr = 0;
  70
  71         if (dev->of_node)
  72                 pool = of_gen_pool_get(dev->of_node, "iram", 0);
  73
  74         if (!pool)
  75                 return;
  76
  77         /* Assign the pool into private_data field */
  78         dmab->private_data = pool;
  79
  80         dmab->area = gen_pool_dma_alloc(pool, size, &dmab->addr);
  81 }
  82
  83 /**
  84  * snd_free_dev_iram - free allocated specific memory from on-chip internal ram
  85  * @dmab: buffer allocation record to store the allocated data
  86  */
  87 static void snd_free_dev_iram(struct snd_dma_buffer *dmab)
  88 {
  89         struct gen_pool *pool = dmab->private_data;
  90
  91         if (pool && dmab->area)
  92                 gen_pool_free(pool, (unsigned long)dmab->area, dmab->bytes);
  93 }
  94 #endif /* CONFIG_GENERIC_ALLOCATOR */
  95 #endif /* CONFIG_HAS_DMA */
  96
  97 /*
  98  *
  99  *  ALSA generic memory management
 100  *
 101  */
 102
 103 static inline gfp_t snd_mem_get_gfp_flags(const struct device *dev,
 104                                           gfp_t default_gfp)
 105 {
 106         if (!dev)
 107                 return default_gfp;
 108         else
 109                 return (__force gfp_t)(unsigned long)dev;
 110 }
 111
 112 /**
 113  * snd_dma_alloc_pages - allocate the buffer area according to the given type
 114  * @type: the DMA buffer type
 115  * @device: the device pointer
 116  * @size: the buffer size to allocate
 117  * @dmab: buffer allocation record to store the allocated data
 118  *
 119  * Calls the memory-allocator function for the corresponding
 120  * buffer type.
 121  *
 122  * Return: Zero if the buffer with the given size is allocated successfully,
 123  * otherwise a negative value on error.
 124  */
 125 int snd_dma_alloc_pages(int type, struct device *device, size_t size,
 126                         struct snd_dma_buffer *dmab)
 127 {
 128         gfp_t gfp;
 129
 130         if (WARN_ON(!size))
 131                 return -ENXIO;
 132         if (WARN_ON(!dmab))
 133                 return -ENXIO;
 134
 135         dmab->dev.type = type;
 136         dmab->dev.dev = device;
 137         dmab->bytes = 0;
 138         switch (type) {
 139         case SNDRV_DMA_TYPE_CONTINUOUS:
 140                 gfp = snd_mem_get_gfp_flags(device, GFP_KERNEL);
 141                 dmab->area = alloc_pages_exact(size, gfp);
 142                 dmab->addr = 0;
 143                 break;
 144         case SNDRV_DMA_TYPE_VMALLOC:
 145                 gfp = snd_mem_get_gfp_flags(device, GFP_KERNEL | __GFP_HIGHMEM);
 146                 dmab->area = __vmalloc(size, gfp, PAGE_KERNEL);
 147                 dmab->addr = 0;
 148                 break;
 149 #ifdef CONFIG_HAS_DMA
 150 #ifdef CONFIG_GENERIC_ALLOCATOR
 151         case SNDRV_DMA_TYPE_DEV_IRAM:
 152                 snd_malloc_dev_iram(dmab, size);
 153                 if (dmab->area)
 154                         break;
 155                 /* Internal memory might have limited size and no enough space,
 156                  * so if we fail to malloc, try to fetch memory traditionally.
 157                  */
 158                 dmab->dev.type = SNDRV_DMA_TYPE_DEV;
 159 #endif /* CONFIG_GENERIC_ALLOCATOR */
 160                 /* fall through */
 161         case SNDRV_DMA_TYPE_DEV:
 162         case SNDRV_DMA_TYPE_DEV_UC:
 163                 snd_malloc_dev_pages(dmab, size);
 164                 break;
 165 #endif
 166 #ifdef CONFIG_SND_DMA_SGBUF
 167         case SNDRV_DMA_TYPE_DEV_SG:
 168         case SNDRV_DMA_TYPE_DEV_UC_SG:
 169                 snd_malloc_sgbuf_pages(device, size, dmab, NULL);
 170                 break;
 171 #endif
 172         default:
 173                 pr_err("snd-malloc: invalid device type %d\n", type);
 174                 dmab->area = NULL;
 175                 dmab->addr = 0;
 176                 return -ENXIO;
 177         }
 178         if (! dmab->area)
 179                 return -ENOMEM;
 180         dmab->bytes = size;
 181         return 0;
 182 }
 183 EXPORT_SYMBOL(snd_dma_alloc_pages);
 184
 185 /**
 186  * snd_dma_alloc_pages_fallback - allocate the buffer area according to the given type with fallback
 187  * @type: the DMA buffer type
 188  * @device: the device pointer
 189  * @size: the buffer size to allocate
 190  * @dmab: buffer allocation record to store the allocated data
 191  *
 192  * Calls the memory-allocator function for the corresponding
 193  * buffer type.  When no space is left, this function reduces the size and
 194  * tries to allocate again.  The size actually allocated is stored in
 195  * res_size argument.
 196  *
 197  * Return: Zero if the buffer with the given size is allocated successfully,
 198  * otherwise a negative value on error.
 199  */
 200 int snd_dma_alloc_pages_fallback(int type, struct device *device, size_t size,
 201                                  struct snd_dma_buffer *dmab)
 202 {
 203         int err;
 204
 205         while ((err = snd_dma_alloc_pages(type, device, size, dmab)) < 0) {
 206                 if (err != -ENOMEM)
 207                         return err;
 208                 if (size <= PAGE_SIZE)
 209                         return -ENOMEM;
 210                 size >>= 1;
 211                 size = PAGE_SIZE << get_order(size);
 212         }
 213         if (! dmab->area)
 214                 return -ENOMEM;
 215         return 0;
 216 }
 217 EXPORT_SYMBOL(snd_dma_alloc_pages_fallback);
 218
 219
 220 /**
 221  * snd_dma_free_pages - release the allocated buffer
 222  * @dmab: the buffer allocation record to release
 223  *
 224  * Releases the allocated buffer via snd_dma_alloc_pages().
 225  */
 226 void snd_dma_free_pages(struct snd_dma_buffer *dmab)
 227 {
 228         switch (dmab->dev.type) {
 229         case SNDRV_DMA_TYPE_CONTINUOUS:
 230                 free_pages_exact(dmab->area, dmab->bytes);
 231                 break;
 232         case SNDRV_DMA_TYPE_VMALLOC:
 233                 vfree(dmab->area);
 234                 break;
 235 #ifdef CONFIG_HAS_DMA
 236 #ifdef CONFIG_GENERIC_ALLOCATOR
 237         case SNDRV_DMA_TYPE_DEV_IRAM:
 238                 snd_free_dev_iram(dmab);
 239                 break;
 240 #endif /* CONFIG_GENERIC_ALLOCATOR */
 241         case SNDRV_DMA_TYPE_DEV:
 242         case SNDRV_DMA_TYPE_DEV_UC:
 243                 snd_free_dev_pages(dmab);
 244                 break;
 245 #endif
 246 #ifdef CONFIG_SND_DMA_SGBUF
 247         case SNDRV_DMA_TYPE_DEV_SG:
 248         case SNDRV_DMA_TYPE_DEV_UC_SG:
 249                 snd_free_sgbuf_pages(dmab);
 250                 break;
 251 #endif
 252         default:
 253                 pr_err("snd-malloc: invalid device type %d\n", dmab->dev.type);
 254         }
 255 }
 256 EXPORT_SYMBOL(snd_dma_free_pages);