1 files changed, 54 insertions, 95 deletions

diff --git a/drivers/char/drm/mga_state.c b/drivers/char/drm/mga_state.c
index 74811727595..5ec8b61c5d4 100644
--- a/drivers/char/drm/mga_state.c
+++ b/drivers/char/drm/mga_state.c
@@ -828,24 +828,20 @@ static void mga_dma_dispatch_blit(struct drm_device * dev, drm_mga_blit_t * blit
  *
  */
 
-static int mga_dma_clear(DRM_IOCTL_ARGS)
+static int mga_dma_clear(struct drm_device *dev, void *data, struct drm_file *file_priv)
 {
-        DRM_DEVICE;
         drm_mga_private_t *dev_priv = dev->dev_private;
         drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
-        drm_mga_clear_t clear;
+        drm_mga_clear_t *clear = data;
 
         LOCK_TEST_WITH_RETURN(dev, file_priv);
 
-        DRM_COPY_FROM_USER_IOCTL(clear, (drm_mga_clear_t __user *) data,
-                                 sizeof(clear));
-
         if (sarea_priv->nbox > MGA_NR_SAREA_CLIPRECTS)
                 sarea_priv->nbox = MGA_NR_SAREA_CLIPRECTS;
 
         WRAP_TEST_WITH_RETURN(dev_priv);
 
-        mga_dma_dispatch_clear(dev, &clear);
+        mga_dma_dispatch_clear(dev, clear);
 
         /* Make sure we restore the 3D state next time.
          */
@@ -854,9 +850,8 @@ static int mga_dma_clear(DRM_IOCTL_ARGS)
         return 0;
 }
 
-static int mga_dma_swap(DRM_IOCTL_ARGS)
+static int mga_dma_swap(struct drm_device *dev, void *data, struct drm_file *file_priv)
 {
-        DRM_DEVICE;
         drm_mga_private_t *dev_priv = dev->dev_private;
         drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
 
@@ -876,31 +871,26 @@ static int mga_dma_swap(DRM_IOCTL_ARGS)
         return 0;
 }
 
-static int mga_dma_vertex(DRM_IOCTL_ARGS)
+static int mga_dma_vertex(struct drm_device *dev, void *data, struct drm_file *file_priv)
 {
-        DRM_DEVICE;
         drm_mga_private_t *dev_priv = dev->dev_private;
         struct drm_device_dma *dma = dev->dma;
         struct drm_buf *buf;
         drm_mga_buf_priv_t *buf_priv;
-        drm_mga_vertex_t vertex;
+        drm_mga_vertex_t *vertex = data;
 
         LOCK_TEST_WITH_RETURN(dev, file_priv);
 
-        DRM_COPY_FROM_USER_IOCTL(vertex,
-                                 (drm_mga_vertex_t __user *) data,
-                                 sizeof(vertex));
-
-        if (vertex.idx < 0 || vertex.idx > dma->buf_count)
+        if (vertex->idx < 0 || vertex->idx > dma->buf_count)
                 return -EINVAL;
-        buf = dma->buflist[vertex.idx];
+        buf = dma->buflist[vertex->idx];
         buf_priv = buf->dev_private;
 
-        buf->used = vertex.used;
-        buf_priv->discard = vertex.discard;
+        buf->used = vertex->used;
+        buf_priv->discard = vertex->discard;
 
         if (!mga_verify_state(dev_priv)) {
-                if (vertex.discard) {
+                if (vertex->discard) {
                         if (buf_priv->dispatched == 1)
                                 AGE_BUFFER(buf_priv);
                         buf_priv->dispatched = 0;
@@ -916,31 +906,26 @@ static int mga_dma_vertex(DRM_IOCTL_ARGS)
         return 0;
 }
 
-static int mga_dma_indices(DRM_IOCTL_ARGS)
+static int mga_dma_indices(struct drm_device *dev, void *data, struct drm_file *file_priv)
 {
-        DRM_DEVICE;
         drm_mga_private_t *dev_priv = dev->dev_private;
         struct drm_device_dma *dma = dev->dma;
         struct drm_buf *buf;
         drm_mga_buf_priv_t *buf_priv;
-        drm_mga_indices_t indices;
+        drm_mga_indices_t *indices = data;
 
         LOCK_TEST_WITH_RETURN(dev, file_priv);
 
-        DRM_COPY_FROM_USER_IOCTL(indices,
-                                 (drm_mga_indices_t __user *) data,
-                                 sizeof(indices));
-
-        if (indices.idx < 0 || indices.idx > dma->buf_count)
+        if (indices->idx < 0 || indices->idx > dma->buf_count)
                 return -EINVAL;
 
-        buf = dma->buflist[indices.idx];
+        buf = dma->buflist[indices->idx];
         buf_priv = buf->dev_private;
 
-        buf_priv->discard = indices.discard;
+        buf_priv->discard = indices->discard;
 
         if (!mga_verify_state(dev_priv)) {
-                if (indices.discard) {
+                if (indices->discard) {
                         if (buf_priv->dispatched == 1)
                                 AGE_BUFFER(buf_priv);
                         buf_priv->dispatched = 0;
@@ -951,26 +936,22 @@ static int mga_dma_indices(DRM_IOCTL_ARGS)
 
         WRAP_TEST_WITH_RETURN(dev_priv);
 
-        mga_dma_dispatch_indices(dev, buf, indices.start, indices.end);
+        mga_dma_dispatch_indices(dev, buf, indices->start, indices->end);
 
         return 0;
 }
 
-static int mga_dma_iload(DRM_IOCTL_ARGS)
+static int mga_dma_iload(struct drm_device *dev, void *data, struct drm_file *file_priv)
 {
-        DRM_DEVICE;
         struct drm_device_dma *dma = dev->dma;
         drm_mga_private_t *dev_priv = dev->dev_private;
         struct drm_buf *buf;
         drm_mga_buf_priv_t *buf_priv;
-        drm_mga_iload_t iload;
+        drm_mga_iload_t *iload = data;
         DRM_DEBUG("\n");
 
         LOCK_TEST_WITH_RETURN(dev, file_priv);
 
-        DRM_COPY_FROM_USER_IOCTL(iload, (drm_mga_iload_t __user *) data,
-                                 sizeof(iload));
-
 #if 0
         if (mga_do_wait_for_idle(dev_priv) < 0) {
                 if (MGA_DMA_DEBUG)
@@ -978,20 +959,20 @@ static int mga_dma_iload(DRM_IOCTL_ARGS)
                 return -EBUSY;
         }
 #endif
-        if (iload.idx < 0 || iload.idx > dma->buf_count)
+        if (iload->idx < 0 || iload->idx > dma->buf_count)
                 return -EINVAL;
 
-        buf = dma->buflist[iload.idx];
+        buf = dma->buflist[iload->idx];
         buf_priv = buf->dev_private;
 
-        if (mga_verify_iload(dev_priv, iload.dstorg, iload.length)) {
+        if (mga_verify_iload(dev_priv, iload->dstorg, iload->length)) {
                 mga_freelist_put(dev, buf);
                 return -EINVAL;
         }
 
         WRAP_TEST_WITH_RETURN(dev_priv);
 
-        mga_dma_dispatch_iload(dev, buf, iload.dstorg, iload.length);
+        mga_dma_dispatch_iload(dev, buf, iload->dstorg, iload->length);
 
         /* Make sure we restore the 3D state next time.
          */
@@ -1000,28 +981,24 @@ static int mga_dma_iload(DRM_IOCTL_ARGS)
         return 0;
 }
 
-static int mga_dma_blit(DRM_IOCTL_ARGS)
+static int mga_dma_blit(struct drm_device *dev, void *data, struct drm_file *file_priv)
 {
-        DRM_DEVICE;
         drm_mga_private_t *dev_priv = dev->dev_private;
         drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
-        drm_mga_blit_t blit;
+        drm_mga_blit_t *blit = data;
         DRM_DEBUG("\n");
 
         LOCK_TEST_WITH_RETURN(dev, file_priv);
 
-        DRM_COPY_FROM_USER_IOCTL(blit, (drm_mga_blit_t __user *) data,
-                                 sizeof(blit));
-
         if (sarea_priv->nbox > MGA_NR_SAREA_CLIPRECTS)
                 sarea_priv->nbox = MGA_NR_SAREA_CLIPRECTS;
 
-        if (mga_verify_blit(dev_priv, blit.srcorg, blit.dstorg))
+        if (mga_verify_blit(dev_priv, blit->srcorg, blit->dstorg))
                 return -EINVAL;
 
         WRAP_TEST_WITH_RETURN(dev_priv);
 
-        mga_dma_dispatch_blit(dev, &blit);
+        mga_dma_dispatch_blit(dev, blit);
 
         /* Make sure we restore the 3D state next time.
          */
@@ -1030,11 +1007,10 @@ static int mga_dma_blit(DRM_IOCTL_ARGS)
         return 0;
 }
 
-static int mga_getparam(DRM_IOCTL_ARGS)
+static int mga_getparam(struct drm_device *dev, void *data, struct drm_file *file_priv)
 {
-        DRM_DEVICE;
         drm_mga_private_t *dev_priv = dev->dev_private;
-        drm_mga_getparam_t param;
+        drm_mga_getparam_t *param = data;
         int value;
 
         if (!dev_priv) {
@@ -1042,12 +1018,9 @@ static int mga_getparam(DRM_IOCTL_ARGS)
                 return -EINVAL;
         }
 
-        DRM_COPY_FROM_USER_IOCTL(param, (drm_mga_getparam_t __user *) data,
-                                 sizeof(param));
-
         DRM_DEBUG("pid=%d\n", DRM_CURRENTPID);
 
-        switch (param.param) {
+        switch (param->param) {
         case MGA_PARAM_IRQ_NR:
                 value = dev->irq;
                 break;
@@ -1058,7 +1031,7 @@ static int mga_getparam(DRM_IOCTL_ARGS)
                 return -EINVAL;
         }
 
-        if (DRM_COPY_TO_USER(param.value, &value, sizeof(int))) {
+        if (DRM_COPY_TO_USER(param->value, &value, sizeof(int))) {
                 DRM_ERROR("copy_to_user\n");
                 return -EFAULT;
         }
@@ -1066,11 +1039,10 @@ static int mga_getparam(DRM_IOCTL_ARGS)
         return 0;
 }
 
-static int mga_set_fence(DRM_IOCTL_ARGS)
+static int mga_set_fence(struct drm_device *dev, void *data, struct drm_file *file_priv)
 {
-        DRM_DEVICE;
         drm_mga_private_t *dev_priv = dev->dev_private;
-        u32 temp;
+        u32 *fence = data;
         DMA_LOCALS;
 
         if (!dev_priv) {
@@ -1080,11 +1052,11 @@ static int mga_set_fence(DRM_IOCTL_ARGS)
 
         DRM_DEBUG("pid=%d\n", DRM_CURRENTPID);
 
-        /* I would normal do this assignment in the declaration of temp,
+        /* I would normal do this assignment in the declaration of fence,
          * but dev_priv may be NULL.
          */
 
-        temp = dev_priv->next_fence_to_post;
+        *fence = dev_priv->next_fence_to_post;
         dev_priv->next_fence_to_post++;
 
         BEGIN_DMA(1);
@@ -1093,53 +1065,40 @@ static int mga_set_fence(DRM_IOCTL_ARGS)
                   MGA_DMAPAD, 0x00000000, MGA_SOFTRAP, 0x00000000);
         ADVANCE_DMA();
 
-        if (DRM_COPY_TO_USER((u32 __user *) data, &temp, sizeof(u32))) {
-                DRM_ERROR("copy_to_user\n");
-                return -EFAULT;
-        }
-
         return 0;
 }
 
-static int mga_wait_fence(DRM_IOCTL_ARGS)
+static int mga_wait_fence(struct drm_device *dev, void *data, struct drm_file *
+file_priv)
 {
-        DRM_DEVICE;
         drm_mga_private_t *dev_priv = dev->dev_private;
-        u32 fence;
+        u32 *fence = data;
 
         if (!dev_priv) {
                 DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
                 return -EINVAL;
         }
 
-        DRM_COPY_FROM_USER_IOCTL(fence, (u32 __user *) data, sizeof(u32));
-
         DRM_DEBUG("pid=%d\n", DRM_CURRENTPID);
 
-        mga_driver_fence_wait(dev, &fence);
-
-        if (DRM_COPY_TO_USER((u32 __user *) data, &fence, sizeof(u32))) {
-                DRM_ERROR("copy_to_user\n");
-                return -EFAULT;
-        }
-
+        mga_driver_fence_wait(dev, fence);
         return 0;
 }
 
-drm_ioctl_desc_t mga_ioctls[] = {
-        [DRM_IOCTL_NR(DRM_MGA_INIT)] = {mga_dma_init, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
-        [DRM_IOCTL_NR(DRM_MGA_FLUSH)] = {mga_dma_flush, DRM_AUTH},
-        [DRM_IOCTL_NR(DRM_MGA_RESET)] = {mga_dma_reset, DRM_AUTH},
-        [DRM_IOCTL_NR(DRM_MGA_SWAP)] = {mga_dma_swap, DRM_AUTH},
-        [DRM_IOCTL_NR(DRM_MGA_CLEAR)] = {mga_dma_clear, DRM_AUTH},
-        [DRM_IOCTL_NR(DRM_MGA_VERTEX)] = {mga_dma_vertex, DRM_AUTH},
-        [DRM_IOCTL_NR(DRM_MGA_INDICES)] = {mga_dma_indices, DRM_AUTH},
-        [DRM_IOCTL_NR(DRM_MGA_ILOAD)] = {mga_dma_iload, DRM_AUTH},
-        [DRM_IOCTL_NR(DRM_MGA_BLIT)] = {mga_dma_blit, DRM_AUTH},
-        [DRM_IOCTL_NR(DRM_MGA_GETPARAM)] = {mga_getparam, DRM_AUTH},
-        [DRM_IOCTL_NR(DRM_MGA_SET_FENCE)] = {mga_set_fence, DRM_AUTH},
-        [DRM_IOCTL_NR(DRM_MGA_WAIT_FENCE)] = {mga_wait_fence, DRM_AUTH},
-        [DRM_IOCTL_NR(DRM_MGA_DMA_BOOTSTRAP)] = {mga_dma_bootstrap, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
+struct drm_ioctl_desc mga_ioctls[] = {
+        DRM_IOCTL_DEF(DRM_MGA_INIT, mga_dma_init, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+        DRM_IOCTL_DEF(DRM_MGA_FLUSH, mga_dma_flush, DRM_AUTH),
+        DRM_IOCTL_DEF(DRM_MGA_RESET, mga_dma_reset, DRM_AUTH),
+        DRM_IOCTL_DEF(DRM_MGA_SWAP, mga_dma_swap, DRM_AUTH),
+        DRM_IOCTL_DEF(DRM_MGA_CLEAR, mga_dma_clear, DRM_AUTH),
+        DRM_IOCTL_DEF(DRM_MGA_VERTEX, mga_dma_vertex, DRM_AUTH),
+        DRM_IOCTL_DEF(DRM_MGA_INDICES, mga_dma_indices, DRM_AUTH),
+        DRM_IOCTL_DEF(DRM_MGA_ILOAD, mga_dma_iload, DRM_AUTH),
+        DRM_IOCTL_DEF(DRM_MGA_BLIT, mga_dma_blit, DRM_AUTH),
+        DRM_IOCTL_DEF(DRM_MGA_GETPARAM, mga_getparam, DRM_AUTH),
+        DRM_IOCTL_DEF(DRM_MGA_SET_FENCE, mga_set_fence, DRM_AUTH),
+        DRM_IOCTL_DEF(DRM_MGA_WAIT_FENCE, mga_wait_fence, DRM_AUTH),
+        DRM_IOCTL_DEF(DRM_MGA_DMA_BOOTSTRAP, mga_dma_bootstrap, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
 };
 
 int mga_max_ioctl = DRM_ARRAY_SIZE(mga_ioctls);