drm: Strip old ttm.

Signed-off-by: Thomas Hellstrom <thellstrom-at-vmware-dot-com>

23 files changed, 4 insertions, 7115 deletions

diff --git a/linux-core/Makefile b/linux-core/Makefile
index 9257a49b..591b6cfa 100644
--- a/linux-core/Makefile
+++ b/linux-core/Makefile
@@ -58,7 +58,7 @@ endif
 
 # Modules for all architectures
 MODULE_LIST := drm.o tdfx.o r128.o radeon.o mga.o sis.o savage.o via.o \
-               mach64.o nouveau.o xgi.o
+               mach64.o xgi.o
 
 # Modules only for ix86 architectures
 ifneq (,$(findstring 86,$(MACHINE)))
diff --git a/linux-core/Makefile.kernel b/linux-core/Makefile.kernel
index 0bea35dd..e83f15c7 100644
--- a/linux-core/Makefile.kernel
+++ b/linux-core/Makefile.kernel
@@ -12,9 +12,8 @@ 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_fence.o drm_ttm.o drm_bo.o drm_bo_move.o drm_bo_lock.o \
-		drm_regman.o drm_vm_nopage_compat.o drm_gem.o
+		drm_hashtab.o drm_mm.o drm_compat.o \
+	        drm_vm_nopage_compat.o drm_gem.o
 tdfx-objs   := tdfx_drv.o
 r128-objs   := r128_drv.o r128_cce.o r128_state.o r128_irq.o
 mga-objs    := mga_drv.o mga_dma.o mga_state.o mga_warp.o mga_irq.o
@@ -35,7 +34,7 @@ sis-objs    := sis_drv.o sis_mm.o
 ffb-objs    := ffb_drv.o ffb_context.o
 savage-objs := savage_drv.o savage_bci.o savage_state.o
 via-objs    := via_irq.o via_drv.o via_map.o via_mm.o via_dma.o via_verifier.o \
-		via_video.o via_dmablit.o via_fence.o via_buffer.o
+		via_video.o via_dmablit.o
 mach64-objs := mach64_drv.o mach64_dma.o mach64_irq.o mach64_state.o
 xgi-objs    := xgi_cmdlist.o xgi_drv.o xgi_fb.o xgi_misc.o xgi_pcie.o \
 		xgi_fence.o
diff --git a/linux-core/drmP.h b/linux-core/drmP.h
index 67702825..9b4b071c 100644
--- a/linux-core/drmP.h
+++ b/linux-core/drmP.h
@@ -155,8 +155,6 @@ typedef unsigned long uintptr_t;
 #define DRM_MEM_MM        22
 #define DRM_MEM_HASHTAB   23
 #define DRM_MEM_OBJECTS   24
-#define DRM_MEM_FENCE     25
-#define DRM_MEM_TTM       26
 #define DRM_MEM_BUFOBJ    27
 
 #define DRM_MAX_CTXBITMAP (PAGE_SIZE * 8)
@@ -660,8 +658,6 @@ struct drm_gem_object {
 	void *driver_private;
 };
 
-#include "drm_objects.h"
-
 /**
  * DRM driver structure. This structure represent the common code for
  * a family of cards. There will one drm_device for each card present
@@ -855,10 +851,6 @@ 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_open_hash object_hash;    /**< User token hash table for objects */
-	struct address_space *dev_mapping;  /**< For unmap_mapping_range() */
-	struct page *ttm_dummy_page;
 
 	/** \name Context handle management */
 	/*@{ */
@@ -953,9 +945,6 @@ struct drm_device {
 	unsigned int agp_buffer_token;
 	struct drm_minor *primary;		/**< render type primary screen head */
 
-	struct drm_fence_manager fm;
-	struct drm_buffer_manager bm;
-
 	/** \name Drawable information */
 	/*@{ */
 	spinlock_t drw_lock;
@@ -978,15 +967,6 @@ struct drm_device {
 	/*@} */
 };
 
-#if __OS_HAS_AGP
-struct drm_agp_ttm_backend {
-	struct drm_ttm_backend backend;
-	DRM_AGP_MEM *mem;
-	struct agp_bridge_data *bridge;
-	int populated;
-};
-#endif
-
 
 static __inline__ int drm_core_check_feature(struct drm_device *dev,
 					     int feature)
@@ -1279,7 +1259,6 @@ extern DRM_AGP_MEM *drm_agp_allocate_memory(struct agp_bridge_data *bridge, size
 extern int drm_agp_free_memory(DRM_AGP_MEM * handle);
 extern int drm_agp_bind_memory(DRM_AGP_MEM * handle, off_t start);
 extern int drm_agp_unbind_memory(DRM_AGP_MEM * handle);
-extern struct drm_ttm_backend *drm_agp_init_ttm(struct drm_device *dev);
 extern void drm_agp_chipset_flush(struct drm_device *dev);
 				/* Stub support (drm_stub.h) */
 extern int drm_get_dev(struct pci_dev *pdev, const struct pci_device_id *ent,
diff --git a/linux-core/drm_agpsupport.c b/linux-core/drm_agpsupport.c
index 2abfac6e..9f746a32 100644
--- a/linux-core/drm_agpsupport.c
+++ b/linux-core/drm_agpsupport.c
@@ -498,177 +498,6 @@ drm_agp_bind_pages(struct drm_device *dev,
 }
 EXPORT_SYMBOL(drm_agp_bind_pages);
 
-/*
- * AGP ttm backend interface.
- */
-
-#ifndef AGP_USER_TYPES
-#define AGP_USER_TYPES (1 << 16)
-#define AGP_USER_MEMORY (AGP_USER_TYPES)
-#define AGP_USER_CACHED_MEMORY (AGP_USER_TYPES + 1)
-#endif
-#define AGP_REQUIRED_MAJOR 0
-#define AGP_REQUIRED_MINOR 102
-
-static int drm_agp_needs_unbind_cache_adjust(struct drm_ttm_backend *backend)
-{
-	return ((backend->flags & DRM_BE_FLAG_BOUND_CACHED) ? 0 : 1);
-}
-
-
-static int drm_agp_populate(struct drm_ttm_backend *backend,
-			    unsigned long num_pages, struct page **pages,
-			    struct page *dummy_read_page)
-{
-	struct drm_agp_ttm_backend *agp_be =
-		container_of(backend, struct drm_agp_ttm_backend, backend);
-	struct page **cur_page, **last_page = pages + num_pages;
-	DRM_AGP_MEM *mem;
-	int dummy_page_count = 0;
-
-	if (drm_alloc_memctl(num_pages * sizeof(void *)))
-		return -1;
-
-	DRM_DEBUG("drm_agp_populate_ttm\n");
-	mem = drm_agp_allocate_memory(agp_be->bridge, num_pages, AGP_USER_MEMORY);
-	if (!mem) {
-		drm_free_memctl(num_pages * sizeof(void *));
-		return -1;
-	}
-
-	DRM_DEBUG("Current page count is %ld\n", (long) mem->page_count);
-	mem->page_count = 0;
-	for (cur_page = pages; cur_page < last_page; ++cur_page) {
-		struct page *page = *cur_page;
-		if (!page) {
-			page = dummy_read_page;
-			++dummy_page_count;
-		}
-		mem->memory[mem->page_count++] = phys_to_gart(page_to_phys(page));
-	}
-	if (dummy_page_count)
-		DRM_DEBUG("Mapped %d dummy pages\n", dummy_page_count);
-	agp_be->mem = mem;
-	return 0;
-}
-
-static int drm_agp_bind_ttm(struct drm_ttm_backend *backend,
-			    struct drm_bo_mem_reg *bo_mem)
-{
-	struct drm_agp_ttm_backend *agp_be =
-		container_of(backend, struct drm_agp_ttm_backend, backend);
-	DRM_AGP_MEM *mem = agp_be->mem;
-	int ret;
-	int snooped = (bo_mem->flags & DRM_BO_FLAG_CACHED) && !(bo_mem->flags & DRM_BO_FLAG_CACHED_MAPPED);
-
-	DRM_DEBUG("drm_agp_bind_ttm\n");
-	mem->is_flushed = true;
-	mem->type = AGP_USER_MEMORY;
-	/* CACHED MAPPED implies not snooped memory */
-	if (snooped)
-		mem->type = AGP_USER_CACHED_MEMORY;
-
-	ret = drm_agp_bind_memory(mem, bo_mem->mm_node->start);
-	if (ret)
-		DRM_ERROR("AGP Bind memory failed\n");
-
-	DRM_FLAG_MASKED(backend->flags, (bo_mem->flags & DRM_BO_FLAG_CACHED) ?
-			DRM_BE_FLAG_BOUND_CACHED : 0,
-			DRM_BE_FLAG_BOUND_CACHED);
-	return ret;
-}
-
-static int drm_agp_unbind_ttm(struct drm_ttm_backend *backend)
-{
-	struct drm_agp_ttm_backend *agp_be =
-		container_of(backend, struct drm_agp_ttm_backend, backend);
-
-	DRM_DEBUG("drm_agp_unbind_ttm\n");
-	if (agp_be->mem->is_bound)
-		return drm_agp_unbind_memory(agp_be->mem);
-	else
-		return 0;
-}
-
-static void drm_agp_clear_ttm(struct drm_ttm_backend *backend)
-{
-	struct drm_agp_ttm_backend *agp_be =
-		container_of(backend, struct drm_agp_ttm_backend, backend);
-	DRM_AGP_MEM *mem = agp_be->mem;
-
-	DRM_DEBUG("drm_agp_clear_ttm\n");
-	if (mem) {
-		unsigned long num_pages = mem->page_count;
-		backend->func->unbind(backend);
-		agp_free_memory(mem);
-		drm_free_memctl(num_pages * sizeof(void *));
-	}
-	agp_be->mem = NULL;
-}
-
-static void drm_agp_destroy_ttm(struct drm_ttm_backend *backend)
-{
-	struct drm_agp_ttm_backend *agp_be;
-
-	if (backend) {
-		DRM_DEBUG("drm_agp_destroy_ttm\n");
-		agp_be = container_of(backend, struct drm_agp_ttm_backend, backend);
-		if (agp_be) {
-			if (agp_be->mem)
-				backend->func->clear(backend);
-			drm_ctl_free(agp_be, sizeof(*agp_be), DRM_MEM_TTM);
-		}
-	}
-}
-
-static struct drm_ttm_backend_func agp_ttm_backend = {
-	.needs_ub_cache_adjust = drm_agp_needs_unbind_cache_adjust,
-	.populate = drm_agp_populate,
-	.clear = drm_agp_clear_ttm,
-	.bind = drm_agp_bind_ttm,
-	.unbind = drm_agp_unbind_ttm,
-	.destroy =  drm_agp_destroy_ttm,
-};
-
-struct drm_ttm_backend *drm_agp_init_ttm(struct drm_device *dev)
-{
-
-	struct drm_agp_ttm_backend *agp_be;
-	struct agp_kern_info *info;
-
-	if (!dev->agp) {
-		DRM_ERROR("AGP is not initialized.\n");
-		return NULL;
-	}
-	info = &dev->agp->agp_info;
-
-	if (info->version.major != AGP_REQUIRED_MAJOR ||
-	    info->version.minor < AGP_REQUIRED_MINOR) {
-		DRM_ERROR("Wrong agpgart version %d.%d\n"
-			  "\tYou need at least version %d.%d.\n",
-			  info->version.major,
-			  info->version.minor,
-			  AGP_REQUIRED_MAJOR,
-			  AGP_REQUIRED_MINOR);
-		return NULL;
-	}
-
-
-	agp_be = drm_ctl_calloc(1, sizeof(*agp_be), DRM_MEM_TTM);
-	if (!agp_be)
-		return NULL;
-
-	agp_be->mem = NULL;
-
-	agp_be->bridge = dev->agp->bridge;
-	agp_be->populated = false;
-	agp_be->backend.func = &agp_ttm_backend;
-	agp_be->backend.dev = dev;
-
-	return &agp_be->backend;
-}
-EXPORT_SYMBOL(drm_agp_init_ttm);
-
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25)
 void drm_agp_chipset_flush(struct drm_device *dev)
 {
diff --git a/linux-core/drm_bo.c b/linux-core/drm_bo.c
deleted file mode 100644
index f43480c5..00000000
--- a/linux-core/drm_bo.c
+++ /dev/null
@@ -1,2730 +0,0 @@
-/**************************************************************************
- *
- * Copyright (c) 2006-2007 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 Hellström <thomas-at-tungstengraphics-dot-com>
- */
-
-#include "drmP.h"
-
-/*
- * Locking may look a bit complicated but isn't really:
- *
- * The buffer usage atomic_t needs to be protected by dev->struct_mutex
- * when there is a chance that it can be zero before or after the operation.
- *
- * dev->struct_mutex also protects all lists and list heads,
- * Hash tables and hash heads.
- *
- * bo->mutex protects the buffer object itself excluding the usage field.
- * bo->mutex does also protect the buffer list heads, so to manipulate those,
- * we need both the bo->mutex and the dev->struct_mutex.
- *
- * Locking order is bo->mutex, dev->struct_mutex. Therefore list traversal
- * is a bit complicated. When dev->struct_mutex is released to grab bo->mutex,
- * the list traversal will, in general, need to be restarted.
- *
- */
-
-static void drm_bo_destroy_locked(struct drm_buffer_object *bo);
-static int drm_bo_setup_vm_locked(struct drm_buffer_object *bo);
-static void drm_bo_takedown_vm_locked(struct drm_buffer_object *bo);
-static void drm_bo_unmap_virtual(struct drm_buffer_object *bo);
-
-static inline uint64_t drm_bo_type_flags(unsigned type)
-{
-	return (1ULL << (24 + type));
-}
-
-/*
- * bo locked. dev->struct_mutex locked.
- */
-
-void drm_bo_add_to_pinned_lru(struct drm_buffer_object *bo)
-{
-	struct drm_mem_type_manager *man;
-
-	DRM_ASSERT_LOCKED(&bo->dev->struct_mutex);
-	DRM_ASSERT_LOCKED(&bo->mutex);
-
-	man = &bo->dev->bm.man[bo->pinned_mem_type];
-	list_add_tail(&bo->pinned_lru, &man->pinned);
-}
-
-void drm_bo_add_to_lru(struct drm_buffer_object *bo)
-{
-	struct drm_mem_type_manager *man;
-
-	DRM_ASSERT_LOCKED(&bo->dev->struct_mutex);
-
-	if (!(bo->mem.proposed_flags & (DRM_BO_FLAG_NO_MOVE | DRM_BO_FLAG_NO_EVICT))
-	    || bo->mem.mem_type != bo->pinned_mem_type) {
-		man = &bo->dev->bm.man[bo->mem.mem_type];
-		list_add_tail(&bo->lru, &man->lru);
-	} else {
-		INIT_LIST_HEAD(&bo->lru);
-	}
-}
-
-static int drm_bo_vm_pre_move(struct drm_buffer_object *bo, int old_is_pci)
-{
-	if (!bo->map_list.map)
-		return 0;
-
-	drm_bo_unmap_virtual(bo);
-	return 0;
-}
-
-/*
- * Call bo->mutex locked.
- */
-
-static int drm_bo_add_ttm(struct drm_buffer_object *bo)
-{
-	struct drm_device *dev = bo->dev;
-	int ret = 0;
-	uint32_t page_flags = 0;
-
-	DRM_ASSERT_LOCKED(&bo->mutex);
-	bo->ttm = NULL;
-
-	if (bo->mem.proposed_flags & DRM_BO_FLAG_WRITE)
-		page_flags |= DRM_TTM_PAGE_WRITE;
-
-	switch (bo->type) {
-	case drm_bo_type_device:
-	case drm_bo_type_kernel:
-		bo->ttm = drm_ttm_create(dev, bo->num_pages << PAGE_SHIFT, 
-					 page_flags, dev->bm.dummy_read_page);
-		if (!bo->ttm)
-			ret = -ENOMEM;
-		break;
-	case drm_bo_type_user:
-		bo->ttm = drm_ttm_create(dev, bo->num_pages << PAGE_SHIFT,
-					 page_flags | DRM_TTM_PAGE_USER,
-					 dev->bm.dummy_read_page);
-		if (!bo->ttm)
-			ret = -ENOMEM;
-
-		ret = drm_ttm_set_user(bo->ttm, current,
-				       bo->buffer_start,
-				       bo->num_pages);
-		if (ret)
-			return ret;
-
-		break;
-	default:
-		DRM_ERROR("Illegal buffer object type\n");
-		ret = -EINVAL;
-		break;
-	}
-
-	return ret;
-}
-
-static int drm_bo_handle_move_mem(struct drm_buffer_object *bo,
-				  struct drm_bo_mem_reg *mem,
-				  int evict, int no_wait)
-{
-	struct drm_device *dev = bo->dev;
-	struct drm_buffer_manager *bm = &dev->bm;
-	int old_is_pci = drm_mem_reg_is_pci(dev, &bo->mem);
-	int new_is_pci = drm_mem_reg_is_pci(dev, mem);
-	struct drm_mem_type_manager *old_man = &bm->man[bo->mem.mem_type];
-	struct drm_mem_type_manager *new_man = &bm->man[mem->mem_type];
-	int ret = 0;
-
-	if (old_is_pci || new_is_pci ||
-	    ((mem->flags ^ bo->mem.flags) & DRM_BO_FLAG_CACHED))
-		ret = drm_bo_vm_pre_move(bo, old_is_pci);
-	if (ret)
-		return ret;
-
-	/*
-	 * Create and bind a ttm if required.
-	 */
-
-	if (!(new_man->flags & _DRM_FLAG_MEMTYPE_FIXED) && (bo->ttm == NULL)) {
-		ret = drm_bo_add_ttm(bo);
-		if (ret)
-			goto out_err;
-
-		if (mem->mem_type != DRM_BO_MEM_LOCAL) {
-			ret = drm_ttm_bind(bo->ttm, mem);
-			if (ret)
-				goto out_err;
-		}
-
-		if (bo->mem.mem_type == DRM_BO_MEM_LOCAL) {
-			
-			struct drm_bo_mem_reg *old_mem = &bo->mem;
-			uint64_t save_flags = old_mem->flags;
-			uint64_t save_proposed_flags = old_mem->proposed_flags;
-			
-			*old_mem = *mem;
-			mem->mm_node = NULL;
-			old_mem->proposed_flags = save_proposed_flags;
-			DRM_FLAG_MASKED(save_flags, mem->flags,
-					DRM_BO_MASK_MEMTYPE);
-			goto moved;
-		}
-		
-	}
-
-	if (!(old_man->flags & _DRM_FLAG_MEMTYPE_FIXED) &&
-	    !(new_man->flags & _DRM_FLAG_MEMTYPE_FIXED))		
-		ret = drm_bo_move_ttm(bo, evict, no_wait, mem);
-	else if (dev->driver->bo_driver->move) 
-		ret = dev->driver->bo_driver->move(bo, evict, no_wait, mem);
-	else
-		ret = drm_bo_move_memcpy(bo, evict, no_wait, mem);
-
-	if (ret)
-		goto out_err;
-
-moved:
-	if (bo->priv_flags & _DRM_BO_FLAG_EVICTED) {
-		ret =
-		    dev->driver->bo_driver->invalidate_caches(dev,
-							      bo->mem.flags);
-		if (ret)
-			DRM_ERROR("Can not flush read caches\n");
-	}
-
-	DRM_FLAG_MASKED(bo->priv_flags,
-			(evict) ? _DRM_BO_FLAG_EVICTED : 0,
-			_DRM_BO_FLAG_EVICTED);
-
-	if (bo->mem.mm_node)
-		bo->offset = (bo->mem.mm_node->start << PAGE_SHIFT) +
-			bm->man[bo->mem.mem_type].gpu_offset;
-
-
-	return 0;
-
-out_err:
-	new_man = &bm->man[bo->mem.mem_type];
-	if ((new_man->flags & _DRM_FLAG_MEMTYPE_FIXED) && bo->ttm) {
-		drm_ttm_unbind(bo->ttm);
-		drm_ttm_destroy(bo->ttm);
-		bo->ttm = NULL;
-	}
-
-	return ret;
-}
-
-/*
- * Call bo->mutex locked.
- * Returns -EBUSY if the buffer is currently rendered to or from. 0 otherwise.
- */
-
-static int drm_bo_busy(struct drm_buffer_object *bo, int check_unfenced)
-{
-	struct drm_fence_object *fence = bo->fence;
-
-	if (check_unfenced && (bo->priv_flags & _DRM_BO_FLAG_UNFENCED))
-		return -EBUSY;
-
-	if (fence) {
-		if (drm_fence_object_signaled(fence, bo->fence_type)) {
-			drm_fence_usage_deref_unlocked(&bo->fence);
-			return 0;
-		}
-		drm_fence_object_flush(fence, DRM_FENCE_TYPE_EXE);
-		if (drm_fence_object_signaled(fence, bo->fence_type)) {
-			drm_fence_usage_deref_unlocked(&bo->fence);
-			return 0;
-		}
-		return -EBUSY;
-	}
-	return 0;
-}
-
-static int drm_bo_check_unfenced(struct drm_buffer_object *bo)
-{
-	int ret;
-
-	mutex_lock(&bo->mutex);
-	ret = (bo->priv_flags & _DRM_BO_FLAG_UNFENCED);
-	mutex_unlock(&bo->mutex);
-	return ret;
-}
-
-
-/*
- * Call bo->mutex locked.
- * Wait until the buffer is idle.
- */
-
-int drm_bo_wait(struct drm_buffer_object *bo, int lazy, int interruptible,
-		int no_wait, int check_unfenced)
-{
-	int ret;
-
-	DRM_ASSERT_LOCKED(&bo->mutex);
-	while(unlikely(drm_bo_busy(bo, check_unfenced))) {
-		if (no_wait)
-			return -EBUSY;
-
-		if (check_unfenced &&  (bo->priv_flags & _DRM_BO_FLAG_UNFENCED)) {
-			mutex_unlock(&bo->mutex);
-			wait_event(bo->event_queue, !drm_bo_check_unfenced(bo));
-			mutex_lock(&bo->mutex);
-			bo->priv_flags |= _DRM_BO_FLAG_UNLOCKED;
-		}
-
-		if (bo->fence) {
-			struct drm_fence_object *fence;
-			uint32_t fence_type = bo->fence_type;
-
-			drm_fence_reference_unlocked(&fence, bo->fence);
-			mutex_unlock(&bo->mutex);
-
-			ret = drm_fence_object_wait(fence, lazy, !interruptible,
-						    fence_type);
-
-			drm_fence_usage_deref_unlocked(&fence);
-			mutex_lock(&bo->mutex);
-			bo->priv_flags |= _DRM_BO_FLAG_UNLOCKED;
-			if (ret)
-				return ret;
-		}
-
-	}
-	return 0;
-}
-EXPORT_SYMBOL(drm_bo_wait);
-
-static int drm_bo_expire_fence(struct drm_buffer_object *bo, int allow_errors)
-{
-	struct drm_device *dev = bo->dev;
-	struct drm_buffer_manager *bm = &dev->bm;
-
-	if (bo->fence) {
-		if (bm->nice_mode) {
-			unsigned long _end = jiffies + 3 * DRM_HZ;
-			int ret;
-			do {
-				ret = drm_bo_wait(bo, 0, 0, 0, 0);
-				if (ret && allow_errors)
-					return ret;
-
-			} while (ret && !time_after_eq(jiffies, _end));
-
-			if (bo->fence) {
-				bm->nice_mode = 0;
-				DRM_ERROR("Detected GPU lockup or "
-					  "fence driver was taken down. "
-					  "Evicting buffer.\n");
-			}
-		}
-		if (bo->fence)
-			drm_fence_usage_deref_unlocked(&bo->fence);
-	}
-	return 0;
-}
-
-/*
- * Call dev->struct_mutex locked.
- * Attempts to remove all private references to a buffer by expiring its
- * fence object and removing from lru lists and memory managers.
- */
-
-static void drm_bo_cleanup_refs(struct drm_buffer_object *bo, int remove_all)
-{
-	struct drm_device *dev = bo->dev;
-	struct drm_buffer_manager *bm = &dev->bm;
-
-	DRM_ASSERT_LOCKED(&dev->struct_mutex);
-
-	atomic_inc(&bo->usage);
-	mutex_unlock(&dev->struct_mutex);
-	mutex_lock(&bo->mutex);
-
-	DRM_FLAG_MASKED(bo->priv_flags, 0, _DRM_BO_FLAG_UNFENCED);
-
-	if (bo->fence && drm_fence_object_signaled(bo->fence,
-						   bo->fence_type))
-		drm_fence_usage_deref_unlocked(&bo->fence);
-
-	if (bo->fence && remove_all)
-		(void)drm_bo_expire_fence(bo, 0);
-
-	mutex_lock(&dev->struct_mutex);
-
-	if (!atomic_dec_and_test(&bo->usage))
-		goto out;
-
-	if (!bo->fence) {
-		list_del_init(&bo->lru);
-		if (bo->mem.mm_node) {
-			drm_mm_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);
-			bo->pinned_node = NULL;
-		}
-		list_del_init(&bo->ddestroy);
-		mutex_unlock(&bo->mutex);
-		drm_bo_destroy_locked(bo);
-		return;
-	}
-
-	if (list_empty(&bo->ddestroy)) {
-		drm_fence_object_flush(bo->fence, bo->fence_type);
-		list_add_tail(&bo->ddestroy, &bm->ddestroy);
-		schedule_delayed_work(&bm->wq,
-				      ((DRM_HZ / 100) < 1) ? 1 : DRM_HZ / 100);
-	}
-
-out:
-	mutex_unlock(&bo->mutex);
-	return;
-}
-
-/*
- * Verify that refcount is 0 and that there are no internal references
- * to the buffer object. Then destroy it.
- */
-
-static void drm_bo_destroy_locked(struct drm_buffer_object *bo)
-{
-	struct drm_device *dev = bo->dev;
-	struct drm_buffer_manager *bm = &dev->bm;
-
-	DRM_ASSERT_LOCKED(&dev->struct_mutex);
-
-	if (list_empty(&bo->lru) && bo->mem.mm_node == NULL &&
-	    list_empty(&bo->pinned_lru) && bo->pinned_node == NULL &&
-	    list_empty(&bo->ddestroy) && atomic_read(&bo->usage) == 0) {
-		if (bo->fence != NULL) {
-			DRM_ERROR("Fence was non-zero.\n");
-			drm_bo_cleanup_refs(bo, 0);
-			return;
-		}
-
-		if (bo->ttm) {
-			drm_ttm_unbind(bo->ttm);
-			drm_ttm_destroy(bo->ttm);
-			bo->ttm = NULL;
-		}
-
-		atomic_dec(&bm->count);
-
-		drm_ctl_free(bo, sizeof(*bo), DRM_MEM_BUFOBJ);
-
-		return;
-	}
-
-	/*
-	 * Some stuff is still trying to reference the buffer object.
-	 * Get rid of those references.
-	 */
-
-	drm_bo_cleanup_refs(bo, 0);
-
-	return;
-}
-
-/*
- * Call dev->struct_mutex locked.
- */
-
-static void drm_bo_delayed_delete(struct drm_device *dev, int remove_all)
-{
-	struct drm_buffer_manager *bm = &dev->bm;
-
-	struct drm_buffer_object *entry, *nentry;
-	struct list_head *list, *next;
-
-	list_for_each_safe(list, next, &bm->ddestroy) {
-		entry = list_entry(list, struct drm_buffer_object, ddestroy);
-
-		nentry = NULL;
-		if (next != &bm->ddestroy) {
-			nentry = list_entry(next, struct drm_buffer_object,
-					    ddestroy);
-			atomic_inc(&nentry->usage);
-		}
-
-		drm_bo_cleanup_refs(entry, remove_all);
-
-		if (nentry)
-			atomic_dec(&nentry->usage);
-	}
-}
-
-static void drm_bo_delayed_workqueue(struct work_struct *work)
-{
-	struct drm_buffer_manager *bm =
-	    container_of(work, struct drm_buffer_manager, wq.work);
-	struct drm_device *dev = container_of(bm, struct drm_device, bm);
-
-	DRM_DEBUG("Delayed delete Worker\n");
-
-	mutex_lock(&dev->struct_mutex);
-	if (!bm->initialized) {
-		mutex_unlock(&dev->struct_mutex);
-		return;
-	}
-	drm_bo_delayed_delete(dev, 0);
-	if (bm->initialized && !list_empty(&bm->ddestroy)) {
-		schedule_delayed_work(&bm->wq,
-				      ((DRM_HZ / 100) < 1) ? 1 : DRM_HZ / 100);
-	}
-	mutex_unlock(&dev->struct_mutex);
-}
-
-void drm_bo_usage_deref_locked(struct drm_buffer_object **bo)
-{
-	struct drm_buffer_object *tmp_bo = *bo;
-	bo = NULL;
-
-	DRM_ASSERT_LOCKED(&tmp_bo->dev->struct_mutex);
-
-	if (atomic_dec_and_test(&tmp_bo->usage))
-		drm_bo_destroy_locked(tmp_bo);
-}
-EXPORT_SYMBOL(drm_bo_usage_deref_locked);
-
-static void drm_bo_base_deref_locked(struct drm_file *file_priv,
-				     struct drm_user_object *uo)
-{
-	struct drm_buffer_object *bo =
-	    drm_user_object_entry(uo, struct drm_buffer_object, base);
-
-	DRM_ASSERT_LOCKED(&bo->dev->struct_mutex);
-
-	drm_bo_takedown_vm_locked(bo);
-	drm_bo_usage_deref_locked(&bo);
-}
-
-void drm_bo_usage_deref_unlocked(struct drm_buffer_object **bo)
-{
-	struct drm_buffer_object *tmp_bo = *bo;
-	struct drm_device *dev = tmp_bo->dev;
-
-	*bo = NULL;
-	if (atomic_dec_and_test(&tmp_bo->usage)) {
-		mutex_lock(&dev->struct_mutex);
-		if (atomic_read(&tmp_bo->usage) == 0)
-			drm_bo_destroy_locked(tmp_bo);
-		mutex_unlock(&dev->struct_mutex);
-	}
-}
-EXPORT_SYMBOL(drm_bo_usage_deref_unlocked);
-
-void drm_putback_buffer_objects(struct drm_device *dev)
-{
-	struct drm_buffer_manager *bm = &dev->bm;
-	struct list_head *list = &bm->unfenced;
-	struct drm_buffer_object *entry, *next;
-
-	mutex_lock(&dev->struct_mutex);
-	list_for_each_entry_safe(entry, next, list, lru) {
-		atomic_inc(&entry->usage);
-		mutex_unlock(&dev->struct_mutex);
-
-		mutex_lock(&entry->mutex);
-		BUG_ON(!(entry->priv_flags & _DRM_BO_FLAG_UNFENCED));
-		mutex_lock(&dev->struct_mutex);
-
-		list_del_init(&entry->lru);
-		DRM_FLAG_MASKED(entry->priv_flags, 0, _DRM_BO_FLAG_UNFENCED);
-		wake_up_all(&entry->event_queue);
-
-		/*
-		 * FIXME: Might want to put back on head of list
-		 * instead of tail here.
-		 */
-
-		drm_bo_add_to_lru(entry);
-		mutex_unlock(&entry->mutex);
-		drm_bo_usage_deref_locked(&entry);
-	}
-	mutex_unlock(&dev->struct_mutex);
-}
-EXPORT_SYMBOL(drm_putback_buffer_objects);
-
-
-/*
- * Note. The caller has to register (if applicable)
- * and deregister fence object usage.
- */
-
-int drm_fence_buffer_objects(struct drm_device *dev,
-			     struct list_head *list,
-			     uint32_t fence_flags,
-			     struct drm_fence_object *fence,
-			     struct drm_fence_object **used_fence)
-{
-	struct drm_buffer_manager *bm = &dev->bm;
-	struct drm_buffer_object *entry;
-	uint32_t fence_type = 0;
-	uint32_t fence_class = ~0;
-	int count = 0;
-	int ret = 0;
-	struct list_head *l;
-
-	mutex_lock(&dev->struct_mutex);
-
-	if (!list)
-		list = &bm->unfenced;
-
-	if (fence)
-		fence_class = fence->fence_class;
-
-	list_for_each_entry(entry, list, lru) {
-		BUG_ON(!(entry->priv_flags & _DRM_BO_FLAG_UNFENCED));
-		fence_type |= entry->new_fence_type;
-		if (fence_class == ~0)
-			fence_class = entry->new_fence_class;
-		else if (entry->new_fence_class != fence_class) {
-			DRM_ERROR("Unmatching fence classes on unfenced list: "
-				  "%d and %d.\n",
-				  fence_class,
-				  entry->new_fence_class);
-			ret = -EINVAL;
-			goto out;
-		}
-		count++;
-	}
-
-	if (!count) {
-		ret = -EINVAL;
-		goto out;
-	}
-
-	if (fence) {
-		if ((fence_type & fence->type) != fence_type ||
-		    (fence->fence_class != fence_class)) {
-			DRM_ERROR("Given fence doesn't match buffers "
-				  "on unfenced list.\n");
-			ret = -EINVAL;
-			goto out;
-		}
-	} else {
-		mutex_unlock(&dev->struct_mutex);
-		ret = drm_fence_object_create(dev, fence_class, fence_type,
-					      fence_flags | DRM_FENCE_FLAG_EMIT,
-					      &fence);
-		mutex_lock(&dev->struct_mutex);
-		if (ret)
-			goto out;
-	}
-
-	count = 0;
-	l = list->next;
-	while (l != list) {
-		prefetch(l->next);
-		entry = list_entry(l, struct drm_buffer_object, lru);
-		atomic_inc(&entry->usage);
-		mutex_unlock(&dev->struct_mutex);
-		mutex_lock(&entry->mutex);
-		mutex_lock(&dev->struct_mutex);
-		list_del_init(l);
-		if (entry->priv_flags & _DRM_BO_FLAG_UNFENCED) {
-			count++;
-			if (entry->fence)
-				drm_fence_usage_deref_locked(&entry->fence);
-			entry->fence = drm_fence_reference_locked(fence);
-			entry->fence_class = entry->new_fence_class;
-			entry->fence_type = entry->new_fence_type;
-			DRM_FLAG_MASKED(entry->priv_flags, 0,
-					_DRM_BO_FLAG_UNFENCED);
-			wake_up_all(&entry->event_queue);
-			drm_bo_add_to_lru(entry);
-		}
-		mutex_unlock(&entry->mutex);
-		drm_bo_usage_deref_locked(&entry);
-		l = list->next;
-	}
-	DRM_DEBUG("Fenced %d buffers\n", count);
-out:
-	mutex_unlock(&dev->struct_mutex);
-	*used_fence = fence;
-	return ret;
-}
-EXPORT_SYMBOL(drm_fence_buffer_objects);
-
-/*
- * bo->mutex locked
- */
-
-static int drm_bo_evict(struct drm_buffer_object *bo, unsigned mem_type,
-			int no_wait)
-{
-	int ret = 0;
-	struct drm_device *dev = bo->dev;
-	struct drm_bo_mem_reg evict_mem;
-
-	/*
-	 * Someone might have modified the buffer before we took the
-	 * buffer mutex.
-	 */
-
-	do {
-		bo->priv_flags &= ~_DRM_BO_FLAG_UNLOCKED;
-
-		if (unlikely(bo->mem.flags &
-			     (DRM_BO_FLAG_NO_MOVE | DRM_BO_FLAG_NO_EVICT)))
-			goto out_unlock;
-		if (unlikely(bo->priv_flags & _DRM_BO_FLAG_UNFENCED))
-			goto out_unlock;
-		if (unlikely(bo->mem.mem_type != mem_type))
-			goto out_unlock;
-		ret = drm_bo_wait(bo, 0, 1, no_wait, 0);
-		if (ret)
-			goto out_unlock;
-
-	} while(bo->priv_flags & _DRM_BO_FLAG_UNLOCKED);
-
-	evict_mem = bo->mem;
-	evict_mem.mm_node = NULL;
-
-	evict_mem = bo->mem;
-	evict_mem.proposed_flags = dev->driver->bo_driver->evict_flags(bo);
-
-	mutex_lock(&dev->struct_mutex);
-	list_del_init(&bo->lru);
-	mutex_unlock(&dev->struct_mutex);
-
-	ret = drm_bo_mem_space(bo, &evict_mem, no_wait);
-
-	if (ret) {
-		if (ret != -EAGAIN)
-			DRM_ERROR("Failed to find memory space for "
-				  "buffer 0x%p eviction.\n", bo);
-		goto out;
-	}
-
-	ret = drm_bo_handle_move_mem(bo, &evict_mem, 1, no_wait);
-
-	if (ret) {
-		if (ret != -EAGAIN)
-			DRM_ERROR("Buffer eviction failed\n");
-		goto out;
-	}
-
-	DRM_FLAG_MASKED(bo->priv_flags, _DRM_BO_FLAG_EVICTED,
-			_DRM_BO_FLAG_EVICTED);
-
-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);
-		evict_mem.mm_node = NULL;
-	}
-	drm_bo_add_to_lru(bo);
-	BUG_ON(bo->priv_flags & _DRM_BO_FLAG_UNLOCKED);
-out_unlock:
-	mutex_unlock(&dev->struct_mutex);
-
-	return ret;
-}
-
-/**
- * Repeatedly evict memory from the LRU for @mem_type until we create enough
- * space, or we've evicted everything and there isn't enough space.
- */
-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_buffer_manager *bm = &dev->bm;
-	struct drm_buffer_object *entry;
-	struct drm_mem_type_manager *man = &bm->man[mem_type];
-	struct list_head *lru;
-	unsigned long num_pages = mem->num_pages;
-	int ret;
-
-	mutex_lock(&dev->struct_mutex);
-	do {
-		node = drm_mm_search_free(&man->manager, num_pages,
-					  mem->page_alignment, 1);
-		if (node)
-			break;
-
-		lru = &man->lru;
-		if (lru->next == lru)
-			break;
-
-		entry = list_entry(lru->next, struct drm_buffer_object, lru);
-		atomic_inc(&entry->usage);
-		mutex_unlock(&dev->struct_mutex);
-		mutex_lock(&entry->mutex);
-		ret = drm_bo_evict(entry, mem_type, no_wait);
-		mutex_unlock(&entry->mutex);
-		drm_bo_usage_deref_unlocked(&entry);
-		if (ret)
-			return ret;
-		mutex_lock(&dev->struct_mutex);
-	} while (1);
-
-	if (!node) {
-		mutex_unlock(&dev->struct_mutex);
-		return -ENOMEM;
-	}
-
-	node = drm_mm_get_block(node, num_pages, mem->page_alignment);
-	if (unlikely(!node)) {
-		mutex_unlock(&dev->struct_mutex);
-		return -ENOMEM;
-	}
-
-	mutex_unlock(&dev->struct_mutex);
-	mem->mm_node = node;
-	mem->mem_type = mem_type;
-	return 0;
-}
-
-static int drm_bo_mt_compatible(struct drm_mem_type_manager *man,
-				int disallow_fixed,
-				uint32_t mem_type,
-				uint64_t mask, uint32_t *res_mask)
-{
-	uint64_t cur_flags = drm_bo_type_flags(mem_type);
-	uint64_t flag_diff;
-
-	if ((man->flags & _DRM_FLAG_MEMTYPE_FIXED) && disallow_fixed)
-		return 0;
-	if (man->flags & _DRM_FLAG_MEMTYPE_CACHED)
-		cur_flags |= DRM_BO_FLAG_CACHED;
-	if (man->flags & _DRM_FLAG_MEMTYPE_MAPPABLE)
-		cur_flags |= DRM_BO_FLAG_MAPPABLE;
-	if (man->flags & _DRM_FLAG_MEMTYPE_CSELECT)
-		DRM_FLAG_MASKED(cur_flags, mask, DRM_BO_FLAG_CACHED);
-
-	if ((cur_flags & mask & DRM_BO_MASK_MEM) == 0)
-		return 0;
-
-	if (mem_type == DRM_BO_MEM_LOCAL) {
-		*res_mask = cur_flags;
-		return 1;
-	}
-
-	flag_diff = (mask ^ cur_flags);
-	if (flag_diff & DRM_BO_FLAG_CACHED_MAPPED)
-		cur_flags |= DRM_BO_FLAG_CACHED_MAPPED;
-
-	if ((flag_diff & DRM_BO_FLAG_CACHED) &&
-	    (!(mask & DRM_BO_FLAG_CACHED) ||
-	     (mask & DRM_BO_FLAG_FORCE_CACHING)))
-		return 0;
-
-	if ((flag_diff & DRM_BO_FLAG_MAPPABLE) &&
-	    ((mask & DRM_BO_FLAG_MAPPABLE) ||
-	     (mask & DRM_BO_FLAG_FORCE_MAPPABLE)))
-		return 0;
-
-	*res_mask = cur_flags;
-	return 1;
-}
-
-/**
- * Creates space for memory region @mem according to its type.
- *
- * This function first searches for free space in compatible memory types in
- * the priority order defined by the driver.  If free space isn't found, then
- * drm_bo_mem_force_space is attempted in priority order to evict and find
- * space.
- */
-int drm_bo_mem_space(struct drm_buffer_object *bo,
-		     struct drm_bo_mem_reg *mem, int no_wait)
-{
-	struct drm_device *dev = bo->dev;
-	struct drm_buffer_manager *bm = &dev->bm;
-	struct drm_mem_type_manager *man;
-
-	uint32_t num_prios = dev->driver->bo_driver->num_mem_type_prio;
-	const uint32_t *prios = dev->driver->bo_driver->mem_type_prio;
-	uint32_t i;
-	uint32_t mem_type = DRM_BO_MEM_LOCAL;
-	uint32_t cur_flags;
-	int type_found = 0;
-	int type_ok = 0;
-	int has_eagain = 0;
-	struct drm_mm_node *node = NULL;
-	int ret;
-
-	mem->mm_node = NULL;
-	for (i = 0; i < num_prios; ++i) {
-		mem_type = prios[i];
-		man = &bm->man[mem_type];
-
-		type_ok = drm_bo_mt_compatible(man,
-					       bo->type == drm_bo_type_user,
-					       mem_type, mem->proposed_flags,
-					       &cur_flags);
-
-		if (!type_ok)
-			continue;
-
-		if (mem_type == DRM_BO_MEM_LOCAL)
-			break;
-
-		if ((mem_type == bo->pinned_mem_type) &&
-		    (bo->pinned_node != NULL)) {
-			node = bo->pinned_node;
-			break;
-		}
-
-		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,
-						  mem->page_alignment, 1);
-			if (node)
-				node = drm_mm_get_block(node, mem->num_pages,
-							mem->page_alignment);
-		}
-		mutex_unlock(&dev->struct_mutex);
-		if (node)
-			break;
-	}
-
-	if ((type_ok && (mem_type == DRM_BO_MEM_LOCAL)) || node) {
-		mem->mm_node = node;
-		mem->mem_type = mem_type;
-		mem->flags = cur_flags;
-		return 0;
-	}
-
-	if (!type_found)
-		return -EINVAL;
-
-	num_prios = dev->driver->bo_driver->num_mem_busy_prio;
-	prios = dev->driver->bo_driver->mem_busy_prio;
-
-	for (i = 0; i < num_prios; ++i) {
-		mem_type = prios[i];
-		man = &bm->man[mem_type];
-
-		if (!man->has_type)
-			continue;
-
-		if (!drm_bo_mt_compatible(man,
-					  bo->type == drm_bo_type_user,
-					  mem_type,
-					  mem->proposed_flags,
-					  &cur_flags))
-			continue;
-
-		ret = drm_bo_mem_force_space(dev, mem, mem_type, no_wait);
-
-		if (ret == 0 && mem->mm_node) {
-			mem->flags = cur_flags;
-			return 0;
-		}
-
-		if (ret == -EAGAIN)
-			has_eagain = 1;
-	}
-
-	ret = (has_eagain) ? -EAGAIN : -ENOMEM;
-	return ret;
-}
-EXPORT_SYMBOL(drm_bo_mem_space);
-
-/*
- * drm_bo_propose_flags:
- *
- * @bo: the buffer object getting new flags
- *
- * @new_flags: the new set of proposed flag bits
- *
- * @new_mask: the mask of bits changed in new_flags
- *
- * Modify the proposed_flag bits in @bo
- */
-static int drm_bo_modify_proposed_flags (struct drm_buffer_object *bo,
-					 uint64_t new_flags, uint64_t new_mask)
-{
-	uint32_t new_access;
-
-	/* Copy unchanging bits from existing proposed_flags */
-	DRM_FLAG_MASKED(new_flags, bo->mem.proposed_flags, ~new_mask);
-	 
-	if (bo->type == drm_bo_type_user &&
-	    ((new_flags & (DRM_BO_FLAG_CACHED | DRM_BO_FLAG_FORCE_CACHING)) !=
-	     (DRM_BO_FLAG_CACHED | DRM_BO_FLAG_FORCE_CACHING))) {
-		DRM_ERROR("User buffers require cache-coherent memory.\n");
-		return -EINVAL;
-	}
-
-	if (bo->type != drm_bo_type_kernel && (new_mask & DRM_BO_FLAG_NO_EVICT) && !DRM_SUSER(DRM_CURPROC)) {
-		DRM_ERROR("DRM_BO_FLAG_NO_EVICT is only available to priviliged processes.\n");
-		return -EPERM;
-	}
-
-	if (likely(new_mask & DRM_BO_MASK_MEM) &&
-	    (bo->mem.flags & DRM_BO_FLAG_NO_EVICT) &&
-	    !DRM_SUSER(DRM_CURPROC)) {
-		if (likely(bo->mem.flags & new_flags & new_mask &
-			   DRM_BO_MASK_MEM))
-			new_flags = (new_flags & ~DRM_BO_MASK_MEM) |
-				(bo->mem.flags & DRM_BO_MASK_MEM);
-		else {
-			DRM_ERROR("Incompatible memory type specification "
-				  "for NO_EVICT buffer.\n");
-			return -EPERM;
-		}
-	}
-
-	if ((new_flags & DRM_BO_FLAG_NO_MOVE)) {
-		DRM_ERROR("DRM_BO_FLAG_NO_MOVE is not properly implemented yet.\n");
-		return -EPERM;
-	}
-
-	new_access = new_flags & (DRM_BO_FLAG_EXE | DRM_BO_FLAG_WRITE |
-				  DRM_BO_FLAG_READ);
-
-	if (new_access == 0) {
-		DRM_ERROR("Invalid buffer object rwx properties\n");
-		return -EINVAL;
-	}
-
-	bo->mem.proposed_flags = new_flags;
-	return 0;
-}
-
-/*
- * Call dev->struct_mutex locked.
- */
-
-struct drm_buffer_object *drm_lookup_buffer_object(struct drm_file *file_priv,
-					      uint32_t handle, int check_owner)
-{
-	struct drm_user_object *uo;
-	struct drm_buffer_object *bo;
-
-	uo = drm_lookup_user_object(file_priv, handle);
-
-	if (!uo || (uo->type != drm_buffer_type)) {
-		DRM_ERROR("Could not find buffer object 0x%08x\n", handle);
-		return NULL;
-	}
-
-	if (check_owner && file_priv != uo->owner) {
-		if (!drm_lookup_ref_object(file_priv, uo, _DRM_REF_USE))
-			return NULL;
-	}
-
-	bo = drm_user_object_entry(uo, struct drm_buffer_object, base);
-	atomic_inc(&bo->usage);
-	return bo;
-}
-EXPORT_SYMBOL(drm_lookup_buffer_object);
-
-/*
- * Call bo->mutex locked.
- * Returns -EBUSY if the buffer is currently rendered to or from. 0 otherwise.
- * Doesn't do any fence flushing as opposed to the drm_bo_busy function.
- */
-
-static int drm_bo_quick_busy(struct drm_buffer_object *bo, int check_unfenced)
-{
-	struct drm_fence_object *fence = bo->fence;
-
-	if (check_unfenced && (bo->priv_flags & _DRM_BO_FLAG_UNFENCED))
-		return -EBUSY;
-
-	if (fence) {
-		if (drm_fence_object_signaled(fence, bo->fence_type)) {
-			drm_fence_usage_deref_unlocked(&bo->fence);
-			return 0;
-		}
-		return -EBUSY;
-	}
-	return 0;
-}
-
-int drm_bo_evict_cached(struct drm_buffer_object *bo)
-{
-	int ret = 0;
-
-	BUG_ON(bo->priv_flags & _DRM_BO_FLAG_UNFENCED);
-	if (bo->mem.mm_node)
-		ret = drm_bo_evict(bo, DRM_BO_MEM_TT, 1);
-	return ret;
-}
-
-EXPORT_SYMBOL(drm_bo_evict_cached);
-/*
- * Wait until a buffer is unmapped.
- */
-
-static int drm_bo_wait_unmapped(struct drm_buffer_object *bo, int no_wait)
-{
-	int ret = 0;
-
-	if (likely(atomic_read(&bo->mapped)) == 0)
-		return 0;
-
-	if (unlikely(no_wait))
-		return -EBUSY;
-
-	do {
-		mutex_unlock(&bo->mutex);
-		ret = wait_event_interruptible(bo->event_queue,
-					       atomic_read(&bo->mapped) == 0);
-		mutex_lock(&bo->mutex);
-		bo->priv_flags |= _DRM_BO_FLAG_UNLOCKED;
-
-		if (ret == -ERESTARTSYS)
-			ret = -EAGAIN;
-	} while((ret == 0) && atomic_read(&bo->mapped) > 0);
-
-	return ret;
-}
-
-/*
- * Fill in the ioctl reply argument with buffer info.
- * Bo locked.
- */
-
-void drm_bo_fill_rep_arg(struct drm_buffer_object *bo,
-			 struct drm_bo_info_rep *rep)
-{
-	if (!rep)
-		return;
-
-	rep->handle = bo->base.hash.key;
-	rep->flags = bo->mem.flags;
-	rep->size = bo->num_pages * PAGE_SIZE;
-	rep->offset = bo->offset;
-
-	/*
-	 * drm_bo_type_device buffers have user-visible
-	 * handles which can be used to share across
-	 * processes. Hand that back to the application
-	 */
-	if (bo->type == drm_bo_type_device)
-		rep->arg_handle = bo->map_list.user_token;
-	else
-		rep->arg_handle = 0;
-
-	rep->proposed_flags = bo->mem.proposed_flags;
-	rep->buffer_start = bo->buffer_start;
-	rep->fence_flags = bo->fence_type;
-	rep->rep_flags = 0;
-	rep->page_alignment = bo->mem.page_alignment;
-
-	if ((bo->priv_flags & _DRM_BO_FLAG_UNFENCED) || drm_bo_quick_busy(bo, 1)) {
-		DRM_FLAG_MASKED(rep->rep_flags, DRM_BO_REP_BUSY,
-				DRM_BO_REP_BUSY);
-	}
-}
-EXPORT_SYMBOL(drm_bo_fill_rep_arg);
-
-/*
- * Wait for buffer idle and register that we've mapped the buffer.
- * Mapping is registered as a drm_ref_object with type _DRM_REF_TYPE1,
- * so that if the client dies, the mapping is automatically
- * unregistered.
- */
-
-static int drm_buffer_object_map(struct drm_file *file_priv, uint32_t handle,
-				 uint32_t map_flags, unsigned hint,
-				 struct drm_bo_info_rep *rep)
-{
-	struct drm_buffer_object *bo;
-	struct drm_device *dev = file_priv->minor->dev;
-	int ret = 0;
-	int no_wait = hint & DRM_BO_HINT_DONT_BLOCK;
-
-	mutex_lock(&dev->struct_mutex);
-	bo = drm_lookup_buffer_object(file_priv, handle, 1);
-	mutex_unlock(&dev->struct_mutex);
-
-	if (!bo)
-		return -EINVAL;
-
-	mutex_lock(&bo->mutex);
-	do {
-		bo->priv_flags &= ~_DRM_BO_FLAG_UNLOCKED;
-
-		ret = drm_bo_wait(bo, 0, 1, no_wait, 1);
-		if (unlikely(ret))
-			goto out;
-
-		if (bo->mem.flags & DRM_BO_FLAG_CACHED_MAPPED)
-			drm_bo_evict_cached(bo);
-
-	} while (unlikely(bo->priv_flags & _DRM_BO_FLAG_UNLOCKED));
-
-	atomic_inc(&bo->mapped);
-	mutex_lock(&dev->struct_mutex);
-	ret = drm_add_ref_object(file_priv, &bo->base, _DRM_REF_TYPE1);
-	mutex_unlock(&dev->struct_mutex);
-	if (ret) {
-		if (atomic_dec_and_test(&bo->mapped))
-			wake_up_all(&bo->event_queue);
-
-	} else
-		drm_bo_fill_rep_arg(bo, rep);
-
- out:
-	mutex_unlock(&bo->mutex);
-	drm_bo_usage_deref_unlocked(&bo);
-
-	return ret;
-}
-
-static int drm_buffer_object_unmap(struct drm_file *file_priv, uint32_t handle)
-{
-	struct drm_device *dev = file_priv->minor->dev;
-	struct drm_buffer_object *bo;
-	struct drm_ref_object *ro;
-	int ret = 0;
-
-	mutex_lock(&dev->struct_mutex);
-
-	bo = drm_lookup_buffer_object(file_priv, handle, 1);
-	if (!bo) {
-		ret = -EINVAL;
-		goto out;
-	}
-
-	ro = drm_lookup_ref_object(file_priv, &bo->base, _DRM_REF_TYPE1);
-	if (!ro) {
-		ret = -EINVAL;
-		goto out;
-	}
-
-	drm_remove_ref_object(file_priv, ro);
-	drm_bo_usage_deref_locked(&bo);
-out:
-	mutex_unlock(&dev->struct_mutex);
-	return ret;
-}
-
-/*
- * Call struct-sem locked.
- */
-
-static void drm_buffer_user_object_unmap(struct drm_file *file_priv,
-					 struct drm_user_object *uo,
-					 enum drm_ref_type action)
-{
-	struct drm_buffer_object *bo =
-	    drm_user_object_entry(uo, struct drm_buffer_object, base);
-
-	/*
-	 * We DON'T want to take the bo->lock here, because we want to
-	 * hold it when we wait for unmapped buffer.
-	 */
-
-	BUG_ON(action != _DRM_REF_TYPE1);
-
-	if (atomic_dec_and_test(&bo->mapped))
-		wake_up_all(&bo->event_queue);
-}
-
-/*
- * bo->mutex locked.
- * Note that new_mem_flags are NOT transferred to the bo->mem.proposed_flags.
- */
-
-int drm_bo_move_buffer(struct drm_buffer_object *bo, uint64_t new_mem_flags,
-		       int no_wait, int move_unfenced)
-{
-	struct drm_device *dev = bo->dev;
-	struct drm_buffer_manager *bm = &dev->bm;
-	int ret = 0;
-	struct drm_bo_mem_reg mem;
-
-	BUG_ON(bo->fence != NULL);
-
-	mem.num_pages = bo->num_pages;
-	mem.size = mem.num_pages << PAGE_SHIFT;
-	mem.proposed_flags = new_mem_flags;
-	mem.page_alignment = bo->mem.page_alignment;
-
-	mutex_lock(&bm->evict_mutex);
-	mutex_lock(&dev->struct_mutex);
-	list_del_init(&bo->lru);
-	mutex_unlock(&dev->struct_mutex);
-
-	/*
-	 * Determine where to move the buffer.
-	 */
-	ret = drm_bo_mem_space(bo, &mem, no_wait);
-	if (ret)
-		goto out_unlock;
-
-	ret = drm_bo_handle_move_mem(bo, &mem, 0, no_wait);
-
-out_unlock:
-	mutex_lock(&dev->struct_mutex);
-	if (ret || !move_unfenced) {
-		if (mem.mm_node) {
-			if (mem.mm_node != bo->pinned_node)
-				drm_mm_put_block(mem.mm_node);
-			mem.mm_node = NULL;
-		}
-		drm_bo_add_to_lru(bo);
-		if (bo->priv_flags & _DRM_BO_FLAG_UNFENCED) {
-			wake_up_all(&bo->event_queue);
-			DRM_FLAG_MASKED(bo->priv_flags, 0,
-					_DRM_BO_FLAG_UNFENCED);
-		}
-	} else {
-		list_add_tail(&bo->lru, &bm->unfenced);
-		DRM_FLAG_MASKED(bo->priv_flags, _DRM_BO_FLAG_UNFENCED,
-				_DRM_BO_FLAG_UNFENCED);
-	}
-	mutex_unlock(&dev->struct_mutex);
-	mutex_unlock(&bm->evict_mutex);
-	return ret;
-}
-
-static int drm_bo_mem_compat(struct drm_bo_mem_reg *mem)
-{
-	uint32_t flag_diff = (mem->proposed_flags ^ mem->flags);
-
-	if ((mem->proposed_flags & mem->flags & DRM_BO_MASK_MEM) == 0)
-		return 0;
-	if ((flag_diff & DRM_BO_FLAG_CACHED) &&
-	    (/* !(mem->proposed_flags & DRM_BO_FLAG_CACHED) ||*/
-	     (mem->proposed_flags & DRM_BO_FLAG_FORCE_CACHING)))
-		return 0;
-
-	if ((flag_diff & DRM_BO_FLAG_MAPPABLE) &&
-	    ((mem->proposed_flags & DRM_BO_FLAG_MAPPABLE) ||
-	     (mem->proposed_flags & DRM_BO_FLAG_FORCE_MAPPABLE)))
-		return 0;
-	return 1;
-}
-
-/**
- * drm_buffer_object_validate:
- *
- * @bo: the buffer object to modify
- *
- * @fence_class: the new fence class covering this buffer
- *
- * @move_unfenced: a boolean indicating whether switching the
- * memory space of this buffer should cause the buffer to
- * be placed on the unfenced list.
- *
- * @no_wait: whether this function should return -EBUSY instead
- * of waiting.
- *
- * Change buffer access parameters. This can involve moving
- * the buffer to the correct memory type, pinning the buffer
- * or changing the class/type of fence covering this buffer
- *
- * Must be called with bo locked.
- */
-
-static int drm_buffer_object_validate(struct drm_buffer_object *bo,
-				      uint32_t fence_class,
-				      int move_unfenced, int no_wait,
-				      int move_buffer)
-{
-	struct drm_device *dev = bo->dev;
-	struct drm_buffer_manager *bm = &dev->bm;
-	int ret;
-
-	if (move_buffer) {
-		ret = drm_bo_move_buffer(bo, bo->mem.proposed_flags, no_wait,
-					 move_unfenced);
-		if (ret) {
-			if (ret != -EAGAIN)
-				DRM_ERROR("Failed moving buffer.\n");
-			if (ret == -ENOMEM)
-				DRM_ERROR("Out of aperture space or "
-					  "DRM memory quota.\n");
-			return ret;
-		}
-	}
-
-	/*
-	 * Pinned buffers.
-	 */
-
-	if (bo->mem.proposed_flags & (DRM_BO_FLAG_NO_EVICT | DRM_BO_FLAG_NO_MOVE)) {
-		bo->pinned_mem_type = bo->mem.mem_type;
-		mutex_lock(&dev->struct_mutex);
-		list_del_init(&bo->pinned_lru);
-		drm_bo_add_to_pinned_lru(bo);
-
-		if (bo->pinned_node != bo->mem.mm_node) {
-			if (bo->pinned_node != NULL)
-				drm_mm_put_block(bo->pinned_node);
-			bo->pinned_node = bo->mem.mm_node;
-		}
-
-		mutex_unlock(&dev->struct_mutex);
-
-	} else if (bo->pinned_node != NULL) {
-
-		mutex_lock(&dev->struct_mutex);
-
-		if (bo->pinned_node != bo->mem.mm_node)
-			drm_mm_put_block(bo->pinned_node);
-
-		list_del_init(&bo->pinned_lru);
-		bo->pinned_node = NULL;
-		mutex_unlock(&dev->struct_mutex);
-
-	}
-
-	/*
-	 * We might need to add a TTM.
-	 */
-
-	if (bo->mem.mem_type == DRM_BO_MEM_LOCAL && bo->ttm == NULL) {
-		ret = drm_bo_add_ttm(bo);
-		if (ret)
-			return ret;
-	}
-	/*
-	 * Validation has succeeded, move the access and other
-	 * non-mapping-related flag bits from the proposed flags to
-	 * the active flags
-	 */
-
-	DRM_FLAG_MASKED(bo->mem.flags, bo->mem.proposed_flags, ~DRM_BO_MASK_MEMTYPE);
-
-	/*
-	 * Finally, adjust lru to be sure.
-	 */
-
-	mutex_lock(&dev->struct_mutex);
-	list_del(&bo->lru);
-	if (move_unfenced) {
-		list_add_tail(&bo->lru, &bm->unfenced);
-		DRM_FLAG_MASKED(bo->priv_flags, _DRM_BO_FLAG_UNFENCED,
-				_DRM_BO_FLAG_UNFENCED);
-	} else {
-		drm_bo_add_to_lru(bo);
-		if (bo->priv_flags & _DRM_BO_FLAG_UNFENCED) {
-			wake_up_all(&bo->event_queue);
-			DRM_FLAG_MASKED(bo->priv_flags, 0,
-					_DRM_BO_FLAG_UNFENCED);
-		}
-	}
-	mutex_unlock(&dev->struct_mutex);
-
-	return 0;
-}
-
-/*
- * This function is called with bo->mutex locked, but may release it
- * temporarily to wait for events.
- */
-
-static int drm_bo_prepare_for_validate(struct drm_buffer_object *bo,
-				       uint64_t flags,
-				       uint64_t mask,
-				       uint32_t hint,
-				       uint32_t fence_class,
-				       int no_wait,
-				       int *move_buffer)
-{
-	struct drm_device *dev = bo->dev;
-	struct drm_bo_driver *driver = dev->driver->bo_driver;
-	uint32_t ftype;
-
-	int ret;
-
-	DRM_DEBUG("Proposed flags 0x%016llx, Old flags 0x%016llx\n",
-		  (unsigned long long) bo->mem.proposed_flags,
-		  (unsigned long long) bo->mem.flags);
-
-	ret = drm_bo_modify_proposed_flags (bo, flags, mask);
-	if (ret)
-		return ret;
-
-	ret = drm_bo_wait_unmapped(bo, no_wait);
-	if (ret)
-		return ret;
-
-	ret = driver->fence_type(bo, &fence_class, &ftype);
-
-	if (ret) {
-		DRM_ERROR("Driver did not support given buffer permissions.\n");
-		return ret;
-	}
-
-	/*
-	 * We're switching command submission mechanism,
-	 * or cannot simply rely on the hardware serializing for us.
-	 * Insert a driver-dependant barrier or wait for buffer idle.
-	 */
-
-	if ((fence_class != bo->fence_class) ||
-	    ((ftype ^ bo->fence_type) & bo->fence_type)) {
-
-		ret = -EINVAL;
-		if (driver->command_stream_barrier) {
-			ret = driver->command_stream_barrier(bo,
-							     fence_class,
-							     ftype,
-							     no_wait);
-		}
-		if (ret && ret != -EAGAIN) 
-			ret = drm_bo_wait(bo, 0, 1, no_wait, 1);
-		
-		if (ret)
-			return ret;
-	}
-
-	bo->new_fence_class = fence_class;
-	bo->new_fence_type = ftype;
-
-	/*
-	 * Check whether we need to move buffer.
-	 */
-
-	*move_buffer = 0;
-	if (!drm_bo_mem_compat(&bo->mem)) {
-		*move_buffer = 1;
-		ret = drm_bo_wait(bo, 0, 1, no_wait, 1);
-	}
-
-	return ret;
-}
-
-/**
- * drm_bo_do_validate:
- *
- * @bo:	the buffer object
- *
- * @flags: access rights, mapping parameters and cacheability. See
- * the DRM_BO_FLAG_* values in drm.h
- *
- * @mask: Which flag values to change; this allows callers to modify
- * things without knowing the current state of other flags.
- *
- * @hint: changes the proceedure for this operation, see the DRM_BO_HINT_*
- * values in drm.h.
- *
- * @fence_class: a driver-specific way of doing fences. Presumably,
- * this would be used if the driver had more than one submission and
- * fencing mechanism. At this point, there isn't any use of this
- * from the user mode code.
- *
- * @rep: To be stuffed with the reply from validation
- * 
- * 'validate' a buffer object. This changes where the buffer is
- * located, along with changing access modes.
- */
-
-int drm_bo_do_validate(struct drm_buffer_object *bo,
-		       uint64_t flags, uint64_t mask, uint32_t hint,
-		       uint32_t fence_class,
-		       struct drm_bo_info_rep *rep)
-{
-	int ret;
-	int no_wait = (hint & DRM_BO_HINT_DONT_BLOCK) != 0;
-	int move_buffer;
-
-	mutex_lock(&bo->mutex);
-
-	do {
-		bo->priv_flags &= ~_DRM_BO_FLAG_UNLOCKED;
-
-		ret = drm_bo_prepare_for_validate(bo, flags, mask, hint,
-						  fence_class, no_wait,
-						  &move_buffer);
-		if (ret)
-			goto out;
-
-	} while(unlikely(bo->priv_flags & _DRM_BO_FLAG_UNLOCKED));
-
-	ret = drm_buffer_object_validate(bo,
-					 fence_class,
-					 !(hint & DRM_BO_HINT_DONT_FENCE),
-					 no_wait,
-					 move_buffer);
-
-	BUG_ON(bo->priv_flags & _DRM_BO_FLAG_UNLOCKED);
-out:
-	if (rep)
-		drm_bo_fill_rep_arg(bo, rep);
-
-	mutex_unlock(&bo->mutex);
-
-	return ret;
-}
-EXPORT_SYMBOL(drm_bo_do_validate);
-
-/**
- * drm_bo_handle_validate
- *
- * @file_priv: the drm file private, used to get a handle to the user context
- *
- * @handle: the buffer object handle
- *
- * @flags: access rights, mapping parameters and cacheability. See
- * the DRM_BO_FLAG_* values in drm.h
- *
- * @mask: Which flag values to change; this allows callers to modify
- * things without knowing the current state of other flags.
- *
- * @hint: changes the proceedure for this operation, see the DRM_BO_HINT_*
- * values in drm.h.
- *
- * @fence_class: a driver-specific way of doing fences. Presumably,
- * this would be used if the driver had more than one submission and
- * fencing mechanism. At this point, there isn't any use of this
- * from the user mode code.
- *
- * @rep: To be stuffed with the reply from validation
- *
- * @bp_rep: To be stuffed with the buffer object pointer
- *
- * Perform drm_bo_do_validate on a buffer referenced by a user-space handle instead
- * of a pointer to a buffer object. Optionally return a pointer to the buffer object.
- * This is a convenience wrapper only.
- */
-
-int drm_bo_handle_validate(struct drm_file *file_priv, uint32_t handle,
-			   uint64_t flags, uint64_t mask,
-			   uint32_t hint,
-			   uint32_t fence_class,
-			   struct drm_bo_info_rep *rep,
-			   struct drm_buffer_object **bo_rep)
-{
-	struct drm_device *dev = file_priv->minor->dev;
-	struct drm_buffer_object *bo;
-	int ret;
-
-	mutex_lock(&dev->struct_mutex);
-	bo = drm_lookup_buffer_object(file_priv, handle, 1);
-	mutex_unlock(&dev->struct_mutex);
-
-	if (!bo)
-		return -EINVAL;
-
-	if (bo->base.owner != file_priv)
-		mask &= ~(DRM_BO_FLAG_NO_EVICT | DRM_BO_FLAG_NO_MOVE);
-
-	ret = drm_bo_do_validate(bo, flags, mask, hint, fence_class, rep);
-
-	if (!ret && bo_rep)
-		*bo_rep = bo;
-	else
-		drm_bo_usage_deref_unlocked(&bo);
-
-	return ret;
-}
-EXPORT_SYMBOL(drm_bo_handle_validate);
-
-
-static int drm_bo_handle_info(struct drm_file *file_priv, uint32_t handle,
-			      struct drm_bo_info_rep *rep)
-{
-	struct drm_device *dev = file_priv->minor->dev;
-	struct drm_buffer_object *bo;
-
-	mutex_lock(&dev->struct_mutex);
-	bo = drm_lookup_buffer_object(file_priv, handle, 1);
-	mutex_unlock(&dev->struct_mutex);
-
-	if (!bo)
-		return -EINVAL;
-
-	mutex_lock(&bo->mutex);
-
-	/*
-	 * FIXME: Quick busy here?
-	 */
-
-	drm_bo_busy(bo, 1);
-	drm_bo_fill_rep_arg(bo, rep);
-	mutex_unlock(&bo->mutex);
-	drm_bo_usage_deref_unlocked(&bo);
-	return 0;
-}
-
-static int drm_bo_handle_wait(struct drm_file *file_priv, uint32_t handle,
-			      uint32_t hint,
-			      struct drm_bo_info_rep *rep)
-{
-	struct drm_device *dev = file_priv->minor->dev;
-	struct drm_buffer_object *bo;
-	int no_wait = hint & DRM_BO_HINT_DONT_BLOCK;
-	int ret;
-
-	mutex_lock(&dev->struct_mutex);
-	bo = drm_lookup_buffer_object(file_priv, handle, 1);
-	mutex_unlock(&dev->struct_mutex);
-
-	if (!bo)
-		return -EINVAL;
-
-	mutex_lock(&bo->mutex);
-	ret = drm_bo_wait(bo, hint & DRM_BO_HINT_WAIT_LAZY, 1, no_wait, 1);
-	if (ret)
-		goto out;
-
-	drm_bo_fill_rep_arg(bo, rep);
-out:
-	mutex_unlock(&bo->mutex);
-	drm_bo_usage_deref_unlocked(&bo);
-	return ret;
-}
-
-int drm_buffer_object_create(struct drm_device *dev,
-			     unsigned long size,
-			     enum drm_bo_type type,
-			     uint64_t flags,
-			     uint32_t hint,
-			     uint32_t page_alignment,
-			     unsigned long buffer_start,
-			     struct drm_buffer_object **buf_obj)
-{
-	struct drm_buffer_manager *bm = &dev->bm;
-	struct drm_buffer_object *bo;
-	int ret = 0;
-	unsigned long num_pages;
-
-	size += buffer_start & ~PAGE_MASK;
-	num_pages = (size + PAGE_SIZE - 1) >> PAGE_SHIFT;
-	if (num_pages == 0) {
-		DRM_ERROR("Illegal buffer object size.\n");
-		return -EINVAL;
-	}
-
-	bo = drm_ctl_calloc(1, sizeof(*bo), DRM_MEM_BUFOBJ);
-
-	if (!bo)
-		return -ENOMEM;
-
-	mutex_init(&bo->mutex);
-	mutex_lock(&bo->mutex);
-
-	atomic_set(&bo->usage, 1);
-	atomic_set(&bo->mapped, 0);
-	DRM_INIT_WAITQUEUE(&bo->event_queue);
-	INIT_LIST_HEAD(&bo->lru);
-	INIT_LIST_HEAD(&bo->pinned_lru);
-	INIT_LIST_HEAD(&bo->ddestroy);
-	bo->dev = dev;
-	bo->type = type;
-	bo->num_pages = num_pages;
-	bo->mem.mem_type = DRM_BO_MEM_LOCAL;
-	bo->mem.num_pages = bo->num_pages;
-	bo->mem.mm_node = NULL;
-	bo->mem.page_alignment = page_alignment;
-	bo->buffer_start = buffer_start & PAGE_MASK;
-	bo->priv_flags = 0;
-	bo->mem.flags = (DRM_BO_FLAG_MEM_LOCAL | DRM_BO_FLAG_CACHED |
-			 DRM_BO_FLAG_MAPPABLE);
-	bo->mem.proposed_flags = 0;
-	atomic_inc(&bm->count);
-	/*
-	 * Use drm_bo_modify_proposed_flags to error-check the proposed flags
-	 */
-	ret = drm_bo_modify_proposed_flags (bo, flags, flags);
-	if (ret)
-		goto out_err;
-
-	/*
-	 * For drm_bo_type_device buffers, allocate
-	 * address space from the device so that applications
-	 * can mmap the buffer from there
-	 */
-	if (bo->type == drm_bo_type_device) {
-		mutex_lock(&dev->struct_mutex);
-		ret = drm_bo_setup_vm_locked(bo);
-		mutex_unlock(&dev->struct_mutex);
-		if (ret)
-			goto out_err;
-	}
-
-	mutex_unlock(&bo->mutex);
-	ret = drm_bo_do_validate(bo, 0, 0, hint | DRM_BO_HINT_DONT_FENCE,
-				 0, NULL);
-	if (ret)
-		goto out_err_unlocked;
-
-	*buf_obj = bo;
-	return 0;
-
-out_err:
-	mutex_unlock(&bo->mutex);
-out_err_unlocked:
-	drm_bo_usage_deref_unlocked(&bo);
-	return ret;
-}
-EXPORT_SYMBOL(drm_buffer_object_create);
-
-
-static int drm_bo_add_user_object(struct drm_file *file_priv,
-				  struct drm_buffer_object *bo, int shareable)
-{
-	struct drm_device *dev = file_priv->minor->dev;
-	int ret;
-
-	mutex_lock(&dev->struct_mutex);
-	ret = drm_add_user_object(file_priv, &bo->base, shareable);
-	if (ret)
-		goto out;
-
-	bo->base.remove = drm_bo_base_deref_locked;
-	bo->base.type = drm_buffer_type;
-	bo->base.ref_struct_locked = NULL;
-	bo->base.unref = drm_buffer_user_object_unmap;
-
-out:
-	mutex_unlock(&dev->struct_mutex);
-	return ret;
-}
-
-int drm_bo_create_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv)
-{
-	struct drm_bo_create_arg *arg = data;
-	struct drm_bo_create_req *req = &arg->d.req;
-	struct drm_bo_info_rep *rep = &arg->d.rep;
-	struct drm_buffer_object *entry;
-	enum drm_bo_type bo_type;
-	int ret = 0;
-
-	DRM_DEBUG("drm_bo_create_ioctl: %dkb, %dkb align\n",
-	    (int)(req->size / 1024), req->page_alignment * 4);
-
-	if (!dev->bm.initialized) {
-		DRM_ERROR("Buffer object manager is not initialized.\n");
-		return -EINVAL;
-	}
-
-	/*
-	 * If the buffer creation request comes in with a starting address,
-	 * that points at the desired user pages to map. Otherwise, create
-	 * a drm_bo_type_device buffer, which uses pages allocated from the kernel
-	 */
-	bo_type = (req->buffer_start) ? drm_bo_type_user : drm_bo_type_device;
-
-	/*
-	 * User buffers cannot be shared
-	 */
-	if (bo_type == drm_bo_type_user)
-		req->flags &= ~DRM_BO_FLAG_SHAREABLE;
-
-	ret = drm_buffer_object_create(file_priv->minor->dev,
-				       req->size, bo_type, req->flags,
-				       req->hint, req->page_alignment,
-				       req->buffer_start, &entry);
-	if (ret)
-		goto out;
-
-	ret = drm_bo_add_user_object(file_priv, entry,
-				     req->flags & DRM_BO_FLAG_SHAREABLE);
-	if (ret) {
-		drm_bo_usage_deref_unlocked(&entry);
-		goto out;
-	}
-
-	mutex_lock(&entry->mutex);
-	drm_bo_fill_rep_arg(entry, rep);
-	mutex_unlock(&entry->mutex);
-
-out:
-	return ret;
-}
-
-int drm_bo_setstatus_ioctl(struct drm_device *dev,
-			   void *data, struct drm_file *file_priv)
-{
-	struct drm_bo_map_wait_idle_arg *arg = data;
-	struct drm_bo_info_req *req = &arg->d.req;
-	struct drm_bo_info_rep *rep = &arg->d.rep;
-	struct drm_buffer_object *bo;
-	int ret;
-
-	if (!dev->bm.initialized) {
-		DRM_ERROR("Buffer object manager is not initialized.\n");
-		return -EINVAL;
-	}
-
-	ret = drm_bo_read_lock(&dev->bm.bm_lock, 1);
-	if (ret)
-		return ret;
-
-	mutex_lock(&dev->struct_mutex);
-	bo = drm_lookup_buffer_object(file_priv, req->handle, 1);
-	mutex_unlock(&dev->struct_mutex);
-
-	if (!bo)
-		return -EINVAL;
-
-	if (bo->base.owner != file_priv)
-		req->mask &= ~(DRM_BO_FLAG_NO_EVICT | DRM_BO_FLAG_NO_MOVE);
-
-	ret = drm_bo_do_validate(bo, req->flags, req->mask,
-				 req->hint | DRM_BO_HINT_DONT_FENCE,
-				 bo->fence_class, rep);
-
-	drm_bo_usage_deref_unlocked(&bo);
-
-	(void) drm_bo_read_unlock(&dev->bm.bm_lock);
-
-	return ret;
-}
-
-int drm_bo_map_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv)
-{
-	struct drm_bo_map_wait_idle_arg *arg = data;
-	struct drm_bo_info_req *req = &arg->d.req;
-	struct drm_bo_info_rep *rep = &arg->d.rep;
-	int ret;
-	if (!dev->bm.initialized) {
-		DRM_ERROR("Buffer object manager is not initialized.\n");
-		return -EINVAL;
-	}
-
-	ret = drm_buffer_object_map(file_priv, req->handle, req->mask,
-				    req->hint, rep);
-	if (ret)
-		return ret;
-
-	return 0;
-}
-
-int drm_bo_unmap_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv)
-{
-	struct drm_bo_handle_arg *arg = data;
-	int ret;
-	if (!dev->bm.initialized) {
-		DRM_ERROR("Buffer object manager is not initialized.\n");
-		return -EINVAL;
-	}
-
-	ret = drm_buffer_object_unmap(file_priv, arg->handle);
-	return ret;
-}
-
-
-int drm_bo_reference_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv)
-{
-	struct drm_bo_reference_info_arg *arg = data;
-	struct drm_bo_handle_arg *req = &arg->d.req;
-	struct drm_bo_info_rep *rep = &arg->d.rep;
-	struct drm_user_object *uo;
-	int ret;
-
-	if (!dev->bm.initialized) {
-		DRM_ERROR("Buffer object manager is not initialized.\n");
-		return -EINVAL;
-	}
-
-	ret = drm_user_object_ref(file_priv, req->handle,
-				  drm_buffer_type, &uo);
-	if (ret)
-		return ret;
-
-	ret = drm_bo_handle_info(file_priv, req->handle, rep);
-	if (ret)
-		return ret;
-
-	return 0;
-}
-
-int drm_bo_unreference_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv)
-{
-	struct drm_bo_handle_arg *arg = data;
-	int ret = 0;
-
-	if (!dev->bm.initialized) {
-		DRM_ERROR("Buffer object manager is not initialized.\n");
-		return -EINVAL;
-	}
-
-	ret = drm_user_object_unref(file_priv, arg->handle, drm_buffer_type);
-	return ret;
-}
-
-int drm_bo_info_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv)
-{
-	struct drm_bo_reference_info_arg *arg = data;
-	struct drm_bo_handle_arg *req = &arg->d.req;
-	struct drm_bo_info_rep *rep = &arg->d.rep;
-	int ret;
-
-	if (!dev->bm.initialized) {
-		DRM_ERROR("Buffer object manager is not initialized.\n");
-		return -EINVAL;
-	}
-
-	ret = drm_bo_handle_info(file_priv, req->handle, rep);
-	if (ret)
-		return ret;
-
-	return 0;
-}
-
-int drm_bo_wait_idle_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv)
-{
-	struct drm_bo_map_wait_idle_arg *arg = data;
-	struct drm_bo_info_req *req = &arg->d.req;
-	struct drm_bo_info_rep *rep = &arg->d.rep;
-	int ret;
-	if (!dev->bm.initialized) {
-		DRM_ERROR("Buffer object manager is not initialized.\n");
-		return -EINVAL;
-	}
-
-	ret = drm_bo_handle_wait(file_priv, req->handle,
-				 req->hint, rep);
-	if (ret)
-		return ret;
-
-	return 0;
-}
-
-static int drm_bo_leave_list(struct drm_buffer_object *bo,
-			     uint32_t mem_type,
-			     int free_pinned,
-			     int allow_errors)
-{
-	struct drm_device *dev = bo->dev;
-	int ret = 0;
-
-	mutex_lock(&bo->mutex);
-
-	ret = drm_bo_expire_fence(bo, allow_errors);
-	if (ret)
-		goto out;
-
-	if (free_pinned) {
-		DRM_FLAG_MASKED(bo->mem.flags, 0, DRM_BO_FLAG_NO_MOVE);
-		mutex_lock(&dev->struct_mutex);
-		list_del_init(&bo->pinned_lru);
-		if (bo->pinned_node == bo->mem.mm_node)
-			bo->pinned_node = NULL;
-		if (bo->pinned_node != NULL) {
-			drm_mm_put_block(bo->pinned_node);
-			bo->pinned_node = NULL;
-		}
-		mutex_unlock(&dev->struct_mutex);
-	}
-
-	if (bo->mem.flags & DRM_BO_FLAG_NO_EVICT) {
-		DRM_ERROR("A DRM_BO_NO_EVICT buffer present at "
-			  "cleanup. Removing flag and evicting.\n");
-		bo->mem.flags &= ~DRM_BO_FLAG_NO_EVICT;
-		bo->mem.proposed_flags &= ~DRM_BO_FLAG_NO_EVICT;
-	}
-
-	if (bo->mem.mem_type == mem_type)
-		ret = drm_bo_evict(bo, mem_type, 0);
-
-	if (ret) {
-		if (allow_errors) {
-			goto out;
-		} else {
-			ret = 0;
-			DRM_ERROR("Cleanup eviction failed\n");
-		}
-	}
-
-out:
-	mutex_unlock(&bo->mutex);
-	return ret;
-}
-
-
-static struct drm_buffer_object *drm_bo_entry(struct list_head *list,
-					 int pinned_list)
-{
-	if (pinned_list)
-		return list_entry(list, struct drm_buffer_object, pinned_lru);
-	else
-		return list_entry(list, struct drm_buffer_object, lru);
-}
-
-/*
- * dev->struct_mutex locked.
- */
-
-static int drm_bo_force_list_clean(struct drm_device *dev,
-				   struct list_head *head,
-				   unsigned mem_type,
-				   int free_pinned,
-				   int allow_errors,
-				   int pinned_list)
-{
-	struct list_head *list, *next, *prev;
-	struct drm_buffer_object *entry, *nentry;
-	int ret;
-	int do_restart;
-
-	/*
-	 * The list traversal is a bit odd here, because an item may
-	 * disappear from the list when we release the struct_mutex or
-	 * when we decrease the usage count. Also we're not guaranteed
-	 * to drain pinned lists, so we can't always restart.
-	 */
-
-restart:
-	nentry = NULL;
-	list_for_each_safe(list, next, head) {
-		prev = list->prev;
-
-		entry = (nentry != NULL) ? nentry: drm_bo_entry(list, pinned_list);
-		atomic_inc(&entry->usage);
-		if (nentry) {
-			atomic_dec(&nentry->usage);
-			nentry = NULL;
-		}
-
-		/*
-		 * Protect the next item from destruction, so we can check
-		 * its list pointers later on.
-		 */
-
-		if (next != head) {
-			nentry = drm_bo_entry(next, pinned_list);
-			atomic_inc(&nentry->usage);
-		}
-		mutex_unlock(&dev->struct_mutex);
-
-		ret = drm_bo_leave_list(entry, mem_type, free_pinned,
-					allow_errors);
-		mutex_lock(&dev->struct_mutex);
-
-		drm_bo_usage_deref_locked(&entry);
-		if (ret)
-			return ret;
-
-		/*
-		 * Has the next item disappeared from the list?
-		 */
-
-		do_restart = ((next->prev != list) && (next->prev != prev));
-
-		if (nentry != NULL && do_restart)
-			drm_bo_usage_deref_locked(&nentry);
-
-		if (do_restart)
-			goto restart;
-	}
-	return 0;
-}
-
-int drm_bo_clean_mm(struct drm_device *dev, unsigned mem_type, int kern_clean)
-{
-	struct drm_buffer_manager *bm = &dev->bm;
-	struct drm_mem_type_manager *man = &bm->man[mem_type];
-	int ret = -EINVAL;
-
-	if (mem_type >= DRM_BO_MEM_TYPES) {
-		DRM_ERROR("Illegal memory type %d\n", mem_type);
-		return ret;
-	}
-
-	if (!man->has_type) {
-		DRM_ERROR("Trying to take down uninitialized "
-			  "memory manager type %u\n", mem_type);
-		return ret;
-	}
-
-	if ((man->kern_init_type) && (kern_clean == 0)) {
-		DRM_ERROR("Trying to take down kernel initialized "
-			  "memory manager type %u\n", mem_type);
-		return -EPERM;
-	}
-
-	man->use_type = 0;
-	man->has_type = 0;
-
-	ret = 0;
-	if (mem_type > 0) {
-		BUG_ON(!list_empty(&bm->unfenced));
-		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);
-		} else {
-			ret = -EBUSY;
-		}
-	}
-
-	return ret;
-}
-EXPORT_SYMBOL(drm_bo_clean_mm);
-
-/**
- *Evict all buffers of a particular mem_type, but leave memory manager
- *regions for NO_MOVE buffers intact. New buffers cannot be added at this
- *point since we have the hardware lock.
- */
-
-static int drm_bo_lock_mm(struct drm_device *dev, unsigned mem_type)
-{
-	int ret;
-	struct drm_buffer_manager *bm = &dev->bm;
-	struct drm_mem_type_manager *man = &bm->man[mem_type];
-
-	if (mem_type == 0 || mem_type >= DRM_BO_MEM_TYPES) {
-		DRM_ERROR("Illegal memory manager memory type %u.\n", mem_type);
-		return -EINVAL;
-	}
-
-	if (!man->has_type) {
-		DRM_ERROR("Memory type %u has not been initialized.\n",
-			  mem_type);
-		return 0;
-	}
-
-	ret = drm_bo_force_list_clean(dev, &man->lru, mem_type, 0, 1, 0);
-	if (ret)
-		return ret;
-	ret = drm_bo_force_list_clean(dev, &man->pinned, mem_type, 0, 1, 1);
-
-	return ret;
-}
-
-int drm_bo_init_mm(struct drm_device *dev, unsigned type,
-		   unsigned long p_offset, unsigned long p_size,
-		   int kern_init)
-{
-	struct drm_buffer_manager *bm = &dev->bm;
-	int ret = -EINVAL;
-	struct drm_mem_type_manager *man;
-
-	if (type >= DRM_BO_MEM_TYPES) {
-		DRM_ERROR("Illegal memory type %d\n", type);
-		return ret;
-	}
-
-	man = &bm->man[type];
-	if (man->has_type) {
-		DRM_ERROR("Memory manager already initialized for type %d\n",
-			  type);
-		return ret;
-	}
-
-	ret = dev->driver->bo_driver->init_mem_type(dev, type, man);
-	if (ret)
-		return ret;
-
-	ret = 0;
-	if (type != DRM_BO_MEM_LOCAL) {
-		if (!p_size) {
-			DRM_ERROR("Zero size memory manager type %d\n", type);
-			return ret;
-		}
-		ret = drm_mm_init(&man->manager, p_offset, p_size);
-		if (ret)
-			return ret;
-	}
-	man->has_type = 1;
-	man->use_type = 1;
-	man->kern_init_type = kern_init;
-	man->size = p_size;
-
-	INIT_LIST_HEAD(&man->lru);
-	INIT_LIST_HEAD(&man->pinned);
-
-	return 0;
-}
-EXPORT_SYMBOL(drm_bo_init_mm);
-
-/*
- * This function is intended to be called on drm driver unload.
- * If you decide to call it from lastclose, you must protect the call
- * from a potentially racing drm_bo_driver_init in firstopen.
- * (This may happen on X server restart).
- */
-
-int drm_bo_driver_finish(struct drm_device *dev)
-{
-	struct drm_buffer_manager *bm = &dev->bm;
-	int ret = 0;
-	unsigned i = DRM_BO_MEM_TYPES;
-	struct drm_mem_type_manager *man;
-
-	mutex_lock(&dev->struct_mutex);
-
-	if (!bm->initialized)
-		goto out;
-	bm->initialized = 0;
-
-	while (i--) {
-		man = &bm->man[i];
-		if (man->has_type) {
-			man->use_type = 0;
-			if ((i != DRM_BO_MEM_LOCAL) && drm_bo_clean_mm(dev, i, 1)) {
-				ret = -EBUSY;
-				DRM_ERROR("DRM memory manager type %d "
-					  "is not clean.\n", i);
-			}
-			man->has_type = 0;
-		}
-	}
-	mutex_unlock(&dev->struct_mutex);
-
-	if (!cancel_delayed_work(&bm->wq))
-		flush_scheduled_work();
-
-	mutex_lock(&dev->struct_mutex);
-	drm_bo_delayed_delete(dev, 1);
-	if (list_empty(&bm->ddestroy))
-		DRM_DEBUG("Delayed destroy list was clean\n");
-
-	if (list_empty(&bm->man[0].lru))
-		DRM_DEBUG("Swap list was clean\n");
-
-	if (list_empty(&bm->man[0].pinned))
-		DRM_DEBUG("NO_MOVE list was clean\n");
-
-	if (list_empty(&bm->unfenced))
-		DRM_DEBUG("Unfenced list was clean\n");
-
-	__free_page(bm->dummy_read_page);
-
-out:
-	mutex_unlock(&dev->struct_mutex);
-	return ret;
-}
-
-/*
- * This function is intended to be called on drm driver load.
- * If you decide to call it from firstopen, you must protect the call
- * from a potentially racing drm_bo_driver_finish in lastclose.
- * (This may happen on X server restart).
- */
-
-int drm_bo_driver_init(struct drm_device *dev)
-{
-	struct drm_bo_driver *driver = dev->driver->bo_driver;
-	struct drm_buffer_manager *bm = &dev->bm;
-	int ret = -EINVAL;
-
-	bm->dummy_read_page = NULL;
-	drm_bo_init_lock(&bm->bm_lock);
-	mutex_lock(&dev->struct_mutex);
-	if (!driver)
-		goto out_unlock;
-
-	bm->dummy_read_page = alloc_page(__GFP_ZERO | GFP_DMA32);
-	if (!bm->dummy_read_page) {
-		ret = -ENOMEM;
-		goto out_unlock;
-	}
-
-	/*
-	 * Initialize the system memory buffer type.
-	 * Other types need to be driver / IOCTL initialized.
-	 */
-	ret = drm_bo_init_mm(dev, DRM_BO_MEM_LOCAL, 0, 0, 1);
-	if (ret)
-		goto out_unlock;
-
-	INIT_DELAYED_WORK(&bm->wq, drm_bo_delayed_workqueue);
-	bm->initialized = 1;
-	bm->nice_mode = 1;
-	atomic_set(&bm->count, 0);
-	bm->cur_pages = 0;
-	INIT_LIST_HEAD(&bm->unfenced);
-	INIT_LIST_HEAD(&bm->ddestroy);
-out_unlock:
-	mutex_unlock(&dev->struct_mutex);
-	return ret;
-}
-EXPORT_SYMBOL(drm_bo_driver_init);
-
-int drm_mm_init_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv)
-{
-	struct drm_mm_init_arg *arg = data;
-	struct drm_buffer_manager *bm = &dev->bm;
-	struct drm_bo_driver *driver = dev->driver->bo_driver;
-	int ret;
-
-	if (!driver) {
-		DRM_ERROR("Buffer objects are not supported by this driver\n");
-		return -EINVAL;
-	}
-
-	ret = drm_bo_write_lock(&bm->bm_lock, 1, file_priv);
-	if (ret)
-		return ret;
-
-	ret = -EINVAL;
-	if (arg->magic != DRM_BO_INIT_MAGIC) {
-		DRM_ERROR("You are using an old libdrm that is not compatible with\n"
-			  "\tthe kernel DRM module. Please upgrade your libdrm.\n");
-		return -EINVAL;
-	}
-	if (arg->major != DRM_BO_INIT_MAJOR) {
-		DRM_ERROR("libdrm and kernel DRM buffer object interface major\n"
-			  "\tversion don't match. Got %d, expected %d.\n",
-			  arg->major, DRM_BO_INIT_MAJOR);
-		return -EINVAL;
-	}
-
-	mutex_lock(&dev->struct_mutex);
-	if (!bm->initialized) {
-		DRM_ERROR("DRM memory manager was not initialized.\n");
-		goto out;
-	}
-	if (arg->mem_type == 0) {
-		DRM_ERROR("System memory buffers already initialized.\n");
-		goto out;
-	}
-	ret = drm_bo_init_mm(dev, arg->mem_type,
-			     arg->p_offset, arg->p_size, 0);
-
-out:
-	mutex_unlock(&dev->struct_mutex);
-	(void) drm_bo_write_unlock(&bm->bm_lock, file_priv);
-
-	if (ret)
-		return ret;
-
-	return 0;
-}
-
-int drm_mm_takedown_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv)
-{
-	struct drm_mm_type_arg *arg = data;
-	struct drm_buffer_manager *bm = &dev->bm;
-	struct drm_bo_driver *driver = dev->driver->bo_driver;
-	int ret;
-
-	if (!driver) {
-		DRM_ERROR("Buffer objects are not supported by this driver\n");
-		return -EINVAL;
-	}
-
-	ret = drm_bo_write_lock(&bm->bm_lock, 0, file_priv);
-	if (ret)
-		return ret;
-
-	mutex_lock(&dev->struct_mutex);
-	ret = -EINVAL;
-	if (!bm->initialized) {
-		DRM_ERROR("DRM memory manager was not initialized\n");
-		goto out;
-	}
-	if (arg->mem_type == 0) {
-		DRM_ERROR("No takedown for System memory buffers.\n");
-		goto out;
-	}
-	ret = 0;
-	if ((ret = drm_bo_clean_mm(dev, arg->mem_type, 0))) {
-		if (ret == -EINVAL)
-			DRM_ERROR("Memory manager type %d not clean. "
-				  "Delaying takedown\n", arg->mem_type);
-		ret = 0;
-	}
-out:
-	mutex_unlock(&dev->struct_mutex);
-	(void) drm_bo_write_unlock(&bm->bm_lock, file_priv);
-
-	if (ret)
-		return ret;
-
-	return 0;
-}
-
-int drm_mm_lock_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv)
-{
-	struct drm_mm_type_arg *arg = data;
-	struct drm_bo_driver *driver = dev->driver->bo_driver;
-	int ret;
-
-	if (!driver) {
-		DRM_ERROR("Buffer objects are not supported by this driver\n");
-		return -EINVAL;
-	}
-
-	if (arg->lock_flags & DRM_BO_LOCK_IGNORE_NO_EVICT) {
-		DRM_ERROR("Lock flag DRM_BO_LOCK_IGNORE_NO_EVICT not supported yet.\n");
-		return -EINVAL;
-	}
-
-	if (arg->lock_flags & DRM_BO_LOCK_UNLOCK_BM) {
-		ret = drm_bo_write_lock(&dev->bm.bm_lock, 1, file_priv);
-		if (ret)
-			return ret;
-	}
-
-	mutex_lock(&dev->struct_mutex);
-	ret = drm_bo_lock_mm(dev, arg->mem_type);
-	mutex_unlock(&dev->struct_mutex);
-	if (ret) {
-		(void) drm_bo_write_unlock(&dev->bm.bm_lock, file_priv);
-		return ret;
-	}
-
-	return 0;
-}
-
-int drm_mm_unlock_ioctl(struct drm_device *dev,
-			void *data,
-			struct drm_file *file_priv)
-{
-	struct drm_mm_type_arg *arg = data;
-	struct drm_bo_driver *driver = dev->driver->bo_driver;
-	int ret;
-
-	if (!driver) {
-		DRM_ERROR("Buffer objects are not supported by this driver\n");
-		return -EINVAL;
-	}
-
-	if (arg->lock_flags & DRM_BO_LOCK_UNLOCK_BM) {
-		ret = drm_bo_write_unlock(&dev->bm.bm_lock, file_priv);
-		if (ret)
-			return ret;
-	}
-
-	return 0;
-}
-
-int drm_mm_info_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv)
-{
-	struct drm_mm_info_arg *arg = data;
-	struct drm_buffer_manager *bm = &dev->bm;
-	struct drm_bo_driver *driver = dev->driver->bo_driver;
-	struct drm_mem_type_manager *man;
-	int ret = 0;
-	int mem_type = arg->mem_type;
-
-	if (!driver) {
-		DRM_ERROR("Buffer objects are not supported by this driver\n");
-		return -EINVAL;
-	}
-
-	if (mem_type >= DRM_BO_MEM_TYPES) {
-		DRM_ERROR("Illegal memory type %d\n", arg->mem_type);
-		return -EINVAL;
-	}
-
-	mutex_lock(&dev->struct_mutex);
-	if (!bm->initialized) {
-		DRM_ERROR("DRM memory manager was not initialized\n");
-		ret = -EINVAL;
-		goto out;
-	}
-
-
-	man = &bm->man[arg->mem_type];
-
-	arg->p_size = man->size;
-
-out:
-	mutex_unlock(&dev->struct_mutex);
-     
-	return ret;
-}
-/*
- * buffer object vm functions.
- */
-
-int drm_mem_reg_is_pci(struct drm_device *dev, struct drm_bo_mem_reg *mem)
-{
-	struct drm_buffer_manager *bm = &dev->bm;
-	struct drm_mem_type_manager *man = &bm->man[mem->mem_type];
-
-	if (!(man->flags & _DRM_FLAG_MEMTYPE_FIXED)) {
-		if (mem->mem_type == DRM_BO_MEM_LOCAL)
-			return 0;
-
-		if (man->flags & _DRM_FLAG_MEMTYPE_CMA)
-			return 0;
-
-		if (mem->flags & DRM_BO_FLAG_CACHED)
-			return 0;
-	}
-	return 1;
-}
-EXPORT_SYMBOL(drm_mem_reg_is_pci);
-
-/**
- * \c Get the PCI offset for the buffer object memory.
- *
- * \param bo The buffer object.
- * \param bus_base On return the base of the PCI region
- * \param bus_offset On return the byte offset into the PCI region
- * \param bus_size On return the byte size of the buffer object or zero if
- *     the buffer object memory is not accessible through a PCI region.
- * \return Failure indication.
- *
- * Returns -EINVAL if the buffer object is currently not mappable.
- * Otherwise returns zero.
- */
-
-int drm_bo_pci_offset(struct drm_device *dev,
-		      struct drm_bo_mem_reg *mem,
-		      unsigned long *bus_base,
-		      unsigned long *bus_offset, unsigned long *bus_size)
-{
-	struct drm_buffer_manager *bm = &dev->bm;
-	struct drm_mem_type_manager *man = &bm->man[mem->mem_type];
-
-	*bus_size = 0;
-	if (!(man->flags & _DRM_FLAG_MEMTYPE_MAPPABLE))
-		return -EINVAL;
-
-	if (drm_mem_reg_is_pci(dev, mem)) {
-		*bus_offset = mem->mm_node->start << PAGE_SHIFT;
-		*bus_size = mem->num_pages << PAGE_SHIFT;
-		*bus_base = man->io_offset;
-	}
-
-	return 0;
-}
-
-/**
- * \c Kill all user-space virtual mappings of this buffer object.
- *
- * \param bo The buffer object.
- *
- * Call bo->mutex locked.
- */
-
-void drm_bo_unmap_virtual(struct drm_buffer_object *bo)
-{
-	struct drm_device *dev = bo->dev;
-	loff_t offset = ((loff_t) bo->map_list.hash.key) << PAGE_SHIFT;
-	loff_t holelen = ((loff_t) bo->mem.num_pages) << PAGE_SHIFT;
-
-	if (!dev->dev_mapping)
-		return;
-
-	unmap_mapping_range(dev->dev_mapping, offset, holelen, 1);
-}
-
-/**
- * drm_bo_takedown_vm_locked:
- *
- * @bo: the buffer object to remove any drm device mapping
- *
- * Remove any associated vm mapping on the drm device node that
- * would have been created for a drm_bo_type_device buffer
- */
-static void drm_bo_takedown_vm_locked(struct drm_buffer_object *bo)
-{
-	struct drm_map_list *list;
-	drm_local_map_t *map;
-	struct drm_device *dev = bo->dev;
-
-	DRM_ASSERT_LOCKED(&dev->struct_mutex);
-	if (bo->type != drm_bo_type_device)
-		return;
-
-	list = &bo->map_list;
-	if (list->user_token) {
-		drm_ht_remove_item(&dev->map_hash, &list->hash);
-		list->user_token = 0;
-	}
-	if (list->file_offset_node) {
-		drm_mm_put_block(list->file_offset_node);
-		list->file_offset_node = NULL;
-	}
-
-	map = list->map;
-	if (!map)
-		return;
-
-	drm_ctl_free(map, sizeof(*map), DRM_MEM_BUFOBJ);
-	list->map = NULL;
-	list->user_token = 0ULL;
-	drm_bo_usage_deref_locked(&bo);
-}
-
-/**
- * drm_bo_setup_vm_locked:
- *
- * @bo: the buffer to allocate address space for
- *
- * Allocate address space in the drm device so that applications
- * can mmap the buffer and access the contents. This only
- * applies to drm_bo_type_device objects as others are not
- * placed in the drm device address space.
- */
-static int drm_bo_setup_vm_locked(struct drm_buffer_object *bo)
-{
-	struct drm_map_list *list = &bo->map_list;
-	drm_local_map_t *map;
-	struct drm_device *dev = bo->dev;
-
-	DRM_ASSERT_LOCKED(&dev->struct_mutex);
-	list->map = drm_ctl_calloc(1, sizeof(*map), DRM_MEM_BUFOBJ);
-	if (!list->map)
-		return -ENOMEM;
-
-	map = list->map;
-	map->offset = 0;
-	map->type = _DRM_TTM;
-	map->flags = _DRM_REMOVABLE;
-	map->size = bo->mem.num_pages * PAGE_SIZE;
-	atomic_inc(&bo->usage);
-	map->handle = (void *)bo;
-
-	list->file_offset_node = drm_mm_search_free(&dev->offset_manager,
-						    bo->mem.num_pages, 0, 0);
-
-	if (unlikely(!list->file_offset_node)) {
-		drm_bo_takedown_vm_locked(bo);
-		return -ENOMEM;
-	}
-
-	list->file_offset_node = drm_mm_get_block(list->file_offset_node,
-						  bo->mem.num_pages, 0);
-
-	if (unlikely(!list->file_offset_node)) {
-		drm_bo_takedown_vm_locked(bo);
-		return -ENOMEM;
-	}
-		
-	list->hash.key = list->file_offset_node->start;
-	if (drm_ht_insert_item(&dev->map_hash, &list->hash)) {
-		drm_bo_takedown_vm_locked(bo);
-		return -ENOMEM;
-	}
-
-	list->user_token = ((uint64_t) list->hash.key) << PAGE_SHIFT;
-
-	return 0;
-}
-
-int drm_bo_version_ioctl(struct drm_device *dev, void *data,
-			 struct drm_file *file_priv)
-{
-	struct drm_bo_version_arg *arg = (struct drm_bo_version_arg *)data;
-
-	arg->major = DRM_BO_INIT_MAJOR;
-	arg->minor = DRM_BO_INIT_MINOR;
-	arg->patchlevel = DRM_BO_INIT_PATCH;
-
-	return 0;
-}
diff --git a/linux-core/drm_bo_lock.c b/linux-core/drm_bo_lock.c
deleted file mode 100644
index 08b1c6be..00000000
--- a/linux-core/drm_bo_lock.c
+++ /dev/null
@@ -1,189 +0,0 @@
-/**************************************************************************
- *
- * Copyright (c) 2007 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 Hellström <thomas-at-tungstengraphics-dot-com>
- */
-
-/*
- * This file implements a simple replacement for the buffer manager use
- * of the heavyweight hardware lock.
- * The lock is a read-write lock. Taking it in read mode is fast, and
- * intended for in-kernel use only.
- * Taking it in write mode is slow.
- *
- * The write mode is used only when there is a need to block all
- * user-space processes from allocating a
- * new memory area.
- * Typical use in write mode is X server VT switching, and it's allowed
- * to leave kernel space with the write lock held. If a user-space process
- * dies while having the write-lock, it will be released during the file
- * descriptor release.
- *
- * The read lock is typically placed at the start of an IOCTL- or
- * user-space callable function that may end up allocating a memory area.
- * This includes setstatus, super-ioctls and no_pfn; the latter may move
- * unmappable regions to mappable. It's a bug to leave kernel space with the
- * read lock held.
- *
- * Both read- and write lock taking may be interruptible for low signal-delivery
- * latency. The locking functions will return -EAGAIN if interrupted by a
- * signal.
- *
- * Locking order: The lock should be taken BEFORE any kernel mutexes
- * or spinlocks.
- */
-
-#include "drmP.h"
-
-void drm_bo_init_lock(struct drm_bo_lock *lock)
-{
-	DRM_INIT_WAITQUEUE(&lock->queue);
-	atomic_set(&lock->write_lock_pending, 0);
-	atomic_set(&lock->readers, 0);
-}
-
-void drm_bo_read_unlock(struct drm_bo_lock *lock)
-{
-	if (atomic_dec_and_test(&lock->readers))
-		wake_up_all(&lock->queue);
-}
-EXPORT_SYMBOL(drm_bo_read_unlock);
-
-int drm_bo_read_lock(struct drm_bo_lock *lock, int interruptible)
-{
-	while (unlikely(atomic_read(&lock->write_lock_pending) != 0)) {
-		int ret;
-		
-		if (!interruptible) {
-			wait_event(lock->queue,
-				   atomic_read(&lock->write_lock_pending) == 0);
-			continue;
-		}
-		ret = wait_event_interruptible
-		    (lock->queue, atomic_read(&lock->write_lock_pending) == 0);
-		if (ret)
-			return -EAGAIN;
-	}
-
-	while (unlikely(!atomic_add_unless(&lock->readers, 1, -1))) {
-		int ret;
-		if (!interruptible) {
-			wait_event(lock->queue,
-				   atomic_read(&lock->readers) != -1);
-			continue;
-		}
-		ret = wait_event_interruptible
-			(lock->queue, atomic_read(&lock->readers) != -1);
-		if (ret)
-			return -EAGAIN;
-	}
-	return 0;
-}
-EXPORT_SYMBOL(drm_bo_read_lock);
-
-static int __drm_bo_write_unlock(struct drm_bo_lock *lock)
-{
-	if (unlikely(atomic_cmpxchg(&lock->readers, -1, 0) != -1))
-		return -EINVAL;
-	wake_up_all(&lock->queue);
-	return 0;
-}
-
-static void drm_bo_write_lock_remove(struct drm_file *file_priv,
-				     struct drm_user_object *item)
-{
-	struct drm_bo_lock *lock = container_of(item, struct drm_bo_lock, base);
-	int ret;
-
-	ret = __drm_bo_write_unlock(lock);
-	BUG_ON(ret);
-}
-
-int drm_bo_write_lock(struct drm_bo_lock *lock, int interruptible,
-		      struct drm_file *file_priv)
-{
-	int ret = 0;
-	struct drm_device *dev;
-
-	atomic_inc(&lock->write_lock_pending);
-
-	while (unlikely(atomic_cmpxchg(&lock->readers, 0, -1) != 0)) {
-		if (!interruptible) {
-			wait_event(lock->queue,
-				   atomic_read(&lock->readers) == 0);
-			continue;
-		}
-		ret = wait_event_interruptible
-		    (lock->queue, atomic_read(&lock->readers) == 0);
-
-		if (ret) {
-			atomic_dec(&lock->write_lock_pending);
-			wake_up_all(&lock->queue);
-			return -EAGAIN;
-		}
-	}
-
-	/*
-	 * Add a dummy user-object, the destructor of which will
-	 * make sure the lock is released if the client dies
-	 * while holding it.
-	 */
-
-	if (atomic_dec_and_test(&lock->write_lock_pending))
-		wake_up_all(&lock->queue);
-	dev = file_priv->minor->dev;
-	mutex_lock(&dev->struct_mutex);
-	ret = drm_add_user_object(file_priv, &lock->base, 0);
-	lock->base.remove = &drm_bo_write_lock_remove;
-	lock->base.type = drm_lock_type;
-	if (ret)
-		(void)__drm_bo_write_unlock(lock);
-
-	mutex_unlock(&dev->struct_mutex);
-
-	return ret;
-}
-
-int drm_bo_write_unlock(struct drm_bo_lock *lock, struct drm_file *file_priv)
-{
-	struct drm_device *dev = file_priv->minor->dev;
-	struct drm_ref_object *ro;
-
-	mutex_lock(&dev->struct_mutex);
-
-	if (lock->base.owner != file_priv) {
-		mutex_unlock(&dev->struct_mutex);
-		return -EINVAL;
-	}
-	ro = drm_lookup_ref_object(file_priv, &lock->base, _DRM_REF_USE);
-	BUG_ON(!ro);
-	drm_remove_ref_object(file_priv, ro);
-	lock->base.owner = NULL;
-
-	mutex_unlock(&dev->struct_mutex);
-	return 0;
-}
diff --git a/linux-core/drm_bo_move.c b/linux-core/drm_bo_move.c
deleted file mode 100644
index d794e985..00000000
--- a/linux-core/drm_bo_move.c
+++ /dev/null
@@ -1,614 +0,0 @@
-/**************************************************************************
- *
- * Copyright (c) 2007 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 Hellström <thomas-at-tungstengraphics-dot-com>
- */
-
-#include "drmP.h"
-
-/**
- * Free the old memory node unless it's a pinned region and we
- * have not been requested to free also pinned regions.
- */
-
-static void drm_bo_free_old_node(struct drm_buffer_object *bo)
-{
-	struct drm_bo_mem_reg *old_mem = &bo->mem;
-
-	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);
-		mutex_unlock(&bo->dev->struct_mutex);
-	}
-	old_mem->mm_node = NULL;
-}
-
-int drm_bo_move_ttm(struct drm_buffer_object *bo,
-		    int evict, int no_wait, struct drm_bo_mem_reg *new_mem)
-{
-	struct drm_ttm *ttm = bo->ttm;
-	struct drm_bo_mem_reg *old_mem = &bo->mem;
-	uint64_t save_flags = old_mem->flags;
-	uint64_t save_proposed_flags = old_mem->proposed_flags;
-	int ret;
-
-	if (old_mem->mem_type != DRM_BO_MEM_LOCAL) {
-		if (evict)
-			drm_ttm_evict(ttm);
-		else
-			drm_ttm_unbind(ttm);
-
-		drm_bo_free_old_node(bo);
-		DRM_FLAG_MASKED(old_mem->flags,
-				DRM_BO_FLAG_CACHED | DRM_BO_FLAG_MAPPABLE |
-				DRM_BO_FLAG_MEM_LOCAL, DRM_BO_MASK_MEMTYPE);
-		old_mem->mem_type = DRM_BO_MEM_LOCAL;
-		save_flags = old_mem->flags;
-	}
-	if (new_mem->mem_type != DRM_BO_MEM_LOCAL) {
-		ret = drm_ttm_bind(ttm, new_mem);
-		if (ret)
-			return ret;
-	}
-
-	*old_mem = *new_mem;
-	new_mem->mm_node = NULL;
-	old_mem->proposed_flags = save_proposed_flags;
-	DRM_FLAG_MASKED(save_flags, new_mem->flags, DRM_BO_MASK_MEMTYPE);
-	return 0;
-}
-EXPORT_SYMBOL(drm_bo_move_ttm);
-
-/**
- * \c Return a kernel virtual address to the buffer object PCI memory.
- *
- * \param bo The buffer object.
- * \return Failure indication.
- *
- * Returns -EINVAL if the buffer object is currently not mappable.
- * Returns -ENOMEM if the ioremap operation failed.
- * Otherwise returns zero.
- *
- * After a successfull call, bo->iomap contains the virtual address, or NULL
- * if the buffer object content is not accessible through PCI space.
- * Call bo->mutex locked.
- */
-
-int drm_mem_reg_ioremap(struct drm_device *dev, struct drm_bo_mem_reg *mem,
-			void **virtual)
-{
-	struct drm_buffer_manager *bm = &dev->bm;
-	struct drm_mem_type_manager *man = &bm->man[mem->mem_type];
-	unsigned long bus_offset;
-	unsigned long bus_size;
-	unsigned long bus_base;
-	int ret;
-	void *addr;
-
-	*virtual = NULL;
-	ret = drm_bo_pci_offset(dev, mem, &bus_base, &bus_offset, &bus_size);
-	if (ret || bus_size == 0)
-		return ret;
-
-	if (!(man->flags & _DRM_FLAG_NEEDS_IOREMAP))
-		addr = (void *)(((u8 *) man->io_addr) + bus_offset);
-	else {
-		addr = ioremap_nocache(bus_base + bus_offset, bus_size);
-		if (!addr)
-			return -ENOMEM;
-	}
-	*virtual = addr;
-	return 0;
-}
-EXPORT_SYMBOL(drm_mem_reg_ioremap);
-
-/**
- * \c Unmap mapping obtained using drm_bo_ioremap
- *
- * \param bo The buffer object.
- *
- * Call bo->mutex locked.
- */
-
-void drm_mem_reg_iounmap(struct drm_device *dev, struct drm_bo_mem_reg *mem,
-			 void *virtual)
-{
-	struct drm_buffer_manager *bm;
-	struct drm_mem_type_manager *man;
-
-	bm = &dev->bm;
-	man = &bm->man[mem->mem_type];
-
-	if (virtual && (man->flags & _DRM_FLAG_NEEDS_IOREMAP))
-		iounmap(virtual);
-}
-
-static int drm_copy_io_page(void *dst, void *src, unsigned long page)
-{
-	uint32_t *dstP =
-	    (uint32_t *) ((unsigned long)dst + (page << PAGE_SHIFT));
-	uint32_t *srcP =
-	    (uint32_t *) ((unsigned long)src + (page << PAGE_SHIFT));
-
-	int i;
-	for (i = 0; i < PAGE_SIZE / sizeof(uint32_t); ++i)
-		iowrite32(ioread32(srcP++), dstP++);
-	return 0;
-}
-
-static int drm_copy_io_ttm_page(struct drm_ttm *ttm, void *src,
-				unsigned long page)
-{
-	struct page *d = drm_ttm_get_page(ttm, page);
-	void *dst;
-
-	if (!d)
-		return -ENOMEM;
-
-	src = (void *)((unsigned long)src + (page << PAGE_SHIFT));
-	dst = kmap(d);
-	if (!dst)
-		return -ENOMEM;
-
-	memcpy_fromio(dst, src, PAGE_SIZE);
-	kunmap(d);
-	return 0;
-}
-
-static int drm_copy_ttm_io_page(struct drm_ttm *ttm, void *dst, unsigned long page)
-{
-	struct page *s = drm_ttm_get_page(ttm, page);
-	void *src;
-
-	if (!s)
-		return -ENOMEM;
-
-	dst = (void *)((unsigned long)dst + (page << PAGE_SHIFT));
-	src = kmap(s);
-	if (!src)
-		return -ENOMEM;
-
-	memcpy_toio(dst, src, PAGE_SIZE);
-	kunmap(s);
-	return 0;
-}
-
-int drm_bo_move_memcpy(struct drm_buffer_object *bo,
-		       int evict, int no_wait, struct drm_bo_mem_reg *new_mem)
-{
-	struct drm_device *dev = bo->dev;
-	struct drm_mem_type_manager *man = &dev->bm.man[new_mem->mem_type];
-	struct drm_ttm *ttm = bo->ttm;
-	struct drm_bo_mem_reg *old_mem = &bo->mem;
-	struct drm_bo_mem_reg old_copy = *old_mem;
-	void *old_iomap;
-	void *new_iomap;
-	int ret;
-	uint64_t save_flags = old_mem->flags;
-	uint64_t save_proposed_flags = old_mem->proposed_flags;
-	unsigned long i;
-	unsigned long page;
-	unsigned long add = 0;
-	int dir;
-
-	ret = drm_mem_reg_ioremap(dev, old_mem, &old_iomap);
-	if (ret)
-		return ret;
-	ret = drm_mem_reg_ioremap(dev, new_mem, &new_iomap);
-	if (ret)
-		goto out;
-
-	if (old_iomap == NULL && new_iomap == NULL)
-		goto out2;
-	if (old_iomap == NULL && ttm == NULL)
-		goto out2;
-
-	add = 0;
-	dir = 1;
-
-	if ((old_mem->mem_type == new_mem->mem_type) &&
-	    (new_mem->mm_node->start <
-	     old_mem->mm_node->start + old_mem->mm_node->size)) {
-		dir = -1;
-		add = new_mem->num_pages - 1;
-	}
-
-	for (i = 0; i < new_mem->num_pages; ++i) {
-		page = i * dir + add;
-		if (old_iomap == NULL)
-			ret = drm_copy_ttm_io_page(ttm, new_iomap, page);
-		else if (new_iomap == NULL)
-			ret = drm_copy_io_ttm_page(ttm, old_iomap, page);
-		else
-			ret = drm_copy_io_page(new_iomap, old_iomap, page);
-		if (ret)
-			goto out1;
-	}
-	mb();
-out2:
-	drm_bo_free_old_node(bo);
-
-	*old_mem = *new_mem;
-	new_mem->mm_node = NULL;
-	old_mem->proposed_flags = save_proposed_flags;
-	DRM_FLAG_MASKED(save_flags, new_mem->flags, DRM_BO_MASK_MEMTYPE);
-
-	if ((man->flags & _DRM_FLAG_MEMTYPE_FIXED) && (ttm != NULL)) {
-		drm_ttm_unbind(ttm);
-		drm_ttm_destroy(ttm);
-		bo->ttm = NULL;
-	}
-
-out1:
-	drm_mem_reg_iounmap(dev, new_mem, new_iomap);
-out:
-	drm_mem_reg_iounmap(dev, &old_copy, old_iomap);
-	return ret;
-}
-EXPORT_SYMBOL(drm_bo_move_memcpy);
-
-/*
- * Transfer a buffer object's memory and LRU status to a newly
- * created object. User-space references remains with the old
- * object. Call bo->mutex locked.
- */
-
-int drm_buffer_object_transfer(struct drm_buffer_object *bo,
-			       struct drm_buffer_object **new_obj)
-{
-	struct drm_buffer_object *fbo;
-	struct drm_device *dev = bo->dev;
-	struct drm_buffer_manager *bm = &dev->bm;
-
-	fbo = drm_ctl_calloc(1, sizeof(*fbo), DRM_MEM_BUFOBJ);
-	if (!fbo)
-		return -ENOMEM;
-
-	*fbo = *bo;
-	mutex_init(&fbo->mutex);
-	mutex_lock(&fbo->mutex);
-	mutex_lock(&dev->struct_mutex);
-
-	DRM_INIT_WAITQUEUE(&bo->event_queue);
-	INIT_LIST_HEAD(&fbo->ddestroy);
-	INIT_LIST_HEAD(&fbo->lru);
-	INIT_LIST_HEAD(&fbo->pinned_lru);
-
-	fbo->fence = drm_fence_reference_locked(bo->fence);
-	fbo->pinned_node = NULL;
-	fbo->mem.mm_node->private = (void *)fbo;
-	atomic_set(&fbo->usage, 1);
-	atomic_inc(&bm->count);
-	mutex_unlock(&dev->struct_mutex);
-	mutex_unlock(&fbo->mutex);
-
-	*new_obj = fbo;
-	return 0;
-}
-
-/*
- * Since move is underway, we need to block signals in this function.
- * We cannot restart until it has finished.
- */
-
-int drm_bo_move_accel_cleanup(struct drm_buffer_object *bo,
-			      int evict, int no_wait, uint32_t fence_class,
-			      uint32_t fence_type, uint32_t fence_flags,
-			      struct drm_bo_mem_reg *new_mem)
-{
-	struct drm_device *dev = bo->dev;
-	struct drm_mem_type_manager *man = &dev->bm.man[new_mem->mem_type];
-	struct drm_bo_mem_reg *old_mem = &bo->mem;
-	int ret;
-	uint64_t save_flags = old_mem->flags;
-	uint64_t save_proposed_flags = old_mem->proposed_flags;
-	struct drm_buffer_object *old_obj;
-
-	if (bo->fence)
-		drm_fence_usage_deref_unlocked(&bo->fence);
-	ret = drm_fence_object_create(dev, fence_class, fence_type,
-				      fence_flags | DRM_FENCE_FLAG_EMIT,
-				      &bo->fence);
-	bo->fence_type = fence_type;
-	if (ret)
-		return ret;
-
-	if (evict || ((bo->mem.mm_node == bo->pinned_node) &&
-		      bo->mem.mm_node != NULL))
-	{
-		if (bo->fence) {
-			(void) drm_fence_object_wait(bo->fence, 0, 1,
-						    bo->fence_type);
-			drm_fence_usage_deref_unlocked(&bo->fence);
-		}
-		drm_bo_free_old_node(bo);
-
-		if ((man->flags & _DRM_FLAG_MEMTYPE_FIXED) && (bo->ttm != NULL)) {
-			drm_ttm_unbind(bo->ttm);
-			drm_ttm_destroy(bo->ttm);
-			bo->ttm = NULL;
-		}
-	} else {
-
-		/* This should help pipeline ordinary buffer moves.
-		 *
-		 * Hang old buffer memory on a new buffer object,
-		 * and leave it to be released when the GPU
-		 * operation has completed.
-		 */
-
-		ret = drm_buffer_object_transfer(bo, &old_obj);
-
-		if (ret)
-			return ret;
-
-		if (!(man->flags & _DRM_FLAG_MEMTYPE_FIXED))
-			old_obj->ttm = NULL;
-		else
-			bo->ttm = NULL;
-
-		mutex_lock(&dev->struct_mutex);
-		list_del_init(&old_obj->lru);
-		DRM_FLAG_MASKED(bo->priv_flags, 0, _DRM_BO_FLAG_UNFENCED);
-		drm_bo_add_to_lru(old_obj);
-
-		drm_bo_usage_deref_locked(&old_obj);
-		mutex_unlock(&dev->struct_mutex);
-
-	}
-
-	*old_mem = *new_mem;
-	new_mem->mm_node = NULL;
-	old_mem->proposed_flags = save_proposed_flags;
-	DRM_FLAG_MASKED(save_flags, new_mem->flags, DRM_BO_MASK_MEMTYPE);
-	return 0;
-}
-EXPORT_SYMBOL(drm_bo_move_accel_cleanup);
-
-int drm_bo_same_page(unsigned long offset,
-		     unsigned long offset2)
-{
-	return (offset & PAGE_MASK) == (offset2 & PAGE_MASK);
-}
-EXPORT_SYMBOL(drm_bo_same_page);
-
-unsigned long drm_bo_offset_end(unsigned long offset,
-				unsigned long end)
-{
-	offset = (offset + PAGE_SIZE) & PAGE_MASK;
-	return (end < offset) ? end : offset;
-}
-EXPORT_SYMBOL(drm_bo_offset_end);
-
-static pgprot_t drm_kernel_io_prot(uint32_t map_type)
-{
-	pgprot_t tmp = PAGE_KERNEL;
-
-#if defined(__i386__) || defined(__x86_64__)
-#ifdef USE_PAT_WC
-#warning using pat
-	if (drm_use_pat() && map_type == _DRM_TTM) {
-		pgprot_val(tmp) |= _PAGE_PAT;
-		return tmp;
-	}
-#endif
-	if (boot_cpu_data.x86 > 3 && map_type != _DRM_AGP) {
-		pgprot_val(tmp) |= _PAGE_PCD;
-		pgprot_val(tmp) &= ~_PAGE_PWT;
-	}
-#elif defined(__powerpc__)
-	pgprot_val(tmp) |= _PAGE_NO_CACHE;
-	if (map_type == _DRM_REGISTERS)
-		pgprot_val(tmp) |= _PAGE_GUARDED;
-#endif
-#if defined(__ia64__)
-	if (map_type == _DRM_TTM)
-		tmp = pgprot_writecombine(tmp);
-	else
-		tmp = pgprot_noncached(tmp);
-#endif
-	return tmp;
-}
-
-static int drm_bo_ioremap(struct drm_buffer_object *bo, unsigned long bus_base,
-			  unsigned long bus_offset, unsigned long bus_size,
-			  struct drm_bo_kmap_obj *map)
-{
-	struct drm_device *dev = bo->dev;
-	struct drm_bo_mem_reg *mem = &bo->mem;
-	struct drm_mem_type_manager *man = &dev->bm.man[mem->mem_type];
-
-	if (!(man->flags & _DRM_FLAG_NEEDS_IOREMAP)) {
-		map->bo_kmap_type = bo_map_premapped;
-		map->virtual = (void *)(((u8 *) man->io_addr) + bus_offset);
-	} else {
-		map->bo_kmap_type = bo_map_iomap;
-		map->virtual = ioremap_nocache(bus_base + bus_offset, bus_size);
-	}
-	return (!map->virtual) ? -ENOMEM : 0;
-}
-
-static int drm_bo_kmap_ttm(struct drm_buffer_object *bo,
-			   unsigned long start_page, unsigned long num_pages,
-			   struct drm_bo_kmap_obj *map)
-{
-	struct drm_device *dev = bo->dev;
-	struct drm_bo_mem_reg *mem = &bo->mem;
-	struct drm_mem_type_manager *man = &dev->bm.man[mem->mem_type];
-	pgprot_t prot;
-	struct drm_ttm *ttm = bo->ttm;
-	struct page *d;
-	int i;
-
-	BUG_ON(!ttm);
-
-	if (num_pages == 1 && (mem->flags & DRM_BO_FLAG_CACHED)) {
-
-		/*
-		 * We're mapping a single page, and the desired
-		 * page protection is consistent with the bo.
-		 */
-
-		map->bo_kmap_type = bo_map_kmap;
-		map->page = drm_ttm_get_page(ttm, start_page);
-		map->virtual = kmap(map->page);
-	} else {
-		/*
-		 * Populate the part we're mapping;
-		 */
-
-		for (i = start_page; i < start_page + num_pages; ++i) {
-			d = drm_ttm_get_page(ttm, i);
-			if (!d)
-				return -ENOMEM;
-		}
-
-		/*
-		 * We need to use vmap to get the desired page protection
-		 * or to make the buffer object look contigous.
-		 */
-
-		prot = (mem->flags & DRM_BO_FLAG_CACHED) ?
-			PAGE_KERNEL :
-			drm_kernel_io_prot(man->drm_bus_maptype);
-		map->bo_kmap_type = bo_map_vmap;
-		map->virtual = vmap(ttm->pages + start_page,
-				    num_pages, 0, prot);
-	}
-	return (!map->virtual) ? -ENOMEM : 0;
-}
-
-/*
- * This function is to be used for kernel mapping of buffer objects.
- * It chooses the appropriate mapping method depending on the memory type
- * and caching policy the buffer currently has.
- * Mapping multiple pages or buffers that live in io memory is a bit slow and
- * consumes vmalloc space. Be restrictive with such mappings.
- * Mapping single pages usually returns the logical kernel address,
- * (which is fast)
- * BUG may use slower temporary mappings for high memory pages or
- * uncached / write-combined pages.
- *
- * The function fills in a drm_bo_kmap_obj which can be used to return the
- * kernel virtual address of the buffer.
- *
- * Code servicing a non-priviliged user request is only allowed to map one
- * page at a time. We might need to implement a better scheme to stop such
- * processes from consuming all vmalloc space.
- */
-
-int drm_bo_kmap(struct drm_buffer_object *bo, unsigned long start_page,
-		unsigned long num_pages, struct drm_bo_kmap_obj *map)
-{
-	int ret;
-	unsigned long bus_base;
-	unsigned long bus_offset;
-	unsigned long bus_size;
-
-	map->virtual = NULL;
-
-	if (num_pages > bo->num_pages)
-		return -EINVAL;
-	if (start_page > bo->num_pages)
-		return -EINVAL;
-#if 0
-	if (num_pages > 1 && !DRM_SUSER(DRM_CURPROC))
-		return -EPERM;
-#endif
-	ret = drm_bo_pci_offset(bo->dev, &bo->mem, &bus_base,
-				&bus_offset, &bus_size);
-
-	if (ret)
-		return ret;
-
-	if (bus_size == 0) {
-		return drm_bo_kmap_ttm(bo, start_page, num_pages, map);
-	} else {
-		bus_offset += start_page << PAGE_SHIFT;
-		bus_size = num_pages << PAGE_SHIFT;
-		return drm_bo_ioremap(bo, bus_base, bus_offset, bus_size, map);
-	}
-}
-EXPORT_SYMBOL(drm_bo_kmap);
-
-void drm_bo_kunmap(struct drm_bo_kmap_obj *map)
-{
-	if (!map->virtual)
-		return;
-
-	switch (map->bo_kmap_type) {
-	case bo_map_iomap:
-		iounmap(map->virtual);
-		break;
-	case bo_map_vmap:
-		vunmap(map->virtual);
-		break;
-	case bo_map_kmap:
-		kunmap(map->page);
-		break;
-	case bo_map_premapped:
-		break;
-	default:
-		BUG();
-	}
-	map->virtual = NULL;
-	map->page = NULL;
-}
-EXPORT_SYMBOL(drm_bo_kunmap);
-
-int drm_bo_pfn_prot(struct drm_buffer_object *bo,
-		    unsigned long dst_offset,
-		    unsigned long *pfn,
-		    pgprot_t *prot)
-{
-	struct drm_bo_mem_reg *mem = &bo->mem;
-	struct drm_device *dev = bo->dev;
-	unsigned long bus_offset;
-	unsigned long bus_size;
-	unsigned long bus_base;
-	struct drm_mem_type_manager *man = &dev->bm.man[mem->mem_type];
-	int ret;
-
-	ret = drm_bo_pci_offset(dev, mem, &bus_base, &bus_offset,
-				&bus_size);
-	if (ret)
-		return -EINVAL;
-
-	if (bus_size != 0)
-		*pfn = (bus_base + bus_offset + dst_offset) >> PAGE_SHIFT;
-	else if (!bo->ttm)
-		return -EINVAL;
-	else
-		*pfn = page_to_pfn(drm_ttm_get_page(bo->ttm, dst_offset >> PAGE_SHIFT));
-
-	*prot = (mem->flags & DRM_BO_FLAG_CACHED) ?
-		PAGE_KERNEL : drm_kernel_io_prot(man->drm_bus_maptype);
-
-	return 0;
-}
-EXPORT_SYMBOL(drm_bo_pfn_prot);
-
diff --git a/linux-core/drm_compat.c b/linux-core/drm_compat.c
index 0ccd2ab3..3bf9d100 100644
--- a/linux-core/drm_compat.c
+++ b/linux-core/drm_compat.c
@@ -151,102 +151,3 @@ void idr_remove_all(struct idr *idp)
 EXPORT_SYMBOL(idr_remove_all);
 
 #endif /* DRM_IDR_COMPAT_FN */
-
-
-#ifdef DRM_NO_FAULT
-unsigned long drm_bo_vm_nopfn(struct vm_area_struct *vma,
-			      unsigned long address)
-{
-	struct drm_buffer_object *bo = (struct drm_buffer_object *) vma->vm_private_data;
-	unsigned long page_offset;
-	struct page *page = NULL;
-	struct drm_ttm *ttm;
-	struct drm_device *dev;
-	unsigned long pfn;
-	int err;
-	unsigned long bus_base;
-	unsigned long bus_offset;
-	unsigned long bus_size;
-	unsigned long ret = NOPFN_REFAULT;
-
-	if (address > vma->vm_end)
-		return NOPFN_SIGBUS;
-
-	dev = bo->dev;
-	err = drm_bo_read_lock(&dev->bm.bm_lock, 1);
-	if (err)
-		return NOPFN_REFAULT;
-
-	err = mutex_lock_interruptible(&bo->mutex);
-	if (err) {
-		drm_bo_read_unlock(&dev->bm.bm_lock);
-		return NOPFN_REFAULT;
-	}
-
-	err = drm_bo_wait(bo, 0, 1, 0, 1);
-	if (err) {
-		ret = (err != -EAGAIN) ? NOPFN_SIGBUS : NOPFN_REFAULT;
-		bo->priv_flags &= ~_DRM_BO_FLAG_UNLOCKED;
-		goto out_unlock;
-	}
-
-	bo->priv_flags &= ~_DRM_BO_FLAG_UNLOCKED;
-
-	/*
-	 * If buffer happens to be in a non-mappable location,
-	 * move it to a mappable.
-	 */
-
-	if (!(bo->mem.flags & DRM_BO_FLAG_MAPPABLE)) {
-		uint32_t new_flags = bo->mem.proposed_flags |
-			DRM_BO_FLAG_MAPPABLE |
-			DRM_BO_FLAG_FORCE_MAPPABLE;
-		err = drm_bo_move_buffer(bo, new_flags, 0, 0);
-		if (err) {
-			ret = (err != -EAGAIN) ? NOPFN_SIGBUS : NOPFN_REFAULT;
-			goto out_unlock;
-		}
-	}
-
-	err = drm_bo_pci_offset(dev, &bo->mem, &bus_base, &bus_offset,
-				&bus_size);
-
-	if (err) {
-		ret = NOPFN_SIGBUS;
-		goto out_unlock;
-	}
-
-	page_offset = (address - vma->vm_start) >> PAGE_SHIFT;
-
-	if (bus_size) {
-		struct drm_mem_type_manager *man = &dev->bm.man[bo->mem.mem_type];
-
-		pfn = ((bus_base + bus_offset) >> PAGE_SHIFT) + page_offset;
-		vma->vm_page_prot = drm_io_prot(man->drm_bus_maptype, vma);
-	} else {
-		ttm = bo->ttm;
-
-		drm_ttm_fixup_caching(ttm);
-		page = drm_ttm_get_page(ttm, page_offset);
-		if (!page) {
-			ret = NOPFN_OOM;
-			goto out_unlock;
-		}
-		pfn = page_to_pfn(page);
-		vma->vm_page_prot = (bo->mem.flags & DRM_BO_FLAG_CACHED) ?
-			vm_get_page_prot(vma->vm_flags) :
-			drm_io_prot(_DRM_TTM, vma);
-	}
-
-	err = vm_insert_pfn(vma, address, pfn);
-	if (err) {
-		ret = (err != -EAGAIN) ? NOPFN_OOM : NOPFN_REFAULT;
-		goto out_unlock;
-	}
-out_unlock:
-	BUG_ON(bo->priv_flags & _DRM_BO_FLAG_UNLOCKED);
-	mutex_unlock(&bo->mutex);
-	drm_bo_read_unlock(&dev->bm.bm_lock);
-	return ret;
-}
-#endif
diff --git a/linux-core/drm_drv.c b/linux-core/drm_drv.c
index 72f0e98b..d3e2ca99 100644
--- a/linux-core/drm_drv.c
+++ b/linux-core/drm_drv.c
@@ -121,36 +121,6 @@ static struct drm_ioctl_desc drm_ioctls[] = {
 
 	DRM_IOCTL_DEF(DRM_IOCTL_UPDATE_DRAW, drm_update_drawable_info, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
 
-	DRM_IOCTL_DEF(DRM_IOCTL_MM_INIT, drm_mm_init_ioctl,
-		      DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
-	DRM_IOCTL_DEF(DRM_IOCTL_MM_TAKEDOWN, drm_mm_takedown_ioctl,
-		      DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
-	DRM_IOCTL_DEF(DRM_IOCTL_MM_LOCK, drm_mm_lock_ioctl,
-		      DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
-	DRM_IOCTL_DEF(DRM_IOCTL_MM_UNLOCK, drm_mm_unlock_ioctl,
-		      DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
-
-	DRM_IOCTL_DEF(DRM_IOCTL_FENCE_CREATE, drm_fence_create_ioctl, DRM_AUTH),
-	DRM_IOCTL_DEF(DRM_IOCTL_FENCE_REFERENCE, drm_fence_reference_ioctl, DRM_AUTH),
-	DRM_IOCTL_DEF(DRM_IOCTL_FENCE_UNREFERENCE, drm_fence_unreference_ioctl, DRM_AUTH),
-	DRM_IOCTL_DEF(DRM_IOCTL_FENCE_SIGNALED, drm_fence_signaled_ioctl, DRM_AUTH),
-	DRM_IOCTL_DEF(DRM_IOCTL_FENCE_FLUSH, drm_fence_flush_ioctl, DRM_AUTH),
-	DRM_IOCTL_DEF(DRM_IOCTL_FENCE_WAIT, drm_fence_wait_ioctl, DRM_AUTH),
-	DRM_IOCTL_DEF(DRM_IOCTL_FENCE_EMIT, drm_fence_emit_ioctl, DRM_AUTH),
-	DRM_IOCTL_DEF(DRM_IOCTL_FENCE_BUFFERS, drm_fence_buffers_ioctl, DRM_AUTH),
-
-	DRM_IOCTL_DEF(DRM_IOCTL_BO_CREATE, drm_bo_create_ioctl, DRM_AUTH),
-	DRM_IOCTL_DEF(DRM_IOCTL_BO_MAP, drm_bo_map_ioctl, DRM_AUTH),
-	DRM_IOCTL_DEF(DRM_IOCTL_BO_UNMAP, drm_bo_unmap_ioctl, DRM_AUTH),
-	DRM_IOCTL_DEF(DRM_IOCTL_BO_REFERENCE, drm_bo_reference_ioctl, DRM_AUTH),
-	DRM_IOCTL_DEF(DRM_IOCTL_BO_UNREFERENCE, drm_bo_unreference_ioctl, DRM_AUTH),
-	DRM_IOCTL_DEF(DRM_IOCTL_BO_SETSTATUS, drm_bo_setstatus_ioctl, DRM_AUTH),
-	DRM_IOCTL_DEF(DRM_IOCTL_BO_INFO, drm_bo_info_ioctl, DRM_AUTH),
-	DRM_IOCTL_DEF(DRM_IOCTL_BO_WAIT_IDLE, drm_bo_wait_idle_ioctl, DRM_AUTH),
-	DRM_IOCTL_DEF(DRM_IOCTL_BO_VERSION, drm_bo_version_ioctl, 0),
-
-	DRM_IOCTL_DEF(DRM_IOCTL_MM_INFO, drm_mm_info_ioctl, 0),
-
 #if OS_HAS_GEM
 	DRM_IOCTL_DEF(DRM_IOCTL_GEM_CLOSE, drm_gem_close_ioctl, 0),
 	DRM_IOCTL_DEF(DRM_IOCTL_GEM_FLINK, drm_gem_flink_ioctl, DRM_AUTH),
@@ -183,8 +153,6 @@ int drm_lastclose(struct drm_device * dev)
 	 * We can't do much about this function failing.
 	 */
 
-	drm_bo_driver_finish(dev);
-
 	if (dev->driver->lastclose)
 		dev->driver->lastclose(dev);
 	DRM_DEBUG("driver lastclose completed\n");
@@ -283,7 +251,6 @@ int drm_lastclose(struct drm_device * dev)
 		dev->lock.file_priv = NULL;
 		wake_up_interruptible(&dev->lock.lock_queue);
 	}
-	dev->dev_mapping = NULL;
 	mutex_unlock(&dev->struct_mutex);
 
 	DRM_DEBUG("lastclose completed\n");
@@ -398,7 +365,6 @@ static void drm_cleanup(struct drm_device * dev)
 	}
 
 	drm_lastclose(dev);
-	drm_fence_manager_takedown(dev);
 
 	drm_vblank_cleanup(dev);
 
@@ -423,8 +389,6 @@ 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_ht_remove(&dev->object_hash);
 
 	drm_put_minor(dev);
 	if (drm_put_dev(dev))
diff --git a/linux-core/drm_fence.c b/linux-core/drm_fence.c
deleted file mode 100644
index 7c78e09f..00000000
--- a/linux-core/drm_fence.c
+++ /dev/null
@@ -1,829 +0,0 @@
-/**************************************************************************
- *
- * Copyright (c) 2006-2007 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 Hellström <thomas-at-tungstengraphics-dot-com>
- */
-
-#include "drmP.h"
-
-
-/*
- * Convenience function to be called by fence::wait methods that
- * need polling.
- */
-
-int drm_fence_wait_polling(struct drm_fence_object *fence, int lazy,
-			   int interruptible, uint32_t mask, 
-			   unsigned long end_jiffies)
-{
-	struct drm_device *dev = fence->dev;
-	struct drm_fence_manager *fm = &dev->fm;
-	struct drm_fence_class_manager *fc = &fm->fence_class[fence->fence_class];
-	uint32_t count = 0;
-	int ret;
-
-	DECLARE_WAITQUEUE(entry, current);
-	add_wait_queue(&fc->fence_queue, &entry);
-
-	ret = 0;
-	
-	for (;;) {
-		__set_current_state((interruptible) ? 
-				    TASK_INTERRUPTIBLE :
-				    TASK_UNINTERRUPTIBLE);
-		if (drm_fence_object_signaled(fence, mask))
-			break;
-		if (time_after_eq(jiffies, end_jiffies)) {
-			ret = -EBUSY;
-			break;
-		}
-		if (lazy)
-			schedule_timeout(1);
-		else if ((++count & 0x0F) == 0){
-			__set_current_state(TASK_RUNNING);
-			schedule();
-			__set_current_state((interruptible) ? 
-					    TASK_INTERRUPTIBLE :
-					    TASK_UNINTERRUPTIBLE);
-		}			
-		if (interruptible && signal_pending(current)) {
-			ret = -EAGAIN;
-			break;
-		}
-	}
-	__set_current_state(TASK_RUNNING);
-	remove_wait_queue(&fc->fence_queue, &entry);
-	return ret;
-}
-EXPORT_SYMBOL(drm_fence_wait_polling);
-
-/*
- * Typically called by the IRQ handler.
- */
-
-void drm_fence_handler(struct drm_device *dev, uint32_t fence_class,
-		       uint32_t sequence, uint32_t type, uint32_t error)
-{
-	int wake = 0;
-	uint32_t diff;
-	uint32_t relevant_type;
-	uint32_t new_type;
-	struct drm_fence_manager *fm = &dev->fm;
-	struct drm_fence_class_manager *fc = &fm->fence_class[fence_class];
-	struct drm_fence_driver *driver = dev->driver->fence_driver;
-	struct list_head *head;
-	struct drm_fence_object *fence, *next;
-	int found = 0;
-
-	if (list_empty(&fc->ring))
-		return;
-
-	list_for_each_entry(fence, &fc->ring, ring) {
-		diff = (sequence - fence->sequence) & driver->sequence_mask;
-		if (diff > driver->wrap_diff) {
-			found = 1;
-			break;
-		}
-	}
-
-	fc->waiting_types &= ~type;
-	head = (found) ? &fence->ring : &fc->ring;
-
-	list_for_each_entry_safe_reverse(fence, next, head, ring) {
-		if (&fence->ring == &fc->ring)
-			break;
-
-		if (error) {
-			fence->error = error;
-			fence->signaled_types = fence->type;
-			list_del_init(&fence->ring);
-			wake = 1;
-			break;
-		}
-
-		if (type & DRM_FENCE_TYPE_EXE)
-			type |= fence->native_types;
-
-		relevant_type = type & fence->type;
-		new_type = (fence->signaled_types | relevant_type) ^
-			fence->signaled_types;
-
-		if (new_type) {
-			fence->signaled_types |= new_type;
-			DRM_DEBUG("Fence 0x%08lx signaled 0x%08x\n",
-				  fence->base.hash.key, fence->signaled_types);
-
-			if (driver->needed_flush)
-				fc->pending_flush |= driver->needed_flush(fence);
-
-			if (new_type & fence->waiting_types)
-				wake = 1;
-		}
-
-		fc->waiting_types |= fence->waiting_types & ~fence->signaled_types;
-
-		if (!(fence->type & ~fence->signaled_types)) {
-			DRM_DEBUG("Fence completely signaled 0x%08lx\n",
-				  fence->base.hash.key);
-			list_del_init(&fence->ring);
-		}
-	}
-
-	/*
-	 * Reinstate lost waiting types.
-	 */
-
-	if ((fc->waiting_types & type) != type) {
-		head = head->prev;
-		list_for_each_entry(fence, head, ring) {
-			if (&fence->ring == &fc->ring)
-				break;
-			diff = (fc->highest_waiting_sequence - fence->sequence) &
-				driver->sequence_mask;
-			if (diff > driver->wrap_diff)
-				break;
-			
-			fc->waiting_types |= fence->waiting_types & ~fence->signaled_types;
-		}
-	}
-
-	if (wake) 
-		wake_up_all(&fc->fence_queue);
-}
-EXPORT_SYMBOL(drm_fence_handler);
-
-static void drm_fence_unring(struct drm_device *dev, struct list_head *ring)
-{
-	struct drm_fence_manager *fm = &dev->fm;
-	unsigned long flags;
-
-	write_lock_irqsave(&fm->lock, flags);
-	list_del_init(ring);
-	write_unlock_irqrestore(&fm->lock, flags);
-}
-
-void drm_fence_usage_deref_locked(struct drm_fence_object **fence)
-{
-	struct drm_fence_object *tmp_fence = *fence;
-	struct drm_device *dev = tmp_fence->dev;
-	struct drm_fence_manager *fm = &dev->fm;
-
-	DRM_ASSERT_LOCKED(&dev->struct_mutex);
-	*fence = NULL;
-	if (atomic_dec_and_test(&tmp_fence->usage)) {
-		drm_fence_unring(dev, &tmp_fence->ring);
-		DRM_DEBUG("Destroyed a fence object 0x%08lx\n",
-			  tmp_fence->base.hash.key);
-		atomic_dec(&fm->count);
-		BUG_ON(!list_empty(&tmp_fence->base.list));
-		drm_ctl_free(tmp_fence, sizeof(*tmp_fence), DRM_MEM_FENCE);
-	}
-}
-EXPORT_SYMBOL(drm_fence_usage_deref_locked);
-
-void drm_fence_usage_deref_unlocked(struct drm_fence_object **fence)
-{
-	struct drm_fence_object *tmp_fence = *fence;
-	struct drm_device *dev = tmp_fence->dev;
-	struct drm_fence_manager *fm = &dev->fm;
-
-	*fence = NULL;
-	if (atomic_dec_and_test(&tmp_fence->usage)) {
-		mutex_lock(&dev->struct_mutex);
-		if (atomic_read(&tmp_fence->usage) == 0) {
-			drm_fence_unring(dev, &tmp_fence->ring);
-			atomic_dec(&fm->count);
-			BUG_ON(!list_empty(&tmp_fence->base.list));
-			drm_ctl_free(tmp_fence, sizeof(*tmp_fence), DRM_MEM_FENCE);
-		}
-		mutex_unlock(&dev->struct_mutex);
-	}
-}
-EXPORT_SYMBOL(drm_fence_usage_deref_unlocked);
-
-struct drm_fence_object
-*drm_fence_reference_locked(struct drm_fence_object *src)
-{
-	DRM_ASSERT_LOCKED(&src->dev->struct_mutex);
-
-	atomic_inc(&src->usage);
-	return src;
-}
-
-void drm_fence_reference_unlocked(struct drm_fence_object **dst,
-				  struct drm_fence_object *src)
-{
-	mutex_lock(&src->dev->struct_mutex);
-	*dst = src;
-	atomic_inc(&src->usage);
-	mutex_unlock(&src->dev->struct_mutex);
-}
-EXPORT_SYMBOL(drm_fence_reference_unlocked);
-
-static void drm_fence_object_destroy(struct drm_file *priv,
-				     struct drm_user_object *base)
-{
-	struct drm_fence_object *fence =
-	    drm_user_object_entry(base, struct drm_fence_object, base);
-
-	drm_fence_usage_deref_locked(&fence);
-}
-
-int drm_fence_object_signaled(struct drm_fence_object *fence, uint32_t mask)
-{
-	unsigned long flags;
-	int signaled;
-	struct drm_device *dev = fence->dev;
-	struct drm_fence_manager *fm = &dev->fm;
-	struct drm_fence_driver *driver = dev->driver->fence_driver;
-	
-	mask &= fence->type;
-	read_lock_irqsave(&fm->lock, flags);
-	signaled = (mask & fence->signaled_types) == mask;
-	read_unlock_irqrestore(&fm->lock, flags);
-	if (!signaled && driver->poll) {
-		write_lock_irqsave(&fm->lock, flags);
-		driver->poll(dev, fence->fence_class, mask);
-		signaled = (mask & fence->signaled_types) == mask;
-		write_unlock_irqrestore(&fm->lock, flags);
-	}
-	return signaled;
-}
-EXPORT_SYMBOL(drm_fence_object_signaled);
-
-
-int drm_fence_object_flush(struct drm_fence_object *fence,
-			   uint32_t type)
-{
-	struct drm_device *dev = fence->dev;
-	struct drm_fence_manager *fm = &dev->fm;
-	struct drm_fence_class_manager *fc = &fm->fence_class[fence->fence_class];
-	struct drm_fence_driver *driver = dev->driver->fence_driver;
-	unsigned long irq_flags;
-	uint32_t saved_pending_flush;
-	uint32_t diff;
-	int call_flush;
-
-	if (type & ~fence->type) {
-		DRM_ERROR("Flush trying to extend fence type, "
-			  "0x%x, 0x%x\n", type, fence->type);
-		return -EINVAL;
-	}
-
-	write_lock_irqsave(&fm->lock, irq_flags);
-	fence->waiting_types |= type;
-	fc->waiting_types |= fence->waiting_types;
-	diff = (fence->sequence - fc->highest_waiting_sequence) & 
-		driver->sequence_mask;
-
-	if (diff < driver->wrap_diff)
-		fc->highest_waiting_sequence = fence->sequence;
-
-	/*
-	 * fence->waiting_types has changed. Determine whether
-	 * we need to initiate some kind of flush as a result of this.
-	 */
-
-	saved_pending_flush = fc->pending_flush;
-	if (driver->needed_flush) 
-		fc->pending_flush |= driver->needed_flush(fence);
-
-	if (driver->poll)
-		driver->poll(dev, fence->fence_class, fence->waiting_types);
-
-	call_flush = fc->pending_flush;
-	write_unlock_irqrestore(&fm->lock, irq_flags);
-
-	if (call_flush && driver->flush)
-		driver->flush(dev, fence->fence_class);
-
-	return 0;
-}
-EXPORT_SYMBOL(drm_fence_object_flush);
-
-/*
- * Make sure old fence objects are signaled before their fence sequences are
- * wrapped around and reused.
- */
-
-void drm_fence_flush_old(struct drm_device *dev, uint32_t fence_class,
-			 uint32_t sequence)
-{
-	struct drm_fence_manager *fm = &dev->fm;
-	struct drm_fence_class_manager *fc = &fm->fence_class[fence_class];
-	struct drm_fence_object *fence;
-	unsigned long irq_flags;
-	struct drm_fence_driver *driver = dev->driver->fence_driver;
-	int call_flush;
-
-	uint32_t diff;
-
-	write_lock_irqsave(&fm->lock, irq_flags);
-
-	list_for_each_entry_reverse(fence, &fc->ring, ring) {
-		diff = (sequence - fence->sequence) & driver->sequence_mask;
-		if (diff <= driver->flush_diff)
-			break;
-	
-		fence->waiting_types = fence->type;
-		fc->waiting_types |= fence->type;
-
-		if (driver->needed_flush)
-			fc->pending_flush |= driver->needed_flush(fence);
-	}	
-	
-	if (driver->poll)
-		driver->poll(dev, fence_class, fc->waiting_types);
-
-	call_flush = fc->pending_flush;
-	write_unlock_irqrestore(&fm->lock, irq_flags);
-
-	if (call_flush && driver->flush)
-		driver->flush(dev, fence->fence_class);
-
-	/*
-	 * FIXME: Shold we implement a wait here for really old fences?
-	 */
-
-}
-EXPORT_SYMBOL(drm_fence_flush_old);
-
-int drm_fence_object_wait(struct drm_fence_object *fence,
-			  int lazy, int ignore_signals, uint32_t mask)
-{
-	struct drm_device *dev = fence->dev;
-	struct drm_fence_driver *driver = dev->driver->fence_driver;
-	struct drm_fence_manager *fm = &dev->fm;
-	struct drm_fence_class_manager *fc = &fm->fence_class[fence->fence_class];
-	int ret = 0;
-	unsigned long _end = 3 * DRM_HZ;
-
-	if (mask & ~fence->type) {
-		DRM_ERROR("Wait trying to extend fence type"
-			  " 0x%08x 0x%08x\n", mask, fence->type);
-		BUG();
-		return -EINVAL;
-	}
-
-	if (driver->wait)
-		return driver->wait(fence, lazy, !ignore_signals, mask);
-
-
-	drm_fence_object_flush(fence, mask);
-	if (driver->has_irq(dev, fence->fence_class, mask)) {
-		if (!ignore_signals)
-			ret = wait_event_interruptible_timeout
-				(fc->fence_queue, 
-				 drm_fence_object_signaled(fence, mask), 
-				 3 * DRM_HZ);
-		else 
-			ret = wait_event_timeout
-				(fc->fence_queue, 
-				 drm_fence_object_signaled(fence, mask), 
-				 3 * DRM_HZ);
-
-		if (unlikely(ret == -ERESTARTSYS))
-			return -EAGAIN;
-
-		if (unlikely(ret == 0))
-			return -EBUSY;
-
-		return 0;
-	}
-
-	return drm_fence_wait_polling(fence, lazy, !ignore_signals, mask,
-				      _end);
-}
-EXPORT_SYMBOL(drm_fence_object_wait);
-
-
-
-int drm_fence_object_emit(struct drm_fence_object *fence, uint32_t fence_flags,
-			  uint32_t fence_class, uint32_t type)
-{
-	struct drm_device *dev = fence->dev;
-	struct drm_fence_manager *fm = &dev->fm;
-	struct drm_fence_driver *driver = dev->driver->fence_driver;
-	struct drm_fence_class_manager *fc = &fm->fence_class[fence->fence_class];
-	unsigned long flags;
-	uint32_t sequence;
-	uint32_t native_types;
-	int ret;
-
-	drm_fence_unring(dev, &fence->ring);
-	ret = driver->emit(dev, fence_class, fence_flags, &sequence,
-			   &native_types);
-	if (ret)
-		return ret;
-
-	write_lock_irqsave(&fm->lock, flags);
-	fence->fence_class = fence_class;
-	fence->type = type;
-	fence->waiting_types = 0;
-	fence->signaled_types = 0;
-	fence->error = 0;
-	fence->sequence = sequence;
-	fence->native_types = native_types;
-	if (list_empty(&fc->ring))
-		fc->highest_waiting_sequence = sequence - 1;
-	list_add_tail(&fence->ring, &fc->ring);
-	fc->latest_queued_sequence = sequence;
-	write_unlock_irqrestore(&fm->lock, flags);
-	return 0;
-}
-EXPORT_SYMBOL(drm_fence_object_emit);
-
-static int drm_fence_object_init(struct drm_device *dev, uint32_t fence_class,
-				 uint32_t type,
-				 uint32_t fence_flags,
-				 struct drm_fence_object *fence)
-{
-	int ret = 0;
-	unsigned long flags;
-	struct drm_fence_manager *fm = &dev->fm;
-
-	mutex_lock(&dev->struct_mutex);
-	atomic_set(&fence->usage, 1);
-	mutex_unlock(&dev->struct_mutex);
-
-	write_lock_irqsave(&fm->lock, flags);
-	INIT_LIST_HEAD(&fence->ring);
-
-	/*
-	 *  Avoid hitting BUG() for kernel-only fence objects.
-	 */
-
-	INIT_LIST_HEAD(&fence->base.list);
-	fence->fence_class = fence_class;
-	fence->type = type;
-	fence->signaled_types = 0;
-	fence->waiting_types = 0;
-	fence->sequence = 0;
-	fence->error = 0;
-	fence->dev = dev;
-	write_unlock_irqrestore(&fm->lock, flags);
-	if (fence_flags & DRM_FENCE_FLAG_EMIT) {
-		ret = drm_fence_object_emit(fence, fence_flags,
-					    fence->fence_class, type);
-	}
-	return ret;
-}
-
-int drm_fence_add_user_object(struct drm_file *priv,
-			      struct drm_fence_object *fence, int shareable)
-{
-	struct drm_device *dev = priv->minor->dev;
-	int ret;
-
-	mutex_lock(&dev->struct_mutex);
-	ret = drm_add_user_object(priv, &fence->base, shareable);
-	if (ret)
-		goto out;
-	atomic_inc(&fence->usage);
-	fence->base.type = drm_fence_type;
-	fence->base.remove = &drm_fence_object_destroy;
-	DRM_DEBUG("Fence 0x%08lx created\n", fence->base.hash.key);
-out:
-	mutex_unlock(&dev->struct_mutex);
-	return ret;
-}
-EXPORT_SYMBOL(drm_fence_add_user_object);
-
-int drm_fence_object_create(struct drm_device *dev, uint32_t fence_class,
-			    uint32_t type, unsigned flags,
-			    struct drm_fence_object **c_fence)
-{
-	struct drm_fence_object *fence;
-	int ret;
-	struct drm_fence_manager *fm = &dev->fm;
-
-	fence = drm_ctl_calloc(1, sizeof(*fence), DRM_MEM_FENCE);
-	if (!fence) {
-		DRM_ERROR("Out of memory creating fence object\n");
-		return -ENOMEM;
-	}
-	ret = drm_fence_object_init(dev, fence_class, type, flags, fence);
-	if (ret) {
-		drm_fence_usage_deref_unlocked(&fence);
-		return ret;
-	}
-	*c_fence = fence;
-	atomic_inc(&fm->count);
-
-	return 0;
-}
-EXPORT_SYMBOL(drm_fence_object_create);
-
-void drm_fence_manager_init(struct drm_device *dev)
-{
-	struct drm_fence_manager *fm = &dev->fm;
-	struct drm_fence_class_manager *fence_class;
-	struct drm_fence_driver *fed = dev->driver->fence_driver;
-	int i;
-	unsigned long flags;
-
-	rwlock_init(&fm->lock);
-	write_lock_irqsave(&fm->lock, flags);
-	fm->initialized = 0;
-	if (!fed)
-	    goto out_unlock;
-
-	fm->initialized = 1;
-	fm->num_classes = fed->num_classes;
-	BUG_ON(fm->num_classes > _DRM_FENCE_CLASSES);
-
-	for (i = 0; i < fm->num_classes; ++i) {
-	    fence_class = &fm->fence_class[i];
-
-	    memset(fence_class, 0, sizeof(*fence_class));
-	    INIT_LIST_HEAD(&fence_class->ring);
-	    DRM_INIT_WAITQUEUE(&fence_class->fence_queue);
-	}
-
-	atomic_set(&fm->count, 0);
- out_unlock:
-	write_unlock_irqrestore(&fm->lock, flags);
-}
-
-void drm_fence_fill_arg(struct drm_fence_object *fence,
-			struct drm_fence_arg *arg)
-{
-	struct drm_device *dev = fence->dev;
-	struct drm_fence_manager *fm = &dev->fm;
-	unsigned long irq_flags;
-
-	read_lock_irqsave(&fm->lock, irq_flags);
-	arg->handle = fence->base.hash.key;
-	arg->fence_class = fence->fence_class;
-	arg->type = fence->type;
-	arg->signaled = fence->signaled_types;
-	arg->error = fence->error;
-	arg->sequence = fence->sequence;
-	read_unlock_irqrestore(&fm->lock, irq_flags);
-}
-EXPORT_SYMBOL(drm_fence_fill_arg);
-
-void drm_fence_manager_takedown(struct drm_device *dev)
-{
-}
-
-struct drm_fence_object *drm_lookup_fence_object(struct drm_file *priv,
-						 uint32_t handle)
-{
-	struct drm_device *dev = priv->minor->dev;
-	struct drm_user_object *uo;
-	struct drm_fence_object *fence;
-
-	mutex_lock(&dev->struct_mutex);
-	uo = drm_lookup_user_object(priv, handle);
-	if (!uo || (uo->type != drm_fence_type)) {
-		mutex_unlock(&dev->struct_mutex);
-		return NULL;
-	}
-	fence = drm_fence_reference_locked(drm_user_object_entry(uo, struct drm_fence_object, base));
-	mutex_unlock(&dev->struct_mutex);
-	return fence;
-}
-
-int drm_fence_create_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv)
-{
-	int ret;
-	struct drm_fence_manager *fm = &dev->fm;
-	struct drm_fence_arg *arg = data;
-	struct drm_fence_object *fence;
-	ret = 0;
-
-	if (!fm->initialized) {
-		DRM_ERROR("The DRM driver does not support fencing.\n");
-		return -EINVAL;
-	}
-
-	if (arg->flags & DRM_FENCE_FLAG_EMIT)
-		LOCK_TEST_WITH_RETURN(dev, file_priv);
-	ret = drm_fence_object_create(dev, arg->fence_class,
-				      arg->type, arg->flags, &fence);
-	if (ret)
-		return ret;
-	ret = drm_fence_add_user_object(file_priv, fence,
-					arg->flags &
-					DRM_FENCE_FLAG_SHAREABLE);
-	if (ret) {
-		drm_fence_usage_deref_unlocked(&fence);
-		return ret;
-	}
-
-	/*
-	 * usage > 0. No need to lock dev->struct_mutex;
-	 */
-
-	arg->handle = fence->base.hash.key;
-
-	drm_fence_fill_arg(fence, arg);
-	drm_fence_usage_deref_unlocked(&fence);
-
-	return ret;
-}
-
-int drm_fence_reference_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv)
-{
-	int ret;
-	struct drm_fence_manager *fm = &dev->fm;
-	struct drm_fence_arg *arg = data;
-	struct drm_fence_object *fence;
-	struct drm_user_object *uo;
-	ret = 0;
-
-	if (!fm->initialized) {
-		DRM_ERROR("The DRM driver does not support fencing.\n");
-		return -EINVAL;
-	}
-
-	ret = drm_user_object_ref(file_priv, arg->handle, drm_fence_type, &uo);
-	if (ret)
-		return ret;
-	fence = drm_lookup_fence_object(file_priv, arg->handle);
-	drm_fence_fill_arg(fence, arg);
-	drm_fence_usage_deref_unlocked(&fence);
-
-	return ret;
-}
-
-
-int drm_fence_unreference_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv)
-{
-	int ret;
-	struct drm_fence_manager *fm = &dev->fm;
-	struct drm_fence_arg *arg = data;
-	ret = 0;
-
-	if (!fm->initialized) {
-		DRM_ERROR("The DRM driver does not support fencing.\n");
-		return -EINVAL;
-	}
-
-	return drm_user_object_unref(file_priv, arg->handle, drm_fence_type);
-}
-
-int drm_fence_signaled_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv)
-{
-	int ret;
-	struct drm_fence_manager *fm = &dev->fm;
-	struct drm_fence_arg *arg = data;
-	struct drm_fence_object *fence;
-	ret = 0;
-
-	if (!fm->initialized) {
-		DRM_ERROR("The DRM driver does not support fencing.\n");
-		return -EINVAL;
-	}
-
-	fence = drm_lookup_fence_object(file_priv, arg->handle);
-	if (!fence)
-		return -EINVAL;
-
-	drm_fence_fill_arg(fence, arg);
-	drm_fence_usage_deref_unlocked(&fence);
-
-	return ret;
-}
-
-int drm_fence_flush_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv)
-{
-	int ret;
-	struct drm_fence_manager *fm = &dev->fm;
-	struct drm_fence_arg *arg = data;
-	struct drm_fence_object *fence;
-	ret = 0;
-
-	if (!fm->initialized) {
-		DRM_ERROR("The DRM driver does not support fencing.\n");
-		return -EINVAL;
-	}
-
-	fence = drm_lookup_fence_object(file_priv, arg->handle);
-	if (!fence)
-		return -EINVAL;
-	ret = drm_fence_object_flush(fence, arg->type);
-
-	drm_fence_fill_arg(fence, arg);
-	drm_fence_usage_deref_unlocked(&fence);
-
-	return ret;
-}
-
-
-int drm_fence_wait_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv)
-{
-	int ret;
-	struct drm_fence_manager *fm = &dev->fm;
-	struct drm_fence_arg *arg = data;
-	struct drm_fence_object *fence;
-	ret = 0;
-
-	if (!fm->initialized) {
-		DRM_ERROR("The DRM driver does not support fencing.\n");
-		return -EINVAL;
-	}
-
-	fence = drm_lookup_fence_object(file_priv, arg->handle);
-	if (!fence)
-		return -EINVAL;
-	ret = drm_fence_object_wait(fence,
-				    arg->flags & DRM_FENCE_FLAG_WAIT_LAZY,
-				    0, arg->type);
-
-	drm_fence_fill_arg(fence, arg);
-	drm_fence_usage_deref_unlocked(&fence);
-
-	return ret;
-}
-
-
-int drm_fence_emit_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv)
-{
-	int ret;
-	struct drm_fence_manager *fm = &dev->fm;
-	struct drm_fence_arg *arg = data;
-	struct drm_fence_object *fence;
-	ret = 0;
-
-	if (!fm->initialized) {
-		DRM_ERROR("The DRM driver does not support fencing.\n");
-		return -EINVAL;
-	}
-
-	LOCK_TEST_WITH_RETURN(dev, file_priv);
-	fence = drm_lookup_fence_object(file_priv, arg->handle);
-	if (!fence)
-		return -EINVAL;
-	ret = drm_fence_object_emit(fence, arg->flags, arg->fence_class,
-				    arg->type);
-
-	drm_fence_fill_arg(fence, arg);
-	drm_fence_usage_deref_unlocked(&fence);
-
-	return ret;
-}
-
-int drm_fence_buffers_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv)
-{
-	int ret;
-	struct drm_fence_manager *fm = &dev->fm;
-	struct drm_fence_arg *arg = data;
-	struct drm_fence_object *fence;
-	ret = 0;
-
-	if (!fm->initialized) {
-		DRM_ERROR("The DRM driver does not support fencing.\n");
-		return -EINVAL;
-	}
-
-	if (!dev->bm.initialized) {
-		DRM_ERROR("Buffer object manager is not initialized\n");
-		return -EINVAL;
-	}
-	LOCK_TEST_WITH_RETURN(dev, file_priv);
-	ret = drm_fence_buffer_objects(dev, NULL, arg->flags,
-				       NULL, &fence);
-	if (ret)
-		return ret;
-
-	if (!(arg->flags & DRM_FENCE_FLAG_NO_USER)) {
-		ret = drm_fence_add_user_object(file_priv, fence,
-						arg->flags &
-						DRM_FENCE_FLAG_SHAREABLE);
-		if (ret)
-			return ret;
-	}
-
-	arg->handle = fence->base.hash.key;
-
-	drm_fence_fill_arg(fence, arg);
-	drm_fence_usage_deref_unlocked(&fence);
-
-	return ret;
-}
diff --git a/linux-core/drm_fops.c b/linux-core/drm_fops.c
index 837645ae..3e2691a8 100644
--- a/linux-core/drm_fops.c
+++ b/linux-core/drm_fops.c
@@ -152,13 +152,6 @@ int drm_open(struct inode *inode, struct file *filp)
 	}
 
 out:
-	mutex_lock(&dev->struct_mutex);
-	BUG_ON((dev->dev_mapping != NULL) &&
-	       (dev->dev_mapping != inode->i_mapping));
-	if (dev->dev_mapping == NULL)
-		dev->dev_mapping = inode->i_mapping;
-	mutex_unlock(&dev->struct_mutex);
-
 	return retcode;
 }
 EXPORT_SYMBOL(drm_open);
@@ -332,33 +325,6 @@ int drm_fasync(int fd, struct file *filp, int on)
 }
 EXPORT_SYMBOL(drm_fasync);
 
-static void drm_object_release(struct file *filp)
-{
-	struct drm_file *priv = filp->private_data;
-	struct list_head *head;
-	struct drm_ref_object *ref_object;
-	int i;
-
-	/*
-	 * Free leftover ref objects created by me. Note that we cannot use
-	 * list_for_each() here, as the struct_mutex may be temporarily
-	 * released by the remove_() functions, and thus the lists may be
-	 * altered.
-	 * Also, a drm_remove_ref_object() will not remove it
-	 * from the list unless its refcount is 1.
-	 */
-
-	head = &priv->refd_objects;
-	while (head->next != head) {
-		ref_object = list_entry(head->next, struct drm_ref_object, list);
-		drm_remove_ref_object(priv, ref_object);
-		head = &priv->refd_objects;
-	}
-
-	for (i = 0; i < _DRM_NO_REF_TYPES; ++i)
-		drm_ht_remove(&priv->refd_object_hash[i]);
-}
-
 /**
  * Release file.
  *
@@ -475,7 +441,6 @@ int drm_release(struct inode *inode, struct file *filp)
 	mutex_unlock(&dev->ctxlist_mutex);
 
 	mutex_lock(&dev->struct_mutex);
-	drm_object_release(filp);
 	if (file_priv->remove_auth_on_close == 1) {
 		struct drm_file *temp;
 
diff --git a/linux-core/drm_object.c b/linux-core/drm_object.c
deleted file mode 100644
index 2994b716..00000000
--- a/linux-core/drm_object.c
+++ /dev/null
@@ -1,294 +0,0 @@
-/**************************************************************************
- *
- * Copyright (c) 2006-2007 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 Hellström <thomas-at-tungstengraphics-dot-com>
- */
-
-#include "drmP.h"
-
-int drm_add_user_object(struct drm_file *priv, struct drm_user_object *item,
-			int shareable)
-{
-	struct drm_device *dev = priv->minor->dev;
-	int ret;
-
-	DRM_ASSERT_LOCKED(&dev->struct_mutex);
-
-	/* The refcount will be bumped to 1 when we add the ref object below. */
-	atomic_set(&item->refcount, 0);
-	item->shareable = shareable;
-	item->owner = priv;
-
-	ret = drm_ht_just_insert_please(&dev->object_hash, &item->hash,
-					(unsigned long)item, 31, 0, 0);
-	if (ret)
-		return ret;
-
-	ret = drm_add_ref_object(priv, item, _DRM_REF_USE);
-	if (ret)
-		ret = drm_ht_remove_item(&dev->object_hash, &item->hash);
-
-	return ret;
-}
-EXPORT_SYMBOL(drm_add_user_object);
-
-struct drm_user_object *drm_lookup_user_object(struct drm_file *priv, uint32_t key)
-{
-	struct drm_device *dev = priv->minor->dev;
-	struct drm_hash_item *hash;
-	int ret;
-	struct drm_user_object *item;
-
-	DRM_ASSERT_LOCKED(&dev->struct_mutex);
-
-	ret = drm_ht_find_item(&dev->object_hash, key, &hash);
-	if (ret)
-		return NULL;
-
-	item = drm_hash_entry(hash, struct drm_user_object, hash);
-
-	if (priv != item->owner) {
-		struct drm_open_hash *ht = &priv->refd_object_hash[_DRM_REF_USE];
-		ret = drm_ht_find_item(ht, (unsigned long)item, &hash);
-		if (ret) {
-			DRM_ERROR("Object not registered for usage\n");
-			return NULL;
-		}
-	}
-	return item;
-}
-EXPORT_SYMBOL(drm_lookup_user_object);
-
-static void drm_deref_user_object(struct drm_file *priv, struct drm_user_object *item)
-{
-	struct drm_device *dev = priv->minor->dev;
-	int ret;
-
-	if (atomic_dec_and_test(&item->refcount)) {
-		ret = drm_ht_remove_item(&dev->object_hash, &item->hash);
-		BUG_ON(ret);
-		item->remove(priv, item);
-	}
-}
-
-static int drm_object_ref_action(struct drm_file *priv, struct drm_user_object *ro,
-				 enum drm_ref_type action)
-{
-	int ret = 0;
-
-	switch (action) {
-	case _DRM_REF_USE:
-		atomic_inc(&ro->refcount);
-		break;
-	default:
-		if (!ro->ref_struct_locked) {
-			break;
-		} else {
-			ro->ref_struct_locked(priv, ro, action);
-		}
-	}
-	return ret;
-}
-
-int drm_add_ref_object(struct drm_file *priv, struct drm_user_object *referenced_object,
-		       enum drm_ref_type ref_action)
-{
-	int ret = 0;
-	struct drm_ref_object *item;
-	struct drm_open_hash *ht = &priv->refd_object_hash[ref_action];
-
-	DRM_ASSERT_LOCKED(&priv->minor->dev->struct_mutex);
-	if (!referenced_object->shareable && priv != referenced_object->owner) {
-		DRM_ERROR("Not allowed to reference this object\n");
-		return -EINVAL;
-	}
-
-	/*
-	 * If this is not a usage reference, Check that usage has been registered
-	 * first. Otherwise strange things may happen on destruction.
-	 */
-
-	if ((ref_action != _DRM_REF_USE) && priv != referenced_object->owner) {
-		item =
-		    drm_lookup_ref_object(priv, referenced_object,
-					  _DRM_REF_USE);
-		if (!item) {
-			DRM_ERROR
-			    ("Object not registered for usage by this client\n");
-			return -EINVAL;
-		}
-	}
-
-	if (NULL !=
-	    (item =
-	     drm_lookup_ref_object(priv, referenced_object, ref_action))) {
-		atomic_inc(&item->refcount);
-		return drm_object_ref_action(priv, referenced_object,
-					     ref_action);
-	}
-
-	item = drm_ctl_calloc(1, sizeof(*item), DRM_MEM_OBJECTS);
-	if (item == NULL) {
-		DRM_ERROR("Could not allocate reference object\n");
-		return -ENOMEM;
-	}
-
-	atomic_set(&item->refcount, 1);
-	item->hash.key = (unsigned long)referenced_object;
-	ret = drm_ht_insert_item(ht, &item->hash);
-	item->unref_action = ref_action;
-
-	if (ret)
-		goto out;
-
-	list_add(&item->list, &priv->refd_objects);
-	ret = drm_object_ref_action(priv, referenced_object, ref_action);
-out:
-	return ret;
-}
-
-struct drm_ref_object *drm_lookup_ref_object(struct drm_file *priv,
-					struct drm_user_object *referenced_object,
-					enum drm_ref_type ref_action)
-{
-	struct drm_hash_item *hash;
-	int ret;
-
-	DRM_ASSERT_LOCKED(&priv->minor->dev->struct_mutex);
-	ret = drm_ht_find_item(&priv->refd_object_hash[ref_action],
-			       (unsigned long)referenced_object, &hash);
-	if (ret)
-		return NULL;
-
-	return drm_hash_entry(hash, struct drm_ref_object, hash);
-}
-EXPORT_SYMBOL(drm_lookup_ref_object);
-
-static void drm_remove_other_references(struct drm_file *priv,
-					struct drm_user_object *ro)
-{
-	int i;
-	struct drm_open_hash *ht;
-	struct drm_hash_item *hash;
-	struct drm_ref_object *item;
-
-	for (i = _DRM_REF_USE + 1; i < _DRM_NO_REF_TYPES; ++i) {
-		ht = &priv->refd_object_hash[i];
-		while (!drm_ht_find_item(ht, (unsigned long)ro, &hash)) {
-			item = drm_hash_entry(hash, struct drm_ref_object, hash);
-			drm_remove_ref_object(priv, item);
-		}
-	}
-}
-
-void drm_remove_ref_object(struct drm_file *priv, struct drm_ref_object *item)
-{
-	int ret;
-	struct drm_user_object *user_object = (struct drm_user_object *) item->hash.key;
-	struct drm_open_hash *ht = &priv->refd_object_hash[item->unref_action];
-	enum drm_ref_type unref_action;
-
-	DRM_ASSERT_LOCKED(&priv->minor->dev->struct_mutex);
-	unref_action = item->unref_action;
-	if (atomic_dec_and_test(&item->refcount)) {
-		ret = drm_ht_remove_item(ht, &item->hash);
-		BUG_ON(ret);
-		list_del_init(&item->list);
-		if (unref_action == _DRM_REF_USE)
-			drm_remove_other_references(priv, user_object);
-		drm_ctl_free(item, sizeof(*item), DRM_MEM_OBJECTS);
-	}
-
-	switch (unref_action) {
-	case _DRM_REF_USE:
-		drm_deref_user_object(priv, user_object);
-		break;
-	default:
-		BUG_ON(!user_object->unref);
-		user_object->unref(priv, user_object, unref_action);
-		break;
-	}
-
-}
-EXPORT_SYMBOL(drm_remove_ref_object);
-
-int drm_user_object_ref(struct drm_file *priv, uint32_t user_token,
-			enum drm_object_type type, struct drm_user_object **object)
-{
-	struct drm_device *dev = priv->minor->dev;
-	struct drm_user_object *uo;
-	struct drm_hash_item *hash;
-	int ret;
-
-	mutex_lock(&dev->struct_mutex);
-	ret = drm_ht_find_item(&dev->object_hash, user_token, &hash);
-	if (ret) {
-		DRM_ERROR("Could not find user object to reference.\n");
-		goto out_err;
-	}
-	uo = drm_hash_entry(hash, struct drm_user_object, hash);
-	if (uo->type != type) {
-		ret = -EINVAL;
-		goto out_err;
-	}
-	ret = drm_add_ref_object(priv, uo, _DRM_REF_USE);
-	if (ret)
-		goto out_err;
-	mutex_unlock(&dev->struct_mutex);
-	*object = uo;
-	return 0;
-out_err:
-	mutex_unlock(&dev->struct_mutex);
-	return ret;
-}
-
-int drm_user_object_unref(struct drm_file *priv, uint32_t user_token,
-			  enum drm_object_type type)
-{
-	struct drm_device *dev = priv->minor->dev;
-	struct drm_user_object *uo;
-	struct drm_ref_object *ro;
-	int ret;
-
-	mutex_lock(&dev->struct_mutex);
-	uo = drm_lookup_user_object(priv, user_token);
-	if (!uo || (uo->type != type)) {
-		ret = -EINVAL;
-		goto out_err;
-	}
-	ro = drm_lookup_ref_object(priv, uo, _DRM_REF_USE);
-	if (!ro) {
-		ret = -EINVAL;
-		goto out_err;
-	}
-	drm_remove_ref_object(priv, ro);
-	mutex_unlock(&dev->struct_mutex);
-	return 0;
-out_err:
-	mutex_unlock(&dev->struct_mutex);
-	return ret;
-}
diff --git a/linux-core/drm_objects.h b/linux-core/drm_objects.h
deleted file mode 100644
index 136fdc8d..00000000
--- a/linux-core/drm_objects.h
+++ /dev/null
@@ -1,821 +0,0 @@
-/**************************************************************************
- *
- * Copyright (c) 2006-2007 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 Hellström <thomas-at-tungstengraphics-dot-com>
- */
-
-#ifndef _DRM_OBJECTS_H
-#define _DRM_OBJECTS_H
-
-struct drm_device;
-struct drm_bo_mem_reg;
-
-/***************************************************
- * User space objects. (drm_object.c)
- */
-
-#define drm_user_object_entry(_ptr, _type, _member) container_of(_ptr, _type, _member)
-
-enum drm_object_type {
-	drm_fence_type,
-	drm_buffer_type,
-	drm_lock_type,
-	    /*
-	     * Add other user space object types here.
-	     */
-	drm_driver_type0 = 256,
-	drm_driver_type1,
-	drm_driver_type2,
-	drm_driver_type3,
-	drm_driver_type4
-};
-
-/*
- * A user object is a structure that helps the drm give out user handles
- * to kernel internal objects and to keep track of these objects so that
- * they can be destroyed, for example when the user space process exits.
- * Designed to be accessible using a user space 32-bit handle.
- */
-
-struct drm_user_object {
-	struct drm_hash_item hash;
-	struct list_head list;
-	enum drm_object_type type;
-	atomic_t refcount;
-	int shareable;
-	struct drm_file *owner;
-	void (*ref_struct_locked) (struct drm_file *priv,
-				   struct drm_user_object *obj,
-				   enum drm_ref_type ref_action);
-	void (*unref) (struct drm_file *priv, struct drm_user_object *obj,
-		       enum drm_ref_type unref_action);
-	void (*remove) (struct drm_file *priv, struct drm_user_object *obj);
-};
-
-/*
- * A ref object is a structure which is used to
- * keep track of references to user objects and to keep track of these
- * references so that they can be destroyed for example when the user space
- * process exits. Designed to be accessible using a pointer to the _user_ object.
- */
-
-struct drm_ref_object {
-	struct drm_hash_item hash;
-	struct list_head list;
-	atomic_t refcount;
-	enum drm_ref_type unref_action;
-};
-
-/**
- * Must be called with the struct_mutex held.
- */
-
-extern int drm_add_user_object(struct drm_file *priv, struct drm_user_object *item,
-			       int shareable);
-/**
- * Must be called with the struct_mutex held.
- */
-
-extern struct drm_user_object *drm_lookup_user_object(struct drm_file *priv,
-						 uint32_t key);
-
-/*
- * Must be called with the struct_mutex held. May temporarily release it.
- */
-
-extern int drm_add_ref_object(struct drm_file *priv,
-			      struct drm_user_object *referenced_object,
-			      enum drm_ref_type ref_action);
-
-/*
- * Must be called with the struct_mutex held.
- */
-
-struct drm_ref_object *drm_lookup_ref_object(struct drm_file *priv,
-					struct drm_user_object *referenced_object,
-					enum drm_ref_type ref_action);
-/*
- * Must be called with the struct_mutex held.
- * If "item" has been obtained by a call to drm_lookup_ref_object. You may not
- * release the struct_mutex before calling drm_remove_ref_object.
- * This function may temporarily release the struct_mutex.
- */
-
-extern void drm_remove_ref_object(struct drm_file *priv, struct drm_ref_object *item);
-extern int drm_user_object_ref(struct drm_file *priv, uint32_t user_token,
-			       enum drm_object_type type,
-			       struct drm_user_object **object);
-extern int drm_user_object_unref(struct drm_file *priv, uint32_t user_token,
-				 enum drm_object_type type);
-
-/***************************************************
- * Fence objects. (drm_fence.c)
- */
-
-struct drm_fence_object {
-	struct drm_user_object base;
-	struct drm_device *dev;
-	atomic_t usage;
-
-	/*
-	 * The below three fields are protected by the fence manager spinlock.
-	 */
-
-	struct list_head ring;
-	int fence_class;
-	uint32_t native_types;
-	uint32_t type;
-	uint32_t signaled_types;
-	uint32_t sequence;
-	uint32_t waiting_types;
-	uint32_t error;
-};
-
-#define _DRM_FENCE_CLASSES 8
-#define _DRM_FENCE_TYPE_EXE 0x00
-
-struct drm_fence_class_manager {
-	struct list_head ring;
-	uint32_t pending_flush;
-	uint32_t waiting_types;
-	wait_queue_head_t fence_queue;
-	uint32_t highest_waiting_sequence;
-        uint32_t latest_queued_sequence;
-};
-
-struct drm_fence_manager {
-	int initialized;
-	rwlock_t lock;
-	struct drm_fence_class_manager fence_class[_DRM_FENCE_CLASSES];
-	uint32_t num_classes;
-	atomic_t count;
-};
-
-struct drm_fence_driver {
-	unsigned long *waiting_jiffies;
-	uint32_t num_classes;
-	uint32_t wrap_diff;
-	uint32_t flush_diff;
-	uint32_t sequence_mask;
-
-	/*
-	 * Driver implemented functions:
-	 * has_irq() : 1 if the hardware can update the indicated type_flags using an
-	 * irq handler. 0 if polling is required.
-	 *
-	 * emit() : Emit a sequence number to the command stream.
-	 * Return the sequence number.
-	 *
-	 * flush() : Make sure the flags indicated in fc->pending_flush will eventually
-	 * signal for fc->highest_received_sequence and all preceding sequences.
-	 * Acknowledge by clearing the flags fc->pending_flush.
-	 *
-	 * poll() : Call drm_fence_handler with any new information.
-	 *
-	 * needed_flush() : Given the current state of the fence->type flags and previusly 
-	 * executed or queued flushes, return the type_flags that need flushing.
-	 *
-	 * wait(): Wait for the "mask" flags to signal on a given fence, performing
-	 * whatever's necessary to make this happen.
-	 */
-
-	int (*has_irq) (struct drm_device *dev, uint32_t fence_class,
-			uint32_t flags);
-	int (*emit) (struct drm_device *dev, uint32_t fence_class,
-		     uint32_t flags, uint32_t *breadcrumb,
-		     uint32_t *native_type);
-	void (*flush) (struct drm_device *dev, uint32_t fence_class);
-	void (*poll) (struct drm_device *dev, uint32_t fence_class,
-		uint32_t types);
-	uint32_t (*needed_flush) (struct drm_fence_object *fence);
-	int (*wait) (struct drm_fence_object *fence, int lazy,
-		     int interruptible, uint32_t mask);
-};
-
-extern int drm_fence_wait_polling(struct drm_fence_object *fence, int lazy,
-				  int interruptible, uint32_t mask,
-				  unsigned long end_jiffies);
-extern void drm_fence_handler(struct drm_device *dev, uint32_t fence_class,
-			      uint32_t sequence, uint32_t type,
-			      uint32_t error);
-extern void drm_fence_manager_init(struct drm_device *dev);
-extern void drm_fence_manager_takedown(struct drm_device *dev);
-extern void drm_fence_flush_old(struct drm_device *dev, uint32_t fence_class,
-				uint32_t sequence);
-extern int drm_fence_object_flush(struct drm_fence_object *fence,
-				  uint32_t type);
-extern int drm_fence_object_signaled(struct drm_fence_object *fence,
-				     uint32_t type);
-extern void drm_fence_usage_deref_locked(struct drm_fence_object **fence);
-extern void drm_fence_usage_deref_unlocked(struct drm_fence_object **fence);
-extern struct drm_fence_object *drm_fence_reference_locked(struct drm_fence_object *src);
-extern void drm_fence_reference_unlocked(struct drm_fence_object **dst,
-					 struct drm_fence_object *src);
-extern int drm_fence_object_wait(struct drm_fence_object *fence,
-				 int lazy, int ignore_signals, uint32_t mask);
-extern int drm_fence_object_create(struct drm_device *dev, uint32_t type,
-				   uint32_t fence_flags, uint32_t fence_class,
-				   struct drm_fence_object **c_fence);
-extern int drm_fence_object_emit(struct drm_fence_object *fence,
-				 uint32_t fence_flags, uint32_t class,
-				 uint32_t type);
-extern void drm_fence_fill_arg(struct drm_fence_object *fence,
-			       struct drm_fence_arg *arg);
-
-extern int drm_fence_add_user_object(struct drm_file *priv,
-				     struct drm_fence_object *fence,
-				     int shareable);
-
-extern int drm_fence_create_ioctl(struct drm_device *dev, void *data,
-				  struct drm_file *file_priv);
-extern int drm_fence_destroy_ioctl(struct drm_device *dev, void *data,
-				   struct drm_file *file_priv);
-extern int drm_fence_reference_ioctl(struct drm_device *dev, void *data,
-				     struct drm_file *file_priv);
-extern int drm_fence_unreference_ioctl(struct drm_device *dev, void *data,
-				       struct drm_file *file_priv);
-extern int drm_fence_signaled_ioctl(struct drm_device *dev, void *data,
-				    struct drm_file *file_priv);
-extern int drm_fence_flush_ioctl(struct drm_device *dev, void *data,
-				 struct drm_file *file_priv);
-extern int drm_fence_wait_ioctl(struct drm_device *dev, void *data,
-				struct drm_file *file_priv);
-extern int drm_fence_emit_ioctl(struct drm_device *dev, void *data,
-				struct drm_file *file_priv);
-extern int drm_fence_buffers_ioctl(struct drm_device *dev, void *data,
-				   struct drm_file *file_priv);
-/**************************************************
- *TTMs
- */
-
-/*
- * The ttm backend GTT interface. (In our case AGP).
- * Any similar type of device (PCIE?)
- * needs only to implement these functions to be usable with the TTM interface.
- * The AGP backend implementation lives in drm_agpsupport.c
- * basically maps these calls to available functions in agpgart.
- * Each drm device driver gets an
- * additional function pointer that creates these types,
- * so that the device can choose the correct aperture.
- * (Multiple AGP apertures, etc.)
- * Most device drivers will let this point to the standard AGP implementation.
- */
-
-#define DRM_BE_FLAG_NEEDS_FREE     0x00000001
-#define DRM_BE_FLAG_BOUND_CACHED   0x00000002
-
-struct drm_ttm_backend;
-struct drm_ttm_backend_func {
-	int (*needs_ub_cache_adjust) (struct drm_ttm_backend *backend);
-	int (*populate) (struct drm_ttm_backend *backend,
-			 unsigned long num_pages, struct page **pages,
-			 struct page *dummy_read_page);
-	void (*clear) (struct drm_ttm_backend *backend);
-	int (*bind) (struct drm_ttm_backend *backend,
-		     struct drm_bo_mem_reg *bo_mem);
-	int (*unbind) (struct drm_ttm_backend *backend);
-	void (*destroy) (struct drm_ttm_backend *backend);
-};
-
-/**
- * This structure associates a set of flags and methods with a drm_ttm
- * object, and will also be subclassed by the particular backend.
- *
- * \sa #drm_agp_ttm_backend
- */
-struct drm_ttm_backend {
-	struct drm_device *dev;
-	uint32_t flags;
-	struct drm_ttm_backend_func *func;
-};
-
-struct drm_ttm {
-	struct page *dummy_read_page;
-	struct page **pages;
-	long first_himem_page;
-	long last_lomem_page;
-	uint32_t page_flags;
-	unsigned long num_pages;
-	atomic_t vma_count;
-	struct drm_device *dev;
-	int destroy;
-	uint32_t mapping_offset;
-	struct drm_ttm_backend *be;
-	unsigned long highest_lomem_entry;
-	unsigned long lowest_himem_entry;
-	enum {
-		ttm_bound,
-		ttm_evicted,
-		ttm_unbound,
-		ttm_unpopulated,
-	} state;
-
-};
-
-extern struct drm_ttm *drm_ttm_create(struct drm_device *dev, unsigned long size,
-				      uint32_t page_flags,
-				      struct page *dummy_read_page);
-extern int drm_ttm_bind(struct drm_ttm *ttm, struct drm_bo_mem_reg *bo_mem);
-extern void drm_ttm_unbind(struct drm_ttm *ttm);
-extern void drm_ttm_evict(struct drm_ttm *ttm);
-extern void drm_ttm_fixup_caching(struct drm_ttm *ttm);
-extern struct page *drm_ttm_get_page(struct drm_ttm *ttm, int index);
-extern void drm_ttm_cache_flush(struct page *pages[], unsigned long num_pages);
-extern int drm_ttm_populate(struct drm_ttm *ttm);
-extern int drm_ttm_set_user(struct drm_ttm *ttm,
-			    struct task_struct *tsk,
-			    unsigned long start,
-			    unsigned long num_pages);
-
-/*
- * Destroy a ttm. The user normally calls drmRmMap or a similar IOCTL to do
- * this which calls this function iff there are no vmas referencing it anymore.
- * Otherwise it is called when the last vma exits.
- */
-
-extern int drm_ttm_destroy(struct drm_ttm *ttm);
-
-#define DRM_FLAG_MASKED(_old, _new, _mask) {\
-(_old) ^= (((_old) ^ (_new)) & (_mask)); \
-}
-
-#define DRM_TTM_MASK_FLAGS ((1 << PAGE_SHIFT) - 1)
-#define DRM_TTM_MASK_PFN (0xFFFFFFFFU - DRM_TTM_MASK_FLAGS)
-
-/*
- * Page flags.
- */
-
-/*
- * This ttm should not be cached by the CPU
- */
-#define DRM_TTM_PAGE_UNCACHED   (1 << 0)
-/*
- * This flat is not used at this time; I don't know what the
- * intent was
- */
-#define DRM_TTM_PAGE_USED       (1 << 1)
-/*
- * This flat is not used at this time; I don't know what the
- * intent was
- */
-#define DRM_TTM_PAGE_BOUND      (1 << 2)
-/*
- * This flat is not used at this time; I don't know what the
- * intent was
- */
-#define DRM_TTM_PAGE_PRESENT    (1 << 3)
-/*
- * The array of page pointers was allocated with vmalloc
- * instead of drm_calloc.
- */
-#define DRM_TTM_PAGEDIR_VMALLOC (1 << 4)
-/*
- * This ttm is mapped from user space
- */
-#define DRM_TTM_PAGE_USER       (1 << 5)
-/*
- * This ttm will be written to by the GPU
- */
-#define DRM_TTM_PAGE_WRITE	(1 << 6)
-/*
- * This ttm was mapped to the GPU, and so the contents may have
- * been modified
- */
-#define DRM_TTM_PAGE_USER_DIRTY (1 << 7)
-/*
- * This flag is not used at this time; I don't know what the
- * intent was.
- */
-#define DRM_TTM_PAGE_USER_DMA   (1 << 8)
-
-/***************************************************
- * Buffer objects. (drm_bo.c, drm_bo_move.c)
- */
-
-struct drm_bo_mem_reg {
-	struct drm_mm_node *mm_node;
-	unsigned long size;
-	unsigned long num_pages;
-	uint32_t page_alignment;
-	uint32_t mem_type;
-	/*
-	 * Current buffer status flags, indicating
-	 * where the buffer is located and which
-	 * access modes are in effect
-	 */
-	uint64_t flags;
-	/**
-	 * These are the flags proposed for
-	 * a validate operation. If the
-	 * validate succeeds, they'll get moved
-	 * into the flags field
-	 */
-	uint64_t proposed_flags;
-	
-	uint32_t desired_tile_stride;
-	uint32_t hw_tile_stride;
-};
-
-enum drm_bo_type {
-	/*
-	 * drm_bo_type_device are 'normal' drm allocations,
-	 * pages are allocated from within the kernel automatically
-	 * and the objects can be mmap'd from the drm device. Each
-	 * drm_bo_type_device object has a unique name which can be
-	 * used by other processes to share access to the underlying
-	 * buffer.
-	 */
-	drm_bo_type_device,
-	/*
-	 * drm_bo_type_user are buffers of pages that already exist
-	 * in the process address space. They are more limited than
-	 * drm_bo_type_device buffers in that they must always
-	 * remain cached (as we assume the user pages are mapped cached),
-	 * and they are not sharable to other processes through DRM
-	 * (although, regular shared memory should still work fine).
-	 */
-	drm_bo_type_user,
-	/*
-	 * drm_bo_type_kernel are buffers that exist solely for use
-	 * within the kernel. The pages cannot be mapped into the
-	 * process. One obvious use would be for the ring
-	 * buffer where user access would not (ideally) be required.
-	 */
-	drm_bo_type_kernel,
-};
-
-struct drm_buffer_object {
-	struct drm_device *dev;
-	struct drm_user_object base;
-
-	/*
-	 * If there is a possibility that the usage variable is zero,
-	 * then dev->struct_mutext should be locked before incrementing it.
-	 */
-
-	atomic_t usage;
-	unsigned long buffer_start;
-	enum drm_bo_type type;
-	unsigned long offset;
-	atomic_t mapped;
-	struct drm_bo_mem_reg mem;
-
-	struct list_head lru;
-	struct list_head ddestroy;
-
-	uint32_t fence_type;
-	uint32_t fence_class;
-	uint32_t new_fence_type;
-	uint32_t new_fence_class;
-	struct drm_fence_object *fence;
-	uint32_t priv_flags;
-	wait_queue_head_t event_queue;
-	struct mutex mutex;
-	unsigned long num_pages;
-
-	/* For pinned buffers */
-	struct drm_mm_node *pinned_node;
-	uint32_t pinned_mem_type;
-	struct list_head pinned_lru;
-
-	/* For vm */
-	struct drm_ttm *ttm;
-	struct drm_map_list map_list;
-	uint32_t memory_type;
-	unsigned long bus_offset;
-	uint32_t vm_flags;
-	void *iomap;
-};
-
-#define _DRM_BO_FLAG_UNFENCED 0x00000001
-#define _DRM_BO_FLAG_EVICTED  0x00000002
-
-/*
- * This flag indicates that a flag called with bo->mutex held has
- * temporarily released the buffer object mutex, (usually to wait for something).
- * and thus any post-lock validation needs to be rerun.
- */
-
-#define _DRM_BO_FLAG_UNLOCKED 0x00000004
-
-struct drm_mem_type_manager {
-	int has_type;
-	int use_type;
-	int kern_init_type;
-	struct drm_mm manager;
-	struct list_head lru;
-	struct list_head pinned;
-	uint32_t flags;
-	uint32_t drm_bus_maptype;
-	unsigned long gpu_offset;
-	unsigned long io_offset;
-	unsigned long io_size;
-	void *io_addr;
-	uint64_t size; /* size of managed area for reporting to userspace */
-};
-
-struct drm_bo_lock {
-	struct drm_user_object base;
-	wait_queue_head_t queue;
-	atomic_t write_lock_pending;
-	atomic_t readers;
-};
-
-#define _DRM_FLAG_MEMTYPE_FIXED     0x00000001	/* Fixed (on-card) PCI memory */
-#define _DRM_FLAG_MEMTYPE_MAPPABLE  0x00000002	/* Memory mappable */
-#define _DRM_FLAG_MEMTYPE_CACHED    0x00000004	/* Cached binding */
-#define _DRM_FLAG_NEEDS_IOREMAP     0x00000008	/* Fixed memory needs ioremap
-						   before kernel access. */
-#define _DRM_FLAG_MEMTYPE_CMA       0x00000010	/* Can't map aperture */
-#define _DRM_FLAG_MEMTYPE_CSELECT   0x00000020	/* Select caching */
-
-struct drm_buffer_manager {
-	struct drm_bo_lock bm_lock;
-	struct mutex evict_mutex;
-	int nice_mode;
-	int initialized;
-	struct drm_file *last_to_validate;
-	struct drm_mem_type_manager man[DRM_BO_MEM_TYPES];
-	struct list_head unfenced;
-	struct list_head ddestroy;
-	struct delayed_work wq;
-	uint32_t fence_type;
-	unsigned long cur_pages;
-	atomic_t count;
-	struct page *dummy_read_page;
-};
-
-struct drm_bo_driver {
-	const uint32_t *mem_type_prio;
-	const uint32_t *mem_busy_prio;
-	uint32_t num_mem_type_prio;
-	uint32_t num_mem_busy_prio;
-	struct drm_ttm_backend *(*create_ttm_backend_entry)
-	 (struct drm_device *dev);
-	int (*fence_type) (struct drm_buffer_object *bo, uint32_t *fclass,
-			   uint32_t *type);
-	int (*invalidate_caches) (struct drm_device *dev, uint64_t flags);
-	int (*init_mem_type) (struct drm_device *dev, uint32_t type,
-			      struct drm_mem_type_manager *man);
-	/*
-	 * evict_flags:
-	 *
-	 * @bo: the buffer object to be evicted
-	 *
-	 * Return the bo flags for a buffer which is not mapped to the hardware.
-	 * These will be placed in proposed_flags so that when the move is
-	 * finished, they'll end up in bo->mem.flags
-	 */
-	uint64_t(*evict_flags) (struct drm_buffer_object *bo);
-	/*
-	 * move:
-	 *
-	 * @bo: the buffer to move
-	 *
-	 * @evict: whether this motion is evicting the buffer from
-	 * the graphics address space
-	 *
-	 * @no_wait: whether this should give up and return -EBUSY
-	 * if this move would require sleeping
-	 *
-	 * @new_mem: the new memory region receiving the buffer
-	 *
-	 * Move a buffer between two memory regions.
-	 */
-	int (*move) (struct drm_buffer_object *bo,
-		     int evict, int no_wait, struct drm_bo_mem_reg *new_mem);
-	/*
-	 * ttm_cache_flush
-	 */
-	void (*ttm_cache_flush)(struct drm_ttm *ttm);
-
-	/*
-	 * command_stream_barrier
-	 *
-	 * @dev: The drm device.
-	 *
-	 * @bo: The buffer object to validate.
-	 *
-	 * @new_fence_class: The new fence class for the buffer object.
-	 *
-	 * @new_fence_type: The new fence type for the buffer object.
-	 *
-	 * @no_wait: whether this should give up and return -EBUSY
-	 * if this operation would require sleeping
-	 *
-	 * Insert a command stream barrier that makes sure that the
-	 * buffer is idle once the commands associated with the
-	 * current validation are starting to execute. If an error
-	 * condition is returned, or the function pointer is NULL,
-	 * the drm core will force buffer idle
-	 * during validation.
-	 */
-
-	int (*command_stream_barrier) (struct drm_buffer_object *bo,
-				       uint32_t new_fence_class,
-				       uint32_t new_fence_type,
-				       int no_wait);				       
-};
-
-/*
- * buffer objects (drm_bo.c)
- */
-
-extern int drm_bo_create_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv);
-extern int drm_bo_destroy_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv);
-extern int drm_bo_map_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv);
-extern int drm_bo_unmap_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv);
-extern int drm_bo_reference_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv);
-extern int drm_bo_unreference_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv);
-extern int drm_bo_wait_idle_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv);
-extern int drm_bo_info_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv);
-extern int drm_bo_setstatus_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv);
-extern int drm_mm_init_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv);
-extern int drm_mm_takedown_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv);
-extern int drm_mm_lock_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv);
-extern int drm_mm_unlock_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv);
-extern int drm_mm_info_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv);
-extern int drm_bo_version_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv);
-extern int drm_bo_driver_finish(struct drm_device *dev);
-extern int drm_bo_driver_init(struct drm_device *dev);
-extern int drm_bo_pci_offset(struct drm_device *dev,
-			     struct drm_bo_mem_reg *mem,
-			     unsigned long *bus_base,
-			     unsigned long *bus_offset,
-			     unsigned long *bus_size);
-extern int drm_mem_reg_is_pci(struct drm_device *dev, struct drm_bo_mem_reg *mem);
-
-extern void drm_bo_usage_deref_locked(struct drm_buffer_object **bo);
-extern void drm_bo_usage_deref_unlocked(struct drm_buffer_object **bo);
-extern void drm_putback_buffer_objects(struct drm_device *dev);
-extern int drm_fence_buffer_objects(struct drm_device *dev,
-				    struct list_head *list,
-				    uint32_t fence_flags,
-				    struct drm_fence_object *fence,
-				    struct drm_fence_object **used_fence);
-extern void drm_bo_add_to_lru(struct drm_buffer_object *bo);
-extern int drm_buffer_object_create(struct drm_device *dev, unsigned long size,
-				    enum drm_bo_type type, uint64_t flags,
-				    uint32_t hint, uint32_t page_alignment,
-				    unsigned long buffer_start,
-				    struct drm_buffer_object **bo);
-extern int drm_bo_wait(struct drm_buffer_object *bo, int lazy, int interruptible,
-		       int no_wait, int check_unfenced);
-extern int drm_bo_mem_space(struct drm_buffer_object *bo,
-			    struct drm_bo_mem_reg *mem, int no_wait);
-extern int drm_bo_move_buffer(struct drm_buffer_object *bo,
-			      uint64_t new_mem_flags,
-			      int no_wait, int move_unfenced);
-extern int drm_bo_clean_mm(struct drm_device *dev, unsigned mem_type, int kern_clean);
-extern int drm_bo_init_mm(struct drm_device *dev, unsigned type,
-			  unsigned long p_offset, unsigned long p_size,
-			  int kern_init);
-extern int drm_bo_handle_validate(struct drm_file *file_priv, uint32_t handle,
-				  uint64_t flags, uint64_t mask, uint32_t hint,
-				  uint32_t fence_class,
-				  struct drm_bo_info_rep *rep,
-				  struct drm_buffer_object **bo_rep);
-extern struct drm_buffer_object *drm_lookup_buffer_object(struct drm_file *file_priv,
-							  uint32_t handle,
-							  int check_owner);
-extern int drm_bo_do_validate(struct drm_buffer_object *bo,
-			      uint64_t flags, uint64_t mask, uint32_t hint,
-			      uint32_t fence_class,
-			      struct drm_bo_info_rep *rep);
-extern int drm_bo_evict_cached(struct drm_buffer_object *bo);
-/*
- * Buffer object memory move- and map helpers.
- * drm_bo_move.c
- */
-
-extern int drm_bo_move_ttm(struct drm_buffer_object *bo,
-			   int evict, int no_wait,
-			   struct drm_bo_mem_reg *new_mem);
-extern int drm_bo_move_memcpy(struct drm_buffer_object *bo,
-			      int evict,
-			      int no_wait, struct drm_bo_mem_reg *new_mem);
-extern int drm_bo_move_accel_cleanup(struct drm_buffer_object *bo,
-				     int evict, int no_wait,
-				     uint32_t fence_class, uint32_t fence_type,
-				     uint32_t fence_flags,
-				     struct drm_bo_mem_reg *new_mem);
-extern int drm_bo_same_page(unsigned long offset, unsigned long offset2);
-extern unsigned long drm_bo_offset_end(unsigned long offset,
-				       unsigned long end);
-
-struct drm_bo_kmap_obj {
-	void *virtual;
-	struct page *page;
-	enum {
-		bo_map_iomap,
-		bo_map_vmap,
-		bo_map_kmap,
-		bo_map_premapped,
-	} bo_kmap_type;
-};
-
-static inline void *drm_bmo_virtual(struct drm_bo_kmap_obj *map, int *is_iomem)
-{
-	*is_iomem = (map->bo_kmap_type == bo_map_iomap ||
-		     map->bo_kmap_type == bo_map_premapped);
-	return map->virtual;
-}
-extern void drm_bo_kunmap(struct drm_bo_kmap_obj *map);
-extern int drm_bo_kmap(struct drm_buffer_object *bo, unsigned long start_page,
-		       unsigned long num_pages, struct drm_bo_kmap_obj *map);
-extern int drm_bo_pfn_prot(struct drm_buffer_object *bo,
-			   unsigned long dst_offset,
-			   unsigned long *pfn,
-			   pgprot_t *prot);
-extern void drm_bo_fill_rep_arg(struct drm_buffer_object *bo,
-				struct drm_bo_info_rep *rep);
-
-
-/*
- * drm_regman.c
- */
-
-struct drm_reg {
-	struct list_head head;
-	struct drm_fence_object *fence;
-	uint32_t fence_type;
-	uint32_t new_fence_type;
-};
-
-struct drm_reg_manager {
-	struct list_head free;
-	struct list_head lru;
-	struct list_head unfenced;
-
-	int (*reg_reusable)(const struct drm_reg *reg, const void *data);
-	void (*reg_destroy)(struct drm_reg *reg);
-};
-
-extern int drm_regs_alloc(struct drm_reg_manager *manager,
-			  const void *data,
-			  uint32_t fence_class,
-			  uint32_t fence_type,
-			  int interruptible,
-			  int no_wait,
-			  struct drm_reg **reg);
-
-extern void drm_regs_fence(struct drm_reg_manager *regs,
-			   struct drm_fence_object *fence);
-
-extern void drm_regs_free(struct drm_reg_manager *manager);
-extern void drm_regs_add(struct drm_reg_manager *manager, struct drm_reg *reg);
-extern void drm_regs_init(struct drm_reg_manager *manager,
-			  int (*reg_reusable)(const struct drm_reg *,
-					      const void *),
-			  void (*reg_destroy)(struct drm_reg *));
-
-/*
- * drm_bo_lock.c
- * Simple replacement for the hardware lock on buffer manager init and clean.
- */
-
-
-extern void drm_bo_init_lock(struct drm_bo_lock *lock);
-extern void drm_bo_read_unlock(struct drm_bo_lock *lock);
-extern int drm_bo_read_lock(struct drm_bo_lock *lock,
-			    int interruptible);
-extern int drm_bo_write_lock(struct drm_bo_lock *lock,
-			     int interruptible,
-			     struct drm_file *file_priv);
-
-extern int drm_bo_write_unlock(struct drm_bo_lock *lock,
-			       struct drm_file *file_priv);
-
-#ifdef CONFIG_DEBUG_MUTEXES
-#define DRM_ASSERT_LOCKED(_mutex)					\
-	BUG_ON(!mutex_is_locked(_mutex) ||				\
-	       ((_mutex)->owner != current_thread_info()))
-#else
-#define DRM_ASSERT_LOCKED(_mutex)
-#endif
-#endif
diff --git a/linux-core/drm_proc.c b/linux-core/drm_proc.c
index 15d8cb96..57c83278 100644
--- a/linux-core/drm_proc.c
+++ b/linux-core/drm_proc.c
@@ -49,8 +49,6 @@ static int drm_queues_info(char *buf, char **start, off_t offset,
 			   int request, int *eof, void *data);
 static int drm_bufs_info(char *buf, char **start, off_t offset,
 			 int request, int *eof, void *data);
-static int drm_objects_info(char *buf, char **start, off_t offset,
-			 int request, int *eof, void *data);
 static int drm_gem_name_info(char *buf, char **start, off_t offset,
 			     int request, int *eof, void *data);
 static int drm_gem_object_info(char *buf, char **start, off_t offset,
@@ -73,7 +71,6 @@ static struct drm_proc_list {
 	{"clients", drm_clients_info},
 	{"queues", drm_queues_info},
 	{"bufs", drm_bufs_info},
-	{"objects", drm_objects_info},
 	{"gem_names", drm_gem_name_info},
 	{"gem_objects", drm_gem_object_info},
 #if DRM_DEBUG_CODE
@@ -432,105 +429,6 @@ static int drm_bufs_info(char *buf, char **start, off_t offset, int request,
 }
 
 /**
- * Called when "/proc/dri/.../objects" is read.
- *
- * \param buf output buffer.
- * \param start start of output data.
- * \param offset requested start offset.
- * \param request requested number of bytes.
- * \param eof whether there is no more data to return.
- * \param data private data.
- * \return number of written bytes.
- */
-static int drm__objects_info(char *buf, char **start, off_t offset, int request,
-			  int *eof, void *data)
-{
-	struct drm_minor *minor = (struct drm_minor *) data; 
-	struct drm_device *dev = minor->dev;
-	int len = 0;
-	struct drm_buffer_manager *bm = &dev->bm;
-	struct drm_fence_manager *fm = &dev->fm;
-	uint64_t used_mem;
-	uint64_t used_emer;
-	uint64_t low_mem;
-	uint64_t high_mem;
-	uint64_t emer_mem;
-
-	if (offset > DRM_PROC_LIMIT) {
-		*eof = 1;
-		return 0;
-	}
-
-	*start = &buf[offset];
-	*eof = 0;
-
-	DRM_PROC_PRINT("Object accounting:\n\n");
-	if (fm->initialized) {
-		DRM_PROC_PRINT("Number of active fence objects: %d.\n",
-			       atomic_read(&fm->count));
-	} else {
-		DRM_PROC_PRINT("Fence objects are not supported by this driver\n");
-	}
-
-	if (bm->initialized) {
-		DRM_PROC_PRINT("Number of active buffer objects: %d.\n\n",
-			       atomic_read(&bm->count));
-	}
-	DRM_PROC_PRINT("Memory accounting:\n\n");
-	if (bm->initialized) {
-		DRM_PROC_PRINT("Number of locked GATT pages: %lu.\n", bm->cur_pages);
-	} else {
-		DRM_PROC_PRINT("Buffer objects are not supported by this driver.\n");
-	}
-
-	drm_query_memctl(&used_mem, &used_emer, &low_mem, &high_mem, &emer_mem);
-
-	if (used_mem > 16*PAGE_SIZE) {
-		DRM_PROC_PRINT("Used object memory is %lu pages.\n",
-			       (unsigned long) (used_mem >> PAGE_SHIFT));
-	} else {
-		DRM_PROC_PRINT("Used object memory is %lu bytes.\n",
-			       (unsigned long) used_mem);
-	}
-	if (used_emer > 16*PAGE_SIZE) {
-		DRM_PROC_PRINT("Used emergency memory is %lu pages.\n",
-			       (unsigned long) (used_emer >> PAGE_SHIFT));
-	} else {
-		DRM_PROC_PRINT("Used emergency memory is %lu bytes.\n\n",
-			       (unsigned long) used_emer);
-	}
-	DRM_PROC_PRINT("Soft object memory usage threshold is %lu pages.\n",
-		       (unsigned long) (low_mem >> PAGE_SHIFT));
-	DRM_PROC_PRINT("Hard object memory usage threshold is %lu pages.\n",
-		       (unsigned long) (high_mem >> PAGE_SHIFT));
-	DRM_PROC_PRINT("Emergency root only memory usage threshold is %lu pages.\n",
-		       (unsigned long) (emer_mem >> PAGE_SHIFT));
-
-	DRM_PROC_PRINT("\n");
-
-	if (len > request + offset)
-		return request;
-	*eof = 1;
-	return len - offset;
-}
-
-/**
- * Simply calls _objects_info() while holding the drm_device::struct_mutex lock.
- */
-static int drm_objects_info(char *buf, char **start, off_t offset, int request,
-			 int *eof, void *data)
-{
-	struct drm_minor *minor = (struct drm_minor *) data; 
-	struct drm_device *dev = minor->dev;
-	int ret;
-
-	mutex_lock(&dev->struct_mutex);
-	ret = drm__objects_info(buf, start, offset, request, eof, data);
-	mutex_unlock(&dev->struct_mutex);
-	return ret;
-}
-
-/**
  * Called when "/proc/dri/.../clients" is read.
  *
  * \param buf output buffer.
diff --git a/linux-core/drm_stub.c b/linux-core/drm_stub.c
index 1518bc6d..6e68f677 100644
--- a/linux-core/drm_stub.c
+++ b/linux-core/drm_stub.c
@@ -98,7 +98,6 @@ static int drm_fill_in_dev(struct drm_device * dev, struct pci_dev *pdev,
 	init_timer(&dev->timer);
 	mutex_init(&dev->struct_mutex);
 	mutex_init(&dev->ctxlist_mutex);
-	mutex_init(&dev->bm.evict_mutex);
 
 	idr_init(&dev->drw_idr);
 
@@ -115,17 +114,6 @@ 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)) {
-		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);
-		return -ENOMEM;
-	}
 
 	/* the DRM has 6 counters */
 	dev->counters = 6;
@@ -171,8 +159,6 @@ static int drm_fill_in_dev(struct drm_device * dev, struct pci_dev *pdev,
 		}
 	}
 
-	drm_fence_manager_init(dev);
-
 	return 0;
 
 error_out_unreg:
diff --git a/linux-core/drm_ttm.c b/linux-core/drm_ttm.c
deleted file mode 100644
index cb3e7505..00000000
--- a/linux-core/drm_ttm.c
+++ /dev/null
@@ -1,512 +0,0 @@
-/**************************************************************************
- *
- * Copyright (c) 2006-2007 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 Hellström <thomas-at-tungstengraphics-dot-com>
- */
-
-#include "drmP.h"
-
-#if defined( CONFIG_X86 ) && (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24))
-static void drm_clflush_page(struct page *page)
-{
-	uint8_t *page_virtual;
-	unsigned int i;
-
-	if (unlikely(page == NULL))
-		return;
-
-	page_virtual = kmap_atomic(page, KM_USER0);
-
-	for (i=0; i < PAGE_SIZE; i += boot_cpu_data.x86_clflush_size)
-		clflush(page_virtual + i);
-
-	kunmap_atomic(page_virtual, KM_USER0);
-}
-
-static void drm_ttm_cache_flush_clflush(struct page *pages[], unsigned long num_pages)
-{
-	unsigned long i;
-
-	mb();
-	for (i=0; i < num_pages; ++i)
-		drm_clflush_page(*pages++);
-	mb();
-}
-#endif
-
-static void drm_ttm_ipi_handler(void *null)
-{
-	flush_agp_cache();
-}
-
-void drm_ttm_cache_flush(struct page *pages[], unsigned long num_pages)
-{
-
-#if defined( CONFIG_X86 ) && (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24))
-	if (cpu_has_clflush) {
-		drm_ttm_cache_flush_clflush(pages, num_pages);
-		return;
-	}
-#endif
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27))
-	if (on_each_cpu(drm_ttm_ipi_handler, NULL, 1))
-#else
- 	if (on_each_cpu(drm_ttm_ipi_handler, NULL, 1, 1) != 0)
-#endif
-		DRM_ERROR("Timed out waiting for drm cache flush.\n");
-}
-EXPORT_SYMBOL(drm_ttm_cache_flush);
-
-/**
- * Allocates storage for pointers to the pages that back the ttm.
- *
- * Uses kmalloc if possible. Otherwise falls back to vmalloc.
- */
-static void drm_ttm_alloc_page_directory(struct drm_ttm *ttm)
-{
-	unsigned long size = ttm->num_pages * sizeof(*ttm->pages);
-	ttm->pages = NULL;
-
-	if (drm_alloc_memctl(size))
-		return;
-
-	if (size <= PAGE_SIZE)
-		ttm->pages = drm_calloc(1, size, DRM_MEM_TTM);
-
-	if (!ttm->pages) {
-		ttm->pages = vmalloc_user(size);
-		if (ttm->pages)
-			ttm->page_flags |= DRM_TTM_PAGEDIR_VMALLOC;
-	}
-	if (!ttm->pages)
-		drm_free_memctl(size);
-}
-
-static void drm_ttm_free_page_directory(struct drm_ttm *ttm)
-{
-	unsigned long size = ttm->num_pages * sizeof(*ttm->pages);
-
-	if (ttm->page_flags & DRM_TTM_PAGEDIR_VMALLOC) {
-		vfree(ttm->pages);
-		ttm->page_flags &= ~DRM_TTM_PAGEDIR_VMALLOC;
-	} else {
-		drm_free(ttm->pages, size, DRM_MEM_TTM);
-	}
-	drm_free_memctl(size);
-	ttm->pages = NULL;
-}
-
-static struct page *drm_ttm_alloc_page(void)
-{
-	struct page *page;
-
-	if (drm_alloc_memctl(PAGE_SIZE))
-		return NULL;
-
-	page = alloc_page(GFP_KERNEL | __GFP_ZERO | GFP_DMA32);
-	if (!page) {
-		drm_free_memctl(PAGE_SIZE);
-		return NULL;
-	}
-	return page;
-}
-
-/*
- * Change caching policy for the linear kernel map
- * for range of pages in a ttm.
- */
-
-static int drm_ttm_set_caching(struct drm_ttm *ttm, int noncached)
-{
-	int i;
-	struct page **cur_page;
-	int do_tlbflush = 0;
-
-	if ((ttm->page_flags & DRM_TTM_PAGE_UNCACHED) == noncached)
-		return 0;
-
-	if (noncached)
-		drm_ttm_cache_flush(ttm->pages, ttm->num_pages);
-
-	for (i = 0; i < ttm->num_pages; ++i) {
-		cur_page = ttm->pages + i;
-		if (*cur_page) {
-			if (!PageHighMem(*cur_page)) {
-				if (noncached) {
-					map_page_into_agp(*cur_page);
-				} else {
-					unmap_page_from_agp(*cur_page);
-				}
-				do_tlbflush = 1;
-			}
-		}
-	}
-	if (do_tlbflush)
-		flush_agp_mappings();
-
-	DRM_FLAG_MASKED(ttm->page_flags, noncached, DRM_TTM_PAGE_UNCACHED);
-
-	return 0;
-}
-
-
-static void drm_ttm_free_user_pages(struct drm_ttm *ttm)
-{
-	int write;
-	int dirty;
-	struct page *page;
-	int i;
-
-	BUG_ON(!(ttm->page_flags & DRM_TTM_PAGE_USER));
-	write = ((ttm->page_flags & DRM_TTM_PAGE_WRITE) != 0);
-	dirty = ((ttm->page_flags & DRM_TTM_PAGE_USER_DIRTY) != 0);
-
-	for (i = 0; i < ttm->num_pages; ++i) {
-		page = ttm->pages[i];
-		if (page == NULL)
-			continue;
-
-		if (page == ttm->dummy_read_page) {
-			BUG_ON(write);
-			continue;
-		}
-
-		if (write && dirty && !PageReserved(page))
-			set_page_dirty_lock(page);
-
-		ttm->pages[i] = NULL;
-		put_page(page);
-	}
-}
-
-static void drm_ttm_free_alloced_pages(struct drm_ttm *ttm)
-{
-	int i;
-	struct drm_buffer_manager *bm = &ttm->dev->bm;
-	struct page **cur_page;
-
-	for (i = 0; i < ttm->num_pages; ++i) {
-		cur_page = ttm->pages + i;
-		if (*cur_page) {
-			if (page_count(*cur_page) != 1)
-				DRM_ERROR("Erroneous page count. Leaking pages.\n");
-			if (page_mapped(*cur_page))
-				DRM_ERROR("Erroneous map count. Leaking page mappings.\n");
-			__free_page(*cur_page);
-			drm_free_memctl(PAGE_SIZE);
-			--bm->cur_pages;
-		}
-	}
-}
-
-/*
- * Free all resources associated with a ttm.
- */
-
-int drm_ttm_destroy(struct drm_ttm *ttm)
-{
-	struct drm_ttm_backend *be;
-
-	if (!ttm)
-		return 0;
-
-	be = ttm->be;
-	if (be) {
-		be->func->destroy(be);
-		ttm->be = NULL;
-	}
-
-	if (ttm->pages) {
-		if (ttm->page_flags & DRM_TTM_PAGE_UNCACHED)
-			drm_ttm_set_caching(ttm, 0);
-
-		if (ttm->page_flags & DRM_TTM_PAGE_USER)
-			drm_ttm_free_user_pages(ttm);
-		else
-			drm_ttm_free_alloced_pages(ttm);
-
-		drm_ttm_free_page_directory(ttm);
-	}
-
-	drm_ctl_free(ttm, sizeof(*ttm), DRM_MEM_TTM);
-	return 0;
-}
-
-struct page *drm_ttm_get_page(struct drm_ttm *ttm, int index)
-{
-	struct page *p;
-	struct drm_buffer_manager *bm = &ttm->dev->bm;
-
-	while(NULL == (p = ttm->pages[index])) {
-		p = drm_ttm_alloc_page();
-		if (!p)
-			return NULL;
-
-		if (PageHighMem(p))
-			ttm->pages[--ttm->first_himem_page] = p;
-		else
-			ttm->pages[++ttm->last_lomem_page] = p;
-
-		++bm->cur_pages;
-	}
-	return p;
-}
-EXPORT_SYMBOL(drm_ttm_get_page);
-
-/**
- * drm_ttm_set_user:
- *
- * @ttm: the ttm to map pages to. This must always be
- * a freshly created ttm.
- *
- * @tsk: a pointer to the address space from which to map
- * pages.
- * 
- * @write: a boolean indicating that write access is desired
- *
- * start: the starting address
- *
- * Map a range of user addresses to a new ttm object. This
- * provides access to user memory from the graphics device.
- */
-int drm_ttm_set_user(struct drm_ttm *ttm,
-		     struct task_struct *tsk,
-		     unsigned long start,
-		     unsigned long num_pages)
-{
-	struct mm_struct *mm = tsk->mm;
-	int ret;
-	int write = (ttm->page_flags & DRM_TTM_PAGE_WRITE) != 0;
-
-	BUG_ON(num_pages != ttm->num_pages);
-	BUG_ON((ttm->page_flags & DRM_TTM_PAGE_USER) == 0);
-
-	down_read(&mm->mmap_sem);
-	ret = get_user_pages(tsk, mm, start, num_pages,
-			     write, 0, ttm->pages, NULL);
-	up_read(&mm->mmap_sem);
-
-	if (ret != num_pages && write) {
-		drm_ttm_free_user_pages(ttm);
-		return -ENOMEM;
-	}
-
-	return 0;
-}
-
-/**
- * drm_ttm_populate:
- *
- * @ttm: the object to allocate pages for
- *
- * Allocate pages for all unset page entries, then
- * call the backend to create the hardware mappings
- */
-int drm_ttm_populate(struct drm_ttm *ttm)
-{
-	struct page *page;
-	unsigned long i;
-	struct drm_ttm_backend *be;
-
-	if (ttm->state != ttm_unpopulated)
-		return 0;
-
-	be = ttm->be;
-
-	for (i = 0; i < ttm->num_pages; ++i) {
-		page = drm_ttm_get_page(ttm, i);
-		if (!page)
-			return -ENOMEM;
-	}
-
-	be->func->populate(be, ttm->num_pages, ttm->pages, ttm->dummy_read_page);
-	ttm->state = ttm_unbound;
-	return 0;
-}
-
-/**
- * drm_ttm_create:
- *
- * @dev: the drm_device
- *
- * @size: The size (in bytes) of the desired object
- *
- * @page_flags: various DRM_TTM_PAGE_* flags. See drm_object.h.
- *
- * Allocate and initialize a ttm, leaving it unpopulated at this time
- */
-
-struct drm_ttm *drm_ttm_create(struct drm_device *dev, unsigned long size,
-			       uint32_t page_flags, struct page *dummy_read_page)
-{
-	struct drm_bo_driver *bo_driver = dev->driver->bo_driver;
-	struct drm_ttm *ttm;
-
-	if (!bo_driver)
-		return NULL;
-
-	ttm = drm_ctl_calloc(1, sizeof(*ttm), DRM_MEM_TTM);
-	if (!ttm)
-		return NULL;
-
-	ttm->dev = dev;
-	atomic_set(&ttm->vma_count, 0);
-
-	ttm->destroy = 0;
-	ttm->num_pages = (size + PAGE_SIZE - 1) >> PAGE_SHIFT;
-	ttm->first_himem_page = ttm->num_pages;
-	ttm->last_lomem_page = -1;
-
-	ttm->page_flags = page_flags;
-
-	ttm->dummy_read_page = dummy_read_page;
-
-	/*
-	 * Account also for AGP module memory usage.
-	 */
-
-	drm_ttm_alloc_page_directory(ttm);
-	if (!ttm->pages) {
-		drm_ttm_destroy(ttm);
-		DRM_ERROR("Failed allocating page table\n");
-		return NULL;
-	}
-	ttm->be = bo_driver->create_ttm_backend_entry(dev);
-	if (!ttm->be) {
-		drm_ttm_destroy(ttm);
-		DRM_ERROR("Failed creating ttm backend entry\n");
-		return NULL;
-	}
-	ttm->state = ttm_unpopulated;
-	return ttm;
-}
-
-/**
- * drm_ttm_evict:
- *
- * @ttm: the object to be unbound from the aperture.
- *
- * Transition a ttm from bound to evicted, where it
- * isn't present in the aperture, but various caches may
- * not be consistent.
- */
-void drm_ttm_evict(struct drm_ttm *ttm)
-{
-	struct drm_ttm_backend *be = ttm->be;
-	int ret;
-
-	if (ttm->state == ttm_bound) {
-		ret = be->func->unbind(be);
-		BUG_ON(ret);
-	}
-
-	ttm->state = ttm_evicted;
-}
-
-/**
- * drm_ttm_fixup_caching:
- *
- * @ttm: the object to set unbound
- *
- * XXX this function is misnamed. Transition a ttm from evicted to
- * unbound, flushing caches as appropriate.
- */
-void drm_ttm_fixup_caching(struct drm_ttm *ttm)
-{
-
-	if (ttm->state == ttm_evicted) {
-		struct drm_ttm_backend *be = ttm->be;
-		if (be->func->needs_ub_cache_adjust(be))
-			drm_ttm_set_caching(ttm, 0);
-		ttm->state = ttm_unbound;
-	}
-}
-
-/**
- * drm_ttm_unbind:
- *
- * @ttm: the object to unbind from the graphics device
- *
- * Unbind an object from the aperture. This removes the mappings
- * from the graphics device and flushes caches if necessary.
- */
-void drm_ttm_unbind(struct drm_ttm *ttm)
-{
-	if (ttm->state == ttm_bound)
-		drm_ttm_evict(ttm);
-
-	drm_ttm_fixup_caching(ttm);
-}
-
-/**
- * drm_ttm_bind:
- *
- * @ttm: the ttm object to bind to the graphics device
- *
- * @bo_mem: the aperture memory region which will hold the object
- *
- * Bind a ttm object to the aperture. This ensures that the necessary
- * pages are allocated, flushes CPU caches as needed and marks the
- * ttm as DRM_TTM_PAGE_USER_DIRTY to indicate that it may have been
- * modified by the GPU
- */
-int drm_ttm_bind(struct drm_ttm *ttm, struct drm_bo_mem_reg *bo_mem)
-{
-	struct drm_bo_driver *bo_driver = ttm->dev->driver->bo_driver;
-	int ret = 0;
-	struct drm_ttm_backend *be;
-
-	if (!ttm)
-		return -EINVAL;
-	if (ttm->state == ttm_bound)
-		return 0;
-
-	be = ttm->be;
-
-	ret = drm_ttm_populate(ttm);
-	if (ret)
-		return ret;
-
-	if (ttm->state == ttm_unbound && !(bo_mem->flags & DRM_BO_FLAG_CACHED))
-		drm_ttm_set_caching(ttm, DRM_TTM_PAGE_UNCACHED);
-	else if ((bo_mem->flags & DRM_BO_FLAG_CACHED_MAPPED) &&
-		   bo_driver->ttm_cache_flush)
-		bo_driver->ttm_cache_flush(ttm);
-
-	ret = be->func->bind(be, bo_mem);
-	if (ret) {
-		ttm->state = ttm_evicted;
-		DRM_ERROR("Couldn't bind backend.\n");
-		return ret;
-	}
-
-	ttm->state = ttm_bound;
-	if (ttm->page_flags & DRM_TTM_PAGE_USER)
-		ttm->page_flags |= DRM_TTM_PAGE_USER_DIRTY;
-	return 0;
-}
-EXPORT_SYMBOL(drm_ttm_bind);
diff --git a/linux-core/drm_vm.c b/linux-core/drm_vm.c
index b99c86d1..c6cee1a1 100644
--- a/linux-core/drm_vm.c
+++ b/linux-core/drm_vm.c
@@ -41,10 +41,6 @@
 
 static void drm_vm_open(struct vm_area_struct *vma);
 static void drm_vm_close(struct vm_area_struct *vma);
-static int drm_bo_mmap_locked(struct vm_area_struct *vma,
-			      struct file *filp,
-			      drm_local_map_t *map);
-
 
 pgprot_t drm_io_prot(uint32_t map_type, struct vm_area_struct *vma)
 {
@@ -651,8 +647,6 @@ static int drm_mmap_locked(struct file *filp, struct vm_area_struct *vma)
 		vma->vm_flags |= VM_RESERVED;
 		vma->vm_page_prot = drm_dma_prot(map->type, vma);
 		break;
-	case _DRM_TTM:
-		return drm_bo_mmap_locked(vma, filp, map);
 	default:
 		return -EINVAL;	/* This should never happen. */
 	}
@@ -676,195 +670,3 @@ int drm_mmap(struct file *filp, struct vm_area_struct *vma)
 	return ret;
 }
 EXPORT_SYMBOL(drm_mmap);
-
-/**
- * buffer object vm functions.
- */
-
-/**
- * \c Pagefault method for buffer objects.
- *
- * \param vma Virtual memory area.
- * \param vmf vm fault data
- * \return Error or VM_FAULT_NOPAGE:. The pfn is manually inserted.
- *
- * It's important that pfns are inserted while holding the bo->mutex lock.
- * otherwise we might race with unmap_mapping_range() which is always
- * called with the bo->mutex lock held.
- *
- * We're modifying the page attribute bits of the vma->vm_page_prot field,
- * without holding the mmap_sem in write mode. Only in read mode.
- * These bits are not used by the mm subsystem code, and we consider them
- * protected by the bo->mutex lock.
- */
-
-#if !defined(DRM_NO_FAULT)
-static int drm_bo_vm_fault(struct vm_area_struct *vma,
-				     struct vm_fault *vmf)
-{
-	struct drm_buffer_object *bo = (struct drm_buffer_object *) vma->vm_private_data;
-	unsigned long page_offset;
-	struct page *page = NULL;
-	struct drm_ttm *ttm;
-	struct drm_device *dev;
-	unsigned long pfn;
-	int err;
-	unsigned long bus_base;
-	unsigned long bus_offset;
-	unsigned long bus_size;
-	unsigned long ret = VM_FAULT_NOPAGE;
-
-	dev = bo->dev;
-	err = drm_bo_read_lock(&dev->bm.bm_lock, 1);
-	if (err)
-		return VM_FAULT_NOPAGE;
-
-	err = mutex_lock_interruptible(&bo->mutex);
-	if (err) {
-		drm_bo_read_unlock(&dev->bm.bm_lock);
-		return VM_FAULT_NOPAGE;
-	}
-
-	err = drm_bo_wait(bo, 0, 1, 0, 1);
-	if (err) {
-		ret = (err != -EAGAIN) ? VM_FAULT_SIGBUS : VM_FAULT_NOPAGE;
-		bo->priv_flags &= ~_DRM_BO_FLAG_UNLOCKED;
-		goto out_unlock;
-	}
-
-	bo->priv_flags &= ~_DRM_BO_FLAG_UNLOCKED;
-
-	/*
-	 * If buffer happens to be in a non-mappable location,
-	 * move it to a mappable.
-	 */
-
-	if (!(bo->mem.flags & DRM_BO_FLAG_MAPPABLE)) {
-		uint32_t new_flags = bo->mem.proposed_flags |
-			DRM_BO_FLAG_MAPPABLE |
-			DRM_BO_FLAG_FORCE_MAPPABLE;
-		err = drm_bo_move_buffer(bo, new_flags, 0, 0);
-		if (err) {
-			ret = (err != -EAGAIN) ? VM_FAULT_SIGBUS : VM_FAULT_NOPAGE;
-			goto out_unlock;
-		}
-	}
-
-	err = drm_bo_pci_offset(dev, &bo->mem, &bus_base, &bus_offset,
-				&bus_size);
-
-	if (err) {
-		ret = VM_FAULT_SIGBUS;
-		goto out_unlock;
-	}
-
-	page_offset = ((unsigned long)vmf->virtual_address - vma->vm_start) >> PAGE_SHIFT;
-
-	if (bus_size) {
-		struct drm_mem_type_manager *man = &dev->bm.man[bo->mem.mem_type];
-
-		pfn = ((bus_base + bus_offset) >> PAGE_SHIFT) + page_offset;
-		vma->vm_page_prot = drm_io_prot(man->drm_bus_maptype, vma);
-	} else {
-		ttm = bo->ttm;
-
-		drm_ttm_fixup_caching(ttm);
-		page = drm_ttm_get_page(ttm, page_offset);
-		if (!page) {
-			ret = VM_FAULT_OOM;
-			goto out_unlock;
-		}
-		pfn = page_to_pfn(page);
-		vma->vm_page_prot = (bo->mem.flags & DRM_BO_FLAG_CACHED) ?
-			vm_get_page_prot(vma->vm_flags) :
-			drm_io_prot(_DRM_TTM, vma);
-	}
-
-	err = vm_insert_pfn(vma, (unsigned long)vmf->virtual_address, pfn);
-	if (err) {
-		ret = (err != -EAGAIN) ? VM_FAULT_OOM : VM_FAULT_NOPAGE;
-		goto out_unlock;
-	}
-out_unlock:
-	BUG_ON(bo->priv_flags & _DRM_BO_FLAG_UNLOCKED);
-	mutex_unlock(&bo->mutex);
-	drm_bo_read_unlock(&dev->bm.bm_lock);
-	return ret;
-}
-#endif
-
-static void drm_bo_vm_open_locked(struct vm_area_struct *vma)
-{
-	struct drm_buffer_object *bo = (struct drm_buffer_object *) vma->vm_private_data;
-
-	drm_vm_open_locked(vma);
-	atomic_inc(&bo->usage);
-}
-
-/**
- * \c vma open method for buffer objects.
- *
- * \param vma virtual memory area.
- */
-
-static void drm_bo_vm_open(struct vm_area_struct *vma)
-{
-	struct drm_buffer_object *bo = (struct drm_buffer_object *) vma->vm_private_data;
-	struct drm_device *dev = bo->dev;
-
-	mutex_lock(&dev->struct_mutex);
-	drm_bo_vm_open_locked(vma);
-	mutex_unlock(&dev->struct_mutex);
-}
-
-/**
- * \c vma close method for buffer objects.
- *
- * \param vma virtual memory area.
- */
-
-static void drm_bo_vm_close(struct vm_area_struct *vma)
-{
-	struct drm_buffer_object *bo = (struct drm_buffer_object *) vma->vm_private_data;
-	struct drm_device *dev = bo->dev;
-
-	drm_vm_close(vma);
-	if (bo) {
-		mutex_lock(&dev->struct_mutex);
-		drm_bo_usage_deref_locked((struct drm_buffer_object **)
-					  &vma->vm_private_data);
-		mutex_unlock(&dev->struct_mutex);
-	}
-	return;
-}
-
-static struct vm_operations_struct drm_bo_vm_ops = {
-#ifdef DRM_NO_FAULT
-	.nopfn = drm_bo_vm_nopfn,
-#else
-	.fault = drm_bo_vm_fault,
-#endif
-	.open = drm_bo_vm_open,
-	.close = drm_bo_vm_close,
-};
-
-/**
- * mmap buffer object memory.
- *
- * \param vma virtual memory area.
- * \param file_priv DRM file private.
- * \param map The buffer object drm map.
- * \return zero on success or a negative number on failure.
- */
-static int drm_bo_mmap_locked(struct vm_area_struct *vma,
-		       struct file *filp,
-		       drm_local_map_t *map)
-{
-	vma->vm_ops = &drm_bo_vm_ops;
-	vma->vm_private_data = map->handle;
-	vma->vm_file = filp;
-	vma->vm_flags |= VM_RESERVED | VM_IO;
-	vma->vm_flags |= VM_PFNMAP;
-	drm_bo_vm_open_locked(vma);
-	return 0;
-}
diff --git a/linux-core/via_buffer.c b/linux-core/via_buffer.c
deleted file mode 100644
index 532fae6a..00000000
--- a/linux-core/via_buffer.c
+++ /dev/null
@@ -1,163 +0,0 @@
-/**************************************************************************
- *
- * Copyright (c) 2007 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 Hellström <thomas-at-tungstengraphics-dot-com>
- */
-
-#include "drmP.h"
-#include "via_drm.h"
-#include "via_drv.h"
-
-struct drm_ttm_backend *via_create_ttm_backend_entry(struct drm_device * dev)
-{
-	return drm_agp_init_ttm(dev);
-}
-
-int via_fence_types(struct drm_buffer_object *bo, uint32_t * fclass,
-		    uint32_t * type)
-{
-	*type = 3;
-	return 0;
-}
-
-int via_invalidate_caches(struct drm_device * dev, uint64_t flags)
-{
-	/*
-	 * FIXME: Invalidate texture caches here.
-	 */
-
-	return 0;
-}
-
-
-static int via_vram_info(struct drm_device *dev,
-			 unsigned long *offset,
-			 unsigned long *size)
-{
-	struct pci_dev *pdev = dev->pdev;
-	unsigned long flags;
-
-	int ret = -EINVAL;
-	int i;
-	for (i=0; i<6; ++i) {
-		flags = pci_resource_flags(pdev, i);
-		if ((flags & (IORESOURCE_MEM | IORESOURCE_PREFETCH)) ==
-		    (IORESOURCE_MEM | IORESOURCE_PREFETCH)) {
-			ret = 0;
-			break;
-		}
-	}
-
-	if (ret) {
-		DRM_ERROR("Could not find VRAM PCI resource\n");
-		return ret;
-	}
-
-	*offset = pci_resource_start(pdev, i);
-	*size = pci_resource_end(pdev, i) - *offset + 1;
-	return 0;
-}
-
-int via_init_mem_type(struct drm_device * dev, uint32_t type,
-		       struct drm_mem_type_manager * man)
-{
-	switch (type) {
-	case DRM_BO_MEM_LOCAL:
-		/* System memory */
-
-		man->flags = _DRM_FLAG_MEMTYPE_MAPPABLE |
-			_DRM_FLAG_MEMTYPE_CACHED;
-		man->drm_bus_maptype = 0;
-		break;
-
-	case DRM_BO_MEM_TT:
-		/* Dynamic agpgart memory */
-
-		if (!(drm_core_has_AGP(dev) && dev->agp)) {
-			DRM_ERROR("AGP is not enabled for memory type %u\n",
-				  (unsigned)type);
-			return -EINVAL;
-		}
-		man->io_offset = dev->agp->agp_info.aper_base;
-		man->io_size = dev->agp->agp_info.aper_size * 1024 * 1024;
-		man->io_addr = NULL;
-		man->flags = _DRM_FLAG_MEMTYPE_MAPPABLE | _DRM_FLAG_NEEDS_IOREMAP;
-
-		/* Only to get pte protection right. */
-
-		man->drm_bus_maptype = _DRM_AGP;
-		break;
-
-	case DRM_BO_MEM_VRAM:
-		/* "On-card" video ram */
-
-		man->flags = _DRM_FLAG_MEMTYPE_MAPPABLE | _DRM_FLAG_NEEDS_IOREMAP;
-		man->drm_bus_maptype = _DRM_FRAME_BUFFER;
-		man->io_addr = NULL;
-		return via_vram_info(dev, &man->io_offset, &man->io_size);
-		break;
-
-	case DRM_BO_MEM_PRIV0:
-		/* Pre-bound agpgart memory */
-
-		if (!(drm_core_has_AGP(dev) && dev->agp)) {
-			DRM_ERROR("AGP is not enabled for memory type %u\n",
-				  (unsigned)type);
-			return -EINVAL;
-		}
-		man->io_offset = dev->agp->agp_info.aper_base;
-		man->io_size = dev->agp->agp_info.aper_size * 1024 * 1024;
-		man->io_addr = NULL;
-		man->flags =  _DRM_FLAG_MEMTYPE_MAPPABLE |
-		    _DRM_FLAG_MEMTYPE_FIXED | _DRM_FLAG_NEEDS_IOREMAP;
-		man->drm_bus_maptype = _DRM_AGP;
-		break;
-
-	default:
-		DRM_ERROR("Unsupported memory type %u\n", (unsigned)type);
-		return -EINVAL;
-	}
-	return 0;
-}
-
-uint64_t via_evict_flags(struct drm_buffer_object *bo)
-{
-	switch (bo->mem.mem_type) {
-	case DRM_BO_MEM_LOCAL:
-	case DRM_BO_MEM_TT:
-		return DRM_BO_FLAG_MEM_LOCAL; /* Evict TT to local */
-	case DRM_BO_MEM_PRIV0: /* Evict pre-bound AGP to TT */
-		return DRM_BO_MEM_TT;
-	case DRM_BO_MEM_VRAM:
-		if (bo->mem.num_pages > 128)
-			return DRM_BO_MEM_TT;
-		else
-			return DRM_BO_MEM_LOCAL;
-	default:
-		return DRM_BO_MEM_LOCAL;
-	}
-}
diff --git a/linux-core/via_fence.c b/linux-core/via_fence.c
deleted file mode 100644
index 3a680a32..00000000
--- a/linux-core/via_fence.c
+++ /dev/null
@@ -1,169 +0,0 @@
-/**************************************************************************
- *
- * Copyright (c) 2007 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 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.
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- *
- **************************************************************************/
-/*
- * Authors: Thomas Hellström <thomas-at-tungstengraphics-dot-com>
- */
-
-#include "drmP.h"
-#include "via_drm.h"
-#include "via_drv.h"
-
-/*
- * DRM_FENCE_TYPE_EXE guarantees that all command buffers can be evicted.
- * DRM_VIA_FENCE_TYPE_ACCEL guarantees that all 2D & 3D rendering is complete.
- */
-
-static void via_fence_poll(struct drm_device *dev, uint32_t class,
-			   uint32_t waiting_types)
-{
-	drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
-	uint32_t signaled_flush_types = 0;
-	uint32_t status;
-
-	if (class != 0)
-		return;
-
-	if (unlikely(!dev_priv))
-		return;
-
-	spin_lock(&dev_priv->fence_lock);
-	if (waiting_types) {
-
-		/*
-		 * Take the idlelock. This guarantees that the next time a client tries
-		 * to grab the lock, it will stall until the idlelock is released. This
-		 * guarantees that eventually, the GPU engines will be idle, but nothing
-		 * else. It cannot be used to protect the hardware.
-		 */
-
-
-		if (!dev_priv->have_idlelock) {
-			drm_idlelock_take(&dev->lock);
-			dev_priv->have_idlelock = 1;
-		}
-
-		/*
-		 * Check if AGP command reader is idle.
-		 */
-
-		if (waiting_types & DRM_FENCE_TYPE_EXE)
-			if (VIA_READ(0x41C) & 0x80000000)
-				signaled_flush_types |= DRM_FENCE_TYPE_EXE;
-
-		/*
-		 * Check VRAM command queue empty and 2D + 3D engines idle.
-		 */
-
-		if (waiting_types & DRM_VIA_FENCE_TYPE_ACCEL) {
-			status = VIA_READ(VIA_REG_STATUS);
-			if ((status & VIA_VR_QUEUE_BUSY) &&
-			    !(status & (VIA_CMD_RGTR_BUSY | VIA_2D_ENG_BUSY | VIA_3D_ENG_BUSY)))
-				signaled_flush_types |= DRM_VIA_FENCE_TYPE_ACCEL;
-		}
-
-		if (signaled_flush_types) {
-			waiting_types &= ~signaled_flush_types;
-			if (!waiting_types && dev_priv->have_idlelock) {
-				drm_idlelock_release(&dev->lock);
-				dev_priv->have_idlelock = 0;
-			}
-			drm_fence_handler(dev, 0, dev_priv->emit_0_sequence,
-					  signaled_flush_types, 0);
-		}
-	}
-
-	spin_unlock(&dev_priv->fence_lock);
-
-	return;
-}
-
-
-/**
- * Emit a fence sequence.
- */
-
-static int via_fence_emit_sequence(struct drm_device * dev, uint32_t class, uint32_t flags,
-				   uint32_t * sequence, uint32_t * native_type)
-{
-	drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
-	int ret = 0;
-
-	if (!dev_priv)
-		return -EINVAL;
-
-	switch(class) {
-	case 0: /* AGP command stream */
-
-		/*
-		 * The sequence number isn't really used by the hardware yet.
-		 */
-
-		spin_lock(&dev_priv->fence_lock);
-		*sequence = ++dev_priv->emit_0_sequence;
-		spin_unlock(&dev_priv->fence_lock);
-
-		/*
-		 * When drm_fence_handler() is called with flush type 0x01, and a
-		 * sequence number, That means that the EXE flag is expired.
-		 * Nothing else. No implicit flushing or other engines idle.
-		 */
-
-		*native_type = DRM_FENCE_TYPE_EXE;
-		break;
-	default:
-		ret = -EINVAL;
-		break;
-	}
-	return ret;
-}
-
-/**
- * No irq fence expirations implemented yet.
- * Although both the HQV engines and PCI dmablit engines signal
- * idle with an IRQ, we haven't implemented this yet.
- * This means that the drm fence manager will always poll for engine idle,
- * unless the caller wanting to wait for a fence object has indicated a lazy wait.
- */
-
-static int via_fence_has_irq(struct drm_device * dev, uint32_t class,
-			     uint32_t flags)
-{
-	return 0;
-}
-
-struct drm_fence_driver via_fence_driver = {
-	.num_classes = 1,
-	.wrap_diff = (1 << 30),
-	.flush_diff = (1 << 20),
-	.sequence_mask = 0xffffffffU,
-	.has_irq = via_fence_has_irq,
-	.emit = via_fence_emit_sequence,
-	.poll = via_fence_poll,
-	.needed_flush = NULL,
-	.wait = NULL
-};
diff --git a/linux-core/xgi_cmdlist.c b/linux-core/xgi_cmdlist.c
index 423208b0..dea9b518 100644
--- a/linux-core/xgi_cmdlist.c
+++ b/linux-core/xgi_cmdlist.c
@@ -148,9 +148,6 @@ int xgi_submit_cmdlist(struct drm_device * dev, void * data,
 	}
 
 	info->cmdring.last_ptr = xgi_find_pcie_virt(info, pCmdInfo->hw_addr);
-#ifdef XGI_HAVE_FENCE
-	drm_fence_flush_old(info->dev, 0, info->next_sequence);
-#endif /* XGI_HAVE_FENCE */
 	return 0;
 }
 
diff --git a/linux-core/xgi_drv.c b/linux-core/xgi_drv.c
index 51ace0ff..4d55f219 100644
--- a/linux-core/xgi_drv.c
+++ b/linux-core/xgi_drv.c
@@ -37,10 +37,6 @@ static struct pci_device_id pciidlist[] = {
 	xgi_PCI_IDS
 };
 
-#ifdef XGI_HAVE_FENCE
-extern struct drm_fence_driver xgi_fence_driver;
-#endif /* XGI_HAVE_FENCE */
-
 int xgi_bootstrap(struct drm_device *, void *, struct drm_file *);
 
 static struct drm_ioctl_desc xgi_ioctls[] = {
@@ -105,10 +101,6 @@ static struct drm_driver driver = {
 		.remove = __devexit_p(drm_cleanup_pci),
 	},
 
-#ifdef XGI_HAVE_FENCE
-	.fence_driver = &xgi_fence_driver,
-#endif /* XGI_HAVE_FENCE */
-
 	.name = DRIVER_NAME,
 	.desc = DRIVER_DESC,
 	.date = DRIVER_DATE,
@@ -362,9 +354,6 @@ irqreturn_t xgi_kern_isr(DRM_IRQ_ARGS)
 		DRM_WRITE32(info->mmio_map,
 			    0x2800 + M2REG_AUTO_LINK_SETTING_ADDRESS,
 			    cpu_to_le32(M2REG_AUTO_LINK_SETTING_COMMAND | irq_bits));
-#ifdef XGI_HAVE_FENCE
-		xgi_fence_handler(dev);
-#endif /* XGI_HAVE_FENCE */
 		DRM_WAKEUP(&info->fence_queue);
 		return IRQ_HANDLED;
 	} else {
diff --git a/linux-core/xgi_drv.h b/linux-core/xgi_drv.h
index 5ad3ddb3..a3ca7fb4 100644
--- a/linux-core/xgi_drv.h
+++ b/linux-core/xgi_drv.h
@@ -99,18 +99,6 @@ extern void xgi_disable_mmio(struct xgi_info * info);
 extern void xgi_enable_ge(struct xgi_info * info);
 extern void xgi_disable_ge(struct xgi_info * info);
 
-/* TTM-style fences.
- */
-#ifdef XGI_HAVE_FENCE
-extern void xgi_poke_flush(struct drm_device * dev, uint32_t class);
-extern int xgi_fence_emit_sequence(struct drm_device * dev, uint32_t class,
-	uint32_t flags, uint32_t * sequence, uint32_t * native_type);
-extern void xgi_fence_handler(struct drm_device * dev);
-extern int xgi_fence_has_irq(struct drm_device *dev, uint32_t class,
-	uint32_t flags);
-#endif /* XGI_HAVE_FENCE */
-
-
 /* Non-TTM-style fences.
  */
 extern int xgi_set_fence_ioctl(struct drm_device * dev, void * data,
diff --git a/linux-core/xgi_fence.c b/linux-core/xgi_fence.c
index 38cf9e4f..7553177c 100644
--- a/linux-core/xgi_fence.c
+++ b/linux-core/xgi_fence.c
@@ -97,90 +97,3 @@ int xgi_wait_fence_ioctl(struct drm_device * dev, void * data,
 	(void) filp;
 	return xgi_low_level_fence_wait(dev, (u32 *) data);
 }
-
-
-#ifdef XGI_HAVE_FENCE
-static void xgi_fence_poll(struct drm_device * dev, uint32_t class, 
-			   uint32_t waiting_types)
-{
-	struct xgi_info * info = dev->dev_private;
-	uint32_t signaled_types = 0;
-
-
-	if ((info == NULL) || (class != 0))
-		return;
-
-	DRM_SPINLOCK(&info->fence_lock);
-
-	if (waiting_types) {
-		if (waiting_types & DRM_FENCE_TYPE_EXE) {
-			const u32 begin_id = le32_to_cpu(DRM_READ32(info->mmio_map,
-							0x2820))
-				& BEGIN_BEGIN_IDENTIFICATION_MASK;
-
-			if (begin_id != info->complete_sequence) {
-				info->complete_sequence = begin_id;
-				signaled_types |= DRM_FENCE_TYPE_EXE;
-			}
-		}
-
-		if (signaled_types) {
-			drm_fence_handler(dev, 0, info->complete_sequence,
-					  signaled_types, 0);
-		}
-	}
-
-	DRM_SPINUNLOCK(&info->fence_lock);
-}
-
-
-int xgi_fence_emit_sequence(struct drm_device * dev, uint32_t class,
-			    uint32_t flags, uint32_t * sequence,
-			    uint32_t * native_type)
-{
-	int err;
-
-	(void) flags;
-
-	if (class != 0)
-		return -EINVAL;
-
-	err = xgi_low_level_fence_emit(dev, sequence);
-	if (err)
-		return err;
-
-	*native_type = DRM_FENCE_TYPE_EXE;
-	return 0;
-}
-
-
-void xgi_fence_handler(struct drm_device * dev)
-{
-	struct drm_fence_manager * fm = &dev->fm;
-	struct drm_fence_class_manager *fc = &fm->fence_class[0];
-
-	write_lock(&fm->lock);
-	xgi_fence_poll(dev, 0, fc->waiting_types);
-	write_unlock(&fm->lock);
-}
-
-
-int xgi_fence_has_irq(struct drm_device *dev, uint32_t class, uint32_t flags)
-{
-	return ((class == 0) && (flags == DRM_FENCE_TYPE_EXE)) ? 1 : 0;
-}
-
-struct drm_fence_driver xgi_fence_driver = {
-	.num_classes = 1,
-	.wrap_diff = BEGIN_BEGIN_IDENTIFICATION_MASK,
-	.flush_diff = BEGIN_BEGIN_IDENTIFICATION_MASK - 1,
-	.sequence_mask = BEGIN_BEGIN_IDENTIFICATION_MASK,
-	.has_irq = xgi_fence_has_irq,
-	.emit = xgi_fence_emit_sequence,
-	.flush = NULL,
-	.poll = xgi_fence_poll,
-	.needed_flush = NULL,
-	.wait = NULL
-};
-
-#endif /* XGI_HAVE_FENCE */