drm: convert crtc and connection_mutex to ww_mutex (v5)

For atomic, it will be quite necessary to not need to care so much
about locking order.  And 'state' gives us a convenient place to stash a
ww_ctx for any sort of update that needs to grab multiple crtc locks.

Because we will want to eventually make locking even more fine grained
(giving locks to planes, connectors, etc), split out drm_modeset_lock
and drm_modeset_acquire_ctx to track acquired locks.

Atomic will use this to keep track of which locks have been acquired
in a transaction.

v1: original
v2: remove a few things not needed until atomic, for now
v3: update for v3 of connection_mutex patch..
v4: squash in docbook
v5: doc tweaks/fixes

Signed-off-by: Rob Clark <robdclark@gmail.com>
Reviewed-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Signed-off-by: Dave Airlie <airlied@redhat.com>

21 files changed, 531 insertions, 87 deletions

diff --git a/Documentation/DocBook/drm.tmpl b/Documentation/DocBook/drm.tmpl
index 00f1c25e53df..efef63717ef6 100644
--- a/Documentation/DocBook/drm.tmpl
+++ b/Documentation/DocBook/drm.tmpl
@@ -1791,6 +1791,12 @@ void intel_crt_init(struct drm_device *dev)
       <title>KMS API Functions</title>
 !Edrivers/gpu/drm/drm_crtc.c
     </sect2>
+    <sect2>
+      <title>KMS Locking</title>
+!Pdrivers/gpu/drm/drm_modeset_lock.c kms locking
+!Iinclude/drm/drm_modeset_lock.h
+!Edrivers/gpu/drm/drm_modeset_lock.c
+    </sect2>
   </sect1>
 
   <!-- Internals: kms helper functions -->
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;
 }
diff --git a/include/drm/drmP.h b/include/drm/drmP.h
index 76ccaabd0418..475ca5cf3c20 100644
--- a/include/drm/drmP.h
+++ b/include/drm/drmP.h
@@ -1186,11 +1186,6 @@ static inline int drm_device_is_unplugged(struct drm_device *dev)
         return ret;
 }
 
-static inline bool drm_modeset_is_locked(struct drm_device *dev)
-{
-        return mutex_is_locked(&dev->mode_config.mutex);
-}
-
 static inline bool drm_is_render_client(const struct drm_file *file_priv)
 {
         return file_priv->minor->type == DRM_MINOR_RENDER;
diff --git a/include/drm/drm_crtc.h b/include/drm/drm_crtc.h
index 6c295df7b0df..a7fac5686915 100644
--- a/include/drm/drm_crtc.h
+++ b/include/drm/drm_crtc.h
@@ -33,6 +33,7 @@
 #include <linux/hdmi.h>
 #include <drm/drm_mode.h>
 #include <drm/drm_fourcc.h>
+#include <drm/drm_modeset_lock.h>
 
 struct drm_device;
 struct drm_mode_set;
@@ -205,6 +206,10 @@ struct drm_property {
         struct list_head enum_blob_list;
 };
 
+void drm_modeset_lock_all(struct drm_device *dev);
+void drm_modeset_unlock_all(struct drm_device *dev);
+void drm_warn_on_modeset_not_all_locked(struct drm_device *dev);
+
 struct drm_crtc;
 struct drm_connector;
 struct drm_encoder;
@@ -280,6 +285,7 @@ struct drm_crtc_funcs {
  * drm_crtc - central CRTC control structure
  * @dev: parent DRM device
  * @head: list management
+ * @mutex: per-CRTC locking
  * @base: base KMS object for ID tracking etc.
  * @primary: primary plane for this CRTC
  * @cursor: cursor plane for this CRTC
@@ -314,7 +320,7 @@ struct drm_crtc {
          * state, ...) and a write lock for everything which can be update
          * without a full modeset (fb, cursor data, ...)
          */
-        struct mutex mutex;
+        struct drm_modeset_lock mutex;
 
         struct drm_mode_object base;
 
@@ -738,7 +744,8 @@ struct drm_mode_group {
  */
 struct drm_mode_config {
         struct mutex mutex; /* protects configuration (mode lists etc.) */
-        struct mutex connection_mutex; /* protects connector->encoder and encoder->crtc links */
+        struct drm_modeset_lock connection_mutex; /* protects connector->encoder and encoder->crtc links */
+        struct drm_modeset_acquire_ctx *acquire_ctx; /* for legacy _lock_all() / _unlock_all() */
         struct mutex idr_mutex; /* for IDR management */
         struct idr crtc_idr; /* use this idr for all IDs, fb, crtc, connector, modes - just makes life easier */
         /* this is limited to one for now */
@@ -839,10 +846,6 @@ struct drm_prop_enum_list {
         char *name;
 };
 
-extern void drm_modeset_lock_all(struct drm_device *dev);
-extern void drm_modeset_unlock_all(struct drm_device *dev);
-extern void drm_warn_on_modeset_not_all_locked(struct drm_device *dev);
-
 extern int drm_crtc_init_with_planes(struct drm_device *dev,
                                      struct drm_crtc *crtc,
                                      struct drm_plane *primary,
diff --git a/include/drm/drm_modeset_lock.h b/include/drm/drm_modeset_lock.h
new file mode 100644
index 000000000000..402aa7a6a058
--- /dev/null
+++ b/include/drm/drm_modeset_lock.h
@@ -0,0 +1,126 @@
+/*
+ * 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.
+ */
+
+#ifndef DRM_MODESET_LOCK_H_
+#define DRM_MODESET_LOCK_H_
+
+#include <linux/ww_mutex.h>
+
+struct drm_modeset_lock;
+
+/**
+ * drm_modeset_acquire_ctx - locking context (see ww_acquire_ctx)
+ * @ww_ctx: base acquire ctx
+ * @contended: used internally for -EDEADLK handling
+ * @locked: list of held locks
+ *
+ * Each thread competing for a set of locks must use one acquire
+ * ctx.  And if any lock fxn returns -EDEADLK, it must backoff and
+ * retry.
+ */
+struct drm_modeset_acquire_ctx {
+
+        struct ww_acquire_ctx ww_ctx;
+
+        /**
+         * Contended lock: if a lock is contended you should only call
+         * drm_modeset_backoff() which drops locks and slow-locks the
+         * contended lock.
+         */
+        struct drm_modeset_lock *contended;
+
+        /**
+         * list of held locks (drm_modeset_lock)
+         */
+        struct list_head locked;
+};
+
+/**
+ * drm_modeset_lock - used for locking modeset resources.
+ * @mutex: resource locking
+ * @head: used to hold it's place on state->locked list when
+ *    part of an atomic update
+ *
+ * Used for locking CRTCs and other modeset resources.
+ */
+struct drm_modeset_lock {
+        /**
+         * modeset lock
+         */
+        struct ww_mutex mutex;
+
+        /**
+         * Resources that are locked as part of an atomic update are added
+         * to a list (so we know what to unlock at the end).
+         */
+        struct list_head head;
+};
+
+extern struct ww_class crtc_ww_class;
+
+void drm_modeset_acquire_init(struct drm_modeset_acquire_ctx *ctx,
+                uint32_t flags);
+void drm_modeset_acquire_fini(struct drm_modeset_acquire_ctx *ctx);
+void drm_modeset_drop_locks(struct drm_modeset_acquire_ctx *ctx);
+void drm_modeset_backoff(struct drm_modeset_acquire_ctx *ctx);
+int drm_modeset_backoff_interruptible(struct drm_modeset_acquire_ctx *ctx);
+
+/**
+ * drm_modeset_lock_init - initialize lock
+ * @lock: lock to init
+ */
+static inline void drm_modeset_lock_init(struct drm_modeset_lock *lock)
+{
+        ww_mutex_init(&lock->mutex, &crtc_ww_class);
+        INIT_LIST_HEAD(&lock->head);
+}
+
+/**
+ * drm_modeset_lock_fini - cleanup lock
+ * @lock: lock to cleanup
+ */
+static inline void drm_modeset_lock_fini(struct drm_modeset_lock *lock)
+{
+        WARN_ON(!list_empty(&lock->head));
+}
+
+/**
+ * drm_modeset_is_locked - equivalent to mutex_is_locked()
+ * @lock: lock to check
+ */
+static inline bool drm_modeset_is_locked(struct drm_modeset_lock *lock)
+{
+        return ww_mutex_is_locked(&lock->mutex);
+}
+
+int drm_modeset_lock(struct drm_modeset_lock *lock,
+                struct drm_modeset_acquire_ctx *ctx);
+int drm_modeset_lock_interruptible(struct drm_modeset_lock *lock,
+                struct drm_modeset_acquire_ctx *ctx);
+void drm_modeset_unlock(struct drm_modeset_lock *lock);
+
+struct drm_device;
+int drm_modeset_lock_all_crtcs(struct drm_device *dev,
+                struct drm_modeset_acquire_ctx *ctx);
+
+#endif /* DRM_MODESET_LOCK_H_ */