[deliverable/linux.git] / include / drm / drm_mm.h

/**************************************************************************
 *
 * Copyright 2006-2008 Tungsten Graphics, Inc., Cedar Park, TX. USA.
 * All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sub license, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice (including the
 * next paragraph) shall be included in all copies or substantial portions
 * of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
 * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 * USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 *
 **************************************************************************/
/*
 * Authors:
 * Thomas Hellstrom <thomas-at-tungstengraphics-dot-com>
 */

#ifndef _DRM_MM_H_
#define _DRM_MM_H_

/*
 * Generic range manager structs
 */
#include <linux/bug.h>
#include <linux/kernel.h>
#include <linux/list.h>
#include <linux/spinlock.h>
#ifdef CONFIG_DEBUG_FS
#include <linux/seq_file.h>
#endif

enum drm_mm_search_flags {
	DRM_MM_SEARCH_DEFAULT =		0,
	DRM_MM_SEARCH_BEST =		1 << 0,
};

struct drm_mm_node {
	struct list_head node_list;
	struct list_head hole_stack;
	unsigned hole_follows : 1;
	unsigned scanned_block : 1;
	unsigned scanned_prev_free : 1;
	unsigned scanned_next_free : 1;
	unsigned scanned_preceeds_hole : 1;
	unsigned allocated : 1;
	unsigned long color;
	unsigned long start;
	unsigned long size;
	struct drm_mm *mm;
};

struct drm_mm {
	/* List of all memory nodes that immediately precede a free hole. */
	struct list_head hole_stack;
	/* head_node.node_list is the list of all memory nodes, ordered
	 * according to the (increasing) start address of the memory node. */
	struct drm_mm_node head_node;
	unsigned int scan_check_range : 1;
	unsigned scan_alignment;
	unsigned long scan_color;
	unsigned long scan_size;
	unsigned long scan_hit_start;
	unsigned long scan_hit_end;
	unsigned scanned_blocks;
	unsigned long scan_start;
	unsigned long scan_end;
	struct drm_mm_node *prev_scanned_node;

	void (*color_adjust)(struct drm_mm_node *node, unsigned long color,
			     unsigned long *start, unsigned long *end);
};

static inline bool drm_mm_node_allocated(struct drm_mm_node *node)
{
	return node->allocated;
}

static inline bool drm_mm_initialized(struct drm_mm *mm)
{
	return mm->hole_stack.next;
}

static inline unsigned long __drm_mm_hole_node_start(struct drm_mm_node *hole_node)
{
	return hole_node->start + hole_node->size;
}

static inline unsigned long drm_mm_hole_node_start(struct drm_mm_node *hole_node)
{
	BUG_ON(!hole_node->hole_follows);
	return __drm_mm_hole_node_start(hole_node);
}

static inline unsigned long __drm_mm_hole_node_end(struct drm_mm_node *hole_node)
{
	return list_entry(hole_node->node_list.next,
			  struct drm_mm_node, node_list)->start;
}

static inline unsigned long drm_mm_hole_node_end(struct drm_mm_node *hole_node)
{
	return __drm_mm_hole_node_end(hole_node);
}

#define drm_mm_for_each_node(entry, mm) list_for_each_entry(entry, \
						&(mm)->head_node.node_list, \
						node_list)

/* Note that we need to unroll list_for_each_entry in order to inline
 * setting hole_start and hole_end on each iteration and keep the
 * macro sane.
 */
#define drm_mm_for_each_hole(entry, mm, hole_start, hole_end) \
	for (entry = list_entry((mm)->hole_stack.next, struct drm_mm_node, hole_stack); \
	     &entry->hole_stack != &(mm)->hole_stack ? \
	     hole_start = drm_mm_hole_node_start(entry), \
	     hole_end = drm_mm_hole_node_end(entry), \
	     1 : 0; \
	     entry = list_entry(entry->hole_stack.next, struct drm_mm_node, hole_stack))

/*
 * Basic range manager support (drm_mm.c)
 */
extern int drm_mm_reserve_node(struct drm_mm *mm, struct drm_mm_node *node);

extern int drm_mm_insert_node_generic(struct drm_mm *mm,
				      struct drm_mm_node *node,
				      unsigned long size,
				      unsigned alignment,
				      unsigned long color,
				      enum drm_mm_search_flags flags);
static inline int drm_mm_insert_node(struct drm_mm *mm,
				     struct drm_mm_node *node,
				     unsigned long size,
				     unsigned alignment,
				     enum drm_mm_search_flags flags)
{
	return drm_mm_insert_node_generic(mm, node, size, alignment, 0, flags);
}

extern int drm_mm_insert_node_in_range_generic(struct drm_mm *mm,
				       struct drm_mm_node *node,
				       unsigned long size,
				       unsigned alignment,
				       unsigned long color,
				       unsigned long start,
				       unsigned long end,
				       enum drm_mm_search_flags flags);
static inline int drm_mm_insert_node_in_range(struct drm_mm *mm,
					      struct drm_mm_node *node,
					      unsigned long size,
					      unsigned alignment,
					      unsigned long start,
					      unsigned long end,
					      enum drm_mm_search_flags flags)
{
	return drm_mm_insert_node_in_range_generic(mm, node, size, alignment,
						   0, start, end, flags);
}

extern void drm_mm_remove_node(struct drm_mm_node *node);
extern void drm_mm_replace_node(struct drm_mm_node *old, struct drm_mm_node *new);
extern void drm_mm_init(struct drm_mm *mm,
			unsigned long start,
			unsigned long size);
extern void drm_mm_takedown(struct drm_mm *mm);
extern int drm_mm_clean(struct drm_mm *mm);

void drm_mm_init_scan(struct drm_mm *mm,
		      unsigned long size,
		      unsigned alignment,
		      unsigned long color);
void drm_mm_init_scan_with_range(struct drm_mm *mm,
				 unsigned long size,
				 unsigned alignment,
				 unsigned long color,
				 unsigned long start,
				 unsigned long end);
int drm_mm_scan_add_block(struct drm_mm_node *node);
int drm_mm_scan_remove_block(struct drm_mm_node *node);

extern void drm_mm_debug_table(struct drm_mm *mm, const char *prefix);
#ifdef CONFIG_DEBUG_FS
int drm_mm_dump_table(struct seq_file *m, struct drm_mm *mm);
#endif

#endif
Commit	Line	Data
249d6048 JG	1	/**************************************************************************
	2	*
	3	* Copyright 2006-2008 Tungsten Graphics, Inc., Cedar Park, TX. USA.
	4	* All Rights Reserved.
	5	*
	6	* Permission is hereby granted, free of charge, to any person obtaining a
	7	* copy of this software and associated documentation files (the
	8	* "Software"), to deal in the Software without restriction, including
	9	* without limitation the rights to use, copy, modify, merge, publish,
	10	* distribute, sub license, and/or sell copies of the Software, and to
	11	* permit persons to whom the Software is furnished to do so, subject to
	12	* the following conditions:
	13	*
	14	* The above copyright notice and this permission notice (including the
	15	* next paragraph) shall be included in all copies or substantial portions
	16	* of the Software.
	17	*
	18	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	19	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	20	* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
	21	* THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
	22	* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
	23	* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
	24	* USE OR OTHER DEALINGS IN THE SOFTWARE.
	25	*
	26	*
	27	**************************************************************************/
	28	/*
	29	* Authors:
	30	* Thomas Hellstrom <thomas-at-tungstengraphics-dot-com>
	31	*/
	32
	33	#ifndef _DRM_MM_H_
	34	#define _DRM_MM_H_
	35
	36	/*
	37	* Generic range manager structs
	38	*/
86e81f0e DH	39	#include <linux/bug.h>
86e81f0e DH	40	#include <linux/kernel.h>
249d6048	41	#include <linux/list.h>
86e81f0e	42	#include <linux/spinlock.h>
f1938cd6 DA	43	#ifdef CONFIG_DEBUG_FS
	44	#include <linux/seq_file.h>
	45	#endif
249d6048	46
31e5d7c6 DH	47	enum drm_mm_search_flags {
	48	DRM_MM_SEARCH_DEFAULT = 0,
	49	DRM_MM_SEARCH_BEST = 1 << 0,
	50	};
	51
249d6048	52	struct drm_mm_node {
d1024ce9	53	struct list_head node_list;
ea7b1dd4 DV	54	struct list_head hole_stack;
ea7b1dd4 DV	55	unsigned hole_follows : 1;
709ea971 DV	56	unsigned scanned_block : 1;
	57	unsigned scanned_prev_free : 1;
	58	unsigned scanned_next_free : 1;
ea7b1dd4	59	unsigned scanned_preceeds_hole : 1;
b0b7af18	60	unsigned allocated : 1;
6b9d89b4	61	unsigned long color;
249d6048 JG	62	unsigned long start;
	63	unsigned long size;
	64	struct drm_mm *mm;
249d6048 JG	65	};
	66
	67	struct drm_mm {
25985edc	68	/* List of all memory nodes that immediately precede a free hole. */
ea7b1dd4 DV	69	struct list_head hole_stack;
	70	/* head_node.node_list is the list of all memory nodes, ordered
	71	* according to the (increasing) start address of the memory node. */
	72	struct drm_mm_node head_node;
d935cc61	73	unsigned int scan_check_range : 1;
709ea971	74	unsigned scan_alignment;
6b9d89b4	75	unsigned long scan_color;
709ea971 DV	76	unsigned long scan_size;
709ea971 DV	77	unsigned long scan_hit_start;
901593f2	78	unsigned long scan_hit_end;
709ea971	79	unsigned scanned_blocks;
d935cc61 DV	80	unsigned long scan_start;
d935cc61 DV	81	unsigned long scan_end;
ae0cec28	82	struct drm_mm_node *prev_scanned_node;
6b9d89b4 CW	83
	84	void (color_adjust)(struct drm_mm_node node, unsigned long color,
	85	unsigned long start, unsigned long end);
249d6048 JG	86	};
249d6048 JG	87
b0b7af18 DV	88	static inline bool drm_mm_node_allocated(struct drm_mm_node *node)
	89	{
	90	return node->allocated;
	91	}
	92
31a5b8ce DV	93	static inline bool drm_mm_initialized(struct drm_mm *mm)
31a5b8ce DV	94	{
ea7b1dd4	95	return mm->hole_stack.next;
31a5b8ce	96	}
9e8944ab CW	97
	98	static inline unsigned long __drm_mm_hole_node_start(struct drm_mm_node *hole_node)
	99	{
	100	return hole_node->start + hole_node->size;
	101	}
	102
	103	static inline unsigned long drm_mm_hole_node_start(struct drm_mm_node *hole_node)
	104	{
	105	BUG_ON(!hole_node->hole_follows);
	106	return __drm_mm_hole_node_start(hole_node);
	107	}
	108
	109	static inline unsigned long __drm_mm_hole_node_end(struct drm_mm_node *hole_node)
	110	{
	111	return list_entry(hole_node->node_list.next,
	112	struct drm_mm_node, node_list)->start;
	113	}
	114
	115	static inline unsigned long drm_mm_hole_node_end(struct drm_mm_node *hole_node)
	116	{
	117	return __drm_mm_hole_node_end(hole_node);
	118	}
	119
ea7b1dd4 DV	120	#define drm_mm_for_each_node(entry, mm) list_for_each_entry(entry, \
ea7b1dd4 DV	121	&(mm)->head_node.node_list, \
2bbd4492	122	node_list)
9e8944ab CW	123
	124	/* Note that we need to unroll list_for_each_entry in order to inline
	125	* setting hole_start and hole_end on each iteration and keep the
	126	* macro sane.
	127	*/
	128	#define drm_mm_for_each_hole(entry, mm, hole_start, hole_end) \
	129	for (entry = list_entry((mm)->hole_stack.next, struct drm_mm_node, hole_stack); \
	130	&entry->hole_stack != &(mm)->hole_stack ? \
	131	hole_start = drm_mm_hole_node_start(entry), \
	132	hole_end = drm_mm_hole_node_end(entry), \
	133	1 : 0; \
	134	entry = list_entry(entry->hole_stack.next, struct drm_mm_node, hole_stack))
	135
249d6048 JG	136	/*
	137	* Basic range manager support (drm_mm.c)
	138	*/
338710e7	139	extern int drm_mm_reserve_node(struct drm_mm mm, struct drm_mm_node node);
b8103450	140
b8103450 CW	141	extern int drm_mm_insert_node_generic(struct drm_mm *mm,
	142	struct drm_mm_node *node,
	143	unsigned long size,
	144	unsigned alignment,
31e5d7c6 DH	145	unsigned long color,
	146	enum drm_mm_search_flags flags);
	147	static inline int drm_mm_insert_node(struct drm_mm *mm,
	148	struct drm_mm_node *node,
	149	unsigned long size,
	150	unsigned alignment,
	151	enum drm_mm_search_flags flags)
	152	{
	153	return drm_mm_insert_node_generic(mm, node, size, alignment, 0, flags);
	154	}
	155
b8103450 CW	156	extern int drm_mm_insert_node_in_range_generic(struct drm_mm *mm,
	157	struct drm_mm_node *node,
	158	unsigned long size,
	159	unsigned alignment,
	160	unsigned long color,
	161	unsigned long start,
31e5d7c6 DH	162	unsigned long end,
	163	enum drm_mm_search_flags flags);
	164	static inline int drm_mm_insert_node_in_range(struct drm_mm *mm,
	165	struct drm_mm_node *node,
	166	unsigned long size,
	167	unsigned alignment,
	168	unsigned long start,
	169	unsigned long end,
	170	enum drm_mm_search_flags flags)
	171	{
	172	return drm_mm_insert_node_in_range_generic(mm, node, size, alignment,
	173	0, start, end, flags);
	174	}
	175
b0b7af18 DV	176	extern void drm_mm_remove_node(struct drm_mm_node *node);
b0b7af18 DV	177	extern void drm_mm_replace_node(struct drm_mm_node old, struct drm_mm_node new);
77ef8bbc DH	178	extern void drm_mm_init(struct drm_mm *mm,
	179	unsigned long start,
	180	unsigned long size);
249d6048 JG	181	extern void drm_mm_takedown(struct drm_mm *mm);
249d6048 JG	182	extern int drm_mm_clean(struct drm_mm *mm);
249d6048	183
6b9d89b4 CW	184	void drm_mm_init_scan(struct drm_mm *mm,
	185	unsigned long size,
	186	unsigned alignment,
	187	unsigned long color);
	188	void drm_mm_init_scan_with_range(struct drm_mm *mm,
	189	unsigned long size,
d935cc61	190	unsigned alignment,
6b9d89b4	191	unsigned long color,
d935cc61 DV	192	unsigned long start,
d935cc61 DV	193	unsigned long end);
709ea971 DV	194	int drm_mm_scan_add_block(struct drm_mm_node *node);
	195	int drm_mm_scan_remove_block(struct drm_mm_node *node);
	196
99d7e48e	197	extern void drm_mm_debug_table(struct drm_mm mm, const char prefix);
fa8a1238 DA	198	#ifdef CONFIG_DEBUG_FS
	199	int drm_mm_dump_table(struct seq_file m, struct drm_mm mm);
	200	#endif
	201
249d6048	202	#endif