[deliverable/linux.git] / include / linux / genalloc.h

/*
 * Basic general purpose allocator for managing special purpose
 * memory, for example, memory that is not managed by the regular
 * kmalloc/kfree interface.  Uses for this includes on-device special
 * memory, uncached memory etc.
 *
 * It is safe to use the allocator in NMI handlers and other special
 * unblockable contexts that could otherwise deadlock on locks.  This
 * is implemented by using atomic operations and retries on any
 * conflicts.  The disadvantage is that there may be livelocks in
 * extreme cases.  For better scalability, one allocator can be used
 * for each CPU.
 *
 * The lockless operation only works if there is enough memory
 * available.  If new memory is added to the pool a lock has to be
 * still taken.  So any user relying on locklessness has to ensure
 * that sufficient memory is preallocated.
 *
 * The basic atomic operation of this allocator is cmpxchg on long.
 * On architectures that don't have NMI-safe cmpxchg implementation,
 * the allocator can NOT be used in NMI handler.  So code uses the
 * allocator in NMI handler should depend on
 * CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG.
 *
 * This source code is licensed under the GNU General Public License,
 * Version 2.  See the file COPYING for more details.
 */


#ifndef __GENALLOC_H__
#define __GENALLOC_H__

struct device;
struct device_node;

/**
 * Allocation callback function type definition
 * @map: Pointer to bitmap
 * @size: The bitmap size in bits
 * @start: The bitnumber to start searching at
 * @nr: The number of zeroed bits we're looking for
 * @data: optional additional data used by @genpool_algo_t
 */
typedef unsigned long (*genpool_algo_t)(unsigned long *map,
			unsigned long size,
			unsigned long start,
			unsigned int nr,
			void *data);

/*
 *  General purpose special memory pool descriptor.
 */
struct gen_pool {
	spinlock_t lock;
	struct list_head chunks;	/* list of chunks in this pool */
	int min_alloc_order;		/* minimum allocation order */

	genpool_algo_t algo;		/* allocation function */
	void *data;
};

/*
 *  General purpose special memory pool chunk descriptor.
 */
struct gen_pool_chunk {
	struct list_head next_chunk;	/* next chunk in pool */
	atomic_t avail;
	phys_addr_t phys_addr;		/* physical starting address of memory chunk */
	unsigned long start_addr;	/* start address of memory chunk */
	unsigned long end_addr;		/* end address of memory chunk (inclusive) */
	unsigned long bits[0];		/* bitmap for allocating memory chunk */
};

extern struct gen_pool *gen_pool_create(int, int);
extern phys_addr_t gen_pool_virt_to_phys(struct gen_pool *pool, unsigned long);
extern int gen_pool_add_virt(struct gen_pool *, unsigned long, phys_addr_t,
			     size_t, int);
/**
 * gen_pool_add - add a new chunk of special memory to the pool
 * @pool: pool to add new memory chunk to
 * @addr: starting address of memory chunk to add to pool
 * @size: size in bytes of the memory chunk to add to pool
 * @nid: node id of the node the chunk structure and bitmap should be
 *       allocated on, or -1
 *
 * Add a new chunk of special memory to the specified pool.
 *
 * Returns 0 on success or a -ve errno on failure.
 */
static inline int gen_pool_add(struct gen_pool *pool, unsigned long addr,
			       size_t size, int nid)
{
	return gen_pool_add_virt(pool, addr, -1, size, nid);
}
extern void gen_pool_destroy(struct gen_pool *);
extern unsigned long gen_pool_alloc(struct gen_pool *, size_t);
extern void *gen_pool_dma_alloc(struct gen_pool *pool, size_t size,
		dma_addr_t *dma);
extern void gen_pool_free(struct gen_pool *, unsigned long, size_t);
extern void gen_pool_for_each_chunk(struct gen_pool *,
	void (*)(struct gen_pool *, struct gen_pool_chunk *, void *), void *);
extern size_t gen_pool_avail(struct gen_pool *);
extern size_t gen_pool_size(struct gen_pool *);

extern void gen_pool_set_algo(struct gen_pool *pool, genpool_algo_t algo,
		void *data);

extern unsigned long gen_pool_first_fit(unsigned long *map, unsigned long size,
		unsigned long start, unsigned int nr, void *data);

extern unsigned long gen_pool_best_fit(unsigned long *map, unsigned long size,
		unsigned long start, unsigned int nr, void *data);

extern struct gen_pool *devm_gen_pool_create(struct device *dev,
		int min_alloc_order, int nid);
extern struct gen_pool *dev_get_gen_pool(struct device *dev);

#ifdef CONFIG_OF
extern struct gen_pool *of_get_named_gen_pool(struct device_node *np,
	const char *propname, int index);
#else
static inline struct gen_pool *of_get_named_gen_pool(struct device_node *np,
	const char *propname, int index)
{
	return NULL;
}
#endif
#endif /* __GENALLOC_H__ */
Commit	Line	Data
f14f75b8	1	/*
7f184275 HY	2	* Basic general purpose allocator for managing special purpose
	3	* memory, for example, memory that is not managed by the regular
	4	* kmalloc/kfree interface. Uses for this includes on-device special
	5	* memory, uncached memory etc.
	6	*
	7	* It is safe to use the allocator in NMI handlers and other special
	8	* unblockable contexts that could otherwise deadlock on locks. This
	9	* is implemented by using atomic operations and retries on any
	10	* conflicts. The disadvantage is that there may be livelocks in
	11	* extreme cases. For better scalability, one allocator can be used
	12	* for each CPU.
	13	*
	14	* The lockless operation only works if there is enough memory
	15	* available. If new memory is added to the pool a lock has to be
	16	* still taken. So any user relying on locklessness has to ensure
	17	* that sufficient memory is preallocated.
	18	*
	19	* The basic atomic operation of this allocator is cmpxchg on long.
	20	* On architectures that don't have NMI-safe cmpxchg implementation,
	21	* the allocator can NOT be used in NMI handler. So code uses the
	22	* allocator in NMI handler should depend on
	23	* CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG.
f14f75b8	24	*
f14f75b8 JS	25	* This source code is licensed under the GNU General Public License,
	26	* Version 2. See the file COPYING for more details.
	27	*/
	28
f14f75b8	29
6aae6e03 JCPV	30	#ifndef __GENALLOC_H__
6aae6e03 JCPV	31	#define __GENALLOC_H__
9375db07 PZ	32
	33	struct device;
	34	struct device_node;
	35
ca279cf1 BG	36	/**
	37	* Allocation callback function type definition
	38	* @map: Pointer to bitmap
	39	* @size: The bitmap size in bits
	40	* @start: The bitnumber to start searching at
	41	* @nr: The number of zeroed bits we're looking for
	42	* @data: optional additional data used by @genpool_algo_t
	43	*/
	44	typedef unsigned long (genpool_algo_t)(unsigned long map,
	45	unsigned long size,
	46	unsigned long start,
	47	unsigned int nr,
	48	void *data);
	49
f14f75b8	50	/*
929f9727	51	* General purpose special memory pool descriptor.
f14f75b8	52	*/
929f9727	53	struct gen_pool {
7f184275	54	spinlock_t lock;
929f9727 DN	55	struct list_head chunks; /* list of chunks in this pool */
929f9727 DN	56	int min_alloc_order; /* minimum allocation order */
ca279cf1 BG	57
	58	genpool_algo_t algo; /* allocation function */
	59	void *data;
f14f75b8 JS	60	};
	61
	62	/*
929f9727	63	* General purpose special memory pool chunk descriptor.
f14f75b8	64	*/
929f9727	65	struct gen_pool_chunk {
929f9727	66	struct list_head next_chunk; /* next chunk in pool */
7f184275	67	atomic_t avail;
3c8f370d	68	phys_addr_t phys_addr; /* physical starting address of memory chunk */
674470d9 JS	69	unsigned long start_addr; /* start address of memory chunk */
674470d9 JS	70	unsigned long end_addr; /* end address of memory chunk (inclusive) */
929f9727	71	unsigned long bits[0]; /* bitmap for allocating memory chunk */
f14f75b8 JS	72	};
f14f75b8 JS	73
929f9727	74	extern struct gen_pool *gen_pool_create(int, int);
3c8f370d JCPV	75	extern phys_addr_t gen_pool_virt_to_phys(struct gen_pool *pool, unsigned long);
	76	extern int gen_pool_add_virt(struct gen_pool *, unsigned long, phys_addr_t,
	77	size_t, int);
	78	/**
	79	* gen_pool_add - add a new chunk of special memory to the pool
	80	* @pool: pool to add new memory chunk to
	81	* @addr: starting address of memory chunk to add to pool
	82	* @size: size in bytes of the memory chunk to add to pool
	83	* @nid: node id of the node the chunk structure and bitmap should be
	84	* allocated on, or -1
	85	*
	86	* Add a new chunk of special memory to the specified pool.
	87	*
	88	* Returns 0 on success or a -ve errno on failure.
	89	*/
	90	static inline int gen_pool_add(struct gen_pool *pool, unsigned long addr,
	91	size_t size, int nid)
	92	{
	93	return gen_pool_add_virt(pool, addr, -1, size, nid);
	94	}
322acc96	95	extern void gen_pool_destroy(struct gen_pool *);
929f9727	96	extern unsigned long gen_pool_alloc(struct gen_pool *, size_t);
684f0d3d NC	97	extern void gen_pool_dma_alloc(struct gen_pool pool, size_t size,
684f0d3d NC	98	dma_addr_t *dma);
929f9727	99	extern void gen_pool_free(struct gen_pool *, unsigned long, size_t);
7f184275 HY	100	extern void gen_pool_for_each_chunk(struct gen_pool *,
	101	void ()(struct gen_pool , struct gen_pool_chunk , void ), void *);
	102	extern size_t gen_pool_avail(struct gen_pool *);
	103	extern size_t gen_pool_size(struct gen_pool *);
ca279cf1 BG	104
	105	extern void gen_pool_set_algo(struct gen_pool *pool, genpool_algo_t algo,
	106	void *data);
	107
	108	extern unsigned long gen_pool_first_fit(unsigned long *map, unsigned long size,
	109	unsigned long start, unsigned int nr, void *data);
	110
	111	extern unsigned long gen_pool_best_fit(unsigned long *map, unsigned long size,
	112	unsigned long start, unsigned int nr, void *data);
	113
9375db07 PZ	114	extern struct gen_pool devm_gen_pool_create(struct device dev,
	115	int min_alloc_order, int nid);
	116	extern struct gen_pool dev_get_gen_pool(struct device dev);
	117
	118	#ifdef CONFIG_OF
	119	extern struct gen_pool of_get_named_gen_pool(struct device_node np,
	120	const char *propname, int index);
	121	#else
	122	static inline struct gen_pool of_get_named_gen_pool(struct device_node np,
	123	const char *propname, int index)
	124	{
	125	return NULL;
	126	}
	127	#endif
6aae6e03	128	#endif /* __GENALLOC_H__ */