/* * Copyright (c) by Jaroslav Kysela <perex@perex.cz> * Takashi Iwai <tiwai@suse.de> * * Generic memory allocators * * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * */ #include <linux/module.h>#include <linux/proc_fs.h>#include <linux/init.h>#include <linux/pci.h>#include <linux/slab.h>#include <linux/mm.h>#include <linux/seq_file.h>#include <asm/uaccess.h>#include <linux/dma-mapping.h>#include <linux/genalloc.h>#include <linux/moduleparam.h>#include <linux/mutex.h>#include <sound/memalloc.h> MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>, Jaroslav Kysela <perex@perex.cz>");MODULE_DESCRIPTION("Memory allocator for ALSA system.");MODULE_LICENSE("GPL"); /* */ static DEFINE_MUTEX(list_mutex);static LIST_HEAD(mem_list_head); /* buffer preservation list */struct snd_mem_list { struct snd_dma_buffer buffer; unsigned int id; struct list_head list;}; /* id for pre-allocated buffers */#define SNDRV_DMA_DEVICE_UNUSED (unsigned int)-1 /* * * Generic memory allocators * */ static long snd_allocated_pages; /* holding the number of allocated pages */ static inline void inc_snd_pages(int order){ snd_allocated_pages += 1 << order;} static inline void dec_snd_pages(int order){ snd_allocated_pages -= 1 << order;} /** * snd_malloc_pages - allocate pages with the given size * @size: the size to allocate in bytes * @gfp_flags: the allocation conditions, GFP_XXX * * Allocates the physically contiguous pages with the given size. * * Return: The pointer of the buffer, or %NULL if no enough memory. */void *snd_malloc_pages(size_t size, gfp_t gfp_flags){ int pg; void *res; if (WARN_ON(!size)) return NULL; if (WARN_ON(!gfp_flags)) return NULL; gfp_flags |= __GFP_COMP; /* compound page lets parts be mapped */ pg = get_order(size); if ((res = (void *) __get_free_pages(gfp_flags, pg)) != NULL) inc_snd_pages(pg); return res;} /** * snd_free_pages - release the pages * @ptr: the buffer pointer to release * @size: the allocated buffer size * * Releases the buffer allocated via snd_malloc_pages(). */void snd_free_pages(void *ptr, size_t size){ int pg; if (ptr == NULL) return; pg = get_order(size); dec_snd_pages(pg); free_pages((unsigned long) ptr, pg);} /* * * Bus-specific memory allocators * */ #ifdef CONFIG_HAS_DMA/* allocate the coherent DMA pages */static void *snd_malloc_dev_pages(struct device *dev, size_t size, dma_addr_t *dma){ int pg; void *res; gfp_t gfp_flags; if (WARN_ON(!dma)) return NULL; pg = get_order(size); gfp_flags = GFP_KERNEL | __GFP_COMP /* compound page lets parts be mapped */ | __GFP_NORETRY /* don't trigger OOM-killer */ | __GFP_NOWARN; /* no stack trace print - this call is non-critical */ res = dma_alloc_coherent(dev, PAGE_SIZE << pg, dma, gfp_flags); if (res != NULL) inc_snd_pages(pg); return res;} /* free the coherent DMA pages */static void snd_free_dev_pages(struct device *dev, size_t size, void *ptr, dma_addr_t dma){ int pg; if (ptr == NULL) return; pg = get_order(size); dec_snd_pages(pg); dma_free_coherent(dev, PAGE_SIZE << pg, ptr, dma);} #ifdef CONFIG_GENERIC_ALLOCATOR/** * snd_malloc_dev_iram - allocate memory from on-chip internal ram * @dmab: buffer allocation record to store the allocated data * @size: number of bytes to allocate from the iram * * This function requires iram phandle provided via of_node */static void snd_malloc_dev_iram(struct snd_dma_buffer *dmab, size_t size){ struct device *dev = dmab->dev.dev; struct gen_pool *pool = NULL; dmab->area = NULL; dmab->addr = 0; if (dev->of_node) pool = of_get_named_gen_pool(dev->of_node, "iram", 0); if (!pool) return; /* Assign the pool into private_data field */ dmab->private_data = pool; dmab->area = gen_pool_dma_alloc(pool, size, &dmab->addr);} /** * snd_free_dev_iram - free allocated specific memory from on-chip internal ram * @dmab: buffer allocation record to store the allocated data */static void snd_free_dev_iram(struct snd_dma_buffer *dmab){ struct gen_pool *pool = dmab->private_data; if (pool && dmab->area) gen_pool_free(pool, (unsigned long)dmab->area, dmab->bytes);}#endif /* CONFIG_GENERIC_ALLOCATOR */#endif /* CONFIG_HAS_DMA */ /* * * ALSA generic memory management * */ /** * snd_dma_alloc_pages - allocate the buffer area according to the given type * @type: the DMA buffer type * @device: the device pointer * @size: the buffer size to allocate * @dmab: buffer allocation record to store the allocated data * * Calls the memory-allocator function for the corresponding * buffer type. * * Return: Zero if the buffer with the given size is allocated successfully, * otherwise a negative value on error. */int snd_dma_alloc_pages(int type, struct device *device, size_t size, struct snd_dma_buffer *dmab){ if (WARN_ON(!size)) return -ENXIO; if (WARN_ON(!dmab)) return -ENXIO; dmab->dev.type = type; dmab->dev.dev = device; dmab->bytes = 0; switch (type) { case SNDRV_DMA_TYPE_CONTINUOUS: dmab->area = snd_malloc_pages(size, (__force gfp_t)(unsigned long)device); dmab->addr = 0; break;#ifdef CONFIG_HAS_DMA#ifdef CONFIG_GENERIC_ALLOCATOR case SNDRV_DMA_TYPE_DEV_IRAM: snd_malloc_dev_iram(dmab, size); if (dmab->area) break; /* Internal memory might have limited size and no enough space, * so if we fail to malloc, try to fetch memory traditionally. */ dmab->dev.type = SNDRV_DMA_TYPE_DEV;#endif /* CONFIG_GENERIC_ALLOCATOR */ case SNDRV_DMA_TYPE_DEV: dmab->area = snd_malloc_dev_pages(device, size, &dmab->addr); break;#endif#ifdef CONFIG_SND_DMA_SGBUF case SNDRV_DMA_TYPE_DEV_SG: snd_malloc_sgbuf_pages(device, size, dmab, NULL); break;#endif default: printk(KERN_ERR "snd-malloc: invalid device type %d\n", type); dmab->area = NULL; dmab->addr = 0; return -ENXIO; } if (! dmab->area) return -ENOMEM; dmab->bytes = size; return 0;} /** * snd_dma_alloc_pages_fallback - allocate the buffer area according to the given type with fallback * @type: the DMA buffer type * @device: the device pointer * @size: the buffer size to allocate * @dmab: buffer allocation record to store the allocated data * * Calls the memory-allocator function for the corresponding * buffer type. When no space is left, this function reduces the size and * tries to allocate again. The size actually allocated is stored in * res_size argument. * * Return: Zero if the buffer with the given size is allocated successfully, * otherwise a negative value on error. */int snd_dma_alloc_pages_fallback(int type, struct device *device, size_t size, struct snd_dma_buffer *dmab){ int err; while ((err = snd_dma_alloc_pages(type, device, size, dmab)) < 0) { size_t aligned_size; if (err != -ENOMEM) return err; if (size <= PAGE_SIZE) return -ENOMEM; aligned_size = PAGE_SIZE << get_order(size); if (size != aligned_size) size = aligned_size; else size >>= 1; } if (! dmab->area) return -ENOMEM; return 0;} /** * snd_dma_free_pages - release the allocated buffer * @dmab: the buffer allocation record to release * * Releases the allocated buffer via snd_dma_alloc_pages(). */void snd_dma_free_pages(struct snd_dma_buffer *dmab){ switch (dmab->dev.type) { case SNDRV_DMA_TYPE_CONTINUOUS: snd_free_pages(dmab->area, dmab->bytes); break;#ifdef CONFIG_HAS_DMA#ifdef CONFIG_GENERIC_ALLOCATOR case SNDRV_DMA_TYPE_DEV_IRAM: snd_free_dev_iram(dmab); break;#endif /* CONFIG_GENERIC_ALLOCATOR */ case SNDRV_DMA_TYPE_DEV: snd_free_dev_pages(dmab->dev.dev, dmab->bytes, dmab->area, dmab->addr); break;#endif#ifdef CONFIG_SND_DMA_SGBUF case SNDRV_DMA_TYPE_DEV_SG: snd_free_sgbuf_pages(dmab); break;#endif default: printk(KERN_ERR "snd-malloc: invalid device type %d\n", dmab->dev.type); }} /** * snd_dma_get_reserved - get the reserved buffer for the given device * @dmab: the buffer allocation record to store * @id: the buffer id * * Looks for the reserved-buffer list and re-uses if the same buffer * is found in the list. When the buffer is found, it's removed from the free list. * * Return: The size of buffer if the buffer is found, or zero if not found. */size_t snd_dma_get_reserved_buf(struct snd_dma_buffer *dmab, unsigned int id){ struct snd_mem_list *mem; if (WARN_ON(!dmab)) return 0; mutex_lock(&list_mutex); list_for_each_entry(mem, &mem_list_head, list) { if (mem->id == id && (mem->buffer.dev.dev == NULL || dmab->dev.dev == NULL || ! memcmp(&mem->buffer.dev, &dmab->dev, sizeof(dmab->dev)))) { struct device *dev = dmab->dev.dev; list_del(&mem->list); *dmab = mem->buffer; if (dmab->dev.dev == NULL) dmab->dev.dev = dev; kfree(mem); mutex_unlock(&list_mutex); return dmab->bytes; } } mutex_unlock(&list_mutex); return 0;} /** * snd_dma_reserve_buf - reserve the buffer * @dmab: the buffer to reserve * @id: the buffer id * * Reserves the given buffer as a reserved buffer. * * Return: Zero if successful, or a negative code on error. */int snd_dma_reserve_buf(struct snd_dma_buffer *dmab, unsigned int id){ struct snd_mem_list *mem; if (WARN_ON(!dmab)) return -EINVAL; mem = kmalloc(sizeof(*mem), GFP_KERNEL); if (! mem) return -ENOMEM; mutex_lock(&list_mutex); mem->buffer = *dmab; mem->id = id; list_add_tail(&mem->list, &mem_list_head); mutex_unlock(&list_mutex); return 0;} /* * purge all reserved buffers */static void free_all_reserved_pages(void){ struct list_head *p; struct snd_mem_list *mem; mutex_lock(&list_mutex); while (! list_empty(&mem_list_head)) { p = mem_list_head.next; mem = list_entry(p, struct snd_mem_list, list); list_del(p); snd_dma_free_pages(&mem->buffer); kfree(mem); } mutex_unlock(&list_mutex);} #ifdef CONFIG_PROC_FS/* * proc file interface */#define SND_MEM_PROC_FILE "driver/snd-page-alloc"static struct proc_dir_entry *snd_mem_proc; static int snd_mem_proc_read(struct seq_file *seq, void *offset){ long pages = snd_allocated_pages >> (PAGE_SHIFT-12); struct snd_mem_list *mem; int devno; static char *types[] = { "UNKNOWN", "CONT", "DEV", "DEV-SG" }; mutex_lock(&list_mutex); seq_printf(seq, "pages : %li bytes (%li pages per %likB)\n", pages * PAGE_SIZE, pages, PAGE_SIZE / 1024); devno = 0; list_for_each_entry(mem, &mem_list_head, list) { devno++; seq_printf(seq, "buffer %d : ID %08x : type %s\n", devno, mem->id, types[mem->buffer.dev.type]); seq_printf(seq, " addr = 0x%lx, size = %d bytes\n", (unsigned long)mem->buffer.addr, (int)mem->buffer.bytes); } mutex_unlock(&list_mutex); return 0;} static int snd_mem_proc_open(struct inode *inode, struct file *file){ return single_open(file, snd_mem_proc_read, NULL);} /* FIXME: for pci only - other bus? */#ifdef CONFIG_PCI#define gettoken(bufp) strsep(bufp, " \t\n") static ssize_t snd_mem_proc_write(struct file *file, const char __user * buffer, size_t count, loff_t * ppos){ char buf[128]; char *token, *p; if (count > sizeof(buf) - 1) return -EINVAL; if (copy_from_user(buf, buffer, count)) return -EFAULT; buf[count] = '\0'; p = buf; token = gettoken(&p); if (! token || *token == '#') return count; if (strcmp(token, "add") == 0) { char *endp; int vendor, device, size, buffers; long mask; int i, alloced; struct pci_dev *pci; if ((token = gettoken(&p)) == NULL || (vendor = simple_strtol(token, NULL, 0)) <= 0 || (token = gettoken(&p)) == NULL || (device = simple_strtol(token, NULL, 0)) <= 0 || (token = gettoken(&p)) == NULL || (mask = simple_strtol(token, NULL, 0)) < 0 || (token = gettoken(&p)) == NULL || (size = memparse(token, &endp)) < 64*1024 || size > 16*1024*1024 /* too big */ || (token = gettoken(&p)) == NULL || (buffers = simple_strtol(token, NULL, 0)) <= 0 || buffers > 4) { printk(KERN_ERR "snd-page-alloc: invalid proc write format\n");Lines 1–500 of 604. Load more
/* * Copyright (c) by Jaroslav Kysela <perex@perex.cz> * Takashi Iwai <tiwai@suse.de> * * Generic memory allocators * * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * */ #include <linux/module.h> #include <linux/proc_fs.h> #include <linux/init.h> #include <linux/pci.h> #include <linux/slab.h> #include <linux/mm.h> #include <linux/seq_file.h> #include <asm/uaccess.h> #include <linux/dma-mapping.h> #include <linux/genalloc.h> #include <linux/moduleparam.h> #include <linux/mutex.h> #include <sound/memalloc.h> MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>, Jaroslav Kysela <perex@perex.cz>"); MODULE_DESCRIPTION("Memory allocator for ALSA system."); MODULE_LICENSE("GPL"); /* */ static DEFINE_MUTEX(list_mutex); static LIST_HEAD(mem_list_head); /* buffer preservation list */ struct snd_mem_list { struct snd_dma_buffer buffer; unsigned int id; struct list_head list; }; /* id for pre-allocated buffers */ #define SNDRV_DMA_DEVICE_UNUSED (unsigned int)-1 /* * * Generic memory allocators * */ static long snd_allocated_pages; /* holding the number of allocated pages */ static inline void inc_snd_pages(int order) { snd_allocated_pages += 1 << order; } static inline void dec_snd_pages(int order) { snd_allocated_pages -= 1 << order; } /** * snd_malloc_pages - allocate pages with the given size * @size: the size to allocate in bytes * @gfp_flags: the allocation conditions, GFP_XXX * * Allocates the physically contiguous pages with the given size. * * Return: The pointer of the buffer, or %NULL if no enough memory. */ void *snd_malloc_pages(size_t size, gfp_t gfp_flags) { int pg; void *res; if (WARN_ON(!size)) return NULL; if (WARN_ON(!gfp_flags)) return NULL; gfp_flags |= __GFP_COMP; /* compound page lets parts be mapped */ pg = get_order(size); if ((res = (void *) __get_free_pages(gfp_flags, pg)) != NULL) inc_snd_pages(pg); return res; } /** * snd_free_pages - release the pages * @ptr: the buffer pointer to release * @size: the allocated buffer size * * Releases the buffer allocated via snd_malloc_pages(). */ void snd_free_pages(void *ptr, size_t size) { int pg; if (ptr == NULL) return; pg = get_order(size); dec_snd_pages(pg); free_pages((unsigned long) ptr, pg); } /* * * Bus-specific memory allocators * */ #ifdef CONFIG_HAS_DMA /* allocate the coherent DMA pages */ static void *snd_malloc_dev_pages(struct device *dev, size_t size, dma_addr_t *dma) { int pg; void *res; gfp_t gfp_flags; if (WARN_ON(!dma)) return NULL; pg = get_order(size); gfp_flags = GFP_KERNEL | __GFP_COMP /* compound page lets parts be mapped */ | __GFP_NORETRY /* don't trigger OOM-killer */ | __GFP_NOWARN; /* no stack trace print - this call is non-critical */ res = dma_alloc_coherent(dev, PAGE_SIZE << pg, dma, gfp_flags); if (res != NULL) inc_snd_pages(pg); return res; } /* free the coherent DMA pages */ static void snd_free_dev_pages(struct device *dev, size_t size, void *ptr, dma_addr_t dma) { int pg; if (ptr == NULL) return; pg = get_order(size); dec_snd_pages(pg); dma_free_coherent(dev, PAGE_SIZE << pg, ptr, dma); } #ifdef CONFIG_GENERIC_ALLOCATOR /** * snd_malloc_dev_iram - allocate memory from on-chip internal ram * @dmab: buffer allocation record to store the allocated data * @size: number of bytes to allocate from the iram * * This function requires iram phandle provided via of_node */ static void snd_malloc_dev_iram(struct snd_dma_buffer *dmab, size_t size) { struct device *dev = dmab->dev.dev; struct gen_pool *pool = NULL; dmab->area = NULL; dmab->addr = 0; if (dev->of_node) pool = of_get_named_gen_pool(dev->of_node, "iram", 0); if (!pool) return; /* Assign the pool into private_data field */ dmab->private_data = pool; dmab->area = gen_pool_dma_alloc(pool, size, &dmab->addr); } /** * snd_free_dev_iram - free allocated specific memory from on-chip internal ram * @dmab: buffer allocation record to store the allocated data */ static void snd_free_dev_iram(struct snd_dma_buffer *dmab) { struct gen_pool *pool = dmab->private_data; if (pool && dmab->area) gen_pool_free(pool, (unsigned long)dmab->area, dmab->bytes); } #endif /* CONFIG_GENERIC_ALLOCATOR */ #endif /* CONFIG_HAS_DMA */ /* * * ALSA generic memory management * */ /** * snd_dma_alloc_pages - allocate the buffer area according to the given type * @type: the DMA buffer type * @device: the device pointer * @size: the buffer size to allocate * @dmab: buffer allocation record to store the allocated data * * Calls the memory-allocator function for the corresponding * buffer type. * * Return: Zero if the buffer with the given size is allocated successfully, * otherwise a negative value on error. */ int snd_dma_alloc_pages(int type, struct device *device, size_t size, struct snd_dma_buffer *dmab) { if (WARN_ON(!size)) return -ENXIO; if (WARN_ON(!dmab)) return -ENXIO; dmab->dev.type = type; dmab->dev.dev = device; dmab->bytes = 0; switch (type) { case SNDRV_DMA_TYPE_CONTINUOUS: dmab->area = snd_malloc_pages(size, (__force gfp_t)(unsigned long)device); dmab->addr = 0; break; #ifdef CONFIG_HAS_DMA #ifdef CONFIG_GENERIC_ALLOCATOR case SNDRV_DMA_TYPE_DEV_IRAM: snd_malloc_dev_iram(dmab, size); if (dmab->area) break; /* Internal memory might have limited size and no enough space, * so if we fail to malloc, try to fetch memory traditionally. */ dmab->dev.type = SNDRV_DMA_TYPE_DEV; #endif /* CONFIG_GENERIC_ALLOCATOR */ case SNDRV_DMA_TYPE_DEV: dmab->area = snd_malloc_dev_pages(device, size, &dmab->addr); break; #endif #ifdef CONFIG_SND_DMA_SGBUF case SNDRV_DMA_TYPE_DEV_SG: snd_malloc_sgbuf_pages(device, size, dmab, NULL); break; #endif default: printk(KERN_ERR "snd-malloc: invalid device type %d\n", type); dmab->area = NULL; dmab->addr = 0; return -ENXIO; } if (! dmab->area) return -ENOMEM; dmab->bytes = size; return 0; } /** * snd_dma_alloc_pages_fallback - allocate the buffer area according to the given type with fallback * @type: the DMA buffer type * @device: the device pointer * @size: the buffer size to allocate * @dmab: buffer allocation record to store the allocated data * * Calls the memory-allocator function for the corresponding * buffer type. When no space is left, this function reduces the size and * tries to allocate again. The size actually allocated is stored in * res_size argument. * * Return: Zero if the buffer with the given size is allocated successfully, * otherwise a negative value on error. */ int snd_dma_alloc_pages_fallback(int type, struct device *device, size_t size, struct snd_dma_buffer *dmab) { int err; while ((err = snd_dma_alloc_pages(type, device, size, dmab)) < 0) { size_t aligned_size; if (err != -ENOMEM) return err; if (size <= PAGE_SIZE) return -ENOMEM; aligned_size = PAGE_SIZE << get_order(size); if (size != aligned_size) size = aligned_size; else size >>= 1; } if (! dmab->area) return -ENOMEM; return 0; } /** * snd_dma_free_pages - release the allocated buffer * @dmab: the buffer allocation record to release * * Releases the allocated buffer via snd_dma_alloc_pages(). */ void snd_dma_free_pages(struct snd_dma_buffer *dmab) { switch (dmab->dev.type) { case SNDRV_DMA_TYPE_CONTINUOUS: snd_free_pages(dmab->area, dmab->bytes); break; #ifdef CONFIG_HAS_DMA #ifdef CONFIG_GENERIC_ALLOCATOR case SNDRV_DMA_TYPE_DEV_IRAM: snd_free_dev_iram(dmab); break; #endif /* CONFIG_GENERIC_ALLOCATOR */ case SNDRV_DMA_TYPE_DEV: snd_free_dev_pages(dmab->dev.dev, dmab->bytes, dmab->area, dmab->addr); break; #endif #ifdef CONFIG_SND_DMA_SGBUF case SNDRV_DMA_TYPE_DEV_SG: snd_free_sgbuf_pages(dmab); break; #endif default: printk(KERN_ERR "snd-malloc: invalid device type %d\n", dmab->dev.type); } } /** * snd_dma_get_reserved - get the reserved buffer for the given device * @dmab: the buffer allocation record to store * @id: the buffer id * * Looks for the reserved-buffer list and re-uses if the same buffer * is found in the list. When the buffer is found, it's removed from the free list. * * Return: The size of buffer if the buffer is found, or zero if not found. */ size_t snd_dma_get_reserved_buf(struct snd_dma_buffer *dmab, unsigned int id) { struct snd_mem_list *mem; if (WARN_ON(!dmab)) return 0; mutex_lock(&list_mutex); list_for_each_entry(mem, &mem_list_head, list) { if (mem->id == id && (mem->buffer.dev.dev == NULL || dmab->dev.dev == NULL || ! memcmp(&mem->buffer.dev, &dmab->dev, sizeof(dmab->dev)))) { struct device *dev = dmab->dev.dev; list_del(&mem->list); *dmab = mem->buffer; if (dmab->dev.dev == NULL) dmab->dev.dev = dev; kfree(mem); mutex_unlock(&list_mutex); return dmab->bytes; } } mutex_unlock(&list_mutex); return 0; } /** * snd_dma_reserve_buf - reserve the buffer * @dmab: the buffer to reserve * @id: the buffer id * * Reserves the given buffer as a reserved buffer. * * Return: Zero if successful, or a negative code on error. */ int snd_dma_reserve_buf(struct snd_dma_buffer *dmab, unsigned int id) { struct snd_mem_list *mem; if (WARN_ON(!dmab)) return -EINVAL; mem = kmalloc(sizeof(*mem), GFP_KERNEL); if (! mem) return -ENOMEM; mutex_lock(&list_mutex); mem->buffer = *dmab; mem->id = id; list_add_tail(&mem->list, &mem_list_head); mutex_unlock(&list_mutex); return 0; } /* * purge all reserved buffers */ static void free_all_reserved_pages(void) { struct list_head *p; struct snd_mem_list *mem; mutex_lock(&list_mutex); while (! list_empty(&mem_list_head)) { p = mem_list_head.next; mem = list_entry(p, struct snd_mem_list, list); list_del(p); snd_dma_free_pages(&mem->buffer); kfree(mem); } mutex_unlock(&list_mutex); } #ifdef CONFIG_PROC_FS /* * proc file interface */ #define SND_MEM_PROC_FILE "driver/snd-page-alloc" static struct proc_dir_entry *snd_mem_proc; static int snd_mem_proc_read(struct seq_file *seq, void *offset) { long pages = snd_allocated_pages >> (PAGE_SHIFT-12); struct snd_mem_list *mem; int devno; static char *types[] = { "UNKNOWN", "CONT", "DEV", "DEV-SG" }; mutex_lock(&list_mutex); seq_printf(seq, "pages : %li bytes (%li pages per %likB)\n", pages * PAGE_SIZE, pages, PAGE_SIZE / 1024); devno = 0; list_for_each_entry(mem, &mem_list_head, list) { devno++; seq_printf(seq, "buffer %d : ID %08x : type %s\n", devno, mem->id, types[mem->buffer.dev.type]); seq_printf(seq, " addr = 0x%lx, size = %d bytes\n", (unsigned long)mem->buffer.addr, (int)mem->buffer.bytes); } mutex_unlock(&list_mutex); return 0; } static int snd_mem_proc_open(struct inode *inode, struct file *file) { return single_open(file, snd_mem_proc_read, NULL); } /* FIXME: for pci only - other bus? */ #ifdef CONFIG_PCI #define gettoken(bufp) strsep(bufp, " \t\n") static ssize_t snd_mem_proc_write(struct file *file, const char __user * buffer, size_t count, loff_t * ppos) { char buf[128]; char *token, *p; if (count > sizeof(buf) - 1) return -EINVAL; if (copy_from_user(buf, buffer, count)) return -EFAULT; buf[count] = '\0'; p = buf; token = gettoken(&p); if (! token || *token == '#') return count; if (strcmp(token, "add") == 0) { char *endp; int vendor, device, size, buffers; long mask; int i, alloced; struct pci_dev *pci; if ((token = gettoken(&p)) == NULL || (vendor = simple_strtol(token, NULL, 0)) <= 0 || (token = gettoken(&p)) == NULL || (device = simple_strtol(token, NULL, 0)) <= 0 || (token = gettoken(&p)) == NULL || (mask = simple_strtol(token, NULL, 0)) < 0 || (token = gettoken(&p)) == NULL || (size = memparse(token, &endp)) < 64*1024 || size > 16*1024*1024 /* too big */ || (token = gettoken(&p)) == NULL || (buffers = simple_strtol(token, NULL, 0)) <= 0 || buffers > 4) { printk(KERN_ERR "snd-page-alloc: invalid proc write format\n");