2 * Copyright (C) 2000 Takashi Iwai <tiwai@suse.de>
4 * Generic memory management routines for soundcard memory allocation
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 #include <sound/driver.h>
22 #include <linux/init.h>
23 #include <linux/slab.h>
24 #include <sound/core.h>
25 #include <sound/util_mem.h>
27 MODULE_AUTHOR("Takashi Iwai");
28 MODULE_DESCRIPTION("Generic memory management routines for soundcard memory allocation");
29 MODULE_LICENSE("GPL");
31 #define get_memblk(p) list_entry(p, snd_util_memblk_t, list)
34 * create a new memory manager
37 snd_util_memhdr_new(int memsize)
39 snd_util_memhdr_t *hdr;
41 hdr = kzalloc(sizeof(*hdr), GFP_KERNEL);
45 init_MUTEX(&hdr->block_mutex);
46 INIT_LIST_HEAD(&hdr->block);
52 * free a memory manager
54 void snd_util_memhdr_free(snd_util_memhdr_t *hdr)
58 snd_assert(hdr != NULL, return);
59 /* release all blocks */
60 while ((p = hdr->block.next) != &hdr->block) {
68 * allocate a memory block (without mutex)
71 __snd_util_mem_alloc(snd_util_memhdr_t *hdr, int size)
73 snd_util_memblk_t *blk;
74 snd_util_unit_t units, prev_offset;
77 snd_assert(hdr != NULL, return NULL);
78 snd_assert(size > 0, return NULL);
84 if (units > hdr->size)
87 /* look for empty block */
89 list_for_each(p, &hdr->block) {
91 if (blk->offset - prev_offset >= units)
93 prev_offset = blk->offset + blk->size;
95 if (hdr->size - prev_offset < units)
99 return __snd_util_memblk_new(hdr, units, p->prev);
104 * create a new memory block with the given size
105 * the block is linked next to prev
108 __snd_util_memblk_new(snd_util_memhdr_t *hdr, snd_util_unit_t units,
109 struct list_head *prev)
111 snd_util_memblk_t *blk;
113 blk = kmalloc(sizeof(snd_util_memblk_t) + hdr->block_extra_size, GFP_KERNEL);
117 if (! prev || prev == &hdr->block)
120 snd_util_memblk_t *p = get_memblk(prev);
121 blk->offset = p->offset + p->size;
124 list_add(&blk->list, prev);
132 * allocate a memory block (with mutex)
135 snd_util_mem_alloc(snd_util_memhdr_t *hdr, int size)
137 snd_util_memblk_t *blk;
138 down(&hdr->block_mutex);
139 blk = __snd_util_mem_alloc(hdr, size);
140 up(&hdr->block_mutex);
146 * remove the block from linked-list and free resource
150 __snd_util_mem_free(snd_util_memhdr_t *hdr, snd_util_memblk_t *blk)
152 list_del(&blk->list);
154 hdr->used -= blk->size;
159 * free a memory block (with mutex)
161 int snd_util_mem_free(snd_util_memhdr_t *hdr, snd_util_memblk_t *blk)
163 snd_assert(hdr && blk, return -EINVAL);
165 down(&hdr->block_mutex);
166 __snd_util_mem_free(hdr, blk);
167 up(&hdr->block_mutex);
172 * return available memory size
174 int snd_util_mem_avail(snd_util_memhdr_t *hdr)
177 down(&hdr->block_mutex);
178 size = hdr->size - hdr->used;
179 up(&hdr->block_mutex);
184 EXPORT_SYMBOL(snd_util_memhdr_new);
185 EXPORT_SYMBOL(snd_util_memhdr_free);
186 EXPORT_SYMBOL(snd_util_mem_alloc);
187 EXPORT_SYMBOL(snd_util_mem_free);
188 EXPORT_SYMBOL(snd_util_mem_avail);
189 EXPORT_SYMBOL(__snd_util_mem_alloc);
190 EXPORT_SYMBOL(__snd_util_mem_free);
191 EXPORT_SYMBOL(__snd_util_memblk_new);
197 static int __init alsa_util_mem_init(void)
202 static void __exit alsa_util_mem_exit(void)
206 module_init(alsa_util_mem_init)
207 module_exit(alsa_util_mem_exit)