WebSVN – Kolibri OS – Diff – /drivers/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 
 */
 
#ifndef _DRM_MM_H_
#define _DRM_MM_H_
 
/*
 * Generic range manager structs
 */
#include 
#ifdef CONFIG_DEBUG_FS
#include 
#endif
 
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;
	struct list_head unused_nodes;
	int num_unused;
	spinlock_t unused_lock;
	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;
}
#define drm_mm_for_each_node(entry, mm) list_for_each_entry(entry, \
						&(mm)->head_node.node_list, \
						node_list)
#define drm_mm_for_each_scanned_node_reverse(entry, n, mm) \
	for (entry = (mm)->prev_scanned_node, \
		next = entry ? list_entry(entry->node_list.next, \
			struct drm_mm_node, node_list) : NULL; \
	     entry != NULL; entry = next, \
		next = entry ? list_entry(entry->node_list.next, \
			struct drm_mm_node, node_list) : NULL) \
/*
 * Basic range manager support (drm_mm.c)
 */
extern struct drm_mm_node *drm_mm_get_block_generic(struct drm_mm_node *node,
						    unsigned long size,
						    unsigned alignment,
						    unsigned long color,
						    int atomic);
extern struct drm_mm_node *drm_mm_get_block_range_generic(
						struct drm_mm_node *node,
						unsigned long size,
						unsigned alignment,
						unsigned long color,
						unsigned long start,
						unsigned long end,
						int atomic);
static inline struct drm_mm_node *drm_mm_get_block(struct drm_mm_node *parent,
						   unsigned long size,
						   unsigned alignment)
{
	return drm_mm_get_block_generic(parent, size, alignment, 0, 0);
}
static inline struct drm_mm_node *drm_mm_get_block_atomic(struct drm_mm_node *parent,
							  unsigned long size,
							  unsigned alignment)
{
	return drm_mm_get_block_generic(parent, size, alignment, 0, 1);
}
static inline struct drm_mm_node *drm_mm_get_block_range(
						struct drm_mm_node *parent,
						unsigned long size,
						unsigned alignment,
						unsigned long start,
						unsigned long end)
{
	return drm_mm_get_block_range_generic(parent, size, alignment, 0,
					      start, end, 0);
}
static inline struct drm_mm_node *drm_mm_get_color_block_range(
						struct drm_mm_node *parent,
						unsigned long size,
						unsigned alignment,
						unsigned long color,
						unsigned long start,
						unsigned long end)
{
	return drm_mm_get_block_range_generic(parent, size, alignment, color,
						start, end, 0);
}
static inline struct drm_mm_node *drm_mm_get_block_atomic_range(
						struct drm_mm_node *parent,
						unsigned long size,
						unsigned alignment,
						unsigned long start,
						unsigned long end)
{
	return drm_mm_get_block_range_generic(parent, size, alignment, 0,
						start, end, 1);
}
 
extern int drm_mm_insert_node(struct drm_mm *mm,
			      struct drm_mm_node *node,
			      unsigned long size,
			      unsigned alignment);
extern 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);
extern int drm_mm_insert_node_generic(struct drm_mm *mm,
				      struct drm_mm_node *node,
				      unsigned long size,
				      unsigned alignment,
				      unsigned long color);
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);
extern void drm_mm_put_block(struct drm_mm_node *cur);
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 struct drm_mm_node *drm_mm_search_free_generic(const struct drm_mm *mm,
					      unsigned long size,
					      unsigned alignment,
						      unsigned long color,
						      bool best_match);
extern struct drm_mm_node *drm_mm_search_free_in_range_generic(
						const struct drm_mm *mm,
						unsigned long size,
						unsigned alignment,
						unsigned long color,
						unsigned long start,
						unsigned long end,
						bool best_match);
static inline struct drm_mm_node *drm_mm_search_free(const struct drm_mm *mm,
						     unsigned long size,
						     unsigned alignment,
						     bool best_match)
{
	return drm_mm_search_free_generic(mm,size, alignment, 0, best_match);
}
static inline  struct drm_mm_node *drm_mm_search_free_in_range(
						const struct drm_mm *mm,
						unsigned long size,
						unsigned alignment,
						unsigned long start,
						unsigned long end,
						bool best_match)
{
	return drm_mm_search_free_in_range_generic(mm, size, alignment, 0,
						   start, end, best_match);
}
static inline struct drm_mm_node *drm_mm_search_free_color(const struct drm_mm *mm,
							   unsigned long size,
							   unsigned alignment,
							   unsigned long color,
							   bool best_match)
{
	return drm_mm_search_free_generic(mm,size, alignment, color, best_match);
}
static inline  struct drm_mm_node *drm_mm_search_free_in_range_color(
						const struct drm_mm *mm,
						unsigned long size,
						unsigned alignment,
						unsigned long color,
						unsigned long start,
						unsigned long end,
						bool best_match)
{
	return drm_mm_search_free_in_range_generic(mm, size, alignment, color,
						   start, end, best_match);
}
extern int 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);
extern int drm_mm_pre_get(struct drm_mm *mm);
 
static inline struct drm_mm *drm_get_mm(struct drm_mm_node *block)
{
	return block->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

Rev 3031	Rev 3192
1	/**************************************************************************	1	/**************************************************************************
2	*	2	*
3	* Copyright 2006-2008 Tungsten Graphics, Inc., Cedar Park, TX. USA.	3	* Copyright 2006-2008 Tungsten Graphics, Inc., Cedar Park, TX. USA.
4	* All Rights Reserved.	4	* All Rights Reserved.
5	*	5	*
6	* Permission is hereby granted, free of charge, to any person obtaining a	6	* Permission is hereby granted, free of charge, to any person obtaining a
7	* copy of this software and associated documentation files (the	7	* copy of this software and associated documentation files (the
8	* "Software"), to deal in the Software without restriction, including	8	* "Software"), to deal in the Software without restriction, including
9	* without limitation the rights to use, copy, modify, merge, publish,	9	* without limitation the rights to use, copy, modify, merge, publish,
10	* distribute, sub license, and/or sell copies of the Software, and to	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	11	* permit persons to whom the Software is furnished to do so, subject to
12	* the following conditions:	12	* the following conditions:
13	*	13	*
14	* The above copyright notice and this permission notice (including the	14	* The above copyright notice and this permission notice (including the
15	* next paragraph) shall be included in all copies or substantial portions	15	* next paragraph) shall be included in all copies or substantial portions
16	* of the Software.	16	* of the Software.
17	*	17	*
18	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR	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,	19	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20	* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL	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,	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	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	23	* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
24	* USE OR OTHER DEALINGS IN THE SOFTWARE.	24	* USE OR OTHER DEALINGS IN THE SOFTWARE.
25	*	25	*
26	*	26	*
27	**************************************************************************/	27	**************************************************************************/
28	/*	28	/*
29	* Authors:	29	* Authors:
30	* Thomas Hellstrom	30	* Thomas Hellstrom
31	*/	31	*/
32		32
33	#ifndef _DRM_MM_H_	33	#ifndef _DRM_MM_H_
34	#define _DRM_MM_H_	34	#define _DRM_MM_H_
35		35
36	/*	36	/*
37	* Generic range manager structs	37	* Generic range manager structs
38	*/	38	*/
39	#include	39	#include
40	#ifdef CONFIG_DEBUG_FS	40	#ifdef CONFIG_DEBUG_FS
41	#include	41	#include
42	#endif	42	#endif
43		43
44	struct drm_mm_node {	44	struct drm_mm_node {
45	struct list_head node_list;	45	struct list_head node_list;
46	struct list_head hole_stack;	46	struct list_head hole_stack;
47	unsigned hole_follows : 1;	47	unsigned hole_follows : 1;
48	unsigned scanned_block : 1;	48	unsigned scanned_block : 1;
49	unsigned scanned_prev_free : 1;	49	unsigned scanned_prev_free : 1;
50	unsigned scanned_next_free : 1;	50	unsigned scanned_next_free : 1;
51	unsigned scanned_preceeds_hole : 1;	51	unsigned scanned_preceeds_hole : 1;
52	unsigned allocated : 1;	52	unsigned allocated : 1;
53	unsigned long color;	53	unsigned long color;
54	unsigned long start;	54	unsigned long start;
55	unsigned long size;	55	unsigned long size;
56	struct drm_mm *mm;	56	struct drm_mm *mm;
57	};	57	};
58		58
59	struct drm_mm {	59	struct drm_mm {
60	/* List of all memory nodes that immediately precede a free hole. */	60	/* List of all memory nodes that immediately precede a free hole. */
61	struct list_head hole_stack;	61	struct list_head hole_stack;
62	/* head_node.node_list is the list of all memory nodes, ordered	62	/* head_node.node_list is the list of all memory nodes, ordered
63	* according to the (increasing) start address of the memory node. */	63	* according to the (increasing) start address of the memory node. */
64	struct drm_mm_node head_node;	64	struct drm_mm_node head_node;
65	struct list_head unused_nodes;	65	struct list_head unused_nodes;
66	int num_unused;	66	int num_unused;
67	spinlock_t unused_lock;	67	spinlock_t unused_lock;
68	unsigned int scan_check_range : 1;	68	unsigned int scan_check_range : 1;
69	unsigned scan_alignment;	69	unsigned scan_alignment;
70	unsigned long scan_color;	70	unsigned long scan_color;
71	unsigned long scan_size;	71	unsigned long scan_size;
72	unsigned long scan_hit_start;	72	unsigned long scan_hit_start;
73	unsigned scan_hit_size;	73	unsigned long scan_hit_end;
74	unsigned scanned_blocks;	74	unsigned scanned_blocks;
75	unsigned long scan_start;	75	unsigned long scan_start;
76	unsigned long scan_end;	76	unsigned long scan_end;
77	struct drm_mm_node *prev_scanned_node;	77	struct drm_mm_node *prev_scanned_node;
78		78
79	void (color_adjust)(struct drm_mm_node node, unsigned long color,	79	void (color_adjust)(struct drm_mm_node node, unsigned long color,
80	unsigned long start, unsigned long end);	80	unsigned long start, unsigned long end);
81	};	81	};
82		82
83	static inline bool drm_mm_node_allocated(struct drm_mm_node *node)	83	static inline bool drm_mm_node_allocated(struct drm_mm_node *node)
84	{	84	{
85	return node->allocated;	85	return node->allocated;
86	}	86	}
87		87
88	static inline bool drm_mm_initialized(struct drm_mm *mm)	88	static inline bool drm_mm_initialized(struct drm_mm *mm)
89	{	89	{
90	return mm->hole_stack.next;	90	return mm->hole_stack.next;
91	}	91	}
92	#define drm_mm_for_each_node(entry, mm) list_for_each_entry(entry, \	92	#define drm_mm_for_each_node(entry, mm) list_for_each_entry(entry, \
93	&(mm)->head_node.node_list, \	93	&(mm)->head_node.node_list, \
94	node_list)	94	node_list)
95	#define drm_mm_for_each_scanned_node_reverse(entry, n, mm) \	95	#define drm_mm_for_each_scanned_node_reverse(entry, n, mm) \
96	for (entry = (mm)->prev_scanned_node, \	96	for (entry = (mm)->prev_scanned_node, \
97	next = entry ? list_entry(entry->node_list.next, \	97	next = entry ? list_entry(entry->node_list.next, \
98	struct drm_mm_node, node_list) : NULL; \	98	struct drm_mm_node, node_list) : NULL; \
99	entry != NULL; entry = next, \	99	entry != NULL; entry = next, \
100	next = entry ? list_entry(entry->node_list.next, \	100	next = entry ? list_entry(entry->node_list.next, \
101	struct drm_mm_node, node_list) : NULL) \	101	struct drm_mm_node, node_list) : NULL) \
102	/*	102	/*
103	* Basic range manager support (drm_mm.c)	103	* Basic range manager support (drm_mm.c)
104	*/	104	*/
105	extern struct drm_mm_node drm_mm_get_block_generic(struct drm_mm_node node,	105	extern struct drm_mm_node drm_mm_get_block_generic(struct drm_mm_node node,
106	unsigned long size,	106	unsigned long size,
107	unsigned alignment,	107	unsigned alignment,
108	unsigned long color,	108	unsigned long color,
109	int atomic);	109	int atomic);
110	extern struct drm_mm_node *drm_mm_get_block_range_generic(	110	extern struct drm_mm_node *drm_mm_get_block_range_generic(
111	struct drm_mm_node *node,	111	struct drm_mm_node *node,
112	unsigned long size,	112	unsigned long size,
113	unsigned alignment,	113	unsigned alignment,
114	unsigned long color,	114	unsigned long color,
115	unsigned long start,	115	unsigned long start,
116	unsigned long end,	116	unsigned long end,
117	int atomic);	117	int atomic);
118	static inline struct drm_mm_node drm_mm_get_block(struct drm_mm_node parent,	118	static inline struct drm_mm_node drm_mm_get_block(struct drm_mm_node parent,
119	unsigned long size,	119	unsigned long size,
120	unsigned alignment)	120	unsigned alignment)
121	{	121	{
122	return drm_mm_get_block_generic(parent, size, alignment, 0, 0);	122	return drm_mm_get_block_generic(parent, size, alignment, 0, 0);
123	}	123	}
124	static inline struct drm_mm_node drm_mm_get_block_atomic(struct drm_mm_node parent,	124	static inline struct drm_mm_node drm_mm_get_block_atomic(struct drm_mm_node parent,
125	unsigned long size,	125	unsigned long size,
126	unsigned alignment)	126	unsigned alignment)
127	{	127	{
128	return drm_mm_get_block_generic(parent, size, alignment, 0, 1);	128	return drm_mm_get_block_generic(parent, size, alignment, 0, 1);
129	}	129	}
130	static inline struct drm_mm_node *drm_mm_get_block_range(	130	static inline struct drm_mm_node *drm_mm_get_block_range(
131	struct drm_mm_node *parent,	131	struct drm_mm_node *parent,
132	unsigned long size,	132	unsigned long size,
133	unsigned alignment,	133	unsigned alignment,
134	unsigned long start,	134	unsigned long start,
135	unsigned long end)	135	unsigned long end)
136	{	136	{
137	return drm_mm_get_block_range_generic(parent, size, alignment, 0,	137	return drm_mm_get_block_range_generic(parent, size, alignment, 0,
138	start, end, 0);	138	start, end, 0);
139	}	139	}
140	static inline struct drm_mm_node *drm_mm_get_color_block_range(	140	static inline struct drm_mm_node *drm_mm_get_color_block_range(
141	struct drm_mm_node *parent,	141	struct drm_mm_node *parent,
142	unsigned long size,	142	unsigned long size,
143	unsigned alignment,	143	unsigned alignment,
144	unsigned long color,	144	unsigned long color,
145	unsigned long start,	145	unsigned long start,
146	unsigned long end)	146	unsigned long end)
147	{	147	{
148	return drm_mm_get_block_range_generic(parent, size, alignment, color,	148	return drm_mm_get_block_range_generic(parent, size, alignment, color,
149	start, end, 0);	149	start, end, 0);
150	}	150	}
151	static inline struct drm_mm_node *drm_mm_get_block_atomic_range(	151	static inline struct drm_mm_node *drm_mm_get_block_atomic_range(
152	struct drm_mm_node *parent,	152	struct drm_mm_node *parent,
153	unsigned long size,	153	unsigned long size,
154	unsigned alignment,	154	unsigned alignment,
155	unsigned long start,	155	unsigned long start,
156	unsigned long end)	156	unsigned long end)
157	{	157	{
158	return drm_mm_get_block_range_generic(parent, size, alignment, 0,	158	return drm_mm_get_block_range_generic(parent, size, alignment, 0,
159	start, end, 1);	159	start, end, 1);
160	}	160	}
-		161
161	extern int drm_mm_insert_node(struct drm_mm mm, struct drm_mm_node node,	162	extern int drm_mm_insert_node(struct drm_mm *mm,
-		163	struct drm_mm_node *node,
-		164	unsigned long size,
162	unsigned long size, unsigned alignment);	165	unsigned alignment);
163	extern int drm_mm_insert_node_in_range(struct drm_mm *mm,	166	extern int drm_mm_insert_node_in_range(struct drm_mm *mm,
164	struct drm_mm_node *node,	167	struct drm_mm_node *node,
-		168	unsigned long size,
165	unsigned long size, unsigned alignment,	169	unsigned alignment,
166	unsigned long start, unsigned long end);	170	unsigned long start,
-		171	unsigned long end);
-		172	extern int drm_mm_insert_node_generic(struct drm_mm *mm,
-		173	struct drm_mm_node *node,
-		174	unsigned long size,
-		175	unsigned alignment,
-		176	unsigned long color);
-		177	extern int drm_mm_insert_node_in_range_generic(struct drm_mm *mm,
-		178	struct drm_mm_node *node,
-		179	unsigned long size,
-		180	unsigned alignment,
-		181	unsigned long color,
-		182	unsigned long start,
-		183	unsigned long end);
167	extern void drm_mm_put_block(struct drm_mm_node *cur);	184	extern void drm_mm_put_block(struct drm_mm_node *cur);
168	extern void drm_mm_remove_node(struct drm_mm_node *node);	185	extern void drm_mm_remove_node(struct drm_mm_node *node);
169	extern void drm_mm_replace_node(struct drm_mm_node old, struct drm_mm_node new);	186	extern void drm_mm_replace_node(struct drm_mm_node old, struct drm_mm_node new);
170	extern struct drm_mm_node drm_mm_search_free_generic(const struct drm_mm mm,	187	extern struct drm_mm_node drm_mm_search_free_generic(const struct drm_mm mm,
171	unsigned long size,	188	unsigned long size,
172	unsigned alignment,	189	unsigned alignment,
173	unsigned long color,	190	unsigned long color,
174	bool best_match);	191	bool best_match);
175	extern struct drm_mm_node *drm_mm_search_free_in_range_generic(	192	extern struct drm_mm_node *drm_mm_search_free_in_range_generic(
176	const struct drm_mm *mm,	193	const struct drm_mm *mm,
177	unsigned long size,	194	unsigned long size,
178	unsigned alignment,	195	unsigned alignment,
179	unsigned long color,	196	unsigned long color,
180	unsigned long start,	197	unsigned long start,
181	unsigned long end,	198	unsigned long end,
182	bool best_match);	199	bool best_match);
183	static inline struct drm_mm_node drm_mm_search_free(const struct drm_mm mm,	200	static inline struct drm_mm_node drm_mm_search_free(const struct drm_mm mm,
184	unsigned long size,	201	unsigned long size,
185	unsigned alignment,	202	unsigned alignment,
186	bool best_match)	203	bool best_match)
187	{	204	{
188	return drm_mm_search_free_generic(mm,size, alignment, 0, best_match);	205	return drm_mm_search_free_generic(mm,size, alignment, 0, best_match);
189	}	206	}
190	static inline struct drm_mm_node *drm_mm_search_free_in_range(	207	static inline struct drm_mm_node *drm_mm_search_free_in_range(
191	const struct drm_mm *mm,	208	const struct drm_mm *mm,
192	unsigned long size,	209	unsigned long size,
193	unsigned alignment,	210	unsigned alignment,
194	unsigned long start,	211	unsigned long start,
195	unsigned long end,	212	unsigned long end,
196	bool best_match)	213	bool best_match)
197	{	214	{
198	return drm_mm_search_free_in_range_generic(mm, size, alignment, 0,	215	return drm_mm_search_free_in_range_generic(mm, size, alignment, 0,
199	start, end, best_match);	216	start, end, best_match);
200	}	217	}
201	static inline struct drm_mm_node drm_mm_search_free_color(const struct drm_mm mm,	218	static inline struct drm_mm_node drm_mm_search_free_color(const struct drm_mm mm,
202	unsigned long size,	219	unsigned long size,
203	unsigned alignment,	220	unsigned alignment,
204	unsigned long color,	221	unsigned long color,
205	bool best_match)	222	bool best_match)
206	{	223	{
207	return drm_mm_search_free_generic(mm,size, alignment, color, best_match);	224	return drm_mm_search_free_generic(mm,size, alignment, color, best_match);
208	}	225	}
209	static inline struct drm_mm_node *drm_mm_search_free_in_range_color(	226	static inline struct drm_mm_node *drm_mm_search_free_in_range_color(
210	const struct drm_mm *mm,	227	const struct drm_mm *mm,
211	unsigned long size,	228	unsigned long size,
212	unsigned alignment,	229	unsigned alignment,
213	unsigned long color,	230	unsigned long color,
214	unsigned long start,	231	unsigned long start,
215	unsigned long end,	232	unsigned long end,
216	bool best_match)	233	bool best_match)
217	{	234	{
218	return drm_mm_search_free_in_range_generic(mm, size, alignment, color,	235	return drm_mm_search_free_in_range_generic(mm, size, alignment, color,
219	start, end, best_match);	236	start, end, best_match);
220	}	237	}
221	extern int drm_mm_init(struct drm_mm *mm,	238	extern int drm_mm_init(struct drm_mm *mm,
222	unsigned long start,	239	unsigned long start,
223	unsigned long size);	240	unsigned long size);
224	extern void drm_mm_takedown(struct drm_mm *mm);	241	extern void drm_mm_takedown(struct drm_mm *mm);
225	extern int drm_mm_clean(struct drm_mm *mm);	242	extern int drm_mm_clean(struct drm_mm *mm);
226	extern int drm_mm_pre_get(struct drm_mm *mm);	243	extern int drm_mm_pre_get(struct drm_mm *mm);
227		244
228	static inline struct drm_mm drm_get_mm(struct drm_mm_node block)	245	static inline struct drm_mm drm_get_mm(struct drm_mm_node block)
229	{	246	{
230	return block->mm;	247	return block->mm;
231	}	248	}
232		249
233	void drm_mm_init_scan(struct drm_mm *mm,	250	void drm_mm_init_scan(struct drm_mm *mm,
234	unsigned long size,	251	unsigned long size,
235	unsigned alignment,	252	unsigned alignment,
236	unsigned long color);	253	unsigned long color);
237	void drm_mm_init_scan_with_range(struct drm_mm *mm,	254	void drm_mm_init_scan_with_range(struct drm_mm *mm,
238	unsigned long size,	255	unsigned long size,
239	unsigned alignment,	256	unsigned alignment,
240	unsigned long color,	257	unsigned long color,
241	unsigned long start,	258	unsigned long start,
242	unsigned long end);	259	unsigned long end);
243	int drm_mm_scan_add_block(struct drm_mm_node *node);	260	int drm_mm_scan_add_block(struct drm_mm_node *node);
244	int drm_mm_scan_remove_block(struct drm_mm_node *node);	261	int drm_mm_scan_remove_block(struct drm_mm_node *node);
245		262
246	extern void drm_mm_debug_table(struct drm_mm mm, const char prefix);	263	extern void drm_mm_debug_table(struct drm_mm mm, const char prefix);
247	#ifdef CONFIG_DEBUG_FS	264	#ifdef CONFIG_DEBUG_FS
248	int drm_mm_dump_table(struct seq_file m, struct drm_mm mm);	265	int drm_mm_dump_table(struct seq_file m, struct drm_mm mm);
249	#endif	266	#endif
250		267
251	#endif	268	#endif

Subversion Repositories Kolibri OS

(root)/drivers/include/drm/drm_mm.h – Rev 3031 → 3192