r128: switch compat ioctls to drm_ioctl_kernel()

[mirror_ubuntu-bionic-kernel.git] / drivers / gpu / drm / r128 / r128_ioc32.c

diff --git a/drivers/gpu/drm/r128/r128_ioc32.c b/drivers/gpu/drm/r128/r128_ioc32.c
index 663f38c63ba6bd334d4732de3e80cdbf89ae711b..6589f9e0310e9846202663fb446c0b7190c514b4 100644 (file)
--- a/drivers/gpu/drm/r128/r128_ioc32.c
+++ b/drivers/gpu/drm/r128/r128_ioc32.c
@@ -63,39 +63,36 @@ static int compat_r128_init(struct file *file, unsigned int cmd,
                            unsigned long arg)
 {
        drm_r128_init32_t init32;
-       drm_r128_init_t __user *init;
+       drm_r128_init_t init;
 
        if (copy_from_user(&init32, (void __user *)arg, sizeof(init32)))
                return -EFAULT;
 
-       init = compat_alloc_user_space(sizeof(*init));
-       if (!access_ok(VERIFY_WRITE, init, sizeof(*init))
-           || __put_user(init32.func, &init->func)
-           || __put_user(init32.sarea_priv_offset, &init->sarea_priv_offset)
-           || __put_user(init32.is_pci, &init->is_pci)
-           || __put_user(init32.cce_mode, &init->cce_mode)
-           || __put_user(init32.cce_secure, &init->cce_secure)
-           || __put_user(init32.ring_size, &init->ring_size)
-           || __put_user(init32.usec_timeout, &init->usec_timeout)
-           || __put_user(init32.fb_bpp, &init->fb_bpp)
-           || __put_user(init32.front_offset, &init->front_offset)
-           || __put_user(init32.front_pitch, &init->front_pitch)
-           || __put_user(init32.back_offset, &init->back_offset)
-           || __put_user(init32.back_pitch, &init->back_pitch)
-           || __put_user(init32.depth_bpp, &init->depth_bpp)
-           || __put_user(init32.depth_offset, &init->depth_offset)
-           || __put_user(init32.depth_pitch, &init->depth_pitch)
-           || __put_user(init32.span_offset, &init->span_offset)
-           || __put_user(init32.fb_offset, &init->fb_offset)
-           || __put_user(init32.mmio_offset, &init->mmio_offset)
-           || __put_user(init32.ring_offset, &init->ring_offset)
-           || __put_user(init32.ring_rptr_offset, &init->ring_rptr_offset)
-           || __put_user(init32.buffers_offset, &init->buffers_offset)
-           || __put_user(init32.agp_textures_offset,
-                         &init->agp_textures_offset))
-               return -EFAULT;
-
-       return drm_ioctl(file, DRM_IOCTL_R128_INIT, (unsigned long)init);
+       init.func = init32.func;
+       init.sarea_priv_offset = init32.sarea_priv_offset;
+       init.is_pci = init32.is_pci;
+       init.cce_mode = init32.cce_mode;
+       init.cce_secure = init32.cce_secure;
+       init.ring_size = init32.ring_size;
+       init.usec_timeout = init32.usec_timeout;
+       init.fb_bpp = init32.fb_bpp;
+       init.front_offset = init32.front_offset;
+       init.front_pitch = init32.front_pitch;
+       init.back_offset = init32.back_offset;
+       init.back_pitch = init32.back_pitch;
+       init.depth_bpp = init32.depth_bpp;
+       init.depth_offset = init32.depth_offset;
+       init.depth_pitch = init32.depth_pitch;
+       init.span_offset = init32.span_offset;
+       init.fb_offset = init32.fb_offset;
+       init.mmio_offset = init32.mmio_offset;
+       init.ring_offset = init32.ring_offset;
+       init.ring_rptr_offset = init32.ring_rptr_offset;
+       init.buffers_offset = init32.buffers_offset;
+       init.agp_textures_offset = init32.agp_textures_offset;
+
+       return drm_ioctl_kernel(file, r128_cce_init, &init,
+                       DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY);
 }
 
 typedef struct drm_r128_depth32 {
@@ -111,25 +108,19 @@ static int compat_r128_depth(struct file *file, unsigned int cmd,
                             unsigned long arg)
 {
        drm_r128_depth32_t depth32;
-       drm_r128_depth_t __user *depth;
+       drm_r128_depth_t depth;
 
        if (copy_from_user(&depth32, (void __user *)arg, sizeof(depth32)))
                return -EFAULT;
 
-       depth = compat_alloc_user_space(sizeof(*depth));
-       if (!access_ok(VERIFY_WRITE, depth, sizeof(*depth))
-           || __put_user(depth32.func, &depth->func)
-           || __put_user(depth32.n, &depth->n)
-           || __put_user((int __user *)(unsigned long)depth32.x, &depth->x)
-           || __put_user((int __user *)(unsigned long)depth32.y, &depth->y)
-           || __put_user((unsigned int __user *)(unsigned long)depth32.buffer,
-                         &depth->buffer)
-           || __put_user((unsigned char __user *)(unsigned long)depth32.mask,
-                         &depth->mask))
-               return -EFAULT;
-
-       return drm_ioctl(file, DRM_IOCTL_R128_DEPTH, (unsigned long)depth);
+       depth.func = depth32.func;
+       depth.n = depth32.n;
+       depth.x = compat_ptr(depth32.x);
+       depth.y = compat_ptr(depth32.y);
+       depth.buffer = compat_ptr(depth32.buffer);
+       depth.mask = compat_ptr(depth32.mask);
 
+       return drm_ioctl_kernel(file, r128_cce_depth, &depth, DRM_AUTH);
 }
 
 typedef struct drm_r128_stipple32 {
@@ -140,18 +131,14 @@ static int compat_r128_stipple(struct file *file, unsigned int cmd,
                               unsigned long arg)
 {
        drm_r128_stipple32_t stipple32;
-       drm_r128_stipple_t __user *stipple;
+       drm_r128_stipple_t stipple;
 
        if (copy_from_user(&stipple32, (void __user *)arg, sizeof(stipple32)))
                return -EFAULT;
 
-       stipple = compat_alloc_user_space(sizeof(*stipple));
-       if (!access_ok(VERIFY_WRITE, stipple, sizeof(*stipple))
-           || __put_user((unsigned int __user *)(unsigned long)stipple32.mask,
-                         &stipple->mask))
-               return -EFAULT;
+       stipple.mask = compat_ptr(stipple32.mask);
 
-       return drm_ioctl(file, DRM_IOCTL_R128_STIPPLE, (unsigned long)stipple);
+       return drm_ioctl_kernel(file, r128_cce_stipple, &stipple, DRM_AUTH);
 }
 
 typedef struct drm_r128_getparam32 {
@@ -163,19 +150,15 @@ static int compat_r128_getparam(struct file *file, unsigned int cmd,
                                unsigned long arg)
 {
        drm_r128_getparam32_t getparam32;
-       drm_r128_getparam_t __user *getparam;
+       drm_r128_getparam_t getparam;
 
        if (copy_from_user(&getparam32, (void __user *)arg, sizeof(getparam32)))
                return -EFAULT;
 
-       getparam = compat_alloc_user_space(sizeof(*getparam));
-       if (!access_ok(VERIFY_WRITE, getparam, sizeof(*getparam))
-           || __put_user(getparam32.param, &getparam->param)
-           || __put_user((void __user *)(unsigned long)getparam32.value,
-                         &getparam->value))
-               return -EFAULT;
+       getparam.param = getparam32.param;
+       getparam.value = compat_ptr(getparam32.value);
 
-       return drm_ioctl(file, DRM_IOCTL_R128_GETPARAM, (unsigned long)getparam);
+       return drm_ioctl_kernel(file, r128_getparam, &getparam, DRM_AUTH);
 }
 
 drm_ioctl_compat_t *r128_compat_ioctls[] = {