struct drm_framebuffer *fb,
                                 struct drm_pending_vblank_event *event,
                                 uint32_t page_flip_flags,
-                                uint32_t target)
+                                uint32_t target,
+                                struct drm_modeset_acquire_ctx *ctx)
 {
        struct amdgpu_bo *new_abo;
        struct amdgpu_flip_work *work;
 
 int amdgpu_crtc_page_flip_target(struct drm_crtc *crtc,
                                 struct drm_framebuffer *fb,
                                 struct drm_pending_vblank_event *event,
-                                uint32_t page_flip_flags, uint32_t target);
+                                uint32_t page_flip_flags, uint32_t target,
+                                struct drm_modeset_acquire_ctx *ctx);
 void amdgpu_crtc_cleanup_flip_ctx(struct amdgpu_flip_work *work,
                                  struct amdgpu_bo *new_abo);
 int amdgpu_crtc_prepare_flip(struct drm_crtc *crtc,
 
  * and a mode_set.
  */
 static int armada_drm_crtc_page_flip(struct drm_crtc *crtc,
-       struct drm_framebuffer *fb, struct drm_pending_vblank_event *event, uint32_t page_flip_flags)
+       struct drm_framebuffer *fb, struct drm_pending_vblank_event *event, uint32_t page_flip_flags,
+       struct drm_modeset_acquire_ctx *ctx)
 {
        struct armada_crtc *dcrtc = drm_to_armada_crtc(crtc);
        struct armada_frame_work *work;
 
 static int bochs_crtc_page_flip(struct drm_crtc *crtc,
                                struct drm_framebuffer *fb,
                                struct drm_pending_vblank_event *event,
-                               uint32_t page_flip_flags)
+                               uint32_t page_flip_flags,
+                               struct drm_modeset_acquire_ctx *ctx)
 {
        struct bochs_device *bochs =
                container_of(crtc, struct bochs_device, crtc);
 
  * @fb: DRM framebuffer
  * @event: optional DRM event to signal upon completion
  * @flags: flip flags for non-vblank sync'ed updates
+ * @ctx: lock acquisition context
  *
  * Provides a default &drm_crtc_funcs.page_flip implementation
  * using the atomic driver interface.
 int drm_atomic_helper_page_flip(struct drm_crtc *crtc,
                                struct drm_framebuffer *fb,
                                struct drm_pending_vblank_event *event,
-                               uint32_t flags)
+                               uint32_t flags,
+                               struct drm_modeset_acquire_ctx *ctx)
 {
        struct drm_plane *plane = crtc->primary;
        struct drm_atomic_state *state;
  * @event: optional DRM event to signal upon completion
  * @flags: flip flags for non-vblank sync'ed updates
  * @target: specifying the target vblank period when the flip to take effect
+ * @ctx: lock acquisition context
  *
  * Provides a default &drm_crtc_funcs.page_flip_target implementation.
  * Similar to drm_atomic_helper_page_flip() with extra parameter to specify
                                struct drm_framebuffer *fb,
                                struct drm_pending_vblank_event *event,
                                uint32_t flags,
-                               uint32_t target)
+                               uint32_t target,
+                               struct drm_modeset_acquire_ctx *ctx)
 {
        struct drm_plane *plane = crtc->primary;
        struct drm_atomic_state *state;
 
        if (crtc->funcs->page_flip_target)
                ret = crtc->funcs->page_flip_target(crtc, fb, e,
                                                    page_flip->flags,
-                                                   target_vblank);
+                                                   target_vblank,
+                                                   &ctx);
        else
-               ret = crtc->funcs->page_flip(crtc, fb, e, page_flip->flags);
+               ret = crtc->funcs->page_flip(crtc, fb, e, page_flip->flags,
+                                            &ctx);
        if (ret) {
                if (page_flip->flags & DRM_MODE_PAGE_FLIP_EVENT)
                        drm_event_cancel_free(dev, &e->base);
 
 
 int
 nouveau_crtc_page_flip(struct drm_crtc *crtc, struct drm_framebuffer *fb,
-                      struct drm_pending_vblank_event *event, u32 flags)
+                      struct drm_pending_vblank_event *event, u32 flags,
+                      struct drm_modeset_acquire_ctx *ctx)
 {
        const int swap_interval = (flags & DRM_MODE_PAGE_FLIP_ASYNC) ? 0 : 1;
        struct drm_device *dev = crtc->dev;
 
 
 int  nouveau_crtc_page_flip(struct drm_crtc *crtc, struct drm_framebuffer *fb,
                            struct drm_pending_vblank_event *event,
-                           uint32_t page_flip_flags);
+                           uint32_t page_flip_flags,
+                           struct drm_modeset_acquire_ctx *ctx);
 int  nouveau_finish_page_flip(struct nouveau_channel *,
                              struct nouveau_page_flip_state *);
 
 
                                        struct drm_framebuffer *fb,
                                        struct drm_pending_vblank_event *event,
                                        uint32_t page_flip_flags,
-                                       uint32_t target)
+                                       uint32_t target,
+                                       struct drm_modeset_acquire_ctx *ctx)
 {
        struct drm_device *dev = crtc->dev;
        struct radeon_device *rdev = dev->dev_private;
 
 static int shmob_drm_crtc_page_flip(struct drm_crtc *crtc,
                                    struct drm_framebuffer *fb,
                                    struct drm_pending_vblank_event *event,
-                                   uint32_t page_flip_flags)
+                                   uint32_t page_flip_flags,
+                                   struct drm_modeset_acquire_ctx *ctx)
 {
        struct shmob_drm_crtc *scrtc = to_shmob_crtc(crtc);
        struct drm_device *dev = scrtc->crtc.dev;
 
 static int udl_crtc_page_flip(struct drm_crtc *crtc,
                              struct drm_framebuffer *fb,
                              struct drm_pending_vblank_event *event,
-                             uint32_t page_flip_flags)
+                             uint32_t page_flip_flags,
+                             struct drm_modeset_acquire_ctx *ctx)
 {
        struct udl_framebuffer *ufb = to_udl_fb(fb);
        struct drm_device *dev = crtc->dev;
 
 static int vc4_page_flip(struct drm_crtc *crtc,
                         struct drm_framebuffer *fb,
                         struct drm_pending_vblank_event *event,
-                        uint32_t flags)
+                        uint32_t flags,
+                        struct drm_modeset_acquire_ctx *ctx)
 {
        if (flags & DRM_MODE_PAGE_FLIP_ASYNC)
                return vc4_async_page_flip(crtc, fb, event, flags);
        else
-               return drm_atomic_helper_page_flip(crtc, fb, event, flags);
+               return drm_atomic_helper_page_flip(crtc, fb, event, flags, ctx);
 }
 
 static struct drm_crtc_state *vc4_crtc_duplicate_state(struct drm_crtc *crtc)
 
 static int vmw_sou_crtc_page_flip(struct drm_crtc *crtc,
                                  struct drm_framebuffer *fb,
                                  struct drm_pending_vblank_event *event,
-                                 uint32_t flags)
+                                 uint32_t flags,
+                                 struct drm_modeset_acquire_ctx *ctx)
 {
        struct vmw_private *dev_priv = vmw_priv(crtc->dev);
        struct drm_framebuffer *old_fb = crtc->primary->fb;
 
 static int vmw_stdu_crtc_page_flip(struct drm_crtc *crtc,
                                   struct drm_framebuffer *new_fb,
                                   struct drm_pending_vblank_event *event,
-                                  uint32_t flags)
+                                  uint32_t flags,
+                                  struct drm_modeset_acquire_ctx *ctx)
 
 {
        struct vmw_private *dev_priv = vmw_priv(crtc->dev);
 
 int drm_atomic_helper_page_flip(struct drm_crtc *crtc,
                                struct drm_framebuffer *fb,
                                struct drm_pending_vblank_event *event,
-                               uint32_t flags);
+                               uint32_t flags,
+                               struct drm_modeset_acquire_ctx *ctx);
 int drm_atomic_helper_page_flip_target(
                                struct drm_crtc *crtc,
                                struct drm_framebuffer *fb,
                                struct drm_pending_vblank_event *event,
                                uint32_t flags,
-                               uint32_t target);
+                               uint32_t target,
+                               struct drm_modeset_acquire_ctx *ctx);
 int drm_atomic_helper_connector_dpms(struct drm_connector *connector,
                                     int mode);
 struct drm_encoder *
 
        int (*page_flip)(struct drm_crtc *crtc,
                         struct drm_framebuffer *fb,
                         struct drm_pending_vblank_event *event,
-                        uint32_t flags);
+                        uint32_t flags,
+                        struct drm_modeset_acquire_ctx *ctx);
 
        /**
         * @page_flip_target:
        int (*page_flip_target)(struct drm_crtc *crtc,
                                struct drm_framebuffer *fb,
                                struct drm_pending_vblank_event *event,
-                               uint32_t flags, uint32_t target);
+                               uint32_t flags, uint32_t target,
+                               struct drm_modeset_acquire_ctx *ctx);
 
        /**
         * @set_property: