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

[linux-2.6-omap-h63xx.git] / drivers / char / drm / i915_irq.c

diff --git a/drivers/char/drm/i915_irq.c b/drivers/char/drm/i915_irq.c
index 36be24e2e8d40544cb127ae0b65b22c8a785f21d..380c3f38721850d74e40b020547af1632eac5ee4 100644 (file)
--- 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;
 }