Revert "drm/ttm: cleanup most of fence ioctl split out"

This reverts commit 3dfc1400e9fc58c69292d7cf7c2e1653fa5e6991.

this shouldn't have gone on master yet

5 files changed, 44 insertions, 362 deletions

diff --git a/libdrm/xf86drm.c b/libdrm/xf86drm.c
index e0d20ee8..bee50824 100644
--- a/libdrm/xf86drm.c
+++ b/libdrm/xf86drm.c
@@ -2272,7 +2272,8 @@ int drmFenceCreate(int fd, unsigned flags, int class, unsigned type,
     arg.flags = flags;
     arg.type = type;
     arg.class = class;
-    if (ioctl(fd, DRM_IOCTL_FENCE_CREATE, &arg))
+    arg.op = drm_fence_create;
+    if (ioctl(fd, DRM_IOCTL_FENCE, &arg))
 	return -errno;
     fence->handle = arg.handle;
     fence->class = arg.class;
@@ -2294,8 +2295,8 @@ int drmFenceBuffers(int fd, unsigned flags, drmFence *fence)
     
     memset(&arg, 0, sizeof(arg));
     arg.flags = flags;
-
-    if (ioctl(fd, DRM_IOCTL_FENCE_BUFFERS, &arg))
+    arg.op = drm_fence_buffers;
+    if (ioctl(fd, DRM_IOCTL_FENCE, &arg))
 	return -errno;
     fence->handle = arg.handle;
     fence->class = arg.class;
@@ -2311,8 +2312,8 @@ int drmFenceDestroy(int fd, const drmFence *fence)
    
     memset(&arg, 0, sizeof(arg));
     arg.handle = fence->handle;
-
-    if (ioctl(fd, DRM_IOCTL_FENCE_DESTROY, &arg))
+    arg.op = drm_fence_destroy;
+    if (ioctl(fd, DRM_IOCTL_FENCE, &arg))
 	return -errno;
     return 0;
 }
@@ -2323,8 +2324,8 @@ int drmFenceReference(int fd, unsigned handle, drmFence *fence)
    
     memset(&arg, 0, sizeof(arg));
     arg.handle = handle;
-
-    if (ioctl(fd, DRM_IOCTL_FENCE_REFERENCE, &arg))
+    arg.op = drm_fence_reference;
+    if (ioctl(fd, DRM_IOCTL_FENCE, &arg))
 	return -errno;
     fence->handle = arg.handle;
     fence->class = arg.class;
@@ -2340,8 +2341,8 @@ int drmFenceUnreference(int fd, const drmFence *fence)
    
     memset(&arg, 0, sizeof(arg));
     arg.handle = fence->handle;
-
-    if (ioctl(fd, DRM_IOCTL_FENCE_UNREFERENCE, &arg))
+    arg.op = drm_fence_unreference;
+    if (ioctl(fd, DRM_IOCTL_FENCE, &arg))
 	return -errno;
     return 0;
 }
@@ -2353,8 +2354,8 @@ int drmFenceFlush(int fd, drmFence *fence, unsigned flush_type)
     memset(&arg, 0, sizeof(arg));
     arg.handle = fence->handle;
     arg.type = flush_type;
-
-    if (ioctl(fd, DRM_IOCTL_FENCE_FLUSH, &arg))
+    arg.op = drm_fence_flush;
+    if (ioctl(fd, DRM_IOCTL_FENCE, &arg))
 	return -errno;
     fence->class = arg.class;
     fence->type = arg.type;
@@ -2368,8 +2369,8 @@ int drmFenceUpdate(int fd, drmFence *fence)
 	
     memset(&arg, 0, sizeof(arg));
     arg.handle = fence->handle;
-
-    if (ioctl(fd, DRM_IOCTL_FENCE_SIGNALED, &arg))
+    arg.op = drm_fence_signaled;
+    if (ioctl(fd, DRM_IOCTL_FENCE, &arg))
 	return -errno;
     fence->class = arg.class;
     fence->type = arg.type;
@@ -2412,8 +2413,8 @@ int drmFenceEmit(int fd, unsigned flags, drmFence *fence, unsigned emit_type)
     arg.flags = flags;
     arg.handle = fence->handle;
     arg.type = emit_type;
-
-    if (ioctl(fd, DRM_IOCTL_FENCE_EMIT, &arg))
+    arg.op = drm_fence_emit;
+    if (ioctl(fd, DRM_IOCTL_FENCE, &arg))
 	return -errno;
     fence->class = arg.class;
     fence->type = arg.type;
@@ -2446,9 +2447,9 @@ int drmFenceWait(int fd, unsigned flags, drmFence *fence, unsigned flush_type)
     arg.handle = fence->handle;
     arg.type = flush_type;
     arg.flags = flags;
-
+    arg.op = drm_fence_wait;
     do {
-	ret = ioctl(fd, DRM_IOCTL_FENCE_WAIT, &arg);
+	ret = ioctl(fd, DRM_IOCTL_FENCE, &arg);
     } while (ret != 0 && errno == EAGAIN);
 
     if (ret)
diff --git a/linux-core/drm_drv.c b/linux-core/drm_drv.c
index edf22d4c..43a9858d 100644
--- a/linux-core/drm_drv.c
+++ b/linux-core/drm_drv.c
@@ -117,7 +117,7 @@ static drm_ioctl_desc_t drm_ioctls[] = {
 	[DRM_IOCTL_NR(DRM_IOCTL_SG_FREE)] = {drm_sg_free, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
 
 	[DRM_IOCTL_NR(DRM_IOCTL_WAIT_VBLANK)] = {drm_wait_vblank, 0},
-
+	[DRM_IOCTL_NR(DRM_IOCTL_FENCE)] = {drm_fence_ioctl, DRM_AUTH},
 	[DRM_IOCTL_NR(DRM_IOCTL_BUFOBJ)] = {drm_bo_ioctl, DRM_AUTH},
 
 	[DRM_IOCTL_NR(DRM_IOCTL_UPDATE_DRAW)] = {drm_update_drawable_info, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
@@ -131,17 +131,6 @@ static drm_ioctl_desc_t drm_ioctls[] = {
 					     DRM_AUTH },
 	[DRM_IOCTL_NR(DRM_IOCTL_MM_UNLOCK)] = {drm_mm_unlock_ioctl, 
 					     DRM_AUTH },
-
-	[DRM_IOCTL_NR(DRM_IOCTL_FENCE_CREATE)] = {drm_fence_create_ioctl, DRM_AUTH},
-	[DRM_IOCTL_NR(DRM_IOCTL_FENCE_DESTROY)] = {drm_fence_destroy_ioctl, DRM_AUTH},
-	[DRM_IOCTL_NR(DRM_IOCTL_FENCE_REFERENCE)] = {drm_fence_reference_ioctl, DRM_AUTH},
-	[DRM_IOCTL_NR(DRM_IOCTL_FENCE_UNREFERENCE)] = {drm_fence_unreference_ioctl, DRM_AUTH},
-	[DRM_IOCTL_NR(DRM_IOCTL_FENCE_SIGNALED)] = {drm_fence_signaled_ioctl, DRM_AUTH},
-	[DRM_IOCTL_NR(DRM_IOCTL_FENCE_FLUSH)] = {drm_fence_flush_ioctl, DRM_AUTH},
-	[DRM_IOCTL_NR(DRM_IOCTL_FENCE_WAIT)] = {drm_fence_wait_ioctl, DRM_AUTH},
-	[DRM_IOCTL_NR(DRM_IOCTL_FENCE_EMIT)] = {drm_fence_emit_ioctl, DRM_AUTH},
-	[DRM_IOCTL_NR(DRM_IOCTL_FENCE_BUFFERS)] = {drm_fence_buffers_ioctl, DRM_AUTH},
-
 };
 
 #define DRM_CORE_IOCTL_COUNT	ARRAY_SIZE( drm_ioctls )
diff --git a/linux-core/drm_fence.c b/linux-core/drm_fence.c
index fe11e87b..ce161dc3 100644
--- a/linux-core/drm_fence.c
+++ b/linux-core/drm_fence.c
@@ -659,313 +659,3 @@ int drm_fence_ioctl(DRM_IOCTL_ARGS)
 	DRM_COPY_TO_USER_IOCTL((void __user *)data, arg, sizeof(arg));
 	return ret;
 }
-
-int drm_fence_create_ioctl(DRM_IOCTL_ARGS)
-{
-	DRM_DEVICE;
-	int ret;
-	drm_fence_manager_t *fm = &dev->fm;
-	drm_fence_arg_t arg;
-	drm_fence_object_t *fence;
-	unsigned long flags;
-	ret = 0;
-
-	if (!fm->initialized) {
-		DRM_ERROR("The DRM driver does not support fencing.\n");
-		return -EINVAL;
-	}
-
-	DRM_COPY_FROM_USER_IOCTL(arg, (void __user *)data, sizeof(arg));
-
-	if (arg.flags & DRM_FENCE_FLAG_EMIT)
-		LOCK_TEST_WITH_RETURN(dev, filp);
-	ret = drm_fence_object_create(dev, arg.class,
-				      arg.type, arg.flags, &fence);
-	if (ret)
-		return ret;
-	ret = drm_fence_add_user_object(priv, fence,
-					arg.flags &
-					DRM_FENCE_FLAG_SHAREABLE);
-	if (ret) {
-		drm_fence_usage_deref_unlocked(dev, fence);
-		return ret;
-	}
-	
-	/*
-	 * usage > 0. No need to lock dev->struct_mutex;
-	 */
-	
-	atomic_inc(&fence->usage);
-	arg.handle = fence->base.hash.key;
-
-	read_lock_irqsave(&fm->lock, flags);
-	arg.class = fence->class;
-	arg.type = fence->type;
-	arg.signaled = fence->signaled;
-	read_unlock_irqrestore(&fm->lock, flags);
-	drm_fence_usage_deref_unlocked(dev, fence);
-
-	DRM_COPY_TO_USER_IOCTL((void __user *)data, arg, sizeof(arg));
-	return ret;
-}
-
-int drm_fence_destroy_ioctl(DRM_IOCTL_ARGS)
-{
-	DRM_DEVICE;
-	int ret;
-	drm_fence_manager_t *fm = &dev->fm;
-	drm_fence_arg_t arg;
-	drm_user_object_t *uo;
-	ret = 0;
-
-	if (!fm->initialized) {
-		DRM_ERROR("The DRM driver does not support fencing.\n");
-		return -EINVAL;
-	}
-
-	DRM_COPY_FROM_USER_IOCTL(arg, (void __user *)data, sizeof(arg));
-
-	mutex_lock(&dev->struct_mutex);
-	uo = drm_lookup_user_object(priv, arg.handle);
-	if (!uo || (uo->type != drm_fence_type) || uo->owner != priv) {
-		mutex_unlock(&dev->struct_mutex);
-		return -EINVAL;
-	}
-	ret = drm_remove_user_object(priv, uo);
-	mutex_unlock(&dev->struct_mutex);
-	return ret;
-}
-
-
-int drm_fence_reference_ioctl(DRM_IOCTL_ARGS)
-{
-	DRM_DEVICE;
-	int ret;
-	drm_fence_manager_t *fm = &dev->fm;
-	drm_fence_arg_t arg;
-	drm_fence_object_t *fence;
-	drm_user_object_t *uo;
-	unsigned long flags;
-	ret = 0;
-
-	if (!fm->initialized) {
-		DRM_ERROR("The DRM driver does not support fencing.\n");
-		return -EINVAL;
-	}
-
-	DRM_COPY_FROM_USER_IOCTL(arg, (void __user *)data, sizeof(arg));
-	ret = drm_user_object_ref(priv, arg.handle, drm_fence_type, &uo);
-	if (ret)
-		return ret;
-	fence = drm_lookup_fence_object(priv, arg.handle);
-
-	read_lock_irqsave(&fm->lock, flags);
-	arg.class = fence->class;
-	arg.type = fence->type;
-	arg.signaled = fence->signaled;
-	read_unlock_irqrestore(&fm->lock, flags);
-	drm_fence_usage_deref_unlocked(dev, fence);
-
-	DRM_COPY_TO_USER_IOCTL((void __user *)data, arg, sizeof(arg));
-	return ret;
-}
-
-
-int drm_fence_unreference_ioctl(DRM_IOCTL_ARGS)
-{
-	DRM_DEVICE;
-	int ret;
-	drm_fence_manager_t *fm = &dev->fm;
-	drm_fence_arg_t arg;
-	ret = 0;
-
-	if (!fm->initialized) {
-		DRM_ERROR("The DRM driver does not support fencing.\n");
-		return -EINVAL;
-	}
-
-	DRM_COPY_FROM_USER_IOCTL(arg, (void __user *)data, sizeof(arg));
-	return drm_user_object_unref(priv, arg.handle, drm_fence_type);
-}
-
-int drm_fence_signaled_ioctl(DRM_IOCTL_ARGS)
-{
-	DRM_DEVICE;
-	int ret;
-	drm_fence_manager_t *fm = &dev->fm;
-	drm_fence_arg_t arg;
-	drm_fence_object_t *fence;
-	unsigned long flags;
-	ret = 0;
-
-	if (!fm->initialized) {
-		DRM_ERROR("The DRM driver does not support fencing.\n");
-		return -EINVAL;
-	}
-
-	DRM_COPY_FROM_USER_IOCTL(arg, (void __user *)data, sizeof(arg));
-
-	fence = drm_lookup_fence_object(priv, arg.handle);
-	if (!fence)
-		return -EINVAL;
-
-	read_lock_irqsave(&fm->lock, flags);
-	arg.class = fence->class;
-	arg.type = fence->type;
-	arg.signaled = fence->signaled;
-	read_unlock_irqrestore(&fm->lock, flags);
-	drm_fence_usage_deref_unlocked(dev, fence);
-
-	DRM_COPY_TO_USER_IOCTL((void __user *)data, arg, sizeof(arg));
-	return ret;
-}
-
-int drm_fence_flush_ioctl(DRM_IOCTL_ARGS)
-{
-	DRM_DEVICE;
-	int ret;
-	drm_fence_manager_t *fm = &dev->fm;
-	drm_fence_arg_t arg;
-	drm_fence_object_t *fence;
-	unsigned long flags;
-	ret = 0;
-
-	if (!fm->initialized) {
-		DRM_ERROR("The DRM driver does not support fencing.\n");
-		return -EINVAL;
-	}
-
-	DRM_COPY_FROM_USER_IOCTL(arg, (void __user *)data, sizeof(arg));
-
-	fence = drm_lookup_fence_object(priv, arg.handle);
-	if (!fence)
-		return -EINVAL;
-	ret = drm_fence_object_flush(dev, fence, arg.type);
-
-	read_lock_irqsave(&fm->lock, flags);
-	arg.class = fence->class;
-	arg.type = fence->type;
-	arg.signaled = fence->signaled;
-	read_unlock_irqrestore(&fm->lock, flags);
-	drm_fence_usage_deref_unlocked(dev, fence);
-
-	DRM_COPY_TO_USER_IOCTL((void __user *)data, arg, sizeof(arg));
-	return ret;
-}
-
-
-int drm_fence_wait_ioctl(DRM_IOCTL_ARGS)
-{
-	DRM_DEVICE;
-	int ret;
-	drm_fence_manager_t *fm = &dev->fm;
-	drm_fence_arg_t arg;
-	drm_fence_object_t *fence;
-	unsigned long flags;
-	ret = 0;
-
-	if (!fm->initialized) {
-		DRM_ERROR("The DRM driver does not support fencing.\n");
-		return -EINVAL;
-	}
-
-	DRM_COPY_FROM_USER_IOCTL(arg, (void __user *)data, sizeof(arg));
-
-	fence = drm_lookup_fence_object(priv, arg.handle);
-	if (!fence)
-		return -EINVAL;
-	ret = drm_fence_object_wait(dev, fence,
-				    arg.flags & DRM_FENCE_FLAG_WAIT_LAZY,
-				    0, arg.type);
-
-	read_lock_irqsave(&fm->lock, flags);
-	arg.class = fence->class;
-	arg.type = fence->type;
-	arg.signaled = fence->signaled;
-	read_unlock_irqrestore(&fm->lock, flags);
-	drm_fence_usage_deref_unlocked(dev, fence);
-
-	DRM_COPY_TO_USER_IOCTL((void __user *)data, arg, sizeof(arg));
-	return ret;
-}
-
-
-int drm_fence_emit_ioctl(DRM_IOCTL_ARGS)
-{
-	DRM_DEVICE;
-	int ret;
-	drm_fence_manager_t *fm = &dev->fm;
-	drm_fence_arg_t arg;
-	drm_fence_object_t *fence;
-	unsigned long flags;
-	ret = 0;
-
-	if (!fm->initialized) {
-		DRM_ERROR("The DRM driver does not support fencing.\n");
-		return -EINVAL;
-	}
-
-	DRM_COPY_FROM_USER_IOCTL(arg, (void __user *)data, sizeof(arg));
-
-	LOCK_TEST_WITH_RETURN(dev, filp);
-	fence = drm_lookup_fence_object(priv, arg.handle);
-	if (!fence)
-		return -EINVAL;
-	ret = drm_fence_object_emit(dev, fence, arg.flags, arg.class,
-				    arg.type);
-
-	read_lock_irqsave(&fm->lock, flags);
-	arg.class = fence->class;
-	arg.type = fence->type;
-	arg.signaled = fence->signaled;
-	read_unlock_irqrestore(&fm->lock, flags);
-	drm_fence_usage_deref_unlocked(dev, fence);
-
-	DRM_COPY_TO_USER_IOCTL((void __user *)data, arg, sizeof(arg));
-	return ret;
-}
-
-int drm_fence_buffers_ioctl(DRM_IOCTL_ARGS)
-{
-	DRM_DEVICE;
-	int ret;
-	drm_fence_manager_t *fm = &dev->fm;
-	drm_fence_arg_t arg;
-	drm_fence_object_t *fence;
-	unsigned long flags;
-	ret = 0;
-
-	if (!fm->initialized) {
-		DRM_ERROR("The DRM driver does not support fencing.\n");
-		return -EINVAL;
-	}
-
-	DRM_COPY_FROM_USER_IOCTL(arg, (void __user *)data, sizeof(arg));
-
-	if (!dev->bm.initialized) {
-		DRM_ERROR("Buffer object manager is not initialized\n");
-		return -EINVAL;
-	}
-	LOCK_TEST_WITH_RETURN(dev, filp);
-	ret = drm_fence_buffer_objects(priv, NULL, arg.flags,
-				       NULL, &fence);
-	if (ret)
-		return ret;
-	ret = drm_fence_add_user_object(priv, fence,
-					arg.flags &
-					DRM_FENCE_FLAG_SHAREABLE);
-	if (ret)
-		return ret;
-	atomic_inc(&fence->usage);
-	arg.handle = fence->base.hash.key;
-
-	read_lock_irqsave(&fm->lock, flags);
-	arg.class = fence->class;
-	arg.type = fence->type;
-	arg.signaled = fence->signaled;
-	read_unlock_irqrestore(&fm->lock, flags);
-	drm_fence_usage_deref_unlocked(dev, fence);
-
-	DRM_COPY_TO_USER_IOCTL((void __user *)data, arg, sizeof(arg));
-	return ret;
-}
diff --git a/linux-core/drm_objects.h b/linux-core/drm_objects.h
index 9576f28a..7f9c8c37 100644
--- a/linux-core/drm_objects.h
+++ b/linux-core/drm_objects.h
@@ -211,16 +211,8 @@ extern int drm_fence_object_create(struct drm_device *dev, uint32_t type,
 				   drm_fence_object_t ** c_fence);
 extern int drm_fence_add_user_object(drm_file_t * priv,
 				     drm_fence_object_t * fence, int shareable);
+extern int drm_fence_ioctl(DRM_IOCTL_ARGS);
 
-extern int drm_fence_create_ioctl(DRM_IOCTL_ARGS);
-extern int drm_fence_destroy_ioctl(DRM_IOCTL_ARGS);
-extern int drm_fence_reference_ioctl(DRM_IOCTL_ARGS);
-extern int drm_fence_unreference_ioctl(DRM_IOCTL_ARGS);
-extern int drm_fence_signaled_ioctl(DRM_IOCTL_ARGS);
-extern int drm_fence_flush_ioctl(DRM_IOCTL_ARGS);
-extern int drm_fence_wait_ioctl(DRM_IOCTL_ARGS);
-extern int drm_fence_emit_ioctl(DRM_IOCTL_ARGS);
-extern int drm_fence_buffers_ioctl(DRM_IOCTL_ARGS);
 /**************************************************
  *TTMs
  */
diff --git a/shared-core/drm.h b/shared-core/drm.h
index 9810321e..d561a082 100644
--- a/shared-core/drm.h
+++ b/shared-core/drm.h
@@ -677,6 +677,17 @@ typedef struct drm_fence_arg {
 	unsigned flags;
 	unsigned signaled;
 	unsigned expand_pad[4]; /*Future expansion */
+	enum {
+		drm_fence_create,
+		drm_fence_destroy,
+		drm_fence_reference,
+		drm_fence_unreference,
+		drm_fence_signaled,
+		drm_fence_flush,
+		drm_fence_wait,
+		drm_fence_emit,
+		drm_fence_buffers
+	} op;
 } drm_fence_arg_t;
 
 /* Buffer permissions, referring to how the GPU uses the buffers.
@@ -943,20 +954,19 @@ typedef struct drm_mm_init_arg {
 #define DRM_IOCTL_FENCE_SIGNALED        DRM_IOWR(0xc8, drm_fence_arg_t)
 #define DRM_IOCTL_FENCE_FLUSH           DRM_IOWR(0xc9, drm_fence_arg_t)
 #define DRM_IOCTL_FENCE_WAIT            DRM_IOWR(0xca, drm_fence_arg_t)
-#define DRM_IOCTL_FENCE_EMIT            DRM_IOWR(0xcb, drm_fence_arg_t)
-#define DRM_IOCTL_FENCE_BUFFERS         DRM_IOWR(0xcc, drm_fence_arg_t)
-
-#define DRM_IOCTL_BO_CREATE             DRM_IOWR(0xcd, drm_bo_arg_t)
-#define DRM_IOCTL_BO_DESTROY            DRM_IOWR(0xce, drm_bo_arg_t)
-#define DRM_IOCTL_BO_MAP                DRM_IOWR(0xcf, drm_bo_arg_t)
-#define DRM_IOCTL_BO_UNMAP              DRM_IOWR(0xd0, drm_bo_arg_t)
-#define DRM_IOCTL_BO_REFERENCE          DRM_IOWR(0xd1, drm_bo_arg_t)
-#define DRM_IOCTL_BO_UNREFERENCE        DRM_IOWR(0xd2, drm_bo_arg_t)
-#define DRM_IOCTL_BO_VALIDATE           DRM_IOWR(0xd3, drm_bo_arg_t)
-#define DRM_IOCTL_BO_FENCE              DRM_IOWR(0xd4, drm_bo_arg_t)
-#define DRM_IOCTL_BO_INFO               DRM_IOWR(0xd5, drm_bo_arg_t)
-#define DRM_IOCTL_BO_WAIT_IDLE          DRM_IOWR(0xd6, drm_bo_arg_t)
-#define DRM_IOCTL_BO_REF_FENCE          DRM_IOWR(0xd7, drm_bo_arg_t)
+#define DRM_IOCTL_FENCE_BUFFERS         DRM_IOWR(0xcb, drm_fence_arg_t)
+
+#define DRM_IOCTL_BO_CREATE             DRM_IOWR(0xcc, drm_bo_arg_t)
+#define DRM_IOCTL_BO_DESTROY            DRM_IOWR(0xcd, drm_bo_arg_t)
+#define DRM_IOCTL_BO_MAP                DRM_IOWR(0xce, drm_bo_arg_t)
+#define DRM_IOCTL_BO_UNMAP              DRM_IOWR(0xcf, drm_bo_arg_t)
+#define DRM_IOCTL_BO_REFERENCE          DRM_IOWR(0xd0, drm_bo_arg_t)
+#define DRM_IOCTL_BO_UNREFERENCE        DRM_IOWR(0xd1, drm_bo_arg_t)
+#define DRM_IOCTL_BO_VALIDATE           DRM_IOWR(0xd2, drm_bo_arg_t)
+#define DRM_IOCTL_BO_FENCE              DRM_IOWR(0xd3, drm_bo_arg_t)
+#define DRM_IOCTL_BO_INFO               DRM_IOWR(0xd4, drm_bo_arg_t)
+#define DRM_IOCTL_BO_WAIT_IDLE          DRM_IOWR(0xd5, drm_bo_arg_t)
+#define DRM_IOCTL_BO_REF_FENCE          DRM_IOWR(0xd6, drm_bo_arg_t)
 
 
 /*@}*/