drm: Replace DRM_IOCTL_ARGS with (dev, data, file_priv) and remove DRM_DEVICE.

The data is now in kernel space, copied in/out as appropriate according to t
This results in DRM_COPY_{TO,FROM}_USER going away, and error paths to deal
with those failures.  This also means that XFree86 4.2.0 support for i810 DR
is lost.

Signed-off-by: Dave Airlie <airlied@linux.ie>

1 files changed, 38 insertions, 54 deletions

diff --git a/drivers/char/drm/i915_irq.c b/drivers/char/drm/i915_irq.c
index 36be24e2e8d4..380c3f387218 100644
--- a/drivers/char/drm/i915_irq.c
+++ b/drivers/char/drm/i915_irq.c
@@ -355,11 +355,11 @@ int i915_driver_vblank_wait2(struct drm_device *dev, unsigned int *sequence)
 
 /* Needs the lock as it touches the ring.
  */
-int i915_irq_emit(DRM_IOCTL_ARGS)
+int i915_irq_emit(struct drm_device *dev, void *data,
+                         struct drm_file *file_priv)
 {
-        DRM_DEVICE;
         drm_i915_private_t *dev_priv = dev->dev_private;
-        drm_i915_irq_emit_t emit;
+        drm_i915_irq_emit_t *emit = data;
         int result;
 
         LOCK_TEST_WITH_RETURN(dev, file_priv);
@@ -369,12 +369,9 @@ int i915_irq_emit(DRM_IOCTL_ARGS)
                 return -EINVAL;
         }
 
-        DRM_COPY_FROM_USER_IOCTL(emit, (drm_i915_irq_emit_t __user *) data,
-                                 sizeof(emit));
-
         result = i915_emit_irq(dev);
 
-        if (DRM_COPY_TO_USER(emit.irq_seq, &result, sizeof(int))) {
+        if (DRM_COPY_TO_USER(emit->irq_seq, &result, sizeof(int))) {
                 DRM_ERROR("copy_to_user\n");
                 return -EFAULT;
         }
@@ -384,21 +381,18 @@ int i915_irq_emit(DRM_IOCTL_ARGS)
 
 /* Doesn't need the hardware lock.
  */
-int i915_irq_wait(DRM_IOCTL_ARGS)
+int i915_irq_wait(struct drm_device *dev, void *data,
+                         struct drm_file *file_priv)
 {
-        DRM_DEVICE;
         drm_i915_private_t *dev_priv = dev->dev_private;
-        drm_i915_irq_wait_t irqwait;
+        drm_i915_irq_wait_t *irqwait = data;
 
         if (!dev_priv) {
                 DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
                 return -EINVAL;
         }
 
-        DRM_COPY_FROM_USER_IOCTL(irqwait, (drm_i915_irq_wait_t __user *) data,
-                                 sizeof(irqwait));
-
-        return i915_wait_irq(dev, irqwait.irq_seq);
+        return i915_wait_irq(dev, irqwait->irq_seq);
 }
 
 static void i915_enable_interrupt (struct drm_device *dev)
@@ -417,38 +411,35 @@ static void i915_enable_interrupt (struct drm_device *dev)
 
 /* Set the vblank monitor pipe
  */
-int i915_vblank_pipe_set(DRM_IOCTL_ARGS)
+int i915_vblank_pipe_set(struct drm_device *dev, void *data,
+                         struct drm_file *file_priv)
 {
-        DRM_DEVICE;
         drm_i915_private_t *dev_priv = dev->dev_private;
-        drm_i915_vblank_pipe_t pipe;
+        drm_i915_vblank_pipe_t *pipe = data;
 
         if (!dev_priv) {
                 DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
                 return -EINVAL;
         }
 
-        DRM_COPY_FROM_USER_IOCTL(pipe, (drm_i915_vblank_pipe_t __user *) data,
-                                 sizeof(pipe));
-
-        if (pipe.pipe & ~(DRM_I915_VBLANK_PIPE_A|DRM_I915_VBLANK_PIPE_B)) {
+        if (pipe->pipe & ~(DRM_I915_VBLANK_PIPE_A|DRM_I915_VBLANK_PIPE_B)) {
                 DRM_ERROR("%s called with invalid pipe 0x%x\n", 
-                          __FUNCTION__, pipe.pipe);
+                          __FUNCTION__, pipe->pipe);
                 return -EINVAL;
         }
 
-        dev_priv->vblank_pipe = pipe.pipe;
+        dev_priv->vblank_pipe = pipe->pipe;
 
         i915_enable_interrupt (dev);
 
         return 0;
 }
 
-int i915_vblank_pipe_get(DRM_IOCTL_ARGS)
+int i915_vblank_pipe_get(struct drm_device *dev, void *data,
+                         struct drm_file *file_priv)
 {
-        DRM_DEVICE;
         drm_i915_private_t *dev_priv = dev->dev_private;
-        drm_i915_vblank_pipe_t pipe;
+        drm_i915_vblank_pipe_t *pipe = data;
         u16 flag;
 
         if (!dev_priv) {
@@ -457,24 +448,23 @@ int i915_vblank_pipe_get(DRM_IOCTL_ARGS)
         }
 
         flag = I915_READ(I915REG_INT_ENABLE_R);
-        pipe.pipe = 0;
+        pipe->pipe = 0;
         if (flag & VSYNC_PIPEA_FLAG)
-                pipe.pipe |= DRM_I915_VBLANK_PIPE_A;
+                pipe->pipe |= DRM_I915_VBLANK_PIPE_A;
         if (flag & VSYNC_PIPEB_FLAG)
-                pipe.pipe |= DRM_I915_VBLANK_PIPE_B;
-        DRM_COPY_TO_USER_IOCTL((drm_i915_vblank_pipe_t __user *) data, pipe,
-                                 sizeof(pipe));
+                pipe->pipe |= DRM_I915_VBLANK_PIPE_B;
+
         return 0;
 }
 
 /**
  * Schedule buffer swap at given vertical blank.
  */
-int i915_vblank_swap(DRM_IOCTL_ARGS)
+int i915_vblank_swap(struct drm_device *dev, void *data,
+                     struct drm_file *file_priv)
 {
-        DRM_DEVICE;
         drm_i915_private_t *dev_priv = dev->dev_private;
-        drm_i915_vblank_swap_t swap;
+        drm_i915_vblank_swap_t *swap = data;
         drm_i915_vbl_swap_t *vbl_swap;
         unsigned int pipe, seqtype, curseq;
         unsigned long irqflags;
@@ -490,18 +480,15 @@ int i915_vblank_swap(DRM_IOCTL_ARGS)
                 return -EINVAL;
         }
 
-        DRM_COPY_FROM_USER_IOCTL(swap, (drm_i915_vblank_swap_t __user *) data,
-                                 sizeof(swap));
-
-        if (swap.seqtype & ~(_DRM_VBLANK_RELATIVE | _DRM_VBLANK_ABSOLUTE |
+        if (swap->seqtype & ~(_DRM_VBLANK_RELATIVE | _DRM_VBLANK_ABSOLUTE |
                              _DRM_VBLANK_SECONDARY | _DRM_VBLANK_NEXTONMISS)) {
-                DRM_ERROR("Invalid sequence type 0x%x\n", swap.seqtype);
+                DRM_ERROR("Invalid sequence type 0x%x\n", swap->seqtype);
                 return -EINVAL;
         }
 
-        pipe = (swap.seqtype & _DRM_VBLANK_SECONDARY) ? 1 : 0;
+        pipe = (swap->seqtype & _DRM_VBLANK_SECONDARY) ? 1 : 0;
 
-        seqtype = swap.seqtype & (_DRM_VBLANK_RELATIVE | _DRM_VBLANK_ABSOLUTE);
+        seqtype = swap->seqtype & (_DRM_VBLANK_RELATIVE | _DRM_VBLANK_ABSOLUTE);
 
         if (!(dev_priv->vblank_pipe & (1 << pipe))) {
                 DRM_ERROR("Invalid pipe %d\n", pipe);
@@ -510,9 +497,9 @@ int i915_vblank_swap(DRM_IOCTL_ARGS)
 
         spin_lock_irqsave(&dev->drw_lock, irqflags);
 
-        if (!drm_get_drawable_info(dev, swap.drawable)) {
+        if (!drm_get_drawable_info(dev, swap->drawable)) {
                 spin_unlock_irqrestore(&dev->drw_lock, irqflags);
-                DRM_DEBUG("Invalid drawable ID %d\n", swap.drawable);
+                DRM_DEBUG("Invalid drawable ID %d\n", swap->drawable);
                 return -EINVAL;
         }
 
@@ -521,11 +508,11 @@ int i915_vblank_swap(DRM_IOCTL_ARGS)
         curseq = atomic_read(pipe ? &dev->vbl_received2 : &dev->vbl_received);
 
         if (seqtype == _DRM_VBLANK_RELATIVE)
-                swap.sequence += curseq;
+                swap->sequence += curseq;
 
-        if ((curseq - swap.sequence) <= (1<<23)) {
-                if (swap.seqtype & _DRM_VBLANK_NEXTONMISS) {
-                        swap.sequence = curseq + 1;
+        if ((curseq - swap->sequence) <= (1<<23)) {
+                if (swap->seqtype & _DRM_VBLANK_NEXTONMISS) {
+                        swap->sequence = curseq + 1;
                 } else {
                         DRM_DEBUG("Missed target sequence\n");
                         return -EINVAL;
@@ -537,9 +524,9 @@ int i915_vblank_swap(DRM_IOCTL_ARGS)
         list_for_each(list, &dev_priv->vbl_swaps.head) {
                 vbl_swap = list_entry(list, drm_i915_vbl_swap_t, head);
 
-                if (vbl_swap->drw_id == swap.drawable &&
+                if (vbl_swap->drw_id == swap->drawable &&
                     vbl_swap->pipe == pipe &&
-                    vbl_swap->sequence == swap.sequence) {
+                    vbl_swap->sequence == swap->sequence) {
                         spin_unlock_irqrestore(&dev_priv->swaps_lock, irqflags);
                         DRM_DEBUG("Already scheduled\n");
                         return 0;
@@ -562,9 +549,9 @@ int i915_vblank_swap(DRM_IOCTL_ARGS)
 
         DRM_DEBUG("\n");
 
-        vbl_swap->drw_id = swap.drawable;
+        vbl_swap->drw_id = swap->drawable;
         vbl_swap->pipe = pipe;
-        vbl_swap->sequence = swap.sequence;
+        vbl_swap->sequence = swap->sequence;
 
         spin_lock_irqsave(&dev_priv->swaps_lock, irqflags);
 
@@ -573,9 +560,6 @@ int i915_vblank_swap(DRM_IOCTL_ARGS)
 
         spin_unlock_irqrestore(&dev_priv->swaps_lock, irqflags);
 
-        DRM_COPY_TO_USER_IOCTL((drm_i915_vblank_swap_t __user *) data, swap,
-                               sizeof(swap));
-
         return 0;
 }