drm: Fix up drm_atomic_state_helper.[hc] extraction
diff mbox series

Message ID 20181128100728.4674-1-daniel.vetter@ffwll.ch
State New
Headers show
Series
  • drm: Fix up drm_atomic_state_helper.[hc] extraction
Related show

Commit Message

Daniel Vetter Nov. 28, 2018, 10:07 a.m. UTC
I've misplaced two functions by accident:
- drm_atomic_helper_duplicate_state is really part of the
  resume/suspend/shutdown device-wide helpers.
- drm_atomic_helper_legacy_gamma_set is part of the legacy ioctl
  compat helpers.

Move them both back.

Fixes: 9ef8a9dc4b21 ("drm: Extract drm_atomic_state_helper.[hc]")
Cc: Ville Syrjälä <ville.syrjala@linux.intel.com>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
---
 drivers/gpu/drm/drm_atomic_helper.c       | 157 ++++++++++++++++++++++
 drivers/gpu/drm/drm_atomic_state_helper.c | 157 ----------------------
 include/drm/drm_atomic_helper.h           |   7 +
 include/drm/drm_atomic_state_helper.h     |   7 -
 4 files changed, 164 insertions(+), 164 deletions(-)

Comments

Sean Paul Nov. 29, 2018, 3:36 p.m. UTC | #1
On Wed, Nov 28, 2018 at 5:07 AM Daniel Vetter <daniel.vetter@ffwll.ch> wrote:
>
> I've misplaced two functions by accident:
> - drm_atomic_helper_duplicate_state is really part of the
>   resume/suspend/shutdown device-wide helpers.
> - drm_atomic_helper_legacy_gamma_set is part of the legacy ioctl
>   compat helpers.
>
> Move them both back.
>
> Fixes: 9ef8a9dc4b21 ("drm: Extract drm_atomic_state_helper.[hc]")
> Cc: Ville Syrjälä <ville.syrjala@linux.intel.com>
> Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>

Reviewed-by: Sean Paul <sean@poorly.run>

> ---
>  drivers/gpu/drm/drm_atomic_helper.c       | 157 ++++++++++++++++++++++
>  drivers/gpu/drm/drm_atomic_state_helper.c | 157 ----------------------
>  include/drm/drm_atomic_helper.h           |   7 +
>  include/drm/drm_atomic_state_helper.h     |   7 -
>  4 files changed, 164 insertions(+), 164 deletions(-)
>
> diff --git a/drivers/gpu/drm/drm_atomic_helper.c b/drivers/gpu/drm/drm_atomic_helper.c
> index 9b22774a9867..de7d872f9f1a 100644
> --- a/drivers/gpu/drm/drm_atomic_helper.c
> +++ b/drivers/gpu/drm/drm_atomic_helper.c
> @@ -3135,6 +3135,93 @@ void drm_atomic_helper_shutdown(struct drm_device *dev)
>  }
>  EXPORT_SYMBOL(drm_atomic_helper_shutdown);
>
> +/**
> + * 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_suspend - subsystem-level suspend helper
>   * @dev: DRM device
> @@ -3418,3 +3505,73 @@ int drm_atomic_helper_page_flip_target(struct drm_crtc *crtc,
>         return ret;
>  }
>  EXPORT_SYMBOL(drm_atomic_helper_page_flip_target);
> +
> +/**
> + * 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);
> diff --git a/drivers/gpu/drm/drm_atomic_state_helper.c b/drivers/gpu/drm/drm_atomic_state_helper.c
> index 3ba996069d69..60bd7d708e35 100644
> --- a/drivers/gpu/drm/drm_atomic_state_helper.c
> +++ b/drivers/gpu/drm/drm_atomic_state_helper.c
> @@ -393,93 +393,6 @@ drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector)
>  }
>  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
> @@ -515,76 +428,6 @@ void drm_atomic_helper_connector_destroy_state(struct drm_connector *connector,
>  }
>  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
> diff --git a/include/drm/drm_atomic_helper.h b/include/drm/drm_atomic_helper.h
> index 25ca0097563e..58214be3bf3d 100644
> --- a/include/drm/drm_atomic_helper.h
> +++ b/include/drm/drm_atomic_helper.h
> @@ -127,6 +127,9 @@ int __drm_atomic_helper_set_config(struct drm_mode_set *set,
>  int drm_atomic_helper_disable_all(struct drm_device *dev,
>                                   struct drm_modeset_acquire_ctx *ctx);
>  void drm_atomic_helper_shutdown(struct drm_device *dev);
> +struct drm_atomic_state *
> +drm_atomic_helper_duplicate_state(struct drm_device *dev,
> +                                 struct drm_modeset_acquire_ctx *ctx);
>  struct drm_atomic_state *drm_atomic_helper_suspend(struct drm_device *dev);
>  int drm_atomic_helper_commit_duplicated_state(struct drm_atomic_state *state,
>                                               struct drm_modeset_acquire_ctx *ctx);
> @@ -145,6 +148,10 @@ int drm_atomic_helper_page_flip_target(
>                                 uint32_t flags,
>                                 uint32_t target,
>                                 struct drm_modeset_acquire_ctx *ctx);
> +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);
>
>  /**
>   * drm_atomic_crtc_for_each_plane - iterate over planes currently attached to CRTC
> diff --git a/include/drm/drm_atomic_state_helper.h b/include/drm/drm_atomic_state_helper.h
> index 5b82ccfdb502..66c92cbd8e16 100644
> --- a/include/drm/drm_atomic_state_helper.h
> +++ b/include/drm/drm_atomic_state_helper.h
> @@ -65,16 +65,9 @@ __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.1
>
> _______________________________________________
> Intel-gfx mailing list
> Intel-gfx@lists.freedesktop.org
> https://lists.freedesktop.org/mailman/listinfo/intel-gfx
Daniel Vetter Nov. 30, 2018, 3:38 p.m. UTC | #2
On Thu, Nov 29, 2018 at 10:36:13AM -0500, Sean Paul wrote:
> On Wed, Nov 28, 2018 at 5:07 AM Daniel Vetter <daniel.vetter@ffwll.ch> wrote:
> >
> > I've misplaced two functions by accident:
> > - drm_atomic_helper_duplicate_state is really part of the
> >   resume/suspend/shutdown device-wide helpers.
> > - drm_atomic_helper_legacy_gamma_set is part of the legacy ioctl
> >   compat helpers.
> >
> > Move them both back.
> >
> > Fixes: 9ef8a9dc4b21 ("drm: Extract drm_atomic_state_helper.[hc]")
> > Cc: Ville Syrjälä <ville.syrjala@linux.intel.com>
> > Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
> 
> Reviewed-by: Sean Paul <sean@poorly.run>

Applied, thanks for reviewing.
-Daniel

> 
> > ---
> >  drivers/gpu/drm/drm_atomic_helper.c       | 157 ++++++++++++++++++++++
> >  drivers/gpu/drm/drm_atomic_state_helper.c | 157 ----------------------
> >  include/drm/drm_atomic_helper.h           |   7 +
> >  include/drm/drm_atomic_state_helper.h     |   7 -
> >  4 files changed, 164 insertions(+), 164 deletions(-)
> >
> > diff --git a/drivers/gpu/drm/drm_atomic_helper.c b/drivers/gpu/drm/drm_atomic_helper.c
> > index 9b22774a9867..de7d872f9f1a 100644
> > --- a/drivers/gpu/drm/drm_atomic_helper.c
> > +++ b/drivers/gpu/drm/drm_atomic_helper.c
> > @@ -3135,6 +3135,93 @@ void drm_atomic_helper_shutdown(struct drm_device *dev)
> >  }
> >  EXPORT_SYMBOL(drm_atomic_helper_shutdown);
> >
> > +/**
> > + * 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_suspend - subsystem-level suspend helper
> >   * @dev: DRM device
> > @@ -3418,3 +3505,73 @@ int drm_atomic_helper_page_flip_target(struct drm_crtc *crtc,
> >         return ret;
> >  }
> >  EXPORT_SYMBOL(drm_atomic_helper_page_flip_target);
> > +
> > +/**
> > + * 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);
> > diff --git a/drivers/gpu/drm/drm_atomic_state_helper.c b/drivers/gpu/drm/drm_atomic_state_helper.c
> > index 3ba996069d69..60bd7d708e35 100644
> > --- a/drivers/gpu/drm/drm_atomic_state_helper.c
> > +++ b/drivers/gpu/drm/drm_atomic_state_helper.c
> > @@ -393,93 +393,6 @@ drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector)
> >  }
> >  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
> > @@ -515,76 +428,6 @@ void drm_atomic_helper_connector_destroy_state(struct drm_connector *connector,
> >  }
> >  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
> > diff --git a/include/drm/drm_atomic_helper.h b/include/drm/drm_atomic_helper.h
> > index 25ca0097563e..58214be3bf3d 100644
> > --- a/include/drm/drm_atomic_helper.h
> > +++ b/include/drm/drm_atomic_helper.h
> > @@ -127,6 +127,9 @@ int __drm_atomic_helper_set_config(struct drm_mode_set *set,
> >  int drm_atomic_helper_disable_all(struct drm_device *dev,
> >                                   struct drm_modeset_acquire_ctx *ctx);
> >  void drm_atomic_helper_shutdown(struct drm_device *dev);
> > +struct drm_atomic_state *
> > +drm_atomic_helper_duplicate_state(struct drm_device *dev,
> > +                                 struct drm_modeset_acquire_ctx *ctx);
> >  struct drm_atomic_state *drm_atomic_helper_suspend(struct drm_device *dev);
> >  int drm_atomic_helper_commit_duplicated_state(struct drm_atomic_state *state,
> >                                               struct drm_modeset_acquire_ctx *ctx);
> > @@ -145,6 +148,10 @@ int drm_atomic_helper_page_flip_target(
> >                                 uint32_t flags,
> >                                 uint32_t target,
> >                                 struct drm_modeset_acquire_ctx *ctx);
> > +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);
> >
> >  /**
> >   * drm_atomic_crtc_for_each_plane - iterate over planes currently attached to CRTC
> > diff --git a/include/drm/drm_atomic_state_helper.h b/include/drm/drm_atomic_state_helper.h
> > index 5b82ccfdb502..66c92cbd8e16 100644
> > --- a/include/drm/drm_atomic_state_helper.h
> > +++ b/include/drm/drm_atomic_state_helper.h
> > @@ -65,16 +65,9 @@ __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.1
> >
> > _______________________________________________
> > Intel-gfx mailing list
> > Intel-gfx@lists.freedesktop.org
> > https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Patch
diff mbox series

diff --git a/drivers/gpu/drm/drm_atomic_helper.c b/drivers/gpu/drm/drm_atomic_helper.c
index 9b22774a9867..de7d872f9f1a 100644
--- a/drivers/gpu/drm/drm_atomic_helper.c
+++ b/drivers/gpu/drm/drm_atomic_helper.c
@@ -3135,6 +3135,93 @@  void drm_atomic_helper_shutdown(struct drm_device *dev)
 }
 EXPORT_SYMBOL(drm_atomic_helper_shutdown);
 
+/**
+ * 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_suspend - subsystem-level suspend helper
  * @dev: DRM device
@@ -3418,3 +3505,73 @@  int drm_atomic_helper_page_flip_target(struct drm_crtc *crtc,
 	return ret;
 }
 EXPORT_SYMBOL(drm_atomic_helper_page_flip_target);
+
+/**
+ * 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);
diff --git a/drivers/gpu/drm/drm_atomic_state_helper.c b/drivers/gpu/drm/drm_atomic_state_helper.c
index 3ba996069d69..60bd7d708e35 100644
--- a/drivers/gpu/drm/drm_atomic_state_helper.c
+++ b/drivers/gpu/drm/drm_atomic_state_helper.c
@@ -393,93 +393,6 @@  drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector)
 }
 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
@@ -515,76 +428,6 @@  void drm_atomic_helper_connector_destroy_state(struct drm_connector *connector,
 }
 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
diff --git a/include/drm/drm_atomic_helper.h b/include/drm/drm_atomic_helper.h
index 25ca0097563e..58214be3bf3d 100644
--- a/include/drm/drm_atomic_helper.h
+++ b/include/drm/drm_atomic_helper.h
@@ -127,6 +127,9 @@  int __drm_atomic_helper_set_config(struct drm_mode_set *set,
 int drm_atomic_helper_disable_all(struct drm_device *dev,
 				  struct drm_modeset_acquire_ctx *ctx);
 void drm_atomic_helper_shutdown(struct drm_device *dev);
+struct drm_atomic_state *
+drm_atomic_helper_duplicate_state(struct drm_device *dev,
+				  struct drm_modeset_acquire_ctx *ctx);
 struct drm_atomic_state *drm_atomic_helper_suspend(struct drm_device *dev);
 int drm_atomic_helper_commit_duplicated_state(struct drm_atomic_state *state,
 					      struct drm_modeset_acquire_ctx *ctx);
@@ -145,6 +148,10 @@  int drm_atomic_helper_page_flip_target(
 				uint32_t flags,
 				uint32_t target,
 				struct drm_modeset_acquire_ctx *ctx);
+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);
 
 /**
  * drm_atomic_crtc_for_each_plane - iterate over planes currently attached to CRTC
diff --git a/include/drm/drm_atomic_state_helper.h b/include/drm/drm_atomic_state_helper.h
index 5b82ccfdb502..66c92cbd8e16 100644
--- a/include/drm/drm_atomic_state_helper.h
+++ b/include/drm/drm_atomic_state_helper.h
@@ -65,16 +65,9 @@  __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);