Merge tag 'topic/atomic-core-2015-01-05' of git://anongit.freedesktop.org/drm-intel into drm-next

Next batch of atomic work. Most important is the propertification from Rob
and the nth iteration of the actual atomic ioctl originally from Ville.
Big differences compared to earlier revisions:
- Core properties are now fully handled by the core, drivers can only
  handle driver-specific properties.
- Atomic props&ioctl are opt-in per file_priv, userspace needs to
  explicitly ask for it (like universal plane support).
- For now all hidden behind the atomic module option until this has
  settled a bit.
- Atomic modesets are currently not possible since the exact abi for how
  to handle the mode property is still under discussion.

Besides this some cleanup patches from me and the addition of per-object
state to global state backpointers to simplify drivers.

* tag 'topic/atomic-core-2015-01-05' of git://anongit.freedesktop.org/drm-intel:
  drm: Ensure universal_planes is set for atomic
  drm/atomic: Hide drm.ko internal interfaces
  drm: Atomic modeset ioctl
  drm/atomic: atomic connector properties
  drm/atomic: atomic plane properties
  drm: small property creation cleanup
  drm/atomic: atomic_check functions
  drm: add atomic properties
  drm: refactor getproperties/getconnector
  drm: tweak getconnector locking
  drm: add atomic_get_property
  drm: add atomic_set_property wrappers
  drm: get rid of direct property value access
  drm: store property instead of id in obj attachment
  drm: allow property validation for refcnted props
  drm/atomic: Introduce state->obj backpointers
  drm/atomic-helper: Again check modeset *before* plane states
  drm/atomic-helper: Export both plane and modeset check helpers

19 files changed, 1294 insertions, 159 deletions

diff --git a/Documentation/DocBook/drm.tmpl b/Documentation/DocBook/drm.tmpl
index 8a0b2a84f4bf..640c2a30563f 100644
--- a/Documentation/DocBook/drm.tmpl
+++ b/Documentation/DocBook/drm.tmpl
@@ -239,6 +239,14 @@
               Driver supports dedicated render nodes.
             </para></listitem>
           </varlistentry>
+          <varlistentry>
+            <term>DRIVER_ATOMIC</term>
+            <listitem><para>
+              Driver supports atomic properties.  In this case the driver
+              must implement appropriate obj->atomic_get_property() vfuncs
+              for any modeset objects with driver specific properties.
+            </para></listitem>
+          </varlistentry>
         </variablelist>
       </sect3>
       <sect3>
@@ -2565,8 +2573,8 @@ void intel_crt_init(struct drm_device *dev)
         <td valign="top" >Description/Restrictions</td>
         </tr>
         <tr>
-        <td rowspan="25" valign="top" >DRM</td>
-        <td rowspan="4" valign="top" >Generic</td>
+        <td rowspan="36" valign="top" >DRM</td>
+        <td rowspan="5" valign="top" >Connector</td>
         <td valign="top" >“EDID”</td>
         <td valign="top" >BLOB | IMMUTABLE</td>
         <td valign="top" >0</td>
@@ -2595,7 +2603,14 @@ void intel_crt_init(struct drm_device *dev)
         <td valign="top" >Contains tiling information for a connector.</td>
         </tr>
         <tr>
-        <td rowspan="1" valign="top" >Plane</td>
+        <td valign="top" >“CRTC_ID”</td>
+        <td valign="top" >OBJECT</td>
+        <td valign="top" >DRM_MODE_OBJECT_CRTC</td>
+        <td valign="top" >Connector</td>
+        <td valign="top" >CRTC that connector is attached to (atomic)</td>
+        </tr>
+        <tr>
+        <td rowspan="11" valign="top" >Plane</td>
         <td valign="top" >“type”</td>
         <td valign="top" >ENUM | IMMUTABLE</td>
         <td valign="top" >{ "Overlay", "Primary", "Cursor" }</td>
@@ -2603,6 +2618,76 @@ void intel_crt_init(struct drm_device *dev)
         <td valign="top" >Plane type</td>
         </tr>
         <tr>
+        <td valign="top" >“SRC_X”</td>
+        <td valign="top" >RANGE</td>
+        <td valign="top" >Min=0, Max=UINT_MAX</td>
+        <td valign="top" >Plane</td>
+        <td valign="top" >Scanout source x coordinate in 16.16 fixed point (atomic)</td>
+        </tr>
+        <tr>
+        <td valign="top" >“SRC_Y”</td>
+        <td valign="top" >RANGE</td>
+        <td valign="top" >Min=0, Max=UINT_MAX</td>
+        <td valign="top" >Plane</td>
+        <td valign="top" >Scanout source y coordinate in 16.16 fixed point (atomic)</td>
+        </tr>
+        <tr>
+        <td valign="top" >“SRC_W”</td>
+        <td valign="top" >RANGE</td>
+        <td valign="top" >Min=0, Max=UINT_MAX</td>
+        <td valign="top" >Plane</td>
+        <td valign="top" >Scanout source width in 16.16 fixed point (atomic)</td>
+        </tr>
+        <tr>
+        <td valign="top" >“SRC_H”</td>
+        <td valign="top" >RANGE</td>
+        <td valign="top" >Min=0, Max=UINT_MAX</td>
+        <td valign="top" >Plane</td>
+        <td valign="top" >Scanout source height in 16.16 fixed point (atomic)</td>
+        </tr>
+        <tr>
+        <td valign="top" >“CRTC_X”</td>
+        <td valign="top" >SIGNED_RANGE</td>
+        <td valign="top" >Min=INT_MIN, Max=INT_MAX</td>
+        <td valign="top" >Plane</td>
+        <td valign="top" >Scanout CRTC (destination) x coordinate (atomic)</td>
+        </tr>
+        <tr>
+        <td valign="top" >“CRTC_Y”</td>
+        <td valign="top" >SIGNED_RANGE</td>
+        <td valign="top" >Min=INT_MIN, Max=INT_MAX</td>
+        <td valign="top" >Plane</td>
+        <td valign="top" >Scanout CRTC (destination) y coordinate (atomic)</td>
+        </tr>
+        <tr>
+        <td valign="top" >“CRTC_W”</td>
+        <td valign="top" >RANGE</td>
+        <td valign="top" >Min=0, Max=UINT_MAX</td>
+        <td valign="top" >Plane</td>
+        <td valign="top" >Scanout CRTC (destination) width (atomic)</td>
+        </tr>
+        <tr>
+        <td valign="top" >“CRTC_H”</td>
+        <td valign="top" >RANGE</td>
+        <td valign="top" >Min=0, Max=UINT_MAX</td>
+        <td valign="top" >Plane</td>
+        <td valign="top" >Scanout CRTC (destination) height (atomic)</td>
+        </tr>
+        <tr>
+        <td valign="top" >“FB_ID”</td>
+        <td valign="top" >OBJECT</td>
+        <td valign="top" >DRM_MODE_OBJECT_FB</td>
+        <td valign="top" >Plane</td>
+        <td valign="top" >Scanout framebuffer (atomic)</td>
+        </tr>
+        <tr>
+        <td valign="top" >“CRTC_ID”</td>
+        <td valign="top" >OBJECT</td>
+        <td valign="top" >DRM_MODE_OBJECT_CRTC</td>
+        <td valign="top" >Plane</td>
+        <td valign="top" >CRTC that plane is attached to (atomic)</td>
+        </tr>
+        <tr>
         <td rowspan="2" valign="top" >DVI-I</td>
         <td valign="top" >“subconnector”</td>
         <td valign="top" >ENUM</td>
diff --git a/drivers/gpu/drm/drm_atomic.c b/drivers/gpu/drm/drm_atomic.c
index ff5f034cc405..1e38dfc8e462 100644
--- a/drivers/gpu/drm/drm_atomic.c
+++ b/drivers/gpu/drm/drm_atomic.c
@@ -56,6 +56,11 @@ drm_atomic_state_alloc(struct drm_device *dev)
         if (!state)
                 return NULL;
 
+        /* TODO legacy paths should maybe do a better job about
+         * setting this appropriately?
+         */
+        state->allow_modeset = true;
+
         state->num_connector = ACCESS_ONCE(dev->mode_config.num_connector);
 
         state->crtcs = kcalloc(dev->mode_config.num_crtc,
@@ -217,6 +222,70 @@ drm_atomic_get_crtc_state(struct drm_atomic_state *state,
 EXPORT_SYMBOL(drm_atomic_get_crtc_state);
 
 /**
+ * drm_atomic_crtc_set_property - set property on CRTC
+ * @crtc: the drm CRTC to set a property on
+ * @state: the state object to update with the new property value
+ * @property: the property to set
+ * @val: the new property value
+ *
+ * Use this instead of calling crtc->atomic_set_property directly.
+ * This function handles generic/core properties and calls out to
+ * driver's ->atomic_set_property() for driver properties.  To ensure
+ * consistent behavior you must call this function rather than the
+ * driver hook directly.
+ *
+ * RETURNS:
+ * Zero on success, error code on failure
+ */
+int drm_atomic_crtc_set_property(struct drm_crtc *crtc,
+                struct drm_crtc_state *state, struct drm_property *property,
+                uint64_t val)
+{
+        if (crtc->funcs->atomic_set_property)
+                return crtc->funcs->atomic_set_property(crtc, state, property, val);
+        return -EINVAL;
+}
+EXPORT_SYMBOL(drm_atomic_crtc_set_property);
+
+/*
+ * This function handles generic/core properties and calls out to
+ * driver's ->atomic_get_property() for driver properties.  To ensure
+ * consistent behavior you must call this function rather than the
+ * driver hook directly.
+ */
+int drm_atomic_crtc_get_property(struct drm_crtc *crtc,
+                const struct drm_crtc_state *state,
+                struct drm_property *property, uint64_t *val)
+{
+        if (crtc->funcs->atomic_get_property)
+                return crtc->funcs->atomic_get_property(crtc, state, property, val);
+        return -EINVAL;
+}
+
+/**
+ * drm_atomic_crtc_check - check crtc state
+ * @crtc: crtc to check
+ * @state: crtc state to check
+ *
+ * Provides core sanity checks for crtc state.
+ *
+ * RETURNS:
+ * Zero on success, error code on failure
+ */
+static int drm_atomic_crtc_check(struct drm_crtc *crtc,
+                struct drm_crtc_state *state)
+{
+        /* NOTE: we explicitly don't enforce constraints such as primary
+         * layer covering entire screen, since that is something we want
+         * to allow (on hw that supports it).  For hw that does not, it
+         * should be checked in driver's crtc->atomic_check() vfunc.
+         *
+         * TODO: Add generic modeset state checks once we support those.
+         */
+        return 0;
+}
+
+/**
  * drm_atomic_get_plane_state - get plane state
  * @state: global atomic state object
  * @plane: plane to get state object for
@@ -272,6 +341,183 @@ drm_atomic_get_plane_state(struct drm_atomic_state *state,
 EXPORT_SYMBOL(drm_atomic_get_plane_state);
 
 /**
+ * drm_atomic_plane_set_property - set property on plane
+ * @plane: the drm plane to set a property on
+ * @state: the state object to update with the new property value
+ * @property: the property to set
+ * @val: the new property value
+ *
+ * Use this instead of calling plane->atomic_set_property directly.
+ * This function handles generic/core properties and calls out to
+ * driver's ->atomic_set_property() for driver properties.  To ensure
+ * consistent behavior you must call this function rather than the
+ * driver hook directly.
+ *
+ * RETURNS:
+ * Zero on success, error code on failure
+ */
+int drm_atomic_plane_set_property(struct drm_plane *plane,
+                struct drm_plane_state *state, struct drm_property *property,
+                uint64_t val)
+{
+        struct drm_device *dev = plane->dev;
+        struct drm_mode_config *config = &dev->mode_config;
+
+        if (property == config->prop_fb_id) {
+                struct drm_framebuffer *fb = drm_framebuffer_lookup(dev, val);
+                drm_atomic_set_fb_for_plane(state, fb);
+                if (fb)
+                        drm_framebuffer_unreference(fb);
+        } else if (property == config->prop_crtc_id) {
+                struct drm_crtc *crtc = drm_crtc_find(dev, val);
+                return drm_atomic_set_crtc_for_plane(state, crtc);
+        } else if (property == config->prop_crtc_x) {
+                state->crtc_x = U642I64(val);
+        } else if (property == config->prop_crtc_y) {
+                state->crtc_y = U642I64(val);
+        } else if (property == config->prop_crtc_w) {
+                state->crtc_w = val;
+        } else if (property == config->prop_crtc_h) {
+                state->crtc_h = val;
+        } else if (property == config->prop_src_x) {
+                state->src_x = val;
+        } else if (property == config->prop_src_y) {
+                state->src_y = val;
+        } else if (property == config->prop_src_w) {
+                state->src_w = val;
+        } else if (property == config->prop_src_h) {
+                state->src_h = val;
+        } else if (plane->funcs->atomic_set_property) {
+                return plane->funcs->atomic_set_property(plane, state,
+                                property, val);
+        } else {
+                return -EINVAL;
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL(drm_atomic_plane_set_property);
+
+/*
+ * This function handles generic/core properties and calls out to
+ * driver's ->atomic_get_property() for driver properties.  To ensure
+ * consistent behavior you must call this function rather than the
+ * driver hook directly.
+ */
+static int
+drm_atomic_plane_get_property(struct drm_plane *plane,
+                const struct drm_plane_state *state,
+                struct drm_property *property, uint64_t *val)
+{
+        struct drm_device *dev = plane->dev;
+        struct drm_mode_config *config = &dev->mode_config;
+
+        if (property == config->prop_fb_id) {
+                *val = (state->fb) ? state->fb->base.id : 0;
+        } else if (property == config->prop_crtc_id) {
+                *val = (state->crtc) ? state->crtc->base.id : 0;
+        } else if (property == config->prop_crtc_x) {
+                *val = I642U64(state->crtc_x);
+        } else if (property == config->prop_crtc_y) {
+                *val = I642U64(state->crtc_y);
+        } else if (property == config->prop_crtc_w) {
+                *val = state->crtc_w;
+        } else if (property == config->prop_crtc_h) {
+                *val = state->crtc_h;
+        } else if (property == config->prop_src_x) {
+                *val = state->src_x;
+        } else if (property == config->prop_src_y) {
+                *val = state->src_y;
+        } else if (property == config->prop_src_w) {
+                *val = state->src_w;
+        } else if (property == config->prop_src_h) {
+                *val = state->src_h;
+        } else if (plane->funcs->atomic_get_property) {
+                return plane->funcs->atomic_get_property(plane, state, property, val);
+        } else {
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+/**
+ * drm_atomic_plane_check - check plane state
+ * @plane: plane to check
+ * @state: plane state to check
+ *
+ * Provides core sanity checks for plane state.
+ *
+ * RETURNS:
+ * Zero on success, error code on failure
+ */
+static int drm_atomic_plane_check(struct drm_plane *plane,
+                struct drm_plane_state *state)
+{
+        unsigned int fb_width, fb_height;
+        unsigned int i;
+
+        /* either *both* CRTC and FB must be set, or neither */
+        if (WARN_ON(state->crtc && !state->fb)) {
+                DRM_DEBUG_KMS("CRTC set but no FB\n");
+                return -EINVAL;
+        } else if (WARN_ON(state->fb && !state->crtc)) {
+                DRM_DEBUG_KMS("FB set but no CRTC\n");
+                return -EINVAL;
+        }
+
+        /* if disabled, we don't care about the rest of the state: */
+        if (!state->crtc)
+                return 0;
+
+        /* Check whether this plane is usable on this CRTC */
+        if (!(plane->possible_crtcs & drm_crtc_mask(state->crtc))) {
+                DRM_DEBUG_KMS("Invalid crtc for plane\n");
+                return -EINVAL;
+        }
+
+        /* Check whether this plane supports the fb pixel format. */
+        for (i = 0; i < plane->format_count; i++)
+                if (state->fb->pixel_format == plane->format_types[i])
+                        break;
+        if (i == plane->format_count) {
+                DRM_DEBUG_KMS("Invalid pixel format %s\n",
+                              drm_get_format_name(state->fb->pixel_format));
+                return -EINVAL;
+        }
+
+        /* Give drivers some help against integer overflows */
+        if (state->crtc_w > INT_MAX ||
+            state->crtc_x > INT_MAX - (int32_t) state->crtc_w ||
+            state->crtc_h > INT_MAX ||
+            state->crtc_y > INT_MAX - (int32_t) state->crtc_h) {
+                DRM_DEBUG_KMS("Invalid CRTC coordinates %ux%u+%d+%d\n",
+                              state->crtc_w, state->crtc_h,
+                              state->crtc_x, state->crtc_y);
+                return -ERANGE;
+        }
+
+        fb_width = state->fb->width << 16;
+        fb_height = state->fb->height << 16;
+
+        /* Make sure source coordinates are inside the fb. */
+        if (state->src_w > fb_width ||
+            state->src_x > fb_width - state->src_w ||
+            state->src_h > fb_height ||
+            state->src_y > fb_height - state->src_h) {
+                DRM_DEBUG_KMS("Invalid source coordinates "
+                              "%u.%06ux%u.%06u+%u.%06u+%u.%06u\n",
+                              state->src_w >> 16, ((state->src_w & 0xffff) * 15625) >> 10,
+                              state->src_h >> 16, ((state->src_h & 0xffff) * 15625) >> 10,
+                              state->src_x >> 16, ((state->src_x & 0xffff) * 15625) >> 10,
+                              state->src_y >> 16, ((state->src_y & 0xffff) * 15625) >> 10);
+                return -ENOSPC;
+        }
+
+        return 0;
+}
+
+/**
  * drm_atomic_get_connector_state - get connector state
  * @state: global atomic state object
  * @connector: connector to get state object for
@@ -343,9 +589,113 @@ drm_atomic_get_connector_state(struct drm_atomic_state *state,
 EXPORT_SYMBOL(drm_atomic_get_connector_state);
 
 /**
+ * drm_atomic_connector_set_property - set property on connector.
+ * @connector: the drm connector to set a property on
+ * @state: the state object to update with the new property value
+ * @property: the property to set
+ * @val: the new property value
+ *
+ * Use this instead of calling connector->atomic_set_property directly.
+ * This function handles generic/core properties and calls out to
+ * driver's ->atomic_set_property() for driver properties.  To ensure
+ * consistent behavior you must call this function rather than the
+ * driver hook directly.
+ *
+ * RETURNS:
+ * Zero on success, error code on failure
+ */
+int drm_atomic_connector_set_property(struct drm_connector *connector,
+                struct drm_connector_state *state, struct drm_property *property,
+                uint64_t val)
+{
+        struct drm_device *dev = connector->dev;
+        struct drm_mode_config *config = &dev->mode_config;
+
+        if (property == config->prop_crtc_id) {
+                struct drm_crtc *crtc = drm_crtc_find(dev, val);
+                return drm_atomic_set_crtc_for_connector(state, crtc);
+        } else if (property == config->dpms_property) {
+                /* setting DPMS property requires special handling, which
+                 * is done in legacy setprop path for us.  Disallow (for
+                 * now?) atomic writes to DPMS property:
+                 */
+                return -EINVAL;
+        } else if (connector->funcs->atomic_set_property) {
+                return connector->funcs->atomic_set_property(connector,
+                                state, property, val);
+        } else {
+                return -EINVAL;
+        }
+}
+EXPORT_SYMBOL(drm_atomic_connector_set_property);
+
+/*
+ * This function handles generic/core properties and calls out to
+ * driver's ->atomic_get_property() for driver properties.  To ensure
+ * consistent behavior you must call this function rather than the
+ * driver hook directly.
+ */
+static int
+drm_atomic_connector_get_property(struct drm_connector *connector,
+                const struct drm_connector_state *state,
+                struct drm_property *property, uint64_t *val)
+{
+        struct drm_device *dev = connector->dev;
+        struct drm_mode_config *config = &dev->mode_config;
+
+        if (property == config->prop_crtc_id) {
+                *val = (state->crtc) ? state->crtc->base.id : 0;
+        } else if (property == config->dpms_property) {
+                *val = connector->dpms;
+        } else if (connector->funcs->atomic_get_property) {
+                return connector->funcs->atomic_get_property(connector,
+                                state, property, val);
+        } else {
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+int drm_atomic_get_property(struct drm_mode_object *obj,
+                struct drm_property *property, uint64_t *val)
+{
+        struct drm_device *dev = property->dev;
+        int ret;
+
+        switch (obj->type) {
+        case DRM_MODE_OBJECT_CONNECTOR: {
+                struct drm_connector *connector = obj_to_connector(obj);
+                WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
+                ret = drm_atomic_connector_get_property(connector,
+                                connector->state, property, val);
+                break;
+        }
+        case DRM_MODE_OBJECT_CRTC: {
+                struct drm_crtc *crtc = obj_to_crtc(obj);
+                WARN_ON(!drm_modeset_is_locked(&crtc->mutex));
+                ret = drm_atomic_crtc_get_property(crtc,
+                                crtc->state, property, val);
+                break;
+        }
+        case DRM_MODE_OBJECT_PLANE: {
+                struct drm_plane *plane = obj_to_plane(obj);
+                WARN_ON(!drm_modeset_is_locked(&plane->mutex));
+                ret = drm_atomic_plane_get_property(plane,
+                                plane->state, property, val);
+                break;
+        }
+        default:
+                ret = -EINVAL;
+                break;
+        }
+
+        return ret;
+}
+
+/**
  * drm_atomic_set_crtc_for_plane - set crtc for plane
- * @state: the incoming atomic state
- * @plane: the plane whose incoming state to update
+ * @plane_state: the plane whose incoming state to update
  * @crtc: crtc to use for the plane
  *
  * Changing the assigned crtc for a plane requires us to grab the lock and state
@@ -358,16 +708,12 @@ EXPORT_SYMBOL(drm_atomic_get_connector_state);
  * sequence must be restarted. All other errors are fatal.
  */
 int
-drm_atomic_set_crtc_for_plane(struct drm_atomic_state *state,
-                              struct drm_plane *plane, struct drm_crtc *crtc)
+drm_atomic_set_crtc_for_plane(struct drm_plane_state *plane_state,
+                              struct drm_crtc *crtc)
 {
-        struct drm_plane_state *plane_state =
-                        drm_atomic_get_plane_state(state, plane);
+        struct drm_plane *plane = plane_state->plane;
         struct drm_crtc_state *crtc_state;
 
-        if (WARN_ON(IS_ERR(plane_state)))
-                return PTR_ERR(plane_state);
-
         if (plane_state->crtc) {
                 crtc_state = drm_atomic_get_crtc_state(plane_state->state,
                                                        plane_state->crtc);
@@ -583,14 +929,62 @@ EXPORT_SYMBOL(drm_atomic_legacy_backoff);
  */
 int drm_atomic_check_only(struct drm_atomic_state *state)
 {
-        struct drm_mode_config *config = &state->dev->mode_config;
+        struct drm_device *dev = state->dev;
+        struct drm_mode_config *config = &dev->mode_config;
+        int nplanes = config->num_total_plane;
+        int ncrtcs = config->num_crtc;
+        int i, ret = 0;
 
         DRM_DEBUG_KMS("checking %p\n", state);
 
+        for (i = 0; i < nplanes; i++) {
+                struct drm_plane *plane = state->planes[i];
+
+                if (!plane)
+                        continue;
+
+                ret = drm_atomic_plane_check(plane, state->plane_states[i]);
+                if (ret) {
+                        DRM_DEBUG_KMS("[PLANE:%d] atomic core check failed\n",
+                                      plane->base.id);
+                        return ret;
+                }
+        }
+
+        for (i = 0; i < ncrtcs; i++) {
+                struct drm_crtc *crtc = state->crtcs[i];
+
+                if (!crtc)
+                        continue;
+
+                ret = drm_atomic_crtc_check(crtc, state->crtc_states[i]);
+                if (ret) {
+                        DRM_DEBUG_KMS("[CRTC:%d] atomic core check failed\n",
+                                      crtc->base.id);
+                        return ret;
+                }
+        }
+
         if (config->funcs->atomic_check)
-                return config->funcs->atomic_check(state->dev, state);
-        else
-                return 0;
+                ret = config->funcs->atomic_check(state->dev, state);
+
+        if (!state->allow_modeset) {
+                for (i = 0; i < ncrtcs; i++) {
+                        struct drm_crtc *crtc = state->crtcs[i];
+                        struct drm_crtc_state *crtc_state = state->crtc_states[i];
+
+                        if (!crtc)
+                                continue;
+
+                        if (crtc_state->mode_changed) {
+                                DRM_DEBUG_KMS("[CRTC:%d] requires full modeset\n",
+                                              crtc->base.id);
+                                return -EINVAL;
+                        }
+                }
+        }
+
+        return ret;
 }
 EXPORT_SYMBOL(drm_atomic_check_only);
 
@@ -655,3 +1049,313 @@ int drm_atomic_async_commit(struct drm_atomic_state *state)
         return config->funcs->atomic_commit(state->dev, state, true);
 }
 EXPORT_SYMBOL(drm_atomic_async_commit);
+
+/*
+ * The big monstor ioctl
+ */
+
+static struct drm_pending_vblank_event *create_vblank_event(
+                struct drm_device *dev, struct drm_file *file_priv, uint64_t user_data)
+{
+        struct drm_pending_vblank_event *e = NULL;
+        unsigned long flags;
+
+        spin_lock_irqsave(&dev->event_lock, flags);
+        if (file_priv->event_space < sizeof e->event) {
+                spin_unlock_irqrestore(&dev->event_lock, flags);
+                goto out;
+        }
+        file_priv->event_space -= sizeof e->event;
+        spin_unlock_irqrestore(&dev->event_lock, flags);
+
+        e = kzalloc(sizeof *e, GFP_KERNEL);
+        if (e == NULL) {
+                spin_lock_irqsave(&dev->event_lock, flags);
+                file_priv->event_space += sizeof e->event;
+                spin_unlock_irqrestore(&dev->event_lock, flags);
+                goto out;
+        }
+
+        e->event.base.type = DRM_EVENT_FLIP_COMPLETE;
+        e->event.base.length = sizeof e->event;
+        e->event.user_data = user_data;
+        e->base.event = &e->event.base;
+        e->base.file_priv = file_priv;
+        e->base.destroy = (void (*) (struct drm_pending_event *)) kfree;
+
+out:
+        return e;
+}
+
+static void destroy_vblank_event(struct drm_device *dev,
+                struct drm_file *file_priv, struct drm_pending_vblank_event *e)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&dev->event_lock, flags);
+        file_priv->event_space += sizeof e->event;
+        spin_unlock_irqrestore(&dev->event_lock, flags);
+        kfree(e);
+}
+
+static int atomic_set_prop(struct drm_atomic_state *state,
+                struct drm_mode_object *obj, struct drm_property *prop,
+                uint64_t prop_value)
+{
+        struct drm_mode_object *ref;
+        int ret;
+
+        if (!drm_property_change_valid_get(prop, prop_value, &ref))
+                return -EINVAL;
+
+        switch (obj->type) {
+        case DRM_MODE_OBJECT_CONNECTOR: {
+                struct drm_connector *connector = obj_to_connector(obj);
+                struct drm_connector_state *connector_state;
+
+                connector_state = drm_atomic_get_connector_state(state, connector);
+                if (IS_ERR(connector_state)) {
+                        ret = PTR_ERR(connector_state);
+                        break;
+                }
+
+                ret = drm_atomic_connector_set_property(connector,
+                                connector_state, prop, prop_value);
+                break;
+        }
+        case DRM_MODE_OBJECT_CRTC: {
+                struct drm_crtc *crtc = obj_to_crtc(obj);
+                struct drm_crtc_state *crtc_state;
+
+                crtc_state = drm_atomic_get_crtc_state(state, crtc);
+                if (IS_ERR(crtc_state)) {
+                        ret = PTR_ERR(crtc_state);
+                        break;
+                }
+
+                ret = drm_atomic_crtc_set_property(crtc,
+                                crtc_state, prop, prop_value);
+                break;
+        }
+        case DRM_MODE_OBJECT_PLANE: {
+                struct drm_plane *plane = obj_to_plane(obj);
+                struct drm_plane_state *plane_state;
+
+                plane_state = drm_atomic_get_plane_state(state, plane);
+                if (IS_ERR(plane_state)) {
+                        ret = PTR_ERR(plane_state);
+                        break;
+                }
+
+                ret = drm_atomic_plane_set_property(plane,
+                                plane_state, prop, prop_value);
+                break;
+        }
+        default:
+                ret = -EINVAL;
+                break;
+        }
+
+        drm_property_change_valid_put(prop, ref);
+        return ret;
+}
+
+int drm_mode_atomic_ioctl(struct drm_device *dev,
+                          void *data, struct drm_file *file_priv)
+{
+        struct drm_mode_atomic *arg = data;
+        uint32_t __user *objs_ptr = (uint32_t __user *)(unsigned long)(arg->objs_ptr);
+        uint32_t __user *count_props_ptr = (uint32_t __user *)(unsigned long)(arg->count_props_ptr);
+        uint32_t __user *props_ptr = (uint32_t __user *)(unsigned long)(arg->props_ptr);
+        uint64_t __user *prop_values_ptr = (uint64_t __user *)(unsigned long)(arg->prop_values_ptr);
+        unsigned int copied_objs, copied_props;
+        struct drm_atomic_state *state;
+        struct drm_modeset_acquire_ctx ctx;
+        struct drm_plane *plane;
+        unsigned plane_mask = 0;
+        int ret = 0;
+        unsigned int i, j;
+
+        /* disallow for drivers not supporting atomic: */
+        if (!drm_core_check_feature(dev, DRIVER_ATOMIC))
+                return -EINVAL;
+
+        /* disallow for userspace that has not enabled atomic cap (even
+         * though this may be a bit overkill, since legacy userspace
+         * wouldn't know how to call this ioctl)
+         */
+        if (!file_priv->atomic)
+                return -EINVAL;
+
+        if (arg->flags & ~DRM_MODE_ATOMIC_FLAGS)
+                return -EINVAL;
+
+        if (arg->reserved)
+                return -EINVAL;
+
+        if ((arg->flags & DRM_MODE_PAGE_FLIP_ASYNC) &&
+                        !dev->mode_config.async_page_flip)
+                return -EINVAL;
+
+        /* can't test and expect an event at the same time. */
+        if ((arg->flags & DRM_MODE_ATOMIC_TEST_ONLY) &&
+                        (arg->flags & DRM_MODE_PAGE_FLIP_EVENT))
+                return -EINVAL;
+
+        drm_modeset_acquire_init(&ctx, 0);
+
+        state = drm_atomic_state_alloc(dev);
+        if (!state)
+                return -ENOMEM;
+
+        state->acquire_ctx = &ctx;
+        state->allow_modeset = !!(arg->flags & DRM_MODE_ATOMIC_ALLOW_MODESET);
+
+retry:
+        copied_objs = 0;
+        copied_props = 0;
+
+        for (i = 0; i < arg->count_objs; i++) {
+                uint32_t obj_id, count_props;
+                struct drm_mode_object *obj;
+
+                if (get_user(obj_id, objs_ptr + copied_objs)) {
+                        ret = -EFAULT;
+                        goto fail;
+                }
+
+                obj = drm_mode_object_find(dev, obj_id, DRM_MODE_OBJECT_ANY);
+                if (!obj || !obj->properties) {
+                        ret = -ENOENT;
+                        goto fail;
+                }
+
+                if (obj->type == DRM_MODE_OBJECT_PLANE) {
+                        plane = obj_to_plane(obj);
+                        plane_mask |= (1 << drm_plane_index(plane));
+                        plane->old_fb = plane->fb;
+                }
+
+                if (get_user(count_props, count_props_ptr + copied_objs)) {
+                        ret = -EFAULT;
+                        goto fail;
+                }
+
+                copied_objs++;
+
+                for (j = 0; j < count_props; j++) {
+                        uint32_t prop_id;
+                        uint64_t prop_value;
+                        struct drm_property *prop;
+
+                        if (get_user(prop_id, props_ptr + copied_props)) {
+                                ret = -EFAULT;
+                                goto fail;
+                        }
+
+                        prop = drm_property_find(dev, prop_id);
+                        if (!prop) {
+                                ret = -ENOENT;
+                                goto fail;
+                        }
+
+                        if (get_user(prop_value, prop_values_ptr + copied_props)) {
+                                ret = -EFAULT;
+                                goto fail;
+                        }
+
+                        ret = atomic_set_prop(state, obj, prop, prop_value);
+                        if (ret)
+                                goto fail;
+
+                        copied_props++;
+                }
+        }
+
+        if (arg->flags & DRM_MODE_PAGE_FLIP_EVENT) {
+                int ncrtcs = dev->mode_config.num_crtc;
+
+                for (i = 0; i < ncrtcs; i++) {
+                        struct drm_crtc_state *crtc_state = state->crtc_states[i];
+                        struct drm_pending_vblank_event *e;
+
+                        if (!crtc_state)
+                                continue;
+
+                        e = create_vblank_event(dev, file_priv, arg->user_data);
+                        if (!e) {
+                                ret = -ENOMEM;
+                                goto fail;
+                        }
+
+                        crtc_state->event = e;
+                }
+        }
+
+        if (arg->flags & DRM_MODE_ATOMIC_TEST_ONLY) {
+                ret = drm_atomic_check_only(state);
+                /* _check_only() does not free state, unlike _commit() */
+                drm_atomic_state_free(state);
+        } else if (arg->flags & DRM_MODE_ATOMIC_NONBLOCK) {
+                ret = drm_atomic_async_commit(state);
+        } else {
+                ret = drm_atomic_commit(state);
+        }
+
+        /* if succeeded, fixup legacy plane crtc/fb ptrs before dropping
+         * locks (ie. while it is still safe to deref plane->state).  We
+         * need to do this here because the driver entry points cannot
+         * distinguish between legacy and atomic ioctls.
+         */
+        drm_for_each_plane_mask(plane, dev, plane_mask) {
+                if (ret == 0) {
+                        struct drm_framebuffer *new_fb = plane->state->fb;
+                        if (new_fb)
+                                drm_framebuffer_reference(new_fb);
+                        plane->fb = new_fb;
+                        plane->crtc = plane->state->crtc;
+                } else {
+                        plane->old_fb = NULL;
+                }
+                if (plane->old_fb) {
+                        drm_framebuffer_unreference(plane->old_fb);
+                        plane->old_fb = NULL;
+                }
+        }
+
+        drm_modeset_drop_locks(&ctx);
+        drm_modeset_acquire_fini(&ctx);
+
+        return ret;
+
+fail:
+        if (ret == -EDEADLK)
+                goto backoff;
+
+        if (arg->flags & DRM_MODE_PAGE_FLIP_EVENT) {
+                int ncrtcs = dev->mode_config.num_crtc;
+
+                for (i = 0; i < ncrtcs; i++) {
+                        struct drm_crtc_state *crtc_state = state->crtc_states[i];
+
+                        if (!crtc_state)
+                                continue;
+
+                        destroy_vblank_event(dev, file_priv, crtc_state->event);
+                        crtc_state->event = NULL;
+                }
+        }
+
+        drm_atomic_state_free(state);
+
+        drm_modeset_drop_locks(&ctx);
+        drm_modeset_acquire_fini(&ctx);
+
+        return ret;
+
+backoff:
+        drm_atomic_state_clear(state);
+        drm_modeset_backoff(&ctx);
+
+        goto retry;
+}
diff --git a/drivers/gpu/drm/drm_atomic_helper.c b/drivers/gpu/drm/drm_atomic_helper.c
index bbdbe4721573..541ba833ed36 100644
--- a/drivers/gpu/drm/drm_atomic_helper.c
+++ b/drivers/gpu/drm/drm_atomic_helper.c
@@ -330,7 +330,29 @@ mode_fixup(struct drm_atomic_state *state)
         return 0;
 }
 
-static int
+/**
+ * drm_atomic_helper_check - validate state object for modeset changes
+ * @dev: DRM device
+ * @state: the driver state object
+ *
+ * Check the state object to see if the requested state is physically possible.
+ * This does all the crtc and connector related computations for an atomic
+ * update. It computes and updates crtc_state->mode_changed, adds any additional
+ * connectors needed for full modesets and calls down into ->mode_fixup
+ * functions of the driver backend.
+ *
+ * IMPORTANT:
+ *
+ * Drivers which update ->mode_changed (e.g. in their ->atomic_check hooks if a
+ * plane update can't be done without a full modeset) _must_ call this function
+ * afterwards after that change. It is permitted to call this function multiple
+ * times for the same update, e.g. when the ->atomic_check functions depend upon
+ * the adjusted dotclock for fifo space allocation and watermark computation.
+ *
+ * RETURNS
+ * Zero for success or -errno
+ */
+int
 drm_atomic_helper_check_modeset(struct drm_device *dev,
                                 struct drm_atomic_state *state)
 {
@@ -406,23 +428,23 @@ drm_atomic_helper_check_modeset(struct drm_device *dev,
 
         return mode_fixup(state);
 }
+EXPORT_SYMBOL(drm_atomic_helper_check_modeset);
 
 /**
- * drm_atomic_helper_check - validate state object
+ * drm_atomic_helper_check - validate state object for modeset changes
  * @dev: DRM device
  * @state: the driver state object
  *
  * Check the state object to see if the requested state is physically possible.
- * Only crtcs and planes have check callbacks, so for any additional (global)
- * checking that a driver needs it can simply wrap that around this function.
- * Drivers without such needs can directly use this as their ->atomic_check()
- * callback.
+ * This does all the plane update related checks using by calling into the
+ * ->atomic_check hooks provided by the driver.
  *
  * RETURNS
  * Zero for success or -errno
  */
-int drm_atomic_helper_check(struct drm_device *dev,
-                            struct drm_atomic_state *state)
+int
+drm_atomic_helper_check_planes(struct drm_device *dev,
+                               struct drm_atomic_state *state)
 {
         int nplanes = dev->mode_config.num_total_plane;
         int ncrtcs = dev->mode_config.num_crtc;
@@ -445,7 +467,7 @@ int drm_atomic_helper_check(struct drm_device *dev,
 
                 ret = funcs->atomic_check(plane, plane_state);
                 if (ret) {
-                        DRM_DEBUG_KMS("[PLANE:%d] atomic check failed\n",
+                        DRM_DEBUG_KMS("[PLANE:%d] atomic driver check failed\n",
                                       plane->base.id);
                         return ret;
                 }
@@ -465,16 +487,49 @@ int drm_atomic_helper_check(struct drm_device *dev,
 
                 ret = funcs->atomic_check(crtc, state->crtc_states[i]);
                 if (ret) {
-                        DRM_DEBUG_KMS("[CRTC:%d] atomic check failed\n",
+                        DRM_DEBUG_KMS("[CRTC:%d] atomic driver check failed\n",
                                       crtc->base.id);
                         return ret;
                 }
         }
 
+        return ret;
+}
+EXPORT_SYMBOL(drm_atomic_helper_check_planes);
+
+/**
+ * drm_atomic_helper_check - validate state object
+ * @dev: DRM device
+ * @state: the driver state object
+ *
+ * Check the state object to see if the requested state is physically possible.
+ * Only crtcs and planes have check callbacks, so for any additional (global)
+ * checking that a driver needs it can simply wrap that around this function.
+ * Drivers without such needs can directly use this as their ->atomic_check()
+ * callback.
+ *
+ * This just wraps the two parts of the state checking for planes and modeset
+ * state in the default order: First it calls drm_atomic_helper_check_modeset()
+ * and then drm_atomic_helper_check_planes(). The assumption is that the
+ * ->atomic_check functions depend upon an updated adjusted_mode.clock to
+ * e.g. properly compute watermarks.
+ *
+ * RETURNS
+ * Zero for success or -errno
+ */
+int drm_atomic_helper_check(struct drm_device *dev,
+                            struct drm_atomic_state *state)
+{
+        int ret;
+
         ret = drm_atomic_helper_check_modeset(dev, state);
         if (ret)
                 return ret;
 
+        ret = drm_atomic_helper_check_planes(dev, state);
+        if (ret)
+                return ret;
+
         return ret;
 }
 EXPORT_SYMBOL(drm_atomic_helper_check);
@@ -1222,7 +1277,7 @@ retry:
                 goto fail;
         }
 
-        ret = drm_atomic_set_crtc_for_plane(state, plane, crtc);
+        ret = drm_atomic_set_crtc_for_plane(plane_state, crtc);
         if (ret != 0)
                 goto fail;
         drm_atomic_set_fb_for_plane(plane_state, fb);
@@ -1301,7 +1356,7 @@ retry:
                 goto fail;
         }
 
-        ret = drm_atomic_set_crtc_for_plane(state, plane, NULL);
+        ret = drm_atomic_set_crtc_for_plane(plane_state, NULL);
         if (ret != 0)
                 goto fail;
         drm_atomic_set_fb_for_plane(plane_state, NULL);
@@ -1464,7 +1519,7 @@ retry:
 
                 crtc_state->enable = false;
 
-                ret = drm_atomic_set_crtc_for_plane(state, crtc->primary, NULL);
+                ret = drm_atomic_set_crtc_for_plane(primary_state, NULL);
                 if (ret != 0)
                         goto fail;
 
@@ -1479,7 +1534,7 @@ retry:
         crtc_state->enable = true;
         drm_mode_copy(&crtc_state->mode, set->mode);
 
-        ret = drm_atomic_set_crtc_for_plane(state, crtc->primary, crtc);
+        ret = drm_atomic_set_crtc_for_plane(primary_state, crtc);
         if (ret != 0)
                 goto fail;
         drm_atomic_set_fb_for_plane(primary_state, set->fb);
@@ -1558,8 +1613,8 @@ retry:
                 goto fail;
         }
 
-        ret = crtc->funcs->atomic_set_property(crtc, crtc_state,
-                                               property, val);
+        ret = drm_atomic_crtc_set_property(crtc, crtc_state,
+                        property, val);
         if (ret)
                 goto fail;
 
@@ -1617,8 +1672,8 @@ retry:
                 goto fail;
         }
 
-        ret = plane->funcs->atomic_set_property(plane, plane_state,
-                                               property, val);
+        ret = drm_atomic_plane_set_property(plane, plane_state,
+                        property, val);
         if (ret)
                 goto fail;
 
@@ -1676,8 +1731,8 @@ retry:
                 goto fail;
         }
 
-        ret = connector->funcs->atomic_set_property(connector, connector_state,
-                                               property, val);
+        ret = drm_atomic_connector_set_property(connector, connector_state,
+                        property, val);
         if (ret)
                 goto fail;
 
@@ -1751,7 +1806,7 @@ retry:
                 goto fail;
         }
 
-        ret = drm_atomic_set_crtc_for_plane(state, plane, crtc);
+        ret = drm_atomic_set_crtc_for_plane(plane_state, crtc);
         if (ret != 0)
                 goto fail;
         drm_atomic_set_fb_for_plane(plane_state, fb);
@@ -1814,6 +1869,9 @@ void drm_atomic_helper_crtc_reset(struct drm_crtc *crtc)
 {
         kfree(crtc->state);
         crtc->state = kzalloc(sizeof(*crtc->state), GFP_KERNEL);
+
+        if (crtc->state)
+                crtc->state->crtc = crtc;
 }
 EXPORT_SYMBOL(drm_atomic_helper_crtc_reset);
 
@@ -1873,6 +1931,9 @@ void drm_atomic_helper_plane_reset(struct drm_plane *plane)
 
         kfree(plane->state);
         plane->state = kzalloc(sizeof(*plane->state), GFP_KERNEL);
+
+        if (plane->state)
+                plane->state->plane = plane;
 }
 EXPORT_SYMBOL(drm_atomic_helper_plane_reset);
 
@@ -1930,6 +1991,9 @@ void drm_atomic_helper_connector_reset(struct drm_connector *connector)
 {
         kfree(connector->state);
         connector->state = kzalloc(sizeof(*connector->state), GFP_KERNEL);
+
+        if (connector->state)
+                connector->state->connector = connector;
 }
 EXPORT_SYMBOL(drm_atomic_helper_connector_reset);
 
diff --git a/drivers/gpu/drm/drm_crtc.c b/drivers/gpu/drm/drm_crtc.c
index 2892d746a1e9..7e4acad3f6f9 100644
--- a/drivers/gpu/drm/drm_crtc.c
+++ b/drivers/gpu/drm/drm_crtc.c
@@ -38,6 +38,7 @@
 #include <drm/drm_edid.h>
 #include <drm/drm_fourcc.h>
 #include <drm/drm_modeset_lock.h>
+#include <drm/drm_atomic.h>
 
 #include "drm_crtc_internal.h"
 #include "drm_internal.h"
@@ -830,6 +831,7 @@ int drm_connector_init(struct drm_device *dev,
                        const struct drm_connector_funcs *funcs,
                        int connector_type)
 {
+        struct drm_mode_config *config = &dev->mode_config;
         int ret;
         struct ida *connector_ida =
                 &drm_connector_enum_list[connector_type].ida;
@@ -868,16 +870,20 @@ int drm_connector_init(struct drm_device *dev,
 
         /* We should add connectors at the end to avoid upsetting the connector
          * index too much. */
-        list_add_tail(&connector->head, &dev->mode_config.connector_list);
-        dev->mode_config.num_connector++;
+        list_add_tail(&connector->head, &config->connector_list);
+        config->num_connector++;
 
         if (connector_type != DRM_MODE_CONNECTOR_VIRTUAL)
                 drm_object_attach_property(&connector->base,
-                                              dev->mode_config.edid_property,
+                                              config->edid_property,
                                               0);
 
         drm_object_attach_property(&connector->base,
-                                      dev->mode_config.dpms_property, 0);
+                                      config->dpms_property, 0);
+
+        if (drm_core_check_feature(dev, DRIVER_ATOMIC)) {
+                drm_object_attach_property(&connector->base, config->prop_crtc_id, 0);
+        }
 
         connector->debugfs_entry = NULL;
 
@@ -1168,6 +1174,7 @@ int drm_universal_plane_init(struct drm_device *dev, struct drm_plane *plane,
                              const uint32_t *formats, uint32_t format_count,
                              enum drm_plane_type type)
 {
+        struct drm_mode_config *config = &dev->mode_config;
         int ret;
 
         ret = drm_mode_object_get(dev, &plane->base, DRM_MODE_OBJECT_PLANE);
@@ -1192,15 +1199,28 @@ int drm_universal_plane_init(struct drm_device *dev, struct drm_plane *plane,
         plane->possible_crtcs = possible_crtcs;
         plane->type = type;
 
-        list_add_tail(&plane->head, &dev->mode_config.plane_list);
-        dev->mode_config.num_total_plane++;
+        list_add_tail(&plane->head, &config->plane_list);
+        config->num_total_plane++;
         if (plane->type == DRM_PLANE_TYPE_OVERLAY)
-                dev->mode_config.num_overlay_plane++;
+                config->num_overlay_plane++;
 
         drm_object_attach_property(&plane->base,
-                                   dev->mode_config.plane_type_property,
+                                   config->plane_type_property,
                                    plane->type);
 
+        if (drm_core_check_feature(dev, DRIVER_ATOMIC)) {
+                drm_object_attach_property(&plane->base, config->prop_fb_id, 0);
+                drm_object_attach_property(&plane->base, config->prop_crtc_id, 0);
+                drm_object_attach_property(&plane->base, config->prop_crtc_x, 0);
+                drm_object_attach_property(&plane->base, config->prop_crtc_y, 0);
+                drm_object_attach_property(&plane->base, config->prop_crtc_w, 0);
+                drm_object_attach_property(&plane->base, config->prop_crtc_h, 0);
+                drm_object_attach_property(&plane->base, config->prop_src_x, 0);
+                drm_object_attach_property(&plane->base, config->prop_src_y, 0);
+                drm_object_attach_property(&plane->base, config->prop_src_w, 0);
+                drm_object_attach_property(&plane->base, config->prop_src_h, 0);
+        }
+
         return 0;
 }
 EXPORT_SYMBOL(drm_universal_plane_init);
@@ -1322,50 +1342,109 @@ void drm_plane_force_disable(struct drm_plane *plane)
 }
 EXPORT_SYMBOL(drm_plane_force_disable);
 
-static int drm_mode_create_standard_connector_properties(struct drm_device *dev)
+static int drm_mode_create_standard_properties(struct drm_device *dev)
 {
-        struct drm_property *edid;
-        struct drm_property *dpms;
-        struct drm_property *dev_path;
+        struct drm_property *prop;
 
         /*
          * Standard properties (apply to all connectors)
          */
-        edid = drm_property_create(dev, DRM_MODE_PROP_BLOB |
+        prop = drm_property_create(dev, DRM_MODE_PROP_BLOB |
                                    DRM_MODE_PROP_IMMUTABLE,
                                    "EDID", 0);
-        dev->mode_config.edid_property = edid;
+        if (!prop)
+                return -ENOMEM;
+        dev->mode_config.edid_property = prop;
 
-        dpms = drm_property_create_enum(dev, 0,
+        prop = drm_property_create_enum(dev, 0,
                                    "DPMS", drm_dpms_enum_list,
                                    ARRAY_SIZE(drm_dpms_enum_list));
-        dev->mode_config.dpms_property = dpms;
-
-        dev_path = drm_property_create(dev,
-                                       DRM_MODE_PROP_BLOB |
-                                       DRM_MODE_PROP_IMMUTABLE,
-                                       "PATH", 0);
-        dev->mode_config.path_property = dev_path;
-
-        dev->mode_config.tile_property = drm_property_create(dev,
-                                                             DRM_MODE_PROP_BLOB |
-                                                             DRM_MODE_PROP_IMMUTABLE,
-                                                             "TILE", 0);
+        if (!prop)
+                return -ENOMEM;
+        dev->mode_config.dpms_property = prop;
 
-        return 0;
-}
+        prop = drm_property_create(dev,
+                                   DRM_MODE_PROP_BLOB |
+                                   DRM_MODE_PROP_IMMUTABLE,
+                                   "PATH", 0);
+        if (!prop)
+                return -ENOMEM;
+        dev->mode_config.path_property = prop;
 
-static int drm_mode_create_standard_plane_properties(struct drm_device *dev)
-{
-        struct drm_property *type;
+        prop = drm_property_create(dev,
+                                   DRM_MODE_PROP_BLOB |
+                                   DRM_MODE_PROP_IMMUTABLE,
+                                   "TILE", 0);
+        if (!prop)
+                return -ENOMEM;
+        dev->mode_config.tile_property = prop;
 
-        /*
-         * Standard properties (apply to all planes)
-         */
-        type = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
+        prop = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
                                         "type", drm_plane_type_enum_list,
                                         ARRAY_SIZE(drm_plane_type_enum_list));
-        dev->mode_config.plane_type_property = type;
+        if (!prop)
+                return -ENOMEM;
+        dev->mode_config.plane_type_property = prop;
+
+        prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
+                        "SRC_X", 0, UINT_MAX);
+        if (!prop)
+                return -ENOMEM;
+        dev->mode_config.prop_src_x = prop;
+
+        prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
+                        "SRC_Y", 0, UINT_MAX);
+        if (!prop)
+                return -ENOMEM;
+        dev->mode_config.prop_src_y = prop;
+
+        prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
+                        "SRC_W", 0, UINT_MAX);
+        if (!prop)
+                return -ENOMEM;
+        dev->mode_config.prop_src_w = prop;
+
+        prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
+                        "SRC_H", 0, UINT_MAX);
+        if (!prop)
+                return -ENOMEM;
+        dev->mode_config.prop_src_h = prop;
+
+        prop = drm_property_create_signed_range(dev, DRM_MODE_PROP_ATOMIC,
+                        "CRTC_X", INT_MIN, INT_MAX);
+        if (!prop)
+                return -ENOMEM;
+        dev->mode_config.prop_crtc_x = prop;
+
+        prop = drm_property_create_signed_range(dev, DRM_MODE_PROP_ATOMIC,
+                        "CRTC_Y", INT_MIN, INT_MAX);
+        if (!prop)
+                return -ENOMEM;
+        dev->mode_config.prop_crtc_y = prop;
+
+        prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
+                        "CRTC_W", 0, INT_MAX);
+        if (!prop)
+                return -ENOMEM;
+        dev->mode_config.prop_crtc_w = prop;
+
+        prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
+                        "CRTC_H", 0, INT_MAX);
+        if (!prop)
+                return -ENOMEM;
+        dev->mode_config.prop_crtc_h = prop;
+
+        prop = drm_property_create_object(dev, DRM_MODE_PROP_ATOMIC,
+                        "FB_ID", DRM_MODE_OBJECT_FB);
+        if (!prop)
+                return -ENOMEM;
+        dev->mode_config.prop_fb_id = prop;
+
+        prop = drm_property_create_object(dev, DRM_MODE_PROP_ATOMIC,
+                        "CRTC_ID", DRM_MODE_OBJECT_CRTC);
+        if (!prop)
+                return -ENOMEM;
+        dev->mode_config.prop_crtc_id = prop;
 
         return 0;
 }
@@ -1991,6 +2070,44 @@ static struct drm_encoder *drm_connector_get_encoder(struct drm_connector *conne
         return connector->encoder;
 }
 
+/* helper for getconnector and getproperties ioctls */
+static int get_properties(struct drm_mode_object *obj, bool atomic,
+                uint32_t __user *prop_ptr, uint64_t __user *prop_values,
+                uint32_t *arg_count_props)
+{
+        int props_count;
+        int i, ret, copied;
+
+        props_count = obj->properties->count;
+        if (!atomic)
+                props_count -= obj->properties->atomic_count;
+
+        if ((*arg_count_props >= props_count) && props_count) {
+                for (i = 0, copied = 0; copied < props_count; i++) {
+                        struct drm_property *prop = obj->properties->properties[i];
+                        uint64_t val;
+
+                        if ((prop->flags & DRM_MODE_PROP_ATOMIC) && !atomic)
+                                continue;
+
+                        ret = drm_object_property_get_value(obj, prop, &val);
+                        if (ret)
+                                return ret;
+
+                        if (put_user(prop->base.id, prop_ptr + copied))
+                                return -EFAULT;
+
+                        if (put_user(val, prop_values + copied))
+                                return -EFAULT;
+
+                        copied++;
+                }
+        }
+        *arg_count_props = props_count;
+
+        return 0;
+}
+
 /**
  * drm_mode_getconnector - get connector configuration
  * @dev: drm device for the ioctl
@@ -2012,15 +2129,12 @@ int drm_mode_getconnector(struct drm_device *dev, void *data,
         struct drm_encoder *encoder;
         struct drm_display_mode *mode;
         int mode_count = 0;
-        int props_count = 0;
         int encoders_count = 0;
         int ret = 0;
         int copied = 0;
         int i;
         struct drm_mode_modeinfo u_mode;
         struct drm_mode_modeinfo __user *mode_ptr;
-        uint32_t __user *prop_ptr;
-        uint64_t __user *prop_values;
         uint32_t __user *encoder_ptr;
 
         if (!drm_core_check_feature(dev, DRIVER_MODESET))
@@ -2031,6 +2145,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);
+        drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
 
         connector = drm_connector_find(dev, out_resp->connector_id);
         if (!connector) {
@@ -2038,8 +2153,6 @@ int drm_mode_getconnector(struct drm_device *dev, void *data,
                 goto out;
         }
 
-        props_count = connector->properties.count;
-
         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++)
                 if (connector->encoder_ids[i] != 0)
                         encoders_count++;
@@ -2062,14 +2175,11 @@ int drm_mode_getconnector(struct drm_device *dev, void *data,
         out_resp->mm_height = connector->display_info.height_mm;
         out_resp->subpixel = connector->display_info.subpixel_order;
         out_resp->connection = connector->status;
-        drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
-
         encoder = drm_connector_get_encoder(connector);
         if (encoder)
                 out_resp->encoder_id = encoder->base.id;
         else
                 out_resp->encoder_id = 0;
-        drm_modeset_unlock(&dev->mode_config.connection_mutex);
 
         /*
          * This ioctl is called twice, once to determine how much space is
@@ -2093,26 +2203,12 @@ int drm_mode_getconnector(struct drm_device *dev, void *data,
         }
         out_resp->count_modes = mode_count;
 
-        if ((out_resp->count_props >= props_count) && props_count) {
-                copied = 0;
-                prop_ptr = (uint32_t __user *)(unsigned long)(out_resp->props_ptr);
-                prop_values = (uint64_t __user *)(unsigned long)(out_resp->prop_values_ptr);
-                for (i = 0; i < connector->properties.count; i++) {
-                        if (put_user(connector->properties.ids[i],
-                                     prop_ptr + copied)) {
-                                ret = -EFAULT;
-                                goto out;
-                        }
-
-                        if (put_user(connector->properties.values[i],
-                                     prop_values + copied)) {
-                                ret = -EFAULT;
-                                goto out;
-                        }
-                        copied++;
-                }
-        }
-        out_resp->count_props = props_count;
+        ret = get_properties(&connector->base, file_priv->atomic,
+                        (uint32_t __user *)(unsigned long)(out_resp->props_ptr),
+                        (uint64_t __user *)(unsigned long)(out_resp->prop_values_ptr),
+                        &out_resp->count_props);
+        if (ret)
+                goto out;
 
         if ((out_resp->count_encoders >= encoders_count) && encoders_count) {
                 copied = 0;
@@ -2131,6 +2227,7 @@ int drm_mode_getconnector(struct drm_device *dev, void *data,
         out_resp->count_encoders = encoders_count;
 
 out:
+        drm_modeset_unlock(&dev->mode_config.connection_mutex);
         mutex_unlock(&dev->mode_config.mutex);
 
         return ret;
@@ -3823,9 +3920,11 @@ void drm_object_attach_property(struct drm_mode_object *obj,
                 return;
         }
 
-        obj->properties->ids[count] = property->base.id;
+        obj->properties->properties[count] = property;
         obj->properties->values[count] = init_val;
         obj->properties->count++;
+        if (property->flags & DRM_MODE_PROP_ATOMIC)
+                obj->properties->atomic_count++;
 }
 EXPORT_SYMBOL(drm_object_attach_property);
 
@@ -3848,7 +3947,7 @@ int drm_object_property_set_value(struct drm_mode_object *obj,
         int i;
 
         for (i = 0; i < obj->properties->count; i++) {
-                if (obj->properties->ids[i] == property->base.id) {
+                if (obj->properties->properties[i] == property) {
                         obj->properties->values[i] = val;
                         return 0;
                 }
@@ -3877,8 +3976,16 @@ int drm_object_property_get_value(struct drm_mode_object *obj,
 {
         int i;
 
+        /* read-only properties bypass atomic mechanism and still store
+         * their value in obj->properties->values[].. mostly to avoid
+         * having to deal w/ EDID and similar props in atomic paths:
+         */
+        if (drm_core_check_feature(property->dev, DRIVER_ATOMIC) &&
+                        !(property->flags & DRM_MODE_PROP_IMMUTABLE))
+                return drm_atomic_get_property(obj, property, val);
+
         for (i = 0; i < obj->properties->count; i++) {
-                if (obj->properties->ids[i] == property->base.id) {
+                if (obj->properties->properties[i] == property) {
                         *val = obj->properties->values[i];
                         return 0;
                 }
@@ -4194,14 +4301,24 @@ int drm_mode_connector_update_edid_property(struct drm_connector *connector,
 }
 EXPORT_SYMBOL(drm_mode_connector_update_edid_property);
 
-static bool drm_property_change_is_valid(struct drm_property *property,
-                                         uint64_t value)
+/* Some properties could refer to dynamic refcnt'd objects, or things that
+ * need special locking to handle lifetime issues (ie. to ensure the prop
+ * value doesn't become invalid part way through the property update due to
+ * race).  The value returned by reference via 'obj' should be passed back
+ * to drm_property_change_valid_put() after the property is set (and the
+ * object to which the property is attached has a chance to take it's own
+ * reference).
+ */
+bool drm_property_change_valid_get(struct drm_property *property,
+                                         uint64_t value, struct drm_mode_object **ref)
 {
         int i;
 
         if (property->flags & DRM_MODE_PROP_IMMUTABLE)
                 return false;
 
+        *ref = NULL;
+
         if (drm_property_type_is(property, DRM_MODE_PROP_RANGE)) {
                 if (value < property->values[0] || value > property->values[1])
                         return false;
@@ -4223,20 +4340,29 @@ static bool drm_property_change_is_valid(struct drm_property *property,
                 /* Only the driver knows */
                 return true;
         } else if (drm_property_type_is(property, DRM_MODE_PROP_OBJECT)) {
-                struct drm_mode_object *obj;
-
                 /* a zero value for an object property translates to null: */
                 if (value == 0)
                         return true;
-                /*
-                 * NOTE: use _object_find() directly to bypass restriction on
-                 * looking up refcnt'd objects (ie. fb's).  For a refcnt'd
-                 * object this could race against object finalization, so it
-                 * simply tells us that the object *was* valid.  Which is good
-                 * enough.
-                 */
-                obj = _object_find(property->dev, value, property->values[0]);
-                return obj != NULL;
+
+                /* handle refcnt'd objects specially: */
+                if (property->values[0] == DRM_MODE_OBJECT_FB) {
+                        struct drm_framebuffer *fb;
+                        fb = drm_framebuffer_lookup(property->dev, value);
+                        if (fb) {
+                                *ref = &fb->base;
+                                return true;
+                        } else {
+                                return false;
+                        }
+                } else {
+                        return _object_find(property->dev, value, property->values[0]) != NULL;
+                }
+        } else {
+                int i;
+                for (i = 0; i < property->num_values; i++)
+                        if (property->values[i] == value)
+                                return true;
+                return false;
         }
 
         for (i = 0; i < property->num_values; i++)
@@ -4245,6 +4371,18 @@ static bool drm_property_change_is_valid(struct drm_property *property,
         return false;
 }
 
+void drm_property_change_valid_put(struct drm_property *property,
+                struct drm_mode_object *ref)
+{
+        if (!ref)
+                return;
+
+        if (drm_property_type_is(property, DRM_MODE_PROP_OBJECT)) {
+                if (property->values[0] == DRM_MODE_OBJECT_FB)
+                        drm_framebuffer_unreference(obj_to_fb(ref));
+        }
+}
+
 /**
  * drm_mode_connector_property_set_ioctl - set the current value of a connector property
  * @dev: DRM device
@@ -4360,11 +4498,6 @@ int drm_mode_obj_get_properties_ioctl(struct drm_device *dev, void *data,
         struct drm_mode_obj_get_properties *arg = data;
         struct drm_mode_object *obj;
         int ret = 0;
-        int i;
-        int copied = 0;
-        int props_count = 0;
-        uint32_t __user *props_ptr;
-        uint64_t __user *prop_values_ptr;
 
         if (!drm_core_check_feature(dev, DRIVER_MODESET))
                 return -EINVAL;
@@ -4381,30 +4514,11 @@ int drm_mode_obj_get_properties_ioctl(struct drm_device *dev, void *data,
                 goto out;
         }
 
-        props_count = obj->properties->count;
+        ret = get_properties(obj, file_priv->atomic,
+                        (uint32_t __user *)(unsigned long)(arg->props_ptr),
+                        (uint64_t __user *)(unsigned long)(arg->prop_values_ptr),
+                        &arg->count_props);
 
-        /* This ioctl is called twice, once to determine how much space is
-         * needed, and the 2nd time to fill it. */
-        if ((arg->count_props >= props_count) && props_count) {
-                copied = 0;
-                props_ptr = (uint32_t __user *)(unsigned long)(arg->props_ptr);
-                prop_values_ptr = (uint64_t __user *)(unsigned long)
-                                  (arg->prop_values_ptr);
-                for (i = 0; i < props_count; i++) {
-                        if (put_user(obj->properties->ids[i],
-                                     props_ptr + copied)) {
-                                ret = -EFAULT;
-                                goto out;
-                        }
-                        if (put_user(obj->properties->values[i],
-                                     prop_values_ptr + copied)) {
-                                ret = -EFAULT;
-                                goto out;
-                        }
-                        copied++;
-                }
-        }
-        arg->count_props = props_count;
 out:
         drm_modeset_unlock_all(dev);
         return ret;
@@ -4433,8 +4547,8 @@ int drm_mode_obj_set_property_ioctl(struct drm_device *dev, void *data,
         struct drm_mode_object *arg_obj;
         struct drm_mode_object *prop_obj;
         struct drm_property *property;
-        int ret = -EINVAL;
-        int i;
+        int i, ret = -EINVAL;
+        struct drm_mode_object *ref;
 
         if (!drm_core_check_feature(dev, DRIVER_MODESET))
                 return -EINVAL;
@@ -4450,7 +4564,7 @@ int drm_mode_obj_set_property_ioctl(struct drm_device *dev, void *data,
                 goto out;
 
         for (i = 0; i < arg_obj->properties->count; i++)
-                if (arg_obj->properties->ids[i] == arg->prop_id)
+                if (arg_obj->properties->properties[i]->base.id == arg->prop_id)
                         break;
 
         if (i == arg_obj->properties->count)
@@ -4464,7 +4578,7 @@ int drm_mode_obj_set_property_ioctl(struct drm_device *dev, void *data,
         }
         property = obj_to_property(prop_obj);
 
-        if (!drm_property_change_is_valid(property, arg->value))
+        if (!drm_property_change_valid_get(property, arg->value, &ref))
                 goto out;
 
         switch (arg_obj->type) {
@@ -4481,6 +4595,8 @@ int drm_mode_obj_set_property_ioctl(struct drm_device *dev, void *data,
                 break;
         }
 
+        drm_property_change_valid_put(property, ref);
+
 out:
         drm_modeset_unlock_all(dev);
         return ret;
@@ -5225,8 +5341,7 @@ void drm_mode_config_init(struct drm_device *dev)
         idr_init(&dev->mode_config.tile_idr);
 
         drm_modeset_lock_all(dev);
-        drm_mode_create_standard_connector_properties(dev);
-        drm_mode_create_standard_plane_properties(dev);
+        drm_mode_create_standard_properties(dev);
         drm_modeset_unlock_all(dev);
 
         /* Just to be sure */
diff --git a/drivers/gpu/drm/drm_crtc_helper.c b/drivers/gpu/drm/drm_crtc_helper.c
index d552708409de..b1979e7bdc88 100644
--- a/drivers/gpu/drm/drm_crtc_helper.c
+++ b/drivers/gpu/drm/drm_crtc_helper.c
@@ -946,6 +946,7 @@ int drm_helper_crtc_mode_set(struct drm_crtc *crtc, struct drm_display_mode *mod
                 crtc_state = kzalloc(sizeof(*crtc_state), GFP_KERNEL);
         if (!crtc_state)
                 return -ENOMEM;
+        crtc_state->crtc = crtc;
 
         crtc_state->enable = true;
         crtc_state->planes_changed = true;
@@ -1005,6 +1006,7 @@ int drm_helper_crtc_mode_set_base(struct drm_crtc *crtc, int x, int y,
                 plane_state = kzalloc(sizeof(*plane_state), GFP_KERNEL);
         if (!plane_state)
                 return -ENOMEM;
+        plane_state->plane = plane;
 
         plane_state->crtc = crtc;
         drm_atomic_set_fb_for_plane(plane_state, crtc->primary->fb);
diff --git a/drivers/gpu/drm/drm_crtc_internal.h b/drivers/gpu/drm/drm_crtc_internal.h
index a2945ee6d675..247dc8b62564 100644
--- a/drivers/gpu/drm/drm_crtc_internal.h
+++ b/drivers/gpu/drm/drm_crtc_internal.h
@@ -36,3 +36,9 @@ int drm_mode_object_get(struct drm_device *dev,
 void drm_mode_object_put(struct drm_device *dev,
                          struct drm_mode_object *object);
 
+/* drm_atomic.c */
+int drm_atomic_get_property(struct drm_mode_object *obj,
+                           struct drm_property *property, uint64_t *val);
+int drm_mode_atomic_ioctl(struct drm_device *dev,
+                          void *data, struct drm_file *file_priv);
+
diff --git a/drivers/gpu/drm/drm_drv.c b/drivers/gpu/drm/drm_drv.c
index 4f41377b0b80..d51213464672 100644
--- a/drivers/gpu/drm/drm_drv.c
+++ b/drivers/gpu/drm/drm_drv.c
@@ -40,15 +40,19 @@
 unsigned int drm_debug = 0;     /* 1 to enable debug output */
 EXPORT_SYMBOL(drm_debug);
 
+bool drm_atomic = 0;
+
 MODULE_AUTHOR(CORE_AUTHOR);
 MODULE_DESCRIPTION(CORE_DESC);
 MODULE_LICENSE("GPL and additional rights");
 MODULE_PARM_DESC(debug, "Enable debug output");
+MODULE_PARM_DESC(atomic, "Enable experimental atomic KMS API");
 MODULE_PARM_DESC(vblankoffdelay, "Delay until vblank irq auto-disable [msecs] (0: never disable, <0: disable immediately)");
 MODULE_PARM_DESC(timestamp_precision_usec, "Max. error on timestamps [usecs]");
 MODULE_PARM_DESC(timestamp_monotonic, "Use monotonic timestamps");
 
 module_param_named(debug, drm_debug, int, 0600);
+module_param_named_unsafe(atomic, drm_atomic, bool, 0600);
 
 static DEFINE_SPINLOCK(drm_minor_lock);
 static struct idr drm_minors_idr;
diff --git a/drivers/gpu/drm/drm_ioctl.c b/drivers/gpu/drm/drm_ioctl.c
index 00587a1e3c83..3785d66721f2 100644
--- a/drivers/gpu/drm/drm_ioctl.c
+++ b/drivers/gpu/drm/drm_ioctl.c
@@ -32,6 +32,7 @@
 #include <drm/drm_core.h>
 #include "drm_legacy.h"
 #include "drm_internal.h"
+#include "drm_crtc_internal.h"
 
 #include <linux/pci.h>
 #include <linux/export.h>
@@ -345,6 +346,17 @@ drm_setclientcap(struct drm_device *dev, void *data, struct drm_file *file_priv)
                         return -EINVAL;
                 file_priv->universal_planes = req->value;
                 break;
+        case DRM_CLIENT_CAP_ATOMIC:
+                /* for now, hide behind experimental drm.atomic moduleparam */
+                if (!drm_atomic)
+                        return -EINVAL;
+                if (!drm_core_check_feature(dev, DRIVER_ATOMIC))
+                        return -EINVAL;
+                if (req->value > 1)
+                        return -EINVAL;
+                file_priv->atomic = req->value;
+                file_priv->universal_planes = req->value;
+                break;
         default:
                 return -EINVAL;
         }
@@ -620,6 +632,7 @@ static const struct drm_ioctl_desc drm_ioctls[] = {
         DRM_IOCTL_DEF(DRM_IOCTL_MODE_OBJ_GETPROPERTIES, drm_mode_obj_get_properties_ioctl, DRM_CONTROL_ALLOW|DRM_UNLOCKED),
         DRM_IOCTL_DEF(DRM_IOCTL_MODE_OBJ_SETPROPERTY, drm_mode_obj_set_property_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
         DRM_IOCTL_DEF(DRM_IOCTL_MODE_CURSOR2, drm_mode_cursor2_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
+        DRM_IOCTL_DEF(DRM_IOCTL_MODE_ATOMIC, drm_mode_atomic_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
 };
 
 #define DRM_CORE_IOCTL_COUNT    ARRAY_SIZE( drm_ioctls )
diff --git a/drivers/gpu/drm/drm_plane_helper.c b/drivers/gpu/drm/drm_plane_helper.c
index 391dfb7d1086..f24c4cfe674b 100644
--- a/drivers/gpu/drm/drm_plane_helper.c
+++ b/drivers/gpu/drm/drm_plane_helper.c
@@ -523,6 +523,7 @@ int drm_plane_helper_update(struct drm_plane *plane, struct drm_crtc *crtc,
                 plane_state = kzalloc(sizeof(*plane_state), GFP_KERNEL);
         if (!plane_state)
                 return -ENOMEM;
+        plane_state->plane = plane;
 
         plane_state->crtc = crtc;
         drm_atomic_set_fb_for_plane(plane_state, fb);
@@ -569,6 +570,7 @@ int drm_plane_helper_disable(struct drm_plane *plane)
                 plane_state = kzalloc(sizeof(*plane_state), GFP_KERNEL);
         if (!plane_state)
                 return -ENOMEM;
+        plane_state->plane = plane;
 
         plane_state->crtc = NULL;
         drm_atomic_set_fb_for_plane(plane_state, NULL);
diff --git a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c
index 26e5fdea6594..fc76f630e5b1 100644
--- a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c
+++ b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c
@@ -113,6 +113,7 @@ static void mdp5_plane_reset(struct drm_plane *plane)
         } else {
                 mdp5_state->zpos = 1 + drm_plane_index(plane);
         }
+        mdp5_state->base.plane = plane;
 
         plane->state = &mdp5_state->base;
 }
diff --git a/drivers/gpu/drm/msm/msm_atomic.c b/drivers/gpu/drm/msm/msm_atomic.c
index 191968256c58..2c396540e279 100644
--- a/drivers/gpu/drm/msm/msm_atomic.c
+++ b/drivers/gpu/drm/msm/msm_atomic.c
@@ -127,6 +127,26 @@ static void add_fb(struct msm_commit *c, struct drm_framebuffer *fb)
 }
 
 
+int msm_atomic_check(struct drm_device *dev,
+                     struct drm_atomic_state *state)
+{
+        int ret;
+
+        /*
+         * msm ->atomic_check can update ->mode_changed for pixel format
+         * changes, hence must be run before we check the modeset changes.
+         */
+        ret = drm_atomic_helper_check_planes(dev, state);
+        if (ret)
+                return ret;
+
+        ret = drm_atomic_helper_check_modeset(dev, state);
+        if (ret)
+                return ret;
+
+        return ret;
+}
+
 /**
  * drm_atomic_helper_commit - commit validated state object
  * @dev: DRM device
diff --git a/drivers/gpu/drm/msm/msm_drv.c b/drivers/gpu/drm/msm/msm_drv.c
index 9a61546a0b05..f1ebedde6346 100644
--- a/drivers/gpu/drm/msm/msm_drv.c
+++ b/drivers/gpu/drm/msm/msm_drv.c
@@ -29,7 +29,7 @@ static void msm_fb_output_poll_changed(struct drm_device *dev)
 static const struct drm_mode_config_funcs mode_config_funcs = {
         .fb_create = msm_framebuffer_create,
         .output_poll_changed = msm_fb_output_poll_changed,
-        .atomic_check = drm_atomic_helper_check,
+        .atomic_check = msm_atomic_check,
         .atomic_commit = msm_atomic_commit,
 };
 
diff --git a/drivers/gpu/drm/msm/msm_drv.h b/drivers/gpu/drm/msm/msm_drv.h
index b69ef2d5a26c..22e5391a7ce8 100644
--- a/drivers/gpu/drm/msm/msm_drv.h
+++ b/drivers/gpu/drm/msm/msm_drv.h
@@ -148,6 +148,8 @@ void __msm_fence_worker(struct work_struct *work);
                 (_cb)->func = _func;                         \
         } while (0)
 
+int msm_atomic_check(struct drm_device *dev,
+                     struct drm_atomic_state *state);
 int msm_atomic_commit(struct drm_device *dev,
                 struct drm_atomic_state *state, bool async);
 
diff --git a/include/drm/drmP.h b/include/drm/drmP.h
index a5f6a1f563c4..e928625a9da0 100644
--- a/include/drm/drmP.h
+++ b/include/drm/drmP.h
@@ -143,6 +143,7 @@ void drm_err(const char *format, ...);
 #define DRIVER_MODESET     0x2000
 #define DRIVER_PRIME       0x4000
 #define DRIVER_RENDER      0x8000
+#define DRIVER_ATOMIC      0x10000
 
 /***********************************************************************/
 /** \name Macros to make printk easier */
@@ -283,6 +284,8 @@ struct drm_file {
          * in the plane list
          */
         unsigned universal_planes:1;
+        /* true if client understands atomic properties */
+        unsigned atomic:1;
 
         struct pid *pid;
         kuid_t uid;
@@ -954,6 +957,7 @@ extern void drm_master_put(struct drm_master **master);
 extern void drm_put_dev(struct drm_device *dev);
 extern void drm_unplug_dev(struct drm_device *dev);
 extern unsigned int drm_debug;
+extern bool drm_atomic;
 
                                 /* Debugfs support */
 #if defined(CONFIG_DEBUG_FS)
diff --git a/include/drm/drm_atomic.h b/include/drm/drm_atomic.h
index ad2229574dd9..51168a8b723a 100644
--- a/include/drm/drm_atomic.h
+++ b/include/drm/drm_atomic.h
@@ -38,16 +38,25 @@ void drm_atomic_state_free(struct drm_atomic_state *state);
 struct drm_crtc_state * __must_check
 drm_atomic_get_crtc_state(struct drm_atomic_state *state,
                           struct drm_crtc *crtc);
+int drm_atomic_crtc_set_property(struct drm_crtc *crtc,
+                struct drm_crtc_state *state, struct drm_property *property,
+                uint64_t val);
 struct drm_plane_state * __must_check
 drm_atomic_get_plane_state(struct drm_atomic_state *state,
                            struct drm_plane *plane);
+int drm_atomic_plane_set_property(struct drm_plane *plane,
+                struct drm_plane_state *state, struct drm_property *property,
+                uint64_t val);
 struct drm_connector_state * __must_check
 drm_atomic_get_connector_state(struct drm_atomic_state *state,
                                struct drm_connector *connector);
+int drm_atomic_connector_set_property(struct drm_connector *connector,
+                struct drm_connector_state *state, struct drm_property *property,
+                uint64_t val);
 
 int __must_check
-drm_atomic_set_crtc_for_plane(struct drm_atomic_state *state,
-                              struct drm_plane *plane, struct drm_crtc *crtc);
+drm_atomic_set_crtc_for_plane(struct drm_plane_state *plane_state,
+                              struct drm_crtc *crtc);
 void drm_atomic_set_fb_for_plane(struct drm_plane_state *plane_state,
                                  struct drm_framebuffer *fb);
 int __must_check
diff --git a/include/drm/drm_atomic_helper.h b/include/drm/drm_atomic_helper.h
index f956b413311e..2095917ff8c7 100644
--- a/include/drm/drm_atomic_helper.h
+++ b/include/drm/drm_atomic_helper.h
@@ -30,6 +30,10 @@
 
 #include <drm/drm_crtc.h>
 
+int drm_atomic_helper_check_modeset(struct drm_device *dev,
+                                struct drm_atomic_state *state);
+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);
 int drm_atomic_helper_commit(struct drm_device *dev,
diff --git a/include/drm/drm_crtc.h b/include/drm/drm_crtc.h
index 291239f2fafc..6588bffb6518 100644
--- a/include/drm/drm_crtc.h
+++ b/include/drm/drm_crtc.h
@@ -63,8 +63,16 @@ struct drm_mode_object {
 
 #define DRM_OBJECT_MAX_PROPERTY 24
 struct drm_object_properties {
-        int count;
-        uint32_t ids[DRM_OBJECT_MAX_PROPERTY];
+        int count, atomic_count;
+        /* NOTE: if we ever start dynamically destroying properties (ie.
+         * not at drm_mode_config_cleanup() time), then we'd have to do
+         * a better job of detaching property from mode objects to avoid
+         * dangling property pointers:
+         */
+        struct drm_property *properties[DRM_OBJECT_MAX_PROPERTY];
+        /* do not read/write values directly, but use drm_object_property_get_value()
+         * and drm_object_property_set_value():
+         */
         uint64_t values[DRM_OBJECT_MAX_PROPERTY];
 };
 
@@ -237,7 +245,9 @@ struct drm_atomic_state;
 
 /**
  * struct drm_crtc_state - mutable CRTC state
+ * @crtc: backpointer to the CRTC
  * @enable: whether the CRTC should be enabled, gates all other state
+ * @active: whether the CRTC is actively displaying (used for DPMS)
  * @mode_changed: for use by helpers and drivers when computing state updates
  * @plane_mask: bitmask of (1 << drm_plane_index(plane)) of attached planes
  * @last_vblank_count: for helpers and drivers to capture the vblank of the
@@ -248,9 +258,18 @@ struct drm_atomic_state;
  * @event: optional pointer to a DRM event to signal upon completion of the
  *      state update
  * @state: backpointer to global drm_atomic_state
+ *
+ * Note that the distinction between @enable and @active is rather subtile:
+ * Flipping @active while @enable is set without changing anything else may
+ * never return in a failure from the ->atomic_check callback. Userspace assumes
+ * that a DPMS On will always succeed. In other words: @enable controls resource
+ * assignment, @active controls the actual hardware state.
  */
 struct drm_crtc_state {
+        struct drm_crtc *crtc;
+
         bool enable;
+        bool active;
 
         /* computed state bits used by helpers and drivers */
         bool planes_changed : 1;
@@ -292,6 +311,9 @@ struct drm_crtc_state {
  * @atomic_duplicate_state: duplicate the atomic state for this CRTC
  * @atomic_destroy_state: destroy an atomic state for this CRTC
  * @atomic_set_property: set a property on an atomic state for this CRTC
+ *    (do not call directly, use drm_atomic_crtc_set_property())
+ * @atomic_get_property: get a property on an atomic state for this CRTC
+ *    (do not call directly, use drm_atomic_crtc_get_property())
  *
  * The drm_crtc_funcs structure is the central CRTC management structure
  * in the DRM.  Each CRTC controls one or more connectors (note that the name
@@ -351,6 +373,10 @@ struct drm_crtc_funcs {
                                    struct drm_crtc_state *state,
                                    struct drm_property *property,
                                    uint64_t val);
+        int (*atomic_get_property)(struct drm_crtc *crtc,
+                                   const struct drm_crtc_state *state,
+                                   struct drm_property *property,
+                                   uint64_t *val);
 };
 
 /**
@@ -449,11 +475,14 @@ struct drm_crtc {
 
 /**
  * struct drm_connector_state - mutable connector state
+ * @connector: backpointer to the connector
  * @crtc: CRTC to connect connector to, NULL if disabled
  * @best_encoder: can be used by helpers and drivers to select the encoder
  * @state: backpointer to global drm_atomic_state
  */
 struct drm_connector_state {
+        struct drm_connector *connector;
+
         struct drm_crtc *crtc;  /* do not write directly, use drm_atomic_set_crtc_for_connector() */
 
         struct drm_encoder *best_encoder;
@@ -475,6 +504,9 @@ struct drm_connector_state {
  * @atomic_duplicate_state: duplicate the atomic state for this connector
  * @atomic_destroy_state: destroy an atomic state for this connector
  * @atomic_set_property: set a property on an atomic state for this connector
+ *    (do not call directly, use drm_atomic_connector_set_property())
+ * @atomic_get_property: get a property on an atomic state for this connector
+ *    (do not call directly, use drm_atomic_connector_get_property())
  *
  * Each CRTC may have one or more connectors attached to it.  The functions
  * below allow the core DRM code to control connectors, enumerate available modes,
@@ -508,6 +540,10 @@ struct drm_connector_funcs {
                                    struct drm_connector_state *state,
                                    struct drm_property *property,
                                    uint64_t val);
+        int (*atomic_get_property)(struct drm_connector *connector,
+                                   const struct drm_connector_state *state,
+                                   struct drm_property *property,
+                                   uint64_t *val);
 };
 
 /**
@@ -693,6 +729,7 @@ struct drm_connector {
 
 /**
  * struct drm_plane_state - mutable plane state
+ * @plane: backpointer to the plane
  * @crtc: currently bound CRTC, NULL if disabled
  * @fb: currently bound framebuffer
  * @fence: optional fence to wait for before scanning out @fb
@@ -709,6 +746,8 @@ struct drm_connector {
  * @state: backpointer to global drm_atomic_state
  */
 struct drm_plane_state {
+        struct drm_plane *plane;
+
         struct drm_crtc *crtc;   /* do not write directly, use drm_atomic_set_crtc_for_plane() */
         struct drm_framebuffer *fb;  /* do not write directly, use drm_atomic_set_fb_for_plane() */
         struct fence *fence;
@@ -735,6 +774,9 @@ struct drm_plane_state {
  * @atomic_duplicate_state: duplicate the atomic state for this plane
  * @atomic_destroy_state: destroy an atomic state for this plane
  * @atomic_set_property: set a property on an atomic state for this plane
+ *    (do not call directly, use drm_atomic_plane_set_property())
+ * @atomic_get_property: get a property on an atomic state for this plane
+ *    (do not call directly, use drm_atomic_plane_get_property())
  */
 struct drm_plane_funcs {
         int (*update_plane)(struct drm_plane *plane,
@@ -758,6 +800,10 @@ struct drm_plane_funcs {
                                    struct drm_plane_state *state,
                                    struct drm_property *property,
                                    uint64_t val);
+        int (*atomic_get_property)(struct drm_plane *plane,
+                                   const struct drm_plane_state *state,
+                                   struct drm_property *property,
+                                   uint64_t *val);
 };
 
 enum drm_plane_type {
@@ -856,7 +902,7 @@ struct drm_bridge {
 /**
  * struct struct drm_atomic_state - the global state object for atomic updates
  * @dev: parent DRM device
- * @flags: state flags like async update
+ * @allow_modeset: allow full modeset
  * @planes: pointer to array of plane pointers
  * @plane_states: pointer to array of plane states pointers
  * @crtcs: pointer to array of CRTC pointers
@@ -868,7 +914,7 @@ struct drm_bridge {
  */
 struct drm_atomic_state {
         struct drm_device *dev;
-        uint32_t flags;
+        bool allow_modeset : 1;
         struct drm_plane **planes;
         struct drm_plane_state **plane_states;
         struct drm_crtc **crtcs;
@@ -1053,6 +1099,16 @@ struct drm_mode_config {
         struct drm_property *tile_property;
         struct drm_property *plane_type_property;
         struct drm_property *rotation_property;
+        struct drm_property *prop_src_x;
+        struct drm_property *prop_src_y;
+        struct drm_property *prop_src_w;
+        struct drm_property *prop_src_h;
+        struct drm_property *prop_crtc_x;
+        struct drm_property *prop_crtc_y;
+        struct drm_property *prop_crtc_w;
+        struct drm_property *prop_crtc_h;
+        struct drm_property *prop_fb_id;
+        struct drm_property *prop_crtc_id;
 
         /* DVI-I properties */
         struct drm_property *dvi_i_subconnector_property;
@@ -1290,6 +1346,10 @@ extern int drm_mode_create_scaling_mode_property(struct drm_device *dev);
 extern int drm_mode_create_aspect_ratio_property(struct drm_device *dev);
 extern int drm_mode_create_dirty_info_property(struct drm_device *dev);
 extern int drm_mode_create_suggested_offset_properties(struct drm_device *dev);
+extern bool drm_property_change_valid_get(struct drm_property *property,
+                                         uint64_t value, struct drm_mode_object **ref);
+extern void drm_property_change_valid_put(struct drm_property *property,
+                struct drm_mode_object *ref);
 
 extern int drm_mode_connector_attach_encoder(struct drm_connector *connector,
                                              struct drm_encoder *encoder);
@@ -1381,6 +1441,8 @@ extern int drm_mode_obj_set_property_ioctl(struct drm_device *dev, void *data,
 extern int drm_mode_plane_set_obj_prop(struct drm_plane *plane,
                                        struct drm_property *property,
                                        uint64_t value);
+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);
diff --git a/include/uapi/drm/drm.h b/include/uapi/drm/drm.h
index b0b855613641..01b2d6d0e355 100644
--- a/include/uapi/drm/drm.h
+++ b/include/uapi/drm/drm.h
@@ -654,6 +654,13 @@ struct drm_get_cap {
  */
 #define DRM_CLIENT_CAP_UNIVERSAL_PLANES  2
 
+/**
+ * DRM_CLIENT_CAP_ATOMIC
+ *
+ * If set to 1, the DRM core will expose atomic properties to userspace
+ */
+#define DRM_CLIENT_CAP_ATOMIC   3
+
 /** DRM_IOCTL_SET_CLIENT_CAP ioctl argument type */
 struct drm_set_client_cap {
         __u64 capability;
@@ -777,6 +784,7 @@ struct drm_prime_handle {
 #define DRM_IOCTL_MODE_OBJ_GETPROPERTIES        DRM_IOWR(0xB9, struct drm_mode_obj_get_properties)
 #define DRM_IOCTL_MODE_OBJ_SETPROPERTY  DRM_IOWR(0xBA, struct drm_mode_obj_set_property)
 #define DRM_IOCTL_MODE_CURSOR2          DRM_IOWR(0xBB, struct drm_mode_cursor2)
+#define DRM_IOCTL_MODE_ATOMIC           DRM_IOWR(0xBC, struct drm_mode_atomic)
 
 /**
  * Device specific ioctls should only be in their respective headers
diff --git a/include/uapi/drm/drm_mode.h b/include/uapi/drm/drm_mode.h
index aae71cb32123..ca788e01dab2 100644
--- a/include/uapi/drm/drm_mode.h
+++ b/include/uapi/drm/drm_mode.h
@@ -272,6 +272,13 @@ struct drm_mode_get_connector {
 #define DRM_MODE_PROP_OBJECT            DRM_MODE_PROP_TYPE(1)
 #define DRM_MODE_PROP_SIGNED_RANGE      DRM_MODE_PROP_TYPE(2)
 
+/* the PROP_ATOMIC flag is used to hide properties from userspace that
+ * is not aware of atomic properties.  This is mostly to work around
+ * older userspace (DDX drivers) that read/write each prop they find,
+ * witout being aware that this could be triggering a lengthy modeset.
+ */
+#define DRM_MODE_PROP_ATOMIC        0x80000000
+
 struct drm_mode_property_enum {
         __u64 value;
         char name[DRM_PROP_NAME_LEN];
@@ -519,4 +526,27 @@ struct drm_mode_destroy_dumb {
         uint32_t handle;
 };
 
+/* page-flip flags are valid, plus: */
+#define DRM_MODE_ATOMIC_TEST_ONLY 0x0100
+#define DRM_MODE_ATOMIC_NONBLOCK  0x0200
+#define DRM_MODE_ATOMIC_ALLOW_MODESET 0x0400
+
+#define DRM_MODE_ATOMIC_FLAGS (\
+                DRM_MODE_PAGE_FLIP_EVENT |\
+                DRM_MODE_PAGE_FLIP_ASYNC |\
+                DRM_MODE_ATOMIC_TEST_ONLY |\
+                DRM_MODE_ATOMIC_NONBLOCK |\
+                DRM_MODE_ATOMIC_ALLOW_MODESET)
+
+struct drm_mode_atomic {
+        __u32 flags;
+        __u32 count_objs;
+        __u64 objs_ptr;
+        __u64 count_props_ptr;
+        __u64 props_ptr;
+        __u64 prop_values_ptr;
+        __u64 reserved;
+        __u64 user_data;
+};
+
 #endif