Subversion Repositories Kolibri OS

/* drm_mm_pre_get() - pre allocate drm_mm_node structure

 * drm_mm:	memory manager struct we are pre-allocating for

 *

 * Returns 0 on success or -ENOMEM if allocation fails.

EXPORT_SYMBOL(drm_mm_get_block_generic);

struct drm_mm_node *drm_mm_get_block_range_generic(struct drm_mm_node *node,

						unsigned long size,

						unsigned alignment,

						unsigned long start,

						unsigned long end,

						int atomic)

{

	struct drm_mm_node *align_splitoff = NULL;

	unsigned tmp = 0;

	unsigned wasted = 0;

	if (node->start < start)

		wasted += start - node->start;

	if (alignment)

		tmp = ((node->start + wasted) % alignment);

	if (tmp)

		wasted += alignment - tmp;

	if (wasted) {

		align_splitoff = drm_mm_split_at_start(node, wasted, atomic);

		if (unlikely(align_splitoff == NULL))

			return NULL;

	}

	if (node->size == size) {

		list_del_init(&node->fl_entry);

		node->free = 0;

	} else {

		node = drm_mm_split_at_start(node, size, atomic);

	}

	if (align_splitoff)

		drm_mm_put_block(align_splitoff);

	return node;

}

				spin_lock(&mm->unused_lock);

				spin_unlock(&mm->unused_lock);

		spin_lock(&mm->unused_lock);

		spin_unlock(&mm->unused_lock);

EXPORT_SYMBOL(drm_mm_search_free);

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,

						int best_match)

{

	struct list_head *list;

	const struct list_head *free_stack = &mm->fl_entry;

	struct drm_mm_node *entry;

	struct drm_mm_node *best;

	unsigned long best_size;

	unsigned wasted;

	best = NULL;

	best_size = ~0UL;

	list_for_each(list, free_stack) {

		entry = list_entry(list, struct drm_mm_node, fl_entry);

		wasted = 0;

		if (entry->size < size)

			continue;

		if (entry->start > end || (entry->start+entry->size) < start)

			continue;

		if (entry->start < start)

			wasted += start - entry->start;

		if (alignment) {

			register unsigned tmp = (entry->start + wasted) % alignment;

			if (tmp)

				wasted += alignment - tmp;

		}

		if (entry->size >= size + wasted) {

			if (!best_match)

				return entry;

			if (size < best_size) {

				best = entry;

				best_size = entry->size;

			}

		}

	}

	return best;

}