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