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 #include "memalloc_local.h"
  19
  20 static const struct snd_malloc_ops *snd_dma_get_ops(struct snd_dma_buffer *dmab);
  21
  22 /* a cast to gfp flag from the dev pointer; for CONTINUOUS and VMALLOC types */
  23 static inline gfp_t snd_mem_get_gfp_flags(const struct snd_dma_buffer *dmab,
  24                                           gfp_t default_gfp)
  25 {
  26         if (!dmab->dev.dev)
  27                 return default_gfp;
  28         else
  29                 return (__force gfp_t)(unsigned long)dmab->dev.dev;
  30 }
  31
  32 static void *__snd_dma_alloc_pages(struct snd_dma_buffer *dmab, size_t size)
  33 {
  34         const struct snd_malloc_ops *ops = snd_dma_get_ops(dmab);
  35
  36         if (WARN_ON_ONCE(!ops || !ops->alloc))
  37                 return NULL;
  38         return ops->alloc(dmab, size);
  39 }
  40
  41 /**
  42  * snd_dma_alloc_pages - allocate the buffer area according to the given type
  43  * @type: the DMA buffer type
  44  * @device: the device pointer
  45  * @size: the buffer size to allocate
  46  * @dmab: buffer allocation record to store the allocated data
  47  *
  48  * Calls the memory-allocator function for the corresponding
  49  * buffer type.
  50  *
  51  * Return: Zero if the buffer with the given size is allocated successfully,
  52  * otherwise a negative value on error.
  53  */
  54 int snd_dma_alloc_pages(int type, struct device *device, size_t size,
  55                         struct snd_dma_buffer *dmab)
  56 {
  57         if (WARN_ON(!size))
  58                 return -ENXIO;
  59         if (WARN_ON(!dmab))
  60                 return -ENXIO;
  61
  62         size = PAGE_ALIGN(size);
  63         dmab->dev.type = type;
  64         dmab->dev.dev = device;
  65         dmab->bytes = 0;
  66         dmab->addr = 0;
  67         dmab->private_data = NULL;
  68         dmab->area = __snd_dma_alloc_pages(dmab, size);
  69         if (!dmab->area)
  70                 return -ENOMEM;
  71         dmab->bytes = size;
  72         return 0;
  73 }
  74 EXPORT_SYMBOL(snd_dma_alloc_pages);
  75
  76 /**
  77  * snd_dma_alloc_pages_fallback - allocate the buffer area according to the given type with fallback
  78  * @type: the DMA buffer type
  79  * @device: the device pointer
  80  * @size: the buffer size to allocate
  81  * @dmab: buffer allocation record to store the allocated data
  82  *
  83  * Calls the memory-allocator function for the corresponding
  84  * buffer type.  When no space is left, this function reduces the size and
  85  * tries to allocate again.  The size actually allocated is stored in
  86  * res_size argument.
  87  *
  88  * Return: Zero if the buffer with the given size is allocated successfully,
  89  * otherwise a negative value on error.
  90  */
  91 int snd_dma_alloc_pages_fallback(int type, struct device *device, size_t size,
  92                                  struct snd_dma_buffer *dmab)
  93 {
  94         int err;
  95
  96         while ((err = snd_dma_alloc_pages(type, device, size, dmab)) < 0) {
  97                 if (err != -ENOMEM)
  98                         return err;
  99                 if (size <= PAGE_SIZE)
 100                         return -ENOMEM;
 101                 size >>= 1;
 102                 size = PAGE_SIZE << get_order(size);
 103         }
 104         if (! dmab->area)
 105                 return -ENOMEM;
 106         return 0;
 107 }
 108 EXPORT_SYMBOL(snd_dma_alloc_pages_fallback);
 109
 110 /**
 111  * snd_dma_free_pages - release the allocated buffer
 112  * @dmab: the buffer allocation record to release
 113  *
 114  * Releases the allocated buffer via snd_dma_alloc_pages().
 115  */
 116 void snd_dma_free_pages(struct snd_dma_buffer *dmab)
 117 {
 118         const struct snd_malloc_ops *ops = snd_dma_get_ops(dmab);
 119
 120         if (ops && ops->free)
 121                 ops->free(dmab);
 122 }
 123 EXPORT_SYMBOL(snd_dma_free_pages);
 124
 125 /* called by devres */
 126 static void __snd_release_pages(struct device *dev, void *res)
 127 {
 128         snd_dma_free_pages(res);
 129 }
 130
 131 /**
 132  * snd_devm_alloc_pages - allocate the buffer and manage with devres
 133  * @dev: the device pointer
 134  * @type: the DMA buffer type
 135  * @size: the buffer size to allocate
 136  *
 137  * Allocate buffer pages depending on the given type and manage using devres.
 138  * The pages will be released automatically at the device removal.
 139  *
 140  * Unlike snd_dma_alloc_pages(), this function requires the real device pointer,
 141  * hence it can't work with SNDRV_DMA_TYPE_CONTINUOUS or
 142  * SNDRV_DMA_TYPE_VMALLOC type.
 143  *
 144  * The function returns the snd_dma_buffer object at success, or NULL if failed.
 145  */
 146 struct snd_dma_buffer *
 147 snd_devm_alloc_pages(struct device *dev, int type, size_t size)
 148 {
 149         struct snd_dma_buffer *dmab;
 150         int err;
 151
 152         if (WARN_ON(type == SNDRV_DMA_TYPE_CONTINUOUS ||
 153                     type == SNDRV_DMA_TYPE_VMALLOC))
 154                 return NULL;
 155
 156         dmab = devres_alloc(__snd_release_pages, sizeof(*dmab), GFP_KERNEL);
 157         if (!dmab)
 158                 return NULL;
 159
 160         err = snd_dma_alloc_pages(type, dev, size, dmab);
 161         if (err < 0) {
 162                 devres_free(dmab);
 163                 return NULL;
 164         }
 165
 166         devres_add(dev, dmab);
 167         return dmab;
 168 }
 169 EXPORT_SYMBOL_GPL(snd_devm_alloc_pages);
 170
 171 /**
 172  * snd_dma_buffer_mmap - perform mmap of the given DMA buffer
 173  * @dmab: buffer allocation information
 174  * @area: VM area information
 175  */
 176 int snd_dma_buffer_mmap(struct snd_dma_buffer *dmab,
 177                         struct vm_area_struct *area)
 178 {
 179         const struct snd_malloc_ops *ops = snd_dma_get_ops(dmab);
 180
 181         if (ops && ops->mmap)
 182                 return ops->mmap(dmab, area);
 183         else
 184                 return -ENOENT;
 185 }
 186 EXPORT_SYMBOL(snd_dma_buffer_mmap);
 187
 188 /**
 189  * snd_sgbuf_get_addr - return the physical address at the corresponding offset
 190  * @dmab: buffer allocation information
 191  * @offset: offset in the ring buffer
 192  */
 193 dma_addr_t snd_sgbuf_get_addr(struct snd_dma_buffer *dmab, size_t offset)
 194 {
 195         const struct snd_malloc_ops *ops = snd_dma_get_ops(dmab);
 196
 197         if (ops && ops->get_addr)
 198                 return ops->get_addr(dmab, offset);
 199         else
 200                 return dmab->addr + offset;
 201 }
 202 EXPORT_SYMBOL(snd_sgbuf_get_addr);
 203
 204 /**
 205  * snd_sgbuf_get_page - return the physical page at the corresponding offset
 206  * @dmab: buffer allocation information
 207  * @offset: offset in the ring buffer
 208  */
 209 struct page *snd_sgbuf_get_page(struct snd_dma_buffer *dmab, size_t offset)
 210 {
 211         const struct snd_malloc_ops *ops = snd_dma_get_ops(dmab);
 212
 213         if (ops && ops->get_page)
 214                 return ops->get_page(dmab, offset);
 215         else
 216                 return virt_to_page(dmab->area + offset);
 217 }
 218 EXPORT_SYMBOL(snd_sgbuf_get_page);
 219
 220 /**
 221  * snd_sgbuf_get_chunk_size - compute the max chunk size with continuous pages
 222  *      on sg-buffer
 223  * @dmab: buffer allocation information
 224  * @ofs: offset in the ring buffer
 225  * @size: the requested size
 226  */
 227 unsigned int snd_sgbuf_get_chunk_size(struct snd_dma_buffer *dmab,
 228                                       unsigned int ofs, unsigned int size)
 229 {
 230         const struct snd_malloc_ops *ops = snd_dma_get_ops(dmab);
 231
 232         if (ops && ops->get_chunk_size)
 233                 return ops->get_chunk_size(dmab, ofs, size);
 234         else
 235                 return size;
 236 }
 237 EXPORT_SYMBOL(snd_sgbuf_get_chunk_size);
 238
 239 /*
 240  * Continuous pages allocator
 241  */
 242 static void *snd_dma_continuous_alloc(struct snd_dma_buffer *dmab, size_t size)
 243 {
 244         gfp_t gfp = snd_mem_get_gfp_flags(dmab, GFP_KERNEL);
 245
 246         return alloc_pages_exact(size, gfp);
 247 }
 248
 249 static void snd_dma_continuous_free(struct snd_dma_buffer *dmab)
 250 {
 251         free_pages_exact(dmab->area, dmab->bytes);
 252 }
 253
 254 static int snd_dma_continuous_mmap(struct snd_dma_buffer *dmab,
 255                                    struct vm_area_struct *area)
 256 {
 257         return remap_pfn_range(area, area->vm_start,
 258                                page_to_pfn(virt_to_page(dmab->area)),
 259                                area->vm_end - area->vm_start,
 260                                area->vm_page_prot);
 261 }
 262
 263 static const struct snd_malloc_ops snd_dma_continuous_ops = {
 264         .alloc = snd_dma_continuous_alloc,
 265         .free = snd_dma_continuous_free,
 266         .mmap = snd_dma_continuous_mmap,
 267 };
 268
 269 /*
 270  * VMALLOC allocator
 271  */
 272 static void *snd_dma_vmalloc_alloc(struct snd_dma_buffer *dmab, size_t size)
 273 {
 274         gfp_t gfp = snd_mem_get_gfp_flags(dmab, GFP_KERNEL | __GFP_HIGHMEM);
 275
 276         return __vmalloc(size, gfp);
 277 }
 278
 279 static void snd_dma_vmalloc_free(struct snd_dma_buffer *dmab)
 280 {
 281         vfree(dmab->area);
 282 }
 283
 284 static int snd_dma_vmalloc_mmap(struct snd_dma_buffer *dmab,
 285                                 struct vm_area_struct *area)
 286 {
 287         return remap_vmalloc_range(area, dmab->area, 0);
 288 }
 289
 290 static dma_addr_t snd_dma_vmalloc_get_addr(struct snd_dma_buffer *dmab,
 291                                            size_t offset)
 292 {
 293         return page_to_phys(vmalloc_to_page(dmab->area + offset)) +
 294                 offset % PAGE_SIZE;
 295 }
 296
 297 static struct page *snd_dma_vmalloc_get_page(struct snd_dma_buffer *dmab,
 298                                              size_t offset)
 299 {
 300         return vmalloc_to_page(dmab->area + offset);
 301 }
 302
 303 static unsigned int
 304 snd_dma_vmalloc_get_chunk_size(struct snd_dma_buffer *dmab,
 305                                unsigned int ofs, unsigned int size)
 306 {
 307         ofs %= PAGE_SIZE;
 308         size += ofs;
 309         if (size > PAGE_SIZE)
 310                 size = PAGE_SIZE;
 311         return size - ofs;
 312 }
 313
 314 static const struct snd_malloc_ops snd_dma_vmalloc_ops = {
 315         .alloc = snd_dma_vmalloc_alloc,
 316         .free = snd_dma_vmalloc_free,
 317         .mmap = snd_dma_vmalloc_mmap,
 318         .get_addr = snd_dma_vmalloc_get_addr,
 319         .get_page = snd_dma_vmalloc_get_page,
 320         .get_chunk_size = snd_dma_vmalloc_get_chunk_size,
 321 };
 322
 323 #ifdef CONFIG_HAS_DMA
 324 /*
 325  * IRAM allocator
 326  */
 327 #ifdef CONFIG_GENERIC_ALLOCATOR
 328 static void *snd_dma_iram_alloc(struct snd_dma_buffer *dmab, size_t size)
 329 {
 330         struct device *dev = dmab->dev.dev;
 331         struct gen_pool *pool;
 332         void *p;
 333
 334         if (dev->of_node) {
 335                 pool = of_gen_pool_get(dev->of_node, "iram", 0);
 336                 /* Assign the pool into private_data field */
 337                 dmab->private_data = pool;
 338
 339                 p = gen_pool_dma_alloc_align(pool, size, &dmab->addr, PAGE_SIZE);
 340                 if (p)
 341                         return p;
 342         }
 343
 344         /* Internal memory might have limited size and no enough space,
 345          * so if we fail to malloc, try to fetch memory traditionally.
 346          */
 347         dmab->dev.type = SNDRV_DMA_TYPE_DEV;
 348         return __snd_dma_alloc_pages(dmab, size);
 349 }
 350
 351 static void snd_dma_iram_free(struct snd_dma_buffer *dmab)
 352 {
 353         struct gen_pool *pool = dmab->private_data;
 354
 355         if (pool && dmab->area)
 356                 gen_pool_free(pool, (unsigned long)dmab->area, dmab->bytes);
 357 }
 358
 359 static int snd_dma_iram_mmap(struct snd_dma_buffer *dmab,
 360                              struct vm_area_struct *area)
 361 {
 362         area->vm_page_prot = pgprot_writecombine(area->vm_page_prot);
 363         return remap_pfn_range(area, area->vm_start,
 364                                dmab->addr >> PAGE_SHIFT,
 365                                area->vm_end - area->vm_start,
 366                                area->vm_page_prot);
 367 }
 368
 369 static const struct snd_malloc_ops snd_dma_iram_ops = {
 370         .alloc = snd_dma_iram_alloc,
 371         .free = snd_dma_iram_free,
 372         .mmap = snd_dma_iram_mmap,
 373 };
 374 #endif /* CONFIG_GENERIC_ALLOCATOR */
 375
 376 #define DEFAULT_GFP \
 377         (GFP_KERNEL | \
 378          __GFP_COMP |    /* compound page lets parts be mapped */ \
 379          __GFP_NORETRY | /* don't trigger OOM-killer */ \
 380          __GFP_NOWARN)   /* no stack trace print - this call is non-critical */
 381
 382 /*
 383  * Coherent device pages allocator
 384  */
 385 static void *snd_dma_dev_alloc(struct snd_dma_buffer *dmab, size_t size)
 386 {
 387         void *p;
 388
 389         p = dma_alloc_coherent(dmab->dev.dev, size, &dmab->addr, DEFAULT_GFP);
 390 #ifdef CONFIG_X86
 391         if (p && dmab->dev.type == SNDRV_DMA_TYPE_DEV_WC)
 392                 set_memory_wc((unsigned long)p, PAGE_ALIGN(size) >> PAGE_SHIFT);
 393 #endif
 394         return p;
 395 }
 396
 397 static void snd_dma_dev_free(struct snd_dma_buffer *dmab)
 398 {
 399 #ifdef CONFIG_X86
 400         if (dmab->dev.type == SNDRV_DMA_TYPE_DEV_WC)
 401                 set_memory_wb((unsigned long)dmab->area,
 402                               PAGE_ALIGN(dmab->bytes) >> PAGE_SHIFT);
 403 #endif
 404         dma_free_coherent(dmab->dev.dev, dmab->bytes, dmab->area, dmab->addr);
 405 }
 406
 407 static int snd_dma_dev_mmap(struct snd_dma_buffer *dmab,
 408                             struct vm_area_struct *area)
 409 {
 410         return dma_mmap_coherent(dmab->dev.dev, area,
 411                                  dmab->area, dmab->addr, dmab->bytes);
 412 }
 413
 414 static const struct snd_malloc_ops snd_dma_dev_ops = {
 415         .alloc = snd_dma_dev_alloc,
 416         .free = snd_dma_dev_free,
 417         .mmap = snd_dma_dev_mmap,
 418 };
 419
 420 /*
 421  * Write-combined pages
 422  */
 423 #ifdef CONFIG_X86
 424 /* On x86, share the same ops as the standard dev ops */
 425 #define snd_dma_wc_ops  snd_dma_dev_ops
 426 #else /* CONFIG_X86 */
 427 static void *snd_dma_wc_alloc(struct snd_dma_buffer *dmab, size_t size)
 428 {
 429         return dma_alloc_wc(dmab->dev.dev, size, &dmab->addr, DEFAULT_GFP);
 430 }
 431
 432 static void snd_dma_wc_free(struct snd_dma_buffer *dmab)
 433 {
 434         dma_free_wc(dmab->dev.dev, dmab->bytes, dmab->area, dmab->addr);
 435 }
 436
 437 static int snd_dma_wc_mmap(struct snd_dma_buffer *dmab,
 438                            struct vm_area_struct *area)
 439 {
 440         return dma_mmap_wc(dmab->dev.dev, area,
 441                            dmab->area, dmab->addr, dmab->bytes);
 442 }
 443
 444 static const struct snd_malloc_ops snd_dma_wc_ops = {
 445         .alloc = snd_dma_wc_alloc,
 446         .free = snd_dma_wc_free,
 447         .mmap = snd_dma_wc_mmap,
 448 };
 449 #endif /* CONFIG_X86 */
 450 #endif /* CONFIG_HAS_DMA */
 451
 452 /*
 453  * Entry points
 454  */
 455 static const struct snd_malloc_ops *dma_ops[] = {
 456         [SNDRV_DMA_TYPE_CONTINUOUS] = &snd_dma_continuous_ops,
 457         [SNDRV_DMA_TYPE_VMALLOC] = &snd_dma_vmalloc_ops,
 458 #ifdef CONFIG_HAS_DMA
 459         [SNDRV_DMA_TYPE_DEV] = &snd_dma_dev_ops,
 460         [SNDRV_DMA_TYPE_DEV_WC] = &snd_dma_wc_ops,
 461 #ifdef CONFIG_GENERIC_ALLOCATOR
 462         [SNDRV_DMA_TYPE_DEV_IRAM] = &snd_dma_iram_ops,
 463 #endif /* CONFIG_GENERIC_ALLOCATOR */
 464 #endif /* CONFIG_HAS_DMA */
 465 #ifdef CONFIG_SND_DMA_SGBUF
 466         [SNDRV_DMA_TYPE_DEV_SG] = &snd_dma_sg_ops,
 467         [SNDRV_DMA_TYPE_DEV_WC_SG] = &snd_dma_sg_ops,
 468 #endif
 469 };
 470
 471 static const struct snd_malloc_ops *snd_dma_get_ops(struct snd_dma_buffer *dmab)
 472 {
 473         if (WARN_ON_ONCE(dmab->dev.type <= SNDRV_DMA_TYPE_UNKNOWN ||
 474                          dmab->dev.type >= ARRAY_SIZE(dma_ops)))
 475                 return NULL;
 476         return dma_ops[dmab->dev.type];
 477 }