blob: 6fc3d2b2519f935c76f1156962d4bae4cd0a6750 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Copyright (C) 2000 Takashi Iwai <tiwai@suse.de>
3 *
4 * Generic memory management routines for soundcard memory allocation
5 *
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.
10 *
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.
15 *
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
19 */
20
Ingo Molnaref9f0a42006-01-16 16:31:42 +010021#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <sound/driver.h>
23#include <linux/init.h>
24#include <linux/slab.h>
25#include <sound/core.h>
26#include <sound/util_mem.h>
27
28MODULE_AUTHOR("Takashi Iwai");
29MODULE_DESCRIPTION("Generic memory management routines for soundcard memory allocation");
30MODULE_LICENSE("GPL");
31
Takashi Iwai03da3122005-11-17 14:24:47 +010032#define get_memblk(p) list_entry(p, struct snd_util_memblk, list)
Linus Torvalds1da177e2005-04-16 15:20:36 -070033
34/*
35 * create a new memory manager
36 */
Takashi Iwai03da3122005-11-17 14:24:47 +010037struct snd_util_memhdr *
Linus Torvalds1da177e2005-04-16 15:20:36 -070038snd_util_memhdr_new(int memsize)
39{
Takashi Iwai03da3122005-11-17 14:24:47 +010040 struct snd_util_memhdr *hdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
Takashi Iwai561b2202005-09-09 14:22:34 +020042 hdr = kzalloc(sizeof(*hdr), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -070043 if (hdr == NULL)
44 return NULL;
45 hdr->size = memsize;
Ingo Molnaref9f0a42006-01-16 16:31:42 +010046 mutex_init(&hdr->block_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070047 INIT_LIST_HEAD(&hdr->block);
48
49 return hdr;
50}
51
52/*
53 * free a memory manager
54 */
Takashi Iwai03da3122005-11-17 14:24:47 +010055void snd_util_memhdr_free(struct snd_util_memhdr *hdr)
Linus Torvalds1da177e2005-04-16 15:20:36 -070056{
57 struct list_head *p;
58
59 snd_assert(hdr != NULL, return);
60 /* release all blocks */
61 while ((p = hdr->block.next) != &hdr->block) {
62 list_del(p);
63 kfree(get_memblk(p));
64 }
65 kfree(hdr);
66}
67
68/*
69 * allocate a memory block (without mutex)
70 */
Takashi Iwai03da3122005-11-17 14:24:47 +010071struct snd_util_memblk *
72__snd_util_mem_alloc(struct snd_util_memhdr *hdr, int size)
Linus Torvalds1da177e2005-04-16 15:20:36 -070073{
Takashi Iwai03da3122005-11-17 14:24:47 +010074 struct snd_util_memblk *blk;
75 unsigned int units, prev_offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -070076 struct list_head *p;
77
78 snd_assert(hdr != NULL, return NULL);
79 snd_assert(size > 0, return NULL);
80
81 /* word alignment */
82 units = size;
83 if (units & 1)
84 units++;
85 if (units > hdr->size)
86 return NULL;
87
88 /* look for empty block */
89 prev_offset = 0;
90 list_for_each(p, &hdr->block) {
91 blk = get_memblk(p);
92 if (blk->offset - prev_offset >= units)
93 goto __found;
94 prev_offset = blk->offset + blk->size;
95 }
96 if (hdr->size - prev_offset < units)
97 return NULL;
98
99__found:
100 return __snd_util_memblk_new(hdr, units, p->prev);
101}
102
103
104/*
105 * create a new memory block with the given size
106 * the block is linked next to prev
107 */
Takashi Iwai03da3122005-11-17 14:24:47 +0100108struct snd_util_memblk *
109__snd_util_memblk_new(struct snd_util_memhdr *hdr, unsigned int units,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 struct list_head *prev)
111{
Takashi Iwai03da3122005-11-17 14:24:47 +0100112 struct snd_util_memblk *blk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113
Takashi Iwai03da3122005-11-17 14:24:47 +0100114 blk = kmalloc(sizeof(struct snd_util_memblk) + hdr->block_extra_size,
115 GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 if (blk == NULL)
117 return NULL;
118
Adrian Bunk8e6c9622007-07-30 15:40:43 +0200119 if (prev == &hdr->block)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 blk->offset = 0;
121 else {
Takashi Iwai03da3122005-11-17 14:24:47 +0100122 struct snd_util_memblk *p = get_memblk(prev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 blk->offset = p->offset + p->size;
124 }
125 blk->size = units;
126 list_add(&blk->list, prev);
127 hdr->nblocks++;
128 hdr->used += units;
129 return blk;
130}
131
132
133/*
134 * allocate a memory block (with mutex)
135 */
Takashi Iwai03da3122005-11-17 14:24:47 +0100136struct snd_util_memblk *
137snd_util_mem_alloc(struct snd_util_memhdr *hdr, int size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138{
Takashi Iwai03da3122005-11-17 14:24:47 +0100139 struct snd_util_memblk *blk;
Ingo Molnaref9f0a42006-01-16 16:31:42 +0100140 mutex_lock(&hdr->block_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 blk = __snd_util_mem_alloc(hdr, size);
Ingo Molnaref9f0a42006-01-16 16:31:42 +0100142 mutex_unlock(&hdr->block_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 return blk;
144}
145
146
147/*
148 * remove the block from linked-list and free resource
149 * (without mutex)
150 */
151void
Takashi Iwai03da3122005-11-17 14:24:47 +0100152__snd_util_mem_free(struct snd_util_memhdr *hdr, struct snd_util_memblk *blk)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153{
154 list_del(&blk->list);
155 hdr->nblocks--;
156 hdr->used -= blk->size;
157 kfree(blk);
158}
159
160/*
161 * free a memory block (with mutex)
162 */
Takashi Iwai03da3122005-11-17 14:24:47 +0100163int snd_util_mem_free(struct snd_util_memhdr *hdr, struct snd_util_memblk *blk)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164{
165 snd_assert(hdr && blk, return -EINVAL);
166
Ingo Molnaref9f0a42006-01-16 16:31:42 +0100167 mutex_lock(&hdr->block_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168 __snd_util_mem_free(hdr, blk);
Ingo Molnaref9f0a42006-01-16 16:31:42 +0100169 mutex_unlock(&hdr->block_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170 return 0;
171}
172
173/*
174 * return available memory size
175 */
Takashi Iwai03da3122005-11-17 14:24:47 +0100176int snd_util_mem_avail(struct snd_util_memhdr *hdr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177{
178 unsigned int size;
Ingo Molnaref9f0a42006-01-16 16:31:42 +0100179 mutex_lock(&hdr->block_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 size = hdr->size - hdr->used;
Ingo Molnaref9f0a42006-01-16 16:31:42 +0100181 mutex_unlock(&hdr->block_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 return size;
183}
184
185
186EXPORT_SYMBOL(snd_util_memhdr_new);
187EXPORT_SYMBOL(snd_util_memhdr_free);
188EXPORT_SYMBOL(snd_util_mem_alloc);
189EXPORT_SYMBOL(snd_util_mem_free);
190EXPORT_SYMBOL(snd_util_mem_avail);
191EXPORT_SYMBOL(__snd_util_mem_alloc);
192EXPORT_SYMBOL(__snd_util_mem_free);
193EXPORT_SYMBOL(__snd_util_memblk_new);
194
195/*
196 * INIT part
197 */
198
199static int __init alsa_util_mem_init(void)
200{
201 return 0;
202}
203
204static void __exit alsa_util_mem_exit(void)
205{
206}
207
208module_init(alsa_util_mem_init)
209module_exit(alsa_util_mem_exit)