[mirror_ubuntu-zesty-kernel.git] / sound / core / memalloc.c

/*
 *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
 *                   Takashi Iwai <tiwai@suse.de>
 * 
 *  Generic memory allocators
 *
 *
 *   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 <linux/slab.h>
#include <linux/mm.h>
#include <linux/dma-mapping.h>
#include <linux/genalloc.h>
#include <sound/memalloc.h>

/*
 *
 *  Generic memory allocators
 *
 */

/**
 * snd_malloc_pages - allocate pages with the given size
 * @size: the size to allocate in bytes
 * @gfp_flags: the allocation conditions, GFP_XXX
 *
 * Allocates the physically contiguous pages with the given size.
 *
 * Return: The pointer of the buffer, or %NULL if no enough memory.
 */
void *snd_malloc_pages(size_t size, gfp_t gfp_flags)
{
	int pg;

	if (WARN_ON(!size))
		return NULL;
	if (WARN_ON(!gfp_flags))
		return NULL;
	gfp_flags |= __GFP_COMP;	/* compound page lets parts be mapped */
	pg = get_order(size);
	return (void *) __get_free_pages(gfp_flags, pg);
}

/**
 * snd_free_pages - release the pages
 * @ptr: the buffer pointer to release
 * @size: the allocated buffer size
 *
 * Releases the buffer allocated via snd_malloc_pages().
 */
void snd_free_pages(void *ptr, size_t size)
{
	int pg;

	if (ptr == NULL)
		return;
	pg = get_order(size);
	free_pages((unsigned long) ptr, pg);
}

/*
 *
 *  Bus-specific memory allocators
 *
 */

#ifdef CONFIG_HAS_DMA
/* allocate the coherent DMA pages */
static void *snd_malloc_dev_pages(struct device *dev, size_t size, dma_addr_t *dma)
{
	int pg;
	gfp_t gfp_flags;

	if (WARN_ON(!dma))
		return NULL;
	pg = get_order(size);
	gfp_flags = GFP_KERNEL
		| __GFP_COMP	/* compound page lets parts be mapped */
		| __GFP_NORETRY /* don't trigger OOM-killer */
		| __GFP_NOWARN; /* no stack trace print - this call is non-critical */
	return dma_alloc_coherent(dev, PAGE_SIZE << pg, dma, gfp_flags);
}

/* free the coherent DMA pages */
static void snd_free_dev_pages(struct device *dev, size_t size, void *ptr,
			       dma_addr_t dma)
{
	int pg;

	if (ptr == NULL)
		return;
	pg = get_order(size);
	dma_free_coherent(dev, PAGE_SIZE << pg, ptr, dma);
}

#ifdef CONFIG_GENERIC_ALLOCATOR
/**
 * snd_malloc_dev_iram - allocate memory from on-chip internal ram
 * @dmab: buffer allocation record to store the allocated data
 * @size: number of bytes to allocate from the iram
 *
 * This function requires iram phandle provided via of_node
 */
static void snd_malloc_dev_iram(struct snd_dma_buffer *dmab, size_t size)
{
	struct device *dev = dmab->dev.dev;
	struct gen_pool *pool = NULL;

	dmab->area = NULL;
	dmab->addr = 0;

	if (dev->of_node)
		pool = of_get_named_gen_pool(dev->of_node, "iram", 0);

	if (!pool)
		return;

	/* Assign the pool into private_data field */
	dmab->private_data = pool;

	dmab->area = gen_pool_dma_alloc(pool, size, &dmab->addr);
}

/**
 * snd_free_dev_iram - free allocated specific memory from on-chip internal ram
 * @dmab: buffer allocation record to store the allocated data
 */
static void snd_free_dev_iram(struct snd_dma_buffer *dmab)
{
	struct gen_pool *pool = dmab->private_data;

	if (pool && dmab->area)
		gen_pool_free(pool, (unsigned long)dmab->area, dmab->bytes);
}
#endif /* CONFIG_GENERIC_ALLOCATOR */
#endif /* CONFIG_HAS_DMA */

/*
 *
 *  ALSA generic memory management
 *
 */


/**
 * snd_dma_alloc_pages - allocate the buffer area according to the given type
 * @type: the DMA buffer type
 * @device: the device pointer
 * @size: the buffer size to allocate
 * @dmab: buffer allocation record to store the allocated data
 *
 * Calls the memory-allocator function for the corresponding
 * buffer type.
 *
 * Return: Zero if the buffer with the given size is allocated successfully,
 * otherwise a negative value on error.
 */
int snd_dma_alloc_pages(int type, struct device *device, size_t size,
			struct snd_dma_buffer *dmab)
{
	if (WARN_ON(!size))
		return -ENXIO;
	if (WARN_ON(!dmab))
		return -ENXIO;

	dmab->dev.type = type;
	dmab->dev.dev = device;
	dmab->bytes = 0;
	switch (type) {
	case SNDRV_DMA_TYPE_CONTINUOUS:
		dmab->area = snd_malloc_pages(size,
					(__force gfp_t)(unsigned long)device);
		dmab->addr = 0;
		break;
#ifdef CONFIG_HAS_DMA
#ifdef CONFIG_GENERIC_ALLOCATOR
	case SNDRV_DMA_TYPE_DEV_IRAM:
		snd_malloc_dev_iram(dmab, size);
		if (dmab->area)
			break;
		/* Internal memory might have limited size and no enough space,
		 * so if we fail to malloc, try to fetch memory traditionally.
		 */
		dmab->dev.type = SNDRV_DMA_TYPE_DEV;
#endif /* CONFIG_GENERIC_ALLOCATOR */
	case SNDRV_DMA_TYPE_DEV:
		dmab->area = snd_malloc_dev_pages(device, size, &dmab->addr);
		break;
#endif
#ifdef CONFIG_SND_DMA_SGBUF
	case SNDRV_DMA_TYPE_DEV_SG:
		snd_malloc_sgbuf_pages(device, size, dmab, NULL);
		break;
#endif
	default:
		pr_err("snd-malloc: invalid device type %d\n", type);
		dmab->area = NULL;
		dmab->addr = 0;
		return -ENXIO;
	}
	if (! dmab->area)
		return -ENOMEM;
	dmab->bytes = size;
	return 0;
}

/**
 * snd_dma_alloc_pages_fallback - allocate the buffer area according to the given type with fallback
 * @type: the DMA buffer type
 * @device: the device pointer
 * @size: the buffer size to allocate
 * @dmab: buffer allocation record to store the allocated data
 *
 * Calls the memory-allocator function for the corresponding
 * buffer type.  When no space is left, this function reduces the size and
 * tries to allocate again.  The size actually allocated is stored in
 * res_size argument.
 *
 * Return: Zero if the buffer with the given size is allocated successfully,
 * otherwise a negative value on error.
 */
int snd_dma_alloc_pages_fallback(int type, struct device *device, size_t size,
				 struct snd_dma_buffer *dmab)
{
	int err;

	while ((err = snd_dma_alloc_pages(type, device, size, dmab)) < 0) {
		size_t aligned_size;
		if (err != -ENOMEM)
			return err;
		if (size <= PAGE_SIZE)
			return -ENOMEM;
		aligned_size = PAGE_SIZE << get_order(size);
		if (size != aligned_size)
			size = aligned_size;
		else
			size >>= 1;
	}
	if (! dmab->area)
		return -ENOMEM;
	return 0;
}


/**
 * snd_dma_free_pages - release the allocated buffer
 * @dmab: the buffer allocation record to release
 *
 * Releases the allocated buffer via snd_dma_alloc_pages().
 */
void snd_dma_free_pages(struct snd_dma_buffer *dmab)
{
	switch (dmab->dev.type) {
	case SNDRV_DMA_TYPE_CONTINUOUS:
		snd_free_pages(dmab->area, dmab->bytes);
		break;
#ifdef CONFIG_HAS_DMA
#ifdef CONFIG_GENERIC_ALLOCATOR
	case SNDRV_DMA_TYPE_DEV_IRAM:
		snd_free_dev_iram(dmab);
		break;
#endif /* CONFIG_GENERIC_ALLOCATOR */
	case SNDRV_DMA_TYPE_DEV:
		snd_free_dev_pages(dmab->dev.dev, dmab->bytes, dmab->area, dmab->addr);
		break;
#endif
#ifdef CONFIG_SND_DMA_SGBUF
	case SNDRV_DMA_TYPE_DEV_SG:
		snd_free_sgbuf_pages(dmab);
		break;
#endif
	default:
		pr_err("snd-malloc: invalid device type %d\n", dmab->dev.type);
	}
}

/*
 * exports
 */
EXPORT_SYMBOL(snd_dma_alloc_pages);
EXPORT_SYMBOL(snd_dma_alloc_pages_fallback);
EXPORT_SYMBOL(snd_dma_free_pages);

EXPORT_SYMBOL(snd_malloc_pages);
EXPORT_SYMBOL(snd_free_pages);
Commit	Line	Data
	1	/*
	2	* Copyright (c) by Jaroslav Kysela <perex@perex.cz>
	3	* Takashi Iwai <tiwai@suse.de>
	4	*
	5	* Generic memory allocators
	6	*
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation; either version 2 of the License, or
	11	* (at your option) any later version.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU General Public License
	19	* along with this program; if not, write to the Free Software
	20	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	21	*
	22	*/
	23
	24	#include <linux/slab.h>
	25	#include <linux/mm.h>
	26	#include <linux/dma-mapping.h>
	27	#include <linux/genalloc.h>
	28	#include <sound/memalloc.h>
	29
	30	/*
	31	*
	32	* Generic memory allocators
	33	*
	34	*/
	35
	36	/**
	37	* snd_malloc_pages - allocate pages with the given size
	38	* @size: the size to allocate in bytes
	39	* @gfp_flags: the allocation conditions, GFP_XXX
	40	*
	41	* Allocates the physically contiguous pages with the given size.
	42	*
	43	* Return: The pointer of the buffer, or %NULL if no enough memory.
	44	*/
	45	void *snd_malloc_pages(size_t size, gfp_t gfp_flags)
	46	{
	47	int pg;
	48
	49	if (WARN_ON(!size))
	50	return NULL;
	51	if (WARN_ON(!gfp_flags))
	52	return NULL;
	53	gfp_flags \|= __GFP_COMP; /* compound page lets parts be mapped */
	54	pg = get_order(size);
	55	return (void *) __get_free_pages(gfp_flags, pg);
	56	}
	57
	58	/**
	59	* snd_free_pages - release the pages
	60	* @ptr: the buffer pointer to release
	61	* @size: the allocated buffer size
	62	*
	63	* Releases the buffer allocated via snd_malloc_pages().
	64	*/
	65	void snd_free_pages(void *ptr, size_t size)
	66	{
	67	int pg;
	68
	69	if (ptr == NULL)
	70	return;
	71	pg = get_order(size);
	72	free_pages((unsigned long) ptr, pg);
	73	}
	74
	75	/*
	76	*
	77	* Bus-specific memory allocators
	78	*
	79	*/
	80
	81	#ifdef CONFIG_HAS_DMA
	82	/* allocate the coherent DMA pages */
	83	static void snd_malloc_dev_pages(struct device dev, size_t size, dma_addr_t *dma)
	84	{
	85	int pg;
	86	gfp_t gfp_flags;
	87
	88	if (WARN_ON(!dma))
	89	return NULL;
	90	pg = get_order(size);
	91	gfp_flags = GFP_KERNEL
	92	\| __GFP_COMP /* compound page lets parts be mapped */
	93	\| __GFP_NORETRY /* don't trigger OOM-killer */
	94	\| __GFP_NOWARN; /* no stack trace print - this call is non-critical */
	95	return dma_alloc_coherent(dev, PAGE_SIZE << pg, dma, gfp_flags);
	96	}
	97
	98	/* free the coherent DMA pages */
	99	static void snd_free_dev_pages(struct device dev, size_t size, void ptr,
	100	dma_addr_t dma)
	101	{
	102	int pg;
	103
	104	if (ptr == NULL)
	105	return;
	106	pg = get_order(size);
	107	dma_free_coherent(dev, PAGE_SIZE << pg, ptr, dma);
	108	}
	109
	110	#ifdef CONFIG_GENERIC_ALLOCATOR
	111	/**
	112	* snd_malloc_dev_iram - allocate memory from on-chip internal ram
	113	* @dmab: buffer allocation record to store the allocated data
	114	* @size: number of bytes to allocate from the iram
	115	*
	116	* This function requires iram phandle provided via of_node
	117	*/
	118	static void snd_malloc_dev_iram(struct snd_dma_buffer *dmab, size_t size)
	119	{
	120	struct device *dev = dmab->dev.dev;
	121	struct gen_pool *pool = NULL;
	122
	123	dmab->area = NULL;
	124	dmab->addr = 0;
	125
	126	if (dev->of_node)
	127	pool = of_get_named_gen_pool(dev->of_node, "iram", 0);
	128
	129	if (!pool)
	130	return;
	131
	132	/* Assign the pool into private_data field */
	133	dmab->private_data = pool;
	134
	135	dmab->area = gen_pool_dma_alloc(pool, size, &dmab->addr);
	136	}
	137
	138	/**
	139	* snd_free_dev_iram - free allocated specific memory from on-chip internal ram
	140	* @dmab: buffer allocation record to store the allocated data
	141	*/
	142	static void snd_free_dev_iram(struct snd_dma_buffer *dmab)
	143	{
	144	struct gen_pool *pool = dmab->private_data;
	145
	146	if (pool && dmab->area)
	147	gen_pool_free(pool, (unsigned long)dmab->area, dmab->bytes);
	148	}
	149	#endif /* CONFIG_GENERIC_ALLOCATOR */
	150	#endif /* CONFIG_HAS_DMA */
	151
	152	/*
	153	*
	154	* ALSA generic memory management
	155	*
	156	*/
	157
	158
	159	/**
	160	* snd_dma_alloc_pages - allocate the buffer area according to the given type
	161	* @type: the DMA buffer type
	162	* @device: the device pointer
	163	* @size: the buffer size to allocate
	164	* @dmab: buffer allocation record to store the allocated data
	165	*
	166	* Calls the memory-allocator function for the corresponding
	167	* buffer type.
	168	*
	169	* Return: Zero if the buffer with the given size is allocated successfully,
	170	* otherwise a negative value on error.
	171	*/
	172	int snd_dma_alloc_pages(int type, struct device *device, size_t size,
	173	struct snd_dma_buffer *dmab)
	174	{
	175	if (WARN_ON(!size))
	176	return -ENXIO;
	177	if (WARN_ON(!dmab))
	178	return -ENXIO;
	179
	180	dmab->dev.type = type;
	181	dmab->dev.dev = device;
	182	dmab->bytes = 0;
	183	switch (type) {
	184	case SNDRV_DMA_TYPE_CONTINUOUS:
	185	dmab->area = snd_malloc_pages(size,
	186	(__force gfp_t)(unsigned long)device);
	187	dmab->addr = 0;
	188	break;
	189	#ifdef CONFIG_HAS_DMA
	190	#ifdef CONFIG_GENERIC_ALLOCATOR
	191	case SNDRV_DMA_TYPE_DEV_IRAM:
	192	snd_malloc_dev_iram(dmab, size);
	193	if (dmab->area)
	194	break;
	195	/* Internal memory might have limited size and no enough space,
	196	* so if we fail to malloc, try to fetch memory traditionally.
	197	*/
	198	dmab->dev.type = SNDRV_DMA_TYPE_DEV;
	199	#endif /* CONFIG_GENERIC_ALLOCATOR */
	200	case SNDRV_DMA_TYPE_DEV:
	201	dmab->area = snd_malloc_dev_pages(device, size, &dmab->addr);
	202	break;
	203	#endif
	204	#ifdef CONFIG_SND_DMA_SGBUF
	205	case SNDRV_DMA_TYPE_DEV_SG:
	206	snd_malloc_sgbuf_pages(device, size, dmab, NULL);
	207	break;
	208	#endif
	209	default:
	210	pr_err("snd-malloc: invalid device type %d\n", type);
	211	dmab->area = NULL;
	212	dmab->addr = 0;
	213	return -ENXIO;
	214	}
	215	if (! dmab->area)
	216	return -ENOMEM;
	217	dmab->bytes = size;
	218	return 0;
	219	}
	220
	221	/**
	222	* snd_dma_alloc_pages_fallback - allocate the buffer area according to the given type with fallback
	223	* @type: the DMA buffer type
	224	* @device: the device pointer
	225	* @size: the buffer size to allocate
	226	* @dmab: buffer allocation record to store the allocated data
	227	*
	228	* Calls the memory-allocator function for the corresponding
	229	* buffer type. When no space is left, this function reduces the size and
	230	* tries to allocate again. The size actually allocated is stored in
	231	* res_size argument.
	232	*
	233	* Return: Zero if the buffer with the given size is allocated successfully,
	234	* otherwise a negative value on error.
	235	*/
	236	int snd_dma_alloc_pages_fallback(int type, struct device *device, size_t size,
	237	struct snd_dma_buffer *dmab)
	238	{
	239	int err;
	240
	241	while ((err = snd_dma_alloc_pages(type, device, size, dmab)) < 0) {
	242	size_t aligned_size;
	243	if (err != -ENOMEM)
	244	return err;
	245	if (size <= PAGE_SIZE)
	246	return -ENOMEM;
	247	aligned_size = PAGE_SIZE << get_order(size);
	248	if (size != aligned_size)
	249	size = aligned_size;
	250	else
	251	size >>= 1;
	252	}
	253	if (! dmab->area)
	254	return -ENOMEM;
	255	return 0;
	256	}
	257
	258
	259	/**
	260	* snd_dma_free_pages - release the allocated buffer
	261	* @dmab: the buffer allocation record to release
	262	*
	263	* Releases the allocated buffer via snd_dma_alloc_pages().
	264	*/
	265	void snd_dma_free_pages(struct snd_dma_buffer *dmab)
	266	{
	267	switch (dmab->dev.type) {
	268	case SNDRV_DMA_TYPE_CONTINUOUS:
	269	snd_free_pages(dmab->area, dmab->bytes);
	270	break;
	271	#ifdef CONFIG_HAS_DMA
	272	#ifdef CONFIG_GENERIC_ALLOCATOR
	273	case SNDRV_DMA_TYPE_DEV_IRAM:
	274	snd_free_dev_iram(dmab);
	275	break;
	276	#endif /* CONFIG_GENERIC_ALLOCATOR */
	277	case SNDRV_DMA_TYPE_DEV:
	278	snd_free_dev_pages(dmab->dev.dev, dmab->bytes, dmab->area, dmab->addr);
	279	break;
	280	#endif
	281	#ifdef CONFIG_SND_DMA_SGBUF
	282	case SNDRV_DMA_TYPE_DEV_SG:
	283	snd_free_sgbuf_pages(dmab);
	284	break;
	285	#endif
	286	default:
	287	pr_err("snd-malloc: invalid device type %d\n", dmab->dev.type);
	288	}
	289	}
	290
	291	/*
	292	* exports
	293	*/
	294	EXPORT_SYMBOL(snd_dma_alloc_pages);
	295	EXPORT_SYMBOL(snd_dma_alloc_pages_fallback);
	296	EXPORT_SYMBOL(snd_dma_free_pages);
	297
	298	EXPORT_SYMBOL(snd_malloc_pages);
	299	EXPORT_SYMBOL(snd_free_pages);