17 files changed, 390 insertions, 76 deletions

diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile
index 863db8415c22..dd2ba4269740 100644
--- a/drivers/gpu/drm/Makefile
+++ b/drivers/gpu/drm/Makefile
@@ -13,7 +13,8 @@ drm-y       :=	drm_auth.o drm_buffer.o drm_bufs.o drm_cache.o \
                 drm_crtc.o drm_modes.o drm_edid.o \
                 drm_info.o drm_debugfs.o drm_encoder_slave.o \
                 drm_trace_points.o drm_global.o drm_prime.o \
-                drm_rect.o drm_vma_manager.o drm_flip_work.o
+                drm_rect.o drm_vma_manager.o drm_flip_work.o \
+                drm_modeset_lock.o
 
 drm-$(CONFIG_COMPAT) += drm_ioc32.o
 drm-$(CONFIG_DRM_GEM_CMA_HELPER) += drm_gem_cma_helper.o
diff --git a/drivers/gpu/drm/drm_crtc.c b/drivers/gpu/drm/drm_crtc.c
index f3b98d4b6f46..43735f38cd17 100644
--- a/drivers/gpu/drm/drm_crtc.c
+++ b/drivers/gpu/drm/drm_crtc.c
@@ -37,6 +37,7 @@
 #include <drm/drm_crtc.h>
 #include <drm/drm_edid.h>
 #include <drm/drm_fourcc.h>
+#include <drm/drm_modeset_lock.h>
 
 #include "drm_crtc_internal.h"
 
@@ -50,14 +51,42 @@
  */
 void drm_modeset_lock_all(struct drm_device *dev)
 {
-        struct drm_crtc *crtc;
+        struct drm_mode_config *config = &dev->mode_config;
+        struct drm_modeset_acquire_ctx *ctx;
+        int ret;
 
-        mutex_lock(&dev->mode_config.mutex);
+        ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
+        if (WARN_ON(!ctx))
+                return;
 
-        mutex_lock(&dev->mode_config.connection_mutex);
+        mutex_lock(&config->mutex);
 
-        list_for_each_entry(crtc, &dev->mode_config.crtc_list, head)
-                mutex_lock_nest_lock(&crtc->mutex, &dev->mode_config.mutex);
+        drm_modeset_acquire_init(ctx, 0);
+
+retry:
+        ret = drm_modeset_lock(&config->connection_mutex, ctx);
+        if (ret)
+                goto fail;
+        ret = drm_modeset_lock_all_crtcs(dev, ctx);
+        if (ret)
+                goto fail;
+
+        WARN_ON(config->acquire_ctx);
+
+        /* now we hold the locks, so now that it is safe, stash the
+         * ctx for drm_modeset_unlock_all():
+         */
+        config->acquire_ctx = ctx;
+
+        drm_warn_on_modeset_not_all_locked(dev);
+
+        return;
+
+fail:
+        if (ret == -EDEADLK) {
+                drm_modeset_backoff(ctx);
+                goto retry;
+        }
 }
 EXPORT_SYMBOL(drm_modeset_lock_all);
 
@@ -69,12 +98,17 @@ EXPORT_SYMBOL(drm_modeset_lock_all);
  */
 void drm_modeset_unlock_all(struct drm_device *dev)
 {
-        struct drm_crtc *crtc;
+        struct drm_mode_config *config = &dev->mode_config;
+        struct drm_modeset_acquire_ctx *ctx = config->acquire_ctx;
 
-        list_for_each_entry(crtc, &dev->mode_config.crtc_list, head)
-                mutex_unlock(&crtc->mutex);
+        if (WARN_ON(!ctx))
+                return;
+
+        config->acquire_ctx = NULL;
+        drm_modeset_drop_locks(ctx);
+        drm_modeset_acquire_fini(ctx);
 
-        mutex_unlock(&dev->mode_config.connection_mutex);
+        kfree(ctx);
 
         mutex_unlock(&dev->mode_config.mutex);
 }
@@ -95,9 +129,9 @@ void drm_warn_on_modeset_not_all_locked(struct drm_device *dev)
                 return;
 
         list_for_each_entry(crtc, &dev->mode_config.crtc_list, head)
-                WARN_ON(!mutex_is_locked(&crtc->mutex));
+                WARN_ON(!drm_modeset_is_locked(&crtc->mutex));
 
-        WARN_ON(!mutex_is_locked(&dev->mode_config.connection_mutex));
+        WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
         WARN_ON(!mutex_is_locked(&dev->mode_config.mutex));
 }
 EXPORT_SYMBOL(drm_warn_on_modeset_not_all_locked);
@@ -671,6 +705,8 @@ void drm_framebuffer_remove(struct drm_framebuffer *fb)
 }
 EXPORT_SYMBOL(drm_framebuffer_remove);
 
+DEFINE_WW_CLASS(crtc_ww_class);
+
 /**
  * drm_crtc_init_with_planes - Initialise a new CRTC object with
  *    specified primary and cursor planes.
@@ -690,6 +726,7 @@ int drm_crtc_init_with_planes(struct drm_device *dev, struct drm_crtc *crtc,
                               void *cursor,
                               const struct drm_crtc_funcs *funcs)
 {
+        struct drm_mode_config *config = &dev->mode_config;
         int ret;
 
         crtc->dev = dev;
@@ -697,8 +734,9 @@ int drm_crtc_init_with_planes(struct drm_device *dev, struct drm_crtc *crtc,
         crtc->invert_dimensions = false;
 
         drm_modeset_lock_all(dev);
-        mutex_init(&crtc->mutex);
-        mutex_lock_nest_lock(&crtc->mutex, &dev->mode_config.mutex);
+        drm_modeset_lock_init(&crtc->mutex);
+        /* dropped by _unlock_all(): */
+        drm_modeset_lock(&crtc->mutex, config->acquire_ctx);
 
         ret = drm_mode_object_get(dev, &crtc->base, DRM_MODE_OBJECT_CRTC);
         if (ret)
@@ -706,8 +744,8 @@ int drm_crtc_init_with_planes(struct drm_device *dev, struct drm_crtc *crtc,
 
         crtc->base.properties = &crtc->properties;
 
-        list_add_tail(&crtc->head, &dev->mode_config.crtc_list);
-        dev->mode_config.num_crtc++;
+        list_add_tail(&crtc->head, &config->crtc_list);
+        config->num_crtc++;
 
         crtc->primary = primary;
         if (primary)
@@ -735,6 +773,8 @@ void drm_crtc_cleanup(struct drm_crtc *crtc)
         kfree(crtc->gamma_store);
         crtc->gamma_store = NULL;
 
+        drm_modeset_lock_fini(&crtc->mutex);
+
         drm_mode_object_put(dev, &crtc->base);
         list_del(&crtc->head);
         dev->mode_config.num_crtc--;
@@ -1798,7 +1838,7 @@ int drm_mode_getconnector(struct drm_device *dev, void *data,
         DRM_DEBUG_KMS("[CONNECTOR:%d:?]\n", out_resp->connector_id);
 
         mutex_lock(&dev->mode_config.mutex);
-        mutex_lock(&dev->mode_config.connection_mutex);
+        drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
 
         connector = drm_connector_find(dev, out_resp->connector_id);
         if (!connector) {
@@ -1897,7 +1937,7 @@ int drm_mode_getconnector(struct drm_device *dev, void *data,
         out_resp->count_encoders = encoders_count;
 
 out:
-        mutex_unlock(&dev->mode_config.connection_mutex);
+        drm_modeset_unlock(&dev->mode_config.connection_mutex);
         mutex_unlock(&dev->mode_config.mutex);
 
         return ret;
@@ -2481,7 +2521,7 @@ static int drm_mode_cursor_common(struct drm_device *dev,
                 return -ENOENT;
         }
 
-        mutex_lock(&crtc->mutex);
+        drm_modeset_lock(&crtc->mutex, NULL);
         if (req->flags & DRM_MODE_CURSOR_BO) {
                 if (!crtc->funcs->cursor_set && !crtc->funcs->cursor_set2) {
                         ret = -ENXIO;
@@ -2505,7 +2545,7 @@ static int drm_mode_cursor_common(struct drm_device *dev,
                 }
         }
 out:
-        mutex_unlock(&crtc->mutex);
+        drm_modeset_unlock(&crtc->mutex);
 
         return ret;
 
@@ -4198,7 +4238,7 @@ int drm_mode_page_flip_ioctl(struct drm_device *dev,
         if (!crtc)
                 return -ENOENT;
 
-        mutex_lock(&crtc->mutex);
+        drm_modeset_lock(&crtc->mutex, NULL);
         if (crtc->primary->fb == NULL) {
                 /* The framebuffer is currently unbound, presumably
                  * due to a hotplug event, that userspace has not
@@ -4282,7 +4322,7 @@ out:
                 drm_framebuffer_unreference(fb);
         if (old_fb)
                 drm_framebuffer_unreference(old_fb);
-        mutex_unlock(&crtc->mutex);
+        drm_modeset_unlock(&crtc->mutex);
 
         return ret;
 }
@@ -4647,7 +4687,7 @@ EXPORT_SYMBOL(drm_format_vert_chroma_subsampling);
 void drm_mode_config_init(struct drm_device *dev)
 {
         mutex_init(&dev->mode_config.mutex);
-        mutex_init(&dev->mode_config.connection_mutex);
+        drm_modeset_lock_init(&dev->mode_config.connection_mutex);
         mutex_init(&dev->mode_config.idr_mutex);
         mutex_init(&dev->mode_config.fb_lock);
         INIT_LIST_HEAD(&dev->mode_config.fb_list);
@@ -4747,5 +4787,6 @@ void drm_mode_config_cleanup(struct drm_device *dev)
         }
 
         idr_destroy(&dev->mode_config.crtc_idr);
+        drm_modeset_lock_fini(&dev->mode_config.connection_mutex);
 }
 EXPORT_SYMBOL(drm_mode_config_cleanup);
diff --git a/drivers/gpu/drm/drm_crtc_helper.c b/drivers/gpu/drm/drm_crtc_helper.c
index b55d27c872f6..eb1c062e04b2 100644
--- a/drivers/gpu/drm/drm_crtc_helper.c
+++ b/drivers/gpu/drm/drm_crtc_helper.c
@@ -89,8 +89,7 @@ bool drm_helper_encoder_in_use(struct drm_encoder *encoder)
         struct drm_device *dev = encoder->dev;
 
         WARN_ON(!mutex_is_locked(&dev->mode_config.mutex));
-        WARN_ON(!mutex_is_locked(&dev->mode_config.connection_mutex));
-
+        WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
         list_for_each_entry(connector, &dev->mode_config.connector_list, head)
                 if (connector->encoder == encoder)
                         return true;
diff --git a/drivers/gpu/drm/drm_fb_helper.c b/drivers/gpu/drm/drm_fb_helper.c
index 1ddc17464250..43329cee299f 100644
--- a/drivers/gpu/drm/drm_fb_helper.c
+++ b/drivers/gpu/drm/drm_fb_helper.c
@@ -331,6 +331,10 @@ static bool drm_fb_helper_force_kernel_mode(void)
                 if (dev->switch_power_state == DRM_SWITCH_POWER_OFF)
                         continue;
 
+                /* NOTE: we use lockless flag below to avoid grabbing other
+                 * modeset locks.  So just trylock the underlying mutex
+                 * directly:
+                 */
                 if (!mutex_trylock(&dev->mode_config.mutex)) {
                         error = true;
                         continue;
diff --git a/drivers/gpu/drm/drm_modeset_lock.c b/drivers/gpu/drm/drm_modeset_lock.c
new file mode 100644
index 000000000000..7c2497dea1e9
--- /dev/null
+++ b/drivers/gpu/drm/drm_modeset_lock.c
@@ -0,0 +1,247 @@
+/*
+ * Copyright (C) 2014 Red Hat
+ * Author: Rob Clark <robdclark@gmail.com>
+ *
+ * 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.
+ */
+
+#include <drm/drmP.h>
+#include <drm/drm_crtc.h>
+#include <drm/drm_modeset_lock.h>
+
+/**
+ * DOC: kms locking
+ *
+ * As KMS moves toward more fine grained locking, and atomic ioctl where
+ * userspace can indirectly control locking order, it becomes necessary
+ * to use ww_mutex and acquire-contexts to avoid deadlocks.  But because
+ * the locking is more distributed around the driver code, we want a bit
+ * of extra utility/tracking out of our acquire-ctx.  This is provided
+ * by drm_modeset_lock / drm_modeset_acquire_ctx.
+ *
+ * For basic principles of ww_mutex, see: Documentation/ww-mutex-design.txt
+ *
+ * The basic usage pattern is to:
+ *
+ *     drm_modeset_acquire_init(&ctx)
+ *   retry:
+ *     foreach (lock in random_ordered_set_of_locks) {
+ *       ret = drm_modeset_lock(lock, &ctx)
+ *       if (ret == -EDEADLK) {
+ *          drm_modeset_backoff(&ctx);
+ *          goto retry;
+ *       }
+ *     }
+ *
+ *     ... do stuff ...
+ *
+ *     drm_modeset_drop_locks(&ctx);
+ *     drm_modeset_acquire_fini(&ctx);
+ */
+
+
+/**
+ * drm_modeset_acquire_init - initialize acquire context
+ * @ctx: the acquire context
+ * @flags: for future
+ */
+void drm_modeset_acquire_init(struct drm_modeset_acquire_ctx *ctx,
+                uint32_t flags)
+{
+        ww_acquire_init(&ctx->ww_ctx, &crtc_ww_class);
+        INIT_LIST_HEAD(&ctx->locked);
+}
+EXPORT_SYMBOL(drm_modeset_acquire_init);
+
+/**
+ * drm_modeset_acquire_fini - cleanup acquire context
+ * @ctx: the acquire context
+ */
+void drm_modeset_acquire_fini(struct drm_modeset_acquire_ctx *ctx)
+{
+        ww_acquire_fini(&ctx->ww_ctx);
+}
+EXPORT_SYMBOL(drm_modeset_acquire_fini);
+
+/**
+ * drm_modeset_drop_locks - drop all locks
+ * @ctx: the acquire context
+ *
+ * Drop all locks currently held against this acquire context.
+ */
+void drm_modeset_drop_locks(struct drm_modeset_acquire_ctx *ctx)
+{
+        WARN_ON(ctx->contended);
+        while (!list_empty(&ctx->locked)) {
+                struct drm_modeset_lock *lock;
+
+                lock = list_first_entry(&ctx->locked,
+                                struct drm_modeset_lock, head);
+
+                drm_modeset_unlock(lock);
+        }
+}
+EXPORT_SYMBOL(drm_modeset_drop_locks);
+
+static inline int modeset_lock(struct drm_modeset_lock *lock,
+                struct drm_modeset_acquire_ctx *ctx,
+                bool interruptible, bool slow)
+{
+        int ret;
+
+        WARN_ON(ctx->contended);
+
+        if (interruptible && slow) {
+                ret = ww_mutex_lock_slow_interruptible(&lock->mutex, &ctx->ww_ctx);
+        } else if (interruptible) {
+                ret = ww_mutex_lock_interruptible(&lock->mutex, &ctx->ww_ctx);
+        } else if (slow) {
+                ww_mutex_lock_slow(&lock->mutex, &ctx->ww_ctx);
+                ret = 0;
+        } else {
+                ret = ww_mutex_lock(&lock->mutex, &ctx->ww_ctx);
+        }
+        if (!ret) {
+                WARN_ON(!list_empty(&lock->head));
+                list_add(&lock->head, &ctx->locked);
+        } else if (ret == -EALREADY) {
+                /* we already hold the lock.. this is fine.  For atomic
+                 * we will need to be able to drm_modeset_lock() things
+                 * without having to keep track of what is already locked
+                 * or not.
+                 */
+                ret = 0;
+        } else if (ret == -EDEADLK) {
+                ctx->contended = lock;
+        }
+
+        return ret;
+}
+
+static int modeset_backoff(struct drm_modeset_acquire_ctx *ctx,
+                bool interruptible)
+{
+        struct drm_modeset_lock *contended = ctx->contended;
+
+        ctx->contended = NULL;
+
+        if (WARN_ON(!contended))
+                return 0;
+
+        drm_modeset_drop_locks(ctx);
+
+        return modeset_lock(contended, ctx, interruptible, true);
+}
+
+/**
+ * drm_modeset_backoff - deadlock avoidance backoff
+ * @ctx: the acquire context
+ *
+ * If deadlock is detected (ie. drm_modeset_lock() returns -EDEADLK),
+ * you must call this function to drop all currently held locks and
+ * block until the contended lock becomes available.
+ */
+void drm_modeset_backoff(struct drm_modeset_acquire_ctx *ctx)
+{
+        modeset_backoff(ctx, false);
+}
+EXPORT_SYMBOL(drm_modeset_backoff);
+
+/**
+ * drm_modeset_backoff_interruptible - deadlock avoidance backoff
+ * @ctx: the acquire context
+ *
+ * Interruptible version of drm_modeset_backoff()
+ */
+int drm_modeset_backoff_interruptible(struct drm_modeset_acquire_ctx *ctx)
+{
+        return modeset_backoff(ctx, true);
+}
+EXPORT_SYMBOL(drm_modeset_backoff_interruptible);
+
+/**
+ * drm_modeset_lock - take modeset lock
+ * @lock: lock to take
+ * @ctx: acquire ctx
+ *
+ * If ctx is not NULL, then its ww acquire context is used and the
+ * lock will be tracked by the context and can be released by calling
+ * drm_modeset_drop_locks().  If -EDEADLK is returned, this means a
+ * deadlock scenario has been detected and it is an error to attempt
+ * to take any more locks without first calling drm_modeset_backoff().
+ */
+int drm_modeset_lock(struct drm_modeset_lock *lock,
+                struct drm_modeset_acquire_ctx *ctx)
+{
+        if (ctx)
+                return modeset_lock(lock, ctx, false, false);
+
+        ww_mutex_lock(&lock->mutex, NULL);
+        return 0;
+}
+EXPORT_SYMBOL(drm_modeset_lock);
+
+/**
+ * drm_modeset_lock_interruptible - take modeset lock
+ * @lock: lock to take
+ * @ctx: acquire ctx
+ *
+ * Interruptible version of drm_modeset_lock()
+ */
+int drm_modeset_lock_interruptible(struct drm_modeset_lock *lock,
+                struct drm_modeset_acquire_ctx *ctx)
+{
+        if (ctx)
+                return modeset_lock(lock, ctx, true, false);
+
+        return ww_mutex_lock_interruptible(&lock->mutex, NULL);
+}
+EXPORT_SYMBOL(drm_modeset_lock_interruptible);
+
+/**
+ * drm_modeset_unlock - drop modeset lock
+ * @lock: lock to release
+ */
+void drm_modeset_unlock(struct drm_modeset_lock *lock)
+{
+        list_del_init(&lock->head);
+        ww_mutex_unlock(&lock->mutex);
+}
+EXPORT_SYMBOL(drm_modeset_unlock);
+
+/* Temporary.. until we have sufficiently fine grained locking, there
+ * are a couple scenarios where it is convenient to grab all crtc locks.
+ * It is planned to remove this:
+ */
+int drm_modeset_lock_all_crtcs(struct drm_device *dev,
+                struct drm_modeset_acquire_ctx *ctx)
+{
+        struct drm_mode_config *config = &dev->mode_config;
+        struct drm_crtc *crtc;
+        int ret = 0;
+
+        list_for_each_entry(crtc, &config->crtc_list, head) {
+                ret = drm_modeset_lock(&crtc->mutex, ctx);
+                if (ret)
+                        return ret;
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL(drm_modeset_lock_all_crtcs);
diff --git a/drivers/gpu/drm/drm_plane_helper.c b/drivers/gpu/drm/drm_plane_helper.c
index f3e0a23abf4e..1b15643b4586 100644
--- a/drivers/gpu/drm/drm_plane_helper.c
+++ b/drivers/gpu/drm/drm_plane_helper.c
@@ -60,7 +60,7 @@ static int get_connectors_for_crtc(struct drm_crtc *crtc,
          * need to grab the connection_mutex here to be able to make these
          * checks.
          */
-        WARN_ON(!mutex_is_locked(&dev->mode_config.connection_mutex));
+        WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
 
         list_for_each_entry(connector, &dev->mode_config.connector_list, head)
                 if (connector->encoder && connector->encoder->crtc == crtc) {
diff --git a/drivers/gpu/drm/i915/intel_crt.c b/drivers/gpu/drm/i915/intel_crt.c
index 1fc91df58296..5a045d3bd77e 100644
--- a/drivers/gpu/drm/i915/intel_crt.c
+++ b/drivers/gpu/drm/i915/intel_crt.c
@@ -630,6 +630,7 @@ intel_crt_detect(struct drm_connector *connector, bool force)
         enum intel_display_power_domain power_domain;
         enum drm_connector_status status;
         struct intel_load_detect_pipe tmp;
+        struct drm_modeset_acquire_ctx ctx;
 
         intel_runtime_pm_get(dev_priv);
 
@@ -673,12 +674,12 @@ intel_crt_detect(struct drm_connector *connector, bool force)
         }
 
         /* for pre-945g platforms use load detect */
-        if (intel_get_load_detect_pipe(connector, NULL, &tmp)) {
+        if (intel_get_load_detect_pipe(connector, NULL, &tmp, &ctx)) {
                 if (intel_crt_detect_ddc(connector))
                         status = connector_status_connected;
                 else
                         status = intel_crt_load_detect(crt);
-                intel_release_load_detect_pipe(connector, &tmp);
+                intel_release_load_detect_pipe(connector, &tmp, &ctx);
         } else
                 status = connector_status_unknown;
 
diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c
index c2976ade823f..1ce4ad4626e4 100644
--- a/drivers/gpu/drm/i915/intel_display.c
+++ b/drivers/gpu/drm/i915/intel_display.c
@@ -2576,7 +2576,7 @@ void intel_display_handle_reset(struct drm_device *dev)
         for_each_crtc(dev, crtc) {
                 struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
 
-                mutex_lock(&crtc->mutex);
+                drm_modeset_lock(&crtc->mutex, NULL);
                 /*
                  * FIXME: Once we have proper support for primary planes (and
                  * disabling them without disabling the entire crtc) allow again
@@ -2587,7 +2587,7 @@ void intel_display_handle_reset(struct drm_device *dev)
                                                                crtc->primary->fb,
                                                                crtc->x,
                                                                crtc->y);
-                mutex_unlock(&crtc->mutex);
+                drm_modeset_unlock(&crtc->mutex);
         }
 }
 
@@ -8307,7 +8307,8 @@ mode_fits_in_fbdev(struct drm_device *dev,
 
 bool intel_get_load_detect_pipe(struct drm_connector *connector,
                                 struct drm_display_mode *mode,
-                                struct intel_load_detect_pipe *old)
+                                struct intel_load_detect_pipe *old,
+                                struct drm_modeset_acquire_ctx *ctx)
 {
         struct intel_crtc *intel_crtc;
         struct intel_encoder *intel_encoder =
@@ -8317,13 +8318,19 @@ bool intel_get_load_detect_pipe(struct drm_connector *connector,
         struct drm_crtc *crtc = NULL;
         struct drm_device *dev = encoder->dev;
         struct drm_framebuffer *fb;
-        int i = -1;
+        struct drm_mode_config *config = &dev->mode_config;
+        int ret, i = -1;
 
         DRM_DEBUG_KMS("[CONNECTOR:%d:%s], [ENCODER:%d:%s]\n",
                       connector->base.id, connector->name,
                       encoder->base.id, encoder->name);
 
-        mutex_lock(&dev->mode_config.connection_mutex);
+        drm_modeset_acquire_init(ctx, 0);
+
+retry:
+        ret = drm_modeset_lock(&config->connection_mutex, ctx);
+        if (ret)
+                goto fail_unlock;
 
         /*
          * Algorithm gets a little messy:
@@ -8339,7 +8346,9 @@ bool intel_get_load_detect_pipe(struct drm_connector *connector,
         if (encoder->crtc) {
                 crtc = encoder->crtc;
 
-                mutex_lock(&crtc->mutex);
+                ret = drm_modeset_lock(&crtc->mutex, ctx);
+                if (ret)
+                        goto fail_unlock;
 
                 old->dpms_mode = connector->dpms;
                 old->load_detect_temp = false;
@@ -8367,10 +8376,12 @@ bool intel_get_load_detect_pipe(struct drm_connector *connector,
          */
         if (!crtc) {
                 DRM_DEBUG_KMS("no pipe available for load-detect\n");
-                goto fail_unlock_connector;
+                goto fail_unlock;
         }
 
-        mutex_lock(&crtc->mutex);
+        ret = drm_modeset_lock(&crtc->mutex, ctx);
+        if (ret)
+                goto fail_unlock;
         intel_encoder->new_crtc = to_intel_crtc(crtc);
         to_intel_connector(connector)->new_encoder = intel_encoder;
 
@@ -8420,15 +8431,21 @@ bool intel_get_load_detect_pipe(struct drm_connector *connector,
                 intel_crtc->new_config = &intel_crtc->config;
         else
                 intel_crtc->new_config = NULL;
-        mutex_unlock(&crtc->mutex);
-fail_unlock_connector:
-        mutex_unlock(&dev->mode_config.connection_mutex);
+fail_unlock:
+        if (ret == -EDEADLK) {
+                drm_modeset_backoff(ctx);
+                goto retry;
+        }
+
+        drm_modeset_drop_locks(ctx);
+        drm_modeset_acquire_fini(ctx);
 
         return false;
 }
 
 void intel_release_load_detect_pipe(struct drm_connector *connector,
-                                    struct intel_load_detect_pipe *old)
+                                    struct intel_load_detect_pipe *old,
+                                    struct drm_modeset_acquire_ctx *ctx)
 {
         struct intel_encoder *intel_encoder =
                 intel_attached_encoder(connector);
@@ -8452,8 +8469,7 @@ void intel_release_load_detect_pipe(struct drm_connector *connector,
                         drm_framebuffer_unreference(old->release_fb);
                 }
 
-                mutex_unlock(&crtc->mutex);
-                mutex_unlock(&connector->dev->mode_config.connection_mutex);
+                goto unlock;
                 return;
         }
 
@@ -8461,8 +8477,9 @@ void intel_release_load_detect_pipe(struct drm_connector *connector,
         if (old->dpms_mode != DRM_MODE_DPMS_ON)
                 connector->funcs->dpms(connector, old->dpms_mode);
 
-        mutex_unlock(&crtc->mutex);
-        mutex_unlock(&connector->dev->mode_config.connection_mutex);
+unlock:
+        drm_modeset_drop_locks(ctx);
+        drm_modeset_acquire_fini(ctx);
 }
 
 static int i9xx_pll_refclk(struct drm_device *dev,
@@ -10995,7 +11012,7 @@ enum pipe intel_get_pipe_from_connector(struct intel_connector *connector)
         struct drm_encoder *encoder = connector->base.encoder;
         struct drm_device *dev = connector->base.dev;
 
-        WARN_ON(!mutex_is_locked(&dev->mode_config.connection_mutex));
+        WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
 
         if (!encoder)
                 return INVALID_PIPE;
@@ -11805,6 +11822,7 @@ static void intel_enable_pipe_a(struct drm_device *dev)
         struct intel_connector *connector;
         struct drm_connector *crt = NULL;
         struct intel_load_detect_pipe load_detect_temp;
+        struct drm_modeset_acquire_ctx ctx;
 
         /* We can't just switch on the pipe A, we need to set things up with a
          * proper mode and output configuration. As a gross hack, enable pipe A
@@ -11821,8 +11839,8 @@ static void intel_enable_pipe_a(struct drm_device *dev)
         if (!crt)
                 return;
 
-        if (intel_get_load_detect_pipe(crt, NULL, &load_detect_temp))
-                intel_release_load_detect_pipe(crt, &load_detect_temp);
+        if (intel_get_load_detect_pipe(crt, NULL, &load_detect_temp, &ctx))
+                intel_release_load_detect_pipe(crt, &load_detect_temp, &ctx);
 
 
 }
diff --git a/drivers/gpu/drm/i915/intel_dp.c b/drivers/gpu/drm/i915/intel_dp.c
index d01bb430b5bc..2d5d9b010073 100644
--- a/drivers/gpu/drm/i915/intel_dp.c
+++ b/drivers/gpu/drm/i915/intel_dp.c
@@ -1154,7 +1154,7 @@ static void edp_panel_vdd_off_sync(struct intel_dp *intel_dp)
         u32 pp;
         u32 pp_stat_reg, pp_ctrl_reg;
 
-        WARN_ON(!mutex_is_locked(&dev->mode_config.connection_mutex));
+        WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
 
         if (!intel_dp->want_panel_vdd && edp_have_panel_vdd(intel_dp)) {
                 struct intel_digital_port *intel_dig_port =
@@ -1191,9 +1191,9 @@ static void edp_panel_vdd_work(struct work_struct *__work)
                                                  struct intel_dp, panel_vdd_work);
         struct drm_device *dev = intel_dp_to_dev(intel_dp);
 
-        mutex_lock(&dev->mode_config.connection_mutex);
+        drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
         edp_panel_vdd_off_sync(intel_dp);
-        mutex_unlock(&dev->mode_config.connection_mutex);
+        drm_modeset_unlock(&dev->mode_config.connection_mutex);
 }
 
 static void edp_panel_vdd_off(struct intel_dp *intel_dp, bool sync)
@@ -3666,9 +3666,9 @@ void intel_dp_encoder_destroy(struct drm_encoder *encoder)
         drm_encoder_cleanup(encoder);
         if (is_edp(intel_dp)) {
                 cancel_delayed_work_sync(&intel_dp->panel_vdd_work);
-                mutex_lock(&dev->mode_config.connection_mutex);
+                drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
                 edp_panel_vdd_off_sync(intel_dp);
-                mutex_unlock(&dev->mode_config.connection_mutex);
+                drm_modeset_unlock(&dev->mode_config.connection_mutex);
         }
         kfree(intel_dig_port);
 }
@@ -4247,9 +4247,9 @@ intel_dp_init_connector(struct intel_digital_port *intel_dig_port,
                 drm_dp_aux_unregister(&intel_dp->aux);
                 if (is_edp(intel_dp)) {
                         cancel_delayed_work_sync(&intel_dp->panel_vdd_work);
-                        mutex_lock(&dev->mode_config.connection_mutex);
+                        drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
                         edp_panel_vdd_off_sync(intel_dp);
-                        mutex_unlock(&dev->mode_config.connection_mutex);
+                        drm_modeset_unlock(&dev->mode_config.connection_mutex);
                 }
                 drm_sysfs_connector_remove(connector);
                 drm_connector_cleanup(connector);
diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h
index f1d5897c96cd..0de04983501e 100644
--- a/drivers/gpu/drm/i915/intel_drv.h
+++ b/drivers/gpu/drm/i915/intel_drv.h
@@ -748,9 +748,11 @@ void vlv_wait_port_ready(struct drm_i915_private *dev_priv,
                          struct intel_digital_port *dport);
 bool intel_get_load_detect_pipe(struct drm_connector *connector,
                                 struct drm_display_mode *mode,
-                                struct intel_load_detect_pipe *old);
+                                struct intel_load_detect_pipe *old,
+                                struct drm_modeset_acquire_ctx *ctx);
 void intel_release_load_detect_pipe(struct drm_connector *connector,
-                                    struct intel_load_detect_pipe *old);
+                                    struct intel_load_detect_pipe *old,
+                                    struct drm_modeset_acquire_ctx *ctx);
 int intel_pin_and_fence_fb_obj(struct drm_device *dev,
                                struct drm_i915_gem_object *obj,
                                struct intel_engine_cs *pipelined);
diff --git a/drivers/gpu/drm/i915/intel_opregion.c b/drivers/gpu/drm/i915/intel_opregion.c
index b812e9d39f38..2e2c71fcc9ed 100644
--- a/drivers/gpu/drm/i915/intel_opregion.c
+++ b/drivers/gpu/drm/i915/intel_opregion.c
@@ -410,7 +410,7 @@ static u32 asle_set_backlight(struct drm_device *dev, u32 bclp)
         if (bclp > 255)
                 return ASLC_BACKLIGHT_FAILED;
 
-        mutex_lock(&dev->mode_config.connection_mutex);
+        drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
 
         /*
          * Update backlight on all connectors that support backlight (usually
@@ -421,7 +421,7 @@ static u32 asle_set_backlight(struct drm_device *dev, u32 bclp)
                 intel_panel_set_backlight(intel_connector, bclp, 255);
         iowrite32(DIV_ROUND_UP(bclp * 100, 255) | ASLE_CBLV_VALID, &asle->cblv);
 
-        mutex_unlock(&dev->mode_config.connection_mutex);
+        drm_modeset_unlock(&dev->mode_config.connection_mutex);
 
 
         return 0;
diff --git a/drivers/gpu/drm/i915/intel_overlay.c b/drivers/gpu/drm/i915/intel_overlay.c
index e97ea33e0117..0396d1312b5c 100644
--- a/drivers/gpu/drm/i915/intel_overlay.c
+++ b/drivers/gpu/drm/i915/intel_overlay.c
@@ -688,7 +688,7 @@ static int intel_overlay_do_put_image(struct intel_overlay *overlay,
         u32 swidth, swidthsw, sheight, ostride;
 
         BUG_ON(!mutex_is_locked(&dev->struct_mutex));
-        BUG_ON(!mutex_is_locked(&dev->mode_config.connection_mutex));
+        BUG_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
         BUG_ON(!overlay);
 
         ret = intel_overlay_release_old_vid(overlay);
@@ -793,7 +793,7 @@ int intel_overlay_switch_off(struct intel_overlay *overlay)
         int ret;
 
         BUG_ON(!mutex_is_locked(&dev->struct_mutex));
-        BUG_ON(!mutex_is_locked(&dev->mode_config.connection_mutex));
+        BUG_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
 
         ret = intel_overlay_recover_from_interrupt(overlay);
         if (ret != 0)
diff --git a/drivers/gpu/drm/i915/intel_panel.c b/drivers/gpu/drm/i915/intel_panel.c
index d4d415665475..2e1338a5d488 100644
--- a/drivers/gpu/drm/i915/intel_panel.c
+++ b/drivers/gpu/drm/i915/intel_panel.c
@@ -876,12 +876,12 @@ static int intel_backlight_device_update_status(struct backlight_device *bd)
         struct intel_connector *connector = bl_get_data(bd);
         struct drm_device *dev = connector->base.dev;
 
-        mutex_lock(&dev->mode_config.connection_mutex);
+        drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
         DRM_DEBUG_KMS("updating intel_backlight, brightness=%d/%d\n",
                       bd->props.brightness, bd->props.max_brightness);
         intel_panel_set_backlight(connector, bd->props.brightness,
                                   bd->props.max_brightness);
-        mutex_unlock(&dev->mode_config.connection_mutex);
+        drm_modeset_unlock(&dev->mode_config.connection_mutex);
         return 0;
 }
 
@@ -893,9 +893,9 @@ static int intel_backlight_device_get_brightness(struct backlight_device *bd)
         int ret;
 
         intel_runtime_pm_get(dev_priv);
-        mutex_lock(&dev->mode_config.connection_mutex);
+        drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
         ret = intel_panel_get_backlight(connector);
-        mutex_unlock(&dev->mode_config.connection_mutex);
+        drm_modeset_unlock(&dev->mode_config.connection_mutex);
         intel_runtime_pm_put(dev_priv);
 
         return ret;
diff --git a/drivers/gpu/drm/i915/intel_sprite.c b/drivers/gpu/drm/i915/intel_sprite.c
index d6acd6bd0bf0..1b66ddcdfb33 100644
--- a/drivers/gpu/drm/i915/intel_sprite.c
+++ b/drivers/gpu/drm/i915/intel_sprite.c
@@ -55,7 +55,7 @@ static bool intel_pipe_update_start(struct intel_crtc *crtc, uint32_t *start_vbl
         int scanline, min, max, vblank_start;
         DEFINE_WAIT(wait);
 
-        WARN_ON(!mutex_is_locked(&crtc->base.mutex));
+        WARN_ON(!drm_modeset_is_locked(&crtc->base.mutex));
 
         vblank_start = mode->crtc_vblank_start;
         if (mode->flags & DRM_MODE_FLAG_INTERLACE)
diff --git a/drivers/gpu/drm/i915/intel_tv.c b/drivers/gpu/drm/i915/intel_tv.c
index 25850a86d70c..67c6c9a2eb1c 100644
--- a/drivers/gpu/drm/i915/intel_tv.c
+++ b/drivers/gpu/drm/i915/intel_tv.c
@@ -1321,10 +1321,11 @@ intel_tv_detect(struct drm_connector *connector, bool force)
 
         if (force) {
                 struct intel_load_detect_pipe tmp;
+                struct drm_modeset_acquire_ctx ctx;
 
-                if (intel_get_load_detect_pipe(connector, &mode, &tmp)) {
+                if (intel_get_load_detect_pipe(connector, &mode, &tmp, &ctx)) {
                         type = intel_tv_detect_type(intel_tv, connector);
-                        intel_release_load_detect_pipe(connector, &tmp);
+                        intel_release_load_detect_pipe(connector, &tmp, &ctx);
                 } else
                         return connector_status_unknown;
         } else
diff --git a/drivers/gpu/drm/omapdrm/omap_crtc.c b/drivers/gpu/drm/omapdrm/omap_crtc.c
index e3c47a8005ff..2d28dc337cfb 100644
--- a/drivers/gpu/drm/omapdrm/omap_crtc.c
+++ b/drivers/gpu/drm/omapdrm/omap_crtc.c
@@ -319,13 +319,13 @@ static void page_flip_worker(struct work_struct *work)
         struct drm_display_mode *mode = &crtc->mode;
         struct drm_gem_object *bo;
 
-        mutex_lock(&crtc->mutex);
+        drm_modeset_lock(&crtc->mutex, NULL);
         omap_plane_mode_set(omap_crtc->plane, crtc, crtc->primary->fb,
                         0, 0, mode->hdisplay, mode->vdisplay,
                         crtc->x << 16, crtc->y << 16,
                         mode->hdisplay << 16, mode->vdisplay << 16,
                         vblank_cb, crtc);
-        mutex_unlock(&crtc->mutex);
+        drm_modeset_unlock(&crtc->mutex);
 
         bo = omap_framebuffer_bo(crtc->primary->fb, 0);
         drm_gem_object_unreference_unlocked(bo);
@@ -465,7 +465,7 @@ static void apply_worker(struct work_struct *work)
          * the callbacks and list modification all serialized
          * with respect to modesetting ioctls from userspace.
          */
-        mutex_lock(&crtc->mutex);
+        drm_modeset_lock(&crtc->mutex, NULL);
         dispc_runtime_get();
 
         /*
@@ -510,7 +510,7 @@ static void apply_worker(struct work_struct *work)
 
 out:
         dispc_runtime_put();
-        mutex_unlock(&crtc->mutex);
+        drm_modeset_unlock(&crtc->mutex);
 }
 
 int omap_crtc_apply(struct drm_crtc *crtc,
@@ -518,7 +518,7 @@ int omap_crtc_apply(struct drm_crtc *crtc,
 {
         struct omap_crtc *omap_crtc = to_omap_crtc(crtc);
 
-        WARN_ON(!mutex_is_locked(&crtc->mutex));
+        WARN_ON(!drm_modeset_is_locked(&crtc->mutex));
 
         /* no need to queue it again if it is already queued: */
         if (apply->queued)
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c b/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c
index e7199b454ca0..8f3edc4710f2 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c
@@ -187,7 +187,7 @@ int vmw_du_crtc_cursor_set(struct drm_crtc *crtc, struct drm_file *file_priv,
          * can do this since the caller in the drm core doesn't check anything
          * which is protected by any looks.
          */
-        mutex_unlock(&crtc->mutex);
+        drm_modeset_unlock(&crtc->mutex);
         drm_modeset_lock_all(dev_priv->dev);
 
         /* A lot of the code assumes this */
@@ -252,7 +252,7 @@ int vmw_du_crtc_cursor_set(struct drm_crtc *crtc, struct drm_file *file_priv,
         ret = 0;
 out:
         drm_modeset_unlock_all(dev_priv->dev);
-        mutex_lock(&crtc->mutex);
+        drm_modeset_lock(&crtc->mutex, NULL);
 
         return ret;
 }
@@ -273,7 +273,7 @@ int vmw_du_crtc_cursor_move(struct drm_crtc *crtc, int x, int y)
          * can do this since the caller in the drm core doesn't check anything
          * which is protected by any looks.
          */
-        mutex_unlock(&crtc->mutex);
+        drm_modeset_unlock(&crtc->mutex);
         drm_modeset_lock_all(dev_priv->dev);
 
         vmw_cursor_update_position(dev_priv, shown,
@@ -281,7 +281,7 @@ int vmw_du_crtc_cursor_move(struct drm_crtc *crtc, int x, int y)
                                    du->cursor_y + du->hotspot_y);
 
         drm_modeset_unlock_all(dev_priv->dev);
-        mutex_lock(&crtc->mutex);
+        drm_modeset_lock(&crtc->mutex, NULL);
 
         return 0;
 }