Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6

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

diff --git a/drivers/char/drm/mga_dma.c b/drivers/char/drm/mga_dma.c
index 95ff450239ddb65f7cf71c185f18a732b5af1522..c1d12dbfa8d8dec82e47c7821561e06da9744417 100644 (file)
--- a/drivers/char/drm/mga_dma.c
+++ b/drivers/char/drm/mga_dma.c
@@ -493,7 +493,7 @@ static int mga_do_agp_dma_bootstrap(struct drm_device * dev,
                          dma_bs->agp_size);
                return err;
        }
-       
+
        dev_priv->agp_size = agp_size;
        dev_priv->agp_handle = agp_req.handle;
 
@@ -550,7 +550,7 @@ static int mga_do_agp_dma_bootstrap(struct drm_device * dev,
        {
                struct drm_map_list *_entry;
                unsigned long agp_token = 0;
-               
+
                list_for_each_entry(_entry, &dev->maplist, head) {
                        if (_entry->map == dev->agp_buffer_map)
                                agp_token = _entry->user_token;
@@ -759,36 +759,30 @@ static int mga_do_dma_bootstrap(struct drm_device * dev,
        return err;
 }
 
-int mga_dma_bootstrap(DRM_IOCTL_ARGS)
+int mga_dma_bootstrap(struct drm_device *dev, void *data,
+                     struct drm_file *file_priv)
 {
-       DRM_DEVICE;
-       drm_mga_dma_bootstrap_t bootstrap;
+       drm_mga_dma_bootstrap_t *bootstrap = data;
        int err;
        static const int modes[] = { 0, 1, 2, 2, 4, 4, 4, 4 };
        const drm_mga_private_t *const dev_priv =
                (drm_mga_private_t *) dev->dev_private;
 
-       DRM_COPY_FROM_USER_IOCTL(bootstrap,
-                                (drm_mga_dma_bootstrap_t __user *) data,
-                                sizeof(bootstrap));
-
-       err = mga_do_dma_bootstrap(dev, &bootstrap);
+       err = mga_do_dma_bootstrap(dev, bootstrap);
        if (err) {
                mga_do_cleanup_dma(dev, FULL_CLEANUP);
                return err;
        }
 
        if (dev_priv->agp_textures != NULL) {
-               bootstrap.texture_handle = dev_priv->agp_textures->offset;
-               bootstrap.texture_size = dev_priv->agp_textures->size;
+               bootstrap->texture_handle = dev_priv->agp_textures->offset;
+               bootstrap->texture_size = dev_priv->agp_textures->size;
        } else {
-               bootstrap.texture_handle = 0;
-               bootstrap.texture_size = 0;
+               bootstrap->texture_handle = 0;
+               bootstrap->texture_size = 0;
        }
 
-       bootstrap.agp_mode = modes[bootstrap.agp_mode & 0x07];
-       DRM_COPY_TO_USER_IOCTL((drm_mga_dma_bootstrap_t __user *)data,
-                              bootstrap, sizeof(bootstrap));
+       bootstrap->agp_mode = modes[bootstrap->agp_mode & 0x07];
 
        return err;
 }
@@ -970,7 +964,7 @@ static int mga_do_cleanup_dma(struct drm_device *dev, int full_cleanup)
 
                                free_req.handle = dev_priv->agp_handle;
                                drm_agp_free(dev, &free_req);
-       
+
                                dev_priv->agp_textures = NULL;
                                dev_priv->agp_size = 0;
                                dev_priv->agp_handle = 0;
@@ -1004,23 +998,20 @@ static int mga_do_cleanup_dma(struct drm_device *dev, int full_cleanup)
                }
        }
 
-       return 0;
+       return err;
 }
 
-int mga_dma_init(DRM_IOCTL_ARGS)
+int mga_dma_init(struct drm_device *dev, void *data,
+                struct drm_file *file_priv)
 {
-       DRM_DEVICE;
-       drm_mga_init_t init;
+       drm_mga_init_t *init = data;
        int err;
 
        LOCK_TEST_WITH_RETURN(dev, file_priv);
 
-       DRM_COPY_FROM_USER_IOCTL(init, (drm_mga_init_t __user *) data,
-                                sizeof(init));
-
-       switch (init.func) {
+       switch (init->func) {
        case MGA_INIT_DMA:
-               err = mga_do_init_dma(dev, &init);
+               err = mga_do_init_dma(dev, init);
                if (err) {
                        (void)mga_do_cleanup_dma(dev, FULL_CLEANUP);
                }
@@ -1036,33 +1027,30 @@ int mga_dma_init(DRM_IOCTL_ARGS)
  * Primary DMA stream management
  */
 
-int mga_dma_flush(DRM_IOCTL_ARGS)
+int mga_dma_flush(struct drm_device *dev, void *data,
+                 struct drm_file *file_priv)
 {
-       DRM_DEVICE;
        drm_mga_private_t *dev_priv = (drm_mga_private_t *) dev->dev_private;
-       struct drm_lock lock;
+       struct drm_lock *lock = data;
 
        LOCK_TEST_WITH_RETURN(dev, file_priv);
 
-       DRM_COPY_FROM_USER_IOCTL(lock, (struct drm_lock __user *) data,
-                                sizeof(lock));
-
        DRM_DEBUG("%s%s%s\n",
-                 (lock.flags & _DRM_LOCK_FLUSH) ? "flush, " : "",
-                 (lock.flags & _DRM_LOCK_FLUSH_ALL) ? "flush all, " : "",
-                 (lock.flags & _DRM_LOCK_QUIESCENT) ? "idle, " : "");
+                 (lock->flags & _DRM_LOCK_FLUSH) ? "flush, " : "",
+                 (lock->flags & _DRM_LOCK_FLUSH_ALL) ? "flush all, " : "",
+                 (lock->flags & _DRM_LOCK_QUIESCENT) ? "idle, " : "");
 
        WRAP_WAIT_WITH_RETURN(dev_priv);
 
-       if (lock.flags & (_DRM_LOCK_FLUSH | _DRM_LOCK_FLUSH_ALL)) {
+       if (lock->flags & (_DRM_LOCK_FLUSH | _DRM_LOCK_FLUSH_ALL)) {
                mga_do_dma_flush(dev_priv);
        }
 
-       if (lock.flags & _DRM_LOCK_QUIESCENT) {
+       if (lock->flags & _DRM_LOCK_QUIESCENT) {
 #if MGA_DMA_DEBUG
                int ret = mga_do_wait_for_idle(dev_priv);
                if (ret < 0)
-                       DRM_INFO("%s: -EBUSY\n", __FUNCTION__);
+                       DRM_INFO("-EBUSY\n");
                return ret;
 #else
                return mga_do_wait_for_idle(dev_priv);
@@ -1072,9 +1060,9 @@ int mga_dma_flush(DRM_IOCTL_ARGS)
        }
 }
 
-int mga_dma_reset(DRM_IOCTL_ARGS)
+int mga_dma_reset(struct drm_device *dev, void *data,
+                 struct drm_file *file_priv)
 {
-       DRM_DEVICE;
        drm_mga_private_t *dev_priv = (drm_mga_private_t *) dev->dev_private;
 
        LOCK_TEST_WITH_RETURN(dev, file_priv);
@@ -1111,45 +1099,40 @@ static int mga_dma_get_buffers(struct drm_device * dev,
        return 0;
 }
 
-int mga_dma_buffers(DRM_IOCTL_ARGS)
+int mga_dma_buffers(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 = (drm_mga_private_t *) dev->dev_private;
-       struct drm_dma __user *argp = (void __user *)data;
-       struct drm_dma d;
+       struct drm_dma *d = data;
        int ret = 0;
 
        LOCK_TEST_WITH_RETURN(dev, file_priv);
 
-       DRM_COPY_FROM_USER_IOCTL(d, argp, sizeof(d));
-
        /* 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);
+                         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);
+                         DRM_CURRENTPID, d->request_count, dma->buf_count);
                return -EINVAL;
        }
 
        WRAP_TEST_WITH_RETURN(dev_priv);
 
-       d.granted_count = 0;
+       d->granted_count = 0;
 
-       if (d.request_count) {
-               ret = mga_dma_get_buffers(dev, file_priv, &d);
+       if (d->request_count) {
+               ret = mga_dma_get_buffers(dev, file_priv, d);
        }
 
-       DRM_COPY_TO_USER_IOCTL(argp, d, sizeof(d));
-
        return ret;
 }