Rename drm_mm.c and its fuctions to drm_memrange.

It's not really a graphics memory allocator, just something to track ranges
of address space.  It doesn't involve actual allocation, and was consuming
some desired namespace.

12 files changed, 108 insertions, 103 deletions

diff --git a/linux-core/Makefile.kernel b/linux-core/Makefile.kernel
index 093552bf..c4975924 100644
--- a/linux-core/Makefile.kernel
+++ b/linux-core/Makefile.kernel
@@ -12,7 +12,7 @@ drm-objs    := drm_auth.o drm_bufs.o drm_context.o drm_dma.o drm_drawable.o \
 		drm_lock.o drm_memory.o drm_proc.o drm_stub.o drm_vm.o \
 		drm_sysfs.o drm_pci.o drm_agpsupport.o drm_scatter.o \
 		drm_memory_debug.o ati_pcigart.o drm_sman.o \
-		drm_hashtab.o drm_mm.o drm_object.o drm_compat.o \
+		drm_hashtab.o drm_memrange.o drm_object.o drm_compat.o \
 	        drm_fence.o drm_ttm.o drm_bo.o drm_bo_move.o drm_bo_lock.o \
 		drm_regman.o
 tdfx-objs   := tdfx_drv.o
diff --git a/linux-core/drmP.h b/linux-core/drmP.h
index 69d31e14..ea8a997f 100644
--- a/linux-core/drmP.h
+++ b/linux-core/drmP.h
@@ -539,17 +539,17 @@ struct drm_sigdata {
  * Generic memory manager structs
  */
 
-struct drm_mm_node {
+struct drm_memrange_node {
 	struct list_head fl_entry;
 	struct list_head ml_entry;
 	int free;
 	unsigned long start;
 	unsigned long size;
-	struct drm_mm *mm;
+	struct drm_memrange *mm;
 	void *private;
 };
 
-struct drm_mm {
+struct drm_memrange {
 	struct list_head fl_entry;
 	struct list_head ml_entry;
 };
@@ -563,7 +563,7 @@ struct drm_map_list {
 	struct drm_hash_item hash;
 	struct drm_map *map;			/**< mapping */
 	uint64_t user_token;
-	struct drm_mm_node *file_offset_node;
+	struct drm_memrange_node *file_offset_node;
 };
 
 typedef struct drm_map drm_local_map_t;
@@ -787,7 +787,7 @@ struct drm_device {
 	struct list_head maplist;	/**< Linked list of regions */
 	int map_count;			/**< Number of mappable regions */
 	struct drm_open_hash map_hash;       /**< User token hash table for maps */
-	struct drm_mm offset_manager;        /**< User token manager */
+	struct drm_memrange offset_manager;  /**< User token manager */
 	struct drm_open_hash object_hash;    /**< User token hash table for objects */
 	struct address_space *dev_mapping;  /**< For unmap_mapping_range() */
 	struct page *ttm_dummy_page;
@@ -1234,22 +1234,27 @@ extern int drm_sysfs_device_add(struct drm_minor *minor);
 extern void drm_sysfs_device_remove(struct drm_minor *minor);
 
 /*
- * Basic memory manager support (drm_mm.c)
+ * Basic memory manager support (drm_memrange.c)
  */
 
-extern struct drm_mm_node * drm_mm_get_block(struct drm_mm_node * parent, unsigned long size,
-					       unsigned alignment);
-extern void drm_mm_put_block(struct drm_mm_node *cur);
-extern struct drm_mm_node *drm_mm_search_free(const struct drm_mm *mm, unsigned long size,
-						unsigned alignment, int 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 unsigned long drm_mm_tail_space(struct drm_mm *mm);
-extern int drm_mm_remove_space_from_tail(struct drm_mm *mm, unsigned long size);
-extern int drm_mm_add_space_to_tail(struct drm_mm *mm, unsigned long size);
-
-static inline struct drm_mm *drm_get_mm(struct drm_mm_node *block)
+extern struct drm_memrange_node *drm_memrange_get_block(struct drm_memrange_node * parent,
+							unsigned long size,
+							unsigned alignment);
+extern void drm_memrange_put_block(struct drm_memrange_node *cur);
+extern struct drm_memrange_node *drm_memrange_search_free(const struct drm_memrange *mm,
+							  unsigned long size,
+							  unsigned alignment, int best_match);
+extern int drm_memrange_init(struct drm_memrange *mm,
+			     unsigned long start, unsigned long size);
+extern void drm_memrange_takedown(struct drm_memrange *mm);
+extern int drm_memrange_clean(struct drm_memrange *mm);
+extern unsigned long drm_memrange_tail_space(struct drm_memrange *mm);
+extern int drm_memrange_remove_space_from_tail(struct drm_memrange *mm,
+					       unsigned long size);
+extern int drm_memrange_add_space_to_tail(struct drm_memrange *mm,
+					  unsigned long size);
+
+static inline struct drm_memrange *drm_get_mm(struct drm_memrange_node *block)
 {
 	return block->mm;
 }
diff --git a/linux-core/drm_bo.c b/linux-core/drm_bo.c
index 88b2ee66..3abbb8c4 100644
--- a/linux-core/drm_bo.c
+++ b/linux-core/drm_bo.c
@@ -418,14 +418,14 @@ static void drm_bo_cleanup_refs(struct drm_buffer_object *bo, int remove_all)
 	if (!bo->fence) {
 		list_del_init(&bo->lru);
 		if (bo->mem.mm_node) {
-			drm_mm_put_block(bo->mem.mm_node);
+			drm_memrange_put_block(bo->mem.mm_node);
 			if (bo->pinned_node == bo->mem.mm_node)
 				bo->pinned_node = NULL;
 			bo->mem.mm_node = NULL;
 		}
 		list_del_init(&bo->pinned_lru);
 		if (bo->pinned_node) {
-			drm_mm_put_block(bo->pinned_node);
+			drm_memrange_put_block(bo->pinned_node);
 			bo->pinned_node = NULL;
 		}
 		list_del_init(&bo->ddestroy);
@@ -791,7 +791,7 @@ out:
 	mutex_lock(&dev->struct_mutex);
 	if (evict_mem.mm_node) {
 		if (evict_mem.mm_node != bo->pinned_node)
-			drm_mm_put_block(evict_mem.mm_node);
+			drm_memrange_put_block(evict_mem.mm_node);
 		evict_mem.mm_node = NULL;
 	}
 	drm_bo_add_to_lru(bo);
@@ -810,7 +810,7 @@ static int drm_bo_mem_force_space(struct drm_device *dev,
 				  struct drm_bo_mem_reg *mem,
 				  uint32_t mem_type, int no_wait)
 {
-	struct drm_mm_node *node;
+	struct drm_memrange_node *node;
 	struct drm_buffer_manager *bm = &dev->bm;
 	struct drm_buffer_object *entry;
 	struct drm_mem_type_manager *man = &bm->man[mem_type];
@@ -820,7 +820,7 @@ static int drm_bo_mem_force_space(struct drm_device *dev,
 
 	mutex_lock(&dev->struct_mutex);
 	do {
-		node = drm_mm_search_free(&man->manager, num_pages,
+		node = drm_memrange_search_free(&man->manager, num_pages,
 					  mem->page_alignment, 1);
 		if (node)
 			break;
@@ -846,7 +846,7 @@ static int drm_bo_mem_force_space(struct drm_device *dev,
 		return -ENOMEM;
 	}
 
-	node = drm_mm_get_block(node, num_pages, mem->page_alignment);
+	node = drm_memrange_get_block(node, num_pages, mem->page_alignment);
 	if (unlikely(!node)) {
 		mutex_unlock(&dev->struct_mutex);
 		return -ENOMEM;
@@ -924,7 +924,7 @@ int drm_bo_mem_space(struct drm_buffer_object *bo,
 	int type_found = 0;
 	int type_ok = 0;
 	int has_eagain = 0;
-	struct drm_mm_node *node = NULL;
+	struct drm_memrange_node *node = NULL;
 	int ret;
 
 	mem->mm_node = NULL;
@@ -952,10 +952,10 @@ int drm_bo_mem_space(struct drm_buffer_object *bo,
 		mutex_lock(&dev->struct_mutex);
 		if (man->has_type && man->use_type) {
 			type_found = 1;
-			node = drm_mm_search_free(&man->manager, mem->num_pages,
+			node = drm_memrange_search_free(&man->manager, mem->num_pages,
 						  mem->page_alignment, 1);
 			if (node)
-				node = drm_mm_get_block(node, mem->num_pages,
+				node = drm_memrange_get_block(node, mem->num_pages,
 							mem->page_alignment);
 		}
 		mutex_unlock(&dev->struct_mutex);
@@ -1340,7 +1340,7 @@ out_unlock:
 	if (ret || !move_unfenced) {
 		if (mem.mm_node) {
 			if (mem.mm_node != bo->pinned_node)
-				drm_mm_put_block(mem.mm_node);
+				drm_memrange_put_block(mem.mm_node);
 			mem.mm_node = NULL;
 		}
 		drm_bo_add_to_lru(bo);
@@ -1432,7 +1432,7 @@ static int drm_buffer_object_validate(struct drm_buffer_object *bo,
 
 		if (bo->pinned_node != bo->mem.mm_node) {
 			if (bo->pinned_node != NULL)
-				drm_mm_put_block(bo->pinned_node);
+				drm_memrange_put_block(bo->pinned_node);
 			bo->pinned_node = bo->mem.mm_node;
 		}
 
@@ -1443,7 +1443,7 @@ static int drm_buffer_object_validate(struct drm_buffer_object *bo,
 		mutex_lock(&dev->struct_mutex);
 
 		if (bo->pinned_node != bo->mem.mm_node)
-			drm_mm_put_block(bo->pinned_node);
+			drm_memrange_put_block(bo->pinned_node);
 
 		list_del_init(&bo->pinned_lru);
 		bo->pinned_node = NULL;
@@ -2082,7 +2082,7 @@ static int drm_bo_leave_list(struct drm_buffer_object *bo,
 		if (bo->pinned_node == bo->mem.mm_node)
 			bo->pinned_node = NULL;
 		if (bo->pinned_node != NULL) {
-			drm_mm_put_block(bo->pinned_node);
+			drm_memrange_put_block(bo->pinned_node);
 			bo->pinned_node = NULL;
 		}
 		mutex_unlock(&dev->struct_mutex);
@@ -2223,8 +2223,8 @@ int drm_bo_clean_mm(struct drm_device *dev, unsigned mem_type, int kern_clean)
 		drm_bo_force_list_clean(dev, &man->lru, mem_type, 1, 0, 0);
 		drm_bo_force_list_clean(dev, &man->pinned, mem_type, 1, 0, 1);
 
-		if (drm_mm_clean(&man->manager)) {
-			drm_mm_takedown(&man->manager);
+		if (drm_memrange_clean(&man->manager)) {
+			drm_memrange_takedown(&man->manager);
 		} else {
 			ret = -EBUSY;
 		}
@@ -2295,7 +2295,7 @@ int drm_bo_init_mm(struct drm_device *dev, unsigned type,
 			DRM_ERROR("Zero size memory manager type %d\n", type);
 			return ret;
 		}
-		ret = drm_mm_init(&man->manager, p_offset, p_size);
+		ret = drm_memrange_init(&man->manager, p_offset, p_size);
 		if (ret)
 			return ret;
 	}
@@ -2713,7 +2713,7 @@ static void drm_bo_takedown_vm_locked(struct drm_buffer_object *bo)
 		list->user_token = 0;
 	}
 	if (list->file_offset_node) {
-		drm_mm_put_block(list->file_offset_node);
+		drm_memrange_put_block(list->file_offset_node);
 		list->file_offset_node = NULL;
 	}
 
@@ -2756,7 +2756,7 @@ static int drm_bo_setup_vm_locked(struct drm_buffer_object *bo)
 	atomic_inc(&bo->usage);
 	map->handle = (void *)bo;
 
-	list->file_offset_node = drm_mm_search_free(&dev->offset_manager,
+	list->file_offset_node = drm_memrange_search_free(&dev->offset_manager,
 						    bo->mem.num_pages, 0, 0);
 
 	if (unlikely(!list->file_offset_node)) {
@@ -2764,7 +2764,7 @@ static int drm_bo_setup_vm_locked(struct drm_buffer_object *bo)
 		return -ENOMEM;
 	}
 
-	list->file_offset_node = drm_mm_get_block(list->file_offset_node,
+	list->file_offset_node = drm_memrange_get_block(list->file_offset_node,
 						  bo->mem.num_pages, 0);
 
 	if (unlikely(!list->file_offset_node)) {
diff --git a/linux-core/drm_bo_move.c b/linux-core/drm_bo_move.c
index bf0e1b74..850be5a3 100644
--- a/linux-core/drm_bo_move.c
+++ b/linux-core/drm_bo_move.c
@@ -41,7 +41,7 @@ static void drm_bo_free_old_node(struct drm_buffer_object *bo)
 
 	if (old_mem->mm_node && (old_mem->mm_node != bo->pinned_node)) {
 		mutex_lock(&bo->dev->struct_mutex);
-		drm_mm_put_block(old_mem->mm_node);
+		drm_memrange_put_block(old_mem->mm_node);
 		mutex_unlock(&bo->dev->struct_mutex);
 	}
 	old_mem->mm_node = NULL;
diff --git a/linux-core/drm_drv.c b/linux-core/drm_drv.c
index b8b8333e..b5bd3616 100644
--- a/linux-core/drm_drv.c
+++ b/linux-core/drm_drv.c
@@ -415,7 +415,7 @@ static void drm_cleanup(struct drm_device * dev)
 
 	drm_ctxbitmap_cleanup(dev);
 	drm_ht_remove(&dev->map_hash);
-	drm_mm_takedown(&dev->offset_manager);
+	drm_memrange_takedown(&dev->offset_manager);
 	drm_ht_remove(&dev->object_hash);
 
 	drm_put_minor(&dev->primary);
diff --git a/linux-core/drm_mm.c b/linux-core/drm_memrange.c
index 59110293..0ae03655 100644
--- a/linux-core/drm_mm.c
+++ b/linux-core/drm_memrange.c
@@ -44,26 +44,26 @@
 #include "drmP.h"
 #include <linux/slab.h>
 
-unsigned long drm_mm_tail_space(struct drm_mm *mm)
+unsigned long drm_memrange_tail_space(struct drm_memrange *mm)
 {
 	struct list_head *tail_node;
-	struct drm_mm_node *entry;
+	struct drm_memrange_node *entry;
 
 	tail_node = mm->ml_entry.prev;
-	entry = list_entry(tail_node, struct drm_mm_node, ml_entry);
+	entry = list_entry(tail_node, struct drm_memrange_node, ml_entry);
 	if (!entry->free)
 		return 0;
 
 	return entry->size;
 }
 
-int drm_mm_remove_space_from_tail(struct drm_mm *mm, unsigned long size)
+int drm_memrange_remove_space_from_tail(struct drm_memrange *mm, unsigned long size)
 {
 	struct list_head *tail_node;
-	struct drm_mm_node *entry;
+	struct drm_memrange_node *entry;
 
 	tail_node = mm->ml_entry.prev;
-	entry = list_entry(tail_node, struct drm_mm_node, ml_entry);
+	entry = list_entry(tail_node, struct drm_memrange_node, ml_entry);
 	if (!entry->free)
 		return -ENOMEM;
 
@@ -75,13 +75,13 @@ int drm_mm_remove_space_from_tail(struct drm_mm *mm, unsigned long size)
 }
 
 
-static int drm_mm_create_tail_node(struct drm_mm *mm,
+static int drm_memrange_create_tail_node(struct drm_memrange *mm,
 			    unsigned long start,
 			    unsigned long size)
 {
-	struct drm_mm_node *child;
+	struct drm_memrange_node *child;
 
-	child = (struct drm_mm_node *)
+	child = (struct drm_memrange_node *)
 		drm_ctl_alloc(sizeof(*child), DRM_MEM_MM);
 	if (!child)
 		return -ENOMEM;
@@ -98,26 +98,26 @@ static int drm_mm_create_tail_node(struct drm_mm *mm,
 }
 
 
-int drm_mm_add_space_to_tail(struct drm_mm *mm, unsigned long size)
+int drm_memrange_add_space_to_tail(struct drm_memrange *mm, unsigned long size)
 {
 	struct list_head *tail_node;
-	struct drm_mm_node *entry;
+	struct drm_memrange_node *entry;
 
 	tail_node = mm->ml_entry.prev;
-	entry = list_entry(tail_node, struct drm_mm_node, ml_entry);
+	entry = list_entry(tail_node, struct drm_memrange_node, ml_entry);
 	if (!entry->free) {
-		return drm_mm_create_tail_node(mm, entry->start + entry->size, size);
+		return drm_memrange_create_tail_node(mm, entry->start + entry->size, size);
 	}
 	entry->size += size;
 	return 0;
 }
 
-static struct drm_mm_node *drm_mm_split_at_start(struct drm_mm_node *parent,
+static struct drm_memrange_node *drm_memrange_split_at_start(struct drm_memrange_node *parent,
 					    unsigned long size)
 {
-	struct drm_mm_node *child;
+	struct drm_memrange_node *child;
 
-	child = (struct drm_mm_node *)
+	child = (struct drm_memrange_node *)
 		drm_ctl_alloc(sizeof(*child), DRM_MEM_MM);
 	if (!child)
 		return NULL;
@@ -137,19 +137,19 @@ static struct drm_mm_node *drm_mm_split_at_start(struct drm_mm_node *parent,
 	return child;
 }
 
-struct drm_mm_node *drm_mm_get_block(struct drm_mm_node * parent,
+struct drm_memrange_node *drm_memrange_get_block(struct drm_memrange_node * parent,
 				unsigned long size, unsigned alignment)
 {
 
-	struct drm_mm_node *align_splitoff = NULL;
-	struct drm_mm_node *child;
+	struct drm_memrange_node *align_splitoff = NULL;
+	struct drm_memrange_node *child;
 	unsigned tmp = 0;
 
 	if (alignment)
 		tmp = parent->start % alignment;
 
 	if (tmp) {
-		align_splitoff = drm_mm_split_at_start(parent, alignment - tmp);
+		align_splitoff = drm_memrange_split_at_start(parent, alignment - tmp);
 		if (!align_splitoff)
 			return NULL;
 	}
@@ -159,11 +159,11 @@ struct drm_mm_node *drm_mm_get_block(struct drm_mm_node * parent,
 		parent->free = 0;
 		return parent;
 	} else {
-		child = drm_mm_split_at_start(parent, size);
+		child = drm_memrange_split_at_start(parent, size);
 	}
 
 	if (align_splitoff)
-		drm_mm_put_block(align_splitoff);
+		drm_memrange_put_block(align_splitoff);
 
 	return child;
 }
@@ -173,26 +173,26 @@ struct drm_mm_node *drm_mm_get_block(struct drm_mm_node * parent,
  * Otherwise add to the free stack.
  */
 
-void drm_mm_put_block(struct drm_mm_node * cur)
+void drm_memrange_put_block(struct drm_memrange_node * cur)
 {
 
-	struct drm_mm *mm = cur->mm;
+	struct drm_memrange *mm = cur->mm;
 	struct list_head *cur_head = &cur->ml_entry;
 	struct list_head *root_head = &mm->ml_entry;
-	struct drm_mm_node *prev_node = NULL;
-	struct drm_mm_node *next_node;
+	struct drm_memrange_node *prev_node = NULL;
+	struct drm_memrange_node *next_node;
 
 	int merged = 0;
 
 	if (cur_head->prev != root_head) {
-		prev_node = list_entry(cur_head->prev, struct drm_mm_node, ml_entry);
+		prev_node = list_entry(cur_head->prev, struct drm_memrange_node, ml_entry);
 		if (prev_node->free) {
 			prev_node->size += cur->size;
 			merged = 1;
 		}
 	}
 	if (cur_head->next != root_head) {
-		next_node = list_entry(cur_head->next, struct drm_mm_node, ml_entry);
+		next_node = list_entry(cur_head->next, struct drm_memrange_node, ml_entry);
 		if (next_node->free) {
 			if (merged) {
 				prev_node->size += next_node->size;
@@ -215,16 +215,16 @@ void drm_mm_put_block(struct drm_mm_node * cur)
 		drm_ctl_free(cur, sizeof(*cur), DRM_MEM_MM);
 	}
 }
-EXPORT_SYMBOL(drm_mm_put_block);
+EXPORT_SYMBOL(drm_memrange_put_block);
 
-struct drm_mm_node *drm_mm_search_free(const struct drm_mm * mm,
+struct drm_memrange_node *drm_memrange_search_free(const struct drm_memrange * mm,
 				  unsigned long size,
 				  unsigned alignment, 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;
+	struct drm_memrange_node *entry;
+	struct drm_memrange_node *best;
 	unsigned long best_size;
 	unsigned wasted;
 
@@ -232,7 +232,7 @@ struct drm_mm_node *drm_mm_search_free(const struct drm_mm * mm,
 	best_size = ~0UL;
 
 	list_for_each(list, free_stack) {
-		entry = list_entry(list, struct drm_mm_node, fl_entry);
+		entry = list_entry(list, struct drm_memrange_node, fl_entry);
 		wasted = 0;
 
 		if (entry->size < size)
@@ -258,29 +258,29 @@ struct drm_mm_node *drm_mm_search_free(const struct drm_mm * mm,
 	return best;
 }
 
-int drm_mm_clean(struct drm_mm * mm)
+int drm_memrange_clean(struct drm_memrange * mm)
 {
 	struct list_head *head = &mm->ml_entry;
 
 	return (head->next->next == head);
 }
 
-int drm_mm_init(struct drm_mm * mm, unsigned long start, unsigned long size)
+int drm_memrange_init(struct drm_memrange * mm, unsigned long start, unsigned long size)
 {
 	INIT_LIST_HEAD(&mm->ml_entry);
 	INIT_LIST_HEAD(&mm->fl_entry);
 
-	return drm_mm_create_tail_node(mm, start, size);
+	return drm_memrange_create_tail_node(mm, start, size);
 }
 
-EXPORT_SYMBOL(drm_mm_init);
+EXPORT_SYMBOL(drm_memrange_init);
 
-void drm_mm_takedown(struct drm_mm * mm)
+void drm_memrange_takedown(struct drm_memrange * mm)
 {
 	struct list_head *bnode = mm->fl_entry.next;
-	struct drm_mm_node *entry;
+	struct drm_memrange_node *entry;
 
-	entry = list_entry(bnode, struct drm_mm_node, fl_entry);
+	entry = list_entry(bnode, struct drm_memrange_node, fl_entry);
 
 	if (entry->ml_entry.next != &mm->ml_entry ||
 	    entry->fl_entry.next != &mm->fl_entry) {
@@ -293,4 +293,4 @@ void drm_mm_takedown(struct drm_mm * mm)
 	drm_ctl_free(entry, sizeof(*entry), DRM_MEM_MM);
 }
 
-EXPORT_SYMBOL(drm_mm_takedown);
+EXPORT_SYMBOL(drm_memrange_takedown);
diff --git a/linux-core/drm_objects.h b/linux-core/drm_objects.h
index 6a900612..6ec09ef8 100644
--- a/linux-core/drm_objects.h
+++ b/linux-core/drm_objects.h
@@ -418,7 +418,7 @@ extern int drm_ttm_destroy(struct drm_ttm *ttm);
  */
 
 struct drm_bo_mem_reg {
-	struct drm_mm_node *mm_node;
+	struct drm_memrange_node *mm_node;
 	unsigned long size;
 	unsigned long num_pages;
 	uint32_t page_alignment;
@@ -499,7 +499,7 @@ struct drm_buffer_object {
 	unsigned long num_pages;
 
 	/* For pinned buffers */
-	struct drm_mm_node *pinned_node;
+	struct drm_memrange_node *pinned_node;
 	uint32_t pinned_mem_type;
 	struct list_head pinned_lru;
 
@@ -534,7 +534,7 @@ struct drm_mem_type_manager {
 	int has_type;
 	int use_type;
 	int kern_init_type;
-	struct drm_mm manager;
+	struct drm_memrange manager;
 	struct list_head lru;
 	struct list_head pinned;
 	uint32_t flags;
diff --git a/linux-core/drm_sman.c b/linux-core/drm_sman.c
index 8421a939..7c16f685 100644
--- a/linux-core/drm_sman.c
+++ b/linux-core/drm_sman.c
@@ -88,34 +88,34 @@ EXPORT_SYMBOL(drm_sman_init);
 static void *drm_sman_mm_allocate(void *private, unsigned long size,
 				  unsigned alignment)
 {
-	struct drm_mm *mm = (struct drm_mm *) private;
-	struct drm_mm_node *tmp;
+	struct drm_memrange *mm = (struct drm_memrange *) private;
+	struct drm_memrange_node *tmp;
 
-	tmp = drm_mm_search_free(mm, size, alignment, 1);
+	tmp = drm_memrange_search_free(mm, size, alignment, 1);
 	if (!tmp) {
 		return NULL;
 	}
-	tmp = drm_mm_get_block(tmp, size, alignment);
+	tmp = drm_memrange_get_block(tmp, size, alignment);
 	return tmp;
 }
 
 static void drm_sman_mm_free(void *private, void *ref)
 {
-	struct drm_mm_node *node = (struct drm_mm_node *) ref;
+	struct drm_memrange_node *node = (struct drm_memrange_node *) ref;
 
-	drm_mm_put_block(node);
+	drm_memrange_put_block(node);
 }
 
 static void drm_sman_mm_destroy(void *private)
 {
-	struct drm_mm *mm = (struct drm_mm *) private;
-	drm_mm_takedown(mm);
+	struct drm_memrange *mm = (struct drm_memrange *) private;
+	drm_memrange_takedown(mm);
 	drm_free(mm, sizeof(*mm), DRM_MEM_MM);
 }
 
 static unsigned long drm_sman_mm_offset(void *private, void *ref)
 {
-	struct drm_mm_node *node = (struct drm_mm_node *) ref;
+	struct drm_memrange_node *node = (struct drm_memrange_node *) ref;
 	return node->start;
 }
 
@@ -124,7 +124,7 @@ drm_sman_set_range(struct drm_sman * sman, unsigned int manager,
 		   unsigned long start, unsigned long size)
 {
 	struct drm_sman_mm *sman_mm;
-	struct drm_mm *mm;
+	struct drm_memrange *mm;
 	int ret;
 
 	BUG_ON(manager >= sman->num_managers);
@@ -135,7 +135,7 @@ drm_sman_set_range(struct drm_sman * sman, unsigned int manager,
 		return -ENOMEM;
 	}
 	sman_mm->private = mm;
-	ret = drm_mm_init(mm, start, size);
+	ret = drm_memrange_init(mm, start, size);
 
 	if (ret) {
 		drm_free(mm, sizeof(*mm), DRM_MEM_MM);
diff --git a/linux-core/drm_sman.h b/linux-core/drm_sman.h
index 39a39fef..0299776c 100644
--- a/linux-core/drm_sman.h
+++ b/linux-core/drm_sman.h
@@ -45,7 +45,7 @@
 /*
  * A class that is an abstration of a simple memory allocator.
  * The sman implementation provides a default such allocator
- * using the drm_mm.c implementation. But the user can replace it.
+ * using the drm_memrange.c implementation. But the user can replace it.
  * See the SiS implementation, which may use the SiS FB kernel module
  * for memory management.
  */
@@ -116,7 +116,7 @@ extern int drm_sman_init(struct drm_sman * sman, unsigned int num_managers,
 			 unsigned int user_order, unsigned int owner_order);
 
 /*
- * Initialize a drm_mm.c allocator. Should be called only once for each
+ * Initialize a drm_memrange.c allocator. Should be called only once for each
  * manager unless a customized allogator is used.
  */
 
diff --git a/linux-core/drm_stub.c b/linux-core/drm_stub.c
index c68adbaf..030fea54 100644
--- a/linux-core/drm_stub.c
+++ b/linux-core/drm_stub.c
@@ -115,15 +115,15 @@ static int drm_fill_in_dev(struct drm_device * dev, struct pci_dev *pdev,
 	if (drm_ht_create(&dev->map_hash, DRM_MAP_HASH_ORDER)) {
 		return -ENOMEM;
 	}
-	if (drm_mm_init(&dev->offset_manager, DRM_FILE_PAGE_OFFSET_START,
-			DRM_FILE_PAGE_OFFSET_SIZE)) {
+	if (drm_memrange_init(&dev->offset_manager, DRM_FILE_PAGE_OFFSET_START,
+			      DRM_FILE_PAGE_OFFSET_SIZE)) {
 		drm_ht_remove(&dev->map_hash);
 		return -ENOMEM;
 	}
 
 	if (drm_ht_create(&dev->object_hash, DRM_OBJECT_HASH_ORDER)) {
 		drm_ht_remove(&dev->map_hash);
-		drm_mm_takedown(&dev->offset_manager);
+		drm_memrange_takedown(&dev->offset_manager);
 		return -ENOMEM;
 	}
 
diff --git a/linux-core/nouveau_bo.c b/linux-core/nouveau_bo.c
index ab3b23a4..86347e03 100644
--- a/linux-core/nouveau_bo.c
+++ b/linux-core/nouveau_bo.c
@@ -229,7 +229,7 @@ out_cleanup:
         if (tmp_mem.mm_node) {
                 mutex_lock(&dev->struct_mutex);
                 if (tmp_mem.mm_node != bo->pinned_node)
-                        drm_mm_put_block(tmp_mem.mm_node);
+                        drm_memrange_put_block(tmp_mem.mm_node);
                 tmp_mem.mm_node = NULL;
                 mutex_unlock(&dev->struct_mutex);
         }
diff --git a/linux-core/nouveau_sgdma.c b/linux-core/nouveau_sgdma.c
index cc4d5a92..81704ea1 100644
--- a/linux-core/nouveau_sgdma.c
+++ b/linux-core/nouveau_sgdma.c
@@ -280,7 +280,7 @@ nouveau_sgdma_nottm_hack_init(struct drm_device *dev)
 	struct drm_nouveau_private *dev_priv = dev->dev_private;
 	struct drm_ttm_backend *be;
 	struct drm_scatter_gather sgreq;
-	struct drm_mm_node mm_node;
+	struct drm_memrange_node mm_node;
 	struct drm_bo_mem_reg mem;
 	int ret;