Merge branch 'master' into modesetting-101 - TTM & typedef removal

Conflicts:

	linux-core/drmP.h
	linux-core/drm_bo.c
	linux-core/drm_drv.c
	linux-core/drm_objects.h
	shared-core/drm.h
	shared-core/i915_dma.c
	shared-core/i915_drv.h
	shared-core/i915_irq.c

Mostly removing typedefs that snuck into the modesetting code and
updating to the latest TTM APIs.  As of today, the i915 driver builds,
but there are likely to be problems, so debugging and bugfixes will
come next.

1 files changed, 754 insertions, 409 deletions

diff --git a/linux-core/drm_bo.c b/linux-core/drm_bo.c
index fd097968..89062f11 100644
--- a/linux-core/drm_bo.c
+++ b/linux-core/drm_bo.c
@@ -49,10 +49,10 @@
  *
  */
 
-static void drm_bo_destroy_locked(drm_buffer_object_t * bo);
-static int drm_bo_setup_vm_locked(drm_buffer_object_t * bo);
-static void drm_bo_takedown_vm_locked(drm_buffer_object_t * bo);
-static void drm_bo_unmap_virtual(drm_buffer_object_t * bo);
+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 uint32_t drm_bo_type_flags(unsigned type)
 {
@@ -63,9 +63,9 @@ static inline uint32_t drm_bo_type_flags(unsigned type)
  * bo locked. dev->struct_mutex locked.
  */
 
-void drm_bo_add_to_pinned_lru(drm_buffer_object_t * bo)
+void drm_bo_add_to_pinned_lru(struct drm_buffer_object * bo)
 {
-	drm_mem_type_manager_t *man;
+	struct drm_mem_type_manager *man;
 
 	DRM_ASSERT_LOCKED(&bo->dev->struct_mutex);
 	DRM_ASSERT_LOCKED(&bo->mutex);
@@ -74,14 +74,13 @@ void drm_bo_add_to_pinned_lru(drm_buffer_object_t * bo)
 	list_add_tail(&bo->pinned_lru, &man->pinned);
 }
 
-void drm_bo_add_to_lru(drm_buffer_object_t * bo)
+void drm_bo_add_to_lru(struct drm_buffer_object * bo)
 {
-	drm_mem_type_manager_t *man;
+	struct drm_mem_type_manager *man;
 
 	DRM_ASSERT_LOCKED(&bo->dev->struct_mutex);
 
-	if (!(bo->mem.mask & (DRM_BO_FLAG_NO_MOVE | DRM_BO_FLAG_NO_EVICT))
-	    || bo->mem.mem_type != bo->pinned_mem_type) {
+	if (!bo->pinned || 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 {
@@ -89,7 +88,7 @@ void drm_bo_add_to_lru(drm_buffer_object_t * bo)
 	}
 }
 
-static int drm_bo_vm_pre_move(drm_buffer_object_t * bo, int old_is_pci)
+static int drm_bo_vm_pre_move(struct drm_buffer_object * bo, int old_is_pci)
 {
 #ifdef DRM_ODD_MM_COMPAT
 	int ret;
@@ -112,7 +111,7 @@ static int drm_bo_vm_pre_move(drm_buffer_object_t * bo, int old_is_pci)
 	return 0;
 }
 
-static void drm_bo_vm_post_move(drm_buffer_object_t * bo)
+static void drm_bo_vm_post_move(struct drm_buffer_object * bo)
 {
 #ifdef DRM_ODD_MM_COMPAT
 	int ret;
@@ -133,9 +132,9 @@ static void drm_bo_vm_post_move(drm_buffer_object_t * bo)
  * Call bo->mutex locked.
  */
 
-static int drm_bo_add_ttm(drm_buffer_object_t * bo)
+static int drm_bo_add_ttm(struct drm_buffer_object * bo)
 {
-	drm_device_t *dev = bo->dev;
+	struct drm_device *dev = bo->dev;
 	int ret = 0;
 	bo->ttm = NULL;
 
@@ -164,16 +163,16 @@ static int drm_bo_add_ttm(drm_buffer_object_t * bo)
 	return ret;
 }
 
-static int drm_bo_handle_move_mem(drm_buffer_object_t * bo,
-				  drm_bo_mem_reg_t * mem,
+static int drm_bo_handle_move_mem(struct drm_buffer_object * bo,
+				  struct drm_bo_mem_reg * mem,
 				  int evict, int no_wait)
 {
-	drm_device_t *dev = bo->dev;
-	drm_buffer_manager_t *bm = &dev->bm;
+	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);
-	drm_mem_type_manager_t *old_man = &bm->man[bo->mem.mem_type];
-	drm_mem_type_manager_t *new_man = &bm->man[mem->mem_type];
+	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)
@@ -201,9 +200,9 @@ static int drm_bo_handle_move_mem(drm_buffer_object_t * bo,
 
 	if ((bo->mem.mem_type == DRM_BO_MEM_LOCAL) && bo->ttm == NULL) {
 
-		drm_bo_mem_reg_t *old_mem = &bo->mem;
-		uint32_t save_flags = old_mem->flags;
-		uint32_t save_mask = old_mem->mask;
+		struct drm_bo_mem_reg *old_mem = &bo->mem;
+		uint64_t save_flags = old_mem->flags;
+		uint64_t save_mask = old_mem->mask;
 
 		*old_mem = *mem;
 		mem->mm_node = NULL;
@@ -266,7 +265,7 @@ static int drm_bo_handle_move_mem(drm_buffer_object_t * bo,
  * Wait until the buffer is idle.
  */
 
-int drm_bo_wait(drm_buffer_object_t * bo, int lazy, int ignore_signals,
+int drm_bo_wait(struct drm_buffer_object * bo, int lazy, int ignore_signals,
 		int no_wait)
 {
 	int ret;
@@ -292,10 +291,10 @@ int drm_bo_wait(drm_buffer_object_t * bo, int lazy, int ignore_signals,
 	return 0;
 }
 
-static int drm_bo_expire_fence(drm_buffer_object_t * bo, int allow_errors)
+static int drm_bo_expire_fence(struct drm_buffer_object * bo, int allow_errors)
 {
-	drm_device_t *dev = bo->dev;
-	drm_buffer_manager_t *bm = &dev->bm;
+	struct drm_device *dev = bo->dev;
+	struct drm_buffer_manager *bm = &dev->bm;
 
 	if (bo->fence) {
 		if (bm->nice_mode) {
@@ -327,10 +326,10 @@ static int drm_bo_expire_fence(drm_buffer_object_t * bo, int allow_errors)
  * fence object and removing from lru lists and memory managers.
  */
 
-static void drm_bo_cleanup_refs(drm_buffer_object_t * bo, int remove_all)
+static void drm_bo_cleanup_refs(struct drm_buffer_object * bo, int remove_all)
 {
-	drm_device_t *dev = bo->dev;
-	drm_buffer_manager_t *bm = &dev->bm;
+	struct drm_device *dev = bo->dev;
+	struct drm_buffer_manager *bm = &dev->bm;
 
 	DRM_ASSERT_LOCKED(&dev->struct_mutex);
 
@@ -389,10 +388,10 @@ static void drm_bo_cleanup_refs(drm_buffer_object_t * bo, int remove_all)
  * to the buffer object. Then destroy it.
  */
 
-static void drm_bo_destroy_locked(drm_buffer_object_t * bo)
+static void drm_bo_destroy_locked(struct drm_buffer_object * bo)
 {
-	drm_device_t *dev = bo->dev;
-	drm_buffer_manager_t *bm = &dev->bm;
+	struct drm_device *dev = bo->dev;
+	struct drm_buffer_manager *bm = &dev->bm;
 
 	DRM_ASSERT_LOCKED(&dev->struct_mutex);
 
@@ -438,19 +437,19 @@ static void drm_bo_destroy_locked(drm_buffer_object_t * bo)
  * Call dev->struct_mutex locked.
  */
 
-static void drm_bo_delayed_delete(drm_device_t * dev, int remove_all)
+static void drm_bo_delayed_delete(struct drm_device * dev, int remove_all)
 {
-	drm_buffer_manager_t *bm = &dev->bm;
+	struct drm_buffer_manager *bm = &dev->bm;
 
-	drm_buffer_object_t *entry, *nentry;
+	struct drm_buffer_object *entry, *nentry;
 	struct list_head *list, *next;
 
 	list_for_each_safe(list, next, &bm->ddestroy) {
-		entry = list_entry(list, drm_buffer_object_t, ddestroy);
+		entry = list_entry(list, struct drm_buffer_object, ddestroy);
 
 		nentry = NULL;
 		if (next != &bm->ddestroy) {
-			nentry = list_entry(next, drm_buffer_object_t,
+			nentry = list_entry(next, struct drm_buffer_object,
 					    ddestroy);
 			atomic_inc(&nentry->usage);
 		}
@@ -470,12 +469,12 @@ static void drm_bo_delayed_workqueue(struct work_struct *work)
 #endif
 {
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
-	drm_device_t *dev = (drm_device_t *) data;
-	drm_buffer_manager_t *bm = &dev->bm;
+	struct drm_device *dev = (struct drm_device *) data;
+	struct drm_buffer_manager *bm = &dev->bm;
 #else
-	drm_buffer_manager_t *bm =
-	    container_of(work, drm_buffer_manager_t, wq.work);
-	drm_device_t *dev = container_of(bm, drm_device_t, bm);
+	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);
 #endif
 
 	DRM_DEBUG("Delayed delete Worker\n");
@@ -493,7 +492,7 @@ static void drm_bo_delayed_workqueue(struct work_struct *work)
 	mutex_unlock(&dev->struct_mutex);
 }
 
-void drm_bo_usage_deref_locked(drm_buffer_object_t ** bo)
+void drm_bo_usage_deref_locked(struct drm_buffer_object ** bo)
 {
         struct drm_buffer_object *tmp_bo = *bo;
 	bo = NULL;
@@ -506,10 +505,11 @@ void drm_bo_usage_deref_locked(drm_buffer_object_t ** bo)
 }
 EXPORT_SYMBOL(drm_bo_usage_deref_locked);
 
-static void drm_bo_base_deref_locked(drm_file_t * priv, drm_user_object_t * uo)
+static void drm_bo_base_deref_locked(struct drm_file * file_priv,
+				     struct drm_user_object * uo)
 {
-	drm_buffer_object_t *bo =
-	    drm_user_object_entry(uo, drm_buffer_object_t, base);
+	struct drm_buffer_object *bo =
+	    drm_user_object_entry(uo, struct drm_buffer_object, base);
 
 	DRM_ASSERT_LOCKED(&bo->dev->struct_mutex);
 
@@ -517,10 +517,10 @@ static void drm_bo_base_deref_locked(drm_file_t * priv, drm_user_object_t * uo)
 	drm_bo_usage_deref_locked(&bo);
 }
 
-static void drm_bo_usage_deref_unlocked(drm_buffer_object_t ** bo)
+void drm_bo_usage_deref_unlocked(struct drm_buffer_object ** bo)
 {
 	struct drm_buffer_object *tmp_bo = *bo;
-	drm_device_t *dev = tmp_bo->dev;
+	struct drm_device *dev = tmp_bo->dev;
 
 	*bo = NULL;
 	if (atomic_dec_and_test(&tmp_bo->usage)) {
@@ -530,22 +530,23 @@ static void drm_bo_usage_deref_unlocked(drm_buffer_object_t ** bo)
 		mutex_unlock(&dev->struct_mutex);
 	}
 }
+EXPORT_SYMBOL(drm_bo_usage_deref_unlocked);
 
 /*
  * Note. The caller has to register (if applicable)
  * and deregister fence object usage.
  */
 
-int drm_fence_buffer_objects(drm_file_t * priv,
+int drm_fence_buffer_objects(struct drm_file * file_priv,
 			     struct list_head *list,
 			     uint32_t fence_flags,
-			     drm_fence_object_t * fence,
-			     drm_fence_object_t ** used_fence)
+			     struct drm_fence_object * fence,
+			     struct drm_fence_object ** used_fence)
 {
-	drm_device_t *dev = priv->head->dev;
-	drm_buffer_manager_t *bm = &dev->bm;
+	struct drm_device *dev = file_priv->head->dev;
+	struct drm_buffer_manager *bm = &dev->bm;
 
-	drm_buffer_object_t *entry;
+	struct drm_buffer_object *entry;
 	uint32_t fence_type = 0;
 	int count = 0;
 	int ret = 0;
@@ -603,7 +604,7 @@ int drm_fence_buffer_objects(drm_file_t * priv,
 	l = f_list.next;
 	while (l != &f_list) {
 		prefetch(l->next);
-		entry = list_entry(l, drm_buffer_object_t, lru);
+		entry = list_entry(l, struct drm_buffer_object, lru);
 		atomic_inc(&entry->usage);
 		mutex_unlock(&dev->struct_mutex);
 		mutex_lock(&entry->mutex);
@@ -636,12 +637,12 @@ EXPORT_SYMBOL(drm_fence_buffer_objects);
  * bo->mutex locked
  */
 
-static int drm_bo_evict(drm_buffer_object_t * bo, unsigned mem_type,
+static int drm_bo_evict(struct drm_buffer_object * bo, unsigned mem_type,
 			int no_wait)
 {
 	int ret = 0;
-	drm_device_t *dev = bo->dev;
-	drm_bo_mem_reg_t evict_mem;
+	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.
@@ -706,14 +707,18 @@ static int drm_bo_evict(drm_buffer_object_t * bo, unsigned mem_type,
 	return ret;
 }
 
-static int drm_bo_mem_force_space(drm_device_t * dev,
-				  drm_bo_mem_reg_t * mem,
+/**
+ * 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)
 {
-	drm_mm_node_t *node;
-	drm_buffer_manager_t *bm = &dev->bm;
-	drm_buffer_object_t *entry;
-	drm_mem_type_manager_t *man = &bm->man[mem_type];
+	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;
@@ -729,11 +734,11 @@ static int drm_bo_mem_force_space(drm_device_t * dev,
 		if (lru->next == lru)
 			break;
 
-		entry = list_entry(lru->next, drm_buffer_object_t, lru);
+		entry = list_entry(lru->next, struct drm_buffer_object, lru);
 		atomic_inc(&entry->usage);
 		mutex_unlock(&dev->struct_mutex);
 		mutex_lock(&entry->mutex);
-		BUG_ON(entry->mem.flags & (DRM_BO_FLAG_NO_MOVE | DRM_BO_FLAG_NO_EVICT));
+		BUG_ON(entry->pinned);
 
 		ret = drm_bo_evict(entry, mem_type, no_wait);
 		mutex_unlock(&entry->mutex);
@@ -755,7 +760,7 @@ static int drm_bo_mem_force_space(drm_device_t * dev,
 	return 0;
 }
 
-static int drm_bo_mt_compatible(drm_mem_type_manager_t * man,
+static int drm_bo_mt_compatible(struct drm_mem_type_manager * man,
 				uint32_t mem_type,
 				uint32_t mask, uint32_t * res_mask)
 {
@@ -792,12 +797,20 @@ static int drm_bo_mt_compatible(drm_mem_type_manager_t * man,
 	return 1;
 }
 
-int drm_bo_mem_space(drm_buffer_object_t * bo,
-		     drm_bo_mem_reg_t * mem, int no_wait)
+/**
+ * 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)
 {
-	drm_device_t *dev = bo->dev;
-	drm_buffer_manager_t *bm = &dev->bm;
-	drm_mem_type_manager_t *man;
+	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;
@@ -807,7 +820,7 @@ int drm_bo_mem_space(drm_buffer_object_t * bo,
 	int type_found = 0;
 	int type_ok = 0;
 	int has_eagain = 0;
-	drm_mm_node_t *node = NULL;
+	struct drm_mm_node *node = NULL;
 	int ret;
 
 	mem->mm_node = NULL;
@@ -884,8 +897,8 @@ int drm_bo_mem_space(drm_buffer_object_t * bo,
 
 EXPORT_SYMBOL(drm_bo_mem_space);
 
-static int drm_bo_new_mask(drm_buffer_object_t * bo,
-			   uint32_t new_mask, uint32_t hint)
+static int drm_bo_new_mask(struct drm_buffer_object * bo,
+			   uint64_t new_mask, uint32_t hint)
 {
 	uint32_t new_props;
 
@@ -893,18 +906,6 @@ static int drm_bo_new_mask(drm_buffer_object_t * bo,
 		DRM_ERROR("User buffers are not supported yet\n");
 		return -EINVAL;
 	}
-	if (bo->type == drm_bo_type_fake &&
-	    !(new_mask & (DRM_BO_FLAG_NO_MOVE | DRM_BO_FLAG_NO_EVICT))) {
-		DRM_ERROR("Fake buffers must be pinned.\n");
-		return -EINVAL;
-	}
-
-	if ((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;
-	}
 
 	new_props = new_mask & (DRM_BO_FLAG_EXE | DRM_BO_FLAG_WRITE |
 				DRM_BO_FLAG_READ);
@@ -922,25 +923,25 @@ static int drm_bo_new_mask(drm_buffer_object_t * bo,
  * Call dev->struct_mutex locked.
  */
 
-drm_buffer_object_t *drm_lookup_buffer_object(drm_file_t * priv,
+struct drm_buffer_object *drm_lookup_buffer_object(struct drm_file *file_priv,
 					      uint32_t handle, int check_owner)
 {
-	drm_user_object_t *uo;
-	drm_buffer_object_t *bo;
+	struct drm_user_object *uo;
+	struct drm_buffer_object *bo;
 
-	uo = drm_lookup_user_object(priv, handle);
+	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 && priv != uo->owner) {
-		if (!drm_lookup_ref_object(priv, uo, _DRM_REF_USE))
+	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, drm_buffer_object_t, base);
+	bo = drm_user_object_entry(uo, struct drm_buffer_object, base);
 	atomic_inc(&bo->usage);
 	return bo;
 }
@@ -951,9 +952,9 @@ drm_buffer_object_t *drm_lookup_buffer_object(drm_file_t * priv,
  * Doesn't do any fence flushing as opposed to the drm_bo_busy function.
  */
 
-static int drm_bo_quick_busy(drm_buffer_object_t * bo)
+static int drm_bo_quick_busy(struct drm_buffer_object * bo)
 {
-	drm_fence_object_t *fence = bo->fence;
+	struct drm_fence_object *fence = bo->fence;
 
 	BUG_ON(bo->priv_flags & _DRM_BO_FLAG_UNFENCED);
 	if (fence) {
@@ -971,9 +972,9 @@ static int drm_bo_quick_busy(drm_buffer_object_t * bo)
  * Returns 1 if the buffer is currently rendered to or from. 0 otherwise.
  */
 
-static int drm_bo_busy(drm_buffer_object_t * bo)
+static int drm_bo_busy(struct drm_buffer_object * bo)
 {
-	drm_fence_object_t *fence = bo->fence;
+	struct drm_fence_object *fence = bo->fence;
 
 	BUG_ON(bo->priv_flags & _DRM_BO_FLAG_UNFENCED);
 	if (fence) {
@@ -991,7 +992,7 @@ static int drm_bo_busy(drm_buffer_object_t * bo)
 	return 0;
 }
 
-static int drm_bo_read_cached(drm_buffer_object_t * bo)
+static int drm_bo_read_cached(struct drm_buffer_object * bo)
 {
 	int ret = 0;
 
@@ -1005,7 +1006,7 @@ static int drm_bo_read_cached(drm_buffer_object_t * bo)
  * Wait until a buffer is unmapped.
  */
 
-static int drm_bo_wait_unmapped(drm_buffer_object_t * bo, int no_wait)
+static int drm_bo_wait_unmapped(struct drm_buffer_object * bo, int no_wait)
 {
 	int ret = 0;
 
@@ -1021,7 +1022,7 @@ static int drm_bo_wait_unmapped(drm_buffer_object_t * bo, int no_wait)
 	return ret;
 }
 
-static int drm_bo_check_unfenced(drm_buffer_object_t * bo)
+static int drm_bo_check_unfenced(struct drm_buffer_object * bo)
 {
 	int ret;
 
@@ -1043,7 +1044,7 @@ static int drm_bo_check_unfenced(drm_buffer_object_t * bo)
  * the buffer "unfenced" after validating, but before fencing.
  */
 
-static int drm_bo_wait_unfenced(drm_buffer_object_t * bo, int no_wait,
+static int drm_bo_wait_unfenced(struct drm_buffer_object * bo, int no_wait,
 				int eagain_if_wait)
 {
 	int ret = (bo->priv_flags & _DRM_BO_FLAG_UNFENCED);
@@ -1076,8 +1077,8 @@ static int drm_bo_wait_unfenced(drm_buffer_object_t * bo, int no_wait,
  * Bo locked.
  */
 
-static void drm_bo_fill_rep_arg(drm_buffer_object_t * bo,
-				drm_bo_arg_reply_t * rep)
+static void drm_bo_fill_rep_arg(struct drm_buffer_object * bo,
+				struct drm_bo_info_rep *rep)
 {
 	rep->handle = bo->base.hash.key;
 	rep->flags = bo->mem.flags;
@@ -1103,17 +1104,17 @@ static void drm_bo_fill_rep_arg(drm_buffer_object_t * bo,
  * unregistered.
  */
 
-static int drm_buffer_object_map(drm_file_t * priv, uint32_t handle,
+static int drm_buffer_object_map(struct drm_file *file_priv, uint32_t handle,
 				 uint32_t map_flags, unsigned hint,
-				 drm_bo_arg_reply_t * rep)
+				 struct drm_bo_info_rep *rep)
 {
-	drm_buffer_object_t *bo;
-	drm_device_t *dev = priv->head->dev;
+	struct drm_buffer_object *bo;
+	struct drm_device *dev = file_priv->head->dev;
 	int ret = 0;
 	int no_wait = hint & DRM_BO_HINT_DONT_BLOCK;
 
 	mutex_lock(&dev->struct_mutex);
-	bo = drm_lookup_buffer_object(priv, handle, 1);
+	bo = drm_lookup_buffer_object(file_priv, handle, 1);
 	mutex_unlock(&dev->struct_mutex);
 
 	if (!bo)
@@ -1170,7 +1171,7 @@ static int drm_buffer_object_map(drm_file_t * priv, uint32_t handle,
 	}
 
 	mutex_lock(&dev->struct_mutex);
-	ret = drm_add_ref_object(priv, &bo->base, _DRM_REF_TYPE1);
+	ret = drm_add_ref_object(file_priv, &bo->base, _DRM_REF_TYPE1);
 	mutex_unlock(&dev->struct_mutex);
 	if (ret) {
 		if (atomic_add_negative(-1, &bo->mapped))
@@ -1184,28 +1185,28 @@ static int drm_buffer_object_map(drm_file_t * priv, uint32_t handle,
 	return ret;
 }
 
-static int drm_buffer_object_unmap(drm_file_t * priv, uint32_t handle)
+static int drm_buffer_object_unmap(struct drm_file *file_priv, uint32_t handle)
 {
-	drm_device_t *dev = priv->head->dev;
-	drm_buffer_object_t *bo;
-	drm_ref_object_t *ro;
+	struct drm_device *dev = file_priv->head->dev;
+	struct drm_buffer_object *bo;
+	struct drm_ref_object *ro;
 	int ret = 0;
 
 	mutex_lock(&dev->struct_mutex);
 
-	bo = drm_lookup_buffer_object(priv, handle, 1);
+	bo = drm_lookup_buffer_object(file_priv, handle, 1);
 	if (!bo) {
 		ret = -EINVAL;
 		goto out;
 	}
 
-	ro = drm_lookup_ref_object(priv, &bo->base, _DRM_REF_TYPE1);
+	ro = drm_lookup_ref_object(file_priv, &bo->base, _DRM_REF_TYPE1);
 	if (!ro) {
 		ret = -EINVAL;
 		goto out;
 	}
 
-	drm_remove_ref_object(priv, ro);
+	drm_remove_ref_object(file_priv, ro);
 	drm_bo_usage_deref_locked(&bo);
       out:
 	mutex_unlock(&dev->struct_mutex);
@@ -1216,12 +1217,12 @@ static int drm_buffer_object_unmap(drm_file_t * priv, uint32_t handle)
  * Call struct-sem locked.
  */
 
-static void drm_buffer_user_object_unmap(drm_file_t * priv,
-					 drm_user_object_t * uo,
-					 drm_ref_t action)
+static void drm_buffer_user_object_unmap(struct drm_file *file_priv,
+					 struct drm_user_object * uo,
+					 enum drm_ref_type action)
 {
-	drm_buffer_object_t *bo =
-	    drm_user_object_entry(uo, drm_buffer_object_t, base);
+	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
@@ -1239,13 +1240,13 @@ static void drm_buffer_user_object_unmap(drm_file_t * priv,
  * Note that new_mem_flags are NOT transferred to the bo->mem.mask.
  */
 
-int drm_bo_move_buffer(drm_buffer_object_t * bo, uint32_t new_mem_flags,
+int drm_bo_move_buffer(struct drm_buffer_object * bo, uint32_t new_mem_flags,
 		       int no_wait, int move_unfenced)
 {
-	drm_device_t *dev = bo->dev;
-	drm_buffer_manager_t *bm = &dev->bm;
+	struct drm_device *dev = bo->dev;
+	struct drm_buffer_manager *bm = &dev->bm;
 	int ret = 0;
-	drm_bo_mem_reg_t mem;
+	struct drm_bo_mem_reg mem;
 	/*
 	 * Flush outstanding fences.
 	 */
@@ -1301,7 +1302,7 @@ int drm_bo_move_buffer(drm_buffer_object_t * bo, uint32_t new_mem_flags,
 	return ret;
 }
 
-static int drm_bo_mem_compat(drm_bo_mem_reg_t * mem)
+static int drm_bo_mem_compat(struct drm_bo_mem_reg * mem)
 {
 	uint32_t flag_diff = (mem->mask ^ mem->flags);
 
@@ -1319,10 +1320,10 @@ static int drm_bo_mem_compat(drm_bo_mem_reg_t * mem)
 	return 1;
 }
 
-static int drm_bo_check_fake(drm_device_t * dev, drm_bo_mem_reg_t * mem)
+static int drm_bo_check_fake(struct drm_device * dev, struct drm_bo_mem_reg * mem)
 {
-	drm_buffer_manager_t *bm = &dev->bm;
-	drm_mem_type_manager_t *man;
+	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;
@@ -1352,7 +1353,8 @@ static int drm_bo_check_fake(drm_device_t * dev, drm_bo_mem_reg_t * mem)
 		return 0;
 	}
 
-	DRM_ERROR("Illegal fake buffer flags 0x%08x\n", mem->mask);
+	DRM_ERROR("Illegal fake buffer flags 0x%016llx\n",
+		  (unsigned long long) mem->mask);
 	return -EINVAL;
 }
 
@@ -1360,23 +1362,52 @@ static int drm_bo_check_fake(drm_device_t * dev, drm_bo_mem_reg_t * mem)
  * bo locked.
  */
 
-static int drm_buffer_object_validate(drm_buffer_object_t * bo,
+static int drm_buffer_object_validate(struct drm_buffer_object * bo,
+				      uint32_t fence_class,
 				      int move_unfenced, int no_wait)
 {
-	drm_device_t *dev = bo->dev;
-	drm_buffer_manager_t *bm = &dev->bm;
-	drm_bo_driver_t *driver = dev->driver->bo_driver;
+	struct drm_device *dev = bo->dev;
+	struct drm_buffer_manager *bm = &dev->bm;
+	struct drm_bo_driver *driver = dev->driver->bo_driver;
+	uint32_t ftype;
 	int ret;
 
-	DRM_DEBUG("New flags 0x%08x, Old flags 0x%08x\n", bo->mem.mask,
-		  bo->mem.flags);
-	ret =
-	    driver->fence_type(bo, &bo->fence_class, &bo->fence_type);
+	DRM_DEBUG("New flags 0x%016llx, Old flags 0x%016llx\n",
+		  (unsigned long long) bo->mem.mask,
+		  (unsigned long long) bo->mem.flags);
+
+	ret = driver->fence_type(bo, &ftype);
+
 	if (ret) {
 		DRM_ERROR("Driver did not support given buffer permissions\n");
 		return ret;
 	}
 
+	if (bo->pinned && bo->pinned_mem_type != bo->mem.mem_type) {
+		DRM_ERROR("Attempt to validate pinned buffer into different memory "
+		    "type\n");
+		return -EINVAL;
+	}
+
+	/*
+	 * We're switching command submission mechanism,
+	 * or cannot simply rely on the hardware serializing for us.
+	 *
+	 * Wait for buffer idle.
+	 */
+
+	if ((fence_class != bo->fence_class) ||
+	    ((ftype ^ bo->fence_type) & bo->fence_type)) {
+
+		ret = drm_bo_wait(bo, 0, 0, no_wait);
+
+		if (ret)
+			return ret;
+
+	}
+	
+	bo->fence_class = fence_class;
+	bo->fence_type = ftype;
 	ret = drm_bo_wait_unmapped(bo, no_wait);
 	if (ret)
 		return ret;
@@ -1402,37 +1433,6 @@ static int drm_buffer_object_validate(drm_buffer_object_t * bo,
 	}
 
 	/*
-	 * Pinned buffers.
-	 */
-
-	if (bo->mem.mask & (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.
 	 */
 
@@ -1466,17 +1466,19 @@ static int drm_buffer_object_validate(drm_buffer_object_t * bo,
 	return 0;
 }
 
-static int drm_bo_handle_validate(drm_file_t * priv, uint32_t handle,
-				  uint32_t flags, uint32_t mask, uint32_t hint,
-				  drm_bo_arg_reply_t * rep)
+static int drm_bo_handle_validate(struct drm_file *file_priv,
+				  uint32_t handle,
+				  uint32_t fence_class,
+				  uint64_t flags, uint64_t mask, uint32_t hint,
+				  struct drm_bo_info_rep *rep)
 {
-	struct drm_device *dev = priv->head->dev;
-	drm_buffer_object_t *bo;
+	struct drm_device *dev = file_priv->head->dev;
+	struct drm_buffer_object *bo;
 	int ret;
 	int no_wait = hint & DRM_BO_HINT_DONT_BLOCK;
 
 	mutex_lock(&dev->struct_mutex);
-	bo = drm_lookup_buffer_object(priv, handle, 1);
+	bo = drm_lookup_buffer_object(file_priv, handle, 1);
 	mutex_unlock(&dev->struct_mutex);
 	if (!bo) {
 		return -EINVAL;
@@ -1494,7 +1496,8 @@ static int drm_bo_handle_validate(drm_file_t * priv, uint32_t handle,
 		goto out;
 
 	ret =
-	    drm_buffer_object_validate(bo, !(hint & DRM_BO_HINT_DONT_FENCE),
+	    drm_buffer_object_validate(bo, fence_class,
+				       !(hint & DRM_BO_HINT_DONT_FENCE),
 				       no_wait);
 	drm_bo_fill_rep_arg(bo, rep);
 
@@ -1506,14 +1509,18 @@ static int drm_bo_handle_validate(drm_file_t * priv, uint32_t handle,
 	return ret;
 }
 
-static int drm_bo_handle_info(drm_file_t * priv, uint32_t handle,
-			      drm_bo_arg_reply_t * rep)
+/**
+ * Fills out the generic buffer object ioctl reply with the information for
+ * the BO with id of handle.
+ */
+static int drm_bo_handle_info(struct drm_file *file_priv, uint32_t handle,
+			      struct drm_bo_info_rep *rep)
 {
-	struct drm_device *dev = priv->head->dev;
-	drm_buffer_object_t *bo;
+	struct drm_device *dev = file_priv->head->dev;
+	struct drm_buffer_object *bo;
 
 	mutex_lock(&dev->struct_mutex);
-	bo = drm_lookup_buffer_object(priv, handle, 1);
+	bo = drm_lookup_buffer_object(file_priv, handle, 1);
 	mutex_unlock(&dev->struct_mutex);
 
 	if (!bo) {
@@ -1528,16 +1535,17 @@ static int drm_bo_handle_info(drm_file_t * priv, uint32_t handle,
 	return 0;
 }
 
-static int drm_bo_handle_wait(drm_file_t * priv, uint32_t handle,
-			      uint32_t hint, drm_bo_arg_reply_t * rep)
+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 = priv->head->dev;
-	drm_buffer_object_t *bo;
+	struct drm_device *dev = file_priv->head->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(priv, handle, 1);
+	bo = drm_lookup_buffer_object(file_priv, handle, 1);
 	mutex_unlock(&dev->struct_mutex);
 
 	if (!bo) {
@@ -1560,17 +1568,18 @@ static int drm_bo_handle_wait(drm_file_t * priv, uint32_t handle,
 	return ret;
 }
 
-int drm_buffer_object_create(drm_device_t *dev,
+int drm_buffer_object_create(struct drm_device *dev,
 			     unsigned long size,
-			     drm_bo_type_t type,
-			     uint32_t mask,
+			     enum drm_bo_type type,
+			     uint64_t mask,
 			     uint32_t hint,
 			     uint32_t page_alignment,
 			     unsigned long buffer_start,
-			     drm_buffer_object_t ** buf_obj)
+			     struct drm_buffer_object ** buf_obj)
 {
-	drm_buffer_manager_t *bm = &dev->bm;
-	drm_buffer_object_t *bo;
+	struct drm_buffer_manager *bm = &dev->bm;
+	struct drm_buffer_object *bo;
+	struct drm_bo_driver *driver = dev->driver->bo_driver;
 	int ret = 0;
 	unsigned long num_pages;
 
@@ -1615,8 +1624,8 @@ int drm_buffer_object_create(drm_device_t *dev,
 		bo->buffer_start = buffer_start;
 	}
 	bo->priv_flags = 0;
-	bo->mem.flags = 0;
-	bo->mem.mask = 0;
+	bo->mem.flags = 0ULL;
+	bo->mem.mask = 0ULL;
 	atomic_inc(&bm->count);
 	ret = drm_bo_new_mask(bo, mask, hint);
 
@@ -1630,10 +1639,28 @@ int drm_buffer_object_create(drm_device_t *dev,
 		if (ret)
 			goto out_err;
 	}
-	ret = drm_buffer_object_validate(bo, 0, hint & DRM_BO_HINT_DONT_BLOCK);
+
+	bo->fence_class = 0;
+	ret = driver->fence_type(bo, &bo->fence_type);
+	if (ret) {
+		DRM_ERROR("Driver did not support given buffer permissions\n");
+		goto out_err;
+	}
+
+	if (bo->type == drm_bo_type_fake) {
+		ret = drm_bo_check_fake(dev, &bo->mem);
+		if (ret)
+			goto out_err;
+	}
+
+	ret = drm_bo_add_ttm(bo);
 	if (ret)
 		goto out_err;
 
+	mutex_lock(&dev->struct_mutex);
+	drm_bo_add_to_lru(bo);
+	mutex_unlock(&dev->struct_mutex);
+
 	mutex_unlock(&bo->mutex);
 	*buf_obj = bo;
 	return 0;
@@ -1646,14 +1673,14 @@ int drm_buffer_object_create(drm_device_t *dev,
 }
 EXPORT_SYMBOL(drm_buffer_object_create);
 
-static int drm_bo_add_user_object(drm_file_t * priv, drm_buffer_object_t * bo,
-				  int shareable)
+int drm_bo_add_user_object(struct drm_file *file_priv,
+			   struct drm_buffer_object *bo, int shareable)
 {
-	drm_device_t *dev = priv->head->dev;
+	struct drm_device *dev = file_priv->head->dev;
 	int ret;
 
 	mutex_lock(&dev->struct_mutex);
-	ret = drm_add_user_object(priv, &bo->base, shareable);
+	ret = drm_add_user_object(file_priv, &bo->base, shareable);
 	if (ret)
 		goto out;
 
@@ -1666,22 +1693,25 @@ static int drm_bo_add_user_object(drm_file_t * priv, drm_buffer_object_t * bo,
 	mutex_unlock(&dev->struct_mutex);
 	return ret;
 }
+EXPORT_SYMBOL(drm_bo_add_user_object);
 
-static int drm_bo_lock_test(drm_device_t * dev, struct file *filp)
+static int drm_bo_lock_test(struct drm_device * dev, struct drm_file *file_priv)
 {
-	LOCK_TEST_WITH_RETURN(dev, filp);
+	LOCK_TEST_WITH_RETURN(dev, file_priv);
 	return 0;
 }
 
-int drm_bo_ioctl(DRM_IOCTL_ARGS)
+int drm_bo_op_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv)
 {
-	DRM_DEVICE;
-	drm_bo_arg_t arg;
-	drm_bo_arg_request_t *req = &arg.d.req;
-	drm_bo_arg_reply_t rep;
-	unsigned long next;
-	drm_user_object_t *uo;
-	drm_buffer_object_t *entry;
+	struct drm_bo_op_arg curarg;
+	struct drm_bo_op_arg *arg = data;
+	struct drm_bo_op_req *req = &arg->d.req;
+	struct drm_bo_info_rep rep;
+	unsigned long next = 0;
+	void __user *curuserarg = NULL;
+	int ret;
+
+	DRM_DEBUG("drm_bo_op_ioctl\n");
 
 	if (!dev->bm.initialized) {
 		DRM_ERROR("Buffer object manager is not initialized.\n");
@@ -1689,140 +1719,388 @@ int drm_bo_ioctl(DRM_IOCTL_ARGS)
 	}
 
 	do {
-		DRM_COPY_FROM_USER_IOCTL(arg, (void __user *)data, sizeof(arg));
+		if (next != 0) {
+			curuserarg = (void __user *)next;
+			if (copy_from_user(&curarg, curuserarg,
+					   sizeof(curarg)) != 0)
+				return -EFAULT;
+			arg = &curarg;
+		}
 
-		if (arg.handled) {
-			data = arg.next;
+		if (arg->handled) {
+			next = arg->next;
 			continue;
 		}
-
-		rep.ret = 0;
+		req = &arg->d.req;
+		ret = 0;
 		switch (req->op) {
-		case drm_bo_create:
-			rep.ret = drm_bo_lock_test(dev, filp);
-			if (rep.ret)
-				break;	
-			rep.ret =
-			    drm_buffer_object_create(priv->head->dev,
-						     req->size,
-						     req->type,
-						     req->mask,
-						     req->hint,
-						     req->page_alignment,
-						     req->buffer_start, &entry);
-			if (rep.ret)
-				break;
-
-			rep.ret =
-			    drm_bo_add_user_object(priv, entry,
-						   req->
-						   mask &
-						   DRM_BO_FLAG_SHAREABLE);
-			if (rep.ret)
-				drm_bo_usage_deref_unlocked(&entry);
-
-			if (rep.ret)
-				break;
-
-			mutex_lock(&entry->mutex);
-			drm_bo_fill_rep_arg(entry, &rep);
-			mutex_unlock(&entry->mutex);
-			break;
-		case drm_bo_unmap:
-			rep.ret = drm_buffer_object_unmap(priv, req->handle);
-			break;
-		case drm_bo_map:
-			rep.ret = drm_buffer_object_map(priv, req->handle,
-							req->mask,
-							req->hint, &rep);
-			break;
-		case drm_bo_destroy:
-			mutex_lock(&dev->struct_mutex);
-			uo = drm_lookup_user_object(priv, req->handle);
-			if (!uo || (uo->type != drm_buffer_type)
-			    || uo->owner != priv) {
-				mutex_unlock(&dev->struct_mutex);
-				rep.ret = -EINVAL;
-				break;
-			}
-			rep.ret = drm_remove_user_object(priv, uo);
-			mutex_unlock(&dev->struct_mutex);
-			break;
-		case drm_bo_reference:
-			rep.ret = drm_user_object_ref(priv, req->handle,
-						      drm_buffer_type, &uo);
-			if (rep.ret)
-				break;
-			rep.ret = drm_bo_handle_info(priv, req->handle, &rep);
-			break;
-		case drm_bo_unreference:
-			rep.ret = drm_user_object_unref(priv, req->handle,
-							drm_buffer_type);
-			break;
 		case drm_bo_validate:
-			rep.ret = drm_bo_lock_test(dev, filp);
-
-			if (rep.ret)
+			ret = drm_bo_lock_test(dev, file_priv);
+			if (ret)
 				break;
-			rep.ret =
-			    drm_bo_handle_validate(priv, req->handle, req->mask,
-						   req->arg_handle, req->hint,
-						   &rep);
+			ret = drm_bo_handle_validate(file_priv, req->bo_req.handle,
+						     req->bo_req.fence_class,
+						     req->bo_req.flags,
+						     req->bo_req.mask,
+						     req->bo_req.hint,
+						     &rep);
 			break;
 		case drm_bo_fence:
-			rep.ret = drm_bo_lock_test(dev, filp);
-			if (rep.ret)
-				break;
-			 /**/ break;
-		case drm_bo_info:
-			rep.ret = drm_bo_handle_info(priv, req->handle, &rep);
-			break;
-		case drm_bo_wait_idle:
-			rep.ret = drm_bo_handle_wait(priv, req->handle,
-						     req->hint, &rep);
+			ret = -EINVAL;
+			DRM_ERROR("Function is not implemented yet.\n");
 			break;
 		case drm_bo_ref_fence:
-			rep.ret = -EINVAL;
+			ret = -EINVAL;
 			DRM_ERROR("Function is not implemented yet.\n");
+			break;
 		default:
-			rep.ret = -EINVAL;
+			ret = -EINVAL;
 		}
-		next = arg.next;
+		next = arg->next;
 
 		/*
 		 * A signal interrupted us. Make sure the ioctl is restartable.
 		 */
 
-		if (rep.ret == -EAGAIN)
+		if (ret == -EAGAIN)
 			return -EAGAIN;
 
-		arg.handled = 1;
-		arg.d.rep = rep;
-		DRM_COPY_TO_USER_IOCTL((void __user *)data, arg, sizeof(arg));
-		data = next;
-	} while (data);
+		arg->handled = 1;
+		arg->d.rep.ret = ret;
+		arg->d.rep.bo_info = rep;
+		if (arg != data) {
+			if (copy_to_user(curuserarg, &curarg,
+					 sizeof(curarg)) != 0)
+				return -EFAULT;
+		}
+	} while (next != 0);
+	return 0;
+}
+
+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;
+	int ret = 0;
+
+	DRM_DEBUG("drm_bo_create_ioctl: %dkb, %dkb align, %d type\n",
+	    (int)(req->size / 1024), req->page_alignment * 4, req->type);
+
+	if (!dev->bm.initialized) {
+		DRM_ERROR("Buffer object manager is not initialized.\n");
+		return -EINVAL;
+	}
+	if (req->type == drm_bo_type_fake)
+		LOCK_TEST_WITH_RETURN(dev, file_priv);
+
+	ret = drm_buffer_object_create(file_priv->head->dev,
+				       req->size, req->type, req->mask,
+				       req->hint, req->page_alignment,
+				       req->buffer_start, &entry);
+	if (ret)
+		goto out;
+	
+	ret = drm_bo_add_user_object(file_priv, entry,
+				     req->mask & 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_destroy_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv)
+{
+	struct drm_bo_handle_arg *arg = data;
+	struct drm_user_object *uo;
+	int ret = 0;
+
+	DRM_DEBUG("drm_bo_destroy_ioctl: buffer %d\n", arg->handle);
+
+	if (!dev->bm.initialized) {
+		DRM_ERROR("Buffer object manager is not initialized.\n");
+		return -EINVAL;
+	}
+
+	mutex_lock(&dev->struct_mutex);
+	uo = drm_lookup_user_object(file_priv, arg->handle);
+	if (!uo || (uo->type != drm_buffer_type) || uo->owner != file_priv) {
+		mutex_unlock(&dev->struct_mutex);
+		return -EINVAL;
+	}
+	ret = drm_remove_user_object(file_priv, uo);
+	mutex_unlock(&dev->struct_mutex);
+	
+	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;
+
+	DRM_DEBUG("drm_bo_map_ioctl: buffer %d\n", req->handle);
+
+	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;
+
+	DRM_DEBUG("drm_bo_unmap_ioctl: buffer %d\n", arg->handle);
+
+	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;
+
+	DRM_DEBUG("drm_bo_reference_ioctl: buffer %d\n", req->handle);
+
+	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;
+
+	DRM_DEBUG("drm_bo_unreference_ioctl: buffer %d\n", arg->handle);
+
+	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;
+
+	DRM_DEBUG("drm_bo_info_ioctl: buffer %d\n", req->handle);
+
+	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;
+
+	DRM_DEBUG("drm_bo_wait_idle_ioctl: buffer %d\n", req->handle);
+
+	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;
 }
 
 /**
+ * Pins or unpins the given buffer object in the given memory area.
+ *
+ * Pinned buffers will not be evicted from or move within their memory area.
+ * Must be called with the hardware lock held for pinning.
+ */
+int
+drm_bo_set_pin(struct drm_device *dev, struct drm_buffer_object *bo,
+    int pin)
+{
+	int ret = 0;
+
+	mutex_lock(&bo->mutex);
+	if (bo->pinned == pin) {
+		mutex_unlock(&bo->mutex);
+		return 0;
+	}
+
+	if (pin) {
+		ret = drm_bo_wait_unfenced(bo, 0, 0);
+		if (ret) {
+			mutex_unlock(&bo->mutex);
+			return ret;
+		}
+
+		/* Validate the buffer into its pinned location, with no
+		 * pending fence.
+		 */
+		ret = drm_buffer_object_validate(bo, bo->fence_class, 0, 0);
+		if (ret) {
+			mutex_unlock(&bo->mutex);
+			return ret;
+		}
+
+		/* Pull the buffer off of the LRU and add it to the pinned
+		 * list
+		 */
+		bo->pinned_mem_type = bo->mem.mem_type;
+		mutex_lock(&dev->struct_mutex);
+		list_del_init(&bo->lru);
+		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;
+		}
+
+		bo->pinned = pin;
+		mutex_unlock(&dev->struct_mutex);
+
+	} else {
+		mutex_lock(&dev->struct_mutex);
+
+		/* Remove our buffer from the pinned list */
+		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;
+		bo->pinned = pin;
+		mutex_unlock(&dev->struct_mutex);
+	}
+	mutex_unlock(&bo->mutex);
+	return 0;
+}
+EXPORT_SYMBOL(drm_bo_set_pin);
+
+int drm_bo_set_pin_ioctl(struct drm_device *dev, void *data,
+			 struct drm_file *file_priv)
+{
+	struct drm_bo_set_pin_arg *arg = data;
+	struct drm_bo_set_pin_req *req = &arg->d.req;
+	struct drm_bo_info_rep *rep = &arg->d.rep;
+	struct drm_buffer_object *bo;
+	int ret;
+
+	DRM_DEBUG("drm_bo_set_pin_ioctl: buffer %d, pin %d\n",
+	    req->handle, req->pin);
+
+	if (!dev->bm.initialized) {
+		DRM_ERROR("Buffer object manager is not initialized.\n");
+		return -EINVAL;
+	}
+
+	if (req->pin < 0 || req->pin > 1) {
+		DRM_ERROR("Bad arguments to set_pin\n");
+		return -EINVAL;
+	}
+
+	if (req->pin)
+		LOCK_TEST_WITH_RETURN(dev, file_priv);
+
+	mutex_lock(&dev->struct_mutex);
+	bo = drm_lookup_buffer_object(file_priv, req->handle, 1);
+	mutex_unlock(&dev->struct_mutex);
+	if (!bo) {
+		return -EINVAL;
+	}
+
+	ret = drm_bo_set_pin(dev, bo, req->pin);
+	if (ret) {
+		drm_bo_usage_deref_unlocked(&bo);
+		return ret;
+	}
+
+	drm_bo_fill_rep_arg(bo, rep);
+	drm_bo_usage_deref_unlocked(&bo);
+
+	return 0;
+}
+
+
+/**
  *Clean the unfenced list and put on regular LRU.
  *This is part of the memory manager cleanup and should only be
  *called with the DRI lock held.
  *Call dev->struct_sem locked.
  */
 
-static void drm_bo_clean_unfenced(drm_device_t *dev)
+static void drm_bo_clean_unfenced(struct drm_device *dev)
 {
-	drm_buffer_manager_t *bm  = &dev->bm;
+	struct drm_buffer_manager *bm  = &dev->bm;
 	struct list_head *head, *list;
-	drm_buffer_object_t *entry;
+	struct drm_buffer_object *entry;
 
 	head = &bm->unfenced;
 
 	list = head->next;
 	while(list != head) {
 		prefetch(list->next);
-		entry = list_entry(list, drm_buffer_object_t, lru);
+		entry = list_entry(list, struct drm_buffer_object, lru);
 
 		atomic_inc(&entry->usage);
 		mutex_unlock(&dev->struct_mutex);
@@ -1837,11 +2115,11 @@ static void drm_bo_clean_unfenced(drm_device_t *dev)
 	}
 }
 
-static int drm_bo_leave_list(drm_buffer_object_t * bo,
+static int drm_bo_leave_list(struct drm_buffer_object * bo,
 			     uint32_t mem_type,
 			     int free_pinned, int allow_errors)
 {
-	drm_device_t *dev = bo->dev;
+	struct drm_device *dev = bo->dev;
 	int ret = 0;
 
 	mutex_lock(&bo->mutex);
@@ -1863,11 +2141,10 @@ static int drm_bo_leave_list(drm_buffer_object_t * bo,
 		mutex_unlock(&dev->struct_mutex);
 	}
 
-	if (bo->mem.flags & DRM_BO_FLAG_NO_EVICT) {
-		DRM_ERROR("A DRM_BO_NO_EVICT buffer present at "
+	if (bo->pinned) {
+		DRM_ERROR("A pinned buffer was present at "
 			  "cleanup. Removing flag and evicting.\n");
-		bo->mem.flags &= ~DRM_BO_FLAG_NO_EVICT;
-		bo->mem.mask &= ~DRM_BO_FLAG_NO_EVICT;
+		bo->pinned = 0;
 	}
 
 	if (bo->mem.mem_type == mem_type)
@@ -1888,20 +2165,20 @@ static int drm_bo_leave_list(drm_buffer_object_t * bo,
 }
 
 
-static drm_buffer_object_t *drm_bo_entry(struct list_head *list,
+static struct drm_buffer_object *drm_bo_entry(struct list_head *list,
 					 int pinned_list)
 {
 	if (pinned_list)
-		return list_entry(list, drm_buffer_object_t, pinned_lru);
+		return list_entry(list, struct drm_buffer_object, pinned_lru);
 	else
-		return list_entry(list, drm_buffer_object_t, lru);
+		return list_entry(list, struct drm_buffer_object, lru);
 }
 
 /*
  * dev->struct_mutex locked.
  */
 
-static int drm_bo_force_list_clean(drm_device_t * dev,
+static int drm_bo_force_list_clean(struct drm_device * dev,
 				   struct list_head *head,
 				   unsigned mem_type,
 				   int free_pinned,
@@ -1909,7 +2186,7 @@ static int drm_bo_force_list_clean(drm_device_t * dev,
 				   int pinned_list)
 {
 	struct list_head *list, *next, *prev;
-	drm_buffer_object_t *entry, *nentry;
+	struct drm_buffer_object *entry, *nentry;
 	int ret;
 	int do_restart;
 
@@ -1966,10 +2243,10 @@ restart:
 	return 0;
 }
 
-int drm_bo_clean_mm(drm_device_t * dev, unsigned mem_type)
+int drm_bo_clean_mm(struct drm_device * dev, unsigned mem_type)
 {
-	drm_buffer_manager_t *bm = &dev->bm;
-	drm_mem_type_manager_t *man = &bm->man[mem_type];
+	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) {
@@ -2009,11 +2286,11 @@ EXPORT_SYMBOL(drm_bo_clean_mm);
  *point since we have the hardware lock.
  */
 
-static int drm_bo_lock_mm(drm_device_t * dev, unsigned mem_type)
+static int drm_bo_lock_mm(struct drm_device * dev, unsigned mem_type)
 {
 	int ret;
-	drm_buffer_manager_t *bm = &dev->bm;
-	drm_mem_type_manager_t *man = &bm->man[mem_type];
+	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);
@@ -2035,13 +2312,13 @@ static int drm_bo_lock_mm(drm_device_t * dev, unsigned mem_type)
 	return ret;
 }
 
-int drm_bo_init_mm(drm_device_t * dev,
+int drm_bo_init_mm(struct drm_device * dev,
 		   unsigned type,
 		   unsigned long p_offset, unsigned long p_size)
 {
-	drm_buffer_manager_t *bm = &dev->bm;
+	struct drm_buffer_manager *bm = &dev->bm;
 	int ret = -EINVAL;
-	drm_mem_type_manager_t *man;
+	struct drm_mem_type_manager *man;
 
 	if (type >= DRM_BO_MEM_TYPES) {
 		DRM_ERROR("Illegal memory type %d\n", type);
@@ -2084,12 +2361,12 @@ EXPORT_SYMBOL(drm_bo_init_mm);
  * any clients still running when we set the initialized flag to zero.
  */
 
-int drm_bo_driver_finish(drm_device_t * dev)
+int drm_bo_driver_finish(struct drm_device * dev)
 {
-	drm_buffer_manager_t *bm = &dev->bm;
+	struct drm_buffer_manager *bm = &dev->bm;
 	int ret = 0;
 	unsigned i = DRM_BO_MEM_TYPES;
-	drm_mem_type_manager_t *man;
+	struct drm_mem_type_manager *man;
 
 	mutex_lock(&dev->bm.init_mutex);
 	mutex_lock(&dev->struct_mutex);
@@ -2136,10 +2413,10 @@ int drm_bo_driver_finish(drm_device_t * dev)
 }
 EXPORT_SYMBOL(drm_bo_driver_finish);
 
-int drm_bo_driver_init(drm_device_t * dev)
+int drm_bo_driver_init(struct drm_device * dev)
 {
-	drm_bo_driver_t *driver = dev->driver->bo_driver;
-	drm_buffer_manager_t *bm = &dev->bm;
+	struct drm_bo_driver *driver = dev->driver->bo_driver;
+	struct drm_buffer_manager *bm = &dev->bm;
 	int ret = -EINVAL;
 
 	mutex_lock(&dev->bm.init_mutex);
@@ -2151,8 +2428,7 @@ int drm_bo_driver_init(drm_device_t * dev)
 	 * Initialize the system memory buffer type.
 	 * Other types need to be driver / IOCTL initialized.
 	 */
-
-	ret = drm_bo_init_mm(dev, 0, 0, 0);
+	ret = drm_bo_init_mm(dev, DRM_BO_MEM_LOCAL, 0, 0);
 	if (ret)
 		goto out_unlock;
 
@@ -2175,81 +2451,150 @@ int drm_bo_driver_init(drm_device_t * dev)
 
 EXPORT_SYMBOL(drm_bo_driver_init);
 
-int drm_mm_init_ioctl(DRM_IOCTL_ARGS)
+int drm_mm_init_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv)
 {
-	DRM_DEVICE;
+	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;
 
-	int ret = 0;
-	drm_mm_init_arg_t arg;
-	drm_buffer_manager_t *bm = &dev->bm;
-	drm_bo_driver_t *driver = dev->driver->bo_driver;
+	DRM_DEBUG("drm_mm_init_ioctl: type %d, 0x%08llx offset, %dkb\n",
+	    arg->mem_type, arg->p_offset * PAGE_SIZE, (int)(arg->p_size * 4));
 
 	if (!driver) {
 		DRM_ERROR("Buffer objects are not supported by this driver\n");
 		return -EINVAL;
 	}
 
-	DRM_COPY_FROM_USER_IOCTL(arg, (void __user *)data, sizeof(arg));
+	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;
+	}
+	if (arg->minor > DRM_BO_INIT_MINOR) {
+		DRM_ERROR("libdrm expects a newer DRM buffer object interface.\n"
+			  "\tlibdrm buffer object interface version is %d.%d.\n"
+			  "\tkernel DRM buffer object interface version is %d.%d\n",
+			  arg->major, arg->minor, DRM_BO_INIT_MAJOR, DRM_BO_INIT_MINOR);
+		return -EINVAL;
+	}
 
-	switch (arg.req.op) {
-	case mm_init:
-		ret = -EINVAL;
-		mutex_lock(&dev->bm.init_mutex);
-		mutex_lock(&dev->struct_mutex);
-		if (!bm->initialized) {
-			DRM_ERROR("DRM memory manager was not initialized.\n");
-			break;
-		}
-		if (arg.req.mem_type == 0) {
-			DRM_ERROR
-			    ("System memory buffers already initialized.\n");
-			break;
-		}
-		ret = drm_bo_init_mm(dev, arg.req.mem_type,
-				     arg.req.p_offset, arg.req.p_size);
-		break;
-	case mm_takedown:
-		LOCK_TEST_WITH_RETURN(dev, filp);
-		mutex_lock(&dev->bm.init_mutex);
-		mutex_lock(&dev->struct_mutex);
-		ret = -EINVAL;
-		if (!bm->initialized) {
-			DRM_ERROR("DRM memory manager was not initialized\n");
-			break;
-		}
-		if (arg.req.mem_type == 0) {
-			DRM_ERROR("No takedown for System memory buffers.\n");
-			break;
-		}
-		ret = 0;
-		if (drm_bo_clean_mm(dev, arg.req.mem_type)) {
-			DRM_ERROR("Memory manager type %d not clean. "
-				  "Delaying takedown\n", arg.req.mem_type);
-		}
-		break;
-	case mm_lock:
-		LOCK_TEST_WITH_RETURN(dev, filp);
-		mutex_lock(&dev->bm.init_mutex);
-		mutex_lock(&dev->struct_mutex);
-		ret = drm_bo_lock_mm(dev, arg.req.mem_type);
-		break;
-	case mm_unlock:
-		LOCK_TEST_WITH_RETURN(dev, filp);
-		mutex_lock(&dev->bm.init_mutex);
-		mutex_lock(&dev->struct_mutex);
-		ret = 0;
-		break;
-	default:
-		DRM_ERROR("Function not implemented yet\n");
+	mutex_lock(&dev->bm.init_mutex);
+	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);
+
+out:
+	mutex_unlock(&dev->struct_mutex);
+	mutex_unlock(&dev->bm.init_mutex);
+	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;
+
+	DRM_DEBUG("drm_mm_takedown_ioctl: %d type\n", arg->mem_type);
+
+	if (!driver) {
+		DRM_ERROR("Buffer objects are not supported by this driver\n");
+		return -EINVAL;
+	}
+
+	LOCK_TEST_WITH_RETURN(dev, file_priv);
+	mutex_lock(&dev->bm.init_mutex);
+	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 (drm_bo_clean_mm(dev, arg->mem_type)) {
+		DRM_ERROR("Memory manager type %d not clean. "
+			  "Delaying takedown\n", arg->mem_type);
+	}
+out:
+	mutex_unlock(&dev->struct_mutex);
+	mutex_unlock(&dev->bm.init_mutex);
+	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;
+
+	DRM_DEBUG("drm_mm_lock_ioctl: %d type\n", arg->mem_type);
+
+	if (!driver) {
+		DRM_ERROR("Buffer objects are not supported by this driver\n");
 		return -EINVAL;
 	}
 
+	LOCK_TEST_WITH_RETURN(dev, file_priv);
+	mutex_lock(&dev->bm.init_mutex);
+	mutex_lock(&dev->struct_mutex);
+	ret = drm_bo_lock_mm(dev, arg->mem_type);
+	mutex_unlock(&dev->struct_mutex);
+	mutex_unlock(&dev->bm.init_mutex);
+	if (ret)
+		return ret;
+
+	return 0;
+}
+
+int drm_mm_unlock_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv)
+{
+	struct drm_bo_driver *driver = dev->driver->bo_driver;
+	int ret;
+
+	DRM_DEBUG("drm_mm_unlock_ioctl\n");
+
+	if (!driver) {
+		DRM_ERROR("Buffer objects are not supported by this driver\n");
+		return -EINVAL;
+	}
+
+	LOCK_TEST_WITH_RETURN(dev, file_priv);
+	mutex_lock(&dev->bm.init_mutex);
+	mutex_lock(&dev->struct_mutex);
+	ret = 0;
+
 	mutex_unlock(&dev->struct_mutex);
 	mutex_unlock(&dev->bm.init_mutex);
 	if (ret)
 		return ret;
 
-	DRM_COPY_TO_USER_IOCTL((void __user *)data, arg, sizeof(arg));
 	return 0;
 }
 
@@ -2257,10 +2602,10 @@ int drm_mm_init_ioctl(DRM_IOCTL_ARGS)
  * buffer object vm functions.
  */
 
-int drm_mem_reg_is_pci(drm_device_t * dev, drm_bo_mem_reg_t * mem)
+int drm_mem_reg_is_pci(struct drm_device * dev, struct drm_bo_mem_reg * mem)
 {
-	drm_buffer_manager_t *bm = &dev->bm;
-	drm_mem_type_manager_t *man = &bm->man[mem->mem_type];
+	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)
@@ -2291,13 +2636,13 @@ EXPORT_SYMBOL(drm_mem_reg_is_pci);
  * Otherwise returns zero.
  */
 
-int drm_bo_pci_offset(drm_device_t * dev,
-		      drm_bo_mem_reg_t * mem,
+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)
 {
-	drm_buffer_manager_t *bm = &dev->bm;
-	drm_mem_type_manager_t *man = &bm->man[mem->mem_type];
+	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))
@@ -2320,9 +2665,9 @@ int drm_bo_pci_offset(drm_device_t * dev,
  * Call bo->mutex locked.
  */
 
-void drm_bo_unmap_virtual(drm_buffer_object_t * bo)
+void drm_bo_unmap_virtual(struct drm_buffer_object * bo)
 {
-	drm_device_t *dev = bo->dev;
+	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;
 
@@ -2332,11 +2677,11 @@ void drm_bo_unmap_virtual(drm_buffer_object_t * bo)
 	unmap_mapping_range(dev->dev_mapping, offset, holelen, 1);
 }
 
-static void drm_bo_takedown_vm_locked(drm_buffer_object_t * bo)
+static void drm_bo_takedown_vm_locked(struct drm_buffer_object * bo)
 {
-	drm_map_list_t *list = &bo->map_list;
+	struct drm_map_list *list = &bo->map_list;
 	drm_local_map_t *map;
-	drm_device_t *dev = bo->dev;
+	struct drm_device *dev = bo->dev;
 
 	DRM_ASSERT_LOCKED(&dev->struct_mutex);
 	if (list->user_token) {
@@ -2358,11 +2703,11 @@ static void drm_bo_takedown_vm_locked(drm_buffer_object_t * bo)
 	drm_bo_usage_deref_locked(&bo);
 }
 
-static int drm_bo_setup_vm_locked(drm_buffer_object_t * bo)
+static int drm_bo_setup_vm_locked(struct drm_buffer_object * bo)
 {
-	drm_map_list_t *list = &bo->map_list;
+	struct drm_map_list *list = &bo->map_list;
 	drm_local_map_t *map;
-	drm_device_t *dev = bo->dev;
+	struct drm_device *dev = bo->dev;
 
 	DRM_ASSERT_LOCKED(&dev->struct_mutex);
 	list->map = drm_ctl_calloc(1, sizeof(*map), DRM_MEM_BUFOBJ);
@@ -2394,7 +2739,7 @@ static int drm_bo_setup_vm_locked(drm_buffer_object_t * bo)
 		return -ENOMEM;
 	}
 
-	list->user_token = ((drm_u64_t) list->hash.key) << PAGE_SHIFT;
+	list->user_token = ((uint64_t) list->hash.key) << PAGE_SHIFT;
 
 	return 0;
 }