[ALSA] Replace with kzalloc() - others
[linux-2.6.git] / sound / synth / util_mem.c
1 /*
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
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>
26
27 MODULE_AUTHOR("Takashi Iwai");
28 MODULE_DESCRIPTION("Generic memory management routines for soundcard memory allocation");
29 MODULE_LICENSE("GPL");
30
31 #define get_memblk(p)   list_entry(p, snd_util_memblk_t, list)
32
33 /*
34  * create a new memory manager
35  */
36 snd_util_memhdr_t *
37 snd_util_memhdr_new(int memsize)
38 {
39         snd_util_memhdr_t *hdr;
40
41         hdr = kzalloc(sizeof(*hdr), GFP_KERNEL);
42         if (hdr == NULL)
43                 return NULL;
44         hdr->size = memsize;
45         init_MUTEX(&hdr->block_mutex);
46         INIT_LIST_HEAD(&hdr->block);
47
48         return hdr;
49 }
50
51 /*
52  * free a memory manager
53  */
54 void snd_util_memhdr_free(snd_util_memhdr_t *hdr)
55 {
56         struct list_head *p;
57
58         snd_assert(hdr != NULL, return);
59         /* release all blocks */
60         while ((p = hdr->block.next) != &hdr->block) {
61                 list_del(p);
62                 kfree(get_memblk(p));
63         }
64         kfree(hdr);
65 }
66
67 /*
68  * allocate a memory block (without mutex)
69  */
70 snd_util_memblk_t *
71 __snd_util_mem_alloc(snd_util_memhdr_t *hdr, int size)
72 {
73         snd_util_memblk_t *blk;
74         snd_util_unit_t units, prev_offset;
75         struct list_head *p;
76
77         snd_assert(hdr != NULL, return NULL);
78         snd_assert(size > 0, return NULL);
79
80         /* word alignment */
81         units = size;
82         if (units & 1)
83                 units++;
84         if (units > hdr->size)
85                 return NULL;
86
87         /* look for empty block */
88         prev_offset = 0;
89         list_for_each(p, &hdr->block) {
90                 blk = get_memblk(p);
91                 if (blk->offset - prev_offset >= units)
92                         goto __found;
93                 prev_offset = blk->offset + blk->size;
94         }
95         if (hdr->size - prev_offset < units)
96                 return NULL;
97
98 __found:
99         return __snd_util_memblk_new(hdr, units, p->prev);
100 }
101
102
103 /*
104  * create a new memory block with the given size
105  * the block is linked next to prev
106  */
107 snd_util_memblk_t *
108 __snd_util_memblk_new(snd_util_memhdr_t *hdr, snd_util_unit_t units,
109                       struct list_head *prev)
110 {
111         snd_util_memblk_t *blk;
112
113         blk = kmalloc(sizeof(snd_util_memblk_t) + hdr->block_extra_size, GFP_KERNEL);
114         if (blk == NULL)
115                 return NULL;
116
117         if (! prev || prev == &hdr->block)
118                 blk->offset = 0;
119         else {
120                 snd_util_memblk_t *p = get_memblk(prev);
121                 blk->offset = p->offset + p->size;
122         }
123         blk->size = units;
124         list_add(&blk->list, prev);
125         hdr->nblocks++;
126         hdr->used += units;
127         return blk;
128 }
129
130
131 /*
132  * allocate a memory block (with mutex)
133  */
134 snd_util_memblk_t *
135 snd_util_mem_alloc(snd_util_memhdr_t *hdr, int size)
136 {
137         snd_util_memblk_t *blk;
138         down(&hdr->block_mutex);
139         blk = __snd_util_mem_alloc(hdr, size);
140         up(&hdr->block_mutex);
141         return blk;
142 }
143
144
145 /*
146  * remove the block from linked-list and free resource
147  * (without mutex)
148  */
149 void
150 __snd_util_mem_free(snd_util_memhdr_t *hdr, snd_util_memblk_t *blk)
151 {
152         list_del(&blk->list);
153         hdr->nblocks--;
154         hdr->used -= blk->size;
155         kfree(blk);
156 }
157
158 /*
159  * free a memory block (with mutex)
160  */
161 int snd_util_mem_free(snd_util_memhdr_t *hdr, snd_util_memblk_t *blk)
162 {
163         snd_assert(hdr && blk, return -EINVAL);
164
165         down(&hdr->block_mutex);
166         __snd_util_mem_free(hdr, blk);
167         up(&hdr->block_mutex);
168         return 0;
169 }
170
171 /*
172  * return available memory size
173  */
174 int snd_util_mem_avail(snd_util_memhdr_t *hdr)
175 {
176         unsigned int size;
177         down(&hdr->block_mutex);
178         size = hdr->size - hdr->used;
179         up(&hdr->block_mutex);
180         return size;
181 }
182
183
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);
192
193 /*
194  *  INIT part
195  */
196
197 static int __init alsa_util_mem_init(void)
198 {
199         return 0;
200 }
201
202 static void __exit alsa_util_mem_exit(void)
203 {
204 }
205
206 module_init(alsa_util_mem_init)
207 module_exit(alsa_util_mem_exit)