Merge branch 'drm-patches' of ssh://master.kernel.org/pub/scm/linux/kernel/git/airlied/drm-2.6

* 'drm-patches' of ssh://master.kernel.org/pub/scm/linux/kernel/git/airlied/drm-2.6:
  via invalid device ids removal
  radeon: Commit the ring after each partial texture upload blit.
  i915: fix vbl swap allocation size.
  drm: Replace DRM_IOCTL_ARGS with (dev, data, file_priv) and remove DRM_DEVICE.
  drm: remove XFREE86_VERSION macros.
  drm: Replace filp in ioctl arguments with drm_file *file_priv.
  drm: Remove DRM_ERR OS macro.

1 files changed, 56 insertions, 72 deletions

diff --git a/drivers/char/drm/i915_irq.c b/drivers/char/drm/i915_irq.c
index bb8e9e9c8201..a443f4a202e3 100644
--- a/drivers/char/drm/i915_irq.c
+++ b/drivers/char/drm/i915_irq.c
@@ -311,7 +311,7 @@ static int i915_wait_irq(struct drm_device * dev, int irq_nr)
         DRM_WAIT_ON(ret, dev_priv->irq_queue, 3 * DRM_HZ,
                     READ_BREADCRUMB(dev_priv) >= irq_nr);
 
-        if (ret == DRM_ERR(EBUSY)) {
+        if (ret == -EBUSY) {
                 DRM_ERROR("%s: EBUSY -- rec: %d emitted: %d\n",
                           __FUNCTION__,
                           READ_BREADCRUMB(dev_priv), (int)dev_priv->counter);
@@ -330,7 +330,7 @@ static int i915_driver_vblank_do_wait(struct drm_device *dev, unsigned int *sequ
 
         if (!dev_priv) {
                 DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
-                return DRM_ERR(EINVAL);
+                return -EINVAL;
         }
 
         DRM_WAIT_ON(ret, dev->vbl_queue, 3 * DRM_HZ,
@@ -355,28 +355,25 @@ 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, filp);
+        LOCK_TEST_WITH_RETURN(dev, file_priv);
 
         if (!dev_priv) {
                 DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
-                return DRM_ERR(EINVAL);
+                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 DRM_ERR(EFAULT);
+                return -EFAULT;
         }
 
         return 0;
@@ -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 DRM_ERR(EINVAL);
+                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,64 +411,60 @@ 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 DRM_ERR(EINVAL);
+                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);
-                return DRM_ERR(EINVAL);
+                          __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) {
                 DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
-                return DRM_ERR(EINVAL);
+                return -EINVAL;
         }
 
         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;
@@ -482,38 +472,35 @@ int i915_vblank_swap(DRM_IOCTL_ARGS)
 
         if (!dev_priv) {
                 DRM_ERROR("%s called with no initialization\n", __func__);
-                return DRM_ERR(EINVAL);
+                return -EINVAL;
         }
 
         if (dev_priv->sarea_priv->rotation) {
                 DRM_DEBUG("Rotation not supported\n");
-                return DRM_ERR(EINVAL);
+                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);
-                return DRM_ERR(EINVAL);
+                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);
-                return DRM_ERR(EINVAL);
+                return -EINVAL;
         }
 
         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);
-                return DRM_ERR(EINVAL);
+                DRM_DEBUG("Invalid drawable ID %d\n", swap->drawable);
+                return -EINVAL;
         }
 
         spin_unlock_irqrestore(&dev->drw_lock, irqflags);
@@ -521,14 +508,14 @@ 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 DRM_ERR(EINVAL);
+                        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;
@@ -550,21 +537,21 @@ int i915_vblank_swap(DRM_IOCTL_ARGS)
 
         if (dev_priv->swaps_pending >= 100) {
                 DRM_DEBUG("Too many swaps queued\n");
-                return DRM_ERR(EBUSY);
+                return -EBUSY;
         }
 
-        vbl_swap = drm_calloc(1, sizeof(vbl_swap), DRM_MEM_DRIVER);
+        vbl_swap = drm_calloc(1, sizeof(*vbl_swap), DRM_MEM_DRIVER);
 
         if (!vbl_swap) {
                 DRM_ERROR("Failed to allocate memory to queue swap\n");
-                return DRM_ERR(ENOMEM);
+                return -ENOMEM;
         }
 
         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;
 }