1 /* 2 * Copyright (c) by Jaroslav Kysela <perex@perex.cz> 3 * Takashi Iwai <tiwai@suse.de> 4 * 5 * Generic memory allocators 6 * 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 21 * 22 */ 23 24 #include <linux/module.h> 25 #include <linux/proc_fs.h> 26 #include <linux/init.h> 27 #include <linux/pci.h> 28 #include <linux/slab.h> 29 #include <linux/mm.h> 30 #include <linux/seq_file.h> 31 #include <asm/uaccess.h> 32 #include <linux/dma-mapping.h> 33 #include <linux/genalloc.h> 34 #include <linux/moduleparam.h> 35 #include <linux/mutex.h> 36 #include <sound/memalloc.h> 37 38 39 MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>, Jaroslav Kysela <perex@perex.cz>"); 40 MODULE_DESCRIPTION("Memory allocator for ALSA system."); 41 MODULE_LICENSE("GPL"); 42 43 44 /* 45 */ 46 47 static DEFINE_MUTEX(list_mutex); 48 static LIST_HEAD(mem_list_head); 49 50 /* buffer preservation list */ 51 struct snd_mem_list { 52 struct snd_dma_buffer buffer; 53 unsigned int id; 54 struct list_head list; 55 }; 56 57 /* id for pre-allocated buffers */ 58 #define SNDRV_DMA_DEVICE_UNUSED (unsigned int)-1 59 60 /* 61 * 62 * Generic memory allocators 63 * 64 */ 65 66 static long snd_allocated_pages; /* holding the number of allocated pages */ 67 68 static inline void inc_snd_pages(int order) 69 { 70 snd_allocated_pages += 1 << order; 71 } 72 73 static inline void dec_snd_pages(int order) 74 { 75 snd_allocated_pages -= 1 << order; 76 } 77 78 /** 79 * snd_malloc_pages - allocate pages with the given size 80 * @size: the size to allocate in bytes 81 * @gfp_flags: the allocation conditions, GFP_XXX 82 * 83 * Allocates the physically contiguous pages with the given size. 84 * 85 * Return: The pointer of the buffer, or %NULL if no enough memory. 86 */ 87 void *snd_malloc_pages(size_t size, gfp_t gfp_flags) 88 { 89 int pg; 90 void *res; 91 92 if (WARN_ON(!size)) 93 return NULL; 94 if (WARN_ON(!gfp_flags)) 95 return NULL; 96 gfp_flags |= __GFP_COMP; /* compound page lets parts be mapped */ 97 pg = get_order(size); 98 if ((res = (void *) __get_free_pages(gfp_flags, pg)) != NULL) 99 inc_snd_pages(pg); 100 return res; 101 } 102 103 /** 104 * snd_free_pages - release the pages 105 * @ptr: the buffer pointer to release 106 * @size: the allocated buffer size 107 * 108 * Releases the buffer allocated via snd_malloc_pages(). 109 */ 110 void snd_free_pages(void *ptr, size_t size) 111 { 112 int pg; 113 114 if (ptr == NULL) 115 return; 116 pg = get_order(size); 117 dec_snd_pages(pg); 118 free_pages((unsigned long) ptr, pg); 119 } 120 121 /* 122 * 123 * Bus-specific memory allocators 124 * 125 */ 126 127 #ifdef CONFIG_HAS_DMA 128 /* allocate the coherent DMA pages */ 129 static void *snd_malloc_dev_pages(struct device *dev, size_t size, dma_addr_t *dma) 130 { 131 int pg; 132 void *res; 133 gfp_t gfp_flags; 134 135 if (WARN_ON(!dma)) 136 return NULL; 137 pg = get_order(size); 138 gfp_flags = GFP_KERNEL 139 | __GFP_COMP /* compound page lets parts be mapped */ 140 | __GFP_NORETRY /* don't trigger OOM-killer */ 141 | __GFP_NOWARN; /* no stack trace print - this call is non-critical */ 142 res = dma_alloc_coherent(dev, PAGE_SIZE << pg, dma, gfp_flags); 143 if (res != NULL) 144 inc_snd_pages(pg); 145 146 return res; 147 } 148 149 /* free the coherent DMA pages */ 150 static void snd_free_dev_pages(struct device *dev, size_t size, void *ptr, 151 dma_addr_t dma) 152 { 153 int pg; 154 155 if (ptr == NULL) 156 return; 157 pg = get_order(size); 158 dec_snd_pages(pg); 159 dma_free_coherent(dev, PAGE_SIZE << pg, ptr, dma); 160 } 161 162 #ifdef CONFIG_GENERIC_ALLOCATOR 163 /** 164 * snd_malloc_dev_iram - allocate memory from on-chip internal ram 165 * @dmab: buffer allocation record to store the allocated data 166 * @size: number of bytes to allocate from the iram 167 * 168 * This function requires iram phandle provided via of_node 169 */ 170 static void snd_malloc_dev_iram(struct snd_dma_buffer *dmab, size_t size) 171 { 172 struct device *dev = dmab->dev.dev; 173 struct gen_pool *pool = NULL; 174 175 dmab->area = NULL; 176 dmab->addr = 0; 177 178 if (dev->of_node) 179 pool = of_get_named_gen_pool(dev->of_node, "iram", 0); 180 181 if (!pool) 182 return; 183 184 /* Assign the pool into private_data field */ 185 dmab->private_data = pool; 186 187 dmab->area = gen_pool_dma_alloc(pool, size, &dmab->addr); 188 } 189 190 /** 191 * snd_free_dev_iram - free allocated specific memory from on-chip internal ram 192 * @dmab: buffer allocation record to store the allocated data 193 */ 194 static void snd_free_dev_iram(struct snd_dma_buffer *dmab) 195 { 196 struct gen_pool *pool = dmab->private_data; 197 198 if (pool && dmab->area) 199 gen_pool_free(pool, (unsigned long)dmab->area, dmab->bytes); 200 } 201 #endif /* CONFIG_GENERIC_ALLOCATOR */ 202 #endif /* CONFIG_HAS_DMA */ 203 204 /* 205 * 206 * ALSA generic memory management 207 * 208 */ 209 210 211 /** 212 * snd_dma_alloc_pages - allocate the buffer area according to the given type 213 * @type: the DMA buffer type 214 * @device: the device pointer 215 * @size: the buffer size to allocate 216 * @dmab: buffer allocation record to store the allocated data 217 * 218 * Calls the memory-allocator function for the corresponding 219 * buffer type. 220 * 221 * Return: Zero if the buffer with the given size is allocated successfully, 222 * otherwise a negative value on error. 223 */ 224 int snd_dma_alloc_pages(int type, struct device *device, size_t size, 225 struct snd_dma_buffer *dmab) 226 { 227 if (WARN_ON(!size)) 228 return -ENXIO; 229 if (WARN_ON(!dmab)) 230 return -ENXIO; 231 232 dmab->dev.type = type; 233 dmab->dev.dev = device; 234 dmab->bytes = 0; 235 switch (type) { 236 case SNDRV_DMA_TYPE_CONTINUOUS: 237 dmab->area = snd_malloc_pages(size, 238 (__force gfp_t)(unsigned long)device); 239 dmab->addr = 0; 240 break; 241 #ifdef CONFIG_HAS_DMA 242 #ifdef CONFIG_GENERIC_ALLOCATOR 243 case SNDRV_DMA_TYPE_DEV_IRAM: 244 snd_malloc_dev_iram(dmab, size); 245 if (dmab->area) 246 break; 247 /* Internal memory might have limited size and no enough space, 248 * so if we fail to malloc, try to fetch memory traditionally. 249 */ 250 dmab->dev.type = SNDRV_DMA_TYPE_DEV; 251 #endif /* CONFIG_GENERIC_ALLOCATOR */ 252 case SNDRV_DMA_TYPE_DEV: 253 dmab->area = snd_malloc_dev_pages(device, size, &dmab->addr); 254 break; 255 #endif 256 #ifdef CONFIG_SND_DMA_SGBUF 257 case SNDRV_DMA_TYPE_DEV_SG: 258 snd_malloc_sgbuf_pages(device, size, dmab, NULL); 259 break; 260 #endif 261 default: 262 printk(KERN_ERR "snd-malloc: invalid device type %d\n", type); 263 dmab->area = NULL; 264 dmab->addr = 0; 265 return -ENXIO; 266 } 267 if (! dmab->area) 268 return -ENOMEM; 269 dmab->bytes = size; 270 return 0; 271 } 272 273 /** 274 * snd_dma_alloc_pages_fallback - allocate the buffer area according to the given type with fallback 275 * @type: the DMA buffer type 276 * @device: the device pointer 277 * @size: the buffer size to allocate 278 * @dmab: buffer allocation record to store the allocated data 279 * 280 * Calls the memory-allocator function for the corresponding 281 * buffer type. When no space is left, this function reduces the size and 282 * tries to allocate again. The size actually allocated is stored in 283 * res_size argument. 284 * 285 * Return: Zero if the buffer with the given size is allocated successfully, 286 * otherwise a negative value on error. 287 */ 288 int snd_dma_alloc_pages_fallback(int type, struct device *device, size_t size, 289 struct snd_dma_buffer *dmab) 290 { 291 int err; 292 293 while ((err = snd_dma_alloc_pages(type, device, size, dmab)) < 0) { 294 size_t aligned_size; 295 if (err != -ENOMEM) 296 return err; 297 if (size <= PAGE_SIZE) 298 return -ENOMEM; 299 aligned_size = PAGE_SIZE << get_order(size); 300 if (size != aligned_size) 301 size = aligned_size; 302 else 303 size >>= 1; 304 } 305 if (! dmab->area) 306 return -ENOMEM; 307 return 0; 308 } 309 310 311 /** 312 * snd_dma_free_pages - release the allocated buffer 313 * @dmab: the buffer allocation record to release 314 * 315 * Releases the allocated buffer via snd_dma_alloc_pages(). 316 */ 317 void snd_dma_free_pages(struct snd_dma_buffer *dmab) 318 { 319 switch (dmab->dev.type) { 320 case SNDRV_DMA_TYPE_CONTINUOUS: 321 snd_free_pages(dmab->area, dmab->bytes); 322 break; 323 #ifdef CONFIG_HAS_DMA 324 #ifdef CONFIG_GENERIC_ALLOCATOR 325 case SNDRV_DMA_TYPE_DEV_IRAM: 326 snd_free_dev_iram(dmab); 327 break; 328 #endif /* CONFIG_GENERIC_ALLOCATOR */ 329 case SNDRV_DMA_TYPE_DEV: 330 snd_free_dev_pages(dmab->dev.dev, dmab->bytes, dmab->area, dmab->addr); 331 break; 332 #endif 333 #ifdef CONFIG_SND_DMA_SGBUF 334 case SNDRV_DMA_TYPE_DEV_SG: 335 snd_free_sgbuf_pages(dmab); 336 break; 337 #endif 338 default: 339 printk(KERN_ERR "snd-malloc: invalid device type %d\n", dmab->dev.type); 340 } 341 } 342 343 344 /** 345 * snd_dma_get_reserved - get the reserved buffer for the given device 346 * @dmab: the buffer allocation record to store 347 * @id: the buffer id 348 * 349 * Looks for the reserved-buffer list and re-uses if the same buffer 350 * is found in the list. When the buffer is found, it's removed from the free list. 351 * 352 * Return: The size of buffer if the buffer is found, or zero if not found. 353 */ 354 size_t snd_dma_get_reserved_buf(struct snd_dma_buffer *dmab, unsigned int id) 355 { 356 struct snd_mem_list *mem; 357 358 if (WARN_ON(!dmab)) 359 return 0; 360 361 mutex_lock(&list_mutex); 362 list_for_each_entry(mem, &mem_list_head, list) { 363 if (mem->id == id && 364 (mem->buffer.dev.dev == NULL || dmab->dev.dev == NULL || 365 ! memcmp(&mem->buffer.dev, &dmab->dev, sizeof(dmab->dev)))) { 366 struct device *dev = dmab->dev.dev; 367 list_del(&mem->list); 368 *dmab = mem->buffer; 369 if (dmab->dev.dev == NULL) 370 dmab->dev.dev = dev; 371 kfree(mem); 372 mutex_unlock(&list_mutex); 373 return dmab->bytes; 374 } 375 } 376 mutex_unlock(&list_mutex); 377 return 0; 378 } 379 380 /** 381 * snd_dma_reserve_buf - reserve the buffer 382 * @dmab: the buffer to reserve 383 * @id: the buffer id 384 * 385 * Reserves the given buffer as a reserved buffer. 386 * 387 * Return: Zero if successful, or a negative code on error. 388 */ 389 int snd_dma_reserve_buf(struct snd_dma_buffer *dmab, unsigned int id) 390 { 391 struct snd_mem_list *mem; 392 393 if (WARN_ON(!dmab)) 394 return -EINVAL; 395 mem = kmalloc(sizeof(*mem), GFP_KERNEL); 396 if (! mem) 397 return -ENOMEM; 398 mutex_lock(&list_mutex); 399 mem->buffer = *dmab; 400 mem->id = id; 401 list_add_tail(&mem->list, &mem_list_head); 402 mutex_unlock(&list_mutex); 403 return 0; 404 } 405 406 /* 407 * purge all reserved buffers 408 */ 409 static void free_all_reserved_pages(void) 410 { 411 struct list_head *p; 412 struct snd_mem_list *mem; 413 414 mutex_lock(&list_mutex); 415 while (! list_empty(&mem_list_head)) { 416 p = mem_list_head.next; 417 mem = list_entry(p, struct snd_mem_list, list); 418 list_del(p); 419 snd_dma_free_pages(&mem->buffer); 420 kfree(mem); 421 } 422 mutex_unlock(&list_mutex); 423 } 424 425 426 #ifdef CONFIG_PROC_FS 427 /* 428 * proc file interface 429 */ 430 #define SND_MEM_PROC_FILE "driver/snd-page-alloc" 431 static struct proc_dir_entry *snd_mem_proc; 432 433 static int snd_mem_proc_read(struct seq_file *seq, void *offset) 434 { 435 long pages = snd_allocated_pages >> (PAGE_SHIFT-12); 436 struct snd_mem_list *mem; 437 int devno; 438 static char *types[] = { "UNKNOWN", "CONT", "DEV", "DEV-SG" }; 439 440 mutex_lock(&list_mutex); 441 seq_printf(seq, "pages : %li bytes (%li pages per %likB)\n", 442 pages * PAGE_SIZE, pages, PAGE_SIZE / 1024); 443 devno = 0; 444 list_for_each_entry(mem, &mem_list_head, list) { 445 devno++; 446 seq_printf(seq, "buffer %d : ID %08x : type %s\n", 447 devno, mem->id, types[mem->buffer.dev.type]); 448 seq_printf(seq, " addr = 0x%lx, size = %d bytes\n", 449 (unsigned long)mem->buffer.addr, 450 (int)mem->buffer.bytes); 451 } 452 mutex_unlock(&list_mutex); 453 return 0; 454 } 455 456 static int snd_mem_proc_open(struct inode *inode, struct file *file) 457 { 458 return single_open(file, snd_mem_proc_read, NULL); 459 } 460 461 /* FIXME: for pci only - other bus? */ 462 #ifdef CONFIG_PCI 463 #define gettoken(bufp) strsep(bufp, " \t\n") 464 465 static ssize_t snd_mem_proc_write(struct file *file, const char __user * buffer, 466 size_t count, loff_t * ppos) 467 { 468 char buf[128]; 469 char *token, *p; 470 471 if (count > sizeof(buf) - 1) 472 return -EINVAL; 473 if (copy_from_user(buf, buffer, count)) 474 return -EFAULT; 475 buf[count] = '\0'; 476 477 p = buf; 478 token = gettoken(&p); 479 if (! token || *token == '#') 480 return count; 481 if (strcmp(token, "add") == 0) { 482 char *endp; 483 int vendor, device, size, buffers; 484 long mask; 485 int i, alloced; 486 struct pci_dev *pci; 487 488 if ((token = gettoken(&p)) == NULL || 489 (vendor = simple_strtol(token, NULL, 0)) <= 0 || 490 (token = gettoken(&p)) == NULL || 491 (device = simple_strtol(token, NULL, 0)) <= 0 || 492 (token = gettoken(&p)) == NULL || 493 (mask = simple_strtol(token, NULL, 0)) < 0 || 494 (token = gettoken(&p)) == NULL || 495 (size = memparse(token, &endp)) < 64*1024 || 496 size > 16*1024*1024 /* too big */ || 497 (token = gettoken(&p)) == NULL || 498 (buffers = simple_strtol(token, NULL, 0)) <= 0 || 499 buffers > 4) { 500 printk(KERN_ERR "snd-page-alloc: invalid proc write format\n"); 501 return count; 502 } 503 vendor &= 0xffff; 504 device &= 0xffff; 505 506 alloced = 0; 507 pci = NULL; 508 while ((pci = pci_get_device(vendor, device, pci)) != NULL) { 509 if (mask > 0 && mask < 0xffffffff) { 510 if (pci_set_dma_mask(pci, mask) < 0 || 511 pci_set_consistent_dma_mask(pci, mask) < 0) { 512 printk(KERN_ERR "snd-page-alloc: cannot set DMA mask %lx for pci %04x:%04x\n", mask, vendor, device); 513 pci_dev_put(pci); 514 return count; 515 } 516 } 517 for (i = 0; i < buffers; i++) { 518 struct snd_dma_buffer dmab; 519 memset(&dmab, 0, sizeof(dmab)); 520 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci), 521 size, &dmab) < 0) { 522 printk(KERN_ERR "snd-page-alloc: cannot allocate buffer pages (size = %d)\n", size); 523 pci_dev_put(pci); 524 return count; 525 } 526 snd_dma_reserve_buf(&dmab, snd_dma_pci_buf_id(pci)); 527 } 528 alloced++; 529 } 530 if (! alloced) { 531 for (i = 0; i < buffers; i++) { 532 struct snd_dma_buffer dmab; 533 memset(&dmab, 0, sizeof(dmab)); 534 /* FIXME: We can allocate only in ZONE_DMA 535 * without a device pointer! 536 */ 537 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, NULL, 538 size, &dmab) < 0) { 539 printk(KERN_ERR "snd-page-alloc: cannot allocate buffer pages (size = %d)\n", size); 540 break; 541 } 542 snd_dma_reserve_buf(&dmab, (unsigned int)((vendor << 16) | device)); 543 } 544 } 545 } else if (strcmp(token, "erase") == 0) 546 /* FIXME: need for releasing each buffer chunk? */ 547 free_all_reserved_pages(); 548 else 549 printk(KERN_ERR "snd-page-alloc: invalid proc cmd\n"); 550 return count; 551 } 552 #endif /* CONFIG_PCI */ 553 554 static const struct file_operations snd_mem_proc_fops = { 555 .owner = THIS_MODULE, 556 .open = snd_mem_proc_open, 557 .read = seq_read, 558 #ifdef CONFIG_PCI 559 .write = snd_mem_proc_write, 560 #endif 561 .llseek = seq_lseek, 562 .release = single_release, 563 }; 564 565 #endif /* CONFIG_PROC_FS */ 566 567 /* 568 * module entry 569 */ 570 571 static int __init snd_mem_init(void) 572 { 573 #ifdef CONFIG_PROC_FS 574 snd_mem_proc = proc_create(SND_MEM_PROC_FILE, 0644, NULL, 575 &snd_mem_proc_fops); 576 #endif 577 return 0; 578 } 579 580 static void __exit snd_mem_exit(void) 581 { 582 remove_proc_entry(SND_MEM_PROC_FILE, NULL); 583 free_all_reserved_pages(); 584 if (snd_allocated_pages > 0) 585 printk(KERN_ERR "snd-malloc: Memory leak? pages not freed = %li\n", snd_allocated_pages); 586 } 587 588 589 module_init(snd_mem_init) 590 module_exit(snd_mem_exit) 591 592 593 /* 594 * exports 595 */ 596 EXPORT_SYMBOL(snd_dma_alloc_pages); 597 EXPORT_SYMBOL(snd_dma_alloc_pages_fallback); 598 EXPORT_SYMBOL(snd_dma_free_pages); 599 600 EXPORT_SYMBOL(snd_dma_get_reserved_buf); 601 EXPORT_SYMBOL(snd_dma_reserve_buf); 602 603 EXPORT_SYMBOL(snd_malloc_pages); 604 EXPORT_SYMBOL(snd_free_pages); 605