[linux-2.6-block.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,
	DRM_MM_SEARCH_BELOW =		1 << 1,
};

enum drm_mm_allocator_flags {
	DRM_MM_CREATE_DEFAULT =		0,
	DRM_MM_CREATE_TOP =		1 << 0,
};

#define DRM_MM_BOTTOMUP DRM_MM_SEARCH_DEFAULT, DRM_MM_CREATE_DEFAULT
#define DRM_MM_TOPDOWN DRM_MM_SEARCH_BELOW, DRM_MM_CREATE_TOP

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;
	u64 start;
	u64 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;
	u64 scan_size;
	u64 scan_hit_start;
	u64 scan_hit_end;
	unsigned scanned_blocks;
	u64 scan_start;
	u64 scan_end;
	struct drm_mm_node *prev_scanned_node;

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

/**
 * drm_mm_node_allocated - checks whether a node is allocated
 * @node: drm_mm_node to check
 *
 * Drivers should use this helpers for proper encapusulation of drm_mm
 * internals.
 *
 * Returns:
 * True if the @node is allocated.
 */
static inline bool drm_mm_node_allocated(struct drm_mm_node *node)
{
	return node->allocated;
}

/**
 * drm_mm_initialized - checks whether an allocator is initialized
 * @mm: drm_mm to check
 *
 * Drivers should use this helpers for proper encapusulation of drm_mm
 * internals.
 *
 * Returns:
 * True if the @mm is initialized.
 */
static inline bool drm_mm_initialized(struct drm_mm *mm)
{
	return mm->hole_stack.next;
}

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

/**
 * drm_mm_hole_node_start - computes the start of the hole following @node
 * @hole_node: drm_mm_node which implicitly tracks the following hole
 *
 * This is useful for driver-sepific debug dumpers. Otherwise drivers should not
 * inspect holes themselves. Drivers must check first whether a hole indeed
 * follows by looking at node->hole_follows.
 *
 * Returns:
 * Start of the subsequent hole.
 */
static inline u64 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 u64 __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;
}

/**
 * drm_mm_hole_node_end - computes the end of the hole following @node
 * @hole_node: drm_mm_node which implicitly tracks the following hole
 *
 * This is useful for driver-sepific debug dumpers. Otherwise drivers should not
 * inspect holes themselves. Drivers must check first whether a hole indeed
 * follows by looking at node->hole_follows.
 *
 * Returns:
 * End of the subsequent hole.
 */
static inline u64 drm_mm_hole_node_end(struct drm_mm_node *hole_node)
{
	return __drm_mm_hole_node_end(hole_node);
}

/**
 * drm_mm_for_each_node - iterator to walk over all allocated nodes
 * @entry: drm_mm_node structure to assign to in each iteration step
 * @mm: drm_mm allocator to walk
 *
 * This iterator walks over all nodes in the range allocator. It is implemented
 * with list_for_each, so not save against removal of elements.
 */
#define drm_mm_for_each_node(entry, mm) list_for_each_entry(entry, \
						&(mm)->head_node.node_list, \
						node_list)

/**
 * drm_mm_for_each_hole - iterator to walk over all holes
 * @entry: drm_mm_node used internally to track progress
 * @mm: drm_mm allocator to walk
 * @hole_start: ulong variable to assign the hole start to on each iteration
 * @hole_end: ulong variable to assign the hole end to on each iteration
 *
 * This iterator walks over all holes in the range allocator. It is implemented
 * with list_for_each, so not save against removal of elements. @entry is used
 * internally and will not reflect a real drm_mm_node for the very first hole.
 * Hence users of this iterator may not access it.
 *
 * Implementation Note:
 * We need to inline list_for_each_entry in order to be able to set hole_start
 * and hole_end on each iteration while keeping the macro sane.
 *
 * The __drm_mm_for_each_hole version is similar, but with added support for
 * going backwards.
 */
#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))

#define __drm_mm_for_each_hole(entry, mm, hole_start, hole_end, backwards) \
	for (entry = list_entry((backwards) ? (mm)->hole_stack.prev : (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((backwards) ? entry->hole_stack.prev : entry->hole_stack.next, struct drm_mm_node, hole_stack))

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

int drm_mm_insert_node_generic(struct drm_mm *mm,
			       struct drm_mm_node *node,
			       u64 size,
			       unsigned alignment,
			       unsigned long color,
			       enum drm_mm_search_flags sflags,
			       enum drm_mm_allocator_flags aflags);
/**
 * drm_mm_insert_node - search for space and insert @node
 * @mm: drm_mm to allocate from
 * @node: preallocate node to insert
 * @size: size of the allocation
 * @alignment: alignment of the allocation
 * @flags: flags to fine-tune the allocation
 *
 * This is a simplified version of drm_mm_insert_node_generic() with @color set
 * to 0.
 *
 * The preallocated node must be cleared to 0.
 *
 * Returns:
 * 0 on success, -ENOSPC if there's no suitable hole.
 */
static inline int drm_mm_insert_node(struct drm_mm *mm,
				     struct drm_mm_node *node,
				     u64 size,
				     unsigned alignment,
				     enum drm_mm_search_flags flags)
{
	return drm_mm_insert_node_generic(mm, node, size, alignment, 0, flags,
					  DRM_MM_CREATE_DEFAULT);
}

int drm_mm_insert_node_in_range_generic(struct drm_mm *mm,
					struct drm_mm_node *node,
					u64 size,
					unsigned alignment,
					unsigned long color,
					u64 start,
					u64 end,
					enum drm_mm_search_flags sflags,
					enum drm_mm_allocator_flags aflags);
/**
 * drm_mm_insert_node_in_range - ranged search for space and insert @node
 * @mm: drm_mm to allocate from
 * @node: preallocate node to insert
 * @size: size of the allocation
 * @alignment: alignment of the allocation
 * @start: start of the allowed range for this node
 * @end: end of the allowed range for this node
 * @flags: flags to fine-tune the allocation
 *
 * This is a simplified version of drm_mm_insert_node_in_range_generic() with
 * @color set to 0.
 *
 * The preallocated node must be cleared to 0.
 *
 * Returns:
 * 0 on success, -ENOSPC if there's no suitable hole.
 */
static inline int drm_mm_insert_node_in_range(struct drm_mm *mm,
					      struct drm_mm_node *node,
					      u64 size,
					      unsigned alignment,
					      u64 start,
					      u64 end,
					      enum drm_mm_search_flags flags)
{
	return drm_mm_insert_node_in_range_generic(mm, node, size, alignment,
						   0, start, end, flags,
						   DRM_MM_CREATE_DEFAULT);
}

void drm_mm_remove_node(struct drm_mm_node *node);
void drm_mm_replace_node(struct drm_mm_node *old, struct drm_mm_node *new);
void drm_mm_init(struct drm_mm *mm,
		 u64 start,
		 u64 size);
void drm_mm_takedown(struct drm_mm *mm);
bool drm_mm_clean(struct drm_mm *mm);

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

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,
62347f9e	50	DRM_MM_SEARCH_BELOW = 1 << 1,
31e5d7c6 DH	51	};
31e5d7c6 DH	52
62347f9e LK	53	enum drm_mm_allocator_flags {
	54	DRM_MM_CREATE_DEFAULT = 0,
	55	DRM_MM_CREATE_TOP = 1 << 0,
	56	};
	57
	58	#define DRM_MM_BOTTOMUP DRM_MM_SEARCH_DEFAULT, DRM_MM_CREATE_DEFAULT
	59	#define DRM_MM_TOPDOWN DRM_MM_SEARCH_BELOW, DRM_MM_CREATE_TOP
	60
249d6048	61	struct drm_mm_node {
d1024ce9	62	struct list_head node_list;
ea7b1dd4 DV	63	struct list_head hole_stack;
ea7b1dd4 DV	64	unsigned hole_follows : 1;
709ea971 DV	65	unsigned scanned_block : 1;
	66	unsigned scanned_prev_free : 1;
	67	unsigned scanned_next_free : 1;
ea7b1dd4	68	unsigned scanned_preceeds_hole : 1;
b0b7af18	69	unsigned allocated : 1;
6b9d89b4	70	unsigned long color;
440fd528 TR	71	u64 start;
440fd528 TR	72	u64 size;
249d6048	73	struct drm_mm *mm;
249d6048 JG	74	};
	75
	76	struct drm_mm {
25985edc	77	/* List of all memory nodes that immediately precede a free hole. */
ea7b1dd4 DV	78	struct list_head hole_stack;
	79	/* head_node.node_list is the list of all memory nodes, ordered
	80	* according to the (increasing) start address of the memory node. */
	81	struct drm_mm_node head_node;
d935cc61	82	unsigned int scan_check_range : 1;
709ea971	83	unsigned scan_alignment;
6b9d89b4	84	unsigned long scan_color;
440fd528 TR	85	u64 scan_size;
	86	u64 scan_hit_start;
	87	u64 scan_hit_end;
709ea971	88	unsigned scanned_blocks;
440fd528 TR	89	u64 scan_start;
440fd528 TR	90	u64 scan_end;
ae0cec28	91	struct drm_mm_node *prev_scanned_node;
6b9d89b4 CW	92
6b9d89b4 CW	93	void (color_adjust)(struct drm_mm_node node, unsigned long color,
440fd528	94	u64 start, u64 end);
249d6048 JG	95	};
249d6048 JG	96
e18c0412 DV	97	/**
	98	* drm_mm_node_allocated - checks whether a node is allocated
	99	* @node: drm_mm_node to check
	100	*
	101	* Drivers should use this helpers for proper encapusulation of drm_mm
	102	* internals.
	103	*
	104	* Returns:
	105	* True if the @node is allocated.
	106	*/
b0b7af18 DV	107	static inline bool drm_mm_node_allocated(struct drm_mm_node *node)
	108	{
	109	return node->allocated;
	110	}
	111
e18c0412 DV	112	/**
	113	* drm_mm_initialized - checks whether an allocator is initialized
	114	* @mm: drm_mm to check
	115	*
	116	* Drivers should use this helpers for proper encapusulation of drm_mm
	117	* internals.
	118	*
	119	* Returns:
	120	* True if the @mm is initialized.
	121	*/
31a5b8ce DV	122	static inline bool drm_mm_initialized(struct drm_mm *mm)
31a5b8ce DV	123	{
ea7b1dd4	124	return mm->hole_stack.next;
31a5b8ce	125	}
9e8944ab	126
440fd528	127	static inline u64 __drm_mm_hole_node_start(struct drm_mm_node *hole_node)
9e8944ab CW	128	{
	129	return hole_node->start + hole_node->size;
	130	}
	131
e18c0412 DV	132	/**
	133	* drm_mm_hole_node_start - computes the start of the hole following @node
	134	* @hole_node: drm_mm_node which implicitly tracks the following hole
	135	*
	136	* This is useful for driver-sepific debug dumpers. Otherwise drivers should not
	137	* inspect holes themselves. Drivers must check first whether a hole indeed
	138	* follows by looking at node->hole_follows.
	139	*
	140	* Returns:
	141	* Start of the subsequent hole.
	142	*/
440fd528	143	static inline u64 drm_mm_hole_node_start(struct drm_mm_node *hole_node)
9e8944ab CW	144	{
	145	BUG_ON(!hole_node->hole_follows);
	146	return __drm_mm_hole_node_start(hole_node);
	147	}
	148
440fd528	149	static inline u64 __drm_mm_hole_node_end(struct drm_mm_node *hole_node)
9e8944ab CW	150	{
	151	return list_entry(hole_node->node_list.next,
	152	struct drm_mm_node, node_list)->start;
	153	}
	154
e18c0412 DV	155	/**
	156	* drm_mm_hole_node_end - computes the end of the hole following @node
	157	* @hole_node: drm_mm_node which implicitly tracks the following hole
	158	*
	159	* This is useful for driver-sepific debug dumpers. Otherwise drivers should not
	160	* inspect holes themselves. Drivers must check first whether a hole indeed
	161	* follows by looking at node->hole_follows.
	162	*
	163	* Returns:
	164	* End of the subsequent hole.
	165	*/
440fd528	166	static inline u64 drm_mm_hole_node_end(struct drm_mm_node *hole_node)
9e8944ab CW	167	{
	168	return __drm_mm_hole_node_end(hole_node);
	169	}
	170
e18c0412 DV	171	/**
	172	* drm_mm_for_each_node - iterator to walk over all allocated nodes
	173	* @entry: drm_mm_node structure to assign to in each iteration step
	174	* @mm: drm_mm allocator to walk
	175	*
	176	* This iterator walks over all nodes in the range allocator. It is implemented
	177	* with list_for_each, so not save against removal of elements.
	178	*/
ea7b1dd4 DV	179	#define drm_mm_for_each_node(entry, mm) list_for_each_entry(entry, \
ea7b1dd4 DV	180	&(mm)->head_node.node_list, \
2bbd4492	181	node_list)
9e8944ab	182
e18c0412 DV	183	/**
	184	* drm_mm_for_each_hole - iterator to walk over all holes
	185	* @entry: drm_mm_node used internally to track progress
	186	* @mm: drm_mm allocator to walk
	187	* @hole_start: ulong variable to assign the hole start to on each iteration
	188	* @hole_end: ulong variable to assign the hole end to on each iteration
	189	*
	190	* This iterator walks over all holes in the range allocator. It is implemented
	191	* with list_for_each, so not save against removal of elements. @entry is used
	192	* internally and will not reflect a real drm_mm_node for the very first hole.
	193	* Hence users of this iterator may not access it.
	194	*
	195	* Implementation Note:
	196	* We need to inline list_for_each_entry in order to be able to set hole_start
	197	* and hole_end on each iteration while keeping the macro sane.
62347f9e LK	198	*
	199	* The __drm_mm_for_each_hole version is similar, but with added support for
	200	* going backwards.
9e8944ab CW	201	*/
	202	#define drm_mm_for_each_hole(entry, mm, hole_start, hole_end) \
	203	for (entry = list_entry((mm)->hole_stack.next, struct drm_mm_node, hole_stack); \
	204	&entry->hole_stack != &(mm)->hole_stack ? \
	205	hole_start = drm_mm_hole_node_start(entry), \
	206	hole_end = drm_mm_hole_node_end(entry), \
	207	1 : 0; \
	208	entry = list_entry(entry->hole_stack.next, struct drm_mm_node, hole_stack))
	209
62347f9e LK	210	#define __drm_mm_for_each_hole(entry, mm, hole_start, hole_end, backwards) \
	211	for (entry = list_entry((backwards) ? (mm)->hole_stack.prev : (mm)->hole_stack.next, struct drm_mm_node, hole_stack); \
	212	&entry->hole_stack != &(mm)->hole_stack ? \
	213	hole_start = drm_mm_hole_node_start(entry), \
	214	hole_end = drm_mm_hole_node_end(entry), \
	215	1 : 0; \
	216	entry = list_entry((backwards) ? entry->hole_stack.prev : entry->hole_stack.next, struct drm_mm_node, hole_stack))
	217
249d6048 JG	218	/*
	219	* Basic range manager support (drm_mm.c)
	220	*/
e18c0412 DV	221	int drm_mm_reserve_node(struct drm_mm mm, struct drm_mm_node node);
	222
	223	int drm_mm_insert_node_generic(struct drm_mm *mm,
	224	struct drm_mm_node *node,
440fd528	225	u64 size,
e18c0412 DV	226	unsigned alignment,
e18c0412 DV	227	unsigned long color,
62347f9e LK	228	enum drm_mm_search_flags sflags,
62347f9e LK	229	enum drm_mm_allocator_flags aflags);
e18c0412 DV	230	/**
	231	* drm_mm_insert_node - search for space and insert @node
	232	* @mm: drm_mm to allocate from
	233	* @node: preallocate node to insert
	234	* @size: size of the allocation
	235	* @alignment: alignment of the allocation
	236	* @flags: flags to fine-tune the allocation
	237	*
	238	* This is a simplified version of drm_mm_insert_node_generic() with @color set
	239	* to 0.
	240	*
	241	* The preallocated node must be cleared to 0.
	242	*
	243	* Returns:
	244	* 0 on success, -ENOSPC if there's no suitable hole.
	245	*/
31e5d7c6 DH	246	static inline int drm_mm_insert_node(struct drm_mm *mm,
31e5d7c6 DH	247	struct drm_mm_node *node,
440fd528	248	u64 size,
31e5d7c6 DH	249	unsigned alignment,
	250	enum drm_mm_search_flags flags)
	251	{
62347f9e LK	252	return drm_mm_insert_node_generic(mm, node, size, alignment, 0, flags,
62347f9e LK	253	DRM_MM_CREATE_DEFAULT);
31e5d7c6 DH	254	}
31e5d7c6 DH	255
e18c0412 DV	256	int drm_mm_insert_node_in_range_generic(struct drm_mm *mm,
e18c0412 DV	257	struct drm_mm_node *node,
440fd528	258	u64 size,
e18c0412 DV	259	unsigned alignment,
e18c0412 DV	260	unsigned long color,
440fd528 TR	261	u64 start,
440fd528 TR	262	u64 end,
62347f9e LK	263	enum drm_mm_search_flags sflags,
62347f9e LK	264	enum drm_mm_allocator_flags aflags);
e18c0412 DV	265	/**
	266	* drm_mm_insert_node_in_range - ranged search for space and insert @node
	267	* @mm: drm_mm to allocate from
	268	* @node: preallocate node to insert
	269	* @size: size of the allocation
	270	* @alignment: alignment of the allocation
	271	* @start: start of the allowed range for this node
	272	* @end: end of the allowed range for this node
	273	* @flags: flags to fine-tune the allocation
	274	*
	275	* This is a simplified version of drm_mm_insert_node_in_range_generic() with
	276	* @color set to 0.
	277	*
	278	* The preallocated node must be cleared to 0.
	279	*
	280	* Returns:
	281	* 0 on success, -ENOSPC if there's no suitable hole.
	282	*/
31e5d7c6 DH	283	static inline int drm_mm_insert_node_in_range(struct drm_mm *mm,
31e5d7c6 DH	284	struct drm_mm_node *node,
440fd528	285	u64 size,
31e5d7c6	286	unsigned alignment,
440fd528 TR	287	u64 start,
440fd528 TR	288	u64 end,
31e5d7c6 DH	289	enum drm_mm_search_flags flags)
	290	{
	291	return drm_mm_insert_node_in_range_generic(mm, node, size, alignment,
62347f9e LK	292	0, start, end, flags,
62347f9e LK	293	DRM_MM_CREATE_DEFAULT);
31e5d7c6 DH	294	}
31e5d7c6 DH	295
e18c0412 DV	296	void drm_mm_remove_node(struct drm_mm_node *node);
	297	void drm_mm_replace_node(struct drm_mm_node old, struct drm_mm_node new);
	298	void drm_mm_init(struct drm_mm *mm,
440fd528 TR	299	u64 start,
440fd528 TR	300	u64 size);
e18c0412 DV	301	void drm_mm_takedown(struct drm_mm *mm);
e18c0412 DV	302	bool drm_mm_clean(struct drm_mm *mm);
249d6048	303
6b9d89b4	304	void drm_mm_init_scan(struct drm_mm *mm,
440fd528	305	u64 size,
6b9d89b4 CW	306	unsigned alignment,
	307	unsigned long color);
	308	void drm_mm_init_scan_with_range(struct drm_mm *mm,
440fd528	309	u64 size,
d935cc61	310	unsigned alignment,
6b9d89b4	311	unsigned long color,
440fd528 TR	312	u64 start,
440fd528 TR	313	u64 end);
e18c0412 DV	314	bool drm_mm_scan_add_block(struct drm_mm_node *node);
e18c0412 DV	315	bool drm_mm_scan_remove_block(struct drm_mm_node *node);
709ea971	316
e18c0412	317	void drm_mm_debug_table(struct drm_mm mm, const char prefix);
fa8a1238 DA	318	#ifdef CONFIG_DEBUG_FS
	319	int drm_mm_dump_table(struct seq_file m, struct drm_mm mm);
	320	#endif
	321
249d6048	322	#endif