1 files changed, 61 insertions, 77 deletions

diff --git a/drivers/char/drm/r128_cce.c b/drivers/char/drm/r128_cce.c
index b163ed09bd81..7d550aba165e 100644
--- a/drivers/char/drm/r128_cce.c
+++ b/drivers/char/drm/r128_cce.c
@@ -129,7 +129,7 @@ static int r128_do_pixcache_flush(drm_r128_private_t * dev_priv)
 #if R128_FIFO_DEBUG
         DRM_ERROR("failed!\n");
 #endif
-        return DRM_ERR(EBUSY);
+        return -EBUSY;
 }
 
 static int r128_do_wait_for_fifo(drm_r128_private_t * dev_priv, int entries)
@@ -146,7 +146,7 @@ static int r128_do_wait_for_fifo(drm_r128_private_t * dev_priv, int entries)
 #if R128_FIFO_DEBUG
         DRM_ERROR("failed!\n");
 #endif
-        return DRM_ERR(EBUSY);
+        return -EBUSY;
 }
 
 static int r128_do_wait_for_idle(drm_r128_private_t * dev_priv)
@@ -168,7 +168,7 @@ static int r128_do_wait_for_idle(drm_r128_private_t * dev_priv)
 #if R128_FIFO_DEBUG
         DRM_ERROR("failed!\n");
 #endif
-        return DRM_ERR(EBUSY);
+        return -EBUSY;
 }
 
 /* ================================================================
@@ -227,7 +227,7 @@ int r128_do_cce_idle(drm_r128_private_t * dev_priv)
         DRM_ERROR("failed!\n");
         r128_status(dev_priv);
 #endif
-        return DRM_ERR(EBUSY);
+        return -EBUSY;
 }
 
 /* Start the Concurrent Command Engine.
@@ -355,7 +355,7 @@ static int r128_do_init_cce(struct drm_device * dev, drm_r128_init_t * init)
 
         dev_priv = drm_alloc(sizeof(drm_r128_private_t), DRM_MEM_DRIVER);
         if (dev_priv == NULL)
-                return DRM_ERR(ENOMEM);
+                return -ENOMEM;
 
         memset(dev_priv, 0, sizeof(drm_r128_private_t));
 
@@ -365,7 +365,7 @@ static int r128_do_init_cce(struct drm_device * dev, drm_r128_init_t * init)
                 DRM_ERROR("PCI GART memory not allocated!\n");
                 dev->dev_private = (void *)dev_priv;
                 r128_do_cleanup_cce(dev);
-                return DRM_ERR(EINVAL);
+                return -EINVAL;
         }
 
         dev_priv->usec_timeout = init->usec_timeout;
@@ -374,7 +374,7 @@ static int r128_do_init_cce(struct drm_device * dev, drm_r128_init_t * init)
                 DRM_DEBUG("TIMEOUT problem!\n");
                 dev->dev_private = (void *)dev_priv;
                 r128_do_cleanup_cce(dev);
-                return DRM_ERR(EINVAL);
+                return -EINVAL;
         }
 
         dev_priv->cce_mode = init->cce_mode;
@@ -394,7 +394,7 @@ static int r128_do_init_cce(struct drm_device * dev, drm_r128_init_t * init)
                 DRM_DEBUG("Bad cce_mode!\n");
                 dev->dev_private = (void *)dev_priv;
                 r128_do_cleanup_cce(dev);
-                return DRM_ERR(EINVAL);
+                return -EINVAL;
         }
 
         switch (init->cce_mode) {
@@ -461,7 +461,7 @@ static int r128_do_init_cce(struct drm_device * dev, drm_r128_init_t * init)
                 DRM_ERROR("could not find sarea!\n");
                 dev->dev_private = (void *)dev_priv;
                 r128_do_cleanup_cce(dev);
-                return DRM_ERR(EINVAL);
+                return -EINVAL;
         }
 
         dev_priv->mmio = drm_core_findmap(dev, init->mmio_offset);
@@ -469,21 +469,21 @@ static int r128_do_init_cce(struct drm_device * dev, drm_r128_init_t * init)
                 DRM_ERROR("could not find mmio region!\n");
                 dev->dev_private = (void *)dev_priv;
                 r128_do_cleanup_cce(dev);
-                return DRM_ERR(EINVAL);
+                return -EINVAL;
         }
         dev_priv->cce_ring = drm_core_findmap(dev, init->ring_offset);
         if (!dev_priv->cce_ring) {
                 DRM_ERROR("could not find cce ring region!\n");
                 dev->dev_private = (void *)dev_priv;
                 r128_do_cleanup_cce(dev);
-                return DRM_ERR(EINVAL);
+                return -EINVAL;
         }
         dev_priv->ring_rptr = drm_core_findmap(dev, init->ring_rptr_offset);
         if (!dev_priv->ring_rptr) {
                 DRM_ERROR("could not find ring read pointer!\n");
                 dev->dev_private = (void *)dev_priv;
                 r128_do_cleanup_cce(dev);
-                return DRM_ERR(EINVAL);
+                return -EINVAL;
         }
         dev->agp_buffer_token = init->buffers_offset;
         dev->agp_buffer_map = drm_core_findmap(dev, init->buffers_offset);
@@ -491,7 +491,7 @@ static int r128_do_init_cce(struct drm_device * dev, drm_r128_init_t * init)
                 DRM_ERROR("could not find dma buffer region!\n");
                 dev->dev_private = (void *)dev_priv;
                 r128_do_cleanup_cce(dev);
-                return DRM_ERR(EINVAL);
+                return -EINVAL;
         }
 
         if (!dev_priv->is_pci) {
@@ -501,7 +501,7 @@ static int r128_do_init_cce(struct drm_device * dev, drm_r128_init_t * init)
                         DRM_ERROR("could not find agp texture region!\n");
                         dev->dev_private = (void *)dev_priv;
                         r128_do_cleanup_cce(dev);
-                        return DRM_ERR(EINVAL);
+                        return -EINVAL;
                 }
         }
 
@@ -520,7 +520,7 @@ static int r128_do_init_cce(struct drm_device * dev, drm_r128_init_t * init)
                         DRM_ERROR("Could not ioremap agp regions!\n");
                         dev->dev_private = (void *)dev_priv;
                         r128_do_cleanup_cce(dev);
-                        return DRM_ERR(ENOMEM);
+                        return -ENOMEM;
                 }
         } else
 #endif
@@ -567,7 +567,7 @@ static int r128_do_init_cce(struct drm_device * dev, drm_r128_init_t * init)
                         DRM_ERROR("failed to init PCI GART!\n");
                         dev->dev_private = (void *)dev_priv;
                         r128_do_cleanup_cce(dev);
-                        return DRM_ERR(ENOMEM);
+                        return -ENOMEM;
                 }
                 R128_WRITE(R128_PCI_GART_PAGE, dev_priv->gart_info.bus_addr);
 #if __OS_HAS_AGP
@@ -625,35 +625,30 @@ int r128_do_cleanup_cce(struct drm_device * dev)
         return 0;
 }
 
-int r128_cce_init(DRM_IOCTL_ARGS)
+int r128_cce_init(struct drm_device *dev, void *data, struct drm_file *file_priv)
 {
-        DRM_DEVICE;
-        drm_r128_init_t init;
+        drm_r128_init_t *init = data;
 
         DRM_DEBUG("\n");
 
-        LOCK_TEST_WITH_RETURN(dev, filp);
+        LOCK_TEST_WITH_RETURN(dev, file_priv);
 
-        DRM_COPY_FROM_USER_IOCTL(init, (drm_r128_init_t __user *) data,
-                                 sizeof(init));
-
-        switch (init.func) {
+        switch (init->func) {
         case R128_INIT_CCE:
-                return r128_do_init_cce(dev, &init);
+                return r128_do_init_cce(dev, init);
         case R128_CLEANUP_CCE:
                 return r128_do_cleanup_cce(dev);
         }
 
-        return DRM_ERR(EINVAL);
+        return -EINVAL;
 }
 
-int r128_cce_start(DRM_IOCTL_ARGS)
+int r128_cce_start(struct drm_device *dev, void *data, struct drm_file *file_priv)
 {
-        DRM_DEVICE;
         drm_r128_private_t *dev_priv = dev->dev_private;
         DRM_DEBUG("\n");
 
-        LOCK_TEST_WITH_RETURN(dev, filp);
+        LOCK_TEST_WITH_RETURN(dev, file_priv);
 
         if (dev_priv->cce_running || dev_priv->cce_mode == R128_PM4_NONPM4) {
                 DRM_DEBUG("%s while CCE running\n", __FUNCTION__);
@@ -668,30 +663,26 @@ int r128_cce_start(DRM_IOCTL_ARGS)
 /* Stop the CCE.  The engine must have been idled before calling this
  * routine.
  */
-int r128_cce_stop(DRM_IOCTL_ARGS)
+int r128_cce_stop(struct drm_device *dev, void *data, struct drm_file *file_priv)
 {
-        DRM_DEVICE;
         drm_r128_private_t *dev_priv = dev->dev_private;
-        drm_r128_cce_stop_t stop;
+        drm_r128_cce_stop_t *stop = data;
         int ret;
         DRM_DEBUG("\n");
 
-        LOCK_TEST_WITH_RETURN(dev, filp);
-
-        DRM_COPY_FROM_USER_IOCTL(stop, (drm_r128_cce_stop_t __user *) data,
-                                 sizeof(stop));
+        LOCK_TEST_WITH_RETURN(dev, file_priv);
 
         /* Flush any pending CCE commands.  This ensures any outstanding
          * commands are exectuted by the engine before we turn it off.
          */
-        if (stop.flush) {
+        if (stop->flush) {
                 r128_do_cce_flush(dev_priv);
         }
 
         /* If we fail to make the engine go idle, we return an error
          * code so that the DRM ioctl wrapper can try again.
          */
-        if (stop.idle) {
+        if (stop->idle) {
                 ret = r128_do_cce_idle(dev_priv);
                 if (ret)
                         return ret;
@@ -711,17 +702,16 @@ int r128_cce_stop(DRM_IOCTL_ARGS)
 
 /* Just reset the CCE ring.  Called as part of an X Server engine reset.
  */
-int r128_cce_reset(DRM_IOCTL_ARGS)
+int r128_cce_reset(struct drm_device *dev, void *data, struct drm_file *file_priv)
 {
-        DRM_DEVICE;
         drm_r128_private_t *dev_priv = dev->dev_private;
         DRM_DEBUG("\n");
 
-        LOCK_TEST_WITH_RETURN(dev, filp);
+        LOCK_TEST_WITH_RETURN(dev, file_priv);
 
         if (!dev_priv) {
                 DRM_DEBUG("%s called before init done\n", __FUNCTION__);
-                return DRM_ERR(EINVAL);
+                return -EINVAL;
         }
 
         r128_do_cce_reset(dev_priv);
@@ -732,13 +722,12 @@ int r128_cce_reset(DRM_IOCTL_ARGS)
         return 0;
 }
 
-int r128_cce_idle(DRM_IOCTL_ARGS)
+int r128_cce_idle(struct drm_device *dev, void *data, struct drm_file *file_priv)
 {
-        DRM_DEVICE;
         drm_r128_private_t *dev_priv = dev->dev_private;
         DRM_DEBUG("\n");
 
-        LOCK_TEST_WITH_RETURN(dev, filp);
+        LOCK_TEST_WITH_RETURN(dev, file_priv);
 
         if (dev_priv->cce_running) {
                 r128_do_cce_flush(dev_priv);
@@ -747,19 +736,18 @@ int r128_cce_idle(DRM_IOCTL_ARGS)
         return r128_do_cce_idle(dev_priv);
 }
 
-int r128_engine_reset(DRM_IOCTL_ARGS)
+int r128_engine_reset(struct drm_device *dev, void *data, struct drm_file *file_priv)
 {
-        DRM_DEVICE;
         DRM_DEBUG("\n");
 
-        LOCK_TEST_WITH_RETURN(dev, filp);
+        LOCK_TEST_WITH_RETURN(dev, file_priv);
 
         return r128_do_engine_reset(dev);
 }
 
-int r128_fullscreen(DRM_IOCTL_ARGS)
+int r128_fullscreen(struct drm_device *dev, void *data, struct drm_file *file_priv)
 {
-        return DRM_ERR(EINVAL);
+        return -EINVAL;
 }
 
 /* ================================================================
@@ -780,7 +768,7 @@ static int r128_freelist_init(struct drm_device * dev)
 
         dev_priv->head = drm_alloc(sizeof(drm_r128_freelist_t), DRM_MEM_DRIVER);
         if (dev_priv->head == NULL)
-                return DRM_ERR(ENOMEM);
+                return -ENOMEM;
 
         memset(dev_priv->head, 0, sizeof(drm_r128_freelist_t));
         dev_priv->head->age = R128_BUFFER_USED;
@@ -791,7 +779,7 @@ static int r128_freelist_init(struct drm_device * dev)
 
                 entry = drm_alloc(sizeof(drm_r128_freelist_t), DRM_MEM_DRIVER);
                 if (!entry)
-                        return DRM_ERR(ENOMEM);
+                        return -ENOMEM;
 
                 entry->age = R128_BUFFER_FREE;
                 entry->buf = buf;
@@ -828,7 +816,7 @@ static struct drm_buf *r128_freelist_get(struct drm_device * dev)
         for (i = 0; i < dma->buf_count; i++) {
                 buf = dma->buflist[i];
                 buf_priv = buf->dev_private;
-                if (buf->filp == 0)
+                if (buf->file_priv == 0)
                         return buf;
         }
 
@@ -883,10 +871,12 @@ int r128_wait_ring(drm_r128_private_t * dev_priv, int n)
 
         /* FIXME: This is being ignored... */
         DRM_ERROR("failed!\n");
-        return DRM_ERR(EBUSY);
+        return -EBUSY;
 }
 
-static int r128_cce_get_buffers(DRMFILE filp, struct drm_device * dev, struct drm_dma * d)
+static int r128_cce_get_buffers(struct drm_device * dev,
+                                struct drm_file *file_priv,
+                                struct drm_dma * d)
 {
         int i;
         struct drm_buf *buf;
@@ -894,57 +884,51 @@ static int r128_cce_get_buffers(DRMFILE filp, struct drm_device * dev, struct dr
         for (i = d->granted_count; i < d->request_count; i++) {
                 buf = r128_freelist_get(dev);
                 if (!buf)
-                        return DRM_ERR(EAGAIN);
+                        return -EAGAIN;
 
-                buf->filp = filp;
+                buf->file_priv = file_priv;
 
                 if (DRM_COPY_TO_USER(&d->request_indices[i], &buf->idx,
                                      sizeof(buf->idx)))
-                        return DRM_ERR(EFAULT);
+                        return -EFAULT;
                 if (DRM_COPY_TO_USER(&d->request_sizes[i], &buf->total,
                                      sizeof(buf->total)))
-                        return DRM_ERR(EFAULT);
+                        return -EFAULT;
 
                 d->granted_count++;
         }
         return 0;
 }
 
-int r128_cce_buffers(DRM_IOCTL_ARGS)
+int r128_cce_buffers(struct drm_device *dev, void *data, struct drm_file *file_priv)
 {
-        DRM_DEVICE;
         struct drm_device_dma *dma = dev->dma;
         int ret = 0;
-        struct drm_dma __user *argp = (void __user *)data;
-        struct drm_dma d;
+        struct drm_dma *d = data;
 
-        LOCK_TEST_WITH_RETURN(dev, filp);
-
-        DRM_COPY_FROM_USER_IOCTL(d, argp, sizeof(d));
+        LOCK_TEST_WITH_RETURN(dev, file_priv);
 
         /* Please don't send us buffers.
          */
-        if (d.send_count != 0) {
+        if (d->send_count != 0) {
                 DRM_ERROR("Process %d trying to send %d buffers via drmDMA\n",
-                          DRM_CURRENTPID, d.send_count);
-                return DRM_ERR(EINVAL);
+                          DRM_CURRENTPID, d->send_count);
+                return -EINVAL;
         }
 
         /* We'll send you buffers.
          */
-        if (d.request_count < 0 || d.request_count > dma->buf_count) {
+        if (d->request_count < 0 || d->request_count > dma->buf_count) {
                 DRM_ERROR("Process %d trying to get %d buffers (of %d max)\n",
-                          DRM_CURRENTPID, d.request_count, dma->buf_count);
-                return DRM_ERR(EINVAL);
+                          DRM_CURRENTPID, d->request_count, dma->buf_count);
+                return -EINVAL;
         }
 
-        d.granted_count = 0;
+        d->granted_count = 0;
 
-        if (d.request_count) {
-                ret = r128_cce_get_buffers(filp, dev, &d);
+        if (d->request_count) {
+                ret = r128_cce_get_buffers(dev, file_priv, d);
         }
 
-        DRM_COPY_TO_USER_IOCTL(argp, d, sizeof(d));
-
         return ret;
 }