[03/18] drm: Extract drm_atomic_state_helper.[hc]
diff mbox series

Message ID 20181002133526.13685-4-daniel.vetter@ffwll.ch
State New
Headers show
Series
  • atomic helper cleanups
Related show

Commit Message

Daniel Vetter Oct. 2, 2018, 1:35 p.m. UTC
We already have a separate overview doc for this, makes sense to
untangle it from the overall atomic helpers.

v2: Rebase

v3: Rebase more.

Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
---
 Documentation/gpu/drm-kms-helpers.rst     |  19 +-
 drivers/gpu/drm/Makefile                  |   3 +-
 drivers/gpu/drm/drm_atomic_helper.c       | 566 --------------------
 drivers/gpu/drm/drm_atomic_state_helper.c | 601 ++++++++++++++++++++++
 include/drm/drm_atomic_helper.h           |  44 +-
 include/drm/drm_atomic_state_helper.h     |  80 +++
 6 files changed, 698 insertions(+), 615 deletions(-)
 create mode 100644 drivers/gpu/drm/drm_atomic_state_helper.c
 create mode 100644 include/drm/drm_atomic_state_helper.h

Comments

Ville Syrjälä Oct. 2, 2018, 3:40 p.m. UTC | #1
On Tue, Oct 02, 2018 at 03:35:11PM +0200, Daniel Vetter wrote:
> We already have a separate overview doc for this, makes sense to
> untangle it from the overall atomic helpers.
> 
> v2: Rebase
> 
> v3: Rebase more.

Hopefully the rebases didn't leave any code changes behind...

Too lazy to read in full detail so
Acked-by: Ville Syrjälä <ville.syrjala@linux.intel.com>

> 
> Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
> ---
>  Documentation/gpu/drm-kms-helpers.rst     |  19 +-
>  drivers/gpu/drm/Makefile                  |   3 +-
>  drivers/gpu/drm/drm_atomic_helper.c       | 566 --------------------
>  drivers/gpu/drm/drm_atomic_state_helper.c | 601 ++++++++++++++++++++++
>  include/drm/drm_atomic_helper.h           |  44 +-
>  include/drm/drm_atomic_state_helper.h     |  80 +++
>  6 files changed, 698 insertions(+), 615 deletions(-)
>  create mode 100644 drivers/gpu/drm/drm_atomic_state_helper.c
>  create mode 100644 include/drm/drm_atomic_state_helper.h
> 
> diff --git a/Documentation/gpu/drm-kms-helpers.rst b/Documentation/gpu/drm-kms-helpers.rst
> index f9cfcdcdf024..4b4dc236ef6f 100644
> --- a/Documentation/gpu/drm-kms-helpers.rst
> +++ b/Documentation/gpu/drm-kms-helpers.rst
> @@ -59,19 +59,28 @@ Implementing Asynchronous Atomic Commit
>  .. kernel-doc:: drivers/gpu/drm/drm_atomic_helper.c
>     :doc: implementing nonblocking commit
>  
> +Helper Functions Reference
> +--------------------------
> +
> +.. kernel-doc:: include/drm/drm_atomic_helper.h
> +   :internal:
> +
> +.. kernel-doc:: drivers/gpu/drm/drm_atomic_helper.c
> +   :export:
> +
>  Atomic State Reset and Initialization
>  -------------------------------------
>  
> -.. kernel-doc:: drivers/gpu/drm/drm_atomic_helper.c
> +.. kernel-doc:: drivers/gpu/drm/drm_atomic_state_helper.c
>     :doc: atomic state reset and initialization
>  
> -Helper Functions Reference
> ---------------------------
> +Atomic State Helper Reference
> +-----------------------------
>  
> -.. kernel-doc:: include/drm/drm_atomic_helper.h
> +.. kernel-doc:: include/drm/drm_atomic_state_helper.h
>     :internal:
>  
> -.. kernel-doc:: drivers/gpu/drm/drm_atomic_helper.c
> +.. kernel-doc:: drivers/gpu/drm/drm_atomic_state_helper.c
>     :export:
>  
>  Simple KMS Helper Reference
> diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile
> index bc6a16a3c36e..576ba985e138 100644
> --- a/drivers/gpu/drm/Makefile
> +++ b/drivers/gpu/drm/Makefile
> @@ -36,7 +36,8 @@ drm_kms_helper-y := drm_crtc_helper.o drm_dp_helper.o drm_probe_helper.o \
>  		drm_plane_helper.o drm_dp_mst_topology.o drm_atomic_helper.o \
>  		drm_kms_helper_common.o drm_dp_dual_mode_helper.o \
>  		drm_simple_kms_helper.o drm_modeset_helper.o \
> -		drm_scdc_helper.o drm_gem_framebuffer_helper.o
> +		drm_scdc_helper.o drm_gem_framebuffer_helper.o \
> +		drm_atomic_state_helper.o
>  
>  drm_kms_helper-$(CONFIG_DRM_PANEL_BRIDGE) += bridge/panel.o
>  drm_kms_helper-$(CONFIG_DRM_FBDEV_EMULATION) += drm_fb_helper.o
> diff --git a/drivers/gpu/drm/drm_atomic_helper.c b/drivers/gpu/drm/drm_atomic_helper.c
> index 8c93f33fe92f..a5edc8757056 100644
> --- a/drivers/gpu/drm/drm_atomic_helper.c
> +++ b/drivers/gpu/drm/drm_atomic_helper.c
> @@ -3382,569 +3382,3 @@ int drm_atomic_helper_page_flip_target(struct drm_crtc *crtc,
>  	return ret;
>  }
>  EXPORT_SYMBOL(drm_atomic_helper_page_flip_target);
> -
> -/**
> - * DOC: atomic state reset and initialization
> - *
> - * Both the drm core and the atomic helpers assume that there is always the full
> - * and correct atomic software state for all connectors, CRTCs and planes
> - * available. Which is a bit a problem on driver load and also after system
> - * suspend. One way to solve this is to have a hardware state read-out
> - * infrastructure which reconstructs the full software state (e.g. the i915
> - * driver).
> - *
> - * The simpler solution is to just reset the software state to everything off,
> - * which is easiest to do by calling drm_mode_config_reset(). To facilitate this
> - * the atomic helpers provide default reset implementations for all hooks.
> - *
> - * On the upside the precise state tracking of atomic simplifies system suspend
> - * and resume a lot. For drivers using drm_mode_config_reset() a complete recipe
> - * is implemented in drm_atomic_helper_suspend() and drm_atomic_helper_resume().
> - * For other drivers the building blocks are split out, see the documentation
> - * for these functions.
> - */
> -
> -/**
> - * drm_atomic_helper_crtc_reset - default &drm_crtc_funcs.reset hook for CRTCs
> - * @crtc: drm CRTC
> - *
> - * Resets the atomic state for @crtc by freeing the state pointer (which might
> - * be NULL, e.g. at driver load time) and allocating a new empty state object.
> - */
> -void drm_atomic_helper_crtc_reset(struct drm_crtc *crtc)
> -{
> -	if (crtc->state)
> -		__drm_atomic_helper_crtc_destroy_state(crtc->state);
> -
> -	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);
> -
> -/**
> - * __drm_atomic_helper_crtc_duplicate_state - copy atomic CRTC state
> - * @crtc: CRTC object
> - * @state: atomic CRTC state
> - *
> - * Copies atomic state from a CRTC's current state and resets inferred values.
> - * This is useful for drivers that subclass the CRTC state.
> - */
> -void __drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc,
> -					      struct drm_crtc_state *state)
> -{
> -	memcpy(state, crtc->state, sizeof(*state));
> -
> -	if (state->mode_blob)
> -		drm_property_blob_get(state->mode_blob);
> -	if (state->degamma_lut)
> -		drm_property_blob_get(state->degamma_lut);
> -	if (state->ctm)
> -		drm_property_blob_get(state->ctm);
> -	if (state->gamma_lut)
> -		drm_property_blob_get(state->gamma_lut);
> -	state->mode_changed = false;
> -	state->active_changed = false;
> -	state->planes_changed = false;
> -	state->connectors_changed = false;
> -	state->color_mgmt_changed = false;
> -	state->zpos_changed = false;
> -	state->commit = NULL;
> -	state->event = NULL;
> -	state->pageflip_flags = 0;
> -}
> -EXPORT_SYMBOL(__drm_atomic_helper_crtc_duplicate_state);
> -
> -/**
> - * drm_atomic_helper_crtc_duplicate_state - default state duplicate hook
> - * @crtc: drm CRTC
> - *
> - * Default CRTC state duplicate hook for drivers which don't have their own
> - * subclassed CRTC state structure.
> - */
> -struct drm_crtc_state *
> -drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc)
> -{
> -	struct drm_crtc_state *state;
> -
> -	if (WARN_ON(!crtc->state))
> -		return NULL;
> -
> -	state = kmalloc(sizeof(*state), GFP_KERNEL);
> -	if (state)
> -		__drm_atomic_helper_crtc_duplicate_state(crtc, state);
> -
> -	return state;
> -}
> -EXPORT_SYMBOL(drm_atomic_helper_crtc_duplicate_state);
> -
> -/**
> - * __drm_atomic_helper_crtc_destroy_state - release CRTC state
> - * @state: CRTC state object to release
> - *
> - * Releases all resources stored in the CRTC state without actually freeing
> - * the memory of the CRTC state. This is useful for drivers that subclass the
> - * CRTC state.
> - */
> -void __drm_atomic_helper_crtc_destroy_state(struct drm_crtc_state *state)
> -{
> -	if (state->commit) {
> -		/*
> -		 * In the event that a non-blocking commit returns
> -		 * -ERESTARTSYS before the commit_tail work is queued, we will
> -		 * have an extra reference to the commit object. Release it, if
> -		 * the event has not been consumed by the worker.
> -		 *
> -		 * state->event may be freed, so we can't directly look at
> -		 * state->event->base.completion.
> -		 */
> -		if (state->event && state->commit->abort_completion)
> -			drm_crtc_commit_put(state->commit);
> -
> -		kfree(state->commit->event);
> -		state->commit->event = NULL;
> -
> -		drm_crtc_commit_put(state->commit);
> -	}
> -
> -	drm_property_blob_put(state->mode_blob);
> -	drm_property_blob_put(state->degamma_lut);
> -	drm_property_blob_put(state->ctm);
> -	drm_property_blob_put(state->gamma_lut);
> -}
> -EXPORT_SYMBOL(__drm_atomic_helper_crtc_destroy_state);
> -
> -/**
> - * drm_atomic_helper_crtc_destroy_state - default state destroy hook
> - * @crtc: drm CRTC
> - * @state: CRTC state object to release
> - *
> - * Default CRTC state destroy hook for drivers which don't have their own
> - * subclassed CRTC state structure.
> - */
> -void drm_atomic_helper_crtc_destroy_state(struct drm_crtc *crtc,
> -					  struct drm_crtc_state *state)
> -{
> -	__drm_atomic_helper_crtc_destroy_state(state);
> -	kfree(state);
> -}
> -EXPORT_SYMBOL(drm_atomic_helper_crtc_destroy_state);
> -
> -/**
> - * __drm_atomic_helper_plane_reset - resets planes state to default values
> - * @plane: plane object, must not be NULL
> - * @state: atomic plane state, must not be NULL
> - *
> - * Initializes plane state to default. This is useful for drivers that subclass
> - * the plane state.
> - */
> -void __drm_atomic_helper_plane_reset(struct drm_plane *plane,
> -				     struct drm_plane_state *state)
> -{
> -	state->plane = plane;
> -	state->rotation = DRM_MODE_ROTATE_0;
> -
> -	state->alpha = DRM_BLEND_ALPHA_OPAQUE;
> -	state->pixel_blend_mode = DRM_MODE_BLEND_PREMULTI;
> -
> -	plane->state = state;
> -}
> -EXPORT_SYMBOL(__drm_atomic_helper_plane_reset);
> -
> -/**
> - * drm_atomic_helper_plane_reset - default &drm_plane_funcs.reset hook for planes
> - * @plane: drm plane
> - *
> - * Resets the atomic state for @plane by freeing the state pointer (which might
> - * be NULL, e.g. at driver load time) and allocating a new empty state object.
> - */
> -void drm_atomic_helper_plane_reset(struct drm_plane *plane)
> -{
> -	if (plane->state)
> -		__drm_atomic_helper_plane_destroy_state(plane->state);
> -
> -	kfree(plane->state);
> -	plane->state = kzalloc(sizeof(*plane->state), GFP_KERNEL);
> -	if (plane->state)
> -		__drm_atomic_helper_plane_reset(plane, plane->state);
> -}
> -EXPORT_SYMBOL(drm_atomic_helper_plane_reset);
> -
> -/**
> - * __drm_atomic_helper_plane_duplicate_state - copy atomic plane state
> - * @plane: plane object
> - * @state: atomic plane state
> - *
> - * Copies atomic state from a plane's current state. This is useful for
> - * drivers that subclass the plane state.
> - */
> -void __drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane,
> -					       struct drm_plane_state *state)
> -{
> -	memcpy(state, plane->state, sizeof(*state));
> -
> -	if (state->fb)
> -		drm_framebuffer_get(state->fb);
> -
> -	state->fence = NULL;
> -	state->commit = NULL;
> -}
> -EXPORT_SYMBOL(__drm_atomic_helper_plane_duplicate_state);
> -
> -/**
> - * drm_atomic_helper_plane_duplicate_state - default state duplicate hook
> - * @plane: drm plane
> - *
> - * Default plane state duplicate hook for drivers which don't have their own
> - * subclassed plane state structure.
> - */
> -struct drm_plane_state *
> -drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane)
> -{
> -	struct drm_plane_state *state;
> -
> -	if (WARN_ON(!plane->state))
> -		return NULL;
> -
> -	state = kmalloc(sizeof(*state), GFP_KERNEL);
> -	if (state)
> -		__drm_atomic_helper_plane_duplicate_state(plane, state);
> -
> -	return state;
> -}
> -EXPORT_SYMBOL(drm_atomic_helper_plane_duplicate_state);
> -
> -/**
> - * __drm_atomic_helper_plane_destroy_state - release plane state
> - * @state: plane state object to release
> - *
> - * Releases all resources stored in the plane state without actually freeing
> - * the memory of the plane state. This is useful for drivers that subclass the
> - * plane state.
> - */
> -void __drm_atomic_helper_plane_destroy_state(struct drm_plane_state *state)
> -{
> -	if (state->fb)
> -		drm_framebuffer_put(state->fb);
> -
> -	if (state->fence)
> -		dma_fence_put(state->fence);
> -
> -	if (state->commit)
> -		drm_crtc_commit_put(state->commit);
> -}
> -EXPORT_SYMBOL(__drm_atomic_helper_plane_destroy_state);
> -
> -/**
> - * drm_atomic_helper_plane_destroy_state - default state destroy hook
> - * @plane: drm plane
> - * @state: plane state object to release
> - *
> - * Default plane state destroy hook for drivers which don't have their own
> - * subclassed plane state structure.
> - */
> -void drm_atomic_helper_plane_destroy_state(struct drm_plane *plane,
> -					   struct drm_plane_state *state)
> -{
> -	__drm_atomic_helper_plane_destroy_state(state);
> -	kfree(state);
> -}
> -EXPORT_SYMBOL(drm_atomic_helper_plane_destroy_state);
> -
> -/**
> - * __drm_atomic_helper_connector_reset - reset state on connector
> - * @connector: drm connector
> - * @conn_state: connector state to assign
> - *
> - * Initializes the newly allocated @conn_state and assigns it to
> - * the &drm_conector->state pointer of @connector, usually required when
> - * initializing the drivers or when called from the &drm_connector_funcs.reset
> - * hook.
> - *
> - * This is useful for drivers that subclass the connector state.
> - */
> -void
> -__drm_atomic_helper_connector_reset(struct drm_connector *connector,
> -				    struct drm_connector_state *conn_state)
> -{
> -	if (conn_state)
> -		conn_state->connector = connector;
> -
> -	connector->state = conn_state;
> -}
> -EXPORT_SYMBOL(__drm_atomic_helper_connector_reset);
> -
> -/**
> - * drm_atomic_helper_connector_reset - default &drm_connector_funcs.reset hook for connectors
> - * @connector: drm connector
> - *
> - * Resets the atomic state for @connector by freeing the state pointer (which
> - * might be NULL, e.g. at driver load time) and allocating a new empty state
> - * object.
> - */
> -void drm_atomic_helper_connector_reset(struct drm_connector *connector)
> -{
> -	struct drm_connector_state *conn_state =
> -		kzalloc(sizeof(*conn_state), GFP_KERNEL);
> -
> -	if (connector->state)
> -		__drm_atomic_helper_connector_destroy_state(connector->state);
> -
> -	kfree(connector->state);
> -	__drm_atomic_helper_connector_reset(connector, conn_state);
> -}
> -EXPORT_SYMBOL(drm_atomic_helper_connector_reset);
> -
> -/**
> - * __drm_atomic_helper_connector_duplicate_state - copy atomic connector state
> - * @connector: connector object
> - * @state: atomic connector state
> - *
> - * Copies atomic state from a connector's current state. This is useful for
> - * drivers that subclass the connector state.
> - */
> -void
> -__drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector,
> -					    struct drm_connector_state *state)
> -{
> -	memcpy(state, connector->state, sizeof(*state));
> -	if (state->crtc)
> -		drm_connector_get(connector);
> -	state->commit = NULL;
> -
> -	/* Don't copy over a writeback job, they are used only once */
> -	state->writeback_job = NULL;
> -}
> -EXPORT_SYMBOL(__drm_atomic_helper_connector_duplicate_state);
> -
> -/**
> - * drm_atomic_helper_connector_duplicate_state - default state duplicate hook
> - * @connector: drm connector
> - *
> - * Default connector state duplicate hook for drivers which don't have their own
> - * subclassed connector state structure.
> - */
> -struct drm_connector_state *
> -drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector)
> -{
> -	struct drm_connector_state *state;
> -
> -	if (WARN_ON(!connector->state))
> -		return NULL;
> -
> -	state = kmalloc(sizeof(*state), GFP_KERNEL);
> -	if (state)
> -		__drm_atomic_helper_connector_duplicate_state(connector, state);
> -
> -	return state;
> -}
> -EXPORT_SYMBOL(drm_atomic_helper_connector_duplicate_state);
> -
> -/**
> - * drm_atomic_helper_duplicate_state - duplicate an atomic state object
> - * @dev: DRM device
> - * @ctx: lock acquisition context
> - *
> - * Makes a copy of the current atomic state by looping over all objects and
> - * duplicating their respective states. This is used for example by suspend/
> - * resume support code to save the state prior to suspend such that it can
> - * be restored upon resume.
> - *
> - * Note that this treats atomic state as persistent between save and restore.
> - * Drivers must make sure that this is possible and won't result in confusion
> - * or erroneous behaviour.
> - *
> - * Note that if callers haven't already acquired all modeset locks this might
> - * return -EDEADLK, which must be handled by calling drm_modeset_backoff().
> - *
> - * Returns:
> - * A pointer to the copy of the atomic state object on success or an
> - * ERR_PTR()-encoded error code on failure.
> - *
> - * See also:
> - * drm_atomic_helper_suspend(), drm_atomic_helper_resume()
> - */
> -struct drm_atomic_state *
> -drm_atomic_helper_duplicate_state(struct drm_device *dev,
> -				  struct drm_modeset_acquire_ctx *ctx)
> -{
> -	struct drm_atomic_state *state;
> -	struct drm_connector *conn;
> -	struct drm_connector_list_iter conn_iter;
> -	struct drm_plane *plane;
> -	struct drm_crtc *crtc;
> -	int err = 0;
> -
> -	state = drm_atomic_state_alloc(dev);
> -	if (!state)
> -		return ERR_PTR(-ENOMEM);
> -
> -	state->acquire_ctx = ctx;
> -
> -	drm_for_each_crtc(crtc, dev) {
> -		struct drm_crtc_state *crtc_state;
> -
> -		crtc_state = drm_atomic_get_crtc_state(state, crtc);
> -		if (IS_ERR(crtc_state)) {
> -			err = PTR_ERR(crtc_state);
> -			goto free;
> -		}
> -	}
> -
> -	drm_for_each_plane(plane, dev) {
> -		struct drm_plane_state *plane_state;
> -
> -		plane_state = drm_atomic_get_plane_state(state, plane);
> -		if (IS_ERR(plane_state)) {
> -			err = PTR_ERR(plane_state);
> -			goto free;
> -		}
> -	}
> -
> -	drm_connector_list_iter_begin(dev, &conn_iter);
> -	drm_for_each_connector_iter(conn, &conn_iter) {
> -		struct drm_connector_state *conn_state;
> -
> -		conn_state = drm_atomic_get_connector_state(state, conn);
> -		if (IS_ERR(conn_state)) {
> -			err = PTR_ERR(conn_state);
> -			drm_connector_list_iter_end(&conn_iter);
> -			goto free;
> -		}
> -	}
> -	drm_connector_list_iter_end(&conn_iter);
> -
> -	/* clear the acquire context so that it isn't accidentally reused */
> -	state->acquire_ctx = NULL;
> -
> -free:
> -	if (err < 0) {
> -		drm_atomic_state_put(state);
> -		state = ERR_PTR(err);
> -	}
> -
> -	return state;
> -}
> -EXPORT_SYMBOL(drm_atomic_helper_duplicate_state);
> -
> -/**
> - * __drm_atomic_helper_connector_destroy_state - release connector state
> - * @state: connector state object to release
> - *
> - * Releases all resources stored in the connector state without actually
> - * freeing the memory of the connector state. This is useful for drivers that
> - * subclass the connector state.
> - */
> -void
> -__drm_atomic_helper_connector_destroy_state(struct drm_connector_state *state)
> -{
> -	if (state->crtc)
> -		drm_connector_put(state->connector);
> -
> -	if (state->commit)
> -		drm_crtc_commit_put(state->commit);
> -}
> -EXPORT_SYMBOL(__drm_atomic_helper_connector_destroy_state);
> -
> -/**
> - * drm_atomic_helper_connector_destroy_state - default state destroy hook
> - * @connector: drm connector
> - * @state: connector state object to release
> - *
> - * Default connector state destroy hook for drivers which don't have their own
> - * subclassed connector state structure.
> - */
> -void drm_atomic_helper_connector_destroy_state(struct drm_connector *connector,
> -					  struct drm_connector_state *state)
> -{
> -	__drm_atomic_helper_connector_destroy_state(state);
> -	kfree(state);
> -}
> -EXPORT_SYMBOL(drm_atomic_helper_connector_destroy_state);
> -
> -/**
> - * drm_atomic_helper_legacy_gamma_set - set the legacy gamma correction table
> - * @crtc: CRTC object
> - * @red: red correction table
> - * @green: green correction table
> - * @blue: green correction table
> - * @size: size of the tables
> - * @ctx: lock acquire context
> - *
> - * Implements support for legacy gamma correction table for drivers
> - * that support color management through the DEGAMMA_LUT/GAMMA_LUT
> - * properties. See drm_crtc_enable_color_mgmt() and the containing chapter for
> - * how the atomic color management and gamma tables work.
> - */
> -int drm_atomic_helper_legacy_gamma_set(struct drm_crtc *crtc,
> -				       u16 *red, u16 *green, u16 *blue,
> -				       uint32_t size,
> -				       struct drm_modeset_acquire_ctx *ctx)
> -{
> -	struct drm_device *dev = crtc->dev;
> -	struct drm_atomic_state *state;
> -	struct drm_crtc_state *crtc_state;
> -	struct drm_property_blob *blob = NULL;
> -	struct drm_color_lut *blob_data;
> -	int i, ret = 0;
> -	bool replaced;
> -
> -	state = drm_atomic_state_alloc(crtc->dev);
> -	if (!state)
> -		return -ENOMEM;
> -
> -	blob = drm_property_create_blob(dev,
> -					sizeof(struct drm_color_lut) * size,
> -					NULL);
> -	if (IS_ERR(blob)) {
> -		ret = PTR_ERR(blob);
> -		blob = NULL;
> -		goto fail;
> -	}
> -
> -	/* Prepare GAMMA_LUT with the legacy values. */
> -	blob_data = blob->data;
> -	for (i = 0; i < size; i++) {
> -		blob_data[i].red = red[i];
> -		blob_data[i].green = green[i];
> -		blob_data[i].blue = blue[i];
> -	}
> -
> -	state->acquire_ctx = ctx;
> -	crtc_state = drm_atomic_get_crtc_state(state, crtc);
> -	if (IS_ERR(crtc_state)) {
> -		ret = PTR_ERR(crtc_state);
> -		goto fail;
> -	}
> -
> -	/* Reset DEGAMMA_LUT and CTM properties. */
> -	replaced  = drm_property_replace_blob(&crtc_state->degamma_lut, NULL);
> -	replaced |= drm_property_replace_blob(&crtc_state->ctm, NULL);
> -	replaced |= drm_property_replace_blob(&crtc_state->gamma_lut, blob);
> -	crtc_state->color_mgmt_changed |= replaced;
> -
> -	ret = drm_atomic_commit(state);
> -
> -fail:
> -	drm_atomic_state_put(state);
> -	drm_property_blob_put(blob);
> -	return ret;
> -}
> -EXPORT_SYMBOL(drm_atomic_helper_legacy_gamma_set);
> -
> -/**
> - * __drm_atomic_helper_private_duplicate_state - copy atomic private state
> - * @obj: CRTC object
> - * @state: new private object state
> - *
> - * Copies atomic state from a private objects's current state and resets inferred values.
> - * This is useful for drivers that subclass the private state.
> - */
> -void __drm_atomic_helper_private_obj_duplicate_state(struct drm_private_obj *obj,
> -						     struct drm_private_state *state)
> -{
> -	memcpy(state, obj->state, sizeof(*state));
> -}
> -EXPORT_SYMBOL(__drm_atomic_helper_private_obj_duplicate_state);
> diff --git a/drivers/gpu/drm/drm_atomic_state_helper.c b/drivers/gpu/drm/drm_atomic_state_helper.c
> new file mode 100644
> index 000000000000..3ba996069d69
> --- /dev/null
> +++ b/drivers/gpu/drm/drm_atomic_state_helper.c
> @@ -0,0 +1,601 @@
> +/*
> + * Copyright (C) 2018 Intel Corp.
> + *
> + * Permission is hereby granted, free of charge, to any person obtaining a
> + * copy of this software and associated documentation files (the "Software"),
> + * to deal in the Software without restriction, including without limitation
> + * the rights to use, copy, modify, merge, publish, distribute, sublicense,
> + * and/or sell copies of the Software, and to permit persons to whom the
> + * Software is furnished to do so, subject to the following conditions:
> + *
> + * The above copyright notice and this permission notice shall be included in
> + * all copies or substantial portions of the Software.
> + *
> + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
> + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
> + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
> + * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
> + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
> + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
> + * OTHER DEALINGS IN THE SOFTWARE.
> + *
> + * Authors:
> + * Rob Clark <robdclark@gmail.com>
> + * Daniel Vetter <daniel.vetter@ffwll.ch>
> + */
> +
> +#include <drm/drm_atomic_state_helper.h>
> +#include <drm/drm_crtc.h>
> +#include <drm/drm_plane.h>
> +#include <drm/drm_connector.h>
> +#include <drm/drm_atomic.h>
> +#include <drm/drm_device.h>
> +
> +#include <linux/slab.h>
> +#include <linux/dma-fence.h>
> +
> +/**
> + * DOC: atomic state reset and initialization
> + *
> + * Both the drm core and the atomic helpers assume that there is always the full
> + * and correct atomic software state for all connectors, CRTCs and planes
> + * available. Which is a bit a problem on driver load and also after system
> + * suspend. One way to solve this is to have a hardware state read-out
> + * infrastructure which reconstructs the full software state (e.g. the i915
> + * driver).
> + *
> + * The simpler solution is to just reset the software state to everything off,
> + * which is easiest to do by calling drm_mode_config_reset(). To facilitate this
> + * the atomic helpers provide default reset implementations for all hooks.
> + *
> + * On the upside the precise state tracking of atomic simplifies system suspend
> + * and resume a lot. For drivers using drm_mode_config_reset() a complete recipe
> + * is implemented in drm_atomic_helper_suspend() and drm_atomic_helper_resume().
> + * For other drivers the building blocks are split out, see the documentation
> + * for these functions.
> + */
> +
> +/**
> + * drm_atomic_helper_crtc_reset - default &drm_crtc_funcs.reset hook for CRTCs
> + * @crtc: drm CRTC
> + *
> + * Resets the atomic state for @crtc by freeing the state pointer (which might
> + * be NULL, e.g. at driver load time) and allocating a new empty state object.
> + */
> +void drm_atomic_helper_crtc_reset(struct drm_crtc *crtc)
> +{
> +	if (crtc->state)
> +		__drm_atomic_helper_crtc_destroy_state(crtc->state);
> +
> +	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);
> +
> +/**
> + * __drm_atomic_helper_crtc_duplicate_state - copy atomic CRTC state
> + * @crtc: CRTC object
> + * @state: atomic CRTC state
> + *
> + * Copies atomic state from a CRTC's current state and resets inferred values.
> + * This is useful for drivers that subclass the CRTC state.
> + */
> +void __drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc,
> +					      struct drm_crtc_state *state)
> +{
> +	memcpy(state, crtc->state, sizeof(*state));
> +
> +	if (state->mode_blob)
> +		drm_property_blob_get(state->mode_blob);
> +	if (state->degamma_lut)
> +		drm_property_blob_get(state->degamma_lut);
> +	if (state->ctm)
> +		drm_property_blob_get(state->ctm);
> +	if (state->gamma_lut)
> +		drm_property_blob_get(state->gamma_lut);
> +	state->mode_changed = false;
> +	state->active_changed = false;
> +	state->planes_changed = false;
> +	state->connectors_changed = false;
> +	state->color_mgmt_changed = false;
> +	state->zpos_changed = false;
> +	state->commit = NULL;
> +	state->event = NULL;
> +	state->pageflip_flags = 0;
> +}
> +EXPORT_SYMBOL(__drm_atomic_helper_crtc_duplicate_state);
> +
> +/**
> + * drm_atomic_helper_crtc_duplicate_state - default state duplicate hook
> + * @crtc: drm CRTC
> + *
> + * Default CRTC state duplicate hook for drivers which don't have their own
> + * subclassed CRTC state structure.
> + */
> +struct drm_crtc_state *
> +drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc)
> +{
> +	struct drm_crtc_state *state;
> +
> +	if (WARN_ON(!crtc->state))
> +		return NULL;
> +
> +	state = kmalloc(sizeof(*state), GFP_KERNEL);
> +	if (state)
> +		__drm_atomic_helper_crtc_duplicate_state(crtc, state);
> +
> +	return state;
> +}
> +EXPORT_SYMBOL(drm_atomic_helper_crtc_duplicate_state);
> +
> +/**
> + * __drm_atomic_helper_crtc_destroy_state - release CRTC state
> + * @state: CRTC state object to release
> + *
> + * Releases all resources stored in the CRTC state without actually freeing
> + * the memory of the CRTC state. This is useful for drivers that subclass the
> + * CRTC state.
> + */
> +void __drm_atomic_helper_crtc_destroy_state(struct drm_crtc_state *state)
> +{
> +	if (state->commit) {
> +		/*
> +		 * In the event that a non-blocking commit returns
> +		 * -ERESTARTSYS before the commit_tail work is queued, we will
> +		 * have an extra reference to the commit object. Release it, if
> +		 * the event has not been consumed by the worker.
> +		 *
> +		 * state->event may be freed, so we can't directly look at
> +		 * state->event->base.completion.
> +		 */
> +		if (state->event && state->commit->abort_completion)
> +			drm_crtc_commit_put(state->commit);
> +
> +		kfree(state->commit->event);
> +		state->commit->event = NULL;
> +
> +		drm_crtc_commit_put(state->commit);
> +	}
> +
> +	drm_property_blob_put(state->mode_blob);
> +	drm_property_blob_put(state->degamma_lut);
> +	drm_property_blob_put(state->ctm);
> +	drm_property_blob_put(state->gamma_lut);
> +}
> +EXPORT_SYMBOL(__drm_atomic_helper_crtc_destroy_state);
> +
> +/**
> + * drm_atomic_helper_crtc_destroy_state - default state destroy hook
> + * @crtc: drm CRTC
> + * @state: CRTC state object to release
> + *
> + * Default CRTC state destroy hook for drivers which don't have their own
> + * subclassed CRTC state structure.
> + */
> +void drm_atomic_helper_crtc_destroy_state(struct drm_crtc *crtc,
> +					  struct drm_crtc_state *state)
> +{
> +	__drm_atomic_helper_crtc_destroy_state(state);
> +	kfree(state);
> +}
> +EXPORT_SYMBOL(drm_atomic_helper_crtc_destroy_state);
> +
> +/**
> + * __drm_atomic_helper_plane_reset - resets planes state to default values
> + * @plane: plane object, must not be NULL
> + * @state: atomic plane state, must not be NULL
> + *
> + * Initializes plane state to default. This is useful for drivers that subclass
> + * the plane state.
> + */
> +void __drm_atomic_helper_plane_reset(struct drm_plane *plane,
> +				     struct drm_plane_state *state)
> +{
> +	state->plane = plane;
> +	state->rotation = DRM_MODE_ROTATE_0;
> +
> +	state->alpha = DRM_BLEND_ALPHA_OPAQUE;
> +	state->pixel_blend_mode = DRM_MODE_BLEND_PREMULTI;
> +
> +	plane->state = state;
> +}
> +EXPORT_SYMBOL(__drm_atomic_helper_plane_reset);
> +
> +/**
> + * drm_atomic_helper_plane_reset - default &drm_plane_funcs.reset hook for planes
> + * @plane: drm plane
> + *
> + * Resets the atomic state for @plane by freeing the state pointer (which might
> + * be NULL, e.g. at driver load time) and allocating a new empty state object.
> + */
> +void drm_atomic_helper_plane_reset(struct drm_plane *plane)
> +{
> +	if (plane->state)
> +		__drm_atomic_helper_plane_destroy_state(plane->state);
> +
> +	kfree(plane->state);
> +	plane->state = kzalloc(sizeof(*plane->state), GFP_KERNEL);
> +	if (plane->state)
> +		__drm_atomic_helper_plane_reset(plane, plane->state);
> +}
> +EXPORT_SYMBOL(drm_atomic_helper_plane_reset);
> +
> +/**
> + * __drm_atomic_helper_plane_duplicate_state - copy atomic plane state
> + * @plane: plane object
> + * @state: atomic plane state
> + *
> + * Copies atomic state from a plane's current state. This is useful for
> + * drivers that subclass the plane state.
> + */
> +void __drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane,
> +					       struct drm_plane_state *state)
> +{
> +	memcpy(state, plane->state, sizeof(*state));
> +
> +	if (state->fb)
> +		drm_framebuffer_get(state->fb);
> +
> +	state->fence = NULL;
> +	state->commit = NULL;
> +}
> +EXPORT_SYMBOL(__drm_atomic_helper_plane_duplicate_state);
> +
> +/**
> + * drm_atomic_helper_plane_duplicate_state - default state duplicate hook
> + * @plane: drm plane
> + *
> + * Default plane state duplicate hook for drivers which don't have their own
> + * subclassed plane state structure.
> + */
> +struct drm_plane_state *
> +drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane)
> +{
> +	struct drm_plane_state *state;
> +
> +	if (WARN_ON(!plane->state))
> +		return NULL;
> +
> +	state = kmalloc(sizeof(*state), GFP_KERNEL);
> +	if (state)
> +		__drm_atomic_helper_plane_duplicate_state(plane, state);
> +
> +	return state;
> +}
> +EXPORT_SYMBOL(drm_atomic_helper_plane_duplicate_state);
> +
> +/**
> + * __drm_atomic_helper_plane_destroy_state - release plane state
> + * @state: plane state object to release
> + *
> + * Releases all resources stored in the plane state without actually freeing
> + * the memory of the plane state. This is useful for drivers that subclass the
> + * plane state.
> + */
> +void __drm_atomic_helper_plane_destroy_state(struct drm_plane_state *state)
> +{
> +	if (state->fb)
> +		drm_framebuffer_put(state->fb);
> +
> +	if (state->fence)
> +		dma_fence_put(state->fence);
> +
> +	if (state->commit)
> +		drm_crtc_commit_put(state->commit);
> +}
> +EXPORT_SYMBOL(__drm_atomic_helper_plane_destroy_state);
> +
> +/**
> + * drm_atomic_helper_plane_destroy_state - default state destroy hook
> + * @plane: drm plane
> + * @state: plane state object to release
> + *
> + * Default plane state destroy hook for drivers which don't have their own
> + * subclassed plane state structure.
> + */
> +void drm_atomic_helper_plane_destroy_state(struct drm_plane *plane,
> +					   struct drm_plane_state *state)
> +{
> +	__drm_atomic_helper_plane_destroy_state(state);
> +	kfree(state);
> +}
> +EXPORT_SYMBOL(drm_atomic_helper_plane_destroy_state);
> +
> +/**
> + * __drm_atomic_helper_connector_reset - reset state on connector
> + * @connector: drm connector
> + * @conn_state: connector state to assign
> + *
> + * Initializes the newly allocated @conn_state and assigns it to
> + * the &drm_conector->state pointer of @connector, usually required when
> + * initializing the drivers or when called from the &drm_connector_funcs.reset
> + * hook.
> + *
> + * This is useful for drivers that subclass the connector state.
> + */
> +void
> +__drm_atomic_helper_connector_reset(struct drm_connector *connector,
> +				    struct drm_connector_state *conn_state)
> +{
> +	if (conn_state)
> +		conn_state->connector = connector;
> +
> +	connector->state = conn_state;
> +}
> +EXPORT_SYMBOL(__drm_atomic_helper_connector_reset);
> +
> +/**
> + * drm_atomic_helper_connector_reset - default &drm_connector_funcs.reset hook for connectors
> + * @connector: drm connector
> + *
> + * Resets the atomic state for @connector by freeing the state pointer (which
> + * might be NULL, e.g. at driver load time) and allocating a new empty state
> + * object.
> + */
> +void drm_atomic_helper_connector_reset(struct drm_connector *connector)
> +{
> +	struct drm_connector_state *conn_state =
> +		kzalloc(sizeof(*conn_state), GFP_KERNEL);
> +
> +	if (connector->state)
> +		__drm_atomic_helper_connector_destroy_state(connector->state);
> +
> +	kfree(connector->state);
> +	__drm_atomic_helper_connector_reset(connector, conn_state);
> +}
> +EXPORT_SYMBOL(drm_atomic_helper_connector_reset);
> +
> +/**
> + * __drm_atomic_helper_connector_duplicate_state - copy atomic connector state
> + * @connector: connector object
> + * @state: atomic connector state
> + *
> + * Copies atomic state from a connector's current state. This is useful for
> + * drivers that subclass the connector state.
> + */
> +void
> +__drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector,
> +					    struct drm_connector_state *state)
> +{
> +	memcpy(state, connector->state, sizeof(*state));
> +	if (state->crtc)
> +		drm_connector_get(connector);
> +	state->commit = NULL;
> +
> +	/* Don't copy over a writeback job, they are used only once */
> +	state->writeback_job = NULL;
> +}
> +EXPORT_SYMBOL(__drm_atomic_helper_connector_duplicate_state);
> +
> +/**
> + * drm_atomic_helper_connector_duplicate_state - default state duplicate hook
> + * @connector: drm connector
> + *
> + * Default connector state duplicate hook for drivers which don't have their own
> + * subclassed connector state structure.
> + */
> +struct drm_connector_state *
> +drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector)
> +{
> +	struct drm_connector_state *state;
> +
> +	if (WARN_ON(!connector->state))
> +		return NULL;
> +
> +	state = kmalloc(sizeof(*state), GFP_KERNEL);
> +	if (state)
> +		__drm_atomic_helper_connector_duplicate_state(connector, state);
> +
> +	return state;
> +}
> +EXPORT_SYMBOL(drm_atomic_helper_connector_duplicate_state);
> +
> +/**
> + * drm_atomic_helper_duplicate_state - duplicate an atomic state object
> + * @dev: DRM device
> + * @ctx: lock acquisition context
> + *
> + * Makes a copy of the current atomic state by looping over all objects and
> + * duplicating their respective states. This is used for example by suspend/
> + * resume support code to save the state prior to suspend such that it can
> + * be restored upon resume.
> + *
> + * Note that this treats atomic state as persistent between save and restore.
> + * Drivers must make sure that this is possible and won't result in confusion
> + * or erroneous behaviour.
> + *
> + * Note that if callers haven't already acquired all modeset locks this might
> + * return -EDEADLK, which must be handled by calling drm_modeset_backoff().
> + *
> + * Returns:
> + * A pointer to the copy of the atomic state object on success or an
> + * ERR_PTR()-encoded error code on failure.
> + *
> + * See also:
> + * drm_atomic_helper_suspend(), drm_atomic_helper_resume()
> + */
> +struct drm_atomic_state *
> +drm_atomic_helper_duplicate_state(struct drm_device *dev,
> +				  struct drm_modeset_acquire_ctx *ctx)
> +{
> +	struct drm_atomic_state *state;
> +	struct drm_connector *conn;
> +	struct drm_connector_list_iter conn_iter;
> +	struct drm_plane *plane;
> +	struct drm_crtc *crtc;
> +	int err = 0;
> +
> +	state = drm_atomic_state_alloc(dev);
> +	if (!state)
> +		return ERR_PTR(-ENOMEM);
> +
> +	state->acquire_ctx = ctx;
> +
> +	drm_for_each_crtc(crtc, dev) {
> +		struct drm_crtc_state *crtc_state;
> +
> +		crtc_state = drm_atomic_get_crtc_state(state, crtc);
> +		if (IS_ERR(crtc_state)) {
> +			err = PTR_ERR(crtc_state);
> +			goto free;
> +		}
> +	}
> +
> +	drm_for_each_plane(plane, dev) {
> +		struct drm_plane_state *plane_state;
> +
> +		plane_state = drm_atomic_get_plane_state(state, plane);
> +		if (IS_ERR(plane_state)) {
> +			err = PTR_ERR(plane_state);
> +			goto free;
> +		}
> +	}
> +
> +	drm_connector_list_iter_begin(dev, &conn_iter);
> +	drm_for_each_connector_iter(conn, &conn_iter) {
> +		struct drm_connector_state *conn_state;
> +
> +		conn_state = drm_atomic_get_connector_state(state, conn);
> +		if (IS_ERR(conn_state)) {
> +			err = PTR_ERR(conn_state);
> +			drm_connector_list_iter_end(&conn_iter);
> +			goto free;
> +		}
> +	}
> +	drm_connector_list_iter_end(&conn_iter);
> +
> +	/* clear the acquire context so that it isn't accidentally reused */
> +	state->acquire_ctx = NULL;
> +
> +free:
> +	if (err < 0) {
> +		drm_atomic_state_put(state);
> +		state = ERR_PTR(err);
> +	}
> +
> +	return state;
> +}
> +EXPORT_SYMBOL(drm_atomic_helper_duplicate_state);
> +
> +/**
> + * __drm_atomic_helper_connector_destroy_state - release connector state
> + * @state: connector state object to release
> + *
> + * Releases all resources stored in the connector state without actually
> + * freeing the memory of the connector state. This is useful for drivers that
> + * subclass the connector state.
> + */
> +void
> +__drm_atomic_helper_connector_destroy_state(struct drm_connector_state *state)
> +{
> +	if (state->crtc)
> +		drm_connector_put(state->connector);
> +
> +	if (state->commit)
> +		drm_crtc_commit_put(state->commit);
> +}
> +EXPORT_SYMBOL(__drm_atomic_helper_connector_destroy_state);
> +
> +/**
> + * drm_atomic_helper_connector_destroy_state - default state destroy hook
> + * @connector: drm connector
> + * @state: connector state object to release
> + *
> + * Default connector state destroy hook for drivers which don't have their own
> + * subclassed connector state structure.
> + */
> +void drm_atomic_helper_connector_destroy_state(struct drm_connector *connector,
> +					  struct drm_connector_state *state)
> +{
> +	__drm_atomic_helper_connector_destroy_state(state);
> +	kfree(state);
> +}
> +EXPORT_SYMBOL(drm_atomic_helper_connector_destroy_state);
> +
> +/**
> + * drm_atomic_helper_legacy_gamma_set - set the legacy gamma correction table
> + * @crtc: CRTC object
> + * @red: red correction table
> + * @green: green correction table
> + * @blue: green correction table
> + * @size: size of the tables
> + * @ctx: lock acquire context
> + *
> + * Implements support for legacy gamma correction table for drivers
> + * that support color management through the DEGAMMA_LUT/GAMMA_LUT
> + * properties. See drm_crtc_enable_color_mgmt() and the containing chapter for
> + * how the atomic color management and gamma tables work.
> + */
> +int drm_atomic_helper_legacy_gamma_set(struct drm_crtc *crtc,
> +				       u16 *red, u16 *green, u16 *blue,
> +				       uint32_t size,
> +				       struct drm_modeset_acquire_ctx *ctx)
> +{
> +	struct drm_device *dev = crtc->dev;
> +	struct drm_atomic_state *state;
> +	struct drm_crtc_state *crtc_state;
> +	struct drm_property_blob *blob = NULL;
> +	struct drm_color_lut *blob_data;
> +	int i, ret = 0;
> +	bool replaced;
> +
> +	state = drm_atomic_state_alloc(crtc->dev);
> +	if (!state)
> +		return -ENOMEM;
> +
> +	blob = drm_property_create_blob(dev,
> +					sizeof(struct drm_color_lut) * size,
> +					NULL);
> +	if (IS_ERR(blob)) {
> +		ret = PTR_ERR(blob);
> +		blob = NULL;
> +		goto fail;
> +	}
> +
> +	/* Prepare GAMMA_LUT with the legacy values. */
> +	blob_data = blob->data;
> +	for (i = 0; i < size; i++) {
> +		blob_data[i].red = red[i];
> +		blob_data[i].green = green[i];
> +		blob_data[i].blue = blue[i];
> +	}
> +
> +	state->acquire_ctx = ctx;
> +	crtc_state = drm_atomic_get_crtc_state(state, crtc);
> +	if (IS_ERR(crtc_state)) {
> +		ret = PTR_ERR(crtc_state);
> +		goto fail;
> +	}
> +
> +	/* Reset DEGAMMA_LUT and CTM properties. */
> +	replaced  = drm_property_replace_blob(&crtc_state->degamma_lut, NULL);
> +	replaced |= drm_property_replace_blob(&crtc_state->ctm, NULL);
> +	replaced |= drm_property_replace_blob(&crtc_state->gamma_lut, blob);
> +	crtc_state->color_mgmt_changed |= replaced;
> +
> +	ret = drm_atomic_commit(state);
> +
> +fail:
> +	drm_atomic_state_put(state);
> +	drm_property_blob_put(blob);
> +	return ret;
> +}
> +EXPORT_SYMBOL(drm_atomic_helper_legacy_gamma_set);
> +
> +/**
> + * __drm_atomic_helper_private_duplicate_state - copy atomic private state
> + * @obj: CRTC object
> + * @state: new private object state
> + *
> + * Copies atomic state from a private objects's current state and resets inferred values.
> + * This is useful for drivers that subclass the private state.
> + */
> +void __drm_atomic_helper_private_obj_duplicate_state(struct drm_private_obj *obj,
> +						     struct drm_private_state *state)
> +{
> +	memcpy(state, obj->state, sizeof(*state));
> +}
> +EXPORT_SYMBOL(__drm_atomic_helper_private_obj_duplicate_state);
> diff --git a/include/drm/drm_atomic_helper.h b/include/drm/drm_atomic_helper.h
> index e60c4f0f8827..25ca0097563e 100644
> --- a/include/drm/drm_atomic_helper.h
> +++ b/include/drm/drm_atomic_helper.h
> @@ -31,6 +31,7 @@
>  #include <drm/drm_crtc.h>
>  #include <drm/drm_modeset_helper_vtables.h>
>  #include <drm/drm_modeset_helper.h>
> +#include <drm/drm_atomic_state_helper.h>
>  #include <drm/drm_util.h>
>  
>  struct drm_atomic_state;
> @@ -145,49 +146,6 @@ int drm_atomic_helper_page_flip_target(
>  				uint32_t target,
>  				struct drm_modeset_acquire_ctx *ctx);
>  
> -/* default implementations for state handling */
> -void drm_atomic_helper_crtc_reset(struct drm_crtc *crtc);
> -void __drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc,
> -					      struct drm_crtc_state *state);
> -struct drm_crtc_state *
> -drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc);
> -void __drm_atomic_helper_crtc_destroy_state(struct drm_crtc_state *state);
> -void drm_atomic_helper_crtc_destroy_state(struct drm_crtc *crtc,
> -					  struct drm_crtc_state *state);
> -
> -void __drm_atomic_helper_plane_reset(struct drm_plane *plane,
> -				     struct drm_plane_state *state);
> -void drm_atomic_helper_plane_reset(struct drm_plane *plane);
> -void __drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane,
> -					       struct drm_plane_state *state);
> -struct drm_plane_state *
> -drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane);
> -void __drm_atomic_helper_plane_destroy_state(struct drm_plane_state *state);
> -void drm_atomic_helper_plane_destroy_state(struct drm_plane *plane,
> -					  struct drm_plane_state *state);
> -
> -void __drm_atomic_helper_connector_reset(struct drm_connector *connector,
> -					 struct drm_connector_state *conn_state);
> -void drm_atomic_helper_connector_reset(struct drm_connector *connector);
> -void
> -__drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector,
> -					   struct drm_connector_state *state);
> -struct drm_connector_state *
> -drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector);
> -struct drm_atomic_state *
> -drm_atomic_helper_duplicate_state(struct drm_device *dev,
> -				  struct drm_modeset_acquire_ctx *ctx);
> -void
> -__drm_atomic_helper_connector_destroy_state(struct drm_connector_state *state);
> -void drm_atomic_helper_connector_destroy_state(struct drm_connector *connector,
> -					  struct drm_connector_state *state);
> -int drm_atomic_helper_legacy_gamma_set(struct drm_crtc *crtc,
> -				       u16 *red, u16 *green, u16 *blue,
> -				       uint32_t size,
> -				       struct drm_modeset_acquire_ctx *ctx);
> -void __drm_atomic_helper_private_obj_duplicate_state(struct drm_private_obj *obj,
> -						     struct drm_private_state *state);
> -
>  /**
>   * drm_atomic_crtc_for_each_plane - iterate over planes currently attached to CRTC
>   * @plane: the loop cursor
> diff --git a/include/drm/drm_atomic_state_helper.h b/include/drm/drm_atomic_state_helper.h
> new file mode 100644
> index 000000000000..5b82ccfdb502
> --- /dev/null
> +++ b/include/drm/drm_atomic_state_helper.h
> @@ -0,0 +1,80 @@
> +/*
> + * Copyright (C) 2018 Intel Corp.
> + *
> + * Permission is hereby granted, free of charge, to any person obtaining a
> + * copy of this software and associated documentation files (the "Software"),
> + * to deal in the Software without restriction, including without limitation
> + * the rights to use, copy, modify, merge, publish, distribute, sublicense,
> + * and/or sell copies of the Software, and to permit persons to whom the
> + * Software is furnished to do so, subject to the following conditions:
> + *
> + * The above copyright notice and this permission notice shall be included in
> + * all copies or substantial portions of the Software.
> + *
> + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
> + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
> + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
> + * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
> + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
> + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
> + * OTHER DEALINGS IN THE SOFTWARE.
> + *
> + * Authors:
> + * Rob Clark <robdclark@gmail.com>
> + * Daniel Vetter <daniel.vetter@ffwll.ch>
> + */
> +
> +#include <linux/types.h>
> +
> +struct drm_crtc;
> +struct drm_crtc_state;
> +struct drm_plane;
> +struct drm_plane_state;
> +struct drm_connector;
> +struct drm_connector_state;
> +struct drm_private_obj;
> +struct drm_private_state;
> +struct drm_modeset_acquire_ctx;
> +struct drm_device;
> +
> +void drm_atomic_helper_crtc_reset(struct drm_crtc *crtc);
> +void __drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc,
> +					      struct drm_crtc_state *state);
> +struct drm_crtc_state *
> +drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc);
> +void __drm_atomic_helper_crtc_destroy_state(struct drm_crtc_state *state);
> +void drm_atomic_helper_crtc_destroy_state(struct drm_crtc *crtc,
> +					  struct drm_crtc_state *state);
> +
> +void __drm_atomic_helper_plane_reset(struct drm_plane *plane,
> +				     struct drm_plane_state *state);
> +void drm_atomic_helper_plane_reset(struct drm_plane *plane);
> +void __drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane,
> +					       struct drm_plane_state *state);
> +struct drm_plane_state *
> +drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane);
> +void __drm_atomic_helper_plane_destroy_state(struct drm_plane_state *state);
> +void drm_atomic_helper_plane_destroy_state(struct drm_plane *plane,
> +					  struct drm_plane_state *state);
> +
> +void __drm_atomic_helper_connector_reset(struct drm_connector *connector,
> +					 struct drm_connector_state *conn_state);
> +void drm_atomic_helper_connector_reset(struct drm_connector *connector);
> +void
> +__drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector,
> +					   struct drm_connector_state *state);
> +struct drm_connector_state *
> +drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector);
> +struct drm_atomic_state *
> +drm_atomic_helper_duplicate_state(struct drm_device *dev,
> +				  struct drm_modeset_acquire_ctx *ctx);
> +void
> +__drm_atomic_helper_connector_destroy_state(struct drm_connector_state *state);
> +void drm_atomic_helper_connector_destroy_state(struct drm_connector *connector,
> +					  struct drm_connector_state *state);
> +int drm_atomic_helper_legacy_gamma_set(struct drm_crtc *crtc,
> +				       u16 *red, u16 *green, u16 *blue,
> +				       uint32_t size,
> +				       struct drm_modeset_acquire_ctx *ctx);
> +void __drm_atomic_helper_private_obj_duplicate_state(struct drm_private_obj *obj,
> +						     struct drm_private_state *state);
> -- 
> 2.19.0.rc2
> 
> _______________________________________________
> Intel-gfx mailing list
> Intel-gfx@lists.freedesktop.org
> https://lists.freedesktop.org/mailman/listinfo/intel-gfx
Daniel Vetter Oct. 3, 2018, 9:10 a.m. UTC | #2
On Tue, Oct 02, 2018 at 06:40:52PM +0300, Ville Syrjälä wrote:
> On Tue, Oct 02, 2018 at 03:35:11PM +0200, Daniel Vetter wrote:
> > We already have a separate overview doc for this, makes sense to
> > untangle it from the overall atomic helpers.
> > 
> > v2: Rebase
> > 
> > v3: Rebase more.
> 
> Hopefully the rebases didn't leave any code changes behind...

I've redone the move on every rebase :-/

> Too lazy to read in full detail so
> Acked-by: Ville Syrjälä <ville.syrjala@linux.intel.com>

Thanks, I'll pick this one right up (just need to double-check CI).
-Daniel

> 
> > 
> > Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
> > ---
> >  Documentation/gpu/drm-kms-helpers.rst     |  19 +-
> >  drivers/gpu/drm/Makefile                  |   3 +-
> >  drivers/gpu/drm/drm_atomic_helper.c       | 566 --------------------
> >  drivers/gpu/drm/drm_atomic_state_helper.c | 601 ++++++++++++++++++++++
> >  include/drm/drm_atomic_helper.h           |  44 +-
> >  include/drm/drm_atomic_state_helper.h     |  80 +++
> >  6 files changed, 698 insertions(+), 615 deletions(-)
> >  create mode 100644 drivers/gpu/drm/drm_atomic_state_helper.c
> >  create mode 100644 include/drm/drm_atomic_state_helper.h
> > 
> > diff --git a/Documentation/gpu/drm-kms-helpers.rst b/Documentation/gpu/drm-kms-helpers.rst
> > index f9cfcdcdf024..4b4dc236ef6f 100644
> > --- a/Documentation/gpu/drm-kms-helpers.rst
> > +++ b/Documentation/gpu/drm-kms-helpers.rst
> > @@ -59,19 +59,28 @@ Implementing Asynchronous Atomic Commit
> >  .. kernel-doc:: drivers/gpu/drm/drm_atomic_helper.c
> >     :doc: implementing nonblocking commit
> >  
> > +Helper Functions Reference
> > +--------------------------
> > +
> > +.. kernel-doc:: include/drm/drm_atomic_helper.h
> > +   :internal:
> > +
> > +.. kernel-doc:: drivers/gpu/drm/drm_atomic_helper.c
> > +   :export:
> > +
> >  Atomic State Reset and Initialization
> >  -------------------------------------
> >  
> > -.. kernel-doc:: drivers/gpu/drm/drm_atomic_helper.c
> > +.. kernel-doc:: drivers/gpu/drm/drm_atomic_state_helper.c
> >     :doc: atomic state reset and initialization
> >  
> > -Helper Functions Reference
> > ---------------------------
> > +Atomic State Helper Reference
> > +-----------------------------
> >  
> > -.. kernel-doc:: include/drm/drm_atomic_helper.h
> > +.. kernel-doc:: include/drm/drm_atomic_state_helper.h
> >     :internal:
> >  
> > -.. kernel-doc:: drivers/gpu/drm/drm_atomic_helper.c
> > +.. kernel-doc:: drivers/gpu/drm/drm_atomic_state_helper.c
> >     :export:
> >  
> >  Simple KMS Helper Reference
> > diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile
> > index bc6a16a3c36e..576ba985e138 100644
> > --- a/drivers/gpu/drm/Makefile
> > +++ b/drivers/gpu/drm/Makefile
> > @@ -36,7 +36,8 @@ drm_kms_helper-y := drm_crtc_helper.o drm_dp_helper.o drm_probe_helper.o \
> >  		drm_plane_helper.o drm_dp_mst_topology.o drm_atomic_helper.o \
> >  		drm_kms_helper_common.o drm_dp_dual_mode_helper.o \
> >  		drm_simple_kms_helper.o drm_modeset_helper.o \
> > -		drm_scdc_helper.o drm_gem_framebuffer_helper.o
> > +		drm_scdc_helper.o drm_gem_framebuffer_helper.o \
> > +		drm_atomic_state_helper.o
> >  
> >  drm_kms_helper-$(CONFIG_DRM_PANEL_BRIDGE) += bridge/panel.o
> >  drm_kms_helper-$(CONFIG_DRM_FBDEV_EMULATION) += drm_fb_helper.o
> > diff --git a/drivers/gpu/drm/drm_atomic_helper.c b/drivers/gpu/drm/drm_atomic_helper.c
> > index 8c93f33fe92f..a5edc8757056 100644
> > --- a/drivers/gpu/drm/drm_atomic_helper.c
> > +++ b/drivers/gpu/drm/drm_atomic_helper.c
> > @@ -3382,569 +3382,3 @@ int drm_atomic_helper_page_flip_target(struct drm_crtc *crtc,
> >  	return ret;
> >  }
> >  EXPORT_SYMBOL(drm_atomic_helper_page_flip_target);
> > -
> > -/**
> > - * DOC: atomic state reset and initialization
> > - *
> > - * Both the drm core and the atomic helpers assume that there is always the full
> > - * and correct atomic software state for all connectors, CRTCs and planes
> > - * available. Which is a bit a problem on driver load and also after system
> > - * suspend. One way to solve this is to have a hardware state read-out
> > - * infrastructure which reconstructs the full software state (e.g. the i915
> > - * driver).
> > - *
> > - * The simpler solution is to just reset the software state to everything off,
> > - * which is easiest to do by calling drm_mode_config_reset(). To facilitate this
> > - * the atomic helpers provide default reset implementations for all hooks.
> > - *
> > - * On the upside the precise state tracking of atomic simplifies system suspend
> > - * and resume a lot. For drivers using drm_mode_config_reset() a complete recipe
> > - * is implemented in drm_atomic_helper_suspend() and drm_atomic_helper_resume().
> > - * For other drivers the building blocks are split out, see the documentation
> > - * for these functions.
> > - */
> > -
> > -/**
> > - * drm_atomic_helper_crtc_reset - default &drm_crtc_funcs.reset hook for CRTCs
> > - * @crtc: drm CRTC
> > - *
> > - * Resets the atomic state for @crtc by freeing the state pointer (which might
> > - * be NULL, e.g. at driver load time) and allocating a new empty state object.
> > - */
> > -void drm_atomic_helper_crtc_reset(struct drm_crtc *crtc)
> > -{
> > -	if (crtc->state)
> > -		__drm_atomic_helper_crtc_destroy_state(crtc->state);
> > -
> > -	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);
> > -
> > -/**
> > - * __drm_atomic_helper_crtc_duplicate_state - copy atomic CRTC state
> > - * @crtc: CRTC object
> > - * @state: atomic CRTC state
> > - *
> > - * Copies atomic state from a CRTC's current state and resets inferred values.
> > - * This is useful for drivers that subclass the CRTC state.
> > - */
> > -void __drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc,
> > -					      struct drm_crtc_state *state)
> > -{
> > -	memcpy(state, crtc->state, sizeof(*state));
> > -
> > -	if (state->mode_blob)
> > -		drm_property_blob_get(state->mode_blob);
> > -	if (state->degamma_lut)
> > -		drm_property_blob_get(state->degamma_lut);
> > -	if (state->ctm)
> > -		drm_property_blob_get(state->ctm);
> > -	if (state->gamma_lut)
> > -		drm_property_blob_get(state->gamma_lut);
> > -	state->mode_changed = false;
> > -	state->active_changed = false;
> > -	state->planes_changed = false;
> > -	state->connectors_changed = false;
> > -	state->color_mgmt_changed = false;
> > -	state->zpos_changed = false;
> > -	state->commit = NULL;
> > -	state->event = NULL;
> > -	state->pageflip_flags = 0;
> > -}
> > -EXPORT_SYMBOL(__drm_atomic_helper_crtc_duplicate_state);
> > -
> > -/**
> > - * drm_atomic_helper_crtc_duplicate_state - default state duplicate hook
> > - * @crtc: drm CRTC
> > - *
> > - * Default CRTC state duplicate hook for drivers which don't have their own
> > - * subclassed CRTC state structure.
> > - */
> > -struct drm_crtc_state *
> > -drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc)
> > -{
> > -	struct drm_crtc_state *state;
> > -
> > -	if (WARN_ON(!crtc->state))
> > -		return NULL;
> > -
> > -	state = kmalloc(sizeof(*state), GFP_KERNEL);
> > -	if (state)
> > -		__drm_atomic_helper_crtc_duplicate_state(crtc, state);
> > -
> > -	return state;
> > -}
> > -EXPORT_SYMBOL(drm_atomic_helper_crtc_duplicate_state);
> > -
> > -/**
> > - * __drm_atomic_helper_crtc_destroy_state - release CRTC state
> > - * @state: CRTC state object to release
> > - *
> > - * Releases all resources stored in the CRTC state without actually freeing
> > - * the memory of the CRTC state. This is useful for drivers that subclass the
> > - * CRTC state.
> > - */
> > -void __drm_atomic_helper_crtc_destroy_state(struct drm_crtc_state *state)
> > -{
> > -	if (state->commit) {
> > -		/*
> > -		 * In the event that a non-blocking commit returns
> > -		 * -ERESTARTSYS before the commit_tail work is queued, we will
> > -		 * have an extra reference to the commit object. Release it, if
> > -		 * the event has not been consumed by the worker.
> > -		 *
> > -		 * state->event may be freed, so we can't directly look at
> > -		 * state->event->base.completion.
> > -		 */
> > -		if (state->event && state->commit->abort_completion)
> > -			drm_crtc_commit_put(state->commit);
> > -
> > -		kfree(state->commit->event);
> > -		state->commit->event = NULL;
> > -
> > -		drm_crtc_commit_put(state->commit);
> > -	}
> > -
> > -	drm_property_blob_put(state->mode_blob);
> > -	drm_property_blob_put(state->degamma_lut);
> > -	drm_property_blob_put(state->ctm);
> > -	drm_property_blob_put(state->gamma_lut);
> > -}
> > -EXPORT_SYMBOL(__drm_atomic_helper_crtc_destroy_state);
> > -
> > -/**
> > - * drm_atomic_helper_crtc_destroy_state - default state destroy hook
> > - * @crtc: drm CRTC
> > - * @state: CRTC state object to release
> > - *
> > - * Default CRTC state destroy hook for drivers which don't have their own
> > - * subclassed CRTC state structure.
> > - */
> > -void drm_atomic_helper_crtc_destroy_state(struct drm_crtc *crtc,
> > -					  struct drm_crtc_state *state)
> > -{
> > -	__drm_atomic_helper_crtc_destroy_state(state);
> > -	kfree(state);
> > -}
> > -EXPORT_SYMBOL(drm_atomic_helper_crtc_destroy_state);
> > -
> > -/**
> > - * __drm_atomic_helper_plane_reset - resets planes state to default values
> > - * @plane: plane object, must not be NULL
> > - * @state: atomic plane state, must not be NULL
> > - *
> > - * Initializes plane state to default. This is useful for drivers that subclass
> > - * the plane state.
> > - */
> > -void __drm_atomic_helper_plane_reset(struct drm_plane *plane,
> > -				     struct drm_plane_state *state)
> > -{
> > -	state->plane = plane;
> > -	state->rotation = DRM_MODE_ROTATE_0;
> > -
> > -	state->alpha = DRM_BLEND_ALPHA_OPAQUE;
> > -	state->pixel_blend_mode = DRM_MODE_BLEND_PREMULTI;
> > -
> > -	plane->state = state;
> > -}
> > -EXPORT_SYMBOL(__drm_atomic_helper_plane_reset);
> > -
> > -/**
> > - * drm_atomic_helper_plane_reset - default &drm_plane_funcs.reset hook for planes
> > - * @plane: drm plane
> > - *
> > - * Resets the atomic state for @plane by freeing the state pointer (which might
> > - * be NULL, e.g. at driver load time) and allocating a new empty state object.
> > - */
> > -void drm_atomic_helper_plane_reset(struct drm_plane *plane)
> > -{
> > -	if (plane->state)
> > -		__drm_atomic_helper_plane_destroy_state(plane->state);
> > -
> > -	kfree(plane->state);
> > -	plane->state = kzalloc(sizeof(*plane->state), GFP_KERNEL);
> > -	if (plane->state)
> > -		__drm_atomic_helper_plane_reset(plane, plane->state);
> > -}
> > -EXPORT_SYMBOL(drm_atomic_helper_plane_reset);
> > -
> > -/**
> > - * __drm_atomic_helper_plane_duplicate_state - copy atomic plane state
> > - * @plane: plane object
> > - * @state: atomic plane state
> > - *
> > - * Copies atomic state from a plane's current state. This is useful for
> > - * drivers that subclass the plane state.
> > - */
> > -void __drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane,
> > -					       struct drm_plane_state *state)
> > -{
> > -	memcpy(state, plane->state, sizeof(*state));
> > -
> > -	if (state->fb)
> > -		drm_framebuffer_get(state->fb);
> > -
> > -	state->fence = NULL;
> > -	state->commit = NULL;
> > -}
> > -EXPORT_SYMBOL(__drm_atomic_helper_plane_duplicate_state);
> > -
> > -/**
> > - * drm_atomic_helper_plane_duplicate_state - default state duplicate hook
> > - * @plane: drm plane
> > - *
> > - * Default plane state duplicate hook for drivers which don't have their own
> > - * subclassed plane state structure.
> > - */
> > -struct drm_plane_state *
> > -drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane)
> > -{
> > -	struct drm_plane_state *state;
> > -
> > -	if (WARN_ON(!plane->state))
> > -		return NULL;
> > -
> > -	state = kmalloc(sizeof(*state), GFP_KERNEL);
> > -	if (state)
> > -		__drm_atomic_helper_plane_duplicate_state(plane, state);
> > -
> > -	return state;
> > -}
> > -EXPORT_SYMBOL(drm_atomic_helper_plane_duplicate_state);
> > -
> > -/**
> > - * __drm_atomic_helper_plane_destroy_state - release plane state
> > - * @state: plane state object to release
> > - *
> > - * Releases all resources stored in the plane state without actually freeing
> > - * the memory of the plane state. This is useful for drivers that subclass the
> > - * plane state.
> > - */
> > -void __drm_atomic_helper_plane_destroy_state(struct drm_plane_state *state)
> > -{
> > -	if (state->fb)
> > -		drm_framebuffer_put(state->fb);
> > -
> > -	if (state->fence)
> > -		dma_fence_put(state->fence);
> > -
> > -	if (state->commit)
> > -		drm_crtc_commit_put(state->commit);
> > -}
> > -EXPORT_SYMBOL(__drm_atomic_helper_plane_destroy_state);
> > -
> > -/**
> > - * drm_atomic_helper_plane_destroy_state - default state destroy hook
> > - * @plane: drm plane
> > - * @state: plane state object to release
> > - *
> > - * Default plane state destroy hook for drivers which don't have their own
> > - * subclassed plane state structure.
> > - */
> > -void drm_atomic_helper_plane_destroy_state(struct drm_plane *plane,
> > -					   struct drm_plane_state *state)
> > -{
> > -	__drm_atomic_helper_plane_destroy_state(state);
> > -	kfree(state);
> > -}
> > -EXPORT_SYMBOL(drm_atomic_helper_plane_destroy_state);
> > -
> > -/**
> > - * __drm_atomic_helper_connector_reset - reset state on connector
> > - * @connector: drm connector
> > - * @conn_state: connector state to assign
> > - *
> > - * Initializes the newly allocated @conn_state and assigns it to
> > - * the &drm_conector->state pointer of @connector, usually required when
> > - * initializing the drivers or when called from the &drm_connector_funcs.reset
> > - * hook.
> > - *
> > - * This is useful for drivers that subclass the connector state.
> > - */
> > -void
> > -__drm_atomic_helper_connector_reset(struct drm_connector *connector,
> > -				    struct drm_connector_state *conn_state)
> > -{
> > -	if (conn_state)
> > -		conn_state->connector = connector;
> > -
> > -	connector->state = conn_state;
> > -}
> > -EXPORT_SYMBOL(__drm_atomic_helper_connector_reset);
> > -
> > -/**
> > - * drm_atomic_helper_connector_reset - default &drm_connector_funcs.reset hook for connectors
> > - * @connector: drm connector
> > - *
> > - * Resets the atomic state for @connector by freeing the state pointer (which
> > - * might be NULL, e.g. at driver load time) and allocating a new empty state
> > - * object.
> > - */
> > -void drm_atomic_helper_connector_reset(struct drm_connector *connector)
> > -{
> > -	struct drm_connector_state *conn_state =
> > -		kzalloc(sizeof(*conn_state), GFP_KERNEL);
> > -
> > -	if (connector->state)
> > -		__drm_atomic_helper_connector_destroy_state(connector->state);
> > -
> > -	kfree(connector->state);
> > -	__drm_atomic_helper_connector_reset(connector, conn_state);
> > -}
> > -EXPORT_SYMBOL(drm_atomic_helper_connector_reset);
> > -
> > -/**
> > - * __drm_atomic_helper_connector_duplicate_state - copy atomic connector state
> > - * @connector: connector object
> > - * @state: atomic connector state
> > - *
> > - * Copies atomic state from a connector's current state. This is useful for
> > - * drivers that subclass the connector state.
> > - */
> > -void
> > -__drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector,
> > -					    struct drm_connector_state *state)
> > -{
> > -	memcpy(state, connector->state, sizeof(*state));
> > -	if (state->crtc)
> > -		drm_connector_get(connector);
> > -	state->commit = NULL;
> > -
> > -	/* Don't copy over a writeback job, they are used only once */
> > -	state->writeback_job = NULL;
> > -}
> > -EXPORT_SYMBOL(__drm_atomic_helper_connector_duplicate_state);
> > -
> > -/**
> > - * drm_atomic_helper_connector_duplicate_state - default state duplicate hook
> > - * @connector: drm connector
> > - *
> > - * Default connector state duplicate hook for drivers which don't have their own
> > - * subclassed connector state structure.
> > - */
> > -struct drm_connector_state *
> > -drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector)
> > -{
> > -	struct drm_connector_state *state;
> > -
> > -	if (WARN_ON(!connector->state))
> > -		return NULL;
> > -
> > -	state = kmalloc(sizeof(*state), GFP_KERNEL);
> > -	if (state)
> > -		__drm_atomic_helper_connector_duplicate_state(connector, state);
> > -
> > -	return state;
> > -}
> > -EXPORT_SYMBOL(drm_atomic_helper_connector_duplicate_state);
> > -
> > -/**
> > - * drm_atomic_helper_duplicate_state - duplicate an atomic state object
> > - * @dev: DRM device
> > - * @ctx: lock acquisition context
> > - *
> > - * Makes a copy of the current atomic state by looping over all objects and
> > - * duplicating their respective states. This is used for example by suspend/
> > - * resume support code to save the state prior to suspend such that it can
> > - * be restored upon resume.
> > - *
> > - * Note that this treats atomic state as persistent between save and restore.
> > - * Drivers must make sure that this is possible and won't result in confusion
> > - * or erroneous behaviour.
> > - *
> > - * Note that if callers haven't already acquired all modeset locks this might
> > - * return -EDEADLK, which must be handled by calling drm_modeset_backoff().
> > - *
> > - * Returns:
> > - * A pointer to the copy of the atomic state object on success or an
> > - * ERR_PTR()-encoded error code on failure.
> > - *
> > - * See also:
> > - * drm_atomic_helper_suspend(), drm_atomic_helper_resume()
> > - */
> > -struct drm_atomic_state *
> > -drm_atomic_helper_duplicate_state(struct drm_device *dev,
> > -				  struct drm_modeset_acquire_ctx *ctx)
> > -{
> > -	struct drm_atomic_state *state;
> > -	struct drm_connector *conn;
> > -	struct drm_connector_list_iter conn_iter;
> > -	struct drm_plane *plane;
> > -	struct drm_crtc *crtc;
> > -	int err = 0;
> > -
> > -	state = drm_atomic_state_alloc(dev);
> > -	if (!state)
> > -		return ERR_PTR(-ENOMEM);
> > -
> > -	state->acquire_ctx = ctx;
> > -
> > -	drm_for_each_crtc(crtc, dev) {
> > -		struct drm_crtc_state *crtc_state;
> > -
> > -		crtc_state = drm_atomic_get_crtc_state(state, crtc);
> > -		if (IS_ERR(crtc_state)) {
> > -			err = PTR_ERR(crtc_state);
> > -			goto free;
> > -		}
> > -	}
> > -
> > -	drm_for_each_plane(plane, dev) {
> > -		struct drm_plane_state *plane_state;
> > -
> > -		plane_state = drm_atomic_get_plane_state(state, plane);
> > -		if (IS_ERR(plane_state)) {
> > -			err = PTR_ERR(plane_state);
> > -			goto free;
> > -		}
> > -	}
> > -
> > -	drm_connector_list_iter_begin(dev, &conn_iter);
> > -	drm_for_each_connector_iter(conn, &conn_iter) {
> > -		struct drm_connector_state *conn_state;
> > -
> > -		conn_state = drm_atomic_get_connector_state(state, conn);
> > -		if (IS_ERR(conn_state)) {
> > -			err = PTR_ERR(conn_state);
> > -			drm_connector_list_iter_end(&conn_iter);
> > -			goto free;
> > -		}
> > -	}
> > -	drm_connector_list_iter_end(&conn_iter);
> > -
> > -	/* clear the acquire context so that it isn't accidentally reused */
> > -	state->acquire_ctx = NULL;
> > -
> > -free:
> > -	if (err < 0) {
> > -		drm_atomic_state_put(state);
> > -		state = ERR_PTR(err);
> > -	}
> > -
> > -	return state;
> > -}
> > -EXPORT_SYMBOL(drm_atomic_helper_duplicate_state);
> > -
> > -/**
> > - * __drm_atomic_helper_connector_destroy_state - release connector state
> > - * @state: connector state object to release
> > - *
> > - * Releases all resources stored in the connector state without actually
> > - * freeing the memory of the connector state. This is useful for drivers that
> > - * subclass the connector state.
> > - */
> > -void
> > -__drm_atomic_helper_connector_destroy_state(struct drm_connector_state *state)
> > -{
> > -	if (state->crtc)
> > -		drm_connector_put(state->connector);
> > -
> > -	if (state->commit)
> > -		drm_crtc_commit_put(state->commit);
> > -}
> > -EXPORT_SYMBOL(__drm_atomic_helper_connector_destroy_state);
> > -
> > -/**
> > - * drm_atomic_helper_connector_destroy_state - default state destroy hook
> > - * @connector: drm connector
> > - * @state: connector state object to release
> > - *
> > - * Default connector state destroy hook for drivers which don't have their own
> > - * subclassed connector state structure.
> > - */
> > -void drm_atomic_helper_connector_destroy_state(struct drm_connector *connector,
> > -					  struct drm_connector_state *state)
> > -{
> > -	__drm_atomic_helper_connector_destroy_state(state);
> > -	kfree(state);
> > -}
> > -EXPORT_SYMBOL(drm_atomic_helper_connector_destroy_state);
> > -
> > -/**
> > - * drm_atomic_helper_legacy_gamma_set - set the legacy gamma correction table
> > - * @crtc: CRTC object
> > - * @red: red correction table
> > - * @green: green correction table
> > - * @blue: green correction table
> > - * @size: size of the tables
> > - * @ctx: lock acquire context
> > - *
> > - * Implements support for legacy gamma correction table for drivers
> > - * that support color management through the DEGAMMA_LUT/GAMMA_LUT
> > - * properties. See drm_crtc_enable_color_mgmt() and the containing chapter for
> > - * how the atomic color management and gamma tables work.
> > - */
> > -int drm_atomic_helper_legacy_gamma_set(struct drm_crtc *crtc,
> > -				       u16 *red, u16 *green, u16 *blue,
> > -				       uint32_t size,
> > -				       struct drm_modeset_acquire_ctx *ctx)
> > -{
> > -	struct drm_device *dev = crtc->dev;
> > -	struct drm_atomic_state *state;
> > -	struct drm_crtc_state *crtc_state;
> > -	struct drm_property_blob *blob = NULL;
> > -	struct drm_color_lut *blob_data;
> > -	int i, ret = 0;
> > -	bool replaced;
> > -
> > -	state = drm_atomic_state_alloc(crtc->dev);
> > -	if (!state)
> > -		return -ENOMEM;
> > -
> > -	blob = drm_property_create_blob(dev,
> > -					sizeof(struct drm_color_lut) * size,
> > -					NULL);
> > -	if (IS_ERR(blob)) {
> > -		ret = PTR_ERR(blob);
> > -		blob = NULL;
> > -		goto fail;
> > -	}
> > -
> > -	/* Prepare GAMMA_LUT with the legacy values. */
> > -	blob_data = blob->data;
> > -	for (i = 0; i < size; i++) {
> > -		blob_data[i].red = red[i];
> > -		blob_data[i].green = green[i];
> > -		blob_data[i].blue = blue[i];
> > -	}
> > -
> > -	state->acquire_ctx = ctx;
> > -	crtc_state = drm_atomic_get_crtc_state(state, crtc);
> > -	if (IS_ERR(crtc_state)) {
> > -		ret = PTR_ERR(crtc_state);
> > -		goto fail;
> > -	}
> > -
> > -	/* Reset DEGAMMA_LUT and CTM properties. */
> > -	replaced  = drm_property_replace_blob(&crtc_state->degamma_lut, NULL);
> > -	replaced |= drm_property_replace_blob(&crtc_state->ctm, NULL);
> > -	replaced |= drm_property_replace_blob(&crtc_state->gamma_lut, blob);
> > -	crtc_state->color_mgmt_changed |= replaced;
> > -
> > -	ret = drm_atomic_commit(state);
> > -
> > -fail:
> > -	drm_atomic_state_put(state);
> > -	drm_property_blob_put(blob);
> > -	return ret;
> > -}
> > -EXPORT_SYMBOL(drm_atomic_helper_legacy_gamma_set);
> > -
> > -/**
> > - * __drm_atomic_helper_private_duplicate_state - copy atomic private state
> > - * @obj: CRTC object
> > - * @state: new private object state
> > - *
> > - * Copies atomic state from a private objects's current state and resets inferred values.
> > - * This is useful for drivers that subclass the private state.
> > - */
> > -void __drm_atomic_helper_private_obj_duplicate_state(struct drm_private_obj *obj,
> > -						     struct drm_private_state *state)
> > -{
> > -	memcpy(state, obj->state, sizeof(*state));
> > -}
> > -EXPORT_SYMBOL(__drm_atomic_helper_private_obj_duplicate_state);
> > diff --git a/drivers/gpu/drm/drm_atomic_state_helper.c b/drivers/gpu/drm/drm_atomic_state_helper.c
> > new file mode 100644
> > index 000000000000..3ba996069d69
> > --- /dev/null
> > +++ b/drivers/gpu/drm/drm_atomic_state_helper.c
> > @@ -0,0 +1,601 @@
> > +/*
> > + * Copyright (C) 2018 Intel Corp.
> > + *
> > + * Permission is hereby granted, free of charge, to any person obtaining a
> > + * copy of this software and associated documentation files (the "Software"),
> > + * to deal in the Software without restriction, including without limitation
> > + * the rights to use, copy, modify, merge, publish, distribute, sublicense,
> > + * and/or sell copies of the Software, and to permit persons to whom the
> > + * Software is furnished to do so, subject to the following conditions:
> > + *
> > + * The above copyright notice and this permission notice shall be included in
> > + * all copies or substantial portions of the Software.
> > + *
> > + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
> > + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
> > + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
> > + * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
> > + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
> > + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
> > + * OTHER DEALINGS IN THE SOFTWARE.
> > + *
> > + * Authors:
> > + * Rob Clark <robdclark@gmail.com>
> > + * Daniel Vetter <daniel.vetter@ffwll.ch>
> > + */
> > +
> > +#include <drm/drm_atomic_state_helper.h>
> > +#include <drm/drm_crtc.h>
> > +#include <drm/drm_plane.h>
> > +#include <drm/drm_connector.h>
> > +#include <drm/drm_atomic.h>
> > +#include <drm/drm_device.h>
> > +
> > +#include <linux/slab.h>
> > +#include <linux/dma-fence.h>
> > +
> > +/**
> > + * DOC: atomic state reset and initialization
> > + *
> > + * Both the drm core and the atomic helpers assume that there is always the full
> > + * and correct atomic software state for all connectors, CRTCs and planes
> > + * available. Which is a bit a problem on driver load and also after system
> > + * suspend. One way to solve this is to have a hardware state read-out
> > + * infrastructure which reconstructs the full software state (e.g. the i915
> > + * driver).
> > + *
> > + * The simpler solution is to just reset the software state to everything off,
> > + * which is easiest to do by calling drm_mode_config_reset(). To facilitate this
> > + * the atomic helpers provide default reset implementations for all hooks.
> > + *
> > + * On the upside the precise state tracking of atomic simplifies system suspend
> > + * and resume a lot. For drivers using drm_mode_config_reset() a complete recipe
> > + * is implemented in drm_atomic_helper_suspend() and drm_atomic_helper_resume().
> > + * For other drivers the building blocks are split out, see the documentation
> > + * for these functions.
> > + */
> > +
> > +/**
> > + * drm_atomic_helper_crtc_reset - default &drm_crtc_funcs.reset hook for CRTCs
> > + * @crtc: drm CRTC
> > + *
> > + * Resets the atomic state for @crtc by freeing the state pointer (which might
> > + * be NULL, e.g. at driver load time) and allocating a new empty state object.
> > + */
> > +void drm_atomic_helper_crtc_reset(struct drm_crtc *crtc)
> > +{
> > +	if (crtc->state)
> > +		__drm_atomic_helper_crtc_destroy_state(crtc->state);
> > +
> > +	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);
> > +
> > +/**
> > + * __drm_atomic_helper_crtc_duplicate_state - copy atomic CRTC state
> > + * @crtc: CRTC object
> > + * @state: atomic CRTC state
> > + *
> > + * Copies atomic state from a CRTC's current state and resets inferred values.
> > + * This is useful for drivers that subclass the CRTC state.
> > + */
> > +void __drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc,
> > +					      struct drm_crtc_state *state)
> > +{
> > +	memcpy(state, crtc->state, sizeof(*state));
> > +
> > +	if (state->mode_blob)
> > +		drm_property_blob_get(state->mode_blob);
> > +	if (state->degamma_lut)
> > +		drm_property_blob_get(state->degamma_lut);
> > +	if (state->ctm)
> > +		drm_property_blob_get(state->ctm);
> > +	if (state->gamma_lut)
> > +		drm_property_blob_get(state->gamma_lut);
> > +	state->mode_changed = false;
> > +	state->active_changed = false;
> > +	state->planes_changed = false;
> > +	state->connectors_changed = false;
> > +	state->color_mgmt_changed = false;
> > +	state->zpos_changed = false;
> > +	state->commit = NULL;
> > +	state->event = NULL;
> > +	state->pageflip_flags = 0;
> > +}
> > +EXPORT_SYMBOL(__drm_atomic_helper_crtc_duplicate_state);
> > +
> > +/**
> > + * drm_atomic_helper_crtc_duplicate_state - default state duplicate hook
> > + * @crtc: drm CRTC
> > + *
> > + * Default CRTC state duplicate hook for drivers which don't have their own
> > + * subclassed CRTC state structure.
> > + */
> > +struct drm_crtc_state *
> > +drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc)
> > +{
> > +	struct drm_crtc_state *state;
> > +
> > +	if (WARN_ON(!crtc->state))
> > +		return NULL;
> > +
> > +	state = kmalloc(sizeof(*state), GFP_KERNEL);
> > +	if (state)
> > +		__drm_atomic_helper_crtc_duplicate_state(crtc, state);
> > +
> > +	return state;
> > +}
> > +EXPORT_SYMBOL(drm_atomic_helper_crtc_duplicate_state);
> > +
> > +/**
> > + * __drm_atomic_helper_crtc_destroy_state - release CRTC state
> > + * @state: CRTC state object to release
> > + *
> > + * Releases all resources stored in the CRTC state without actually freeing
> > + * the memory of the CRTC state. This is useful for drivers that subclass the
> > + * CRTC state.
> > + */
> > +void __drm_atomic_helper_crtc_destroy_state(struct drm_crtc_state *state)
> > +{
> > +	if (state->commit) {
> > +		/*
> > +		 * In the event that a non-blocking commit returns
> > +		 * -ERESTARTSYS before the commit_tail work is queued, we will
> > +		 * have an extra reference to the commit object. Release it, if
> > +		 * the event has not been consumed by the worker.
> > +		 *
> > +		 * state->event may be freed, so we can't directly look at
> > +		 * state->event->base.completion.
> > +		 */
> > +		if (state->event && state->commit->abort_completion)
> > +			drm_crtc_commit_put(state->commit);
> > +
> > +		kfree(state->commit->event);
> > +		state->commit->event = NULL;
> > +
> > +		drm_crtc_commit_put(state->commit);
> > +	}
> > +
> > +	drm_property_blob_put(state->mode_blob);
> > +	drm_property_blob_put(state->degamma_lut);
> > +	drm_property_blob_put(state->ctm);
> > +	drm_property_blob_put(state->gamma_lut);
> > +}
> > +EXPORT_SYMBOL(__drm_atomic_helper_crtc_destroy_state);
> > +
> > +/**
> > + * drm_atomic_helper_crtc_destroy_state - default state destroy hook
> > + * @crtc: drm CRTC
> > + * @state: CRTC state object to release
> > + *
> > + * Default CRTC state destroy hook for drivers which don't have their own
> > + * subclassed CRTC state structure.
> > + */
> > +void drm_atomic_helper_crtc_destroy_state(struct drm_crtc *crtc,
> > +					  struct drm_crtc_state *state)
> > +{
> > +	__drm_atomic_helper_crtc_destroy_state(state);
> > +	kfree(state);
> > +}
> > +EXPORT_SYMBOL(drm_atomic_helper_crtc_destroy_state);
> > +
> > +/**
> > + * __drm_atomic_helper_plane_reset - resets planes state to default values
> > + * @plane: plane object, must not be NULL
> > + * @state: atomic plane state, must not be NULL
> > + *
> > + * Initializes plane state to default. This is useful for drivers that subclass
> > + * the plane state.
> > + */
> > +void __drm_atomic_helper_plane_reset(struct drm_plane *plane,
> > +				     struct drm_plane_state *state)
> > +{
> > +	state->plane = plane;
> > +	state->rotation = DRM_MODE_ROTATE_0;
> > +
> > +	state->alpha = DRM_BLEND_ALPHA_OPAQUE;
> > +	state->pixel_blend_mode = DRM_MODE_BLEND_PREMULTI;
> > +
> > +	plane->state = state;
> > +}
> > +EXPORT_SYMBOL(__drm_atomic_helper_plane_reset);
> > +
> > +/**
> > + * drm_atomic_helper_plane_reset - default &drm_plane_funcs.reset hook for planes
> > + * @plane: drm plane
> > + *
> > + * Resets the atomic state for @plane by freeing the state pointer (which might
> > + * be NULL, e.g. at driver load time) and allocating a new empty state object.
> > + */
> > +void drm_atomic_helper_plane_reset(struct drm_plane *plane)
> > +{
> > +	if (plane->state)
> > +		__drm_atomic_helper_plane_destroy_state(plane->state);
> > +
> > +	kfree(plane->state);
> > +	plane->state = kzalloc(sizeof(*plane->state), GFP_KERNEL);
> > +	if (plane->state)
> > +		__drm_atomic_helper_plane_reset(plane, plane->state);
> > +}
> > +EXPORT_SYMBOL(drm_atomic_helper_plane_reset);
> > +
> > +/**
> > + * __drm_atomic_helper_plane_duplicate_state - copy atomic plane state
> > + * @plane: plane object
> > + * @state: atomic plane state
> > + *
> > + * Copies atomic state from a plane's current state. This is useful for
> > + * drivers that subclass the plane state.
> > + */
> > +void __drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane,
> > +					       struct drm_plane_state *state)
> > +{
> > +	memcpy(state, plane->state, sizeof(*state));
> > +
> > +	if (state->fb)
> > +		drm_framebuffer_get(state->fb);
> > +
> > +	state->fence = NULL;
> > +	state->commit = NULL;
> > +}
> > +EXPORT_SYMBOL(__drm_atomic_helper_plane_duplicate_state);
> > +
> > +/**
> > + * drm_atomic_helper_plane_duplicate_state - default state duplicate hook
> > + * @plane: drm plane
> > + *
> > + * Default plane state duplicate hook for drivers which don't have their own
> > + * subclassed plane state structure.
> > + */
> > +struct drm_plane_state *
> > +drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane)
> > +{
> > +	struct drm_plane_state *state;
> > +
> > +	if (WARN_ON(!plane->state))
> > +		return NULL;
> > +
> > +	state = kmalloc(sizeof(*state), GFP_KERNEL);
> > +	if (state)
> > +		__drm_atomic_helper_plane_duplicate_state(plane, state);
> > +
> > +	return state;
> > +}
> > +EXPORT_SYMBOL(drm_atomic_helper_plane_duplicate_state);
> > +
> > +/**
> > + * __drm_atomic_helper_plane_destroy_state - release plane state
> > + * @state: plane state object to release
> > + *
> > + * Releases all resources stored in the plane state without actually freeing
> > + * the memory of the plane state. This is useful for drivers that subclass the
> > + * plane state.
> > + */
> > +void __drm_atomic_helper_plane_destroy_state(struct drm_plane_state *state)
> > +{
> > +	if (state->fb)
> > +		drm_framebuffer_put(state->fb);
> > +
> > +	if (state->fence)
> > +		dma_fence_put(state->fence);
> > +
> > +	if (state->commit)
> > +		drm_crtc_commit_put(state->commit);
> > +}
> > +EXPORT_SYMBOL(__drm_atomic_helper_plane_destroy_state);
> > +
> > +/**
> > + * drm_atomic_helper_plane_destroy_state - default state destroy hook
> > + * @plane: drm plane
> > + * @state: plane state object to release
> > + *
> > + * Default plane state destroy hook for drivers which don't have their own
> > + * subclassed plane state structure.
> > + */
> > +void drm_atomic_helper_plane_destroy_state(struct drm_plane *plane,
> > +					   struct drm_plane_state *state)
> > +{
> > +	__drm_atomic_helper_plane_destroy_state(state);
> > +	kfree(state);
> > +}
> > +EXPORT_SYMBOL(drm_atomic_helper_plane_destroy_state);
> > +
> > +/**
> > + * __drm_atomic_helper_connector_reset - reset state on connector
> > + * @connector: drm connector
> > + * @conn_state: connector state to assign
> > + *
> > + * Initializes the newly allocated @conn_state and assigns it to
> > + * the &drm_conector->state pointer of @connector, usually required when
> > + * initializing the drivers or when called from the &drm_connector_funcs.reset
> > + * hook.
> > + *
> > + * This is useful for drivers that subclass the connector state.
> > + */
> > +void
> > +__drm_atomic_helper_connector_reset(struct drm_connector *connector,
> > +				    struct drm_connector_state *conn_state)
> > +{
> > +	if (conn_state)
> > +		conn_state->connector = connector;
> > +
> > +	connector->state = conn_state;
> > +}
> > +EXPORT_SYMBOL(__drm_atomic_helper_connector_reset);
> > +
> > +/**
> > + * drm_atomic_helper_connector_reset - default &drm_connector_funcs.reset hook for connectors
> > + * @connector: drm connector
> > + *
> > + * Resets the atomic state for @connector by freeing the state pointer (which
> > + * might be NULL, e.g. at driver load time) and allocating a new empty state
> > + * object.
> > + */
> > +void drm_atomic_helper_connector_reset(struct drm_connector *connector)
> > +{
> > +	struct drm_connector_state *conn_state =
> > +		kzalloc(sizeof(*conn_state), GFP_KERNEL);
> > +
> > +	if (connector->state)
> > +		__drm_atomic_helper_connector_destroy_state(connector->state);
> > +
> > +	kfree(connector->state);
> > +	__drm_atomic_helper_connector_reset(connector, conn_state);
> > +}
> > +EXPORT_SYMBOL(drm_atomic_helper_connector_reset);
> > +
> > +/**
> > + * __drm_atomic_helper_connector_duplicate_state - copy atomic connector state
> > + * @connector: connector object
> > + * @state: atomic connector state
> > + *
> > + * Copies atomic state from a connector's current state. This is useful for
> > + * drivers that subclass the connector state.
> > + */
> > +void
> > +__drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector,
> > +					    struct drm_connector_state *state)
> > +{
> > +	memcpy(state, connector->state, sizeof(*state));
> > +	if (state->crtc)
> > +		drm_connector_get(connector);
> > +	state->commit = NULL;
> > +
> > +	/* Don't copy over a writeback job, they are used only once */
> > +	state->writeback_job = NULL;
> > +}
> > +EXPORT_SYMBOL(__drm_atomic_helper_connector_duplicate_state);
> > +
> > +/**
> > + * drm_atomic_helper_connector_duplicate_state - default state duplicate hook
> > + * @connector: drm connector
> > + *
> > + * Default connector state duplicate hook for drivers which don't have their own
> > + * subclassed connector state structure.
> > + */
> > +struct drm_connector_state *
> > +drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector)
> > +{
> > +	struct drm_connector_state *state;
> > +
> > +	if (WARN_ON(!connector->state))
> > +		return NULL;
> > +
> > +	state = kmalloc(sizeof(*state), GFP_KERNEL);
> > +	if (state)
> > +		__drm_atomic_helper_connector_duplicate_state(connector, state);
> > +
> > +	return state;
> > +}
> > +EXPORT_SYMBOL(drm_atomic_helper_connector_duplicate_state);
> > +
> > +/**
> > + * drm_atomic_helper_duplicate_state - duplicate an atomic state object
> > + * @dev: DRM device
> > + * @ctx: lock acquisition context
> > + *
> > + * Makes a copy of the current atomic state by looping over all objects and
> > + * duplicating their respective states. This is used for example by suspend/
> > + * resume support code to save the state prior to suspend such that it can
> > + * be restored upon resume.
> > + *
> > + * Note that this treats atomic state as persistent between save and restore.
> > + * Drivers must make sure that this is possible and won't result in confusion
> > + * or erroneous behaviour.
> > + *
> > + * Note that if callers haven't already acquired all modeset locks this might
> > + * return -EDEADLK, which must be handled by calling drm_modeset_backoff().
> > + *
> > + * Returns:
> > + * A pointer to the copy of the atomic state object on success or an
> > + * ERR_PTR()-encoded error code on failure.
> > + *
> > + * See also:
> > + * drm_atomic_helper_suspend(), drm_atomic_helper_resume()
> > + */
> > +struct drm_atomic_state *
> > +drm_atomic_helper_duplicate_state(struct drm_device *dev,
> > +				  struct drm_modeset_acquire_ctx *ctx)
> > +{
> > +	struct drm_atomic_state *state;
> > +	struct drm_connector *conn;
> > +	struct drm_connector_list_iter conn_iter;
> > +	struct drm_plane *plane;
> > +	struct drm_crtc *crtc;
> > +	int err = 0;
> > +
> > +	state = drm_atomic_state_alloc(dev);
> > +	if (!state)
> > +		return ERR_PTR(-ENOMEM);
> > +
> > +	state->acquire_ctx = ctx;
> > +
> > +	drm_for_each_crtc(crtc, dev) {
> > +		struct drm_crtc_state *crtc_state;
> > +
> > +		crtc_state = drm_atomic_get_crtc_state(state, crtc);
> > +		if (IS_ERR(crtc_state)) {
> > +			err = PTR_ERR(crtc_state);
> > +			goto free;
> > +		}
> > +	}
> > +
> > +	drm_for_each_plane(plane, dev) {
> > +		struct drm_plane_state *plane_state;
> > +
> > +		plane_state = drm_atomic_get_plane_state(state, plane);
> > +		if (IS_ERR(plane_state)) {
> > +			err = PTR_ERR(plane_state);
> > +			goto free;
> > +		}
> > +	}
> > +
> > +	drm_connector_list_iter_begin(dev, &conn_iter);
> > +	drm_for_each_connector_iter(conn, &conn_iter) {
> > +		struct drm_connector_state *conn_state;
> > +
> > +		conn_state = drm_atomic_get_connector_state(state, conn);
> > +		if (IS_ERR(conn_state)) {
> > +			err = PTR_ERR(conn_state);
> > +			drm_connector_list_iter_end(&conn_iter);
> > +			goto free;
> > +		}
> > +	}
> > +	drm_connector_list_iter_end(&conn_iter);
> > +
> > +	/* clear the acquire context so that it isn't accidentally reused */
> > +	state->acquire_ctx = NULL;
> > +
> > +free:
> > +	if (err < 0) {
> > +		drm_atomic_state_put(state);
> > +		state = ERR_PTR(err);
> > +	}
> > +
> > +	return state;
> > +}
> > +EXPORT_SYMBOL(drm_atomic_helper_duplicate_state);
> > +
> > +/**
> > + * __drm_atomic_helper_connector_destroy_state - release connector state
> > + * @state: connector state object to release
> > + *
> > + * Releases all resources stored in the connector state without actually
> > + * freeing the memory of the connector state. This is useful for drivers that
> > + * subclass the connector state.
> > + */
> > +void
> > +__drm_atomic_helper_connector_destroy_state(struct drm_connector_state *state)
> > +{
> > +	if (state->crtc)
> > +		drm_connector_put(state->connector);
> > +
> > +	if (state->commit)
> > +		drm_crtc_commit_put(state->commit);
> > +}
> > +EXPORT_SYMBOL(__drm_atomic_helper_connector_destroy_state);
> > +
> > +/**
> > + * drm_atomic_helper_connector_destroy_state - default state destroy hook
> > + * @connector: drm connector
> > + * @state: connector state object to release
> > + *
> > + * Default connector state destroy hook for drivers which don't have their own
> > + * subclassed connector state structure.
> > + */
> > +void drm_atomic_helper_connector_destroy_state(struct drm_connector *connector,
> > +					  struct drm_connector_state *state)
> > +{
> > +	__drm_atomic_helper_connector_destroy_state(state);
> > +	kfree(state);
> > +}
> > +EXPORT_SYMBOL(drm_atomic_helper_connector_destroy_state);
> > +
> > +/**
> > + * drm_atomic_helper_legacy_gamma_set - set the legacy gamma correction table
> > + * @crtc: CRTC object
> > + * @red: red correction table
> > + * @green: green correction table
> > + * @blue: green correction table
> > + * @size: size of the tables
> > + * @ctx: lock acquire context
> > + *
> > + * Implements support for legacy gamma correction table for drivers
> > + * that support color management through the DEGAMMA_LUT/GAMMA_LUT
> > + * properties. See drm_crtc_enable_color_mgmt() and the containing chapter for
> > + * how the atomic color management and gamma tables work.
> > + */
> > +int drm_atomic_helper_legacy_gamma_set(struct drm_crtc *crtc,
> > +				       u16 *red, u16 *green, u16 *blue,
> > +				       uint32_t size,
> > +				       struct drm_modeset_acquire_ctx *ctx)
> > +{
> > +	struct drm_device *dev = crtc->dev;
> > +	struct drm_atomic_state *state;
> > +	struct drm_crtc_state *crtc_state;
> > +	struct drm_property_blob *blob = NULL;
> > +	struct drm_color_lut *blob_data;
> > +	int i, ret = 0;
> > +	bool replaced;
> > +
> > +	state = drm_atomic_state_alloc(crtc->dev);
> > +	if (!state)
> > +		return -ENOMEM;
> > +
> > +	blob = drm_property_create_blob(dev,
> > +					sizeof(struct drm_color_lut) * size,
> > +					NULL);
> > +	if (IS_ERR(blob)) {
> > +		ret = PTR_ERR(blob);
> > +		blob = NULL;
> > +		goto fail;
> > +	}
> > +
> > +	/* Prepare GAMMA_LUT with the legacy values. */
> > +	blob_data = blob->data;
> > +	for (i = 0; i < size; i++) {
> > +		blob_data[i].red = red[i];
> > +		blob_data[i].green = green[i];
> > +		blob_data[i].blue = blue[i];
> > +	}
> > +
> > +	state->acquire_ctx = ctx;
> > +	crtc_state = drm_atomic_get_crtc_state(state, crtc);
> > +	if (IS_ERR(crtc_state)) {
> > +		ret = PTR_ERR(crtc_state);
> > +		goto fail;
> > +	}
> > +
> > +	/* Reset DEGAMMA_LUT and CTM properties. */
> > +	replaced  = drm_property_replace_blob(&crtc_state->degamma_lut, NULL);
> > +	replaced |= drm_property_replace_blob(&crtc_state->ctm, NULL);
> > +	replaced |= drm_property_replace_blob(&crtc_state->gamma_lut, blob);
> > +	crtc_state->color_mgmt_changed |= replaced;
> > +
> > +	ret = drm_atomic_commit(state);
> > +
> > +fail:
> > +	drm_atomic_state_put(state);
> > +	drm_property_blob_put(blob);
> > +	return ret;
> > +}
> > +EXPORT_SYMBOL(drm_atomic_helper_legacy_gamma_set);
> > +
> > +/**
> > + * __drm_atomic_helper_private_duplicate_state - copy atomic private state
> > + * @obj: CRTC object
> > + * @state: new private object state
> > + *
> > + * Copies atomic state from a private objects's current state and resets inferred values.
> > + * This is useful for drivers that subclass the private state.
> > + */
> > +void __drm_atomic_helper_private_obj_duplicate_state(struct drm_private_obj *obj,
> > +						     struct drm_private_state *state)
> > +{
> > +	memcpy(state, obj->state, sizeof(*state));
> > +}
> > +EXPORT_SYMBOL(__drm_atomic_helper_private_obj_duplicate_state);
> > diff --git a/include/drm/drm_atomic_helper.h b/include/drm/drm_atomic_helper.h
> > index e60c4f0f8827..25ca0097563e 100644
> > --- a/include/drm/drm_atomic_helper.h
> > +++ b/include/drm/drm_atomic_helper.h
> > @@ -31,6 +31,7 @@
> >  #include <drm/drm_crtc.h>
> >  #include <drm/drm_modeset_helper_vtables.h>
> >  #include <drm/drm_modeset_helper.h>
> > +#include <drm/drm_atomic_state_helper.h>
> >  #include <drm/drm_util.h>
> >  
> >  struct drm_atomic_state;
> > @@ -145,49 +146,6 @@ int drm_atomic_helper_page_flip_target(
> >  				uint32_t target,
> >  				struct drm_modeset_acquire_ctx *ctx);
> >  
> > -/* default implementations for state handling */
> > -void drm_atomic_helper_crtc_reset(struct drm_crtc *crtc);
> > -void __drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc,
> > -					      struct drm_crtc_state *state);
> > -struct drm_crtc_state *
> > -drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc);
> > -void __drm_atomic_helper_crtc_destroy_state(struct drm_crtc_state *state);
> > -void drm_atomic_helper_crtc_destroy_state(struct drm_crtc *crtc,
> > -					  struct drm_crtc_state *state);
> > -
> > -void __drm_atomic_helper_plane_reset(struct drm_plane *plane,
> > -				     struct drm_plane_state *state);
> > -void drm_atomic_helper_plane_reset(struct drm_plane *plane);
> > -void __drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane,
> > -					       struct drm_plane_state *state);
> > -struct drm_plane_state *
> > -drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane);
> > -void __drm_atomic_helper_plane_destroy_state(struct drm_plane_state *state);
> > -void drm_atomic_helper_plane_destroy_state(struct drm_plane *plane,
> > -					  struct drm_plane_state *state);
> > -
> > -void __drm_atomic_helper_connector_reset(struct drm_connector *connector,
> > -					 struct drm_connector_state *conn_state);
> > -void drm_atomic_helper_connector_reset(struct drm_connector *connector);
> > -void
> > -__drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector,
> > -					   struct drm_connector_state *state);
> > -struct drm_connector_state *
> > -drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector);
> > -struct drm_atomic_state *
> > -drm_atomic_helper_duplicate_state(struct drm_device *dev,
> > -				  struct drm_modeset_acquire_ctx *ctx);
> > -void
> > -__drm_atomic_helper_connector_destroy_state(struct drm_connector_state *state);
> > -void drm_atomic_helper_connector_destroy_state(struct drm_connector *connector,
> > -					  struct drm_connector_state *state);
> > -int drm_atomic_helper_legacy_gamma_set(struct drm_crtc *crtc,
> > -				       u16 *red, u16 *green, u16 *blue,
> > -				       uint32_t size,
> > -				       struct drm_modeset_acquire_ctx *ctx);
> > -void __drm_atomic_helper_private_obj_duplicate_state(struct drm_private_obj *obj,
> > -						     struct drm_private_state *state);
> > -
> >  /**
> >   * drm_atomic_crtc_for_each_plane - iterate over planes currently attached to CRTC
> >   * @plane: the loop cursor
> > diff --git a/include/drm/drm_atomic_state_helper.h b/include/drm/drm_atomic_state_helper.h
> > new file mode 100644
> > index 000000000000..5b82ccfdb502
> > --- /dev/null
> > +++ b/include/drm/drm_atomic_state_helper.h
> > @@ -0,0 +1,80 @@
> > +/*
> > + * Copyright (C) 2018 Intel Corp.
> > + *
> > + * Permission is hereby granted, free of charge, to any person obtaining a
> > + * copy of this software and associated documentation files (the "Software"),
> > + * to deal in the Software without restriction, including without limitation
> > + * the rights to use, copy, modify, merge, publish, distribute, sublicense,
> > + * and/or sell copies of the Software, and to permit persons to whom the
> > + * Software is furnished to do so, subject to the following conditions:
> > + *
> > + * The above copyright notice and this permission notice shall be included in
> > + * all copies or substantial portions of the Software.
> > + *
> > + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
> > + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
> > + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
> > + * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
> > + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
> > + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
> > + * OTHER DEALINGS IN THE SOFTWARE.
> > + *
> > + * Authors:
> > + * Rob Clark <robdclark@gmail.com>
> > + * Daniel Vetter <daniel.vetter@ffwll.ch>
> > + */
> > +
> > +#include <linux/types.h>
> > +
> > +struct drm_crtc;
> > +struct drm_crtc_state;
> > +struct drm_plane;
> > +struct drm_plane_state;
> > +struct drm_connector;
> > +struct drm_connector_state;
> > +struct drm_private_obj;
> > +struct drm_private_state;
> > +struct drm_modeset_acquire_ctx;
> > +struct drm_device;
> > +
> > +void drm_atomic_helper_crtc_reset(struct drm_crtc *crtc);
> > +void __drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc,
> > +					      struct drm_crtc_state *state);
> > +struct drm_crtc_state *
> > +drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc);
> > +void __drm_atomic_helper_crtc_destroy_state(struct drm_crtc_state *state);
> > +void drm_atomic_helper_crtc_destroy_state(struct drm_crtc *crtc,
> > +					  struct drm_crtc_state *state);
> > +
> > +void __drm_atomic_helper_plane_reset(struct drm_plane *plane,
> > +				     struct drm_plane_state *state);
> > +void drm_atomic_helper_plane_reset(struct drm_plane *plane);
> > +void __drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane,
> > +					       struct drm_plane_state *state);
> > +struct drm_plane_state *
> > +drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane);
> > +void __drm_atomic_helper_plane_destroy_state(struct drm_plane_state *state);
> > +void drm_atomic_helper_plane_destroy_state(struct drm_plane *plane,
> > +					  struct drm_plane_state *state);
> > +
> > +void __drm_atomic_helper_connector_reset(struct drm_connector *connector,
> > +					 struct drm_connector_state *conn_state);
> > +void drm_atomic_helper_connector_reset(struct drm_connector *connector);
> > +void
> > +__drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector,
> > +					   struct drm_connector_state *state);
> > +struct drm_connector_state *
> > +drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector);
> > +struct drm_atomic_state *
> > +drm_atomic_helper_duplicate_state(struct drm_device *dev,
> > +				  struct drm_modeset_acquire_ctx *ctx);
> > +void
> > +__drm_atomic_helper_connector_destroy_state(struct drm_connector_state *state);
> > +void drm_atomic_helper_connector_destroy_state(struct drm_connector *connector,
> > +					  struct drm_connector_state *state);
> > +int drm_atomic_helper_legacy_gamma_set(struct drm_crtc *crtc,
> > +				       u16 *red, u16 *green, u16 *blue,
> > +				       uint32_t size,
> > +				       struct drm_modeset_acquire_ctx *ctx);
> > +void __drm_atomic_helper_private_obj_duplicate_state(struct drm_private_obj *obj,
> > +						     struct drm_private_state *state);
> > -- 
> > 2.19.0.rc2
> > 
> > _______________________________________________
> > Intel-gfx mailing list
> > Intel-gfx@lists.freedesktop.org
> > https://lists.freedesktop.org/mailman/listinfo/intel-gfx
> 
> -- 
> Ville Syrjälä
> Intel

Patch
diff mbox series

diff --git a/Documentation/gpu/drm-kms-helpers.rst b/Documentation/gpu/drm-kms-helpers.rst
index f9cfcdcdf024..4b4dc236ef6f 100644
--- a/Documentation/gpu/drm-kms-helpers.rst
+++ b/Documentation/gpu/drm-kms-helpers.rst
@@ -59,19 +59,28 @@  Implementing Asynchronous Atomic Commit
 .. kernel-doc:: drivers/gpu/drm/drm_atomic_helper.c
    :doc: implementing nonblocking commit
 
+Helper Functions Reference
+--------------------------
+
+.. kernel-doc:: include/drm/drm_atomic_helper.h
+   :internal:
+
+.. kernel-doc:: drivers/gpu/drm/drm_atomic_helper.c
+   :export:
+
 Atomic State Reset and Initialization
 -------------------------------------
 
-.. kernel-doc:: drivers/gpu/drm/drm_atomic_helper.c
+.. kernel-doc:: drivers/gpu/drm/drm_atomic_state_helper.c
    :doc: atomic state reset and initialization
 
-Helper Functions Reference
---------------------------
+Atomic State Helper Reference
+-----------------------------
 
-.. kernel-doc:: include/drm/drm_atomic_helper.h
+.. kernel-doc:: include/drm/drm_atomic_state_helper.h
    :internal:
 
-.. kernel-doc:: drivers/gpu/drm/drm_atomic_helper.c
+.. kernel-doc:: drivers/gpu/drm/drm_atomic_state_helper.c
    :export:
 
 Simple KMS Helper Reference
diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile
index bc6a16a3c36e..576ba985e138 100644
--- a/drivers/gpu/drm/Makefile
+++ b/drivers/gpu/drm/Makefile
@@ -36,7 +36,8 @@  drm_kms_helper-y := drm_crtc_helper.o drm_dp_helper.o drm_probe_helper.o \
 		drm_plane_helper.o drm_dp_mst_topology.o drm_atomic_helper.o \
 		drm_kms_helper_common.o drm_dp_dual_mode_helper.o \
 		drm_simple_kms_helper.o drm_modeset_helper.o \
-		drm_scdc_helper.o drm_gem_framebuffer_helper.o
+		drm_scdc_helper.o drm_gem_framebuffer_helper.o \
+		drm_atomic_state_helper.o
 
 drm_kms_helper-$(CONFIG_DRM_PANEL_BRIDGE) += bridge/panel.o
 drm_kms_helper-$(CONFIG_DRM_FBDEV_EMULATION) += drm_fb_helper.o
diff --git a/drivers/gpu/drm/drm_atomic_helper.c b/drivers/gpu/drm/drm_atomic_helper.c
index 8c93f33fe92f..a5edc8757056 100644
--- a/drivers/gpu/drm/drm_atomic_helper.c
+++ b/drivers/gpu/drm/drm_atomic_helper.c
@@ -3382,569 +3382,3 @@  int drm_atomic_helper_page_flip_target(struct drm_crtc *crtc,
 	return ret;
 }
 EXPORT_SYMBOL(drm_atomic_helper_page_flip_target);
-
-/**
- * DOC: atomic state reset and initialization
- *
- * Both the drm core and the atomic helpers assume that there is always the full
- * and correct atomic software state for all connectors, CRTCs and planes
- * available. Which is a bit a problem on driver load and also after system
- * suspend. One way to solve this is to have a hardware state read-out
- * infrastructure which reconstructs the full software state (e.g. the i915
- * driver).
- *
- * The simpler solution is to just reset the software state to everything off,
- * which is easiest to do by calling drm_mode_config_reset(). To facilitate this
- * the atomic helpers provide default reset implementations for all hooks.
- *
- * On the upside the precise state tracking of atomic simplifies system suspend
- * and resume a lot. For drivers using drm_mode_config_reset() a complete recipe
- * is implemented in drm_atomic_helper_suspend() and drm_atomic_helper_resume().
- * For other drivers the building blocks are split out, see the documentation
- * for these functions.
- */
-
-/**
- * drm_atomic_helper_crtc_reset - default &drm_crtc_funcs.reset hook for CRTCs
- * @crtc: drm CRTC
- *
- * Resets the atomic state for @crtc by freeing the state pointer (which might
- * be NULL, e.g. at driver load time) and allocating a new empty state object.
- */
-void drm_atomic_helper_crtc_reset(struct drm_crtc *crtc)
-{
-	if (crtc->state)
-		__drm_atomic_helper_crtc_destroy_state(crtc->state);
-
-	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);
-
-/**
- * __drm_atomic_helper_crtc_duplicate_state - copy atomic CRTC state
- * @crtc: CRTC object
- * @state: atomic CRTC state
- *
- * Copies atomic state from a CRTC's current state and resets inferred values.
- * This is useful for drivers that subclass the CRTC state.
- */
-void __drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc,
-					      struct drm_crtc_state *state)
-{
-	memcpy(state, crtc->state, sizeof(*state));
-
-	if (state->mode_blob)
-		drm_property_blob_get(state->mode_blob);
-	if (state->degamma_lut)
-		drm_property_blob_get(state->degamma_lut);
-	if (state->ctm)
-		drm_property_blob_get(state->ctm);
-	if (state->gamma_lut)
-		drm_property_blob_get(state->gamma_lut);
-	state->mode_changed = false;
-	state->active_changed = false;
-	state->planes_changed = false;
-	state->connectors_changed = false;
-	state->color_mgmt_changed = false;
-	state->zpos_changed = false;
-	state->commit = NULL;
-	state->event = NULL;
-	state->pageflip_flags = 0;
-}
-EXPORT_SYMBOL(__drm_atomic_helper_crtc_duplicate_state);
-
-/**
- * drm_atomic_helper_crtc_duplicate_state - default state duplicate hook
- * @crtc: drm CRTC
- *
- * Default CRTC state duplicate hook for drivers which don't have their own
- * subclassed CRTC state structure.
- */
-struct drm_crtc_state *
-drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc)
-{
-	struct drm_crtc_state *state;
-
-	if (WARN_ON(!crtc->state))
-		return NULL;
-
-	state = kmalloc(sizeof(*state), GFP_KERNEL);
-	if (state)
-		__drm_atomic_helper_crtc_duplicate_state(crtc, state);
-
-	return state;
-}
-EXPORT_SYMBOL(drm_atomic_helper_crtc_duplicate_state);
-
-/**
- * __drm_atomic_helper_crtc_destroy_state - release CRTC state
- * @state: CRTC state object to release
- *
- * Releases all resources stored in the CRTC state without actually freeing
- * the memory of the CRTC state. This is useful for drivers that subclass the
- * CRTC state.
- */
-void __drm_atomic_helper_crtc_destroy_state(struct drm_crtc_state *state)
-{
-	if (state->commit) {
-		/*
-		 * In the event that a non-blocking commit returns
-		 * -ERESTARTSYS before the commit_tail work is queued, we will
-		 * have an extra reference to the commit object. Release it, if
-		 * the event has not been consumed by the worker.
-		 *
-		 * state->event may be freed, so we can't directly look at
-		 * state->event->base.completion.
-		 */
-		if (state->event && state->commit->abort_completion)
-			drm_crtc_commit_put(state->commit);
-
-		kfree(state->commit->event);
-		state->commit->event = NULL;
-
-		drm_crtc_commit_put(state->commit);
-	}
-
-	drm_property_blob_put(state->mode_blob);
-	drm_property_blob_put(state->degamma_lut);
-	drm_property_blob_put(state->ctm);
-	drm_property_blob_put(state->gamma_lut);
-}
-EXPORT_SYMBOL(__drm_atomic_helper_crtc_destroy_state);
-
-/**
- * drm_atomic_helper_crtc_destroy_state - default state destroy hook
- * @crtc: drm CRTC
- * @state: CRTC state object to release
- *
- * Default CRTC state destroy hook for drivers which don't have their own
- * subclassed CRTC state structure.
- */
-void drm_atomic_helper_crtc_destroy_state(struct drm_crtc *crtc,
-					  struct drm_crtc_state *state)
-{
-	__drm_atomic_helper_crtc_destroy_state(state);
-	kfree(state);
-}
-EXPORT_SYMBOL(drm_atomic_helper_crtc_destroy_state);
-
-/**
- * __drm_atomic_helper_plane_reset - resets planes state to default values
- * @plane: plane object, must not be NULL
- * @state: atomic plane state, must not be NULL
- *
- * Initializes plane state to default. This is useful for drivers that subclass
- * the plane state.
- */
-void __drm_atomic_helper_plane_reset(struct drm_plane *plane,
-				     struct drm_plane_state *state)
-{
-	state->plane = plane;
-	state->rotation = DRM_MODE_ROTATE_0;
-
-	state->alpha = DRM_BLEND_ALPHA_OPAQUE;
-	state->pixel_blend_mode = DRM_MODE_BLEND_PREMULTI;
-
-	plane->state = state;
-}
-EXPORT_SYMBOL(__drm_atomic_helper_plane_reset);
-
-/**
- * drm_atomic_helper_plane_reset - default &drm_plane_funcs.reset hook for planes
- * @plane: drm plane
- *
- * Resets the atomic state for @plane by freeing the state pointer (which might
- * be NULL, e.g. at driver load time) and allocating a new empty state object.
- */
-void drm_atomic_helper_plane_reset(struct drm_plane *plane)
-{
-	if (plane->state)
-		__drm_atomic_helper_plane_destroy_state(plane->state);
-
-	kfree(plane->state);
-	plane->state = kzalloc(sizeof(*plane->state), GFP_KERNEL);
-	if (plane->state)
-		__drm_atomic_helper_plane_reset(plane, plane->state);
-}
-EXPORT_SYMBOL(drm_atomic_helper_plane_reset);
-
-/**
- * __drm_atomic_helper_plane_duplicate_state - copy atomic plane state
- * @plane: plane object
- * @state: atomic plane state
- *
- * Copies atomic state from a plane's current state. This is useful for
- * drivers that subclass the plane state.
- */
-void __drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane,
-					       struct drm_plane_state *state)
-{
-	memcpy(state, plane->state, sizeof(*state));
-
-	if (state->fb)
-		drm_framebuffer_get(state->fb);
-
-	state->fence = NULL;
-	state->commit = NULL;
-}
-EXPORT_SYMBOL(__drm_atomic_helper_plane_duplicate_state);
-
-/**
- * drm_atomic_helper_plane_duplicate_state - default state duplicate hook
- * @plane: drm plane
- *
- * Default plane state duplicate hook for drivers which don't have their own
- * subclassed plane state structure.
- */
-struct drm_plane_state *
-drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane)
-{
-	struct drm_plane_state *state;
-
-	if (WARN_ON(!plane->state))
-		return NULL;
-
-	state = kmalloc(sizeof(*state), GFP_KERNEL);
-	if (state)
-		__drm_atomic_helper_plane_duplicate_state(plane, state);
-
-	return state;
-}
-EXPORT_SYMBOL(drm_atomic_helper_plane_duplicate_state);
-
-/**
- * __drm_atomic_helper_plane_destroy_state - release plane state
- * @state: plane state object to release
- *
- * Releases all resources stored in the plane state without actually freeing
- * the memory of the plane state. This is useful for drivers that subclass the
- * plane state.
- */
-void __drm_atomic_helper_plane_destroy_state(struct drm_plane_state *state)
-{
-	if (state->fb)
-		drm_framebuffer_put(state->fb);
-
-	if (state->fence)
-		dma_fence_put(state->fence);
-
-	if (state->commit)
-		drm_crtc_commit_put(state->commit);
-}
-EXPORT_SYMBOL(__drm_atomic_helper_plane_destroy_state);
-
-/**
- * drm_atomic_helper_plane_destroy_state - default state destroy hook
- * @plane: drm plane
- * @state: plane state object to release
- *
- * Default plane state destroy hook for drivers which don't have their own
- * subclassed plane state structure.
- */
-void drm_atomic_helper_plane_destroy_state(struct drm_plane *plane,
-					   struct drm_plane_state *state)
-{
-	__drm_atomic_helper_plane_destroy_state(state);
-	kfree(state);
-}
-EXPORT_SYMBOL(drm_atomic_helper_plane_destroy_state);
-
-/**
- * __drm_atomic_helper_connector_reset - reset state on connector
- * @connector: drm connector
- * @conn_state: connector state to assign
- *
- * Initializes the newly allocated @conn_state and assigns it to
- * the &drm_conector->state pointer of @connector, usually required when
- * initializing the drivers or when called from the &drm_connector_funcs.reset
- * hook.
- *
- * This is useful for drivers that subclass the connector state.
- */
-void
-__drm_atomic_helper_connector_reset(struct drm_connector *connector,
-				    struct drm_connector_state *conn_state)
-{
-	if (conn_state)
-		conn_state->connector = connector;
-
-	connector->state = conn_state;
-}
-EXPORT_SYMBOL(__drm_atomic_helper_connector_reset);
-
-/**
- * drm_atomic_helper_connector_reset - default &drm_connector_funcs.reset hook for connectors
- * @connector: drm connector
- *
- * Resets the atomic state for @connector by freeing the state pointer (which
- * might be NULL, e.g. at driver load time) and allocating a new empty state
- * object.
- */
-void drm_atomic_helper_connector_reset(struct drm_connector *connector)
-{
-	struct drm_connector_state *conn_state =
-		kzalloc(sizeof(*conn_state), GFP_KERNEL);
-
-	if (connector->state)
-		__drm_atomic_helper_connector_destroy_state(connector->state);
-
-	kfree(connector->state);
-	__drm_atomic_helper_connector_reset(connector, conn_state);
-}
-EXPORT_SYMBOL(drm_atomic_helper_connector_reset);
-
-/**
- * __drm_atomic_helper_connector_duplicate_state - copy atomic connector state
- * @connector: connector object
- * @state: atomic connector state
- *
- * Copies atomic state from a connector's current state. This is useful for
- * drivers that subclass the connector state.
- */
-void
-__drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector,
-					    struct drm_connector_state *state)
-{
-	memcpy(state, connector->state, sizeof(*state));
-	if (state->crtc)
-		drm_connector_get(connector);
-	state->commit = NULL;
-
-	/* Don't copy over a writeback job, they are used only once */
-	state->writeback_job = NULL;
-}
-EXPORT_SYMBOL(__drm_atomic_helper_connector_duplicate_state);
-
-/**
- * drm_atomic_helper_connector_duplicate_state - default state duplicate hook
- * @connector: drm connector
- *
- * Default connector state duplicate hook for drivers which don't have their own
- * subclassed connector state structure.
- */
-struct drm_connector_state *
-drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector)
-{
-	struct drm_connector_state *state;
-
-	if (WARN_ON(!connector->state))
-		return NULL;
-
-	state = kmalloc(sizeof(*state), GFP_KERNEL);
-	if (state)
-		__drm_atomic_helper_connector_duplicate_state(connector, state);
-
-	return state;
-}
-EXPORT_SYMBOL(drm_atomic_helper_connector_duplicate_state);
-
-/**
- * drm_atomic_helper_duplicate_state - duplicate an atomic state object
- * @dev: DRM device
- * @ctx: lock acquisition context
- *
- * Makes a copy of the current atomic state by looping over all objects and
- * duplicating their respective states. This is used for example by suspend/
- * resume support code to save the state prior to suspend such that it can
- * be restored upon resume.
- *
- * Note that this treats atomic state as persistent between save and restore.
- * Drivers must make sure that this is possible and won't result in confusion
- * or erroneous behaviour.
- *
- * Note that if callers haven't already acquired all modeset locks this might
- * return -EDEADLK, which must be handled by calling drm_modeset_backoff().
- *
- * Returns:
- * A pointer to the copy of the atomic state object on success or an
- * ERR_PTR()-encoded error code on failure.
- *
- * See also:
- * drm_atomic_helper_suspend(), drm_atomic_helper_resume()
- */
-struct drm_atomic_state *
-drm_atomic_helper_duplicate_state(struct drm_device *dev,
-				  struct drm_modeset_acquire_ctx *ctx)
-{
-	struct drm_atomic_state *state;
-	struct drm_connector *conn;
-	struct drm_connector_list_iter conn_iter;
-	struct drm_plane *plane;
-	struct drm_crtc *crtc;
-	int err = 0;
-
-	state = drm_atomic_state_alloc(dev);
-	if (!state)
-		return ERR_PTR(-ENOMEM);
-
-	state->acquire_ctx = ctx;
-
-	drm_for_each_crtc(crtc, dev) {
-		struct drm_crtc_state *crtc_state;
-
-		crtc_state = drm_atomic_get_crtc_state(state, crtc);
-		if (IS_ERR(crtc_state)) {
-			err = PTR_ERR(crtc_state);
-			goto free;
-		}
-	}
-
-	drm_for_each_plane(plane, dev) {
-		struct drm_plane_state *plane_state;
-
-		plane_state = drm_atomic_get_plane_state(state, plane);
-		if (IS_ERR(plane_state)) {
-			err = PTR_ERR(plane_state);
-			goto free;
-		}
-	}
-
-	drm_connector_list_iter_begin(dev, &conn_iter);
-	drm_for_each_connector_iter(conn, &conn_iter) {
-		struct drm_connector_state *conn_state;
-
-		conn_state = drm_atomic_get_connector_state(state, conn);
-		if (IS_ERR(conn_state)) {
-			err = PTR_ERR(conn_state);
-			drm_connector_list_iter_end(&conn_iter);
-			goto free;
-		}
-	}
-	drm_connector_list_iter_end(&conn_iter);
-
-	/* clear the acquire context so that it isn't accidentally reused */
-	state->acquire_ctx = NULL;
-
-free:
-	if (err < 0) {
-		drm_atomic_state_put(state);
-		state = ERR_PTR(err);
-	}
-
-	return state;
-}
-EXPORT_SYMBOL(drm_atomic_helper_duplicate_state);
-
-/**
- * __drm_atomic_helper_connector_destroy_state - release connector state
- * @state: connector state object to release
- *
- * Releases all resources stored in the connector state without actually
- * freeing the memory of the connector state. This is useful for drivers that
- * subclass the connector state.
- */
-void
-__drm_atomic_helper_connector_destroy_state(struct drm_connector_state *state)
-{
-	if (state->crtc)
-		drm_connector_put(state->connector);
-
-	if (state->commit)
-		drm_crtc_commit_put(state->commit);
-}
-EXPORT_SYMBOL(__drm_atomic_helper_connector_destroy_state);
-
-/**
- * drm_atomic_helper_connector_destroy_state - default state destroy hook
- * @connector: drm connector
- * @state: connector state object to release
- *
- * Default connector state destroy hook for drivers which don't have their own
- * subclassed connector state structure.
- */
-void drm_atomic_helper_connector_destroy_state(struct drm_connector *connector,
-					  struct drm_connector_state *state)
-{
-	__drm_atomic_helper_connector_destroy_state(state);
-	kfree(state);
-}
-EXPORT_SYMBOL(drm_atomic_helper_connector_destroy_state);
-
-/**
- * drm_atomic_helper_legacy_gamma_set - set the legacy gamma correction table
- * @crtc: CRTC object
- * @red: red correction table
- * @green: green correction table
- * @blue: green correction table
- * @size: size of the tables
- * @ctx: lock acquire context
- *
- * Implements support for legacy gamma correction table for drivers
- * that support color management through the DEGAMMA_LUT/GAMMA_LUT
- * properties. See drm_crtc_enable_color_mgmt() and the containing chapter for
- * how the atomic color management and gamma tables work.
- */
-int drm_atomic_helper_legacy_gamma_set(struct drm_crtc *crtc,
-				       u16 *red, u16 *green, u16 *blue,
-				       uint32_t size,
-				       struct drm_modeset_acquire_ctx *ctx)
-{
-	struct drm_device *dev = crtc->dev;
-	struct drm_atomic_state *state;
-	struct drm_crtc_state *crtc_state;
-	struct drm_property_blob *blob = NULL;
-	struct drm_color_lut *blob_data;
-	int i, ret = 0;
-	bool replaced;
-
-	state = drm_atomic_state_alloc(crtc->dev);
-	if (!state)
-		return -ENOMEM;
-
-	blob = drm_property_create_blob(dev,
-					sizeof(struct drm_color_lut) * size,
-					NULL);
-	if (IS_ERR(blob)) {
-		ret = PTR_ERR(blob);
-		blob = NULL;
-		goto fail;
-	}
-
-	/* Prepare GAMMA_LUT with the legacy values. */
-	blob_data = blob->data;
-	for (i = 0; i < size; i++) {
-		blob_data[i].red = red[i];
-		blob_data[i].green = green[i];
-		blob_data[i].blue = blue[i];
-	}
-
-	state->acquire_ctx = ctx;
-	crtc_state = drm_atomic_get_crtc_state(state, crtc);
-	if (IS_ERR(crtc_state)) {
-		ret = PTR_ERR(crtc_state);
-		goto fail;
-	}
-
-	/* Reset DEGAMMA_LUT and CTM properties. */
-	replaced  = drm_property_replace_blob(&crtc_state->degamma_lut, NULL);
-	replaced |= drm_property_replace_blob(&crtc_state->ctm, NULL);
-	replaced |= drm_property_replace_blob(&crtc_state->gamma_lut, blob);
-	crtc_state->color_mgmt_changed |= replaced;
-
-	ret = drm_atomic_commit(state);
-
-fail:
-	drm_atomic_state_put(state);
-	drm_property_blob_put(blob);
-	return ret;
-}
-EXPORT_SYMBOL(drm_atomic_helper_legacy_gamma_set);
-
-/**
- * __drm_atomic_helper_private_duplicate_state - copy atomic private state
- * @obj: CRTC object
- * @state: new private object state
- *
- * Copies atomic state from a private objects's current state and resets inferred values.
- * This is useful for drivers that subclass the private state.
- */
-void __drm_atomic_helper_private_obj_duplicate_state(struct drm_private_obj *obj,
-						     struct drm_private_state *state)
-{
-	memcpy(state, obj->state, sizeof(*state));
-}
-EXPORT_SYMBOL(__drm_atomic_helper_private_obj_duplicate_state);
diff --git a/drivers/gpu/drm/drm_atomic_state_helper.c b/drivers/gpu/drm/drm_atomic_state_helper.c
new file mode 100644
index 000000000000..3ba996069d69
--- /dev/null
+++ b/drivers/gpu/drm/drm_atomic_state_helper.c
@@ -0,0 +1,601 @@ 
+/*
+ * Copyright (C) 2018 Intel Corp.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ * Rob Clark <robdclark@gmail.com>
+ * Daniel Vetter <daniel.vetter@ffwll.ch>
+ */
+
+#include <drm/drm_atomic_state_helper.h>
+#include <drm/drm_crtc.h>
+#include <drm/drm_plane.h>
+#include <drm/drm_connector.h>
+#include <drm/drm_atomic.h>
+#include <drm/drm_device.h>
+
+#include <linux/slab.h>
+#include <linux/dma-fence.h>
+
+/**
+ * DOC: atomic state reset and initialization
+ *
+ * Both the drm core and the atomic helpers assume that there is always the full
+ * and correct atomic software state for all connectors, CRTCs and planes
+ * available. Which is a bit a problem on driver load and also after system
+ * suspend. One way to solve this is to have a hardware state read-out
+ * infrastructure which reconstructs the full software state (e.g. the i915
+ * driver).
+ *
+ * The simpler solution is to just reset the software state to everything off,
+ * which is easiest to do by calling drm_mode_config_reset(). To facilitate this
+ * the atomic helpers provide default reset implementations for all hooks.
+ *
+ * On the upside the precise state tracking of atomic simplifies system suspend
+ * and resume a lot. For drivers using drm_mode_config_reset() a complete recipe
+ * is implemented in drm_atomic_helper_suspend() and drm_atomic_helper_resume().
+ * For other drivers the building blocks are split out, see the documentation
+ * for these functions.
+ */
+
+/**
+ * drm_atomic_helper_crtc_reset - default &drm_crtc_funcs.reset hook for CRTCs
+ * @crtc: drm CRTC
+ *
+ * Resets the atomic state for @crtc by freeing the state pointer (which might
+ * be NULL, e.g. at driver load time) and allocating a new empty state object.
+ */
+void drm_atomic_helper_crtc_reset(struct drm_crtc *crtc)
+{
+	if (crtc->state)
+		__drm_atomic_helper_crtc_destroy_state(crtc->state);
+
+	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);
+
+/**
+ * __drm_atomic_helper_crtc_duplicate_state - copy atomic CRTC state
+ * @crtc: CRTC object
+ * @state: atomic CRTC state
+ *
+ * Copies atomic state from a CRTC's current state and resets inferred values.
+ * This is useful for drivers that subclass the CRTC state.
+ */
+void __drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc,
+					      struct drm_crtc_state *state)
+{
+	memcpy(state, crtc->state, sizeof(*state));
+
+	if (state->mode_blob)
+		drm_property_blob_get(state->mode_blob);
+	if (state->degamma_lut)
+		drm_property_blob_get(state->degamma_lut);
+	if (state->ctm)
+		drm_property_blob_get(state->ctm);
+	if (state->gamma_lut)
+		drm_property_blob_get(state->gamma_lut);
+	state->mode_changed = false;
+	state->active_changed = false;
+	state->planes_changed = false;
+	state->connectors_changed = false;
+	state->color_mgmt_changed = false;
+	state->zpos_changed = false;
+	state->commit = NULL;
+	state->event = NULL;
+	state->pageflip_flags = 0;
+}
+EXPORT_SYMBOL(__drm_atomic_helper_crtc_duplicate_state);
+
+/**
+ * drm_atomic_helper_crtc_duplicate_state - default state duplicate hook
+ * @crtc: drm CRTC
+ *
+ * Default CRTC state duplicate hook for drivers which don't have their own
+ * subclassed CRTC state structure.
+ */
+struct drm_crtc_state *
+drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc)
+{
+	struct drm_crtc_state *state;
+
+	if (WARN_ON(!crtc->state))
+		return NULL;
+
+	state = kmalloc(sizeof(*state), GFP_KERNEL);
+	if (state)
+		__drm_atomic_helper_crtc_duplicate_state(crtc, state);
+
+	return state;
+}
+EXPORT_SYMBOL(drm_atomic_helper_crtc_duplicate_state);
+
+/**
+ * __drm_atomic_helper_crtc_destroy_state - release CRTC state
+ * @state: CRTC state object to release
+ *
+ * Releases all resources stored in the CRTC state without actually freeing
+ * the memory of the CRTC state. This is useful for drivers that subclass the
+ * CRTC state.
+ */
+void __drm_atomic_helper_crtc_destroy_state(struct drm_crtc_state *state)
+{
+	if (state->commit) {
+		/*
+		 * In the event that a non-blocking commit returns
+		 * -ERESTARTSYS before the commit_tail work is queued, we will
+		 * have an extra reference to the commit object. Release it, if
+		 * the event has not been consumed by the worker.
+		 *
+		 * state->event may be freed, so we can't directly look at
+		 * state->event->base.completion.
+		 */
+		if (state->event && state->commit->abort_completion)
+			drm_crtc_commit_put(state->commit);
+
+		kfree(state->commit->event);
+		state->commit->event = NULL;
+
+		drm_crtc_commit_put(state->commit);
+	}
+
+	drm_property_blob_put(state->mode_blob);
+	drm_property_blob_put(state->degamma_lut);
+	drm_property_blob_put(state->ctm);
+	drm_property_blob_put(state->gamma_lut);
+}
+EXPORT_SYMBOL(__drm_atomic_helper_crtc_destroy_state);
+
+/**
+ * drm_atomic_helper_crtc_destroy_state - default state destroy hook
+ * @crtc: drm CRTC
+ * @state: CRTC state object to release
+ *
+ * Default CRTC state destroy hook for drivers which don't have their own
+ * subclassed CRTC state structure.
+ */
+void drm_atomic_helper_crtc_destroy_state(struct drm_crtc *crtc,
+					  struct drm_crtc_state *state)
+{
+	__drm_atomic_helper_crtc_destroy_state(state);
+	kfree(state);
+}
+EXPORT_SYMBOL(drm_atomic_helper_crtc_destroy_state);
+
+/**
+ * __drm_atomic_helper_plane_reset - resets planes state to default values
+ * @plane: plane object, must not be NULL
+ * @state: atomic plane state, must not be NULL
+ *
+ * Initializes plane state to default. This is useful for drivers that subclass
+ * the plane state.
+ */
+void __drm_atomic_helper_plane_reset(struct drm_plane *plane,
+				     struct drm_plane_state *state)
+{
+	state->plane = plane;
+	state->rotation = DRM_MODE_ROTATE_0;
+
+	state->alpha = DRM_BLEND_ALPHA_OPAQUE;
+	state->pixel_blend_mode = DRM_MODE_BLEND_PREMULTI;
+
+	plane->state = state;
+}
+EXPORT_SYMBOL(__drm_atomic_helper_plane_reset);
+
+/**
+ * drm_atomic_helper_plane_reset - default &drm_plane_funcs.reset hook for planes
+ * @plane: drm plane
+ *
+ * Resets the atomic state for @plane by freeing the state pointer (which might
+ * be NULL, e.g. at driver load time) and allocating a new empty state object.
+ */
+void drm_atomic_helper_plane_reset(struct drm_plane *plane)
+{
+	if (plane->state)
+		__drm_atomic_helper_plane_destroy_state(plane->state);
+
+	kfree(plane->state);
+	plane->state = kzalloc(sizeof(*plane->state), GFP_KERNEL);
+	if (plane->state)
+		__drm_atomic_helper_plane_reset(plane, plane->state);
+}
+EXPORT_SYMBOL(drm_atomic_helper_plane_reset);
+
+/**
+ * __drm_atomic_helper_plane_duplicate_state - copy atomic plane state
+ * @plane: plane object
+ * @state: atomic plane state
+ *
+ * Copies atomic state from a plane's current state. This is useful for
+ * drivers that subclass the plane state.
+ */
+void __drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane,
+					       struct drm_plane_state *state)
+{
+	memcpy(state, plane->state, sizeof(*state));
+
+	if (state->fb)
+		drm_framebuffer_get(state->fb);
+
+	state->fence = NULL;
+	state->commit = NULL;
+}
+EXPORT_SYMBOL(__drm_atomic_helper_plane_duplicate_state);
+
+/**
+ * drm_atomic_helper_plane_duplicate_state - default state duplicate hook
+ * @plane: drm plane
+ *
+ * Default plane state duplicate hook for drivers which don't have their own
+ * subclassed plane state structure.
+ */
+struct drm_plane_state *
+drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane)
+{
+	struct drm_plane_state *state;
+
+	if (WARN_ON(!plane->state))
+		return NULL;
+
+	state = kmalloc(sizeof(*state), GFP_KERNEL);
+	if (state)
+		__drm_atomic_helper_plane_duplicate_state(plane, state);
+
+	return state;
+}
+EXPORT_SYMBOL(drm_atomic_helper_plane_duplicate_state);
+
+/**
+ * __drm_atomic_helper_plane_destroy_state - release plane state
+ * @state: plane state object to release
+ *
+ * Releases all resources stored in the plane state without actually freeing
+ * the memory of the plane state. This is useful for drivers that subclass the
+ * plane state.
+ */
+void __drm_atomic_helper_plane_destroy_state(struct drm_plane_state *state)
+{
+	if (state->fb)
+		drm_framebuffer_put(state->fb);
+
+	if (state->fence)
+		dma_fence_put(state->fence);
+
+	if (state->commit)
+		drm_crtc_commit_put(state->commit);
+}
+EXPORT_SYMBOL(__drm_atomic_helper_plane_destroy_state);
+
+/**
+ * drm_atomic_helper_plane_destroy_state - default state destroy hook
+ * @plane: drm plane
+ * @state: plane state object to release
+ *
+ * Default plane state destroy hook for drivers which don't have their own
+ * subclassed plane state structure.
+ */
+void drm_atomic_helper_plane_destroy_state(struct drm_plane *plane,
+					   struct drm_plane_state *state)
+{
+	__drm_atomic_helper_plane_destroy_state(state);
+	kfree(state);
+}
+EXPORT_SYMBOL(drm_atomic_helper_plane_destroy_state);
+
+/**
+ * __drm_atomic_helper_connector_reset - reset state on connector
+ * @connector: drm connector
+ * @conn_state: connector state to assign
+ *
+ * Initializes the newly allocated @conn_state and assigns it to
+ * the &drm_conector->state pointer of @connector, usually required when
+ * initializing the drivers or when called from the &drm_connector_funcs.reset
+ * hook.
+ *
+ * This is useful for drivers that subclass the connector state.
+ */
+void
+__drm_atomic_helper_connector_reset(struct drm_connector *connector,
+				    struct drm_connector_state *conn_state)
+{
+	if (conn_state)
+		conn_state->connector = connector;
+
+	connector->state = conn_state;
+}
+EXPORT_SYMBOL(__drm_atomic_helper_connector_reset);
+
+/**
+ * drm_atomic_helper_connector_reset - default &drm_connector_funcs.reset hook for connectors
+ * @connector: drm connector
+ *
+ * Resets the atomic state for @connector by freeing the state pointer (which
+ * might be NULL, e.g. at driver load time) and allocating a new empty state
+ * object.
+ */
+void drm_atomic_helper_connector_reset(struct drm_connector *connector)
+{
+	struct drm_connector_state *conn_state =
+		kzalloc(sizeof(*conn_state), GFP_KERNEL);
+
+	if (connector->state)
+		__drm_atomic_helper_connector_destroy_state(connector->state);
+
+	kfree(connector->state);
+	__drm_atomic_helper_connector_reset(connector, conn_state);
+}
+EXPORT_SYMBOL(drm_atomic_helper_connector_reset);
+
+/**
+ * __drm_atomic_helper_connector_duplicate_state - copy atomic connector state
+ * @connector: connector object
+ * @state: atomic connector state
+ *
+ * Copies atomic state from a connector's current state. This is useful for
+ * drivers that subclass the connector state.
+ */
+void
+__drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector,
+					    struct drm_connector_state *state)
+{
+	memcpy(state, connector->state, sizeof(*state));
+	if (state->crtc)
+		drm_connector_get(connector);
+	state->commit = NULL;
+
+	/* Don't copy over a writeback job, they are used only once */
+	state->writeback_job = NULL;
+}
+EXPORT_SYMBOL(__drm_atomic_helper_connector_duplicate_state);
+
+/**
+ * drm_atomic_helper_connector_duplicate_state - default state duplicate hook
+ * @connector: drm connector
+ *
+ * Default connector state duplicate hook for drivers which don't have their own
+ * subclassed connector state structure.
+ */
+struct drm_connector_state *
+drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector)
+{
+	struct drm_connector_state *state;
+
+	if (WARN_ON(!connector->state))
+		return NULL;
+
+	state = kmalloc(sizeof(*state), GFP_KERNEL);
+	if (state)
+		__drm_atomic_helper_connector_duplicate_state(connector, state);
+
+	return state;
+}
+EXPORT_SYMBOL(drm_atomic_helper_connector_duplicate_state);
+
+/**
+ * drm_atomic_helper_duplicate_state - duplicate an atomic state object
+ * @dev: DRM device
+ * @ctx: lock acquisition context
+ *
+ * Makes a copy of the current atomic state by looping over all objects and
+ * duplicating their respective states. This is used for example by suspend/
+ * resume support code to save the state prior to suspend such that it can
+ * be restored upon resume.
+ *
+ * Note that this treats atomic state as persistent between save and restore.
+ * Drivers must make sure that this is possible and won't result in confusion
+ * or erroneous behaviour.
+ *
+ * Note that if callers haven't already acquired all modeset locks this might
+ * return -EDEADLK, which must be handled by calling drm_modeset_backoff().
+ *
+ * Returns:
+ * A pointer to the copy of the atomic state object on success or an
+ * ERR_PTR()-encoded error code on failure.
+ *
+ * See also:
+ * drm_atomic_helper_suspend(), drm_atomic_helper_resume()
+ */
+struct drm_atomic_state *
+drm_atomic_helper_duplicate_state(struct drm_device *dev,
+				  struct drm_modeset_acquire_ctx *ctx)
+{
+	struct drm_atomic_state *state;
+	struct drm_connector *conn;
+	struct drm_connector_list_iter conn_iter;
+	struct drm_plane *plane;
+	struct drm_crtc *crtc;
+	int err = 0;
+
+	state = drm_atomic_state_alloc(dev);
+	if (!state)
+		return ERR_PTR(-ENOMEM);
+
+	state->acquire_ctx = ctx;
+
+	drm_for_each_crtc(crtc, dev) {
+		struct drm_crtc_state *crtc_state;
+
+		crtc_state = drm_atomic_get_crtc_state(state, crtc);
+		if (IS_ERR(crtc_state)) {
+			err = PTR_ERR(crtc_state);
+			goto free;
+		}
+	}
+
+	drm_for_each_plane(plane, dev) {
+		struct drm_plane_state *plane_state;
+
+		plane_state = drm_atomic_get_plane_state(state, plane);
+		if (IS_ERR(plane_state)) {
+			err = PTR_ERR(plane_state);
+			goto free;
+		}
+	}
+
+	drm_connector_list_iter_begin(dev, &conn_iter);
+	drm_for_each_connector_iter(conn, &conn_iter) {
+		struct drm_connector_state *conn_state;
+
+		conn_state = drm_atomic_get_connector_state(state, conn);
+		if (IS_ERR(conn_state)) {
+			err = PTR_ERR(conn_state);
+			drm_connector_list_iter_end(&conn_iter);
+			goto free;
+		}
+	}
+	drm_connector_list_iter_end(&conn_iter);
+
+	/* clear the acquire context so that it isn't accidentally reused */
+	state->acquire_ctx = NULL;
+
+free:
+	if (err < 0) {
+		drm_atomic_state_put(state);
+		state = ERR_PTR(err);
+	}
+
+	return state;
+}
+EXPORT_SYMBOL(drm_atomic_helper_duplicate_state);
+
+/**
+ * __drm_atomic_helper_connector_destroy_state - release connector state
+ * @state: connector state object to release
+ *
+ * Releases all resources stored in the connector state without actually
+ * freeing the memory of the connector state. This is useful for drivers that
+ * subclass the connector state.
+ */
+void
+__drm_atomic_helper_connector_destroy_state(struct drm_connector_state *state)
+{
+	if (state->crtc)
+		drm_connector_put(state->connector);
+
+	if (state->commit)
+		drm_crtc_commit_put(state->commit);
+}
+EXPORT_SYMBOL(__drm_atomic_helper_connector_destroy_state);
+
+/**
+ * drm_atomic_helper_connector_destroy_state - default state destroy hook
+ * @connector: drm connector
+ * @state: connector state object to release
+ *
+ * Default connector state destroy hook for drivers which don't have their own
+ * subclassed connector state structure.
+ */
+void drm_atomic_helper_connector_destroy_state(struct drm_connector *connector,
+					  struct drm_connector_state *state)
+{
+	__drm_atomic_helper_connector_destroy_state(state);
+	kfree(state);
+}
+EXPORT_SYMBOL(drm_atomic_helper_connector_destroy_state);
+
+/**
+ * drm_atomic_helper_legacy_gamma_set - set the legacy gamma correction table
+ * @crtc: CRTC object
+ * @red: red correction table
+ * @green: green correction table
+ * @blue: green correction table
+ * @size: size of the tables
+ * @ctx: lock acquire context
+ *
+ * Implements support for legacy gamma correction table for drivers
+ * that support color management through the DEGAMMA_LUT/GAMMA_LUT
+ * properties. See drm_crtc_enable_color_mgmt() and the containing chapter for
+ * how the atomic color management and gamma tables work.
+ */
+int drm_atomic_helper_legacy_gamma_set(struct drm_crtc *crtc,
+				       u16 *red, u16 *green, u16 *blue,
+				       uint32_t size,
+				       struct drm_modeset_acquire_ctx *ctx)
+{
+	struct drm_device *dev = crtc->dev;
+	struct drm_atomic_state *state;
+	struct drm_crtc_state *crtc_state;
+	struct drm_property_blob *blob = NULL;
+	struct drm_color_lut *blob_data;
+	int i, ret = 0;
+	bool replaced;
+
+	state = drm_atomic_state_alloc(crtc->dev);
+	if (!state)
+		return -ENOMEM;
+
+	blob = drm_property_create_blob(dev,
+					sizeof(struct drm_color_lut) * size,
+					NULL);
+	if (IS_ERR(blob)) {
+		ret = PTR_ERR(blob);
+		blob = NULL;
+		goto fail;
+	}
+
+	/* Prepare GAMMA_LUT with the legacy values. */
+	blob_data = blob->data;
+	for (i = 0; i < size; i++) {
+		blob_data[i].red = red[i];
+		blob_data[i].green = green[i];
+		blob_data[i].blue = blue[i];
+	}
+
+	state->acquire_ctx = ctx;
+	crtc_state = drm_atomic_get_crtc_state(state, crtc);
+	if (IS_ERR(crtc_state)) {
+		ret = PTR_ERR(crtc_state);
+		goto fail;
+	}
+
+	/* Reset DEGAMMA_LUT and CTM properties. */
+	replaced  = drm_property_replace_blob(&crtc_state->degamma_lut, NULL);
+	replaced |= drm_property_replace_blob(&crtc_state->ctm, NULL);
+	replaced |= drm_property_replace_blob(&crtc_state->gamma_lut, blob);
+	crtc_state->color_mgmt_changed |= replaced;
+
+	ret = drm_atomic_commit(state);
+
+fail:
+	drm_atomic_state_put(state);
+	drm_property_blob_put(blob);
+	return ret;
+}
+EXPORT_SYMBOL(drm_atomic_helper_legacy_gamma_set);
+
+/**
+ * __drm_atomic_helper_private_duplicate_state - copy atomic private state
+ * @obj: CRTC object
+ * @state: new private object state
+ *
+ * Copies atomic state from a private objects's current state and resets inferred values.
+ * This is useful for drivers that subclass the private state.
+ */
+void __drm_atomic_helper_private_obj_duplicate_state(struct drm_private_obj *obj,
+						     struct drm_private_state *state)
+{
+	memcpy(state, obj->state, sizeof(*state));
+}
+EXPORT_SYMBOL(__drm_atomic_helper_private_obj_duplicate_state);
diff --git a/include/drm/drm_atomic_helper.h b/include/drm/drm_atomic_helper.h
index e60c4f0f8827..25ca0097563e 100644
--- a/include/drm/drm_atomic_helper.h
+++ b/include/drm/drm_atomic_helper.h
@@ -31,6 +31,7 @@ 
 #include <drm/drm_crtc.h>
 #include <drm/drm_modeset_helper_vtables.h>
 #include <drm/drm_modeset_helper.h>
+#include <drm/drm_atomic_state_helper.h>
 #include <drm/drm_util.h>
 
 struct drm_atomic_state;
@@ -145,49 +146,6 @@  int drm_atomic_helper_page_flip_target(
 				uint32_t target,
 				struct drm_modeset_acquire_ctx *ctx);
 
-/* default implementations for state handling */
-void drm_atomic_helper_crtc_reset(struct drm_crtc *crtc);
-void __drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc,
-					      struct drm_crtc_state *state);
-struct drm_crtc_state *
-drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc);
-void __drm_atomic_helper_crtc_destroy_state(struct drm_crtc_state *state);
-void drm_atomic_helper_crtc_destroy_state(struct drm_crtc *crtc,
-					  struct drm_crtc_state *state);
-
-void __drm_atomic_helper_plane_reset(struct drm_plane *plane,
-				     struct drm_plane_state *state);
-void drm_atomic_helper_plane_reset(struct drm_plane *plane);
-void __drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane,
-					       struct drm_plane_state *state);
-struct drm_plane_state *
-drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane);
-void __drm_atomic_helper_plane_destroy_state(struct drm_plane_state *state);
-void drm_atomic_helper_plane_destroy_state(struct drm_plane *plane,
-					  struct drm_plane_state *state);
-
-void __drm_atomic_helper_connector_reset(struct drm_connector *connector,
-					 struct drm_connector_state *conn_state);
-void drm_atomic_helper_connector_reset(struct drm_connector *connector);
-void
-__drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector,
-					   struct drm_connector_state *state);
-struct drm_connector_state *
-drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector);
-struct drm_atomic_state *
-drm_atomic_helper_duplicate_state(struct drm_device *dev,
-				  struct drm_modeset_acquire_ctx *ctx);
-void
-__drm_atomic_helper_connector_destroy_state(struct drm_connector_state *state);
-void drm_atomic_helper_connector_destroy_state(struct drm_connector *connector,
-					  struct drm_connector_state *state);
-int drm_atomic_helper_legacy_gamma_set(struct drm_crtc *crtc,
-				       u16 *red, u16 *green, u16 *blue,
-				       uint32_t size,
-				       struct drm_modeset_acquire_ctx *ctx);
-void __drm_atomic_helper_private_obj_duplicate_state(struct drm_private_obj *obj,
-						     struct drm_private_state *state);
-
 /**
  * drm_atomic_crtc_for_each_plane - iterate over planes currently attached to CRTC
  * @plane: the loop cursor
diff --git a/include/drm/drm_atomic_state_helper.h b/include/drm/drm_atomic_state_helper.h
new file mode 100644
index 000000000000..5b82ccfdb502
--- /dev/null
+++ b/include/drm/drm_atomic_state_helper.h
@@ -0,0 +1,80 @@ 
+/*
+ * Copyright (C) 2018 Intel Corp.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ * Rob Clark <robdclark@gmail.com>
+ * Daniel Vetter <daniel.vetter@ffwll.ch>
+ */
+
+#include <linux/types.h>
+
+struct drm_crtc;
+struct drm_crtc_state;
+struct drm_plane;
+struct drm_plane_state;
+struct drm_connector;
+struct drm_connector_state;
+struct drm_private_obj;
+struct drm_private_state;
+struct drm_modeset_acquire_ctx;
+struct drm_device;
+
+void drm_atomic_helper_crtc_reset(struct drm_crtc *crtc);
+void __drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc,
+					      struct drm_crtc_state *state);
+struct drm_crtc_state *
+drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc);
+void __drm_atomic_helper_crtc_destroy_state(struct drm_crtc_state *state);
+void drm_atomic_helper_crtc_destroy_state(struct drm_crtc *crtc,
+					  struct drm_crtc_state *state);
+
+void __drm_atomic_helper_plane_reset(struct drm_plane *plane,
+				     struct drm_plane_state *state);
+void drm_atomic_helper_plane_reset(struct drm_plane *plane);
+void __drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane,
+					       struct drm_plane_state *state);
+struct drm_plane_state *
+drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane);
+void __drm_atomic_helper_plane_destroy_state(struct drm_plane_state *state);
+void drm_atomic_helper_plane_destroy_state(struct drm_plane *plane,
+					  struct drm_plane_state *state);
+
+void __drm_atomic_helper_connector_reset(struct drm_connector *connector,
+					 struct drm_connector_state *conn_state);
+void drm_atomic_helper_connector_reset(struct drm_connector *connector);
+void
+__drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector,
+					   struct drm_connector_state *state);
+struct drm_connector_state *
+drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector);
+struct drm_atomic_state *
+drm_atomic_helper_duplicate_state(struct drm_device *dev,
+				  struct drm_modeset_acquire_ctx *ctx);
+void
+__drm_atomic_helper_connector_destroy_state(struct drm_connector_state *state);
+void drm_atomic_helper_connector_destroy_state(struct drm_connector *connector,
+					  struct drm_connector_state *state);
+int drm_atomic_helper_legacy_gamma_set(struct drm_crtc *crtc,
+				       u16 *red, u16 *green, u16 *blue,
+				       uint32_t size,
+				       struct drm_modeset_acquire_ctx *ctx);
+void __drm_atomic_helper_private_obj_duplicate_state(struct drm_private_obj *obj,
+						     struct drm_private_state *state);