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