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         dmab->area = NULL;
 139         dmab->addr = 0;
 140         dmab->private_data = NULL;
 141         switch (type) {
 142         case SNDRV_DMA_TYPE_CONTINUOUS:
 143                 gfp = snd_mem_get_gfp_flags(device, GFP_KERNEL);
 144                 dmab->area = alloc_pages_exact(size, gfp);
 145                 break;
 146         case SNDRV_DMA_TYPE_VMALLOC:
 147                 gfp = snd_mem_get_gfp_flags(device, GFP_KERNEL | __GFP_HIGHMEM);
 148                 dmab->area = __vmalloc(size, gfp);
 149                 break;
 150 #ifdef CONFIG_HAS_DMA
 151 #ifdef CONFIG_GENERIC_ALLOCATOR
 152         case SNDRV_DMA_TYPE_DEV_IRAM:
 153                 snd_malloc_dev_iram(dmab, size);
 154                 if (dmab->area)
 155                         break;
 156                 /* Internal memory might have limited size and no enough space,
 157                  * so if we fail to malloc, try to fetch memory traditionally.
 158                  */
 159                 dmab->dev.type = SNDRV_DMA_TYPE_DEV;
 160 #endif /* CONFIG_GENERIC_ALLOCATOR */
 161                 fallthrough;
 162         case SNDRV_DMA_TYPE_DEV:
 163         case SNDRV_DMA_TYPE_DEV_UC:
 164                 snd_malloc_dev_pages(dmab, size);
 165                 break;
 166 #endif
 167 #ifdef CONFIG_SND_DMA_SGBUF
 168         case SNDRV_DMA_TYPE_DEV_SG:
 169         case SNDRV_DMA_TYPE_DEV_UC_SG:
 170                 snd_malloc_sgbuf_pages(device, size, dmab, NULL);
 171                 break;
 172 #endif
 173         default:
 174                 pr_err("snd-malloc: invalid device type %d\n", type);
 175                 return -ENXIO;
 176         }
 177         if (! dmab->area)
 178                 return -ENOMEM;
 179         dmab->bytes = size;
 180         return 0;
 181 }
 182 EXPORT_SYMBOL(snd_dma_alloc_pages);
 183
 184 /**
 185  * snd_dma_alloc_pages_fallback - allocate the buffer area according to the given type with fallback
 186  * @type: the DMA buffer type
 187  * @device: the device pointer
 188  * @size: the buffer size to allocate
 189  * @dmab: buffer allocation record to store the allocated data
 190  *
 191  * Calls the memory-allocator function for the corresponding
 192  * buffer type.  When no space is left, this function reduces the size and
 193  * tries to allocate again.  The size actually allocated is stored in
 194  * res_size argument.
 195  *
 196  * Return: Zero if the buffer with the given size is allocated successfully,
 197  * otherwise a negative value on error.
 198  */
 199 int snd_dma_alloc_pages_fallback(int type, struct device *device, size_t size,
 200                                  struct snd_dma_buffer *dmab)
 201 {
 202         int err;
 203
 204         while ((err = snd_dma_alloc_pages(type, device, size, dmab)) < 0) {
 205                 if (err != -ENOMEM)
 206                         return err;
 207                 if (size <= PAGE_SIZE)
 208                         return -ENOMEM;
 209                 size >>= 1;
 210                 size = PAGE_SIZE << get_order(size);
 211         }
 212         if (! dmab->area)
 213                 return -ENOMEM;
 214         return 0;
 215 }
 216 EXPORT_SYMBOL(snd_dma_alloc_pages_fallback);
 217
 218
 219 /**
 220  * snd_dma_free_pages - release the allocated buffer
 221  * @dmab: the buffer allocation record to release
 222  *
 223  * Releases the allocated buffer via snd_dma_alloc_pages().
 224  */
 225 void snd_dma_free_pages(struct snd_dma_buffer *dmab)
 226 {
 227         switch (dmab->dev.type) {
 228         case SNDRV_DMA_TYPE_CONTINUOUS:
 229                 free_pages_exact(dmab->area, dmab->bytes);
 230                 break;
 231         case SNDRV_DMA_TYPE_VMALLOC:
 232                 vfree(dmab->area);
 233                 break;
 234 #ifdef CONFIG_HAS_DMA
 235 #ifdef CONFIG_GENERIC_ALLOCATOR
 236         case SNDRV_DMA_TYPE_DEV_IRAM:
 237                 snd_free_dev_iram(dmab);
 238                 break;
 239 #endif /* CONFIG_GENERIC_ALLOCATOR */
 240         case SNDRV_DMA_TYPE_DEV:
 241         case SNDRV_DMA_TYPE_DEV_UC:
 242                 snd_free_dev_pages(dmab);
 243                 break;
 244 #endif
 245 #ifdef CONFIG_SND_DMA_SGBUF
 246         case SNDRV_DMA_TYPE_DEV_SG:
 247         case SNDRV_DMA_TYPE_DEV_UC_SG:
 248                 snd_free_sgbuf_pages(dmab);
 249                 break;
 250 #endif
 251         default:
 252                 pr_err("snd-malloc: invalid device type %d\n", dmab->dev.type);
 253         }
 254 }
 255 EXPORT_SYMBOL(snd_dma_free_pages);