2 * Copyright (c) by Jaroslav Kysela <perex@suse.cz>
3 * GUS's memory allocation routines / bottom layer
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
22 #include <sound/driver.h>
23 #include <linux/slab.h>
24 #include <linux/string.h>
25 #include <sound/core.h>
26 #include <sound/gus.h>
27 #include <sound/info.h>
29 #ifdef CONFIG_SND_DEBUG
30 static void snd_gf1_mem_info_read(snd_info_entry_t
*entry
,
31 snd_info_buffer_t
* buffer
);
34 void snd_gf1_mem_lock(snd_gf1_mem_t
* alloc
, int xup
)
37 down(&alloc
->memory_mutex
);
39 up(&alloc
->memory_mutex
);
43 static snd_gf1_mem_block_t
*snd_gf1_mem_xalloc(snd_gf1_mem_t
* alloc
,
44 snd_gf1_mem_block_t
* block
)
46 snd_gf1_mem_block_t
*pblock
, *nblock
;
48 nblock
= (snd_gf1_mem_block_t
*) kmalloc(sizeof(snd_gf1_mem_block_t
), GFP_KERNEL
);
52 pblock
= alloc
->first
;
54 if (pblock
->ptr
> nblock
->ptr
) {
55 nblock
->prev
= pblock
->prev
;
56 nblock
->next
= pblock
;
57 pblock
->prev
= nblock
;
58 if (pblock
== alloc
->first
)
59 alloc
->first
= nblock
;
61 nblock
->prev
->next
= nblock
;
62 up(&alloc
->memory_mutex
);
65 pblock
= pblock
->next
;
68 if (alloc
->last
== NULL
) {
70 alloc
->first
= alloc
->last
= nblock
;
72 nblock
->prev
= alloc
->last
;
73 alloc
->last
->next
= nblock
;
79 int snd_gf1_mem_xfree(snd_gf1_mem_t
* alloc
, snd_gf1_mem_block_t
* block
)
81 if (block
->share
) { /* ok.. shared block */
83 up(&alloc
->memory_mutex
);
86 if (alloc
->first
== block
) {
87 alloc
->first
= block
->next
;
89 block
->next
->prev
= NULL
;
91 block
->prev
->next
= block
->next
;
93 block
->next
->prev
= block
->prev
;
95 if (alloc
->last
== block
) {
96 alloc
->last
= block
->prev
;
98 block
->prev
->next
= NULL
;
100 block
->next
->prev
= block
->prev
;
102 block
->prev
->next
= block
->next
;
109 static snd_gf1_mem_block_t
*snd_gf1_mem_look(snd_gf1_mem_t
* alloc
,
110 unsigned int address
)
112 snd_gf1_mem_block_t
*block
;
114 for (block
= alloc
->first
; block
; block
= block
->next
) {
115 if (block
->ptr
== address
) {
122 static snd_gf1_mem_block_t
*snd_gf1_mem_share(snd_gf1_mem_t
* alloc
,
123 unsigned int *share_id
)
125 snd_gf1_mem_block_t
*block
;
127 if (!share_id
[0] && !share_id
[1] &&
128 !share_id
[2] && !share_id
[3])
130 for (block
= alloc
->first
; block
; block
= block
->next
)
131 if (!memcmp(share_id
, block
->share_id
, sizeof(share_id
)))
136 static int snd_gf1_mem_find(snd_gf1_mem_t
* alloc
,
137 snd_gf1_mem_block_t
* block
,
138 unsigned int size
, int w_16
, int align
)
140 snd_gf1_bank_info_t
*info
= w_16
? alloc
->banks_16
: alloc
->banks_8
;
141 unsigned int idx
, boundary
;
143 snd_gf1_mem_block_t
*pblock
;
144 unsigned int ptr1
, ptr2
;
147 if (w_16
&& align
< 1)
149 block
->flags
= w_16
? SNDRV_GF1_MEM_BLOCK_16BIT
: 0;
150 block
->owner
= SNDRV_GF1_MEM_OWNER_DRIVER
;
152 block
->share_id
[0] = block
->share_id
[1] =
153 block
->share_id
[2] = block
->share_id
[3] = 0;
155 block
->prev
= block
->next
= NULL
;
156 for (pblock
= alloc
->first
, idx
= 0; pblock
; pblock
= pblock
->next
) {
157 while (pblock
->ptr
>= (boundary
= info
[idx
].address
+ info
[idx
].size
))
159 while (pblock
->ptr
+ pblock
->size
>= (boundary
= info
[idx
].address
+ info
[idx
].size
))
163 if (pblock
->ptr
+ pblock
->size
== pblock
->next
->ptr
)
165 if (pblock
->next
->ptr
< boundary
)
166 ptr2
= pblock
->next
->ptr
;
168 ptr1
= (pblock
->ptr
+ pblock
->size
+ align
) & ~align
;
172 if ((int)size
<= size1
) {
179 if (size
<= info
[idx
].size
) {
180 /* I assume that bank address is already aligned.. */
181 block
->ptr
= info
[idx
].address
;
189 snd_gf1_mem_block_t
*snd_gf1_mem_alloc(snd_gf1_mem_t
* alloc
, int owner
,
190 char *name
, int size
, int w_16
, int align
,
191 unsigned int *share_id
)
193 snd_gf1_mem_block_t block
, *nblock
;
195 snd_gf1_mem_lock(alloc
, 0);
196 if (share_id
!= NULL
) {
197 nblock
= snd_gf1_mem_share(alloc
, share_id
);
198 if (nblock
!= NULL
) {
199 if (size
!= (int)nblock
->size
) {
200 /* TODO: remove in the future */
201 snd_printk("snd_gf1_mem_alloc - share: sizes differ\n");
205 snd_gf1_mem_lock(alloc
, 1);
210 if (snd_gf1_mem_find(alloc
, &block
, size
, w_16
, align
) < 0) {
211 snd_gf1_mem_lock(alloc
, 1);
214 if (share_id
!= NULL
)
215 memcpy(&block
.share_id
, share_id
, sizeof(block
.share_id
));
217 block
.name
= kstrdup(name
, GFP_KERNEL
);
218 nblock
= snd_gf1_mem_xalloc(alloc
, &block
);
219 snd_gf1_mem_lock(alloc
, 1);
223 int snd_gf1_mem_free(snd_gf1_mem_t
* alloc
, unsigned int address
)
226 snd_gf1_mem_block_t
*block
;
228 snd_gf1_mem_lock(alloc
, 0);
229 if ((block
= snd_gf1_mem_look(alloc
, address
)) != NULL
) {
230 result
= snd_gf1_mem_xfree(alloc
, block
);
231 snd_gf1_mem_lock(alloc
, 1);
234 snd_gf1_mem_lock(alloc
, 1);
238 int snd_gf1_mem_init(snd_gus_card_t
* gus
)
240 snd_gf1_mem_t
*alloc
;
241 snd_gf1_mem_block_t block
;
242 #ifdef CONFIG_SND_DEBUG
243 snd_info_entry_t
*entry
;
246 alloc
= &gus
->gf1
.mem_alloc
;
247 init_MUTEX(&alloc
->memory_mutex
);
248 alloc
->first
= alloc
->last
= NULL
;
249 if (!gus
->gf1
.memory
)
252 memset(&block
, 0, sizeof(block
));
253 block
.owner
= SNDRV_GF1_MEM_OWNER_DRIVER
;
254 if (gus
->gf1
.enh_mode
) {
257 block
.name
= kstrdup("InterWave LFOs", GFP_KERNEL
);
258 if (snd_gf1_mem_xalloc(alloc
, &block
) == NULL
)
261 block
.ptr
= gus
->gf1
.default_voice_address
;
263 block
.name
= kstrdup("Voice default (NULL's)", GFP_KERNEL
);
264 if (snd_gf1_mem_xalloc(alloc
, &block
) == NULL
)
266 #ifdef CONFIG_SND_DEBUG
267 if (! snd_card_proc_new(gus
->card
, "gusmem", &entry
)) {
268 snd_info_set_text_ops(entry
, gus
, 1024, snd_gf1_mem_info_read
);
269 entry
->c
.text
.read_size
= 256 * 1024;
275 int snd_gf1_mem_done(snd_gus_card_t
* gus
)
277 snd_gf1_mem_t
*alloc
;
278 snd_gf1_mem_block_t
*block
, *nblock
;
280 alloc
= &gus
->gf1
.mem_alloc
;
281 block
= alloc
->first
;
283 nblock
= block
->next
;
284 snd_gf1_mem_xfree(alloc
, block
);
290 #ifdef CONFIG_SND_DEBUG
291 static void snd_gf1_mem_info_read(snd_info_entry_t
*entry
,
292 snd_info_buffer_t
* buffer
)
295 snd_gf1_mem_t
*alloc
;
296 snd_gf1_mem_block_t
*block
;
297 unsigned int total
, used
;
300 gus
= entry
->private_data
;
301 alloc
= &gus
->gf1
.mem_alloc
;
302 down(&alloc
->memory_mutex
);
303 snd_iprintf(buffer
, "8-bit banks : \n ");
304 for (i
= 0; i
< 4; i
++)
305 snd_iprintf(buffer
, "0x%06x (%04ik)%s", alloc
->banks_8
[i
].address
, alloc
->banks_8
[i
].size
>> 10, i
+ 1 < 4 ? "," : "");
306 snd_iprintf(buffer
, "\n"
307 "16-bit banks : \n ");
308 for (i
= total
= 0; i
< 4; i
++) {
309 snd_iprintf(buffer
, "0x%06x (%04ik)%s", alloc
->banks_16
[i
].address
, alloc
->banks_16
[i
].size
>> 10, i
+ 1 < 4 ? "," : "");
310 total
+= alloc
->banks_16
[i
].size
;
312 snd_iprintf(buffer
, "\n");
314 for (block
= alloc
->first
, i
= 0; block
; block
= block
->next
, i
++) {
316 snd_iprintf(buffer
, "Block %i at 0x%lx onboard 0x%x size %i (0x%x):\n", i
, (long) block
, block
->ptr
, block
->size
, block
->size
);
318 block
->share_id
[0] || block
->share_id
[1] ||
319 block
->share_id
[2] || block
->share_id
[3])
320 snd_iprintf(buffer
, " Share : %i [id0 0x%x] [id1 0x%x] [id2 0x%x] [id3 0x%x]\n",
322 block
->share_id
[0], block
->share_id
[1],
323 block
->share_id
[2], block
->share_id
[3]);
324 snd_iprintf(buffer
, " Flags :%s\n",
325 block
->flags
& SNDRV_GF1_MEM_BLOCK_16BIT
? " 16-bit" : "");
326 snd_iprintf(buffer
, " Owner : ");
327 switch (block
->owner
) {
328 case SNDRV_GF1_MEM_OWNER_DRIVER
:
329 snd_iprintf(buffer
, "driver - %s\n", block
->name
);
331 case SNDRV_GF1_MEM_OWNER_WAVE_SIMPLE
:
332 snd_iprintf(buffer
, "SIMPLE wave\n");
334 case SNDRV_GF1_MEM_OWNER_WAVE_GF1
:
335 snd_iprintf(buffer
, "GF1 wave\n");
337 case SNDRV_GF1_MEM_OWNER_WAVE_IWFFFF
:
338 snd_iprintf(buffer
, "IWFFFF wave\n");
341 snd_iprintf(buffer
, "unknown\n");
344 snd_iprintf(buffer
, " Total: memory = %i, used = %i, free = %i\n",
345 total
, used
, total
- used
);
346 up(&alloc
->memory_mutex
);
348 ultra_iprintf(buffer
, " Verify: free = %i, max 8-bit block = %i, max 16-bit block = %i\n",
349 ultra_memory_free_size(card
, &card
->gf1
.mem_alloc
),
350 ultra_memory_free_block(card
, &card
->gf1
.mem_alloc
, 0),
351 ultra_memory_free_block(card
, &card
->gf1
.mem_alloc
, 1));