[deliverable/linux.git] / sound / synth / util_mem.c

/*
 *  Copyright (C) 2000 Takashi Iwai <tiwai@suse.de>
 *
 *  Generic memory management routines for soundcard memory allocation
 *
 *   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 <sound/driver.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <sound/core.h>
#include <sound/util_mem.h>

MODULE_AUTHOR("Takashi Iwai");
MODULE_DESCRIPTION("Generic memory management routines for soundcard memory allocation");
MODULE_LICENSE("GPL");

#define get_memblk(p)	list_entry(p, snd_util_memblk_t, list)

/*
 * create a new memory manager
 */
snd_util_memhdr_t *
snd_util_memhdr_new(int memsize)
{
	snd_util_memhdr_t *hdr;

	hdr = kcalloc(1, sizeof(*hdr), GFP_KERNEL);
	if (hdr == NULL)
		return NULL;
	hdr->size = memsize;
	init_MUTEX(&hdr->block_mutex);
	INIT_LIST_HEAD(&hdr->block);

	return hdr;
}

/*
 * free a memory manager
 */
void snd_util_memhdr_free(snd_util_memhdr_t *hdr)
{
	struct list_head *p;

	snd_assert(hdr != NULL, return);
	/* release all blocks */
	while ((p = hdr->block.next) != &hdr->block) {
		list_del(p);
		kfree(get_memblk(p));
	}
	kfree(hdr);
}

/*
 * allocate a memory block (without mutex)
 */
snd_util_memblk_t *
__snd_util_mem_alloc(snd_util_memhdr_t *hdr, int size)
{
	snd_util_memblk_t *blk;
	snd_util_unit_t units, prev_offset;
	struct list_head *p;

	snd_assert(hdr != NULL, return NULL);
	snd_assert(size > 0, return NULL);

	/* word alignment */
	units = size;
	if (units & 1)
		units++;
	if (units > hdr->size)
		return NULL;

	/* look for empty block */
	prev_offset = 0;
	list_for_each(p, &hdr->block) {
		blk = get_memblk(p);
		if (blk->offset - prev_offset >= units)
			goto __found;
		prev_offset = blk->offset + blk->size;
	}
	if (hdr->size - prev_offset < units)
		return NULL;

__found:
	return __snd_util_memblk_new(hdr, units, p->prev);
}


/*
 * create a new memory block with the given size
 * the block is linked next to prev
 */
snd_util_memblk_t *
__snd_util_memblk_new(snd_util_memhdr_t *hdr, snd_util_unit_t units,
		      struct list_head *prev)
{
	snd_util_memblk_t *blk;

	blk = kmalloc(sizeof(snd_util_memblk_t) + hdr->block_extra_size, GFP_KERNEL);
	if (blk == NULL)
		return NULL;

	if (! prev || prev == &hdr->block)
		blk->offset = 0;
	else {
		snd_util_memblk_t *p = get_memblk(prev);
		blk->offset = p->offset + p->size;
	}
	blk->size = units;
	list_add(&blk->list, prev);
	hdr->nblocks++;
	hdr->used += units;
	return blk;
}


/*
 * allocate a memory block (with mutex)
 */
snd_util_memblk_t *
snd_util_mem_alloc(snd_util_memhdr_t *hdr, int size)
{
	snd_util_memblk_t *blk;
	down(&hdr->block_mutex);
	blk = __snd_util_mem_alloc(hdr, size);
	up(&hdr->block_mutex);
	return blk;
}


/*
 * remove the block from linked-list and free resource
 * (without mutex)
 */
void
__snd_util_mem_free(snd_util_memhdr_t *hdr, snd_util_memblk_t *blk)
{
	list_del(&blk->list);
	hdr->nblocks--;
	hdr->used -= blk->size;
	kfree(blk);
}

/*
 * free a memory block (with mutex)
 */
int snd_util_mem_free(snd_util_memhdr_t *hdr, snd_util_memblk_t *blk)
{
	snd_assert(hdr && blk, return -EINVAL);

	down(&hdr->block_mutex);
	__snd_util_mem_free(hdr, blk);
	up(&hdr->block_mutex);
	return 0;
}

/*
 * return available memory size
 */
int snd_util_mem_avail(snd_util_memhdr_t *hdr)
{
	unsigned int size;
	down(&hdr->block_mutex);
	size = hdr->size - hdr->used;
	up(&hdr->block_mutex);
	return size;
}


EXPORT_SYMBOL(snd_util_memhdr_new);
EXPORT_SYMBOL(snd_util_memhdr_free);
EXPORT_SYMBOL(snd_util_mem_alloc);
EXPORT_SYMBOL(snd_util_mem_free);
EXPORT_SYMBOL(snd_util_mem_avail);
EXPORT_SYMBOL(__snd_util_mem_alloc);
EXPORT_SYMBOL(__snd_util_mem_free);
EXPORT_SYMBOL(__snd_util_memblk_new);

/*
 *  INIT part
 */

static int __init alsa_util_mem_init(void)
{
	return 0;
}

static void __exit alsa_util_mem_exit(void)
{
}

module_init(alsa_util_mem_init)
module_exit(alsa_util_mem_exit)
Commit	Line	Data
1da177e4 LT	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 = kcalloc(1, 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)