Merge tag 'topic/drm-misc-2016-11-10' of git://anongit.freedesktop.org/drm-intel into drm-next

- better atomic state debugging from Rob
- fence prep from gustavo
- sumits flushed out his backlog of pending dma-buf/fence patches from
  various people
- drm_mm leak debugging plus trying to appease Kconfig (Chris)
- a few misc things all over

* tag 'topic/drm-misc-2016-11-10' of git://anongit.freedesktop.org/drm-intel: (35 commits)
  drm: Make DRM_DEBUG_MM depend on STACKTRACE_SUPPORT
  drm/i915: Restrict DRM_DEBUG_MM automatic selection
  drm: Restrict stackdepot usage to builtin drm.ko
  drm/msm: module param to dump state on error irq
  drm/msm/mdp5: add atomic_print_state support
  drm/atomic: add debugfs file to dump out atomic state
  drm/atomic: add new drm_debug bit to dump atomic state
  drm: add helpers to go from plane state to drm_rect
  drm: add helper for printing to log or seq_file
  drm: helper macros to print composite types
  reservation: revert "wait only with non-zero timeout specified (v3)" v2
  drm/ttm: fix ttm_bo_wait
  dma-buf/fence: revert "don't wait when specified timeout is zero" (v2)
  dma-buf/fence: make timeout handling in fence_default_wait consistent (v2)
  drm/amdgpu: add the interface of waiting multiple fences (v4)
  dma-buf: return index of the first signaled fence (v2)
  MAINTAINERS: update Sync File Framework files
  dma-buf/sw_sync: put fence reference from the fence creation
  dma-buf/sw_sync: mark sync_timeline_create() static
  drm: Add stackdepot include for DRM_DEBUG_MM
  ...

62 files changed, 613 insertions, 130 deletions

diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig
index 483059a22b1b..2ac0a564af60 100644
--- a/drivers/gpu/drm/Kconfig
+++ b/drivers/gpu/drm/Kconfig
@@ -33,6 +33,20 @@ config DRM_DP_AUX_CHARDEV
           read and write values to arbitrary DPCD registers on the DP aux
           channel.
 
+config DRM_DEBUG_MM
+        bool "Insert extra checks and debug info into the DRM range managers"
+        default n
+        depends on DRM=y
+        depends on STACKTRACE_SUPPORT
+        select STACKDEPOT
+        help
+          Enable allocation tracking of memory manager and leak detection on
+          shutdown.
+
+          Recommended for driver developers only.
+
+          If in doubt, say "N".
+
 config DRM_KMS_HELPER
         tristate
         depends on DRM
diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile
index 74579d2e796e..c1d0602fbe24 100644
--- a/drivers/gpu/drm/Makefile
+++ b/drivers/gpu/drm/Makefile
@@ -15,7 +15,7 @@ drm-y       :=	drm_auth.o drm_bufs.o drm_cache.o \
                 drm_modeset_lock.o drm_atomic.o drm_bridge.o \
                 drm_framebuffer.o drm_connector.o drm_blend.o \
                 drm_encoder.o drm_mode_object.o drm_property.o \
-                drm_plane.o drm_color_mgmt.o
+                drm_plane.o drm_color_mgmt.o drm_print.o
 
 drm-$(CONFIG_COMPAT) += drm_ioc32.o
 drm-$(CONFIG_DRM_GEM_CMA_HELPER) += drm_gem_cma_helper.o
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu.h b/drivers/gpu/drm/amd/amdgpu/amdgpu.h
index 2ec7b3baeec2..c2b8496cdf63 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu.h
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu.h
@@ -1212,6 +1212,8 @@ int amdgpu_gem_op_ioctl(struct drm_device *dev, void *data,
                         struct drm_file *filp);
 int amdgpu_cs_ioctl(struct drm_device *dev, void *data, struct drm_file *filp);
 int amdgpu_cs_wait_ioctl(struct drm_device *dev, void *data, struct drm_file *filp);
+int amdgpu_cs_wait_fences_ioctl(struct drm_device *dev, void *data,
+                                struct drm_file *filp);
 
 int amdgpu_gem_metadata_ioctl(struct drm_device *dev, void *data,
                                 struct drm_file *filp);
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c
index a370101d923f..78da52f90099 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c
@@ -1141,6 +1141,180 @@ int amdgpu_cs_wait_ioctl(struct drm_device *dev, void *data,
 }
 
 /**
+ * amdgpu_cs_get_fence - helper to get fence from drm_amdgpu_fence
+ *
+ * @adev: amdgpu device
+ * @filp: file private
+ * @user: drm_amdgpu_fence copied from user space
+ */
+static struct dma_fence *amdgpu_cs_get_fence(struct amdgpu_device *adev,
+                                             struct drm_file *filp,
+                                             struct drm_amdgpu_fence *user)
+{
+        struct amdgpu_ring *ring;
+        struct amdgpu_ctx *ctx;
+        struct dma_fence *fence;
+        int r;
+
+        r = amdgpu_cs_get_ring(adev, user->ip_type, user->ip_instance,
+                               user->ring, &ring);
+        if (r)
+                return ERR_PTR(r);
+
+        ctx = amdgpu_ctx_get(filp->driver_priv, user->ctx_id);
+        if (ctx == NULL)
+                return ERR_PTR(-EINVAL);
+
+        fence = amdgpu_ctx_get_fence(ctx, ring, user->seq_no);
+        amdgpu_ctx_put(ctx);
+
+        return fence;
+}
+
+/**
+ * amdgpu_cs_wait_all_fence - wait on all fences to signal
+ *
+ * @adev: amdgpu device
+ * @filp: file private
+ * @wait: wait parameters
+ * @fences: array of drm_amdgpu_fence
+ */
+static int amdgpu_cs_wait_all_fences(struct amdgpu_device *adev,
+                                     struct drm_file *filp,
+                                     union drm_amdgpu_wait_fences *wait,
+                                     struct drm_amdgpu_fence *fences)
+{
+        uint32_t fence_count = wait->in.fence_count;
+        unsigned int i;
+        long r = 1;
+
+        for (i = 0; i < fence_count; i++) {
+                struct dma_fence *fence;
+                unsigned long timeout = amdgpu_gem_timeout(wait->in.timeout_ns);
+
+                fence = amdgpu_cs_get_fence(adev, filp, &fences[i]);
+                if (IS_ERR(fence))
+                        return PTR_ERR(fence);
+                else if (!fence)
+                        continue;
+
+                r = dma_fence_wait_timeout(fence, true, timeout);
+                if (r < 0)
+                        return r;
+
+                if (r == 0)
+                        break;
+        }
+
+        memset(wait, 0, sizeof(*wait));
+        wait->out.status = (r > 0);
+
+        return 0;
+}
+
+/**
+ * amdgpu_cs_wait_any_fence - wait on any fence to signal
+ *
+ * @adev: amdgpu device
+ * @filp: file private
+ * @wait: wait parameters
+ * @fences: array of drm_amdgpu_fence
+ */
+static int amdgpu_cs_wait_any_fence(struct amdgpu_device *adev,
+                                    struct drm_file *filp,
+                                    union drm_amdgpu_wait_fences *wait,
+                                    struct drm_amdgpu_fence *fences)
+{
+        unsigned long timeout = amdgpu_gem_timeout(wait->in.timeout_ns);
+        uint32_t fence_count = wait->in.fence_count;
+        uint32_t first = ~0;
+        struct dma_fence **array;
+        unsigned int i;
+        long r;
+
+        /* Prepare the fence array */
+        array = kcalloc(fence_count, sizeof(struct dma_fence *), GFP_KERNEL);
+
+        if (array == NULL)
+                return -ENOMEM;
+
+        for (i = 0; i < fence_count; i++) {
+                struct dma_fence *fence;
+
+                fence = amdgpu_cs_get_fence(adev, filp, &fences[i]);
+                if (IS_ERR(fence)) {
+                        r = PTR_ERR(fence);
+                        goto err_free_fence_array;
+                } else if (fence) {
+                        array[i] = fence;
+                } else { /* NULL, the fence has been already signaled */
+                        r = 1;
+                        goto out;
+                }
+        }
+
+        r = dma_fence_wait_any_timeout(array, fence_count, true, timeout,
+                                       &first);
+        if (r < 0)
+                goto err_free_fence_array;
+
+out:
+        memset(wait, 0, sizeof(*wait));
+        wait->out.status = (r > 0);
+        wait->out.first_signaled = first;
+        /* set return value 0 to indicate success */
+        r = 0;
+
+err_free_fence_array:
+        for (i = 0; i < fence_count; i++)
+                dma_fence_put(array[i]);
+        kfree(array);
+
+        return r;
+}
+
+/**
+ * amdgpu_cs_wait_fences_ioctl - wait for multiple command submissions to finish
+ *
+ * @dev: drm device
+ * @data: data from userspace
+ * @filp: file private
+ */
+int amdgpu_cs_wait_fences_ioctl(struct drm_device *dev, void *data,
+                                struct drm_file *filp)
+{
+        struct amdgpu_device *adev = dev->dev_private;
+        union drm_amdgpu_wait_fences *wait = data;
+        uint32_t fence_count = wait->in.fence_count;
+        struct drm_amdgpu_fence *fences_user;
+        struct drm_amdgpu_fence *fences;
+        int r;
+
+        /* Get the fences from userspace */
+        fences = kmalloc_array(fence_count, sizeof(struct drm_amdgpu_fence),
+                        GFP_KERNEL);
+        if (fences == NULL)
+                return -ENOMEM;
+
+        fences_user = (void __user *)(unsigned long)(wait->in.fences);
+        if (copy_from_user(fences, fences_user,
+                sizeof(struct drm_amdgpu_fence) * fence_count)) {
+                r = -EFAULT;
+                goto err_free_fences;
+        }
+
+        if (wait->in.wait_all)
+                r = amdgpu_cs_wait_all_fences(adev, filp, wait, fences);
+        else
+                r = amdgpu_cs_wait_any_fence(adev, filp, wait, fences);
+
+err_free_fences:
+        kfree(fences);
+
+        return r;
+}
+
+/**
  * amdgpu_cs_find_bo_va - find bo_va for VM address
  *
  * @parser: command submission parser context
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c
index 55c413a55a40..ad908612aff9 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c
@@ -823,6 +823,7 @@ const struct drm_ioctl_desc amdgpu_ioctls_kms[] = {
         DRM_IOCTL_DEF_DRV(AMDGPU_CS, amdgpu_cs_ioctl, DRM_AUTH|DRM_RENDER_ALLOW),
         DRM_IOCTL_DEF_DRV(AMDGPU_INFO, amdgpu_info_ioctl, DRM_AUTH|DRM_RENDER_ALLOW),
         DRM_IOCTL_DEF_DRV(AMDGPU_WAIT_CS, amdgpu_cs_wait_ioctl, DRM_AUTH|DRM_RENDER_ALLOW),
+        DRM_IOCTL_DEF_DRV(AMDGPU_WAIT_FENCES, amdgpu_cs_wait_fences_ioctl, DRM_AUTH|DRM_RENDER_ALLOW),
         DRM_IOCTL_DEF_DRV(AMDGPU_GEM_METADATA, amdgpu_gem_metadata_ioctl, DRM_AUTH|DRM_RENDER_ALLOW),
         DRM_IOCTL_DEF_DRV(AMDGPU_GEM_VA, amdgpu_gem_va_ioctl, DRM_AUTH|DRM_RENDER_ALLOW),
         DRM_IOCTL_DEF_DRV(AMDGPU_GEM_OP, amdgpu_gem_op_ioctl, DRM_AUTH|DRM_RENDER_ALLOW),
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_sa.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_sa.c
index fd26c4b8d793..34a795463988 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_sa.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_sa.c
@@ -361,7 +361,8 @@ int amdgpu_sa_bo_new(struct amdgpu_sa_manager *sa_manager,
                 if (count) {
                         spin_unlock(&sa_manager->wq.lock);
                         t = dma_fence_wait_any_timeout(fences, count, false,
-                                                       MAX_SCHEDULE_TIMEOUT);
+                                                       MAX_SCHEDULE_TIMEOUT,
+                                                       NULL);
                         for (i = 0; i < count; ++i)
                                 dma_fence_put(fences[i]);
 
diff --git a/drivers/gpu/drm/arc/arcpgu_drv.c b/drivers/gpu/drm/arc/arcpgu_drv.c
index 28e6471257d0..0b6eaa49a1db 100644
--- a/drivers/gpu/drm/arc/arcpgu_drv.c
+++ b/drivers/gpu/drm/arc/arcpgu_drv.c
@@ -65,9 +65,7 @@ static const struct file_operations arcpgu_drm_ops = {
         .open = drm_open,
         .release = drm_release,
         .unlocked_ioctl = drm_ioctl,
-#ifdef CONFIG_COMPAT
         .compat_ioctl = drm_compat_ioctl,
-#endif
         .poll = drm_poll,
         .read = drm_read,
         .llseek = no_llseek,
diff --git a/drivers/gpu/drm/arm/hdlcd_drv.c b/drivers/gpu/drm/arm/hdlcd_drv.c
index 6477d1a65266..59747ecaad54 100644
--- a/drivers/gpu/drm/arm/hdlcd_drv.c
+++ b/drivers/gpu/drm/arm/hdlcd_drv.c
@@ -268,9 +268,7 @@ static const struct file_operations fops = {
         .open           = drm_open,
         .release        = drm_release,
         .unlocked_ioctl = drm_ioctl,
-#ifdef CONFIG_COMPAT
         .compat_ioctl   = drm_compat_ioctl,
-#endif
         .poll           = drm_poll,
         .read           = drm_read,
         .llseek         = noop_llseek,
diff --git a/drivers/gpu/drm/arm/malidp_drv.c b/drivers/gpu/drm/arm/malidp_drv.c
index 9f4739452a25..d53b625b14fe 100644
--- a/drivers/gpu/drm/arm/malidp_drv.c
+++ b/drivers/gpu/drm/arm/malidp_drv.c
@@ -197,9 +197,7 @@ static const struct file_operations fops = {
         .open = drm_open,
         .release = drm_release,
         .unlocked_ioctl = drm_ioctl,
-#ifdef CONFIG_COMPAT
         .compat_ioctl = drm_compat_ioctl,
-#endif
         .poll = drm_poll,
         .read = drm_read,
         .llseek = noop_llseek,
diff --git a/drivers/gpu/drm/ast/ast_drv.c b/drivers/gpu/drm/ast/ast_drv.c
index f54afd2113a9..fd7c9eec92e4 100644
--- a/drivers/gpu/drm/ast/ast_drv.c
+++ b/drivers/gpu/drm/ast/ast_drv.c
@@ -188,9 +188,7 @@ static const struct file_operations ast_fops = {
         .unlocked_ioctl = drm_ioctl,
         .mmap = ast_mmap,
         .poll = drm_poll,
-#ifdef CONFIG_COMPAT
         .compat_ioctl = drm_compat_ioctl,
-#endif
         .read = drm_read,
 };
 
diff --git a/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_dc.c b/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_dc.c
index 9f6222895212..cbd0070265c9 100644
--- a/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_dc.c
+++ b/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_dc.c
@@ -749,9 +749,7 @@ static const struct file_operations fops = {
         .open               = drm_open,
         .release            = drm_release,
         .unlocked_ioctl     = drm_ioctl,
-#ifdef CONFIG_COMPAT
         .compat_ioctl       = drm_compat_ioctl,
-#endif
         .poll               = drm_poll,
         .read               = drm_read,
         .llseek             = no_llseek,
diff --git a/drivers/gpu/drm/bochs/bochs_drv.c b/drivers/gpu/drm/bochs/bochs_drv.c
index 534227df23f3..15a293e65b31 100644
--- a/drivers/gpu/drm/bochs/bochs_drv.c
+++ b/drivers/gpu/drm/bochs/bochs_drv.c
@@ -70,9 +70,7 @@ static const struct file_operations bochs_fops = {
         .open           = drm_open,
         .release        = drm_release,
         .unlocked_ioctl = drm_ioctl,
-#ifdef CONFIG_COMPAT
         .compat_ioctl   = drm_compat_ioctl,
-#endif
         .poll           = drm_poll,
         .read           = drm_read,
         .llseek         = no_llseek,
diff --git a/drivers/gpu/drm/cirrus/cirrus_drv.c b/drivers/gpu/drm/cirrus/cirrus_drv.c
index 6c76d125995b..d893ea21a359 100644
--- a/drivers/gpu/drm/cirrus/cirrus_drv.c
+++ b/drivers/gpu/drm/cirrus/cirrus_drv.c
@@ -126,9 +126,7 @@ static const struct file_operations cirrus_driver_fops = {
         .unlocked_ioctl = drm_ioctl,
         .mmap = cirrus_mmap,
         .poll = drm_poll,
-#ifdef CONFIG_COMPAT
         .compat_ioctl = drm_compat_ioctl,
-#endif
 };
 static struct drm_driver driver = {
         .driver_features = DRIVER_MODESET | DRIVER_GEM,
diff --git a/drivers/gpu/drm/drm_atomic.c b/drivers/gpu/drm/drm_atomic.c
index 1d6ab371cd52..f5ea7db4a48a 100644
--- a/drivers/gpu/drm/drm_atomic.c
+++ b/drivers/gpu/drm/drm_atomic.c
@@ -30,6 +30,7 @@
 #include <drm/drm_atomic.h>
 #include <drm/drm_mode.h>
 #include <drm/drm_plane_helper.h>
+#include <drm/drm_print.h>
 
 #include "drm_crtc_internal.h"
 
@@ -605,6 +606,28 @@ static int drm_atomic_crtc_check(struct drm_crtc *crtc,
         return 0;
 }
 
+static void drm_atomic_crtc_print_state(struct drm_printer *p,
+                const struct drm_crtc_state *state)
+{
+        struct drm_crtc *crtc = state->crtc;
+
+        drm_printf(p, "crtc[%u]: %s\n", crtc->base.id, crtc->name);
+        drm_printf(p, "\tenable=%d\n", state->enable);
+        drm_printf(p, "\tactive=%d\n", state->active);
+        drm_printf(p, "\tplanes_changed=%d\n", state->planes_changed);
+        drm_printf(p, "\tmode_changed=%d\n", state->mode_changed);
+        drm_printf(p, "\tactive_changed=%d\n", state->active_changed);
+        drm_printf(p, "\tconnectors_changed=%d\n", state->connectors_changed);
+        drm_printf(p, "\tcolor_mgmt_changed=%d\n", state->color_mgmt_changed);
+        drm_printf(p, "\tplane_mask=%x\n", state->plane_mask);
+        drm_printf(p, "\tconnector_mask=%x\n", state->connector_mask);
+        drm_printf(p, "\tencoder_mask=%x\n", state->encoder_mask);
+        drm_printf(p, "\tmode: " DRM_MODE_FMT "\n", DRM_MODE_ARG(&state->mode));
+
+        if (crtc->funcs->atomic_print_state)
+                crtc->funcs->atomic_print_state(p, state);
+}
+
 /**
  * drm_atomic_get_plane_state - get plane state
  * @state: global atomic state object
@@ -881,6 +904,38 @@ static int drm_atomic_plane_check(struct drm_plane *plane,
         return 0;
 }
 
+static void drm_atomic_plane_print_state(struct drm_printer *p,
+                const struct drm_plane_state *state)
+{
+        struct drm_plane *plane = state->plane;
+        struct drm_rect src  = drm_plane_state_src(state);
+        struct drm_rect dest = drm_plane_state_dest(state);
+
+        drm_printf(p, "plane[%u]: %s\n", plane->base.id, plane->name);
+        drm_printf(p, "\tcrtc=%s\n", state->crtc ? state->crtc->name : "(null)");
+        drm_printf(p, "\tfb=%u\n", state->fb ? state->fb->base.id : 0);
+        if (state->fb) {
+                struct drm_framebuffer *fb = state->fb;
+                int i, n = drm_format_num_planes(fb->pixel_format);
+
+                drm_printf(p, "\t\tformat=%s\n",
+                                drm_get_format_name(fb->pixel_format));
+                drm_printf(p, "\t\tsize=%dx%d\n", fb->width, fb->height);
+                drm_printf(p, "\t\tlayers:\n");
+                for (i = 0; i < n; i++) {
+                        drm_printf(p, "\t\t\tpitch[%d]=%u\n", i, fb->pitches[i]);
+                        drm_printf(p, "\t\t\toffset[%d]=%u\n", i, fb->offsets[i]);
+                        drm_printf(p, "\t\t\tmodifier[%d]=0x%llx\n", i, fb->modifier[i]);
+                }
+        }
+        drm_printf(p, "\tcrtc-pos=" DRM_RECT_FMT "\n", DRM_RECT_ARG(&dest));
+        drm_printf(p, "\tsrc-pos=" DRM_RECT_FP_FMT "\n", DRM_RECT_FP_ARG(&src));
+        drm_printf(p, "\trotation=%x\n", state->rotation);
+
+        if (plane->funcs->atomic_print_state)
+                plane->funcs->atomic_print_state(p, state);
+}
+
 /**
  * drm_atomic_get_connector_state - get connector state
  * @state: global atomic state object
@@ -996,6 +1051,18 @@ int drm_atomic_connector_set_property(struct drm_connector *connector,
 }
 EXPORT_SYMBOL(drm_atomic_connector_set_property);
 
+static void drm_atomic_connector_print_state(struct drm_printer *p,
+                const struct drm_connector_state *state)
+{
+        struct drm_connector *connector = state->connector;
+
+        drm_printf(p, "connector[%u]: %s\n", connector->base.id, connector->name);
+        drm_printf(p, "\tcrtc=%s\n", state->crtc ? state->crtc->name : "(null)");
+
+        if (connector->funcs->atomic_print_state)
+                connector->funcs->atomic_print_state(p, state);
+}
+
 /**
  * drm_atomic_connector_get_property - get property value from connector state
  * @connector: the drm connector to set a property on
@@ -1150,6 +1217,36 @@ drm_atomic_set_fb_for_plane(struct drm_plane_state *plane_state,
 EXPORT_SYMBOL(drm_atomic_set_fb_for_plane);
 
 /**
+ * drm_atomic_set_fence_for_plane - set fence for plane
+ * @plane_state: atomic state object for the plane
+ * @fence: dma_fence to use for the plane
+ *
+ * Helper to setup the plane_state fence in case it is not set yet.
+ * By using this drivers doesn't need to worry if the user choose
+ * implicit or explicit fencing.
+ *
+ * This function will not set the fence to the state if it was set
+ * via explicit fencing interfaces on the atomic ioctl. It will
+ * all drope the reference to the fence as we not storing it
+ * anywhere.
+ *
+ * Otherwise, if plane_state->fence is not set this function we
+ * just set it with the received implict fence.
+ */
+void
+drm_atomic_set_fence_for_plane(struct drm_plane_state *plane_state,
+                               struct dma_fence *fence)
+{
+        if (plane_state->fence) {
+                dma_fence_put(fence);
+                return;
+        }
+
+        plane_state->fence = fence;
+}
+EXPORT_SYMBOL(drm_atomic_set_fence_for_plane);
+
+/**
  * drm_atomic_set_crtc_for_connector - set crtc for connector
  * @conn_state: atomic state object for the connector
  * @crtc: crtc to use for the connector
@@ -1460,6 +1557,92 @@ int drm_atomic_nonblocking_commit(struct drm_atomic_state *state)
 }
 EXPORT_SYMBOL(drm_atomic_nonblocking_commit);
 
+static void drm_atomic_print_state(const struct drm_atomic_state *state)
+{
+        struct drm_printer p = drm_info_printer(state->dev->dev);
+        struct drm_plane *plane;
+        struct drm_plane_state *plane_state;
+        struct drm_crtc *crtc;
+        struct drm_crtc_state *crtc_state;
+        struct drm_connector *connector;
+        struct drm_connector_state *connector_state;
+        int i;
+
+        DRM_DEBUG_ATOMIC("checking %p\n", state);
+
+        for_each_plane_in_state(state, plane, plane_state, i)
+                drm_atomic_plane_print_state(&p, plane_state);
+
+        for_each_crtc_in_state(state, crtc, crtc_state, i)
+                drm_atomic_crtc_print_state(&p, crtc_state);
+
+        for_each_connector_in_state(state, connector, connector_state, i)
+                drm_atomic_connector_print_state(&p, connector_state);
+}
+
+/**
+ * drm_state_dump - dump entire device atomic state
+ * @dev: the drm device
+ * @p: where to print the state to
+ *
+ * Just for debugging.  Drivers might want an option to dump state
+ * to dmesg in case of error irq's.  (Hint, you probably want to
+ * ratelimit this!)
+ *
+ * The caller must drm_modeset_lock_all(), or if this is called
+ * from error irq handler, it should not be enabled by default.
+ * (Ie. if you are debugging errors you might not care that this
+ * is racey.  But calling this without all modeset locks held is
+ * not inherently safe.)
+ */
+void drm_state_dump(struct drm_device *dev, struct drm_printer *p)
+{
+        struct drm_mode_config *config = &dev->mode_config;
+        struct drm_plane *plane;
+        struct drm_crtc *crtc;
+        struct drm_connector *connector;
+
+        if (!drm_core_check_feature(dev, DRIVER_ATOMIC))
+                return;
+
+        list_for_each_entry(plane, &config->plane_list, head)
+                drm_atomic_plane_print_state(p, plane->state);
+
+        list_for_each_entry(crtc, &config->crtc_list, head)
+                drm_atomic_crtc_print_state(p, crtc->state);
+
+        list_for_each_entry(connector, &config->connector_list, head)
+                drm_atomic_connector_print_state(p, connector->state);
+}
+EXPORT_SYMBOL(drm_state_dump);
+
+#ifdef CONFIG_DEBUG_FS
+static int drm_state_info(struct seq_file *m, void *data)
+{
+        struct drm_info_node *node = (struct drm_info_node *) m->private;
+        struct drm_device *dev = node->minor->dev;
+        struct drm_printer p = drm_seq_file_printer(m);
+
+        drm_modeset_lock_all(dev);
+        drm_state_dump(dev, &p);
+        drm_modeset_unlock_all(dev);
+
+        return 0;
+}
+
+/* any use in debugfs files to dump individual planes/crtc/etc? */
+static const struct drm_info_list drm_atomic_debugfs_list[] = {
+        {"state", drm_state_info, 0},
+};
+
+int drm_atomic_debugfs_init(struct drm_minor *minor)
+{
+        return drm_debugfs_create_files(drm_atomic_debugfs_list,
+                        ARRAY_SIZE(drm_atomic_debugfs_list),
+                        minor->debugfs_root, minor);
+}
+#endif
+
 /*
  * The big monstor ioctl
  */
@@ -1749,6 +1932,9 @@ retry:
         } else if (arg->flags & DRM_MODE_ATOMIC_NONBLOCK) {
                 ret = drm_atomic_nonblocking_commit(state);
         } else {
+                if (unlikely(drm_debug & DRM_UT_STATE))
+                        drm_atomic_print_state(state);
+
                 ret = drm_atomic_commit(state);
         }
 
diff --git a/drivers/gpu/drm/drm_crtc.c b/drivers/gpu/drm/drm_crtc.c
index 13441e21117c..ce274edb9e52 100644
--- a/drivers/gpu/drm/drm_crtc.c
+++ b/drivers/gpu/drm/drm_crtc.c
@@ -229,9 +229,9 @@ int drm_crtc_init_with_planes(struct drm_device *dev, struct drm_crtc *crtc,
 
         crtc->primary = primary;
         crtc->cursor = cursor;
-        if (primary)
+        if (primary && !primary->possible_crtcs)
                 primary->possible_crtcs = 1 << drm_crtc_index(crtc);
-        if (cursor)
+        if (cursor && !cursor->possible_crtcs)
                 cursor->possible_crtcs = 1 << drm_crtc_index(crtc);
 
         ret = drm_crtc_crc_init(crtc);
diff --git a/drivers/gpu/drm/drm_debugfs.c b/drivers/gpu/drm/drm_debugfs.c
index 800055c39cdb..206a4fe7ea26 100644
--- a/drivers/gpu/drm/drm_debugfs.c
+++ b/drivers/gpu/drm/drm_debugfs.c
@@ -36,6 +36,7 @@
 #include <linux/export.h>
 #include <drm/drmP.h>
 #include <drm/drm_edid.h>
+#include <drm/drm_atomic.h>
 #include "drm_internal.h"
 
 #if defined(CONFIG_DEBUG_FS)
@@ -163,6 +164,14 @@ int drm_debugfs_init(struct drm_minor *minor, int minor_id,
                 return ret;
         }
 
+        if (drm_core_check_feature(dev, DRIVER_ATOMIC)) {
+                ret = drm_atomic_debugfs_init(minor);
+                if (ret) {
+                        DRM_ERROR("Failed to create atomic debugfs files\n");
+                        return ret;
+                }
+        }
+
         if (dev->driver->debugfs_init) {
                 ret = dev->driver->debugfs_init(minor);
                 if (ret) {
diff --git a/drivers/gpu/drm/drm_edid.c b/drivers/gpu/drm/drm_edid.c
index 9506933b41cd..7eec18925b70 100644
--- a/drivers/gpu/drm/drm_edid.c
+++ b/drivers/gpu/drm/drm_edid.c
@@ -957,13 +957,13 @@ static const struct drm_display_mode edid_cea_modes[] = {
                    798, 858, 0, 480, 489, 495, 525, 0,
                    DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
           .vrefresh = 240, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
-        /* 58 - 720(1440)x480i@240 */
+        /* 58 - 720(1440)x480i@240Hz */
         { DRM_MODE("720x480i", DRM_MODE_TYPE_DRIVER, 54000, 720, 739,
                    801, 858, 0, 480, 488, 494, 525, 0,
                    DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
                         DRM_MODE_FLAG_INTERLACE | DRM_MODE_FLAG_DBLCLK),
           .vrefresh = 240, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_4_3, },
-        /* 59 - 720(1440)x480i@240 */
+        /* 59 - 720(1440)x480i@240Hz */
         { DRM_MODE("720x480i", DRM_MODE_TYPE_DRIVER, 54000, 720, 739,
                    801, 858, 0, 480, 488, 494, 525, 0,
                    DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
diff --git a/drivers/gpu/drm/drm_fops.c b/drivers/gpu/drm/drm_fops.c
index cf993dbf602e..5d96de40b63f 100644
--- a/drivers/gpu/drm/drm_fops.c
+++ b/drivers/gpu/drm/drm_fops.c
@@ -51,10 +51,11 @@ DEFINE_MUTEX(drm_global_mutex);
  * Drivers must define the file operations structure that forms the DRM
  * userspace API entry point, even though most of those operations are
  * implemented in the DRM core. The mandatory functions are drm_open(),
- * drm_read(), drm_ioctl() and drm_compat_ioctl if CONFIG_COMPAT is enabled.
- * Drivers which implement private ioctls that require 32/64 bit compatibility
- * support must provided their onw .compat_ioctl() handler that processes
- * private ioctls and calls drm_compat_ioctl() for core ioctls.
+ * drm_read(), drm_ioctl() and drm_compat_ioctl() if CONFIG_COMPAT is enabled
+ * (note that drm_compat_ioctl will be NULL if CONFIG_COMPAT=n). Drivers which
+ * implement private ioctls that require 32/64 bit compatibility support must
+ * provide their own .compat_ioctl() handler that processes private ioctls and
+ * calls drm_compat_ioctl() for core ioctls.
  *
  * In addition drm_read() and drm_poll() provide support for DRM events. DRM
  * events are a generic and extensible means to send asynchronous events to
@@ -75,9 +76,7 @@ DEFINE_MUTEX(drm_global_mutex);
  *             .open = drm_open,
  *             .release = drm_release,
  *             .unlocked_ioctl = drm_ioctl,
- *     #ifdef CONFIG_COMPAT
- *             .compat_ioctl = drm_compat_ioctl,
- *     #endif
+ *             .compat_ioctl = drm_compat_ioctl, // NULL if CONFIG_COMPAT=n
  *             .poll = drm_poll,
  *             .read = drm_read,
  *             .llseek = no_llseek,
diff --git a/drivers/gpu/drm/drm_framebuffer.c b/drivers/gpu/drm/drm_framebuffer.c
index 49fd7db758e0..af786f27f72e 100644
--- a/drivers/gpu/drm/drm_framebuffer.c
+++ b/drivers/gpu/drm/drm_framebuffer.c
@@ -673,6 +673,11 @@ EXPORT_SYMBOL(drm_framebuffer_lookup);
  * those used for fbdev. Note that the caller must hold a reference of it's own,
  * i.e. the object may not be destroyed through this call (since it'll lead to a
  * locking inversion).
+ *
+ * NOTE: This function is deprecated. For driver-private framebuffers it is not
+ * recommended to embed a framebuffer struct info fbdev struct, instead, a
+ * framebuffer pointer is preferred and drm_framebuffer_unreference() should be
+ * called when the framebuffer is to be cleaned up.
  */
 void drm_framebuffer_unregister_private(struct drm_framebuffer *fb)
 {
diff --git a/drivers/gpu/drm/drm_mm.c b/drivers/gpu/drm/drm_mm.c
index 11d44a1e0ab3..632473beb40c 100644
--- a/drivers/gpu/drm/drm_mm.c
+++ b/drivers/gpu/drm/drm_mm.c
@@ -104,6 +104,68 @@ static struct drm_mm_node *drm_mm_search_free_in_range_generic(const struct drm_
                                                 u64 end,
                                                 enum drm_mm_search_flags flags);
 
+#ifdef CONFIG_DRM_DEBUG_MM
+#include <linux/stackdepot.h>
+
+#define STACKDEPTH 32
+#define BUFSZ 4096
+
+static noinline void save_stack(struct drm_mm_node *node)
+{
+        unsigned long entries[STACKDEPTH];
+        struct stack_trace trace = {
+                .entries = entries,
+                .max_entries = STACKDEPTH,
+                .skip = 1
+        };
+
+        save_stack_trace(&trace);
+        if (trace.nr_entries != 0 &&
+            trace.entries[trace.nr_entries-1] == ULONG_MAX)
+                trace.nr_entries--;
+
+        /* May be called under spinlock, so avoid sleeping */
+        node->stack = depot_save_stack(&trace, GFP_NOWAIT);
+}
+
+static void show_leaks(struct drm_mm *mm)
+{
+        struct drm_mm_node *node;
+        unsigned long entries[STACKDEPTH];
+        char *buf;
+
+        buf = kmalloc(BUFSZ, GFP_KERNEL);
+        if (!buf)
+                return;
+
+        list_for_each_entry(node, &mm->head_node.node_list, node_list) {
+                struct stack_trace trace = {
+                        .entries = entries,
+                        .max_entries = STACKDEPTH
+                };
+
+                if (!node->stack) {
+                        DRM_ERROR("node [%08llx + %08llx]: unknown owner\n",
+                                  node->start, node->size);
+                        continue;
+                }
+
+                depot_fetch_stack(node->stack, &trace);
+                snprint_stack_trace(buf, BUFSZ, &trace, 0);
+                DRM_ERROR("node [%08llx + %08llx]: inserted at\n%s",
+                          node->start, node->size, buf);
+        }
+
+        kfree(buf);
+}
+
+#undef STACKDEPTH
+#undef BUFSZ
+#else
+static void save_stack(struct drm_mm_node *node) { }
+static void show_leaks(struct drm_mm *mm) { }
+#endif
+
 #define START(node) ((node)->start)
 #define LAST(node)  ((node)->start + (node)->size - 1)
 
@@ -228,6 +290,8 @@ static void drm_mm_insert_helper(struct drm_mm_node *hole_node,
                 list_add(&node->hole_stack, &mm->hole_stack);
                 node->hole_follows = 1;
         }
+
+        save_stack(node);
 }
 
 /**
@@ -293,6 +357,8 @@ int drm_mm_reserve_node(struct drm_mm *mm, struct drm_mm_node *node)
                 node->hole_follows = 1;
         }
 
+        save_stack(node);
+
         return 0;
 }
 EXPORT_SYMBOL(drm_mm_reserve_node);
@@ -397,6 +463,8 @@ static void drm_mm_insert_helper_range(struct drm_mm_node *hole_node,
                 list_add(&node->hole_stack, &mm->hole_stack);
                 node->hole_follows = 1;
         }
+
+        save_stack(node);
 }
 
 /**
@@ -861,10 +929,12 @@ EXPORT_SYMBOL(drm_mm_init);
  * Note that it is a bug to call this function on an allocator which is not
  * clean.
  */
-void drm_mm_takedown(struct drm_mm * mm)
+void drm_mm_takedown(struct drm_mm *mm)
 {
-        WARN(!list_empty(&mm->head_node.node_list),
-             "Memory manager not clean during takedown.\n");
+        if (WARN(!list_empty(&mm->head_node.node_list),
+                 "Memory manager not clean during takedown.\n"))
+                show_leaks(mm);
+
 }
 EXPORT_SYMBOL(drm_mm_takedown);
 
diff --git a/drivers/gpu/drm/drm_modes.c b/drivers/gpu/drm/drm_modes.c
index f64ac86deb84..ce6eeda02acf 100644
--- a/drivers/gpu/drm/drm_modes.c
+++ b/drivers/gpu/drm/drm_modes.c
@@ -49,13 +49,7 @@
  */
 void drm_mode_debug_printmodeline(const struct drm_display_mode *mode)
 {
-        DRM_DEBUG_KMS("Modeline %d:\"%s\" %d %d %d %d %d %d %d %d %d %d "
-                        "0x%x 0x%x\n",
-                mode->base.id, mode->name, mode->vrefresh, mode->clock,
-                mode->hdisplay, mode->hsync_start,
-                mode->hsync_end, mode->htotal,
-                mode->vdisplay, mode->vsync_start,
-                mode->vsync_end, mode->vtotal, mode->type, mode->flags);
+        DRM_DEBUG_KMS("Modeline " DRM_MODE_FMT "\n", DRM_MODE_ARG(mode));
 }
 EXPORT_SYMBOL(drm_mode_debug_printmodeline);
 
diff --git a/drivers/gpu/drm/drm_plane_helper.c b/drivers/gpu/drm/drm_plane_helper.c
index 7899fc1dcdb0..7a7dddf604d7 100644
--- a/drivers/gpu/drm/drm_plane_helper.c
+++ b/drivers/gpu/drm/drm_plane_helper.c
@@ -130,15 +130,8 @@ int drm_plane_helper_check_state(struct drm_plane_state *state,
         unsigned int rotation = state->rotation;
         int hscale, vscale;
 
-        src->x1 = state->src_x;
-        src->y1 = state->src_y;
-        src->x2 = state->src_x + state->src_w;
-        src->y2 = state->src_y + state->src_h;
-
-        dst->x1 = state->crtc_x;
-        dst->y1 = state->crtc_y;
-        dst->x2 = state->crtc_x + state->crtc_w;
-        dst->y2 = state->crtc_y + state->crtc_h;
+        *src = drm_plane_state_src(state);
+        *dst = drm_plane_state_dest(state);
 
         if (!fb) {
                 state->visible = false;
diff --git a/drivers/gpu/drm/drm_print.c b/drivers/gpu/drm/drm_print.c
new file mode 100644
index 000000000000..34eb85618b76
--- /dev/null
+++ b/drivers/gpu/drm/drm_print.c
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2016 Red Hat
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ * Rob Clark <robdclark@gmail.com>
+ */
+
+#include <stdarg.h>
+#include <linux/seq_file.h>
+#include <drm/drmP.h>
+#include <drm/drm_print.h>
+
+void __drm_printfn_seq_file(struct drm_printer *p, struct va_format *vaf)
+{
+        seq_printf(p->arg, "%pV", vaf);
+}
+EXPORT_SYMBOL(__drm_printfn_seq_file);
+
+void __drm_printfn_info(struct drm_printer *p, struct va_format *vaf)
+{
+        dev_printk(KERN_INFO, p->arg, "[" DRM_NAME "] %pV", vaf);
+}
+EXPORT_SYMBOL(__drm_printfn_info);
+
+void drm_printf(struct drm_printer *p, const char *f, ...)
+{
+        struct va_format vaf;
+        va_list args;
+
+        va_start(args, f);
+        vaf.fmt = f;
+        vaf.va = &args;
+        p->printfn(p, &vaf);
+        va_end(args);
+}
+EXPORT_SYMBOL(drm_printf);
diff --git a/drivers/gpu/drm/drm_rect.c b/drivers/gpu/drm/drm_rect.c
index 73e53a8d1b37..e6057d8cdcd5 100644
--- a/drivers/gpu/drm/drm_rect.c
+++ b/drivers/gpu/drm/drm_rect.c
@@ -281,17 +281,10 @@ EXPORT_SYMBOL(drm_rect_calc_vscale_relaxed);
  */
 void drm_rect_debug_print(const char *prefix, const struct drm_rect *r, bool fixed_point)
 {
-        int w = drm_rect_width(r);
-        int h = drm_rect_height(r);
-
         if (fixed_point)
-                DRM_DEBUG_KMS("%s%d.%06ux%d.%06u%+d.%06u%+d.%06u\n", prefix,
-                              w >> 16, ((w & 0xffff) * 15625) >> 10,
-                              h >> 16, ((h & 0xffff) * 15625) >> 10,
-                              r->x1 >> 16, ((r->x1 & 0xffff) * 15625) >> 10,
-                              r->y1 >> 16, ((r->y1 & 0xffff) * 15625) >> 10);
+                DRM_DEBUG_KMS("%s" DRM_RECT_FP_FMT "\n", prefix, DRM_RECT_FP_ARG(r));
         else
-                DRM_DEBUG_KMS("%s%dx%d%+d%+d\n", prefix, w, h, r->x1, r->y1);
+                DRM_DEBUG_KMS("%s" DRM_RECT_FMT "\n", prefix, DRM_RECT_ARG(r));
 }
 EXPORT_SYMBOL(drm_rect_debug_print);
 
diff --git a/drivers/gpu/drm/etnaviv/etnaviv_drv.c b/drivers/gpu/drm/etnaviv/etnaviv_drv.c
index 0dee6acbd880..a6799b0aa3d9 100644
--- a/drivers/gpu/drm/etnaviv/etnaviv_drv.c
+++ b/drivers/gpu/drm/etnaviv/etnaviv_drv.c
@@ -479,9 +479,7 @@ static const struct file_operations fops = {
         .open               = drm_open,
         .release            = drm_release,
         .unlocked_ioctl     = drm_ioctl,
-#ifdef CONFIG_COMPAT
         .compat_ioctl       = drm_compat_ioctl,
-#endif
         .poll               = drm_poll,
         .read               = drm_read,
         .llseek             = no_llseek,
diff --git a/drivers/gpu/drm/exynos/exynos_drm_drv.c b/drivers/gpu/drm/exynos/exynos_drm_drv.c
index 463d6fd56756..739180ac3da5 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_drv.c
+++ b/drivers/gpu/drm/exynos/exynos_drm_drv.c
@@ -366,9 +366,7 @@ static const struct file_operations exynos_drm_driver_fops = {
         .poll           = drm_poll,
         .read           = drm_read,
         .unlocked_ioctl = drm_ioctl,
-#ifdef CONFIG_COMPAT
         .compat_ioctl = drm_compat_ioctl,
-#endif
         .release        = drm_release,
 };
 
diff --git a/drivers/gpu/drm/fsl-dcu/fsl_dcu_drm_drv.c b/drivers/gpu/drm/fsl-dcu/fsl_dcu_drm_drv.c
index e04efbed1a54..0b0d1cb11641 100644
--- a/drivers/gpu/drm/fsl-dcu/fsl_dcu_drm_drv.c
+++ b/drivers/gpu/drm/fsl-dcu/fsl_dcu_drm_drv.c
@@ -180,9 +180,7 @@ static const struct file_operations fsl_dcu_drm_fops = {
         .open           = drm_open,
         .release        = drm_release,
         .unlocked_ioctl = drm_ioctl,
-#ifdef CONFIG_COMPAT
         .compat_ioctl   = drm_compat_ioctl,
-#endif
         .poll           = drm_poll,
         .read           = drm_read,
         .llseek         = no_llseek,
diff --git a/drivers/gpu/drm/gma500/gtt.c b/drivers/gpu/drm/gma500/gtt.c
index 76aea2e7fb9d..3f4f424196b2 100644
--- a/drivers/gpu/drm/gma500/gtt.c
+++ b/drivers/gpu/drm/gma500/gtt.c
@@ -131,7 +131,7 @@ static int psb_gtt_insert(struct drm_device *dev, struct gtt_range *r,
  *      page table entries with the dummy page. This is protected via the gtt
  *      mutex which the caller must hold.
  */
-void psb_gtt_remove(struct drm_device *dev, struct gtt_range *r)
+static void psb_gtt_remove(struct drm_device *dev, struct gtt_range *r)
 {
         struct drm_psb_private *dev_priv = dev->dev_private;
         u32 __iomem *gtt_slot;
diff --git a/drivers/gpu/drm/gma500/psb_drv.c b/drivers/gpu/drm/gma500/psb_drv.c
index 50eb944fb78a..ff37ea585664 100644
--- a/drivers/gpu/drm/gma500/psb_drv.c
+++ b/drivers/gpu/drm/gma500/psb_drv.c
@@ -473,6 +473,7 @@ static const struct file_operations psb_gem_fops = {
         .open = drm_open,
         .release = drm_release,
         .unlocked_ioctl = psb_unlocked_ioctl,
+        .compat_ioctl = drm_compat_ioctl,
         .mmap = drm_gem_mmap,
         .poll = drm_poll,
         .read = drm_read,
diff --git a/drivers/gpu/drm/gma500/psb_drv.h b/drivers/gpu/drm/gma500/psb_drv.h
index b74372760d7f..05d7aaf47eea 100644
--- a/drivers/gpu/drm/gma500/psb_drv.h
+++ b/drivers/gpu/drm/gma500/psb_drv.h
@@ -753,10 +753,6 @@ extern int psb_gem_dumb_create(struct drm_file *file, struct drm_device *dev,
 extern int psb_gem_dumb_map_gtt(struct drm_file *file, struct drm_device *dev,
                         uint32_t handle, uint64_t *offset);
 extern int psb_gem_fault(struct vm_area_struct *vma, struct vm_fault *vmf);
-extern int psb_gem_create_ioctl(struct drm_device *dev, void *data,
-                        struct drm_file *file);
-extern int psb_gem_mmap_ioctl(struct drm_device *dev, void *data,
-                                        struct drm_file *file);
 
 /* psb_device.c */
 extern const struct psb_ops psb_chip_ops;
diff --git a/drivers/gpu/drm/hisilicon/kirin/kirin_drm_drv.c b/drivers/gpu/drm/hisilicon/kirin/kirin_drm_drv.c
index e88fde18c946..ebd5f4fe4c23 100644
--- a/drivers/gpu/drm/hisilicon/kirin/kirin_drm_drv.c
+++ b/drivers/gpu/drm/hisilicon/kirin/kirin_drm_drv.c
@@ -152,9 +152,7 @@ static const struct file_operations kirin_drm_fops = {
         .open           = drm_open,
         .release        = drm_release,
         .unlocked_ioctl = drm_ioctl,
-#ifdef CONFIG_COMPAT
         .compat_ioctl   = drm_compat_ioctl,
-#endif
         .poll           = drm_poll,
         .read           = drm_read,
         .llseek         = no_llseek,
diff --git a/drivers/gpu/drm/i810/i810_dma.c b/drivers/gpu/drm/i810/i810_dma.c
index d91856779beb..ab4e6cbe1f8b 100644
--- a/drivers/gpu/drm/i810/i810_dma.c
+++ b/drivers/gpu/drm/i810/i810_dma.c
@@ -113,9 +113,7 @@ static const struct file_operations i810_buffer_fops = {
         .release = drm_release,
         .unlocked_ioctl = drm_ioctl,
         .mmap = i810_mmap_buffers,
-#ifdef CONFIG_COMPAT
         .compat_ioctl = drm_compat_ioctl,
-#endif
         .llseek = noop_llseek,
 };
 
diff --git a/drivers/gpu/drm/i810/i810_drv.c b/drivers/gpu/drm/i810/i810_drv.c
index 0be55dc1ef4b..02504a7cfaf2 100644
--- a/drivers/gpu/drm/i810/i810_drv.c
+++ b/drivers/gpu/drm/i810/i810_drv.c
@@ -49,9 +49,7 @@ static const struct file_operations i810_driver_fops = {
         .unlocked_ioctl = drm_ioctl,
         .mmap = drm_legacy_mmap,
         .poll = drm_poll,
-#ifdef CONFIG_COMPAT
         .compat_ioctl = drm_compat_ioctl,
-#endif
         .llseek = noop_llseek,
 };
 
diff --git a/drivers/gpu/drm/i915/Kconfig.debug b/drivers/gpu/drm/i915/Kconfig.debug
index cee87bfd10c4..51ba630a134b 100644
--- a/drivers/gpu/drm/i915/Kconfig.debug
+++ b/drivers/gpu/drm/i915/Kconfig.debug
@@ -21,6 +21,7 @@ config DRM_I915_DEBUG
         select PREEMPT_COUNT
         select X86_MSR # used by igt/pm_rpm
         select DRM_VGEM # used by igt/prime_vgem (dmabuf interop checks)
+        select DRM_DEBUG_MM if DRM=y
         default n
         help
           Choose this option to turn on extra driver debugging that may affect
diff --git a/drivers/gpu/drm/i915/i915_drv.c b/drivers/gpu/drm/i915/i915_drv.c
index b72c24ff39c3..0213a3090ab3 100644
--- a/drivers/gpu/drm/i915/i915_drv.c
+++ b/drivers/gpu/drm/i915/i915_drv.c
@@ -2497,9 +2497,7 @@ static const struct file_operations i915_driver_fops = {
         .mmap = drm_gem_mmap,
         .poll = drm_poll,
         .read = drm_read,
-#ifdef CONFIG_COMPAT
         .compat_ioctl = i915_compat_ioctl,
-#endif
         .llseek = noop_llseek,
 };
 
diff --git a/drivers/gpu/drm/i915/i915_drv.h b/drivers/gpu/drm/i915/i915_drv.h
index 80775b882b4a..6f4a6bcf6ed4 100644
--- a/drivers/gpu/drm/i915/i915_drv.h
+++ b/drivers/gpu/drm/i915/i915_drv.h
@@ -3001,6 +3001,8 @@ __i915_printk(struct drm_i915_private *dev_priv, const char *level,
 #ifdef CONFIG_COMPAT
 extern long i915_compat_ioctl(struct file *filp, unsigned int cmd,
                               unsigned long arg);
+#else
+#define i915_compat_ioctl NULL
 #endif
 extern const struct dev_pm_ops i915_pm_ops;
 
diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c
index 92ab01f33208..f4e321853fa4 100644
--- a/drivers/gpu/drm/i915/intel_display.c
+++ b/drivers/gpu/drm/i915/intel_display.c
@@ -2821,14 +2821,8 @@ valid_fb:
         plane_state->crtc_w = fb->width;
         plane_state->crtc_h = fb->height;
 
-        intel_state->base.src.x1 = plane_state->src_x;
-        intel_state->base.src.y1 = plane_state->src_y;
-        intel_state->base.src.x2 = plane_state->src_x + plane_state->src_w;
-        intel_state->base.src.y2 = plane_state->src_y + plane_state->src_h;
-        intel_state->base.dst.x1 = plane_state->crtc_x;
-        intel_state->base.dst.y1 = plane_state->crtc_y;
-        intel_state->base.dst.x2 = plane_state->crtc_x + plane_state->crtc_w;
-        intel_state->base.dst.y2 = plane_state->crtc_y + plane_state->crtc_h;
+        intel_state->base.src = drm_plane_state_src(plane_state);
+        intel_state->base.dst = drm_plane_state_dest(plane_state);
 
         obj = intel_fb_obj(fb);
         if (i915_gem_object_is_tiled(obj))
diff --git a/drivers/gpu/drm/i915/intel_sprite.c b/drivers/gpu/drm/i915/intel_sprite.c
index df0fbb4b15a3..0e9aac2e3eae 100644
--- a/drivers/gpu/drm/i915/intel_sprite.c
+++ b/drivers/gpu/drm/i915/intel_sprite.c
@@ -773,15 +773,8 @@ intel_check_sprite_plane(struct drm_plane *plane,
         bool can_scale;
         int ret;
 
-        src->x1 = state->base.src_x;
-        src->y1 = state->base.src_y;
-        src->x2 = state->base.src_x + state->base.src_w;
-        src->y2 = state->base.src_y + state->base.src_h;
-
-        dst->x1 = state->base.crtc_x;
-        dst->y1 = state->base.crtc_y;
-        dst->x2 = state->base.crtc_x + state->base.crtc_w;
-        dst->y2 = state->base.crtc_y + state->base.crtc_h;
+        *src = drm_plane_state_src(&state->base);
+        *dst = drm_plane_state_dest(&state->base);
 
         if (!fb) {
                 state->base.visible = false;
diff --git a/drivers/gpu/drm/imx/imx-drm-core.c b/drivers/gpu/drm/imx/imx-drm-core.c
index 9672b579f950..a16e8b7df120 100644
--- a/drivers/gpu/drm/imx/imx-drm-core.c
+++ b/drivers/gpu/drm/imx/imx-drm-core.c
@@ -158,6 +158,7 @@ static int imx_drm_atomic_commit(struct drm_device *dev,
         struct drm_plane_state *plane_state;
         struct drm_plane *plane;
         struct dma_buf *dma_buf;
+        struct dma_fence *fence;
         int i;
 
         /*
@@ -170,8 +171,9 @@ static int imx_drm_atomic_commit(struct drm_device *dev,
                                                          0)->base.dma_buf;
                         if (!dma_buf)
                                 continue;
-                        plane_state->fence =
-                                reservation_object_get_excl_rcu(dma_buf->resv);
+                        fence = reservation_object_get_excl_rcu(dma_buf->resv);
+
+                        drm_atomic_set_fence_for_plane(plane_state, fence);
                 }
         }
 
diff --git a/drivers/gpu/drm/mediatek/mtk_drm_drv.c b/drivers/gpu/drm/mediatek/mtk_drm_drv.c
index 296f541fbe2f..d90152e85ed0 100644
--- a/drivers/gpu/drm/mediatek/mtk_drm_drv.c
+++ b/drivers/gpu/drm/mediatek/mtk_drm_drv.c
@@ -249,9 +249,7 @@ static const struct file_operations mtk_drm_fops = {
         .mmap = mtk_drm_gem_mmap,
         .poll = drm_poll,
         .read = drm_read,
-#ifdef CONFIG_COMPAT
         .compat_ioctl = drm_compat_ioctl,
-#endif
 };
 
 static struct drm_driver mtk_drm_driver = {
diff --git a/drivers/gpu/drm/mgag200/mgag200_drv.c b/drivers/gpu/drm/mgag200/mgag200_drv.c
index 1443b3a34775..b0b874264f9d 100644
--- a/drivers/gpu/drm/mgag200/mgag200_drv.c
+++ b/drivers/gpu/drm/mgag200/mgag200_drv.c
@@ -82,9 +82,7 @@ static const struct file_operations mgag200_driver_fops = {
         .unlocked_ioctl = drm_ioctl,
         .mmap = mgag200_mmap,
         .poll = drm_poll,
-#ifdef CONFIG_COMPAT
         .compat_ioctl = drm_compat_ioctl,
-#endif
         .read = drm_read,
 };
 
diff --git a/drivers/gpu/drm/msm/mdp/mdp4/mdp4_irq.c b/drivers/gpu/drm/msm/mdp/mdp4/mdp4_irq.c
index a521207db8a1..b764d7f10312 100644
--- a/drivers/gpu/drm/msm/mdp/mdp4/mdp4_irq.c
+++ b/drivers/gpu/drm/msm/mdp/mdp4/mdp4_irq.c
@@ -15,6 +15,7 @@
  * this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <drm/drm_print.h>
 
 #include "msm_drv.h"
 #include "mdp4_kms.h"
@@ -29,7 +30,16 @@ void mdp4_set_irqmask(struct mdp_kms *mdp_kms, uint32_t irqmask,
 
 static void mdp4_irq_error_handler(struct mdp_irq *irq, uint32_t irqstatus)
 {
+        struct mdp4_kms *mdp4_kms = container_of(irq, struct mdp4_kms, error_handler);
+        static DEFINE_RATELIMIT_STATE(rs, 5*HZ, 1);
+        extern bool dumpstate;
+
         DRM_ERROR_RATELIMITED("errors: %08x\n", irqstatus);
+
+        if (dumpstate && __ratelimit(&rs)) {
+                struct drm_printer p = drm_info_printer(mdp4_kms->dev->dev);
+                drm_state_dump(mdp4_kms->dev, &p);
+        }
 }
 
 void mdp4_irq_preinstall(struct msm_kms *kms)
diff --git a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_irq.c b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_irq.c
index d53e5510fd7c..5c5940db898e 100644
--- a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_irq.c
+++ b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_irq.c
@@ -17,6 +17,8 @@
 
 #include <linux/irq.h>
 
+#include <drm/drm_print.h>
+
 #include "msm_drv.h"
 #include "mdp5_kms.h"
 
@@ -30,7 +32,16 @@ void mdp5_set_irqmask(struct mdp_kms *mdp_kms, uint32_t irqmask,
 
 static void mdp5_irq_error_handler(struct mdp_irq *irq, uint32_t irqstatus)
 {
+        struct mdp5_kms *mdp5_kms = container_of(irq, struct mdp5_kms, error_handler);
+        static DEFINE_RATELIMIT_STATE(rs, 5*HZ, 1);
+        extern bool dumpstate;
+
         DRM_ERROR_RATELIMITED("errors: %08x\n", irqstatus);
+
+        if (dumpstate && __ratelimit(&rs)) {
+                struct drm_printer p = drm_info_printer(mdp5_kms->dev->dev);
+                drm_state_dump(mdp5_kms->dev, &p);
+        }
 }
 
 void mdp5_irq_preinstall(struct msm_kms *kms)
diff --git a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_kms.h b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_kms.h
index 03738927be10..c6fbcfad2d59 100644
--- a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_kms.h
+++ b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_kms.h
@@ -114,6 +114,18 @@ static inline u32 mdp5_read(struct mdp5_kms *mdp5_kms, u32 reg)
         return msm_readl(mdp5_kms->mmio + reg);
 }
 
+static inline const char *stage2name(enum mdp_mixer_stage_id stage)
+{
+        static const char *names[] = {
+#define NAME(n) [n] = #n
+                NAME(STAGE_UNUSED), NAME(STAGE_BASE),
+                NAME(STAGE0), NAME(STAGE1), NAME(STAGE2),
+                NAME(STAGE3), NAME(STAGE4), NAME(STAGE6),
+#undef NAME
+        };
+        return names[stage];
+}
+
 static inline const char *pipe2name(enum mdp5_pipe pipe)
 {
         static const char *names[] = {
diff --git a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c
index cf50d3ec8d1b..8bf55e3450c5 100644
--- a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c
+++ b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c
@@ -16,6 +16,7 @@
  * this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <drm/drm_print.h>
 #include "mdp5_kms.h"
 
 struct mdp5_plane {
@@ -181,6 +182,20 @@ done:
 #undef SET_PROPERTY
 }
 
+static void
+mdp5_plane_atomic_print_state(struct drm_printer *p,
+                const struct drm_plane_state *state)
+{
+        struct mdp5_plane_state *pstate = to_mdp5_plane_state(state);
+
+        drm_printf(p, "\tpremultiplied=%u\n", pstate->premultiplied);
+        drm_printf(p, "\tzpos=%u\n", pstate->zpos);
+        drm_printf(p, "\talpha=%u\n", pstate->alpha);
+        drm_printf(p, "\tstage=%s\n", stage2name(pstate->stage));
+        drm_printf(p, "\tmode_changed=%u\n", pstate->mode_changed);
+        drm_printf(p, "\tpending=%u\n", pstate->pending);
+}
+
 static void mdp5_plane_reset(struct drm_plane *plane)
 {
         struct mdp5_plane_state *mdp5_state;
@@ -244,6 +259,7 @@ static const struct drm_plane_funcs mdp5_plane_funcs = {
                 .reset = mdp5_plane_reset,
                 .atomic_duplicate_state = mdp5_plane_duplicate_state,
                 .atomic_destroy_state = mdp5_plane_destroy_state,
+                .atomic_print_state = mdp5_plane_atomic_print_state,
 };
 
 static int mdp5_plane_prepare_fb(struct drm_plane *plane,
@@ -913,7 +929,7 @@ struct drm_plane *mdp5_plane_init(struct drm_device *dev,
         type = private_plane ? DRM_PLANE_TYPE_PRIMARY : DRM_PLANE_TYPE_OVERLAY;
         ret = drm_universal_plane_init(dev, plane, 0xff, &mdp5_plane_funcs,
                                  mdp5_plane->formats, mdp5_plane->nformats,
-                                 type, NULL);
+                                 type, "%s", mdp5_plane->name);
         if (ret)
                 goto fail;
 
diff --git a/drivers/gpu/drm/msm/msm_atomic.c b/drivers/gpu/drm/msm/msm_atomic.c
index db193f835298..4e21e1d72378 100644
--- a/drivers/gpu/drm/msm/msm_atomic.c
+++ b/drivers/gpu/drm/msm/msm_atomic.c
@@ -217,8 +217,9 @@ int msm_atomic_commit(struct drm_device *dev,
                 if ((plane->state->fb != plane_state->fb) && plane_state->fb) {
                         struct drm_gem_object *obj = msm_framebuffer_bo(plane_state->fb, 0);
                         struct msm_gem_object *msm_obj = to_msm_bo(obj);
+                        struct dma_fence *fence = reservation_object_get_excl_rcu(msm_obj->resv);
 
-                        plane_state->fence = reservation_object_get_excl_rcu(msm_obj->resv);
+                        drm_atomic_set_fence_for_plane(plane_state, fence);
                 }
         }
 
diff --git a/drivers/gpu/drm/msm/msm_drv.c b/drivers/gpu/drm/msm/msm_drv.c
index 84d38eaea585..8d21fb27a401 100644
--- a/drivers/gpu/drm/msm/msm_drv.c
+++ b/drivers/gpu/drm/msm/msm_drv.c
@@ -79,6 +79,10 @@ static char *vram = "16m";
 MODULE_PARM_DESC(vram, "Configure VRAM size (for devices without IOMMU/GPUMMU)");
 module_param(vram, charp, 0);
 
+bool dumpstate = false;
+MODULE_PARM_DESC(dumpstate, "Dump KMS state on errors");
+module_param(dumpstate, bool, 0600);
+
 /*
  * Util/helpers:
  */
@@ -768,9 +772,7 @@ static const struct file_operations fops = {
         .open               = drm_open,
         .release            = drm_release,
         .unlocked_ioctl     = drm_ioctl,
-#ifdef CONFIG_COMPAT
         .compat_ioctl       = drm_compat_ioctl,
-#endif
         .poll               = drm_poll,
         .read               = drm_read,
         .llseek             = no_llseek,
diff --git a/drivers/gpu/drm/rcar-du/rcar_du_drv.c b/drivers/gpu/drm/rcar-du/rcar_du_drv.c
index 73c971e39b1c..68fd167d7313 100644
--- a/drivers/gpu/drm/rcar-du/rcar_du_drv.c
+++ b/drivers/gpu/drm/rcar-du/rcar_du_drv.c
@@ -201,9 +201,7 @@ static const struct file_operations rcar_du_fops = {
         .open           = drm_open,
         .release        = drm_release,
         .unlocked_ioctl = drm_ioctl,
-#ifdef CONFIG_COMPAT
         .compat_ioctl   = drm_compat_ioctl,
-#endif
         .poll           = drm_poll,
         .read           = drm_read,
         .llseek         = no_llseek,
diff --git a/drivers/gpu/drm/rockchip/rockchip_drm_drv.c b/drivers/gpu/drm/rockchip/rockchip_drm_drv.c
index 6fe161192bb4..2390c8577617 100644
--- a/drivers/gpu/drm/rockchip/rockchip_drm_drv.c
+++ b/drivers/gpu/drm/rockchip/rockchip_drm_drv.c
@@ -275,9 +275,7 @@ static const struct file_operations rockchip_drm_driver_fops = {
         .poll = drm_poll,
         .read = drm_read,
         .unlocked_ioctl = drm_ioctl,
-#ifdef CONFIG_COMPAT
         .compat_ioctl = drm_compat_ioctl,
-#endif
         .release = drm_release,
 };
 
diff --git a/drivers/gpu/drm/savage/savage_drv.c b/drivers/gpu/drm/savage/savage_drv.c
index 3b807135a5cd..78c6d8e9b42c 100644
--- a/drivers/gpu/drm/savage/savage_drv.c
+++ b/drivers/gpu/drm/savage/savage_drv.c
@@ -42,9 +42,7 @@ static const struct file_operations savage_driver_fops = {
         .unlocked_ioctl = drm_ioctl,
         .mmap = drm_legacy_mmap,
         .poll = drm_poll,
-#ifdef CONFIG_COMPAT
         .compat_ioctl = drm_compat_ioctl,
-#endif
         .llseek = noop_llseek,
 };
 
diff --git a/drivers/gpu/drm/shmobile/shmob_drm_drv.c b/drivers/gpu/drm/shmobile/shmob_drm_drv.c
index f0492603ea88..38dd55f4af81 100644
--- a/drivers/gpu/drm/shmobile/shmob_drm_drv.c
+++ b/drivers/gpu/drm/shmobile/shmob_drm_drv.c
@@ -245,9 +245,7 @@ static const struct file_operations shmob_drm_fops = {
         .open           = drm_open,
         .release        = drm_release,
         .unlocked_ioctl = drm_ioctl,
-#ifdef CONFIG_COMPAT
         .compat_ioctl   = drm_compat_ioctl,
-#endif
         .poll           = drm_poll,
         .read           = drm_read,
         .llseek         = no_llseek,
diff --git a/drivers/gpu/drm/sis/sis_drv.c b/drivers/gpu/drm/sis/sis_drv.c
index ae9839886c4d..a836451920f0 100644
--- a/drivers/gpu/drm/sis/sis_drv.c
+++ b/drivers/gpu/drm/sis/sis_drv.c
@@ -72,9 +72,7 @@ static const struct file_operations sis_driver_fops = {
         .unlocked_ioctl = drm_ioctl,
         .mmap = drm_legacy_mmap,
         .poll = drm_poll,
-#ifdef CONFIG_COMPAT
         .compat_ioctl = drm_compat_ioctl,
-#endif
         .llseek = noop_llseek,
 };
 
diff --git a/drivers/gpu/drm/sti/sti_drv.c b/drivers/gpu/drm/sti/sti_drv.c
index d614701bdcc7..ff71e25ab5bf 100644
--- a/drivers/gpu/drm/sti/sti_drv.c
+++ b/drivers/gpu/drm/sti/sti_drv.c
@@ -297,9 +297,7 @@ static const struct file_operations sti_driver_fops = {
         .poll = drm_poll,
         .read = drm_read,
         .unlocked_ioctl = drm_ioctl,
-#ifdef CONFIG_COMPAT
         .compat_ioctl = drm_compat_ioctl,
-#endif
         .release = drm_release,
 };
 
diff --git a/drivers/gpu/drm/sun4i/sun4i_drv.c b/drivers/gpu/drm/sun4i/sun4i_drv.c
index b3c4ad605e81..aae723cd6d79 100644
--- a/drivers/gpu/drm/sun4i/sun4i_drv.c
+++ b/drivers/gpu/drm/sun4i/sun4i_drv.c
@@ -53,9 +53,7 @@ static const struct file_operations sun4i_drv_fops = {
         .open           = drm_open,
         .release        = drm_release,
         .unlocked_ioctl = drm_ioctl,
-#ifdef CONFIG_COMPAT
         .compat_ioctl   = drm_compat_ioctl,
-#endif
         .poll           = drm_poll,
         .read           = drm_read,
         .llseek         = no_llseek,
diff --git a/drivers/gpu/drm/tdfx/tdfx_drv.c b/drivers/gpu/drm/tdfx/tdfx_drv.c
index f418892b0c71..c54138c3a376 100644
--- a/drivers/gpu/drm/tdfx/tdfx_drv.c
+++ b/drivers/gpu/drm/tdfx/tdfx_drv.c
@@ -49,9 +49,7 @@ static const struct file_operations tdfx_driver_fops = {
         .unlocked_ioctl = drm_ioctl,
         .mmap = drm_legacy_mmap,
         .poll = drm_poll,
-#ifdef CONFIG_COMPAT
         .compat_ioctl = drm_compat_ioctl,
-#endif
         .llseek = noop_llseek,
 };
 
diff --git a/drivers/gpu/drm/tegra/drm.c b/drivers/gpu/drm/tegra/drm.c
index a9630c2d6cb3..b8be3ee4d3b8 100644
--- a/drivers/gpu/drm/tegra/drm.c
+++ b/drivers/gpu/drm/tegra/drm.c
@@ -802,9 +802,7 @@ static const struct file_operations tegra_drm_fops = {
         .mmap = tegra_drm_mmap,
         .poll = drm_poll,
         .read = drm_read,
-#ifdef CONFIG_COMPAT
         .compat_ioctl = drm_compat_ioctl,
-#endif
         .llseek = noop_llseek,
 };
 
diff --git a/drivers/gpu/drm/tilcdc/tilcdc_drv.c b/drivers/gpu/drm/tilcdc/tilcdc_drv.c
index 147fb28287ae..0f58a74f25d1 100644
--- a/drivers/gpu/drm/tilcdc/tilcdc_drv.c
+++ b/drivers/gpu/drm/tilcdc/tilcdc_drv.c
@@ -573,9 +573,7 @@ static const struct file_operations fops = {
         .open               = drm_open,
         .release            = drm_release,
         .unlocked_ioctl     = drm_ioctl,
-#ifdef CONFIG_COMPAT
         .compat_ioctl       = drm_compat_ioctl,
-#endif
         .poll               = drm_poll,
         .read               = drm_read,
         .llseek             = no_llseek,
diff --git a/drivers/gpu/drm/ttm/ttm_bo.c b/drivers/gpu/drm/ttm/ttm_bo.c
index f6ff579e8918..d5063618efa7 100644
--- a/drivers/gpu/drm/ttm/ttm_bo.c
+++ b/drivers/gpu/drm/ttm/ttm_bo.c
@@ -1611,7 +1611,14 @@ EXPORT_SYMBOL(ttm_bo_unmap_virtual);
 int ttm_bo_wait(struct ttm_buffer_object *bo,
                 bool interruptible, bool no_wait)
 {
-        long timeout = no_wait ? 0 : 15 * HZ;
+        long timeout = 15 * HZ;
+
+        if (no_wait) {
+                if (reservation_object_test_signaled_rcu(bo->resv, true))
+                        return 0;
+                else
+                        return -EBUSY;
+        }
 
         timeout = reservation_object_wait_timeout_rcu(bo->resv, true,
                                                       interruptible, timeout);
diff --git a/drivers/gpu/drm/udl/udl_drv.c b/drivers/gpu/drm/udl/udl_drv.c
index cc45d98f9bb5..cd8b01727734 100644
--- a/drivers/gpu/drm/udl/udl_drv.c
+++ b/drivers/gpu/drm/udl/udl_drv.c
@@ -44,9 +44,7 @@ static const struct file_operations udl_driver_fops = {
         .read = drm_read,
         .unlocked_ioctl = drm_ioctl,
         .release = drm_release,
-#ifdef CONFIG_COMPAT
         .compat_ioctl = drm_compat_ioctl,
-#endif
         .llseek = noop_llseek,
 };
 
diff --git a/drivers/gpu/drm/vc4/vc4_drv.c b/drivers/gpu/drm/vc4/vc4_drv.c
index 8703f56b7947..eaf26d9b5f11 100644
--- a/drivers/gpu/drm/vc4/vc4_drv.c
+++ b/drivers/gpu/drm/vc4/vc4_drv.c
@@ -103,9 +103,7 @@ static const struct file_operations vc4_drm_fops = {
         .mmap = vc4_mmap,
         .poll = drm_poll,
         .read = drm_read,
-#ifdef CONFIG_COMPAT
         .compat_ioctl = drm_compat_ioctl,
-#endif
         .llseek = noop_llseek,
 };
 
diff --git a/drivers/gpu/drm/via/via_drv.c b/drivers/gpu/drm/via/via_drv.c
index e5582bab7e3c..9e0e5392b6ec 100644
--- a/drivers/gpu/drm/via/via_drv.c
+++ b/drivers/gpu/drm/via/via_drv.c
@@ -64,9 +64,7 @@ static const struct file_operations via_driver_fops = {
         .unlocked_ioctl = drm_ioctl,
         .mmap = drm_legacy_mmap,
         .poll = drm_poll,
-#ifdef CONFIG_COMPAT
         .compat_ioctl = drm_compat_ioctl,
-#endif
         .llseek = noop_llseek,
 };
 
diff --git a/drivers/gpu/drm/virtio/virtgpu_drv.c b/drivers/gpu/drm/virtio/virtgpu_drv.c
index 5820b7020ae5..04d98db75c64 100644
--- a/drivers/gpu/drm/virtio/virtgpu_drv.c
+++ b/drivers/gpu/drm/virtio/virtgpu_drv.c
@@ -108,9 +108,7 @@ static const struct file_operations virtio_gpu_driver_fops = {
         .read = drm_read,
         .unlocked_ioctl = drm_ioctl,
         .release = drm_release,
-#ifdef CONFIG_COMPAT
         .compat_ioctl = drm_compat_ioctl,
-#endif
         .llseek = noop_llseek,
 };