Merge remote-tracking branch 'airlied/drm-next' into drm-intel-next-queued

Backmerge drm-next to get at the nonblocking atomic helpers, needed to
merge the i915 conversion.

Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>

11 files changed, 578 insertions, 97 deletions

diff --git a/include/drm/drmP.h b/include/drm/drmP.h
index c5d29505f937..04310cb08111 100644
--- a/include/drm/drmP.h
+++ b/include/drm/drmP.h
@@ -57,6 +57,7 @@
 #include <linux/types.h>
 #include <linux/vmalloc.h>
 #include <linux/workqueue.h>
+#include <linux/fence.h>
 
 #include <asm/mman.h>
 #include <asm/pgalloc.h>
@@ -67,6 +68,7 @@
 
 #include <drm/drm_agpsupport.h>
 #include <drm/drm_crtc.h>
+#include <drm/drm_fourcc.h>
 #include <drm/drm_global.h>
 #include <drm/drm_hashtab.h>
 #include <drm/drm_mem_util.h>
@@ -282,13 +284,14 @@ struct drm_ioctl_desc {
 
 /* Event queued up for userspace to read */
 struct drm_pending_event {
+        struct completion *completion;
         struct drm_event *event;
+        struct fence *fence;
         struct list_head link;
         struct list_head pending_link;
         struct drm_file *file_priv;
         pid_t pid; /* pid of requester, no guarantee it's valid by the time
                       we deliver the event, for tracing only */
-        void (*destroy)(struct drm_pending_event *event);
 };
 
 /* initial implementaton using a linked list - todo hashtab */
@@ -416,8 +419,6 @@ struct drm_driver {
         void (*postclose) (struct drm_device *, struct drm_file *);
         void (*lastclose) (struct drm_device *);
         int (*unload) (struct drm_device *);
-        int (*suspend) (struct drm_device *, pm_message_t state);
-        int (*resume) (struct drm_device *);
         int (*dma_ioctl) (struct drm_device *dev, void *data, struct drm_file *file_priv);
         int (*dma_quiescent) (struct drm_device *);
         int (*context_dtor) (struct drm_device *dev, int context);
@@ -430,7 +431,7 @@ struct drm_driver {
          *
          * Driver callback for fetching a raw hardware vblank counter for @crtc.
          * If a device doesn't have a hardware counter, the driver can simply
-         * return the value of drm_vblank_count. The DRM core will account for
+         * use drm_vblank_no_hw_counter() function. The DRM core will account for
          * missed vblank events while interrupts where disabled based on system
          * timestamps.
          *
@@ -448,8 +449,8 @@ struct drm_driver {
          * @pipe: which irq to enable
          *
          * Enable vblank interrupts for @crtc.  If the device doesn't have
-         * a hardware vblank counter, this routine should be a no-op, since
-         * interrupts will have to stay on to keep the count accurate.
+         * a hardware vblank counter, the driver should use the
+         * drm_vblank_no_hw_counter() function that keeps a virtual counter.
          *
          * RETURNS
          * Zero on success, appropriate errno if the given @crtc's vblank
@@ -463,8 +464,8 @@ struct drm_driver {
          * @pipe: which irq to enable
          *
          * Disable vblank interrupts for @crtc.  If the device doesn't have
-         * a hardware vblank counter, this routine should be a no-op, since
-         * interrupts will have to stay on to keep the count accurate.
+         * a hardware vblank counter, the driver should use the
+         * drm_vblank_no_hw_counter() function that keeps a virtual counter.
          */
         void (*disable_vblank) (struct drm_device *dev, unsigned int pipe);
 
@@ -968,18 +969,12 @@ extern u32 drm_vblank_count_and_time(struct drm_device *dev, unsigned int pipe,
                                      struct timeval *vblanktime);
 extern u32 drm_crtc_vblank_count_and_time(struct drm_crtc *crtc,
                                           struct timeval *vblanktime);
-extern void drm_send_vblank_event(struct drm_device *dev, unsigned int pipe,
-                                  struct drm_pending_vblank_event *e);
 extern void drm_crtc_send_vblank_event(struct drm_crtc *crtc,
                                        struct drm_pending_vblank_event *e);
-extern void drm_arm_vblank_event(struct drm_device *dev, unsigned int pipe,
-                                 struct drm_pending_vblank_event *e);
 extern void drm_crtc_arm_vblank_event(struct drm_crtc *crtc,
                                       struct drm_pending_vblank_event *e);
 extern bool drm_handle_vblank(struct drm_device *dev, unsigned int pipe);
 extern bool drm_crtc_handle_vblank(struct drm_crtc *crtc);
-extern int drm_vblank_get(struct drm_device *dev, unsigned int pipe);
-extern void drm_vblank_put(struct drm_device *dev, unsigned int pipe);
 extern int drm_crtc_vblank_get(struct drm_crtc *crtc);
 extern void drm_crtc_vblank_put(struct drm_crtc *crtc);
 extern void drm_wait_one_vblank(struct drm_device *dev, unsigned int pipe);
diff --git a/include/drm/drm_atomic.h b/include/drm/drm_atomic.h
index 92c84e9ab09a..856a9c85a838 100644
--- a/include/drm/drm_atomic.h
+++ b/include/drm/drm_atomic.h
@@ -30,6 +30,12 @@
 
 #include <drm/drm_crtc.h>
 
+void drm_crtc_commit_put(struct drm_crtc_commit *commit);
+static inline void drm_crtc_commit_get(struct drm_crtc_commit *commit)
+{
+        kref_get(&commit->ref);
+}
+
 struct drm_atomic_state * __must_check
 drm_atomic_state_alloc(struct drm_device *dev);
 void drm_atomic_state_clear(struct drm_atomic_state *state);
@@ -71,7 +77,7 @@ static inline struct drm_crtc_state *
 drm_atomic_get_existing_crtc_state(struct drm_atomic_state *state,
                                    struct drm_crtc *crtc)
 {
-        return state->crtc_states[drm_crtc_index(crtc)];
+        return state->crtcs[drm_crtc_index(crtc)].state;
 }
 
 /**
@@ -86,7 +92,7 @@ static inline struct drm_plane_state *
 drm_atomic_get_existing_plane_state(struct drm_atomic_state *state,
                                     struct drm_plane *plane)
 {
-        return state->plane_states[drm_plane_index(plane)];
+        return state->planes[drm_plane_index(plane)].state;
 }
 
 /**
@@ -106,7 +112,43 @@ drm_atomic_get_existing_connector_state(struct drm_atomic_state *state,
         if (index >= state->num_connector)
                 return NULL;
 
-        return state->connector_states[index];
+        return state->connectors[index].state;
+}
+
+/**
+ * __drm_atomic_get_current_plane_state - get current plane state
+ * @state: global atomic state object
+ * @plane: plane to grab
+ *
+ * This function returns the plane state for the given plane, either from
+ * @state, or if the plane isn't part of the atomic state update, from @plane.
+ * This is useful in atomic check callbacks, when drivers need to peek at, but
+ * not change, state of other planes, since it avoids threading an error code
+ * back up the call chain.
+ *
+ * WARNING:
+ *
+ * Note that this function is in general unsafe since it doesn't check for the
+ * required locking for access state structures. Drivers must ensure that it is
+ * safe to access the returned state structure through other means. One common
+ * example is when planes are fixed to a single CRTC, and the driver knows that
+ * the CRTC lock is held already. In that case holding the CRTC lock gives a
+ * read-lock on all planes connected to that CRTC. But if planes can be
+ * reassigned things get more tricky. In that case it's better to use
+ * drm_atomic_get_plane_state and wire up full error handling.
+ *
+ * Returns:
+ *
+ * Read-only pointer to the current plane state.
+ */
+static inline const struct drm_plane_state *
+__drm_atomic_get_current_plane_state(struct drm_atomic_state *state,
+                                     struct drm_plane *plane)
+{
+        if (state->planes[drm_plane_index(plane)].state)
+                return state->planes[drm_plane_index(plane)].state;
+
+        return plane->state;
 }
 
 int __must_check
@@ -139,29 +181,39 @@ int __must_check drm_atomic_check_only(struct drm_atomic_state *state);
 int __must_check drm_atomic_commit(struct drm_atomic_state *state);
 int __must_check drm_atomic_nonblocking_commit(struct drm_atomic_state *state);
 
-#define for_each_connector_in_state(state, connector, connector_state, __i) \
+#define for_each_connector_in_state(__state, connector, connector_state, __i) \
         for ((__i) = 0;                                                 \
-             (__i) < (state)->num_connector &&                          \
-             ((connector) = (state)->connectors[__i],                   \
-             (connector_state) = (state)->connector_states[__i], 1);    \
+             (__i) < (__state)->num_connector &&                                \
+             ((connector) = (__state)->connectors[__i].ptr,                     \
+             (connector_state) = (__state)->connectors[__i].state, 1);  \
              (__i)++)                                                   \
                 for_each_if (connector)
 
-#define for_each_crtc_in_state(state, crtc, crtc_state, __i)    \
+#define for_each_crtc_in_state(__state, crtc, crtc_state, __i)  \
         for ((__i) = 0;                                         \
-             (__i) < (state)->dev->mode_config.num_crtc &&      \
-             ((crtc) = (state)->crtcs[__i],                     \
-             (crtc_state) = (state)->crtc_states[__i], 1);      \
+             (__i) < (__state)->dev->mode_config.num_crtc &&    \
+             ((crtc) = (__state)->crtcs[__i].ptr,                       \
+             (crtc_state) = (__state)->crtcs[__i].state, 1);    \
              (__i)++)                                           \
                 for_each_if (crtc_state)
 
-#define for_each_plane_in_state(state, plane, plane_state, __i)         \
+#define for_each_plane_in_state(__state, plane, plane_state, __i)               \
         for ((__i) = 0;                                                 \
-             (__i) < (state)->dev->mode_config.num_total_plane &&       \
-             ((plane) = (state)->planes[__i],                           \
-             (plane_state) = (state)->plane_states[__i], 1);            \
+             (__i) < (__state)->dev->mode_config.num_total_plane &&     \
+             ((plane) = (__state)->planes[__i].ptr,                             \
+             (plane_state) = (__state)->planes[__i].state, 1);          \
              (__i)++)                                                   \
                 for_each_if (plane_state)
+
+/**
+ * drm_atomic_crtc_needs_modeset - compute combined modeset need
+ * @state: &drm_crtc_state for the CRTC
+ *
+ * To give drivers flexibility struct &drm_crtc_state has 3 booleans to track
+ * whether the state CRTC changed enough to need a full modeset cycle:
+ * connectors_changed, mode_changed and active_change. This helper simply
+ * combines these three to compute the overall need for a modeset for @state.
+ */
 static inline bool
 drm_atomic_crtc_needs_modeset(struct drm_crtc_state *state)
 {
diff --git a/include/drm/drm_atomic_helper.h b/include/drm/drm_atomic_helper.h
index d473dcc91f54..d86ae5dcd7b4 100644
--- a/include/drm/drm_atomic_helper.h
+++ b/include/drm/drm_atomic_helper.h
@@ -38,6 +38,7 @@ int drm_atomic_helper_check_planes(struct drm_device *dev,
                                struct drm_atomic_state *state);
 int drm_atomic_helper_check(struct drm_device *dev,
                             struct drm_atomic_state *state);
+void drm_atomic_helper_commit_tail(struct drm_atomic_state *state);
 int drm_atomic_helper_commit(struct drm_device *dev,
                              struct drm_atomic_state *state,
                              bool nonblock);
@@ -71,8 +72,15 @@ void drm_atomic_helper_commit_planes_on_crtc(struct drm_crtc_state *old_crtc_sta
 void drm_atomic_helper_disable_planes_on_crtc(struct drm_crtc *crtc,
                                               bool atomic);
 
-void drm_atomic_helper_swap_state(struct drm_device *dev,
-                                  struct drm_atomic_state *state);
+void drm_atomic_helper_swap_state(struct drm_atomic_state *state,
+                                  bool stall);
+
+/* nonblocking commit helpers */
+int drm_atomic_helper_setup_commit(struct drm_atomic_state *state,
+                                   bool nonblock);
+void drm_atomic_helper_wait_for_dependencies(struct drm_atomic_state *state);
+void drm_atomic_helper_commit_hw_done(struct drm_atomic_state *state);
+void drm_atomic_helper_commit_cleanup_done(struct drm_atomic_state *state);
 
 /* implementations for legacy interfaces */
 int drm_atomic_helper_update_plane(struct drm_plane *plane,
@@ -147,9 +155,9 @@ void
 __drm_atomic_helper_connector_destroy_state(struct drm_connector_state *state);
 void drm_atomic_helper_connector_destroy_state(struct drm_connector *connector,
                                           struct drm_connector_state *state);
-void drm_atomic_helper_legacy_gamma_set(struct drm_crtc *crtc,
-                                        u16 *red, u16 *green, u16 *blue,
-                                        uint32_t start, uint32_t size);
+int drm_atomic_helper_legacy_gamma_set(struct drm_crtc *crtc,
+                                       u16 *red, u16 *green, u16 *blue,
+                                       uint32_t size);
 
 /**
  * drm_atomic_crtc_for_each_plane - iterate over planes currently attached to CRTC
@@ -159,7 +167,7 @@ void drm_atomic_helper_legacy_gamma_set(struct drm_crtc *crtc,
  * This iterates over the current state, useful (for example) when applying
  * atomic state after it has been checked and swapped.  To iterate over the
  * planes which *will* be attached (for ->atomic_check()) see
- * drm_crtc_for_each_pending_plane()
+ * drm_atomic_crtc_state_for_each_plane().
  */
 #define drm_atomic_crtc_for_each_plane(plane, crtc) \
         drm_for_each_plane_mask(plane, (crtc)->dev, (crtc)->state->plane_mask)
@@ -171,11 +179,31 @@ void drm_atomic_helper_legacy_gamma_set(struct drm_crtc *crtc,
  *
  * Similar to drm_crtc_for_each_plane(), but iterates the planes that will be
  * attached if the specified state is applied.  Useful during (for example)
- * ->atomic_check() operations, to validate the incoming state
+ * ->atomic_check() operations, to validate the incoming state.
  */
 #define drm_atomic_crtc_state_for_each_plane(plane, crtc_state) \
         drm_for_each_plane_mask(plane, (crtc_state)->state->dev, (crtc_state)->plane_mask)
 
+/**
+ * drm_crtc_atomic_state_for_each_plane_state - iterate over attached planes in new state
+ * @plane: the loop cursor
+ * @plane_state: loop cursor for the plane's state, must be const
+ * @crtc_state: the incoming crtc-state
+ *
+ * Similar to drm_crtc_for_each_plane(), but iterates the planes that will be
+ * attached if the specified state is applied.  Useful during (for example)
+ * ->atomic_check() operations, to validate the incoming state.
+ *
+ * Compared to just drm_atomic_crtc_state_for_each_plane() this also fills in a
+ * const plane_state. This is useful when a driver just wants to peek at other
+ * active planes on this crtc, but does not need to change it.
+ */
+#define drm_atomic_crtc_state_for_each_plane_state(plane, plane_state, crtc_state) \
+        drm_for_each_plane_mask(plane, (crtc_state)->state->dev, (crtc_state)->plane_mask) \
+                for_each_if ((plane_state = \
+                              __drm_atomic_get_current_plane_state((crtc_state)->state, \
+                                                                   plane)))
+
 /*
  * drm_atomic_plane_disabling - check whether a plane is being disabled
  * @plane: plane object
diff --git a/include/drm/drm_crtc.h b/include/drm/drm_crtc.h
index d1559cd04e3d..914baa8c161d 100644
--- a/include/drm/drm_crtc.h
+++ b/include/drm/drm_crtc.h
@@ -253,6 +253,8 @@ struct drm_framebuffer {
         int bits_per_pixel;
         int flags;
         uint32_t pixel_format; /* fourcc format */
+        int hot_x;
+        int hot_y;
         struct list_head filp_head;
 };
 
@@ -314,6 +316,7 @@ struct drm_plane_helper_funcs;
  *      update to ensure framebuffer cleanup isn't done too early
  * @adjusted_mode: for use by helpers and drivers to compute adjusted mode timings
  * @mode: current mode timings
+ * @mode_blob: &drm_property_blob for @mode
  * @degamma_lut: Lookup table for converting framebuffer pixel data
  *      before apply the conversion matrix
  * @ctm: Transformation matrix
@@ -478,8 +481,8 @@ struct drm_crtc_funcs {
          * going on, which should eventually be unified to just one set of
          * hooks.
          */
-        void (*gamma_set)(struct drm_crtc *crtc, u16 *r, u16 *g, u16 *b,
-                          uint32_t start, uint32_t size);
+        int (*gamma_set)(struct drm_crtc *crtc, u16 *r, u16 *g, u16 *b,
+                         uint32_t size);
 
         /**
          * @destroy:
@@ -708,6 +711,7 @@ struct drm_crtc_funcs {
  * @dev: parent DRM device
  * @port: OF node used by drm_of_find_possible_crtcs()
  * @head: list management
+ * @name: human readable name, can be overwritten by the driver
  * @mutex: per-CRTC locking
  * @base: base KMS object for ID tracking etc.
  * @primary: primary plane for this CRTC
@@ -724,9 +728,6 @@ struct drm_crtc_funcs {
  * @gamma_store: gamma ramp values
  * @helper_private: mid-layer private data
  * @properties: property tracking for this CRTC
- * @state: current atomic state for this CRTC
- * @acquire_ctx: per-CRTC implicit acquire context used by atomic drivers for
- *      legacy IOCTLs
  *
  * Each CRTC may have one or more connectors associated with it.  This structure
  * allows the CRTC to be controlled.
@@ -738,12 +739,13 @@ struct drm_crtc {
 
         char *name;
 
-        /*
-         * crtc mutex
+        /**
+         * @mutex:
          *
          * This provides a read lock for the overall crtc state (mode, dpms
          * state, ...) and a write lock for everything which can be update
-         * without a full modeset (fb, cursor data, ...)
+         * without a full modeset (fb, cursor data, crtc properties ...). Full
+         * modeset also need to grab dev->mode_config.connection_mutex.
          */
         struct drm_modeset_lock mutex;
 
@@ -753,6 +755,9 @@ struct drm_crtc {
         struct drm_plane *primary;
         struct drm_plane *cursor;
 
+        /* position inside the mode_config.list, can be used as a [] idx */
+        unsigned index;
+
         /* position of cursor plane on crtc */
         int cursor_x;
         int cursor_y;
@@ -779,11 +784,37 @@ struct drm_crtc {
 
         struct drm_object_properties properties;
 
+        /**
+         * @state:
+         *
+         * Current atomic state for this CRTC.
+         */
         struct drm_crtc_state *state;
 
-        /*
-         * For legacy crtc IOCTLs so that atomic drivers can get at the locking
-         * acquire context.
+        /**
+         * @commit_list:
+         *
+         * List of &drm_crtc_commit structures tracking pending commits.
+         * Protected by @commit_lock. This list doesn't hold its own full
+         * reference, but burrows it from the ongoing commit. Commit entries
+         * must be removed from this list once the commit is fully completed,
+         * but before it's correspoding &drm_atomic_state gets destroyed.
+         */
+        struct list_head commit_list;
+
+        /**
+         * @commit_lock:
+         *
+         * Spinlock to protect @commit_list.
+         */
+        spinlock_t commit_lock;
+
+        /**
+         * @acquire_ctx:
+         *
+         * Per-CRTC implicit acquire context used by atomic drivers for legacy
+         * IOCTLs, so that atomic drivers can get at the locking acquire
+         * context.
          */
         struct drm_modeset_acquire_ctx *acquire_ctx;
 };
@@ -1078,7 +1109,7 @@ struct drm_encoder_funcs {
  * @dev: parent DRM device
  * @head: list management
  * @base: base KMS object
- * @name: encoder name
+ * @name: human readable name, can be overwritten by the driver
  * @encoder_type: one of the %DRM_MODE_ENCODER_<foo> types in drm_mode.h
  * @possible_crtcs: bitmask of potential CRTC bindings
  * @possible_clones: bitmask of potential sibling encoders for cloning
@@ -1097,6 +1128,10 @@ struct drm_encoder {
         struct drm_mode_object base;
         char *name;
         int encoder_type;
+
+        /* position inside the mode_config.list, can be used as a [] idx */
+        unsigned index;
+
         uint32_t possible_crtcs;
         uint32_t possible_clones;
 
@@ -1124,7 +1159,8 @@ struct drm_encoder {
  * @attr: sysfs attributes
  * @head: list management
  * @base: base KMS object
- * @name: connector name
+ * @name: human readable name, can be overwritten by the driver
+ * @connector_id: compacted connector id useful indexing arrays
  * @connector_type: one of the %DRM_MODE_CONNECTOR_<foo> types from drm_mode.h
  * @connector_type_id: index into connector type enum
  * @interlace_allowed: can this connector handle interlaced modes?
@@ -1137,7 +1173,6 @@ struct drm_encoder {
  * @funcs: connector control functions
  * @edid_blob_ptr: DRM property containing EDID if present
  * @properties: property tracking for this connector
- * @path_blob_ptr: DRM blob property data for the DP MST path property
  * @polled: a %DRM_CONNECTOR_POLL_<foo> value for core driven polling
  * @dpms: current dpms state
  * @helper_private: mid-layer private data
@@ -1200,8 +1235,23 @@ struct drm_connector {
         struct drm_property_blob *edid_blob_ptr;
         struct drm_object_properties properties;
 
+        /**
+         * @path_blob_ptr:
+         *
+         * DRM blob property data for the DP MST path property.
+         */
         struct drm_property_blob *path_blob_ptr;
 
+        /**
+         * @tile_blob_ptr:
+         *
+         * DRM blob property data for the tile property (used mostly by DP MST).
+         * This is meant for screens which are driven through separate display
+         * pipelines represented by &drm_crtc, which might not be running with
+         * genlocked clocks. For tiled panels which are genlocked, like
+         * dual-link LVDS or dual-link DSI, the driver should try to not expose
+         * the tiling and virtualize both &drm_crtc and &drm_plane if needed.
+         */
         struct drm_property_blob *tile_blob_ptr;
 
         uint8_t polled; /* DRM_CONNECTOR_POLL_* */
@@ -1263,6 +1313,7 @@ struct drm_connector {
  *      plane (in 16.16)
  * @src_w: width of visible portion of plane (in 16.16)
  * @src_h: height of visible portion of plane (in 16.16)
+ * @rotation: rotation of the plane
  * @state: backpointer to global drm_atomic_state
  */
 struct drm_plane_state {
@@ -1503,6 +1554,7 @@ enum drm_plane_type {
  * struct drm_plane - central DRM plane control structure
  * @dev: DRM device this plane belongs to
  * @head: for list management
+ * @name: human readable name, can be overwritten by the driver
  * @base: base mode object
  * @possible_crtcs: pipes this plane can be bound to
  * @format_types: array of formats supported by this plane
@@ -1516,6 +1568,7 @@ enum drm_plane_type {
  * @properties: property tracking for this plane
  * @type: type of plane (overlay, primary, cursor)
  * @state: current atomic state for this plane
+ * @helper_private: mid-layer private data
  */
 struct drm_plane {
         struct drm_device *dev;
@@ -1523,6 +1576,13 @@ struct drm_plane {
 
         char *name;
 
+        /**
+         * @mutex:
+         *
+         * Protects modeset plane state, together with the mutex of &drm_crtc
+         * this plane is linked to (when active, getting actived or getting
+         * disabled).
+         */
         struct drm_modeset_lock mutex;
 
         struct drm_mode_object base;
@@ -1543,6 +1603,9 @@ struct drm_plane {
 
         enum drm_plane_type type;
 
+        /* position inside the mode_config.list, can be used as a [] idx */
+        unsigned index;
+
         const struct drm_plane_helper_funcs *helper_private;
 
         struct drm_plane_state *state;
@@ -1694,18 +1757,136 @@ struct drm_bridge {
 };
 
 /**
+ * struct drm_crtc_commit - track modeset commits on a CRTC
+ *
+ * This structure is used to track pending modeset changes and atomic commit on
+ * a per-CRTC basis. Since updating the list should never block this structure
+ * is reference counted to allow waiters to safely wait on an event to complete,
+ * without holding any locks.
+ *
+ * It has 3 different events in total to allow a fine-grained synchronization
+ * between outstanding updates::
+ *
+ *      atomic commit thread                    hardware
+ *
+ *      write new state into hardware   ---->   ...
+ *      signal hw_done
+ *                                              switch to new state on next
+ *      ...                                     v/hblank
+ *
+ *      wait for buffers to show up             ...
+ *
+ *      ...                                     send completion irq
+ *                                              irq handler signals flip_done
+ *      cleanup old buffers
+ *
+ *      signal cleanup_done
+ *
+ *      wait for flip_done              <----
+ *      clean up atomic state
+ *
+ * The important bit to know is that cleanup_done is the terminal event, but the
+ * ordering between flip_done and hw_done is entirely up to the specific driver
+ * and modeset state change.
+ *
+ * For an implementation of how to use this look at
+ * drm_atomic_helper_setup_commit() from the atomic helper library.
+ */
+struct drm_crtc_commit {
+        /**
+         * @crtc:
+         *
+         * DRM CRTC for this commit.
+         */
+        struct drm_crtc *crtc;
+
+        /**
+         * @ref:
+         *
+         * Reference count for this structure. Needed to allow blocking on
+         * completions without the risk of the completion disappearing
+         * meanwhile.
+         */
+        struct kref ref;
+
+        /**
+         * @flip_done:
+         *
+         * Will be signaled when the hardware has flipped to the new set of
+         * buffers. Signals at the same time as when the drm event for this
+         * commit is sent to userspace, or when an out-fence is singalled. Note
+         * that for most hardware, in most cases this happens after @hw_done is
+         * signalled.
+         */
+        struct completion flip_done;
+
+        /**
+         * @hw_done:
+         *
+         * Will be signalled when all hw register changes for this commit have
+         * been written out. Especially when disabling a pipe this can be much
+         * later than than @flip_done, since that can signal already when the
+         * screen goes black, whereas to fully shut down a pipe more register
+         * I/O is required.
+         *
+         * Note that this does not need to include separately reference-counted
+         * resources like backing storage buffer pinning, or runtime pm
+         * management.
+         */
+        struct completion hw_done;
+
+        /**
+         * @cleanup_done:
+         *
+         * Will be signalled after old buffers have been cleaned up by calling
+         * drm_atomic_helper_cleanup_planes(). Since this can only happen after
+         * a vblank wait completed it might be a bit later. This completion is
+         * useful to throttle updates and avoid hardware updates getting ahead
+         * of the buffer cleanup too much.
+         */
+        struct completion cleanup_done;
+
+        /**
+         * @commit_entry:
+         *
+         * Entry on the per-CRTC commit_list. Protected by crtc->commit_lock.
+         */
+        struct list_head commit_entry;
+
+        /**
+         * @event:
+         *
+         * &drm_pending_vblank_event pointer to clean up private events.
+         */
+        struct drm_pending_vblank_event *event;
+};
+
+struct __drm_planes_state {
+        struct drm_plane *ptr;
+        struct drm_plane_state *state;
+};
+
+struct __drm_crtcs_state {
+        struct drm_crtc *ptr;
+        struct drm_crtc_state *state;
+        struct drm_crtc_commit *commit;
+};
+
+struct __drm_connnectors_state {
+        struct drm_connector *ptr;
+        struct drm_connector_state *state;
+};
+
+/**
  * struct drm_atomic_state - the global state object for atomic updates
  * @dev: parent DRM device
  * @allow_modeset: allow full modeset
  * @legacy_cursor_update: hint to enforce legacy cursor IOCTL semantics
  * @legacy_set_config: Disable conflicting encoders instead of failing with -EINVAL.
- * @planes: pointer to array of plane pointers
- * @plane_states: pointer to array of plane states pointers
+ * @planes: pointer to array of structures with per-plane data
  * @crtcs: pointer to array of CRTC pointers
- * @crtc_states: pointer to array of CRTC states pointers
  * @num_connector: size of the @connectors and @connector_states arrays
- * @connectors: pointer to array of connector pointers
- * @connector_states: pointer to array of connector states pointers
+ * @connectors: pointer to array of structures with per-connector data
  * @acquire_ctx: acquire context for this atomic modeset state update
  */
 struct drm_atomic_state {
@@ -1713,15 +1894,20 @@ struct drm_atomic_state {
         bool allow_modeset : 1;
         bool legacy_cursor_update : 1;
         bool legacy_set_config : 1;
-        struct drm_plane **planes;
-        struct drm_plane_state **plane_states;
-        struct drm_crtc **crtcs;
-        struct drm_crtc_state **crtc_states;
+        struct __drm_planes_state *planes;
+        struct __drm_crtcs_state *crtcs;
         int num_connector;
-        struct drm_connector **connectors;
-        struct drm_connector_state **connector_states;
+        struct __drm_connnectors_state *connectors;
 
         struct drm_modeset_acquire_ctx *acquire_ctx;
+
+        /**
+         * @commit_work:
+         *
+         * Work item which can be used by the driver or helpers to execute the
+         * commit without blocking.
+         */
+        struct work_struct commit_work;
 };
 
 
@@ -2022,8 +2208,6 @@ struct drm_mode_config_funcs {
  * @connection_mutex: ww mutex protecting connector state and routing
  * @acquire_ctx: global implicit acquire context used by atomic drivers for
  *      legacy IOCTLs
- * @idr_mutex: mutex for KMS ID allocation and management
- * @crtc_idr: main KMS ID tracking object
  * @fb_lock: mutex to protect fb state and lists
  * @num_fb: number of fbs available
  * @fb_list: list of framebuffers available
@@ -2045,6 +2229,7 @@ struct drm_mode_config_funcs {
  * @fb_base: base address of the framebuffer
  * @poll_enabled: track polling support for this device
  * @poll_running: track polling status for this device
+ * @delayed_event: track delayed poll uevent deliver for this device
  * @output_poll_work: delayed work for polling in process context
  * @property_blob_list: list of all the blob property objects
  * @blob_lock: mutex for blob property allocation and management
@@ -2063,6 +2248,7 @@ struct drm_mode_config_funcs {
  * @async_page_flip: does this device support async flips on the primary plane?
  * @cursor_width: hint to userspace for max cursor width
  * @cursor_height: hint to userspace for max cursor height
+ * @helper_private: mid-layer private data
  *
  * Core mode resource tracking structure.  All CRTC, encoders, and connectors
  * enumerated by the driver are added here, as are global properties.  Some
@@ -2072,10 +2258,30 @@ struct drm_mode_config {
         struct mutex mutex; /* protects configuration (mode lists etc.) */
         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 */
-        struct idr tile_idr; /* use this idr for all IDs, fb, crtc, connector, modes - just makes life easier */
-        /* this is limited to one for now */
+
+        /**
+         * @idr_mutex:
+         *
+         * Mutex for KMS ID allocation and management. Protects both @crtc_idr
+         * and @tile_idr.
+         */
+        struct mutex idr_mutex;
+
+        /**
+         * @crtc_idr:
+         *
+         * Main KMS ID tracking object. Use this idr for all IDs, fb, crtc,
+         * connector, modes - just makes life easier to have only one.
+         */
+        struct idr crtc_idr;
+
+        /**
+         * @tile_idr:
+         *
+         * Use this idr for allocating new IDs for tiled sinks like use in some
+         * high-res DP MST screens.
+         */
+        struct idr tile_idr;
 
         struct mutex fb_lock; /* proctects global and per-file fb lists */
         int num_fb;
@@ -2177,11 +2383,17 @@ struct drm_mode_config {
         /* whether async page flip is supported or not */
         bool async_page_flip;
 
-        /* whether the driver supports fb modifiers */
+        /**
+         * @allow_fb_modifiers:
+         *
+         * Whether the driver supports fb modifiers in the ADDFB2.1 ioctl call.
+         */
         bool allow_fb_modifiers;
 
         /* cursor size */
         uint32_t cursor_width, cursor_height;
+
+        struct drm_mode_config_helper_funcs *helper_private;
 };
 
 /**
@@ -2230,7 +2442,18 @@ int drm_crtc_init_with_planes(struct drm_device *dev,
                               const struct drm_crtc_funcs *funcs,
                               const char *name, ...);
 extern void drm_crtc_cleanup(struct drm_crtc *crtc);
-extern unsigned int drm_crtc_index(struct drm_crtc *crtc);
+
+/**
+ * drm_crtc_index - find the index of a registered CRTC
+ * @crtc: CRTC to find index for
+ *
+ * Given a registered CRTC, return the index of that CRTC within a DRM
+ * device's list of CRTCs.
+ */
+static inline unsigned int drm_crtc_index(struct drm_crtc *crtc)
+{
+        return crtc->index;
+}
 
 /**
  * drm_crtc_mask - find the mask of a registered CRTC
@@ -2284,7 +2507,18 @@ int drm_encoder_init(struct drm_device *dev,
                      struct drm_encoder *encoder,
                      const struct drm_encoder_funcs *funcs,
                      int encoder_type, const char *name, ...);
-extern unsigned int drm_encoder_index(struct drm_encoder *encoder);
+
+/**
+ * drm_encoder_index - find the index of a registered encoder
+ * @encoder: encoder to find index for
+ *
+ * Given a registered encoder, return the index of that encoder within a DRM
+ * device's list of encoders.
+ */
+static inline unsigned int drm_encoder_index(struct drm_encoder *encoder)
+{
+        return encoder->index;
+}
 
 /**
  * drm_encoder_crtc_ok - can a given crtc drive a given encoder?
@@ -2315,7 +2549,18 @@ extern int drm_plane_init(struct drm_device *dev,
                           const uint32_t *formats, unsigned int format_count,
                           bool is_primary);
 extern void drm_plane_cleanup(struct drm_plane *plane);
-extern unsigned int drm_plane_index(struct drm_plane *plane);
+
+/**
+ * drm_plane_index - find the index of a registered plane
+ * @plane: plane to find index for
+ *
+ * Given a registered plane, return the index of that plane within a DRM
+ * device's list of planes.
+ */
+static inline unsigned int drm_plane_index(struct drm_plane *plane)
+{
+        return plane->index;
+}
 extern struct drm_plane * drm_plane_from_index(struct drm_device *dev, int idx);
 extern void drm_plane_force_disable(struct drm_plane *plane);
 extern int drm_plane_check_pixel_format(const struct drm_plane *plane,
@@ -2540,20 +2785,14 @@ extern int drm_mode_plane_set_obj_prop(struct drm_plane *plane,
 extern int drm_mode_atomic_ioctl(struct drm_device *dev,
                                  void *data, struct drm_file *file_priv);
 
-extern void drm_fb_get_bpp_depth(uint32_t format, unsigned int *depth,
-                                 int *bpp);
-extern int drm_format_num_planes(uint32_t format);
-extern int drm_format_plane_cpp(uint32_t format, int plane);
-extern int drm_format_horz_chroma_subsampling(uint32_t format);
-extern int drm_format_vert_chroma_subsampling(uint32_t format);
-extern int drm_format_plane_width(int width, uint32_t format, int plane);
-extern int drm_format_plane_height(int height, uint32_t format, int plane);
-extern const char *drm_get_format_name(uint32_t format);
 extern struct drm_property *drm_mode_create_rotation_property(struct drm_device *dev,
                                                               unsigned int supported_rotations);
 extern unsigned int drm_rotation_simplify(unsigned int rotation,
                                           unsigned int supported_rotations);
-
+extern void drm_crtc_enable_color_mgmt(struct drm_crtc *crtc,
+                                       uint degamma_lut_size,
+                                       bool has_ctm,
+                                       uint gamma_lut_size);
 /* Helpers */
 
 static inline struct drm_plane *drm_plane_find(struct drm_device *dev,
diff --git a/include/drm/drm_crtc_helper.h b/include/drm/drm_crtc_helper.h
index 97fa894d4ee2..4b37afa2b73b 100644
--- a/include/drm/drm_crtc_helper.h
+++ b/include/drm/drm_crtc_helper.h
@@ -48,9 +48,6 @@ extern bool drm_crtc_helper_set_mode(struct drm_crtc *crtc,
                                      struct drm_display_mode *mode,
                                      int x, int y,
                                      struct drm_framebuffer *old_fb);
-extern void drm_helper_crtc_enable_color_mgmt(struct drm_crtc *crtc,
-                                              int degamma_lut_size,
-                                              int gamma_lut_size);
 extern bool drm_helper_crtc_in_use(struct drm_crtc *crtc);
 extern bool drm_helper_encoder_in_use(struct drm_encoder *encoder);
 
diff --git a/include/drm/drm_fb_helper.h b/include/drm/drm_fb_helper.h
index 5b4aa35026a3..db8d4780eaa2 100644
--- a/include/drm/drm_fb_helper.h
+++ b/include/drm/drm_fb_helper.h
@@ -212,17 +212,6 @@ struct drm_fb_helper {
          * needs to be reprobe when fbdev is in control again.
          */
         bool delayed_hotplug;
-
-        /**
-         * @atomic:
-         *
-         * Use atomic updates for restore_fbdev_mode(), etc.  This defaults to
-         * true if driver has DRIVER_ATOMIC feature flag, but drivers can
-         * override it to true after drm_fb_helper_init() if they support atomic
-         * modeset but do not yet advertise DRIVER_ATOMIC (note that fb-helper
-         * does not require ASYNC commits).
-         */
-        bool atomic;
 };
 
 #ifdef CONFIG_DRM_FBDEV_EMULATION
diff --git a/include/drm/drm_fourcc.h b/include/drm/drm_fourcc.h
new file mode 100644
index 000000000000..7f90a396cf2b
--- /dev/null
+++ b/include/drm/drm_fourcc.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2016 Laurent Pinchart <laurent.pinchart@ideasonboard.com>
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting documentation, and
+ * that the name of the copyright holders not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  The copyright holders make no representations
+ * about the suitability of this software for any purpose.  It is provided "as
+ * is" without express or implied warranty.
+ *
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+ * OF THIS SOFTWARE.
+ */
+#ifndef __DRM_FOURCC_H__
+#define __DRM_FOURCC_H__
+
+#include <linux/types.h>
+#include <uapi/drm/drm_fourcc.h>
+
+void drm_fb_get_bpp_depth(uint32_t format, unsigned int *depth, int *bpp);
+int drm_format_num_planes(uint32_t format);
+int drm_format_plane_cpp(uint32_t format, int plane);
+int drm_format_horz_chroma_subsampling(uint32_t format);
+int drm_format_vert_chroma_subsampling(uint32_t format);
+int drm_format_plane_width(int width, uint32_t format, int plane);
+int drm_format_plane_height(int height, uint32_t format, int plane);
+const char *drm_get_format_name(uint32_t format);
+
+#endif /* __DRM_FOURCC_H__ */
diff --git a/include/drm/drm_mipi_dsi.h b/include/drm/drm_mipi_dsi.h
index 7a9840f8b38e..72f5b15e0738 100644
--- a/include/drm/drm_mipi_dsi.h
+++ b/include/drm/drm_mipi_dsi.h
@@ -180,6 +180,8 @@ struct mipi_dsi_device {
         unsigned long mode_flags;
 };
 
+#define MIPI_DSI_MODULE_PREFIX "mipi-dsi:"
+
 static inline struct mipi_dsi_device *to_mipi_dsi_device(struct device *dev)
 {
         return container_of(dev, struct mipi_dsi_device, dev);
@@ -263,6 +265,7 @@ int mipi_dsi_dcs_set_column_address(struct mipi_dsi_device *dsi, u16 start,
                                     u16 end);
 int mipi_dsi_dcs_set_page_address(struct mipi_dsi_device *dsi, u16 start,
                                   u16 end);
+int mipi_dsi_set_tear_scanline(struct mipi_dsi_device *dsi, u16 param);
 int mipi_dsi_dcs_set_tear_off(struct mipi_dsi_device *dsi);
 int mipi_dsi_dcs_set_tear_on(struct mipi_dsi_device *dsi,
                              enum mipi_dsi_dcs_tear_mode mode);
diff --git a/include/drm/drm_modes.h b/include/drm/drm_modes.h
index 625966a906f2..ff481770d76b 100644
--- a/include/drm/drm_modes.h
+++ b/include/drm/drm_modes.h
@@ -169,6 +169,8 @@ enum drm_mode_status {
  *
  * The horizontal and vertical timings are defined per the following diagram.
  *
+ * ::
+ *
  *
  *               Active                 Front           Sync           Back
  *              Region                 Porch                          Porch
diff --git a/include/drm/drm_modeset_helper_vtables.h b/include/drm/drm_modeset_helper_vtables.h
index d4619dc2eecb..b55f21857a98 100644
--- a/include/drm/drm_modeset_helper_vtables.h
+++ b/include/drm/drm_modeset_helper_vtables.h
@@ -736,6 +736,11 @@ struct drm_connector_helper_funcs {
          * inspect dynamic configuration state should instead use
          * @atomic_best_encoder.
          *
+         * You can leave this function to NULL if the connector is only
+         * attached to a single encoder and you are using the atomic helpers.
+         * In this case, the core will call drm_atomic_helper_best_encoder()
+         * for you.
+         *
          * RETURNS:
          *
          * Encoder that should be used for the given connector and connector
@@ -752,8 +757,9 @@ struct drm_connector_helper_funcs {
          * need to select the best encoder depending upon the desired
          * configuration and can't select it statically.
          *
-         * This function is used by drm_atomic_helper_check_modeset() and either
-         * this or @best_encoder is required.
+         * This function is used by drm_atomic_helper_check_modeset().
+         * If it is not implemented, the core will fallback to @best_encoder
+         * (or drm_atomic_helper_best_encoder() if @best_encoder is NULL).
          *
          * NOTE:
          *
@@ -925,4 +931,43 @@ static inline void drm_plane_helper_add(struct drm_plane *plane,
         plane->helper_private = funcs;
 }
 
+/**
+ * struct drm_mode_config_helper_funcs - global modeset helper operations
+ *
+ * These helper functions are used by the atomic helpers.
+ */
+struct drm_mode_config_helper_funcs {
+        /**
+         * @atomic_commit_tail:
+         *
+         * This hook is used by the default atomic_commit() hook implemented in
+         * drm_atomic_helper_commit() together with the nonblocking commit
+         * helpers (see drm_atomic_helper_setup_commit() for a starting point)
+         * to implement blocking and nonblocking commits easily. It is not used
+         * by the atomic helpers
+         *
+         * This hook should first commit the given atomic state to the hardware.
+         * But drivers can add more waiting calls at the start of their
+         * implementation, e.g. to wait for driver-internal request for implicit
+         * syncing, before starting to commit the update to the hardware.
+         *
+         * After the atomic update is committed to the hardware this hook needs
+         * to call drm_atomic_helper_commit_hw_done(). Then wait for the upate
+         * to be executed by the hardware, for example using
+         * drm_atomic_helper_wait_for_vblanks(), and then clean up the old
+         * framebuffers using drm_atomic_helper_cleanup_planes().
+         *
+         * When disabling a CRTC this hook _must_ stall for the commit to
+         * complete. Vblank waits don't work on disabled CRTC, hence the core
+         * can't take care of this. And it also can't rely on the vblank event,
+         * since that can be signalled already when the screen shows black,
+         * which can happen much earlier than the last hardware access needed to
+         * shut off the display pipeline completely.
+         *
+         * This hook is optional, the default implementation is
+         * drm_atomic_helper_commit_tail().
+         */
+        void (*atomic_commit_tail)(struct drm_atomic_state *state);
+};
+
 #endif
diff --git a/include/drm/drm_simple_kms_helper.h b/include/drm/drm_simple_kms_helper.h
new file mode 100644
index 000000000000..269039722f91
--- /dev/null
+++ b/include/drm/drm_simple_kms_helper.h
@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2016 Noralf Trønnes
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#ifndef __LINUX_DRM_SIMPLE_KMS_HELPER_H
+#define __LINUX_DRM_SIMPLE_KMS_HELPER_H
+
+struct drm_simple_display_pipe;
+
+/**
+ * struct drm_simple_display_pipe_funcs - helper operations for a simple
+ *                                        display pipeline
+ */
+struct drm_simple_display_pipe_funcs {
+        /**
+         * @enable:
+         *
+         * This function should be used to enable the pipeline.
+         * It is called when the underlying crtc is enabled.
+         * This hook is optional.
+         */
+        void (*enable)(struct drm_simple_display_pipe *pipe,
+                       struct drm_crtc_state *crtc_state);
+        /**
+         * @disable:
+         *
+         * This function should be used to disable the pipeline.
+         * It is called when the underlying crtc is disabled.
+         * This hook is optional.
+         */
+        void (*disable)(struct drm_simple_display_pipe *pipe);
+
+        /**
+         * @check:
+         *
+         * This function is called in the check phase of an atomic update,
+         * specifically when the underlying plane is checked.
+         * The simple display pipeline helpers already check that the plane is
+         * not scaled, fills the entire visible area and is always enabled
+         * when the crtc is also enabled.
+         * This hook is optional.
+         *
+         * RETURNS:
+         *
+         * 0 on success, -EINVAL if the state or the transition can't be
+         * supported, -ENOMEM on memory allocation failure and -EDEADLK if an
+         * attempt to obtain another state object ran into a &drm_modeset_lock
+         * deadlock.
+         */
+        int (*check)(struct drm_simple_display_pipe *pipe,
+                     struct drm_plane_state *plane_state,
+                     struct drm_crtc_state *crtc_state);
+        /**
+         * @update:
+         *
+         * This function is called when the underlying plane state is updated.
+         * This hook is optional.
+         */
+        void (*update)(struct drm_simple_display_pipe *pipe,
+                       struct drm_plane_state *plane_state);
+};
+
+/**
+ * struct drm_simple_display_pipe - simple display pipeline
+ * @crtc: CRTC control structure
+ * @plane: Plane control structure
+ * @encoder: Encoder control structure
+ * @connector: Connector control structure
+ * @funcs: Pipeline control functions (optional)
+ *
+ * Simple display pipeline with plane, crtc and encoder collapsed into one
+ * entity. It should be initialized by calling drm_simple_display_pipe_init().
+ */
+struct drm_simple_display_pipe {
+        struct drm_crtc crtc;
+        struct drm_plane plane;
+        struct drm_encoder encoder;
+        struct drm_connector *connector;
+
+        const struct drm_simple_display_pipe_funcs *funcs;
+};
+
+int drm_simple_display_pipe_init(struct drm_device *dev,
+                        struct drm_simple_display_pipe *pipe,
+                        const struct drm_simple_display_pipe_funcs *funcs,
+                        const uint32_t *formats, unsigned int format_count,
+                        struct drm_connector *connector);
+
+#endif /* __LINUX_DRM_SIMPLE_KMS_HELPER_H */