1 /* 2 * Copyright (c) by Jaroslav Kysela <perex@suse.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/config.h> 25 #include <linux/module.h> 26 #include <linux/proc_fs.h> 27 #include <linux/init.h> 28 #include <linux/pci.h> 29 #include <linux/slab.h> 30 #include <linux/mm.h> 31 #include <asm/uaccess.h> 32 #include <linux/dma-mapping.h> 33 #include <linux/moduleparam.h> 34 #include <asm/semaphore.h> 35 #include <sound/memalloc.h> 36 #ifdef CONFIG_SBUS 37 #include <asm/sbus.h> 38 #endif 39 40 41 MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>, Jaroslav Kysela <perex@suse.cz>"); 42 MODULE_DESCRIPTION("Memory allocator for ALSA system."); 43 MODULE_LICENSE("GPL"); 44 45 46 #ifndef SNDRV_CARDS 47 #define SNDRV_CARDS 8 48 #endif 49 50 /* 51 */ 52 53 void *snd_malloc_sgbuf_pages(struct device *device, 54 size_t size, struct snd_dma_buffer *dmab, 55 size_t *res_size); 56 int snd_free_sgbuf_pages(struct snd_dma_buffer *dmab); 57 58 /* 59 */ 60 61 static DECLARE_MUTEX(list_mutex); 62 static LIST_HEAD(mem_list_head); 63 64 /* buffer preservation list */ 65 struct snd_mem_list { 66 struct snd_dma_buffer buffer; 67 unsigned int id; 68 struct list_head list; 69 }; 70 71 /* id for pre-allocated buffers */ 72 #define SNDRV_DMA_DEVICE_UNUSED (unsigned int)-1 73 74 #ifdef CONFIG_SND_DEBUG 75 #define __ASTRING__(x) #x 76 #define snd_assert(expr, args...) do {\ 77 if (!(expr)) {\ 78 printk(KERN_ERR "snd-malloc: BUG? (%s) (called from %p)\n", __ASTRING__(expr), __builtin_return_address(0));\ 79 args;\ 80 }\ 81 } while (0) 82 #else 83 #define snd_assert(expr, args...) /**/ 84 #endif 85 86 /* 87 * Hacks 88 */ 89 90 #if defined(__i386__) || defined(__ppc__) || defined(__x86_64__) 91 /* 92 * A hack to allocate large buffers via dma_alloc_coherent() 93 * 94 * since dma_alloc_coherent always tries GFP_DMA when the requested 95 * pci memory region is below 32bit, it happens quite often that even 96 * 2 order of pages cannot be allocated. 97 * 98 * so in the following, we allocate at first without dma_mask, so that 99 * allocation will be done without GFP_DMA. if the area doesn't match 100 * with the requested region, then realloate with the original dma_mask 101 * again. 102 * 103 * Really, we want to move this type of thing into dma_alloc_coherent() 104 * so dma_mask doesn't have to be messed with. 105 */ 106 107 static void *snd_dma_hack_alloc_coherent(struct device *dev, size_t size, 108 dma_addr_t *dma_handle, int flags) 109 { 110 void *ret; 111 u64 dma_mask, coherent_dma_mask; 112 113 if (dev == NULL || !dev->dma_mask) 114 return dma_alloc_coherent(dev, size, dma_handle, flags); 115 dma_mask = *dev->dma_mask; 116 coherent_dma_mask = dev->coherent_dma_mask; 117 *dev->dma_mask = 0xffffffff; /* do without masking */ 118 dev->coherent_dma_mask = 0xffffffff; /* do without masking */ 119 ret = dma_alloc_coherent(dev, size, dma_handle, flags); 120 *dev->dma_mask = dma_mask; /* restore */ 121 dev->coherent_dma_mask = coherent_dma_mask; /* restore */ 122 if (ret) { 123 /* obtained address is out of range? */ 124 if (((unsigned long)*dma_handle + size - 1) & ~dma_mask) { 125 /* reallocate with the proper mask */ 126 dma_free_coherent(dev, size, ret, *dma_handle); 127 ret = dma_alloc_coherent(dev, size, dma_handle, flags); 128 } 129 } else { 130 /* wish to success now with the proper mask... */ 131 if (dma_mask != 0xffffffffUL) { 132 /* allocation with GFP_ATOMIC to avoid the long stall */ 133 flags &= ~GFP_KERNEL; 134 flags |= GFP_ATOMIC; 135 ret = dma_alloc_coherent(dev, size, dma_handle, flags); 136 } 137 } 138 return ret; 139 } 140 141 /* redefine dma_alloc_coherent for some architectures */ 142 #undef dma_alloc_coherent 143 #define dma_alloc_coherent snd_dma_hack_alloc_coherent 144 145 #endif /* arch */ 146 147 #if ! defined(__arm__) 148 #define NEED_RESERVE_PAGES 149 #endif 150 151 /* 152 * 153 * Generic memory allocators 154 * 155 */ 156 157 static long snd_allocated_pages; /* holding the number of allocated pages */ 158 159 static inline void inc_snd_pages(int order) 160 { 161 snd_allocated_pages += 1 << order; 162 } 163 164 static inline void dec_snd_pages(int order) 165 { 166 snd_allocated_pages -= 1 << order; 167 } 168 169 static void mark_pages(struct page *page, int order) 170 { 171 struct page *last_page = page + (1 << order); 172 while (page < last_page) 173 SetPageReserved(page++); 174 } 175 176 static void unmark_pages(struct page *page, int order) 177 { 178 struct page *last_page = page + (1 << order); 179 while (page < last_page) 180 ClearPageReserved(page++); 181 } 182 183 /** 184 * snd_malloc_pages - allocate pages with the given size 185 * @size: the size to allocate in bytes 186 * @gfp_flags: the allocation conditions, GFP_XXX 187 * 188 * Allocates the physically contiguous pages with the given size. 189 * 190 * Returns the pointer of the buffer, or NULL if no enoguh memory. 191 */ 192 void *snd_malloc_pages(size_t size, unsigned int gfp_flags) 193 { 194 int pg; 195 void *res; 196 197 snd_assert(size > 0, return NULL); 198 snd_assert(gfp_flags != 0, return NULL); 199 pg = get_order(size); 200 if ((res = (void *) __get_free_pages(gfp_flags, pg)) != NULL) { 201 mark_pages(virt_to_page(res), pg); 202 inc_snd_pages(pg); 203 } 204 return res; 205 } 206 207 /** 208 * snd_free_pages - release the pages 209 * @ptr: the buffer pointer to release 210 * @size: the allocated buffer size 211 * 212 * Releases the buffer allocated via snd_malloc_pages(). 213 */ 214 void snd_free_pages(void *ptr, size_t size) 215 { 216 int pg; 217 218 if (ptr == NULL) 219 return; 220 pg = get_order(size); 221 dec_snd_pages(pg); 222 unmark_pages(virt_to_page(ptr), pg); 223 free_pages((unsigned long) ptr, pg); 224 } 225 226 /* 227 * 228 * Bus-specific memory allocators 229 * 230 */ 231 232 /* allocate the coherent DMA pages */ 233 static void *snd_malloc_dev_pages(struct device *dev, size_t size, dma_addr_t *dma) 234 { 235 int pg; 236 void *res; 237 unsigned int gfp_flags; 238 239 snd_assert(size > 0, return NULL); 240 snd_assert(dma != NULL, return NULL); 241 pg = get_order(size); 242 gfp_flags = GFP_KERNEL 243 | __GFP_NORETRY /* don't trigger OOM-killer */ 244 | __GFP_NOWARN; /* no stack trace print - this call is non-critical */ 245 res = dma_alloc_coherent(dev, PAGE_SIZE << pg, dma, gfp_flags); 246 if (res != NULL) { 247 #ifdef NEED_RESERVE_PAGES 248 mark_pages(virt_to_page(res), pg); /* should be dma_to_page() */ 249 #endif 250 inc_snd_pages(pg); 251 } 252 253 return res; 254 } 255 256 /* free the coherent DMA pages */ 257 static void snd_free_dev_pages(struct device *dev, size_t size, void *ptr, 258 dma_addr_t dma) 259 { 260 int pg; 261 262 if (ptr == NULL) 263 return; 264 pg = get_order(size); 265 dec_snd_pages(pg); 266 #ifdef NEED_RESERVE_PAGES 267 unmark_pages(virt_to_page(ptr), pg); /* should be dma_to_page() */ 268 #endif 269 dma_free_coherent(dev, PAGE_SIZE << pg, ptr, dma); 270 } 271 272 #ifdef CONFIG_SBUS 273 274 static void *snd_malloc_sbus_pages(struct device *dev, size_t size, 275 dma_addr_t *dma_addr) 276 { 277 struct sbus_dev *sdev = (struct sbus_dev *)dev; 278 int pg; 279 void *res; 280 281 snd_assert(size > 0, return NULL); 282 snd_assert(dma_addr != NULL, return NULL); 283 pg = get_order(size); 284 res = sbus_alloc_consistent(sdev, PAGE_SIZE * (1 << pg), dma_addr); 285 if (res != NULL) 286 inc_snd_pages(pg); 287 return res; 288 } 289 290 static void snd_free_sbus_pages(struct device *dev, size_t size, 291 void *ptr, dma_addr_t dma_addr) 292 { 293 struct sbus_dev *sdev = (struct sbus_dev *)dev; 294 int pg; 295 296 if (ptr == NULL) 297 return; 298 pg = get_order(size); 299 dec_snd_pages(pg); 300 sbus_free_consistent(sdev, PAGE_SIZE * (1 << pg), ptr, dma_addr); 301 } 302 303 #endif /* CONFIG_SBUS */ 304 305 /* 306 * 307 * ALSA generic memory management 308 * 309 */ 310 311 312 /** 313 * snd_dma_alloc_pages - allocate the buffer area according to the given type 314 * @type: the DMA buffer type 315 * @device: the device pointer 316 * @size: the buffer size to allocate 317 * @dmab: buffer allocation record to store the allocated data 318 * 319 * Calls the memory-allocator function for the corresponding 320 * buffer type. 321 * 322 * Returns zero if the buffer with the given size is allocated successfuly, 323 * other a negative value at error. 324 */ 325 int snd_dma_alloc_pages(int type, struct device *device, size_t size, 326 struct snd_dma_buffer *dmab) 327 { 328 snd_assert(size > 0, return -ENXIO); 329 snd_assert(dmab != NULL, return -ENXIO); 330 331 dmab->dev.type = type; 332 dmab->dev.dev = device; 333 dmab->bytes = 0; 334 switch (type) { 335 case SNDRV_DMA_TYPE_CONTINUOUS: 336 dmab->area = snd_malloc_pages(size, (unsigned long)device); 337 dmab->addr = 0; 338 break; 339 #ifdef CONFIG_SBUS 340 case SNDRV_DMA_TYPE_SBUS: 341 dmab->area = snd_malloc_sbus_pages(device, size, &dmab->addr); 342 break; 343 #endif 344 case SNDRV_DMA_TYPE_DEV: 345 dmab->area = snd_malloc_dev_pages(device, size, &dmab->addr); 346 break; 347 case SNDRV_DMA_TYPE_DEV_SG: 348 snd_malloc_sgbuf_pages(device, size, dmab, NULL); 349 break; 350 default: 351 printk(KERN_ERR "snd-malloc: invalid device type %d\n", type); 352 dmab->area = NULL; 353 dmab->addr = 0; 354 return -ENXIO; 355 } 356 if (! dmab->area) 357 return -ENOMEM; 358 dmab->bytes = size; 359 return 0; 360 } 361 362 /** 363 * snd_dma_alloc_pages_fallback - allocate the buffer area according to the given type with fallback 364 * @type: the DMA buffer type 365 * @device: the device pointer 366 * @size: the buffer size to allocate 367 * @dmab: buffer allocation record to store the allocated data 368 * 369 * Calls the memory-allocator function for the corresponding 370 * buffer type. When no space is left, this function reduces the size and 371 * tries to allocate again. The size actually allocated is stored in 372 * res_size argument. 373 * 374 * Returns zero if the buffer with the given size is allocated successfuly, 375 * other a negative value at error. 376 */ 377 int snd_dma_alloc_pages_fallback(int type, struct device *device, size_t size, 378 struct snd_dma_buffer *dmab) 379 { 380 int err; 381 382 snd_assert(size > 0, return -ENXIO); 383 snd_assert(dmab != NULL, return -ENXIO); 384 385 while ((err = snd_dma_alloc_pages(type, device, size, dmab)) < 0) { 386 if (err != -ENOMEM) 387 return err; 388 size >>= 1; 389 if (size <= PAGE_SIZE) 390 return -ENOMEM; 391 } 392 if (! dmab->area) 393 return -ENOMEM; 394 return 0; 395 } 396 397 398 /** 399 * snd_dma_free_pages - release the allocated buffer 400 * @dmab: the buffer allocation record to release 401 * 402 * Releases the allocated buffer via snd_dma_alloc_pages(). 403 */ 404 void snd_dma_free_pages(struct snd_dma_buffer *dmab) 405 { 406 switch (dmab->dev.type) { 407 case SNDRV_DMA_TYPE_CONTINUOUS: 408 snd_free_pages(dmab->area, dmab->bytes); 409 break; 410 #ifdef CONFIG_SBUS 411 case SNDRV_DMA_TYPE_SBUS: 412 snd_free_sbus_pages(dmab->dev.dev, dmab->bytes, dmab->area, dmab->addr); 413 break; 414 #endif 415 case SNDRV_DMA_TYPE_DEV: 416 snd_free_dev_pages(dmab->dev.dev, dmab->bytes, dmab->area, dmab->addr); 417 break; 418 case SNDRV_DMA_TYPE_DEV_SG: 419 snd_free_sgbuf_pages(dmab); 420 break; 421 default: 422 printk(KERN_ERR "snd-malloc: invalid device type %d\n", dmab->dev.type); 423 } 424 } 425 426 427 /** 428 * snd_dma_get_reserved - get the reserved buffer for the given device 429 * @dmab: the buffer allocation record to store 430 * @id: the buffer id 431 * 432 * Looks for the reserved-buffer list and re-uses if the same buffer 433 * is found in the list. When the buffer is found, it's removed from the free list. 434 * 435 * Returns the size of buffer if the buffer is found, or zero if not found. 436 */ 437 size_t snd_dma_get_reserved_buf(struct snd_dma_buffer *dmab, unsigned int id) 438 { 439 struct list_head *p; 440 struct snd_mem_list *mem; 441 442 snd_assert(dmab, return 0); 443 444 down(&list_mutex); 445 list_for_each(p, &mem_list_head) { 446 mem = list_entry(p, struct snd_mem_list, list); 447 if (mem->id == id && 448 (mem->buffer.dev.dev == NULL || dmab->dev.dev == NULL || 449 ! memcmp(&mem->buffer.dev, &dmab->dev, sizeof(dmab->dev)))) { 450 struct device *dev = dmab->dev.dev; 451 list_del(p); 452 *dmab = mem->buffer; 453 if (dmab->dev.dev == NULL) 454 dmab->dev.dev = dev; 455 kfree(mem); 456 up(&list_mutex); 457 return dmab->bytes; 458 } 459 } 460 up(&list_mutex); 461 return 0; 462 } 463 464 /** 465 * snd_dma_reserve_buf - reserve the buffer 466 * @dmab: the buffer to reserve 467 * @id: the buffer id 468 * 469 * Reserves the given buffer as a reserved buffer. 470 * 471 * Returns zero if successful, or a negative code at error. 472 */ 473 int snd_dma_reserve_buf(struct snd_dma_buffer *dmab, unsigned int id) 474 { 475 struct snd_mem_list *mem; 476 477 snd_assert(dmab, return -EINVAL); 478 mem = kmalloc(sizeof(*mem), GFP_KERNEL); 479 if (! mem) 480 return -ENOMEM; 481 down(&list_mutex); 482 mem->buffer = *dmab; 483 mem->id = id; 484 list_add_tail(&mem->list, &mem_list_head); 485 up(&list_mutex); 486 return 0; 487 } 488 489 /* 490 * purge all reserved buffers 491 */ 492 static void free_all_reserved_pages(void) 493 { 494 struct list_head *p; 495 struct snd_mem_list *mem; 496 497 down(&list_mutex); 498 while (! list_empty(&mem_list_head)) { 499 p = mem_list_head.next; 500 mem = list_entry(p, struct snd_mem_list, list); 501 list_del(p); 502 snd_dma_free_pages(&mem->buffer); 503 kfree(mem); 504 } 505 up(&list_mutex); 506 } 507 508 509 #ifdef CONFIG_PROC_FS 510 /* 511 * proc file interface 512 */ 513 #define SND_MEM_PROC_FILE "driver/snd-page-alloc" 514 struct proc_dir_entry *snd_mem_proc; 515 516 static int snd_mem_proc_read(char *page, char **start, off_t off, 517 int count, int *eof, void *data) 518 { 519 int len = 0; 520 long pages = snd_allocated_pages >> (PAGE_SHIFT-12); 521 struct list_head *p; 522 struct snd_mem_list *mem; 523 int devno; 524 static char *types[] = { "UNKNOWN", "CONT", "DEV", "DEV-SG", "SBUS" }; 525 526 down(&list_mutex); 527 len += snprintf(page + len, count - len, 528 "pages : %li bytes (%li pages per %likB)\n", 529 pages * PAGE_SIZE, pages, PAGE_SIZE / 1024); 530 devno = 0; 531 list_for_each(p, &mem_list_head) { 532 mem = list_entry(p, struct snd_mem_list, list); 533 devno++; 534 len += snprintf(page + len, count - len, 535 "buffer %d : ID %08x : type %s\n", 536 devno, mem->id, types[mem->buffer.dev.type]); 537 len += snprintf(page + len, count - len, 538 " addr = 0x%lx, size = %d bytes\n", 539 (unsigned long)mem->buffer.addr, (int)mem->buffer.bytes); 540 } 541 up(&list_mutex); 542 return len; 543 } 544 545 /* FIXME: for pci only - other bus? */ 546 #ifdef CONFIG_PCI 547 #define gettoken(bufp) strsep(bufp, " \t\n") 548 549 static int snd_mem_proc_write(struct file *file, const char __user *buffer, 550 unsigned long count, void *data) 551 { 552 char buf[128]; 553 char *token, *p; 554 555 if (count > ARRAY_SIZE(buf) - 1) 556 count = ARRAY_SIZE(buf) - 1; 557 if (copy_from_user(buf, buffer, count)) 558 return -EFAULT; 559 buf[ARRAY_SIZE(buf) - 1] = '\0'; 560 561 p = buf; 562 token = gettoken(&p); 563 if (! token || *token == '#') 564 return (int)count; 565 if (strcmp(token, "add") == 0) { 566 char *endp; 567 int vendor, device, size, buffers; 568 long mask; 569 int i, alloced; 570 struct pci_dev *pci; 571 572 if ((token = gettoken(&p)) == NULL || 573 (vendor = simple_strtol(token, NULL, 0)) <= 0 || 574 (token = gettoken(&p)) == NULL || 575 (device = simple_strtol(token, NULL, 0)) <= 0 || 576 (token = gettoken(&p)) == NULL || 577 (mask = simple_strtol(token, NULL, 0)) < 0 || 578 (token = gettoken(&p)) == NULL || 579 (size = memparse(token, &endp)) < 64*1024 || 580 size > 16*1024*1024 /* too big */ || 581 (token = gettoken(&p)) == NULL || 582 (buffers = simple_strtol(token, NULL, 0)) <= 0 || 583 buffers > 4) { 584 printk(KERN_ERR "snd-page-alloc: invalid proc write format\n"); 585 return (int)count; 586 } 587 vendor &= 0xffff; 588 device &= 0xffff; 589 590 alloced = 0; 591 pci = NULL; 592 while ((pci = pci_find_device(vendor, device, pci)) != NULL) { 593 if (mask > 0 && mask < 0xffffffff) { 594 if (pci_set_dma_mask(pci, mask) < 0 || 595 pci_set_consistent_dma_mask(pci, mask) < 0) { 596 printk(KERN_ERR "snd-page-alloc: cannot set DMA mask %lx for pci %04x:%04x\n", mask, vendor, device); 597 return (int)count; 598 } 599 } 600 for (i = 0; i < buffers; i++) { 601 struct snd_dma_buffer dmab; 602 memset(&dmab, 0, sizeof(dmab)); 603 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci), 604 size, &dmab) < 0) { 605 printk(KERN_ERR "snd-page-alloc: cannot allocate buffer pages (size = %d)\n", size); 606 return (int)count; 607 } 608 snd_dma_reserve_buf(&dmab, snd_dma_pci_buf_id(pci)); 609 } 610 alloced++; 611 } 612 if (! alloced) { 613 for (i = 0; i < buffers; i++) { 614 struct snd_dma_buffer dmab; 615 memset(&dmab, 0, sizeof(dmab)); 616 /* FIXME: We can allocate only in ZONE_DMA 617 * without a device pointer! 618 */ 619 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, NULL, 620 size, &dmab) < 0) { 621 printk(KERN_ERR "snd-page-alloc: cannot allocate buffer pages (size = %d)\n", size); 622 break; 623 } 624 snd_dma_reserve_buf(&dmab, (unsigned int)((vendor << 16) | device)); 625 } 626 } 627 } else if (strcmp(token, "erase") == 0) 628 /* FIXME: need for releasing each buffer chunk? */ 629 free_all_reserved_pages(); 630 else 631 printk(KERN_ERR "snd-page-alloc: invalid proc cmd\n"); 632 return (int)count; 633 } 634 #endif /* CONFIG_PCI */ 635 #endif /* CONFIG_PROC_FS */ 636 637 /* 638 * module entry 639 */ 640 641 static int __init snd_mem_init(void) 642 { 643 #ifdef CONFIG_PROC_FS 644 snd_mem_proc = create_proc_entry(SND_MEM_PROC_FILE, 0644, NULL); 645 if (snd_mem_proc) { 646 snd_mem_proc->read_proc = snd_mem_proc_read; 647 #ifdef CONFIG_PCI 648 snd_mem_proc->write_proc = snd_mem_proc_write; 649 #endif 650 } 651 #endif 652 return 0; 653 } 654 655 static void __exit snd_mem_exit(void) 656 { 657 if (snd_mem_proc) 658 remove_proc_entry(SND_MEM_PROC_FILE, NULL); 659 free_all_reserved_pages(); 660 if (snd_allocated_pages > 0) 661 printk(KERN_ERR "snd-malloc: Memory leak? pages not freed = %li\n", snd_allocated_pages); 662 } 663 664 665 module_init(snd_mem_init) 666 module_exit(snd_mem_exit) 667 668 669 /* 670 * exports 671 */ 672 EXPORT_SYMBOL(snd_dma_alloc_pages); 673 EXPORT_SYMBOL(snd_dma_alloc_pages_fallback); 674 EXPORT_SYMBOL(snd_dma_free_pages); 675 676 EXPORT_SYMBOL(snd_dma_get_reserved_buf); 677 EXPORT_SYMBOL(snd_dma_reserve_buf); 678 679 EXPORT_SYMBOL(snd_malloc_pages); 680 EXPORT_SYMBOL(snd_free_pages); 681