From: Ville Syrjälä ville.syrjala@linux.intel.com

Pass the appropriate new crtc state explicitly to intel_pipe_update_start/end() instead of of mucking around with crtc->state.

Signed-off-by: Ville Syrjälä ville.syrjala@linux.intel.com --- drivers/gpu/drm/i915/intel_display.c | 18 +++++++++++------- drivers/gpu/drm/i915/intel_drv.h | 13 +++++++++++-- drivers/gpu/drm/i915/intel_sprite.c | 28 ++++++++++++++-------------- 3 files changed, 36 insertions(+), 23 deletions(-)

diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c index 90fba8a44630..cdfa95be4b8e 100644 --- a/drivers/gpu/drm/i915/intel_display.c +++ b/drivers/gpu/drm/i915/intel_display.c @@ -10645,7 +10645,7 @@ static void intel_mmio_flip_work_func(struct work_struct *w)

WARN_ON(i915_gem_object_wait(obj, 0, MAX_SCHEDULE_TIMEOUT, NULL) < 0);

- intel_pipe_update_start(crtc); + intel_pipe_update_start(crtc->config);

if (INTEL_GEN(dev_priv) >= 9) skl_do_mmio_flip(crtc, work->rotation, work); @@ -10653,7 +10653,7 @@ static void intel_mmio_flip_work_func(struct work_struct *w) /* use_mmio_flip() retricts MMIO flips to ilk+ */ ilk_do_mmio_flip(crtc, work);

- intel_pipe_update_end(crtc, work); + intel_pipe_update_end(crtc->config, work); }

static int intel_default_queue_flip(struct drm_device *dev, @@ -13535,13 +13535,13 @@ static void intel_begin_crtc_commit(struct drm_crtc *crtc, struct drm_device *dev = crtc->dev; struct drm_i915_private *dev_priv = to_i915(dev); struct intel_crtc *intel_crtc = to_intel_crtc(crtc); - struct intel_crtc_state *intel_cstate = - to_intel_crtc_state(crtc->state); struct intel_crtc_state *old_intel_cstate = to_intel_crtc_state(old_crtc_state); struct intel_atomic_state *old_intel_state = to_intel_atomic_state(old_crtc_state->state); - bool modeset = needs_modeset(crtc->state); + struct intel_crtc_state *intel_cstate = + intel_atomic_get_new_crtc_state(old_intel_state, intel_crtc); + bool modeset = needs_modeset(&intel_cstate->base);

if (!modeset && (intel_cstate->base.color_mgmt_changed || @@ -13551,7 +13551,7 @@ static void intel_begin_crtc_commit(struct drm_crtc *crtc, }

/* Perform vblank evasion around commit operation */ - intel_pipe_update_start(intel_crtc); + intel_pipe_update_start(intel_cstate);

if (modeset) goto out; @@ -13571,8 +13571,12 @@ static void intel_finish_crtc_commit(struct drm_crtc *crtc, struct drm_crtc_state *old_crtc_state) { struct intel_crtc *intel_crtc = to_intel_crtc(crtc); + struct intel_atomic_state *old_intel_state = + to_intel_atomic_state(old_crtc_state->state); + struct intel_crtc_state *new_crtc_state = + intel_atomic_get_new_crtc_state(old_intel_state, intel_crtc);

- intel_pipe_update_end(intel_crtc, NULL); + intel_pipe_update_end(new_crtc_state, NULL); }

/** diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h index d17a32437f07..d22ca42f35da 100644 --- a/drivers/gpu/drm/i915/intel_drv.h +++ b/drivers/gpu/drm/i915/intel_drv.h @@ -1207,6 +1207,14 @@ hdmi_to_dig_port(struct intel_hdmi *intel_hdmi) return container_of(intel_hdmi, struct intel_digital_port, hdmi); }

+static inline struct intel_crtc_state * +intel_atomic_get_new_crtc_state(struct intel_atomic_state *state, + struct intel_crtc *crtc) +{ + return to_intel_crtc_state(drm_atomic_get_new_crtc_state(&state->base, + &crtc->base)); +} + /* intel_fifo_underrun.c */ bool intel_set_cpu_fifo_underrun_reporting(struct drm_i915_private *dev_priv, enum pipe pipe, bool enable); @@ -1900,8 +1908,9 @@ struct intel_plane *intel_sprite_plane_create(struct drm_i915_private *dev_priv, enum pipe pipe, int plane); int intel_sprite_set_colorkey(struct drm_device *dev, void *data, struct drm_file *file_priv); -void intel_pipe_update_start(struct intel_crtc *crtc); -void intel_pipe_update_end(struct intel_crtc *crtc, struct intel_flip_work *work); +void intel_pipe_update_start(const struct intel_crtc_state *new_crtc_state); +void intel_pipe_update_end(struct intel_crtc_state *new_crtc_state, + struct intel_flip_work *work);

/* intel_tv.c */ void intel_tv_init(struct drm_i915_private *dev_priv); diff --git a/drivers/gpu/drm/i915/intel_sprite.c b/drivers/gpu/drm/i915/intel_sprite.c index 0c650c2cbca8..697b95016c7a 100644 --- a/drivers/gpu/drm/i915/intel_sprite.c +++ b/drivers/gpu/drm/i915/intel_sprite.c @@ -69,8 +69,7 @@ int intel_usecs_to_scanlines(const struct drm_display_mode *adjusted_mode,

/** * intel_pipe_update_start() - start update of a set of display registers - * @crtc: the crtc of which the registers are going to be updated - * @start_vbl_count: vblank counter return pointer used for error checking + * @new_crtc_state: the new crtc state * * Mark the start of an update to pipe registers that should be updated * atomically regarding vblank. If the next vblank will happens within @@ -78,18 +77,18 @@ int intel_usecs_to_scanlines(const struct drm_display_mode *adjusted_mode, * * After a successful call to this function, interrupts will be disabled * until a subsequent call to intel_pipe_update_end(). That is done to - * avoid random delays. The value written to @start_vbl_count should be - * supplied to intel_pipe_update_end() for error checking. + * avoid random delays. */ -void intel_pipe_update_start(struct intel_crtc *crtc) +void intel_pipe_update_start(const struct intel_crtc_state *new_crtc_state) { + struct intel_crtc *crtc = to_intel_crtc(new_crtc_state->base.crtc); struct drm_i915_private *dev_priv = to_i915(crtc->base.dev); - const struct drm_display_mode *adjusted_mode = &crtc->config->base.adjusted_mode; + const struct drm_display_mode *adjusted_mode = &new_crtc_state->base.adjusted_mode; long timeout = msecs_to_jiffies_timeout(1); int scanline, min, max, vblank_start; wait_queue_head_t *wq = drm_crtc_vblank_waitqueue(&crtc->base); bool need_vlv_dsi_wa = (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv)) && - intel_crtc_has_type(crtc->config, INTEL_OUTPUT_DSI); + intel_crtc_has_type(new_crtc_state, INTEL_OUTPUT_DSI); DEFINE_WAIT(wait);

vblank_start = adjusted_mode->crtc_vblank_start; @@ -169,15 +168,16 @@ void intel_pipe_update_start(struct intel_crtc *crtc)

/** * intel_pipe_update_end() - end update of a set of display registers - * @crtc: the crtc of which the registers were updated - * @start_vbl_count: start vblank counter (used for error checking) + * @new_crtc_state: the new crtc state * * Mark the end of an update started with intel_pipe_update_start(). This * re-enables interrupts and verifies the update was actually completed - * before a vblank using the value of @start_vbl_count. + * before a vblank. */ -void intel_pipe_update_end(struct intel_crtc *crtc, struct intel_flip_work *work) +void intel_pipe_update_end(struct intel_crtc_state *new_crtc_state, + struct intel_flip_work *work) { + struct intel_crtc *crtc = to_intel_crtc(new_crtc_state->base.crtc); enum pipe pipe = crtc->pipe; int scanline_end = intel_get_crtc_scanline(crtc); u32 end_vbl_count = intel_crtc_get_vblank_counter(crtc); @@ -196,14 +196,14 @@ void intel_pipe_update_end(struct intel_crtc *crtc, struct intel_flip_work *work * Would be slightly nice to just grab the vblank count and arm the * event outside of the critical section - the spinlock might spin for a * while ... */ - if (crtc->base.state->event) { + if (new_crtc_state->base.event) { WARN_ON(drm_crtc_vblank_get(&crtc->base) != 0);

spin_lock(&crtc->base.dev->event_lock); - drm_crtc_arm_vblank_event(&crtc->base, crtc->base.state->event); + drm_crtc_arm_vblank_event(&crtc->base, new_crtc_state->base.event); spin_unlock(&crtc->base.dev->event_lock);

- crtc->base.state->event = NULL; + new_crtc_state->base.event = NULL; }

local_irq_enable();

From: Ville Syrjälä ville.syrjala@linux.intel.com

Eliminate plane->state and crtc->state usage from intel_plane_atomic_check_with_state() and its callers. Instead pass the proper states in or dig them up from the top level atomic state.

Note that intel_plane_atomic_check_with_state() itself isn't allowed to use the top level atomic state as there is none when it gets called from the legacy cursor short circuit path.

Signed-off-by: Ville Syrjälä ville.syrjala@linux.intel.com --- drivers/gpu/drm/i915/intel_atomic_plane.c | 40 +++++++++++++++++++------------ drivers/gpu/drm/i915/intel_display.c | 12 ++++++---- drivers/gpu/drm/i915/intel_drv.h | 16 +++++++++++-- 3 files changed, 46 insertions(+), 22 deletions(-)

diff --git a/drivers/gpu/drm/i915/intel_atomic_plane.c b/drivers/gpu/drm/i915/intel_atomic_plane.c index ee76fab7bb6f..7cdbe9ae2c96 100644 --- a/drivers/gpu/drm/i915/intel_atomic_plane.c +++ b/drivers/gpu/drm/i915/intel_atomic_plane.c @@ -107,7 +107,9 @@ intel_plane_destroy_state(struct drm_plane *plane, drm_atomic_helper_plane_destroy_state(plane, state); }

-int intel_plane_atomic_check_with_state(struct intel_crtc_state *crtc_state, +int intel_plane_atomic_check_with_state(const struct intel_crtc_state *old_crtc_state, + struct intel_crtc_state *crtc_state, + const struct intel_plane_state *old_plane_state, struct intel_plane_state *intel_state) { struct drm_plane *plane = intel_state->base.plane; @@ -124,7 +126,7 @@ int intel_plane_atomic_check_with_state(struct intel_crtc_state *crtc_state, * anything driver-specific we need to test in that case, so * just return success. */ - if (!intel_state->base.crtc && !plane->state->crtc) + if (!intel_state->base.crtc && !old_plane_state->base.crtc) return 0;

/* Clip all planes to CRTC size, or 0x0 if CRTC is disabled */ @@ -194,17 +196,21 @@ int intel_plane_atomic_check_with_state(struct intel_crtc_state *crtc_state, else crtc_state->active_planes &= ~BIT(intel_plane->id);

- return intel_plane_atomic_calc_changes(&crtc_state->base, state); + return intel_plane_atomic_calc_changes(old_crtc_state, + &crtc_state->base, + old_plane_state, + state); }

static int intel_plane_atomic_check(struct drm_plane *plane, struct drm_plane_state *state) { - struct drm_crtc *crtc = state->crtc; + const struct drm_plane_state *old_plane_state = + drm_atomic_get_old_plane_state(state->state, plane); + struct drm_crtc *crtc = state->crtc ?: old_plane_state->crtc; + const struct drm_crtc_state *old_crtc_state; struct drm_crtc_state *drm_crtc_state;

- crtc = crtc ? crtc : plane->state->crtc; - /* * Both crtc and plane->crtc could be NULL if we're updating a * property while the plane is disabled. We don't actually have @@ -214,29 +220,33 @@ static int intel_plane_atomic_check(struct drm_plane *plane, if (!crtc) return 0;

- drm_crtc_state = drm_atomic_get_existing_crtc_state(state->state, crtc); - if (WARN_ON(!drm_crtc_state)) - return -EINVAL; + old_crtc_state = drm_atomic_get_old_crtc_state(state->state, crtc); + drm_crtc_state = drm_atomic_get_new_crtc_state(state->state, crtc);

- return intel_plane_atomic_check_with_state(to_intel_crtc_state(drm_crtc_state), + return intel_plane_atomic_check_with_state(to_intel_crtc_state(old_crtc_state), + to_intel_crtc_state(drm_crtc_state), + to_intel_plane_state(old_plane_state), to_intel_plane_state(state)); }

static void intel_plane_atomic_update(struct drm_plane *plane, struct drm_plane_state *old_state) { + struct intel_atomic_state *state = to_intel_atomic_state(old_state->state); struct intel_plane *intel_plane = to_intel_plane(plane); - struct intel_plane_state *intel_state = - to_intel_plane_state(plane->state); - struct drm_crtc *crtc = plane->state->crtc ?: old_state->crtc; + const struct intel_plane_state *intel_state = + intel_atomic_get_new_plane_state(state, intel_plane); + struct drm_crtc *crtc = intel_state->base.crtc ?: old_state->crtc;

if (intel_state->base.visible) { + const struct intel_crtc_state *intel_crtc_state = + intel_atomic_get_new_crtc_state(state, to_intel_crtc(crtc)); + trace_intel_update_plane(plane, to_intel_crtc(crtc));

intel_plane->update_plane(intel_plane, - to_intel_crtc_state(crtc->state), - intel_state); + intel_crtc_state, intel_state); } else { trace_intel_disable_plane(plane, to_intel_crtc(crtc)); diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c index cdfa95be4b8e..6440479d6fe2 100644 --- a/drivers/gpu/drm/i915/intel_display.c +++ b/drivers/gpu/drm/i915/intel_display.c @@ -11011,7 +11011,7 @@ static bool intel_wm_need_update(struct drm_plane *plane, return false; }

-static bool needs_scaling(struct intel_plane_state *state) +static bool needs_scaling(const struct intel_plane_state *state) { int src_w = drm_rect_width(&state->base.src) >> 16; int src_h = drm_rect_height(&state->base.src) >> 16; @@ -11021,7 +11021,9 @@ static bool needs_scaling(struct intel_plane_state *state) return (src_w != dst_w || src_h != dst_h); }

-int intel_plane_atomic_calc_changes(struct drm_crtc_state *crtc_state, +int intel_plane_atomic_calc_changes(const struct intel_crtc_state *old_crtc_state, + struct drm_crtc_state *crtc_state, + const struct intel_plane_state *old_plane_state, struct drm_plane_state *plane_state) { struct intel_crtc_state *pipe_config = to_intel_crtc_state(crtc_state); @@ -11030,10 +11032,8 @@ int intel_plane_atomic_calc_changes(struct drm_crtc_state *crtc_state, struct intel_plane *plane = to_intel_plane(plane_state->plane); struct drm_device *dev = crtc->dev; struct drm_i915_private *dev_priv = to_i915(dev); - struct intel_plane_state *old_plane_state = - to_intel_plane_state(plane->base.state); bool mode_changed = needs_modeset(crtc_state); - bool was_crtc_enabled = crtc->state->active; + bool was_crtc_enabled = old_crtc_state->base.active; bool is_crtc_enabled = crtc_state->active; bool turn_off, turn_on, visible, was_visible; struct drm_framebuffer *fb = plane_state->fb; @@ -13660,6 +13660,8 @@ intel_legacy_cursor_update(struct drm_plane *plane, new_plane_state->crtc_h = crtc_h;

ret = intel_plane_atomic_check_with_state(to_intel_crtc_state(crtc->state), + to_intel_crtc_state(crtc->state), /* FIXME need a new crtc state? */ + to_intel_plane_state(plane->state), to_intel_plane_state(new_plane_state)); if (ret) goto out_free; diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h index e9d61a03c46e..ea36d1a61e86 100644 --- a/drivers/gpu/drm/i915/intel_drv.h +++ b/drivers/gpu/drm/i915/intel_drv.h @@ -1207,6 +1207,14 @@ hdmi_to_dig_port(struct intel_hdmi *intel_hdmi) return container_of(intel_hdmi, struct intel_digital_port, hdmi); }

+static inline struct intel_plane_state * +intel_atomic_get_new_plane_state(struct intel_atomic_state *state, + struct intel_plane *plane) +{ + return to_intel_plane_state(drm_atomic_get_new_plane_state(&state->base, + &plane->base)); +} + static inline struct intel_crtc_state * intel_atomic_get_old_crtc_state(struct intel_atomic_state *state, struct intel_crtc *crtc) @@ -1439,7 +1447,9 @@ int intel_plane_atomic_set_property(struct drm_plane *plane, struct drm_plane_state *state, struct drm_property *property, uint64_t val); -int intel_plane_atomic_calc_changes(struct drm_crtc_state *crtc_state, +int intel_plane_atomic_calc_changes(const struct intel_crtc_state *old_crtc_state, + struct drm_crtc_state *crtc_state, + const struct intel_plane_state *old_plane_state, struct drm_plane_state *plane_state);

void assert_pch_transcoder_disabled(struct drm_i915_private *dev_priv, @@ -1990,7 +2000,9 @@ struct drm_plane_state *intel_plane_duplicate_state(struct drm_plane *plane); void intel_plane_destroy_state(struct drm_plane *plane, struct drm_plane_state *state); extern const struct drm_plane_helper_funcs intel_plane_helper_funcs; -int intel_plane_atomic_check_with_state(struct intel_crtc_state *crtc_state, +int intel_plane_atomic_check_with_state(const struct intel_crtc_state *old_crtc_state, + struct intel_crtc_state *crtc_state, + const struct intel_plane_state *old_plane_state, struct intel_plane_state *intel_state);

/* intel_color.c */

From: Ville Syrjälä ville.syrjala@linux.intel.com

Dig up the appropriate new crtc and plane states from the top level atomic state in intel_pre_plane_update() and intel_post_plane_update().

Signed-off-by: Ville Syrjälä ville.syrjala@linux.intel.com --- drivers/gpu/drm/i915/intel_display.c | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c index 6440479d6fe2..182881c4d6d3 100644 --- a/drivers/gpu/drm/i915/intel_display.c +++ b/drivers/gpu/drm/i915/intel_display.c @@ -4994,7 +4994,8 @@ static void intel_post_plane_update(struct intel_crtc_state *old_crtc_state) struct intel_crtc *crtc = to_intel_crtc(old_crtc_state->base.crtc); struct drm_atomic_state *old_state = old_crtc_state->base.state; struct intel_crtc_state *pipe_config = - to_intel_crtc_state(crtc->base.state); + intel_atomic_get_new_crtc_state(to_intel_atomic_state(old_state), + crtc); struct drm_plane *primary = crtc->base.primary; struct drm_plane_state *old_pri_state = drm_atomic_get_existing_plane_state(old_state, primary); @@ -5006,7 +5007,8 @@ static void intel_post_plane_update(struct intel_crtc_state *old_crtc_state)

if (old_pri_state) { struct intel_plane_state *primary_state = - to_intel_plane_state(primary->state); + intel_atomic_get_new_plane_state(to_intel_atomic_state(old_state), + to_intel_plane(primary)); struct intel_plane_state *old_primary_state = to_intel_plane_state(old_pri_state);

@@ -5035,7 +5037,8 @@ static void intel_pre_plane_update(struct intel_crtc_state *old_crtc_state,

if (old_pri_state) { struct intel_plane_state *primary_state = - to_intel_plane_state(primary->state); + intel_atomic_get_new_plane_state(old_intel_state, + to_intel_plane(primary)); struct intel_plane_state *old_primary_state = to_intel_plane_state(old_pri_state);

From: Ville Syrjälä ville.syrjala@linux.intel.com

We already have the correct new crtc state so just use that instead of crtc->state.

Signed-off-by: Ville Syrjälä ville.syrjala@linux.intel.com --- drivers/gpu/drm/i915/intel_display.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c index 0c18e3e7c6a5..791204c8621c 100644 --- a/drivers/gpu/drm/i915/intel_display.c +++ b/drivers/gpu/drm/i915/intel_display.c @@ -12970,7 +12970,7 @@ static void skl_update_crtcs(struct drm_atomic_state *state, unsigned int cmask = drm_crtc_mask(crtc);

intel_crtc = to_intel_crtc(crtc); - cstate = to_intel_crtc_state(crtc->state); + cstate = to_intel_crtc_state(new_crtc_state); pipe = intel_crtc->pipe;

if (updated & cmask || !cstate->base.active) @@ -13073,7 +13073,7 @@ static void intel_atomic_commit_tail(struct drm_atomic_state *state) intel_check_cpu_fifo_underruns(dev_priv); intel_check_pch_fifo_underruns(dev_priv);

- if (!crtc->state->active) { + if (!new_crtc_state->active) { /* * Make sure we don't call initial_watermarks * for ILK-style watermark updates. @@ -13082,7 +13082,7 @@ static void intel_atomic_commit_tail(struct drm_atomic_state *state) */ if (INTEL_GEN(dev_priv) >= 9) dev_priv->display.initial_watermarks(intel_state, - to_intel_crtc_state(crtc->state)); + to_intel_crtc_state(new_crtc_state)); } } }

From: Ville Syrjälä ville.syrjala@linux.intel.com

Add a small helper that gives us dynamically growing arrays. We have a couple hand rolled implementations of this in the atomic code, which we can unify to use a common implementation.

Signed-off-by: Ville Syrjälä ville.syrjala@linux.intel.com --- Documentation/gpu/drm-utils.rst | 15 +++++++ Documentation/gpu/index.rst | 1 + drivers/gpu/drm/Makefile | 2 +- drivers/gpu/drm/drm_dynarray.c | 97 +++++++++++++++++++++++++++++++++++++++++ include/drm/drm_dynarray.h | 54 +++++++++++++++++++++++ 5 files changed, 168 insertions(+), 1 deletion(-) create mode 100644 Documentation/gpu/drm-utils.rst create mode 100644 drivers/gpu/drm/drm_dynarray.c create mode 100644 include/drm/drm_dynarray.h

diff --git a/Documentation/gpu/drm-utils.rst b/Documentation/gpu/drm-utils.rst new file mode 100644 index 000000000000..bff8c899d7cd --- /dev/null +++ b/Documentation/gpu/drm-utils.rst @@ -0,0 +1,15 @@ +============= +DRM Utilities +============= + +Dynamic arrays +-------------- + +.. kernel-doc:: drivers/gpu/drm/drm_dynarray.c + :doc: Dynamic arrays + +.. kernel-doc:: drivers/gpu/drm/drm_dynarray.c + :export: + +.. kernel-doc:: include/drm/drm_dynarray.h + :internal: diff --git a/Documentation/gpu/index.rst b/Documentation/gpu/index.rst index 35d673bf9b56..b7d196e5c70d 100644 --- a/Documentation/gpu/index.rst +++ b/Documentation/gpu/index.rst @@ -10,6 +10,7 @@ Linux GPU Driver Developer's Guide drm-kms drm-kms-helpers drm-uapi + drm-utils i915 meson pl111 diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile index 24a066e1841c..b637a34df388 100644 --- a/drivers/gpu/drm/Makefile +++ b/drivers/gpu/drm/Makefile @@ -3,7 +3,7 @@ # Direct Rendering Infrastructure (DRI) in XFree86 4.1.0 and higher.

drm-y := drm_auth.o drm_bufs.o drm_cache.o \ - drm_context.o drm_dma.o \ + drm_context.o drm_dma.o drm_dynarray.o \ drm_file.o drm_gem.o drm_ioctl.o drm_irq.o \ drm_lock.o drm_memory.o drm_drv.o \ drm_scatter.o drm_pci.o \ diff --git a/drivers/gpu/drm/drm_dynarray.c b/drivers/gpu/drm/drm_dynarray.c new file mode 100644 index 000000000000..69a8819ecb62 --- /dev/null +++ b/drivers/gpu/drm/drm_dynarray.c @@ -0,0 +1,97 @@ +/* + * Copyright (C) 2017 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. + */ + +#include <linux/slab.h> +#include <linux/string.h> +#include <drm/drm_dynarray.h> + +/** + * DOC: Dynamic arrays + * + * Helper that provides dynamically growing arrays. The array + * must be initilaized to specify the size of each element, and + * space can be reserved in the array by specifying the element + * index to be used. + */ + +/** + * drm_dynarray_init - Initialize the dynamic array + * @dynarr: the dynamic array + * @elem_size: size of each element in bytes + * + * Initialize the dynamic array and specify the size of + * each element of the array. + */ +void drm_dynarray_init(struct drm_dynarray *dynarr, + unsigned int elem_size) +{ + memset(dynarr, 0, sizeof(*dynarr)); + dynarr->elem_size = elem_size; +} +EXPORT_SYMBOL(drm_dynarray_init); + +/** + * drm_dynarray_fini - Finalize the dynamic array + * @dynarr: the dynamic array + * + * Finalize the dynamic array, ie. free the memory + * used by the array. + */ +void drm_dynarray_fini(struct drm_dynarray *dynarr) +{ + kfree(dynarr->elems); + memset(dynarr, 0, sizeof(*dynarr)); +} +EXPORT_SYMBOL(drm_dynarray_fini); + +/** + * drm_dynarray_reserve - Reserve space in the dynamic array + * @dynarr: the dynamic array + * @index: the index of the element to reserve + * + * Grow the array sufficiently to make sure @index points + * to a valid memory location within the array. + */ +int drm_dynarray_reserve(struct drm_dynarray *dynarr, + unsigned int index) +{ + unsigned int num_elems = index + 1; + unsigned int old_num_elems = dynarr->num_elems; + void *elems; + + if (num_elems <= old_num_elems) + return 0; + + elems = krealloc(dynarr->elems, + num_elems * dynarr->elem_size, GFP_KERNEL); + if (!elems) + return -ENOMEM; + + dynarr->elems = elems; + dynarr->num_elems = num_elems; + + memset(drm_dynarray_elem(dynarr, old_num_elems), 0, + (num_elems - old_num_elems) * dynarr->elem_size); + + return 0; +} +EXPORT_SYMBOL(drm_dynarray_reserve); diff --git a/include/drm/drm_dynarray.h b/include/drm/drm_dynarray.h new file mode 100644 index 000000000000..c8cd088a3a3b --- /dev/null +++ b/include/drm/drm_dynarray.h @@ -0,0 +1,54 @@ +/* + * Copyright (C) 2017 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. + */ + +#ifndef DRM_DYNARRAY_H +#define DRM_DYNARRAY_H + +struct drm_dynarray { + void *elems; + unsigned int elem_size, num_elems; +}; + +/** + * drm_dynarray_elem - Return a pointer to an element + * @dynarr: the dynamic array + * @index: the index of the element + * + * Returns: + * A pointer to the element at @index in the array. + */ +static inline void *drm_dynarray_elem(const struct drm_dynarray *dynarr, + unsigned int index) +{ + if (index >= dynarr->num_elems) + return NULL; + return dynarr->elems + index * dynarr->elem_size; +} + +int drm_dynarray_reserve(struct drm_dynarray *dynarr, + unsigned int index); + +void drm_dynarray_init(struct drm_dynarray *dynarr, + unsigned int elem_size); +void drm_dynarray_fini(struct drm_dynarray *dynarr); + +#endif

From: Ville Syrjälä ville.syrjala@linux.intel.com

We will never add private objects with a NULL state into the atomic state, hence checking for that is pointless.

Cc: Dhinakaran Pandiyan dhinakaran.pandiyan@intel.com Reviewed-by: Daniel Vetter daniel.vetter@ffwll.ch Signed-off-by: Ville Syrjälä ville.syrjala@linux.intel.com --- drivers/gpu/drm/drm_atomic.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/drivers/gpu/drm/drm_atomic.c b/drivers/gpu/drm/drm_atomic.c index 1663ec3626a1..a61e396b11a8 100644 --- a/drivers/gpu/drm/drm_atomic.c +++ b/drivers/gpu/drm/drm_atomic.c @@ -1019,8 +1019,7 @@ drm_atomic_get_private_obj_state(struct drm_atomic_state *state, void *obj, struct __drm_private_objs_state *arr;

for (i = 0; i < state->num_private_objs; i++) - if (obj == state->private_objs[i].obj && - state->private_objs[i].obj_state) + if (obj == state->private_objs[i].obj) return state->private_objs[i].obj_state;

num_objs = state->num_private_objs + 1;

From: Ville Syrjälä ville.syrjala@linux.intel.com

Make the atomic private object stuff less special by introducing proper base classes for the object and its state. Drivers can embed these in their own appropriate objects, after which these things will work exactly like the plane/crtc/connector states during atomic operations.

Cc: Dhinakaran Pandiyan dhinakaran.pandiyan@intel.com Reviewed-by: Daniel Vetter daniel.vetter@ffwll.ch Signed-off-by: Ville Syrjälä ville.syrjala@linux.intel.com --- drivers/gpu/drm/drm_atomic.c | 78 +++++++++++++++------ drivers/gpu/drm/drm_atomic_helper.c | 30 +++++++-- drivers/gpu/drm/drm_dp_mst_topology.c | 63 +++++++++-------- include/drm/drm_atomic.h | 123 +++++++++++++++++++++------------- include/drm/drm_atomic_helper.h | 4 ++ include/drm/drm_dp_mst_helper.h | 10 +++ 6 files changed, 206 insertions(+), 102 deletions(-)

diff --git a/drivers/gpu/drm/drm_atomic.c b/drivers/gpu/drm/drm_atomic.c index 5eb14c73c0fb..da7752230e4c 100644 --- a/drivers/gpu/drm/drm_atomic.c +++ b/drivers/gpu/drm/drm_atomic.c @@ -197,12 +197,14 @@ void drm_atomic_state_default_clear(struct drm_atomic_state *state) for (i = 0; i < state->num_private_objs; i++) { struct __drm_private_objs_state *p = __drm_atomic_state_private_obj(state, i); - void *obj_state = p->obj_state; + struct drm_private_obj *obj = p->ptr;

- p->funcs->destroy_state(obj_state); - p->obj = NULL; - p->obj_state = NULL; - p->funcs = NULL; + if (WARN_ON(!obj)) + continue; + + obj->funcs->atomic_destroy_state(obj, p->state); + p->ptr = NULL; + p->state = NULL; } state->num_private_objs = 0;

@@ -1000,11 +1002,44 @@ static void drm_atomic_plane_print_state(struct drm_printer *p, }

/** + * drm_atomic_private_obj_init - initialize private object + * @obj: private object + * @state: initial private object state + * @funcs: pointer to the struct of function pointers that identify the object + * type + * + * Initialize the private object, which can be embedded into any + * driver private object that needs its own atomic state. + */ +void +drm_atomic_private_obj_init(struct drm_private_obj *obj, + struct drm_private_state *state, + const struct drm_private_state_funcs *funcs) +{ + memset(obj, 0, sizeof(*obj)); + + obj->state = state; + obj->funcs = funcs; +} +EXPORT_SYMBOL(drm_atomic_private_obj_init); + +/** + * drm_atomic_private_obj_fini - finalize private object + * @obj: private object + * + * Finalize the private object. + */ +void +drm_atomic_private_obj_fini(struct drm_private_obj *obj) +{ + obj->funcs->atomic_destroy_state(obj, obj->state); +} +EXPORT_SYMBOL(drm_atomic_private_obj_fini); + +/** * drm_atomic_get_private_obj_state - get private object state * @state: global atomic state * @obj: private object to get the state for - * @funcs: pointer to the struct of function pointers that identify the object - * type * * This function returns the private object state for the given private object, * allocating the state if needed. It does not grab any locks as the caller is @@ -1014,19 +1049,21 @@ static void drm_atomic_plane_print_state(struct drm_printer *p, * * Either the allocated state or the error code encoded into a pointer. */ -void * -drm_atomic_get_private_obj_state(struct drm_atomic_state *state, void *obj, - const struct drm_private_state_funcs *funcs) +struct drm_private_state * +drm_atomic_get_private_obj_state(struct drm_atomic_state *state, + struct drm_private_obj *obj) { + const struct drm_private_state_funcs *funcs = obj->funcs; struct __drm_private_objs_state *p; + struct drm_private_state *obj_state; int index = state->num_private_objs; int ret, i;

for (i = 0; i < state->num_private_objs; i++) { p = __drm_atomic_state_private_obj(state, i);

- if (obj == p->obj) - return p->obj_state; + if (obj == p->ptr) + return p->state; }

ret = drm_dynarray_reserve(&state->private_objs, index); @@ -1035,19 +1072,22 @@ drm_atomic_get_private_obj_state(struct drm_atomic_state *state, void *obj,

p = __drm_atomic_state_private_obj(state, index);

- p->obj_state = funcs->duplicate_state(state, obj); - if (!p->obj_state) + obj_state = funcs->atomic_duplicate_state(obj); + if (!obj_state) return ERR_PTR(-ENOMEM);

- p->obj = obj; - p->funcs = funcs; + p->state = obj_state; + p->old_state = obj->state; + p->new_state = obj_state; + p->ptr = obj; + obj_state->state = state;

state->num_private_objs = index + 1;

- DRM_DEBUG_ATOMIC("Added new private object state %p to %p\n", - p->obj_state, state); + DRM_DEBUG_ATOMIC("Added new private object [%p] state %p to %p\n", + obj, obj_state, state);

- return p->obj_state; + return obj_state; } EXPORT_SYMBOL(drm_atomic_get_private_obj_state);

diff --git a/drivers/gpu/drm/drm_atomic_helper.c b/drivers/gpu/drm/drm_atomic_helper.c index 77b57cdf0460..bc7d3a5a50f7 100644 --- a/drivers/gpu/drm/drm_atomic_helper.c +++ b/drivers/gpu/drm/drm_atomic_helper.c @@ -2267,8 +2267,8 @@ void drm_atomic_helper_swap_state(struct drm_atomic_state *state, struct drm_plane *plane; struct drm_plane_state *old_plane_state, *new_plane_state; struct drm_crtc_commit *commit; - void *obj, *obj_state; - const struct drm_private_state_funcs *funcs; + struct drm_private_obj *obj; + struct drm_private_state *old_obj_state, *new_obj_state;

if (stall) { for_each_new_crtc_in_state(state, crtc, new_crtc_state, i) { @@ -2330,8 +2330,15 @@ void drm_atomic_helper_swap_state(struct drm_atomic_state *state, plane->state = new_plane_state; }

- __for_each_private_obj(state, obj, obj_state, i, funcs) - funcs->swap_state(obj, &__drm_atomic_state_private_obj(state, i)->obj_state); + for_each_oldnew_private_obj_in_state(state, obj, old_obj_state, new_obj_state, i) { + WARN_ON(obj->state != old_obj_state); + + old_obj_state->state = state; + new_obj_state->state = NULL; + + __drm_atomic_state_private_obj(state, i)->state = old_obj_state; + obj->state = new_obj_state; + } } EXPORT_SYMBOL(drm_atomic_helper_swap_state);

@@ -3828,3 +3835,18 @@ int drm_atomic_helper_legacy_gamma_set(struct drm_crtc *crtc, 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_dp_mst_topology.c b/drivers/gpu/drm/drm_dp_mst_topology.c index bfd237c15e76..91510098f60e 100644 --- a/drivers/gpu/drm/drm_dp_mst_topology.c +++ b/drivers/gpu/drm/drm_dp_mst_topology.c @@ -31,6 +31,8 @@ #include <drm/drmP.h>

#include <drm/drm_fixed.h> +#include <drm/drm_atomic.h> +#include <drm/drm_atomic_helper.h>

/** * DOC: dp mst helper @@ -2992,41 +2994,32 @@ static void drm_dp_destroy_connector_work(struct work_struct *work) (*mgr->cbs->hotplug)(mgr); }

-void *drm_dp_mst_duplicate_state(struct drm_atomic_state *state, void *obj) +static struct drm_private_state * +drm_dp_mst_duplicate_state(struct drm_private_obj *obj) { - struct drm_dp_mst_topology_mgr *mgr = obj; - struct drm_dp_mst_topology_state *new_mst_state; + struct drm_dp_mst_topology_state *state;

- if (WARN_ON(!mgr->state)) + state = kmemdup(obj->state, sizeof(*state), GFP_KERNEL); + if (!state) return NULL;

- new_mst_state = kmemdup(mgr->state, sizeof(*new_mst_state), GFP_KERNEL); - if (new_mst_state) - new_mst_state->state = state; - return new_mst_state; -} - -void drm_dp_mst_swap_state(void *obj, void **obj_state_ptr) -{ - struct drm_dp_mst_topology_mgr *mgr = obj; - struct drm_dp_mst_topology_state **topology_state_ptr; - - topology_state_ptr = (struct drm_dp_mst_topology_state **)obj_state_ptr; + __drm_atomic_helper_private_obj_duplicate_state(obj, &state->base);

- mgr->state->state = (*topology_state_ptr)->state; - swap(*topology_state_ptr, mgr->state); - mgr->state->state = NULL; + return &state->base; }

-void drm_dp_mst_destroy_state(void *obj_state) +static void drm_dp_mst_destroy_state(struct drm_private_obj *obj, + struct drm_private_state *state) { - kfree(obj_state); + struct drm_dp_mst_topology_state *mst_state = + to_dp_mst_topology_state(state); + + kfree(mst_state); }

static const struct drm_private_state_funcs mst_state_funcs = { - .duplicate_state = drm_dp_mst_duplicate_state, - .swap_state = drm_dp_mst_swap_state, - .destroy_state = drm_dp_mst_destroy_state, + .atomic_duplicate_state = drm_dp_mst_duplicate_state, + .atomic_destroy_state = drm_dp_mst_destroy_state, };

/** @@ -3050,8 +3043,7 @@ struct drm_dp_mst_topology_state *drm_atomic_get_mst_topology_state(struct drm_a struct drm_device *dev = mgr->dev;

WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex)); - return drm_atomic_get_private_obj_state(state, mgr, - &mst_state_funcs); + return to_dp_mst_topology_state(drm_atomic_get_private_obj_state(state, &mgr->base)); } EXPORT_SYMBOL(drm_atomic_get_mst_topology_state);

@@ -3071,6 +3063,8 @@ int drm_dp_mst_topology_mgr_init(struct drm_dp_mst_topology_mgr *mgr, int max_dpcd_transaction_bytes, int max_payloads, int conn_base_id) { + struct drm_dp_mst_topology_state *mst_state; + mutex_init(&mgr->lock); mutex_init(&mgr->qlock); mutex_init(&mgr->payload_lock); @@ -3099,14 +3093,18 @@ int drm_dp_mst_topology_mgr_init(struct drm_dp_mst_topology_mgr *mgr, if (test_calc_pbn_mode() < 0) DRM_ERROR("MST PBN self-test failed\n");

- mgr->state = kzalloc(sizeof(*mgr->state), GFP_KERNEL); - if (mgr->state == NULL) + mst_state = kzalloc(sizeof(*mst_state), GFP_KERNEL); + if (mst_state == NULL) return -ENOMEM; - mgr->state->mgr = mgr; + + mst_state->mgr = mgr;

/* max. time slots - one slot for MTP header */ - mgr->state->avail_slots = 63; - mgr->funcs = &mst_state_funcs; + mst_state->avail_slots = 63; + + drm_atomic_private_obj_init(&mgr->base, + &mst_state->base, + &mst_state_funcs);

return 0; } @@ -3128,8 +3126,7 @@ void drm_dp_mst_topology_mgr_destroy(struct drm_dp_mst_topology_mgr *mgr) mutex_unlock(&mgr->payload_lock); mgr->dev = NULL; mgr->aux = NULL; - kfree(mgr->state); - mgr->state = NULL; + drm_atomic_private_obj_fini(&mgr->base); mgr->funcs = NULL; } EXPORT_SYMBOL(drm_dp_mst_topology_mgr_destroy); diff --git a/include/drm/drm_atomic.h b/include/drm/drm_atomic.h index 809e8b4c3719..addec49a14bf 100644 --- a/include/drm/drm_atomic.h +++ b/include/drm/drm_atomic.h @@ -155,6 +155,9 @@ struct __drm_connectors_state { struct drm_connector_state *state, *old_state, *new_state; };

+struct drm_private_obj; +struct drm_private_state; + /** * struct drm_private_state_funcs - atomic state functions for private objects * @@ -167,7 +170,7 @@ struct __drm_connectors_state { */ struct drm_private_state_funcs { /** - * @duplicate_state: + * @atomic_duplicate_state: * * Duplicate the current state of the private object and return it. It * is an error to call this before obj->state has been initialized. @@ -177,29 +180,30 @@ struct drm_private_state_funcs { * Duplicated atomic state or NULL when obj->state is not * initialized or allocation failed. */ - void *(*duplicate_state)(struct drm_atomic_state *state, void *obj); + struct drm_private_state *(*atomic_duplicate_state)(struct drm_private_obj *obj);

/** - * @swap_state: + * @atomic_destroy_state: * - * This function swaps the existing state of a private object @obj with - * it's newly created state, the pointer to which is passed as - * @obj_state_ptr. + * Frees the private object state created with @atomic_duplicate_state. */ - void (*swap_state)(void *obj, void **obj_state_ptr); + void (*atomic_destroy_state)(struct drm_private_obj *obj, + struct drm_private_state *state); +};

- /** - * @destroy_state: - * - * Frees the private object state created with @duplicate_state. - */ - void (*destroy_state)(void *obj_state); +struct drm_private_obj { + struct drm_private_state *state; + + const struct drm_private_state_funcs *funcs; +}; + +struct drm_private_state { + struct drm_atomic_state *state; };

struct __drm_private_objs_state { - void *obj; - void *obj_state; - const struct drm_private_state_funcs *funcs; + struct drm_private_obj *ptr; + struct drm_private_state *state, *old_state, *new_state; };

/** @@ -336,10 +340,14 @@ int drm_atomic_connector_set_property(struct drm_connector *connector, struct drm_connector_state *state, struct drm_property *property, uint64_t val);

-void * __must_check +void drm_atomic_private_obj_init(struct drm_private_obj *obj, + struct drm_private_state *state, + const struct drm_private_state_funcs *funcs); +void drm_atomic_private_obj_fini(struct drm_private_obj *obj); + +struct drm_private_state * __must_check drm_atomic_get_private_obj_state(struct drm_atomic_state *state, - void *obj, - const struct drm_private_state_funcs *funcs); + struct drm_private_obj *obj);

/** * drm_atomic_get_existing_crtc_state - get crtc state, if it exists @@ -826,43 +834,66 @@ void drm_state_dump(struct drm_device *dev, struct drm_printer *p); for_each_if (plane)

/** - * __for_each_private_obj - iterate over all private objects + * for_each_oldnew_private_obj_in_state - iterate over all private objects in an atomic update * @__state: &struct drm_atomic_state pointer - * @obj: private object iteration cursor - * @obj_state: private object state iteration cursor + * @obj: &struct drm_private_obj iteration cursor + * @old_obj_state: &struct drm_private_state iteration cursor for the old state + * @new_obj_state: &struct drm_private_state iteration cursor for the new state * @__i: int iteration cursor, for macro-internal use - * @__funcs: &struct drm_private_state_funcs iteration cursor * - * This macro iterates over the array containing private object data in atomic - * state + * This iterates over all private objects in an atomic update, tracking both + * old and new state. This is useful in places where the state delta needs + * to be considered, for example in atomic check functions. */ -#define __for_each_private_obj(__state, obj, obj_state, __i, __funcs) \ - for ((__i) = 0; \ - (__i) < (__state)->num_private_objs && \ - ((obj) = __drm_atomic_state_private_obj(__state, __i)->obj, \ - (__funcs) = __drm_atomic_state_private_obj(__state, __i)->funcs, \ - (obj_state) = __drm_atomic_state_private_obj(__state, __i)->obj_state, \ - 1); \ - (__i)++) \ +#define for_each_oldnew_private_obj_in_state(__state, obj, old_obj_state, new_obj_state, __i) \ + for ((__i) = 0; \ + (__i) < (__state)->num_private_objs && \ + ((obj) = __drm_atomic_state_private_obj(__state, __i)->ptr, \ + (old_obj_state) = __drm_atomic_state_private_obj(__state, __i)->old_state, \ + (new_obj_state) = __drm_atomic_state_private_obj(__state, __i)->new_state, 1); \ + (__i)++) \ + for_each_if (obj) +

/** - * for_each_private_obj - iterate over a specify type of private object + * for_each_old_private_obj_in_state - iterate over all private objects in an atomic update * @__state: &struct drm_atomic_state pointer - * @obj_funcs: &struct drm_private_state_funcs function table to filter - * private objects - * @obj: private object iteration cursor - * @obj_state: private object state iteration cursor + * @obj: &struct drm_private_obj iteration cursor + * @old_obj_state: &struct drm_private_state iteration cursor for the old state * @__i: int iteration cursor, for macro-internal use - * @__funcs: &struct drm_private_state_funcs iteration cursor * - * This macro iterates over the private objects state array while filtering the - * objects based on the vfunc table that is passed as @obj_funcs. New macros - * can be created by passing in the vfunc table associated with a specific - * private object. + * This iterates over all private objects in an atomic update, tracking only + * the old state. This is useful in disable functions, where we need the old + * state the hardware is still in. */ -#define for_each_private_obj(__state, obj_funcs, obj, obj_state, __i, __funcs) \ - __for_each_private_obj(__state, obj, obj_state, __i, __funcs) \ - for_each_if (__funcs == obj_funcs) +#define for_each_old_private_obj_in_state(__state, obj, old_obj_state, __i) \ + for ((__i) = 0; \ + (__i) < (__state)->num_private_objs && \ + ((obj) = __drm_atomic_state_private_obj(__state, __i)->ptr, \ + (old_obj_state) = __drm_atomic_state_private_obj(__state, __i)->old_state, 1); \ + (__i)++) \ + for_each_if (obj) + + +/** + * for_each_new_private_obj_in_state - iterate over all private objects in an atomic update + * @__state: &struct drm_atomic_state pointer + * @obj: &struct drm_private_obj iteration cursor + * @new_obj_state: &struct drm_private_state iteration cursor for the new state + * @__i: int iteration cursor, for macro-internal use + * + * This iterates over all private objects in an atomic update, tracking only + * the new state. This is useful in enable functions, where we need the new state the + * hardware should be in when the atomic commit operation has completed. + */ +#define for_each_new_private_obj_in_state(__state, obj, new_obj_state, __i) \ + for ((__i) = 0; \ + (__i) < (__state)->num_private_objs && \ + ((obj) = __drm_atomic_state_private_obj(__state, __i)->ptr, \ + (new_obj_state) = __drm_atomic_state_private_obj(__state, __i)->new_state, 1); \ + (__i)++) \ + for_each_if (obj) +

/** * drm_atomic_crtc_needs_modeset - compute combined modeset need diff --git a/include/drm/drm_atomic_helper.h b/include/drm/drm_atomic_helper.h index dd196cc0afd7..7db3438ff735 100644 --- a/include/drm/drm_atomic_helper.h +++ b/include/drm/drm_atomic_helper.h @@ -33,6 +33,8 @@ #include <drm/drm_modeset_helper.h>

struct drm_atomic_state; +struct drm_private_obj; +struct drm_private_state;

int drm_atomic_helper_check_modeset(struct drm_device *dev, struct drm_atomic_state *state); @@ -185,6 +187,8 @@ 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 diff --git a/include/drm/drm_dp_mst_helper.h b/include/drm/drm_dp_mst_helper.h index 177ab6f86855..d55abb75f29a 100644 --- a/include/drm/drm_dp_mst_helper.h +++ b/include/drm/drm_dp_mst_helper.h @@ -404,12 +404,17 @@ struct drm_dp_payload { int vcpi; };

+#define to_dp_mst_topology_state(x) container_of(x, struct drm_dp_mst_topology_state, base) + struct drm_dp_mst_topology_state { + struct drm_private_state base; int avail_slots; struct drm_atomic_state *state; struct drm_dp_mst_topology_mgr *mgr; };

+#define to_dp_mst_topology_mgr(x) container_of(x, struct drm_dp_mst_topology_mgr, base) + /** * struct drm_dp_mst_topology_mgr - DisplayPort MST manager * @@ -419,6 +424,11 @@ struct drm_dp_mst_topology_state { */ struct drm_dp_mst_topology_mgr { /** + * @base: Base private object for atomic + */ + struct drm_private_obj base; + + /** * @dev: device pointer for adding i2c devices etc. */ struct drm_device *dev;

From: Ville Syrjälä ville.syrjala@linux.intel.com

Rename the local 'old_state' variable to 'old_mali_state' to get it out of the way of some cocci refactoring.

Signed-off-by: Ville Syrjälä ville.syrjala@linux.intel.com --- drivers/gpu/drm/arm/malidp_crtc.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/drivers/gpu/drm/arm/malidp_crtc.c b/drivers/gpu/drm/arm/malidp_crtc.c index 037514f42a83..2a92cb066bea 100644 --- a/drivers/gpu/drm/arm/malidp_crtc.c +++ b/drivers/gpu/drm/arm/malidp_crtc.c @@ -417,23 +417,23 @@ static const struct drm_crtc_helper_funcs malidp_crtc_helper_funcs = {

static struct drm_crtc_state *malidp_crtc_duplicate_state(struct drm_crtc *crtc) { - struct malidp_crtc_state *state, *old_state; + struct malidp_crtc_state *state, *old_mali_state;

if (WARN_ON(!crtc->state)) return NULL;

- old_state = to_malidp_crtc_state(crtc->state); + old_mali_state = to_malidp_crtc_state(crtc->state); state = kmalloc(sizeof(*state), GFP_KERNEL); if (!state) return NULL;

__drm_atomic_helper_crtc_duplicate_state(crtc, &state->base, crtc->state); - memcpy(state->gamma_coeffs, old_state->gamma_coeffs, + memcpy(state->gamma_coeffs, old_mali_state->gamma_coeffs, sizeof(state->gamma_coeffs)); - memcpy(state->coloradj_coeffs, old_state->coloradj_coeffs, + memcpy(state->coloradj_coeffs, old_mali_state->coloradj_coeffs, sizeof(state->coloradj_coeffs)); - memcpy(&state->scaler_config, &old_state->scaler_config, + memcpy(&state->scaler_config, &old_mali_state->scaler_config, sizeof(state->scaler_config)); state->scaled_planes_mask = 0;

From: Ville Syrjälä ville.syrjala@linux.intel.com

We'll be wanting to duplicate other states besides the one pointed to by crtc->state & co., so pass the duplicated state in explicitly.

I wanted to make the old_state const, but that would have results in tons of new warnings because some drivers have their to_foo_state()s as static inlines. So I decided to leave old_state as non-const in the end.

@r@ identifier F =~ "^[^_].*duplicate_.*state$"; identifier I; type TO, TS; @@ TS F(TO I + ,TS old_state ) { <... - I->state + old_state ...> }

@@ identifier r.F; expression E; @@ F(E + ,E->state )

@@ type r.TO; type r.TS; type TF; identifier I; @@ TF { ... TS (*atomic_duplicate_state)(TO I + ,TS old_state ); ... };

@@ expression X, E; @@ X->atomic_duplicate_state(E + ,E->state )

Signed-off-by: Ville Syrjälä ville.syrjala@linux.intel.com --- drivers/gpu/drm/arm/malidp_crtc.c | 9 +++++---- drivers/gpu/drm/arm/malidp_planes.c | 9 +++++---- drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_crtc.c | 9 +++++---- drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_plane.c | 5 +++-- drivers/gpu/drm/drm_atomic.c | 10 ++++++---- drivers/gpu/drm/drm_atomic_helper.c | 21 ++++++++++++--------- drivers/gpu/drm/drm_crtc_helper.c | 12 ++++++++---- drivers/gpu/drm/drm_dp_mst_topology.c | 7 ++++--- drivers/gpu/drm/drm_plane_helper.c | 12 ++++++++---- drivers/gpu/drm/exynos/exynos_drm_plane.c | 7 ++++--- drivers/gpu/drm/i915/intel_atomic.c | 14 ++++++++------ drivers/gpu/drm/i915/intel_atomic_plane.c | 7 ++++--- drivers/gpu/drm/i915/intel_display.c | 2 +- drivers/gpu/drm/i915/intel_drv.h | 9 ++++++--- drivers/gpu/drm/i915/intel_sdvo.c | 7 ++++--- drivers/gpu/drm/imx/ipuv3-crtc.c | 5 +++-- drivers/gpu/drm/imx/ipuv3-plane.c | 7 ++++--- drivers/gpu/drm/mediatek/mtk_drm_crtc.c | 5 +++-- drivers/gpu/drm/mediatek/mtk_drm_plane.c | 7 ++++--- drivers/gpu/drm/msm/mdp/mdp5/mdp5_crtc.c | 9 +++++---- drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c | 13 +++++++------ drivers/gpu/drm/nouveau/nouveau_connector.c | 7 ++++--- drivers/gpu/drm/nouveau/nouveau_connector.h | 3 ++- drivers/gpu/drm/nouveau/nv50_display.c | 14 ++++++++------ drivers/gpu/drm/rcar-du/rcar_du_plane.c | 9 +++++---- drivers/gpu/drm/rcar-du/rcar_du_vsp.c | 9 +++++---- drivers/gpu/drm/rockchip/rockchip_drm_vop.c | 5 +++-- drivers/gpu/drm/tegra/dc.c | 14 ++++++++------ drivers/gpu/drm/tegra/dsi.c | 7 ++++--- drivers/gpu/drm/tegra/sor.c | 7 ++++--- drivers/gpu/drm/vc4/vc4_crtc.c | 5 +++-- drivers/gpu/drm/vc4/vc4_plane.c | 9 +++++---- drivers/gpu/drm/vmwgfx/vmwgfx_kms.c | 25 ++++++++++++++----------- drivers/gpu/drm/vmwgfx/vmwgfx_kms.h | 9 ++++++--- include/drm/drm_atomic.h | 3 ++- include/drm/drm_atomic_helper.h | 9 ++++++--- include/drm/drm_connector.h | 3 ++- include/drm/drm_crtc.h | 3 ++- include/drm/drm_plane.h | 3 ++- 39 files changed, 194 insertions(+), 136 deletions(-)

diff --git a/drivers/gpu/drm/arm/malidp_crtc.c b/drivers/gpu/drm/arm/malidp_crtc.c index 2a92cb066bea..8c78cb13b23b 100644 --- a/drivers/gpu/drm/arm/malidp_crtc.c +++ b/drivers/gpu/drm/arm/malidp_crtc.c @@ -415,20 +415,21 @@ static const struct drm_crtc_helper_funcs malidp_crtc_helper_funcs = { .atomic_disable = malidp_crtc_atomic_disable, };

-static struct drm_crtc_state *malidp_crtc_duplicate_state(struct drm_crtc *crtc) +static struct drm_crtc_state *malidp_crtc_duplicate_state(struct drm_crtc *crtc, + struct drm_crtc_state *old_state) { struct malidp_crtc_state *state, *old_mali_state;

- if (WARN_ON(!crtc->state)) + if (WARN_ON(!old_state)) return NULL;

- old_mali_state = to_malidp_crtc_state(crtc->state); + old_mali_state = to_malidp_crtc_state(old_state); state = kmalloc(sizeof(*state), GFP_KERNEL); if (!state) return NULL;

__drm_atomic_helper_crtc_duplicate_state(crtc, &state->base, - crtc->state); + old_state); memcpy(state->gamma_coeffs, old_mali_state->gamma_coeffs, sizeof(state->gamma_coeffs)); memcpy(state->coloradj_coeffs, old_mali_state->coloradj_coeffs, diff --git a/drivers/gpu/drm/arm/malidp_planes.c b/drivers/gpu/drm/arm/malidp_planes.c index fe744396bc99..33b0c07ad3a3 100644 --- a/drivers/gpu/drm/arm/malidp_planes.c +++ b/drivers/gpu/drm/arm/malidp_planes.c @@ -86,20 +86,21 @@ static void malidp_plane_reset(struct drm_plane *plane) }

static struct -drm_plane_state *malidp_duplicate_plane_state(struct drm_plane *plane) +drm_plane_state *malidp_duplicate_plane_state(struct drm_plane *plane, + struct drm_plane_state *old_state) { struct malidp_plane_state *state, *m_state;

- if (!plane->state) + if (!old_state) return NULL;

state = kmalloc(sizeof(*state), GFP_KERNEL); if (!state) return NULL;

- m_state = to_malidp_plane_state(plane->state); + m_state = to_malidp_plane_state(old_state); __drm_atomic_helper_plane_duplicate_state(plane, &state->base, - plane->state); + old_state); state->rotmem_size = m_state->rotmem_size; state->format = m_state->format; state->n_planes = m_state->n_planes; diff --git a/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_crtc.c b/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_crtc.c index bb7c5eb9526a..cabba730c79a 100644 --- a/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_crtc.c +++ b/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_crtc.c @@ -375,20 +375,21 @@ static void atmel_hlcdc_crtc_reset(struct drm_crtc *crtc) }

static struct drm_crtc_state * -atmel_hlcdc_crtc_duplicate_state(struct drm_crtc *crtc) +atmel_hlcdc_crtc_duplicate_state(struct drm_crtc *crtc, + struct drm_crtc_state *old_state) { struct atmel_hlcdc_crtc_state *state, *cur;

- if (WARN_ON(!crtc->state)) + if (WARN_ON(!old_state)) return NULL;

state = kmalloc(sizeof(*state), GFP_KERNEL); if (!state) return NULL; __drm_atomic_helper_crtc_duplicate_state(crtc, &state->base, - crtc->state); + old_state);

- cur = drm_crtc_state_to_atmel_hlcdc_crtc_state(crtc->state); + cur = drm_crtc_state_to_atmel_hlcdc_crtc_state(old_state); state->output_mode = cur->output_mode;

return &state->base; diff --git a/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_plane.c b/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_plane.c index b5bd9b005225..2ebf5c632a7a 100644 --- a/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_plane.c +++ b/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_plane.c @@ -1009,10 +1009,11 @@ static void atmel_hlcdc_plane_reset(struct drm_plane *p) }

static struct drm_plane_state * -atmel_hlcdc_plane_atomic_duplicate_state(struct drm_plane *p) +atmel_hlcdc_plane_atomic_duplicate_state(struct drm_plane *p, + struct drm_plane_state *old_state) { struct atmel_hlcdc_plane_state *state = - drm_plane_state_to_atmel_hlcdc_plane_state(p->state); + drm_plane_state_to_atmel_hlcdc_plane_state(old_state); struct atmel_hlcdc_plane_state *copy;

copy = kmemdup(state, sizeof(*state), GFP_KERNEL); diff --git a/drivers/gpu/drm/drm_atomic.c b/drivers/gpu/drm/drm_atomic.c index da7752230e4c..b1983e7b65d2 100644 --- a/drivers/gpu/drm/drm_atomic.c +++ b/drivers/gpu/drm/drm_atomic.c @@ -294,7 +294,7 @@ drm_atomic_get_crtc_state(struct drm_atomic_state *state, if (ret) return ERR_PTR(ret);

- crtc_state = crtc->funcs->atomic_duplicate_state(crtc); + crtc_state = crtc->funcs->atomic_duplicate_state(crtc, crtc->state); if (!crtc_state) return ERR_PTR(-ENOMEM);

@@ -709,7 +709,8 @@ drm_atomic_get_plane_state(struct drm_atomic_state *state, if (ret) return ERR_PTR(ret);

- plane_state = plane->funcs->atomic_duplicate_state(plane); + plane_state = plane->funcs->atomic_duplicate_state(plane, + plane->state); if (!plane_state) return ERR_PTR(-ENOMEM);

@@ -1072,7 +1073,7 @@ drm_atomic_get_private_obj_state(struct drm_atomic_state *state,

p = __drm_atomic_state_private_obj(state, index);

- obj_state = funcs->atomic_duplicate_state(obj); + obj_state = funcs->atomic_duplicate_state(obj, obj->state); if (!obj_state) return ERR_PTR(-ENOMEM);

@@ -1133,7 +1134,8 @@ drm_atomic_get_connector_state(struct drm_atomic_state *state, if (c->state) return c->state;

- connector_state = connector->funcs->atomic_duplicate_state(connector); + connector_state = connector->funcs->atomic_duplicate_state(connector, + connector->state); if (!connector_state) return ERR_PTR(-ENOMEM);

diff --git a/drivers/gpu/drm/drm_atomic_helper.c b/drivers/gpu/drm/drm_atomic_helper.c index 0745a08a6cc2..c60fb6289276 100644 --- a/drivers/gpu/drm/drm_atomic_helper.c +++ b/drivers/gpu/drm/drm_atomic_helper.c @@ -3406,17 +3406,18 @@ EXPORT_SYMBOL(__drm_atomic_helper_crtc_duplicate_state); * subclassed CRTC state structure. */ struct drm_crtc_state * -drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc) +drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc, + struct drm_crtc_state *old_state) { struct drm_crtc_state *state;

- if (WARN_ON(!crtc->state)) + if (WARN_ON(!old_state)) return NULL;

state = kmalloc(sizeof(*state), GFP_KERNEL); if (state) __drm_atomic_helper_crtc_duplicate_state(crtc, state, - crtc->state); + old_state);

return state; } @@ -3506,17 +3507,18 @@ EXPORT_SYMBOL(__drm_atomic_helper_plane_duplicate_state); * subclassed plane state structure. */ struct drm_plane_state * -drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane) +drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane, + struct drm_plane_state *old_state) { struct drm_plane_state *state;

- if (WARN_ON(!plane->state)) + if (WARN_ON(!old_state)) return NULL;

state = kmalloc(sizeof(*state), GFP_KERNEL); if (state) __drm_atomic_helper_plane_duplicate_state(plane, state, - plane->state); + old_state);

return state; } @@ -3627,18 +3629,19 @@ EXPORT_SYMBOL(__drm_atomic_helper_connector_duplicate_state); * subclassed connector state structure. */ struct drm_connector_state * -drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector) +drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector, + struct drm_connector_state *old_state) { struct drm_connector_state *state;

- if (WARN_ON(!connector->state)) + if (WARN_ON(!old_state)) return NULL;

state = kmalloc(sizeof(*state), GFP_KERNEL); if (state) __drm_atomic_helper_connector_duplicate_state(connector, state, - connector->state); + old_state);

return state; } diff --git a/drivers/gpu/drm/drm_crtc_helper.c b/drivers/gpu/drm/drm_crtc_helper.c index 4afdf7902eda..d0806c5cc472 100644 --- a/drivers/gpu/drm/drm_crtc_helper.c +++ b/drivers/gpu/drm/drm_crtc_helper.c @@ -1011,12 +1011,14 @@ int drm_helper_crtc_mode_set(struct drm_crtc *crtc, struct drm_display_mode *mod int ret;

if (crtc->funcs->atomic_duplicate_state) - crtc_state = crtc->funcs->atomic_duplicate_state(crtc); + crtc_state = crtc->funcs->atomic_duplicate_state(crtc, + crtc->state); else { if (!crtc->state) drm_atomic_helper_crtc_reset(crtc);

- crtc_state = drm_atomic_helper_crtc_duplicate_state(crtc); + crtc_state = drm_atomic_helper_crtc_duplicate_state(crtc, + crtc->state); }

if (!crtc_state) @@ -1074,12 +1076,14 @@ int drm_helper_crtc_mode_set_base(struct drm_crtc *crtc, int x, int y, struct drm_plane *plane = crtc->primary;

if (plane->funcs->atomic_duplicate_state) - plane_state = plane->funcs->atomic_duplicate_state(plane); + plane_state = plane->funcs->atomic_duplicate_state(plane, + plane->state); else { if (!plane->state) drm_atomic_helper_plane_reset(plane);

- plane_state = drm_atomic_helper_plane_duplicate_state(plane); + plane_state = drm_atomic_helper_plane_duplicate_state(plane, + plane->state); } if (!plane_state) return -ENOMEM; diff --git a/drivers/gpu/drm/drm_dp_mst_topology.c b/drivers/gpu/drm/drm_dp_mst_topology.c index 140c24258b7b..d679fcb9b912 100644 --- a/drivers/gpu/drm/drm_dp_mst_topology.c +++ b/drivers/gpu/drm/drm_dp_mst_topology.c @@ -2995,16 +2995,17 @@ static void drm_dp_destroy_connector_work(struct work_struct *work) }

static struct drm_private_state * -drm_dp_mst_duplicate_state(struct drm_private_obj *obj) +drm_dp_mst_duplicate_state(struct drm_private_obj *obj, + struct drm_private_state *old_state) { struct drm_dp_mst_topology_state *state;

- state = kmemdup(obj->state, sizeof(*state), GFP_KERNEL); + state = kmemdup(old_state, sizeof(*state), GFP_KERNEL); if (!state) return NULL;

__drm_atomic_helper_private_obj_duplicate_state(obj, &state->base, - obj->state); + old_state);

return &state->base; } diff --git a/drivers/gpu/drm/drm_plane_helper.c b/drivers/gpu/drm/drm_plane_helper.c index 06aee1741e96..cf3bbc4a3f6b 100644 --- a/drivers/gpu/drm/drm_plane_helper.c +++ b/drivers/gpu/drm/drm_plane_helper.c @@ -552,12 +552,14 @@ int drm_plane_helper_update(struct drm_plane *plane, struct drm_crtc *crtc, struct drm_plane_state *plane_state;

if (plane->funcs->atomic_duplicate_state) - plane_state = plane->funcs->atomic_duplicate_state(plane); + plane_state = plane->funcs->atomic_duplicate_state(plane, + plane->state); else { if (!plane->state) drm_atomic_helper_plane_reset(plane);

- plane_state = drm_atomic_helper_plane_duplicate_state(plane); + plane_state = drm_atomic_helper_plane_duplicate_state(plane, + plane->state); } if (!plane_state) return -ENOMEM; @@ -601,12 +603,14 @@ int drm_plane_helper_disable(struct drm_plane *plane) return 0;

if (plane->funcs->atomic_duplicate_state) - plane_state = plane->funcs->atomic_duplicate_state(plane); + plane_state = plane->funcs->atomic_duplicate_state(plane, + plane->state); else { if (!plane->state) drm_atomic_helper_plane_reset(plane);

- plane_state = drm_atomic_helper_plane_duplicate_state(plane); + plane_state = drm_atomic_helper_plane_duplicate_state(plane, + plane->state); } if (!plane_state) return -ENOMEM; diff --git a/drivers/gpu/drm/exynos/exynos_drm_plane.c b/drivers/gpu/drm/exynos/exynos_drm_plane.c index 1807f4c7bcf6..fc57e880f75c 100644 --- a/drivers/gpu/drm/exynos/exynos_drm_plane.c +++ b/drivers/gpu/drm/exynos/exynos_drm_plane.c @@ -146,18 +146,19 @@ static void exynos_drm_plane_reset(struct drm_plane *plane) }

static struct drm_plane_state * -exynos_drm_plane_duplicate_state(struct drm_plane *plane) +exynos_drm_plane_duplicate_state(struct drm_plane *plane, + struct drm_plane_state *old_state) { struct exynos_drm_plane_state *exynos_state; struct exynos_drm_plane_state *copy;

- exynos_state = to_exynos_plane_state(plane->state); + exynos_state = to_exynos_plane_state(old_state); copy = kzalloc(sizeof(*exynos_state), GFP_KERNEL); if (!copy) return NULL;

__drm_atomic_helper_plane_duplicate_state(plane, &copy->base, - plane->state); + old_state); return &copy->base; }

diff --git a/drivers/gpu/drm/i915/intel_atomic.c b/drivers/gpu/drm/i915/intel_atomic.c index e5d5a558c84a..978902d19c5f 100644 --- a/drivers/gpu/drm/i915/intel_atomic.c +++ b/drivers/gpu/drm/i915/intel_atomic.c @@ -138,16 +138,17 @@ int intel_digital_connector_atomic_check(struct drm_connector *conn, * Returns: The newly allocated connector state, or NULL on failure. */ struct drm_connector_state * -intel_digital_connector_duplicate_state(struct drm_connector *connector) +intel_digital_connector_duplicate_state(struct drm_connector *connector, + struct drm_connector_state *old_state) { struct intel_digital_connector_state *state;

- state = kmemdup(connector->state, sizeof(*state), GFP_KERNEL); + state = kmemdup(old_state, sizeof(*state), GFP_KERNEL); if (!state) return NULL;

__drm_atomic_helper_connector_duplicate_state(connector, &state->base, - connector->state); + old_state); return &state->base; }

@@ -161,16 +162,17 @@ intel_digital_connector_duplicate_state(struct drm_connector *connector) * Returns: The newly allocated crtc state, or NULL on failure. */ struct drm_crtc_state * -intel_crtc_duplicate_state(struct drm_crtc *crtc) +intel_crtc_duplicate_state(struct drm_crtc *crtc, + struct drm_crtc_state *old_state) { struct intel_crtc_state *crtc_state;

- crtc_state = kmemdup(crtc->state, sizeof(*crtc_state), GFP_KERNEL); + crtc_state = kmemdup(old_state, sizeof(*crtc_state), GFP_KERNEL); if (!crtc_state) return NULL;

__drm_atomic_helper_crtc_duplicate_state(crtc, &crtc_state->base, - crtc->state); + old_state);

crtc_state->update_pipe = false; crtc_state->disable_lp_wm = false; diff --git a/drivers/gpu/drm/i915/intel_atomic_plane.c b/drivers/gpu/drm/i915/intel_atomic_plane.c index 41a7354c14d3..4716e8dadba8 100644 --- a/drivers/gpu/drm/i915/intel_atomic_plane.c +++ b/drivers/gpu/drm/i915/intel_atomic_plane.c @@ -71,19 +71,20 @@ intel_create_plane_state(struct drm_plane *plane) * Returns: The newly allocated plane state, or NULL on failure. */ struct drm_plane_state * -intel_plane_duplicate_state(struct drm_plane *plane) +intel_plane_duplicate_state(struct drm_plane *plane, + struct drm_plane_state *old_state) { struct drm_plane_state *state; struct intel_plane_state *intel_state;

- intel_state = kmemdup(plane->state, sizeof(*intel_state), GFP_KERNEL); + intel_state = kmemdup(old_state, sizeof(*intel_state), GFP_KERNEL);

if (!intel_state) return NULL;

state = &intel_state->base;

- __drm_atomic_helper_plane_duplicate_state(plane, state, plane->state); + __drm_atomic_helper_plane_duplicate_state(plane, state, old_state);

intel_state->vma = NULL;

diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c index 791204c8621c..1016afebef27 100644 --- a/drivers/gpu/drm/i915/intel_display.c +++ b/drivers/gpu/drm/i915/intel_display.c @@ -13646,7 +13646,7 @@ intel_legacy_cursor_update(struct drm_plane *plane, !old_plane_state->fb != !fb) goto slow;

- new_plane_state = intel_plane_duplicate_state(plane); + new_plane_state = intel_plane_duplicate_state(plane, plane->state); if (!new_plane_state) return -ENOMEM;

diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h index ea36d1a61e86..4be10983e7cc 100644 --- a/drivers/gpu/drm/i915/intel_drv.h +++ b/drivers/gpu/drm/i915/intel_drv.h @@ -1945,9 +1945,11 @@ int intel_digital_connector_atomic_set_property(struct drm_connector *connector, int intel_digital_connector_atomic_check(struct drm_connector *conn, struct drm_connector_state *new_state); struct drm_connector_state * -intel_digital_connector_duplicate_state(struct drm_connector *connector); +intel_digital_connector_duplicate_state(struct drm_connector *connector, + struct drm_connector_state *old_state);

-struct drm_crtc_state *intel_crtc_duplicate_state(struct drm_crtc *crtc); +struct drm_crtc_state *intel_crtc_duplicate_state(struct drm_crtc *crtc, + struct drm_crtc_state *old_state); void intel_crtc_destroy_state(struct drm_crtc *crtc, struct drm_crtc_state *state); struct drm_atomic_state *intel_atomic_state_alloc(struct drm_device *dev); @@ -1996,7 +1998,8 @@ int intel_atomic_setup_scalers(struct drm_i915_private *dev_priv,

/* intel_atomic_plane.c */ struct intel_plane_state *intel_create_plane_state(struct drm_plane *plane); -struct drm_plane_state *intel_plane_duplicate_state(struct drm_plane *plane); +struct drm_plane_state *intel_plane_duplicate_state(struct drm_plane *plane, + struct drm_plane_state *old_state); void intel_plane_destroy_state(struct drm_plane *plane, struct drm_plane_state *state); extern const struct drm_plane_helper_funcs intel_plane_helper_funcs; diff --git a/drivers/gpu/drm/i915/intel_sdvo.c b/drivers/gpu/drm/i915/intel_sdvo.c index 0d14807b38a5..9ed722b1c6fd 100644 --- a/drivers/gpu/drm/i915/intel_sdvo.c +++ b/drivers/gpu/drm/i915/intel_sdvo.c @@ -2179,17 +2179,18 @@ intel_sdvo_connector_unregister(struct drm_connector *connector) }

static struct drm_connector_state * -intel_sdvo_connector_duplicate_state(struct drm_connector *connector) +intel_sdvo_connector_duplicate_state(struct drm_connector *connector, + struct drm_connector_state *old_state) { struct intel_sdvo_connector_state *state;

- state = kmemdup(connector->state, sizeof(*state), GFP_KERNEL); + state = kmemdup(old_state, sizeof(*state), GFP_KERNEL); if (!state) return NULL;

__drm_atomic_helper_connector_duplicate_state(connector, &state->base.base, - connector->state); + old_state); return &state->base.base; }

diff --git a/drivers/gpu/drm/imx/ipuv3-crtc.c b/drivers/gpu/drm/imx/ipuv3-crtc.c index 44598b6a5cfc..666c02f27a3c 100644 --- a/drivers/gpu/drm/imx/ipuv3-crtc.c +++ b/drivers/gpu/drm/imx/ipuv3-crtc.c @@ -129,7 +129,8 @@ static void imx_drm_crtc_reset(struct drm_crtc *crtc) state->base.crtc = crtc; }

-static struct drm_crtc_state *imx_drm_crtc_duplicate_state(struct drm_crtc *crtc) +static struct drm_crtc_state *imx_drm_crtc_duplicate_state(struct drm_crtc *crtc, + struct drm_crtc_state *old_state) { struct imx_crtc_state *state;

@@ -138,7 +139,7 @@ static struct drm_crtc_state *imx_drm_crtc_duplicate_state(struct drm_crtc *crtc return NULL;

__drm_atomic_helper_crtc_duplicate_state(crtc, &state->base, - crtc->state); + old_state);

WARN_ON(state->base.crtc != crtc); state->base.crtc = crtc; diff --git a/drivers/gpu/drm/imx/ipuv3-plane.c b/drivers/gpu/drm/imx/ipuv3-plane.c index 3b3c979c4f6d..474fff30ae79 100644 --- a/drivers/gpu/drm/imx/ipuv3-plane.c +++ b/drivers/gpu/drm/imx/ipuv3-plane.c @@ -279,17 +279,18 @@ void ipu_plane_state_reset(struct drm_plane *plane) plane->state = &ipu_state->base; }

-struct drm_plane_state *ipu_plane_duplicate_state(struct drm_plane *plane) +struct drm_plane_state *ipu_plane_duplicate_state(struct drm_plane *plane, + struct drm_plane_state *old_state) { struct ipu_plane_state *state;

- if (WARN_ON(!plane->state)) + if (WARN_ON(!old_state)) return NULL;

state = kmalloc(sizeof(*state), GFP_KERNEL); if (state) __drm_atomic_helper_plane_duplicate_state(plane, &state->base, - plane->state); + old_state);

return &state->base; } diff --git a/drivers/gpu/drm/mediatek/mtk_drm_crtc.c b/drivers/gpu/drm/mediatek/mtk_drm_crtc.c index 4bdc612fbe89..c11d0f26a4b5 100644 --- a/drivers/gpu/drm/mediatek/mtk_drm_crtc.c +++ b/drivers/gpu/drm/mediatek/mtk_drm_crtc.c @@ -126,7 +126,8 @@ static void mtk_drm_crtc_reset(struct drm_crtc *crtc) state->base.crtc = crtc; }

-static struct drm_crtc_state *mtk_drm_crtc_duplicate_state(struct drm_crtc *crtc) +static struct drm_crtc_state *mtk_drm_crtc_duplicate_state(struct drm_crtc *crtc, + struct drm_crtc_state *old_state) { struct mtk_crtc_state *state;

@@ -135,7 +136,7 @@ static struct drm_crtc_state *mtk_drm_crtc_duplicate_state(struct drm_crtc *crtc return NULL;

__drm_atomic_helper_crtc_duplicate_state(crtc, &state->base, - crtc->state); + old_state);

WARN_ON(state->base.crtc != crtc); state->base.crtc = crtc; diff --git a/drivers/gpu/drm/mediatek/mtk_drm_plane.c b/drivers/gpu/drm/mediatek/mtk_drm_plane.c index 67c7bd17e350..a0ccad4c577e 100644 --- a/drivers/gpu/drm/mediatek/mtk_drm_plane.c +++ b/drivers/gpu/drm/mediatek/mtk_drm_plane.c @@ -50,9 +50,10 @@ static void mtk_plane_reset(struct drm_plane *plane) state->pending.format = DRM_FORMAT_RGB565; }

-static struct drm_plane_state *mtk_plane_duplicate_state(struct drm_plane *plane) +static struct drm_plane_state *mtk_plane_duplicate_state(struct drm_plane *plane, + struct drm_plane_state *old_state) { - struct mtk_plane_state *old_mtk_state = to_mtk_plane_state(plane->state); + struct mtk_plane_state *old_mtk_state = to_mtk_plane_state(old_state); struct mtk_plane_state *state;

state = kzalloc(sizeof(*state), GFP_KERNEL); @@ -60,7 +61,7 @@ static struct drm_plane_state *mtk_plane_duplicate_state(struct drm_plane *plane return NULL;

__drm_atomic_helper_plane_duplicate_state(plane, &state->base, - plane->state); + old_state);

WARN_ON(state->base.plane != plane);

diff --git a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_crtc.c b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_crtc.c index 49c7410d0ef6..2f0d08dc15b1 100644 --- a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_crtc.c +++ b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_crtc.c @@ -889,20 +889,21 @@ static void mdp5_crtc_reset(struct drm_crtc *crtc) }

static struct drm_crtc_state * -mdp5_crtc_duplicate_state(struct drm_crtc *crtc) +mdp5_crtc_duplicate_state(struct drm_crtc *crtc, + struct drm_crtc_state *old_state) { struct mdp5_crtc_state *mdp5_cstate;

- if (WARN_ON(!crtc->state)) + if (WARN_ON(!old_state)) return NULL;

- mdp5_cstate = kmemdup(to_mdp5_crtc_state(crtc->state), + mdp5_cstate = kmemdup(to_mdp5_crtc_state(old_state), sizeof(*mdp5_cstate), GFP_KERNEL); if (!mdp5_cstate) return NULL;

__drm_atomic_helper_crtc_duplicate_state(crtc, &mdp5_cstate->base, - crtc->state); + old_state);

return &mdp5_cstate->base; } diff --git a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c index de00c9ad14fd..7400632877ff 100644 --- a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c +++ b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c @@ -214,20 +214,21 @@ static void mdp5_plane_reset(struct drm_plane *plane) }

static struct drm_plane_state * -mdp5_plane_duplicate_state(struct drm_plane *plane) +mdp5_plane_duplicate_state(struct drm_plane *plane, + struct drm_plane_state *old_state) { struct mdp5_plane_state *mdp5_state;

- if (WARN_ON(!plane->state)) + if (WARN_ON(!old_state)) return NULL;

- mdp5_state = kmemdup(to_mdp5_plane_state(plane->state), - sizeof(*mdp5_state), GFP_KERNEL); + mdp5_state = kmemdup(to_mdp5_plane_state(old_state), + sizeof(*mdp5_state), GFP_KERNEL); if (!mdp5_state) return NULL;

__drm_atomic_helper_plane_duplicate_state(plane, &mdp5_state->base, - plane->state); + old_state);

return &mdp5_state->base; } @@ -1032,7 +1033,7 @@ static int mdp5_update_cursor_plane_legacy(struct drm_plane *plane, plane_state->fb != fb) goto slow;

- new_plane_state = mdp5_plane_duplicate_state(plane); + new_plane_state = mdp5_plane_duplicate_state(plane, plane->state); if (!new_plane_state) return -ENOMEM;

diff --git a/drivers/gpu/drm/nouveau/nouveau_connector.c b/drivers/gpu/drm/nouveau/nouveau_connector.c index dc1880eb00bf..4418220e3d6c 100644 --- a/drivers/gpu/drm/nouveau/nouveau_connector.c +++ b/drivers/gpu/drm/nouveau/nouveau_connector.c @@ -228,14 +228,15 @@ nouveau_conn_atomic_destroy_state(struct drm_connector *connector, }

struct drm_connector_state * -nouveau_conn_atomic_duplicate_state(struct drm_connector *connector) +nouveau_conn_atomic_duplicate_state(struct drm_connector *connector, + struct drm_connector_state *old_state) { - struct nouveau_conn_atom *armc = nouveau_conn_atom(connector->state); + struct nouveau_conn_atom *armc = nouveau_conn_atom(old_state); struct nouveau_conn_atom *asyc; if (!(asyc = kmalloc(sizeof(*asyc), GFP_KERNEL))) return NULL; __drm_atomic_helper_connector_duplicate_state(connector, &asyc->state, - connector->state); + old_state); asyc->dither = armc->dither; asyc->scaler = armc->scaler; asyc->procamp = armc->procamp; diff --git a/drivers/gpu/drm/nouveau/nouveau_connector.h b/drivers/gpu/drm/nouveau/nouveau_connector.h index a4d1a059bd3d..2e4b20f5ffb7 100644 --- a/drivers/gpu/drm/nouveau/nouveau_connector.h +++ b/drivers/gpu/drm/nouveau/nouveau_connector.h @@ -141,7 +141,8 @@ struct nouveau_conn_atom { void nouveau_conn_attach_properties(struct drm_connector *); void nouveau_conn_reset(struct drm_connector *); struct drm_connector_state * -nouveau_conn_atomic_duplicate_state(struct drm_connector *); +nouveau_conn_atomic_duplicate_state(struct drm_connector *, + struct drm_connector_state *); void nouveau_conn_atomic_destroy_state(struct drm_connector *, struct drm_connector_state *); int nouveau_conn_atomic_set_property(struct drm_connector *, diff --git a/drivers/gpu/drm/nouveau/nv50_display.c b/drivers/gpu/drm/nouveau/nv50_display.c index 6ca8d97e7dbc..a2401c3894a1 100644 --- a/drivers/gpu/drm/nouveau/nv50_display.c +++ b/drivers/gpu/drm/nouveau/nv50_display.c @@ -1005,14 +1005,15 @@ nv50_wndw_atomic_destroy_state(struct drm_plane *plane, }

static struct drm_plane_state * -nv50_wndw_atomic_duplicate_state(struct drm_plane *plane) +nv50_wndw_atomic_duplicate_state(struct drm_plane *plane, + struct drm_plane_state *old_state) { - struct nv50_wndw_atom *armw = nv50_wndw_atom(plane->state); + struct nv50_wndw_atom *armw = nv50_wndw_atom(old_state); struct nv50_wndw_atom *asyw; if (!(asyw = kmalloc(sizeof(*asyw), GFP_KERNEL))) return NULL; __drm_atomic_helper_plane_duplicate_state(plane, &asyw->state, - plane->state); + old_state); asyw->interval = 1; asyw->sema = armw->sema; asyw->ntfy = armw->ntfy; @@ -2258,14 +2259,15 @@ nv50_head_atomic_destroy_state(struct drm_crtc *crtc, }

static struct drm_crtc_state * -nv50_head_atomic_duplicate_state(struct drm_crtc *crtc) +nv50_head_atomic_duplicate_state(struct drm_crtc *crtc, + struct drm_crtc_state *old_state) { - struct nv50_head_atom *armh = nv50_head_atom(crtc->state); + struct nv50_head_atom *armh = nv50_head_atom(old_state); struct nv50_head_atom *asyh; if (!(asyh = kmalloc(sizeof(*asyh), GFP_KERNEL))) return NULL; __drm_atomic_helper_crtc_duplicate_state(crtc, &asyh->state, - crtc->state); + old_state); asyh->view = armh->view; asyh->mode = armh->mode; asyh->lut = armh->lut; diff --git a/drivers/gpu/drm/rcar-du/rcar_du_plane.c b/drivers/gpu/drm/rcar-du/rcar_du_plane.c index a856507f5717..a46a5eee89ef 100644 --- a/drivers/gpu/drm/rcar-du/rcar_du_plane.c +++ b/drivers/gpu/drm/rcar-du/rcar_du_plane.c @@ -610,21 +610,22 @@ static const struct drm_plane_helper_funcs rcar_du_plane_helper_funcs = { };

static struct drm_plane_state * -rcar_du_plane_atomic_duplicate_state(struct drm_plane *plane) +rcar_du_plane_atomic_duplicate_state(struct drm_plane *plane, + struct drm_plane_state *old_state) { struct rcar_du_plane_state *state; struct rcar_du_plane_state *copy;

- if (WARN_ON(!plane->state)) + if (WARN_ON(!old_state)) return NULL;

- state = to_rcar_plane_state(plane->state); + state = to_rcar_plane_state(old_state); copy = kmemdup(state, sizeof(*state), GFP_KERNEL); if (copy == NULL) return NULL;

__drm_atomic_helper_plane_duplicate_state(plane, &copy->state, - plane->state); + old_state);

return &copy->state; } diff --git a/drivers/gpu/drm/rcar-du/rcar_du_vsp.c b/drivers/gpu/drm/rcar-du/rcar_du_vsp.c index 21a30775edb7..5f1547f4215e 100644 --- a/drivers/gpu/drm/rcar-du/rcar_du_vsp.c +++ b/drivers/gpu/drm/rcar-du/rcar_du_vsp.c @@ -303,21 +303,22 @@ static const struct drm_plane_helper_funcs rcar_du_vsp_plane_helper_funcs = { };

static struct drm_plane_state * -rcar_du_vsp_plane_atomic_duplicate_state(struct drm_plane *plane) +rcar_du_vsp_plane_atomic_duplicate_state(struct drm_plane *plane, + struct drm_plane_state *old_state) { struct rcar_du_vsp_plane_state *state; struct rcar_du_vsp_plane_state *copy;

- if (WARN_ON(!plane->state)) + if (WARN_ON(!old_state)) return NULL;

- state = to_rcar_vsp_plane_state(plane->state); + state = to_rcar_vsp_plane_state(old_state); copy = kmemdup(state, sizeof(*state), GFP_KERNEL); if (copy == NULL) return NULL;

__drm_atomic_helper_plane_duplicate_state(plane, &copy->state, - plane->state); + old_state);

return &copy->state; } diff --git a/drivers/gpu/drm/rockchip/rockchip_drm_vop.c b/drivers/gpu/drm/rockchip/rockchip_drm_vop.c index 9f586f698e52..a8af4d752b68 100644 --- a/drivers/gpu/drm/rockchip/rockchip_drm_vop.c +++ b/drivers/gpu/drm/rockchip/rockchip_drm_vop.c @@ -1104,7 +1104,8 @@ static void vop_crtc_reset(struct drm_crtc *crtc) crtc->state->crtc = crtc; }

-static struct drm_crtc_state *vop_crtc_duplicate_state(struct drm_crtc *crtc) +static struct drm_crtc_state *vop_crtc_duplicate_state(struct drm_crtc *crtc, + struct drm_crtc_state *old_state) { struct rockchip_crtc_state *rockchip_state;

@@ -1113,7 +1114,7 @@ static struct drm_crtc_state *vop_crtc_duplicate_state(struct drm_crtc *crtc) return NULL;

__drm_atomic_helper_crtc_duplicate_state(crtc, &rockchip_state->base, - crtc->state); + old_state); return &rockchip_state->base; }

diff --git a/drivers/gpu/drm/tegra/dc.c b/drivers/gpu/drm/tegra/dc.c index d725115d011d..5e3d02ae9653 100644 --- a/drivers/gpu/drm/tegra/dc.c +++ b/drivers/gpu/drm/tegra/dc.c @@ -448,9 +448,10 @@ static void tegra_plane_reset(struct drm_plane *plane) } }

-static struct drm_plane_state *tegra_plane_atomic_duplicate_state(struct drm_plane *plane) +static struct drm_plane_state *tegra_plane_atomic_duplicate_state(struct drm_plane *plane, + struct drm_plane_state *old_state) { - struct tegra_plane_state *state = to_tegra_plane_state(plane->state); + struct tegra_plane_state *state = to_tegra_plane_state(old_state); struct tegra_plane_state *copy;

copy = kmalloc(sizeof(*copy), GFP_KERNEL); @@ -458,7 +459,7 @@ static struct drm_plane_state *tegra_plane_atomic_duplicate_state(struct drm_pla return NULL;

__drm_atomic_helper_plane_duplicate_state(plane, &copy->base, - plane->state); + old_state); copy->tiling = state->tiling; copy->format = state->format; copy->swap = state->swap; @@ -1034,9 +1035,10 @@ static void tegra_crtc_reset(struct drm_crtc *crtc) }

static struct drm_crtc_state * -tegra_crtc_atomic_duplicate_state(struct drm_crtc *crtc) +tegra_crtc_atomic_duplicate_state(struct drm_crtc *crtc, + struct drm_crtc_state *old_state) { - struct tegra_dc_state *state = to_dc_state(crtc->state); + struct tegra_dc_state *state = to_dc_state(old_state); struct tegra_dc_state *copy;

copy = kmalloc(sizeof(*copy), GFP_KERNEL); @@ -1044,7 +1046,7 @@ tegra_crtc_atomic_duplicate_state(struct drm_crtc *crtc) return NULL;

__drm_atomic_helper_crtc_duplicate_state(crtc, &copy->base, - crtc->state); + old_state); copy->clk = state->clk; copy->pclk = state->pclk; copy->div = state->div; diff --git a/drivers/gpu/drm/tegra/dsi.c b/drivers/gpu/drm/tegra/dsi.c index ce646493e939..9156434e0627 100644 --- a/drivers/gpu/drm/tegra/dsi.c +++ b/drivers/gpu/drm/tegra/dsi.c @@ -799,9 +799,10 @@ static void tegra_dsi_connector_reset(struct drm_connector *connector) }

static struct drm_connector_state * -tegra_dsi_connector_duplicate_state(struct drm_connector *connector) +tegra_dsi_connector_duplicate_state(struct drm_connector *connector, + struct drm_connector_state *old_state) { - struct tegra_dsi_state *state = to_dsi_state(connector->state); + struct tegra_dsi_state *state = to_dsi_state(old_state); struct tegra_dsi_state *copy;

copy = kmemdup(state, sizeof(*state), GFP_KERNEL); @@ -810,7 +811,7 @@ tegra_dsi_connector_duplicate_state(struct drm_connector *connector)

__drm_atomic_helper_connector_duplicate_state(connector, &copy->base, - connector->state); + old_state);

return &copy->base; } diff --git a/drivers/gpu/drm/tegra/sor.c b/drivers/gpu/drm/tegra/sor.c index 02c3439c2e96..4e79ae0561cd 100644 --- a/drivers/gpu/drm/tegra/sor.c +++ b/drivers/gpu/drm/tegra/sor.c @@ -1325,9 +1325,10 @@ tegra_sor_connector_detect(struct drm_connector *connector, bool force) }

static struct drm_connector_state * -tegra_sor_connector_duplicate_state(struct drm_connector *connector) +tegra_sor_connector_duplicate_state(struct drm_connector *connector, + struct drm_connector_state *old_state) { - struct tegra_sor_state *state = to_sor_state(connector->state); + struct tegra_sor_state *state = to_sor_state(old_state); struct tegra_sor_state *copy;

copy = kmemdup(state, sizeof(*state), GFP_KERNEL); @@ -1335,7 +1336,7 @@ tegra_sor_connector_duplicate_state(struct drm_connector *connector) return NULL;

__drm_atomic_helper_connector_duplicate_state(connector, &copy->base, - connector->state); + old_state);

return &copy->base; } diff --git a/drivers/gpu/drm/vc4/vc4_crtc.c b/drivers/gpu/drm/vc4/vc4_crtc.c index 28bdfb5adb9e..1d7e46af7450 100644 --- a/drivers/gpu/drm/vc4/vc4_crtc.c +++ b/drivers/gpu/drm/vc4/vc4_crtc.c @@ -813,7 +813,8 @@ static int vc4_page_flip(struct drm_crtc *crtc, return drm_atomic_helper_page_flip(crtc, fb, event, flags, ctx); }

-static struct drm_crtc_state *vc4_crtc_duplicate_state(struct drm_crtc *crtc) +static struct drm_crtc_state *vc4_crtc_duplicate_state(struct drm_crtc *crtc, + struct drm_crtc_state *old_state) { struct vc4_crtc_state *vc4_state;

@@ -822,7 +823,7 @@ static struct drm_crtc_state *vc4_crtc_duplicate_state(struct drm_crtc *crtc) return NULL;

__drm_atomic_helper_crtc_duplicate_state(crtc, &vc4_state->base, - crtc->state); + old_state); return &vc4_state->base; }

diff --git a/drivers/gpu/drm/vc4/vc4_plane.c b/drivers/gpu/drm/vc4/vc4_plane.c index 43b388a42c1e..0c57309d6c2f 100644 --- a/drivers/gpu/drm/vc4/vc4_plane.c +++ b/drivers/gpu/drm/vc4/vc4_plane.c @@ -174,21 +174,22 @@ static bool plane_enabled(struct drm_plane_state *state) return state->fb && state->crtc; }

-static struct drm_plane_state *vc4_plane_duplicate_state(struct drm_plane *plane) +static struct drm_plane_state *vc4_plane_duplicate_state(struct drm_plane *plane, + struct drm_plane_state *old_state) { struct vc4_plane_state *vc4_state;

- if (WARN_ON(!plane->state)) + if (WARN_ON(!old_state)) return NULL;

- vc4_state = kmemdup(plane->state, sizeof(*vc4_state), GFP_KERNEL); + vc4_state = kmemdup(old_state, sizeof(*vc4_state), GFP_KERNEL); if (!vc4_state) return NULL;

memset(&vc4_state->lbm, 0, sizeof(vc4_state->lbm));

__drm_atomic_helper_plane_duplicate_state(plane, &vc4_state->base, - plane->state); + old_state);

if (vc4_state->dlist) { vc4_state->dlist = kmemdup(vc4_state->dlist, diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c b/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c index dc3b4a9e3d25..946f11c93619 100644 --- a/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c +++ b/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c @@ -597,22 +597,23 @@ void vmw_du_crtc_atomic_flush(struct drm_crtc *crtc, * Returns: The newly allocated crtc state, or NULL on failure. */ struct drm_crtc_state * -vmw_du_crtc_duplicate_state(struct drm_crtc *crtc) +vmw_du_crtc_duplicate_state(struct drm_crtc *crtc, + struct drm_crtc_state *old_state) { struct drm_crtc_state *state; struct vmw_crtc_state *vcs;

- if (WARN_ON(!crtc->state)) + if (WARN_ON(!old_state)) return NULL;

- vcs = kmemdup(crtc->state, sizeof(*vcs), GFP_KERNEL); + vcs = kmemdup(old_state, sizeof(*vcs), GFP_KERNEL);

if (!vcs) return NULL;

state = &vcs->base;

- __drm_atomic_helper_crtc_duplicate_state(crtc, state, crtc->state); + __drm_atomic_helper_crtc_duplicate_state(crtc, state, old_state);

return state; } @@ -675,12 +676,13 @@ vmw_du_crtc_destroy_state(struct drm_crtc *crtc, * Returns: The newly allocated plane state, or NULL on failure. */ struct drm_plane_state * -vmw_du_plane_duplicate_state(struct drm_plane *plane) +vmw_du_plane_duplicate_state(struct drm_plane *plane, + struct drm_plane_state *old_state) { struct drm_plane_state *state; struct vmw_plane_state *vps;

- vps = kmemdup(plane->state, sizeof(*vps), GFP_KERNEL); + vps = kmemdup(old_state, sizeof(*vps), GFP_KERNEL);

if (!vps) return NULL; @@ -701,7 +703,7 @@ vmw_du_plane_duplicate_state(struct drm_plane *plane)

state = &vps->base;

- __drm_atomic_helper_plane_duplicate_state(plane, state, plane->state); + __drm_atomic_helper_plane_duplicate_state(plane, state, old_state);

return state; } @@ -781,15 +783,16 @@ vmw_du_plane_destroy_state(struct drm_plane *plane, * Returns: The newly allocated connector state, or NULL on failure. */ struct drm_connector_state * -vmw_du_connector_duplicate_state(struct drm_connector *connector) +vmw_du_connector_duplicate_state(struct drm_connector *connector, + struct drm_connector_state *old_state) { struct drm_connector_state *state; struct vmw_connector_state *vcs;

- if (WARN_ON(!connector->state)) + if (WARN_ON(!old_state)) return NULL;

- vcs = kmemdup(connector->state, sizeof(*vcs), GFP_KERNEL); + vcs = kmemdup(old_state, sizeof(*vcs), GFP_KERNEL);

if (!vcs) return NULL; @@ -797,7 +800,7 @@ vmw_du_connector_duplicate_state(struct drm_connector *connector) state = &vcs->base;

__drm_atomic_helper_connector_duplicate_state(connector, state, - connector->state); + old_state);

return state; } diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_kms.h b/drivers/gpu/drm/vmwgfx/vmwgfx_kms.h index ff9c8389ff21..4769c8a412c2 100644 --- a/drivers/gpu/drm/vmwgfx/vmwgfx_kms.h +++ b/drivers/gpu/drm/vmwgfx/vmwgfx_kms.h @@ -348,7 +348,8 @@ int vmw_du_cursor_plane_prepare_fb(struct drm_plane *plane, void vmw_du_plane_cleanup_fb(struct drm_plane *plane, struct drm_plane_state *old_state); void vmw_du_plane_reset(struct drm_plane *plane); -struct drm_plane_state *vmw_du_plane_duplicate_state(struct drm_plane *plane); +struct drm_plane_state *vmw_du_plane_duplicate_state(struct drm_plane *plane, + struct drm_plane_state *old_state); void vmw_du_plane_destroy_state(struct drm_plane *plane, struct drm_plane_state *state); void vmw_du_plane_unpin_surf(struct vmw_plane_state *vps, @@ -361,12 +362,14 @@ void vmw_du_crtc_atomic_begin(struct drm_crtc *crtc, void vmw_du_crtc_atomic_flush(struct drm_crtc *crtc, struct drm_crtc_state *old_crtc_state); void vmw_du_crtc_reset(struct drm_crtc *crtc); -struct drm_crtc_state *vmw_du_crtc_duplicate_state(struct drm_crtc *crtc); +struct drm_crtc_state *vmw_du_crtc_duplicate_state(struct drm_crtc *crtc, + struct drm_crtc_state *old_state); void vmw_du_crtc_destroy_state(struct drm_crtc *crtc, struct drm_crtc_state *state); void vmw_du_connector_reset(struct drm_connector *connector); struct drm_connector_state * -vmw_du_connector_duplicate_state(struct drm_connector *connector); +vmw_du_connector_duplicate_state(struct drm_connector *connector, + struct drm_connector_state *old_state);

void vmw_du_connector_destroy_state(struct drm_connector *connector, struct drm_connector_state *state); diff --git a/include/drm/drm_atomic.h b/include/drm/drm_atomic.h index addec49a14bf..0e6c54b3e0af 100644 --- a/include/drm/drm_atomic.h +++ b/include/drm/drm_atomic.h @@ -180,7 +180,8 @@ struct drm_private_state_funcs { * Duplicated atomic state or NULL when obj->state is not * initialized or allocation failed. */ - struct drm_private_state *(*atomic_duplicate_state)(struct drm_private_obj *obj); + struct drm_private_state *(*atomic_duplicate_state)(struct drm_private_obj *obj, + struct drm_private_state *old_state);

/** * @atomic_destroy_state: diff --git a/include/drm/drm_atomic_helper.h b/include/drm/drm_atomic_helper.h index 0adacaca0941..b799687a4b09 100644 --- a/include/drm/drm_atomic_helper.h +++ b/include/drm/drm_atomic_helper.h @@ -155,7 +155,8 @@ void __drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc, struct drm_crtc_state *state, const struct drm_crtc_state *old_state); struct drm_crtc_state * -drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc); +drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc, + struct drm_crtc_state *old_state); 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); @@ -165,7 +166,8 @@ void __drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane, struct drm_plane_state *state, const struct drm_plane_state *old_state); struct drm_plane_state * -drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane); +drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane, + struct drm_plane_state *old_state); 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); @@ -178,7 +180,8 @@ __drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector, struct drm_connector_state *state, const struct drm_connector_state *old_state); struct drm_connector_state * -drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector); +drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector, + struct drm_connector_state *old_state); struct drm_atomic_state * drm_atomic_helper_duplicate_state(struct drm_device *dev, struct drm_modeset_acquire_ctx *ctx); diff --git a/include/drm/drm_connector.h b/include/drm/drm_connector.h index ae5b7dc316c8..ee9a15a87db5 100644 --- a/include/drm/drm_connector.h +++ b/include/drm/drm_connector.h @@ -540,7 +540,8 @@ struct drm_connector_funcs { * * Duplicated atomic state or NULL when the allocation failed. */ - struct drm_connector_state *(*atomic_duplicate_state)(struct drm_connector *connector); + struct drm_connector_state *(*atomic_duplicate_state)(struct drm_connector *connector, + struct drm_connector_state *old_state);

/** * @atomic_destroy_state: diff --git a/include/drm/drm_crtc.h b/include/drm/drm_crtc.h index 3a911a64c257..1d187331fe5d 100644 --- a/include/drm/drm_crtc.h +++ b/include/drm/drm_crtc.h @@ -523,7 +523,8 @@ struct drm_crtc_funcs { * * Duplicated atomic state or NULL when the allocation failed. */ - struct drm_crtc_state *(*atomic_duplicate_state)(struct drm_crtc *crtc); + struct drm_crtc_state *(*atomic_duplicate_state)(struct drm_crtc *crtc, + struct drm_crtc_state *old_state);

/** * @atomic_destroy_state: diff --git a/include/drm/drm_plane.h b/include/drm/drm_plane.h index 9ab3e7044812..f01023ed1c7b 100644 --- a/include/drm/drm_plane.h +++ b/include/drm/drm_plane.h @@ -275,7 +275,8 @@ struct drm_plane_funcs { * * Duplicated atomic state or NULL when the allocation failed. */ - struct drm_plane_state *(*atomic_duplicate_state)(struct drm_plane *plane); + struct drm_plane_state *(*atomic_duplicate_state)(struct drm_plane *plane, + struct drm_plane_state *old_state);

/** * @atomic_destroy_state:

From: Ville Syrjälä ville.syrjala@linux.intel.com

Make drm_connector_get() return the connector. This allows the nice pattern of 'foo->connector = drm_connector_get(connector)'

Signed-off-by: Ville Syrjälä ville.syrjala@linux.intel.com --- drivers/gpu/drm/drm_atomic.c | 3 +-- drivers/gpu/drm/drm_fb_helper.c | 7 +++---- include/drm/drm_connector.h | 7 ++++++- 3 files changed, 10 insertions(+), 7 deletions(-)

diff --git a/drivers/gpu/drm/drm_atomic.c b/drivers/gpu/drm/drm_atomic.c index b1983e7b65d2..56925b93f598 100644 --- a/drivers/gpu/drm/drm_atomic.c +++ b/drivers/gpu/drm/drm_atomic.c @@ -1139,11 +1139,10 @@ drm_atomic_get_connector_state(struct drm_atomic_state *state, if (!connector_state) return ERR_PTR(-ENOMEM);

- drm_connector_get(connector); c->state = connector_state; c->old_state = connector->state; c->new_state = connector_state; - c->ptr = connector; + c->ptr = drm_connector_get(connector); connector_state->state = state;

state->num_connector = state->connectors.num_elems; diff --git a/drivers/gpu/drm/drm_fb_helper.c b/drivers/gpu/drm/drm_fb_helper.c index 721511da4de6..f520c235a6fb 100644 --- a/drivers/gpu/drm/drm_fb_helper.c +++ b/drivers/gpu/drm/drm_fb_helper.c @@ -138,8 +138,7 @@ static int __drm_fb_helper_add_one_connector(struct drm_fb_helper *fb_helper, if (!fb_conn) return -ENOMEM;

- drm_connector_get(connector); - fb_conn->connector = connector; + fb_conn->connector = drm_connector_get(connector); fb_helper->connector_info[fb_helper->connector_count++] = fb_conn;

return 0; @@ -2338,8 +2337,8 @@ static void drm_setup_crtcs(struct drm_fb_helper *fb_helper, fb_crtc->y = offset->y; modeset->mode = drm_mode_duplicate(dev, fb_crtc->desired_mode); - drm_connector_get(connector); - modeset->connectors[modeset->num_connectors++] = connector; + modeset->connectors[modeset->num_connectors++] = + drm_connector_get(connector); modeset->fb = fb_helper->fb; modeset->x = offset->x; modeset->y = offset->y; diff --git a/include/drm/drm_connector.h b/include/drm/drm_connector.h index a0d862d23082..8f26166f78b4 100644 --- a/include/drm/drm_connector.h +++ b/include/drm/drm_connector.h @@ -916,10 +916,15 @@ static inline struct drm_connector *drm_connector_lookup(struct drm_device *dev, * @connector: DRM connector * * This function increments the connector's refcount. + + * Returns: + * + * The connector. */ -static inline void drm_connector_get(struct drm_connector *connector) +static inline struct drm_connector *drm_connector_get(struct drm_connector *connector) { drm_mode_object_get(&connector->base); + return connector; }

/**

From: Ville Syrjälä ville.syrjala@linux.intel.com

To avoid having to deference plane_state->vma during the commit phase of plane updates, let's store the vma gtt offset (or the bus address when we need it) in the plane state. This is crucial for doing the modeset operations during GPU reset as as plane_state->vma gets cleared when we duplicate the state and we won't be calling .prepare_fb() during GPU reset plane commits.

Signed-off-by: Ville Syrjälä ville.syrjala@linux.intel.com --- drivers/gpu/drm/i915/intel_display.c | 38 +++++++++++++++++++++--------------- drivers/gpu/drm/i915/intel_drv.h | 6 +----- drivers/gpu/drm/i915/intel_sprite.c | 8 ++++---- 3 files changed, 27 insertions(+), 25 deletions(-)

diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c index 1016afebef27..0ff3f254ee58 100644 --- a/drivers/gpu/drm/i915/intel_display.c +++ b/drivers/gpu/drm/i915/intel_display.c @@ -2744,7 +2744,7 @@ intel_find_initial_plane_obj(struct intel_crtc *intel_crtc, if (!state->vma) continue;

- if (intel_plane_ggtt_offset(state) == plane_config->base) { + if (state->gtt_offset == plane_config->base) { fb = c->primary->fb; drm_framebuffer_reference(fb); goto valid_fb; @@ -2771,6 +2771,8 @@ intel_find_initial_plane_obj(struct intel_crtc *intel_crtc, mutex_lock(&dev->struct_mutex); intel_state->vma = intel_pin_and_fence_fb_obj(fb, primary->state->rotation); + intel_state->gtt_offset = i915_ggtt_offset(intel_state->vma); + mutex_unlock(&dev->struct_mutex); if (IS_ERR(intel_state->vma)) { DRM_ERROR("failed to pin boot fb on pipe %d: %li\n", @@ -3122,19 +3124,16 @@ static void i9xx_update_primary_plane(struct intel_plane *primary, I915_WRITE_FW(DSPSTRIDE(plane), fb->pitches[0]); if (IS_HASWELL(dev_priv) || IS_BROADWELL(dev_priv)) { I915_WRITE_FW(DSPSURF(plane), - intel_plane_ggtt_offset(plane_state) + - crtc->dspaddr_offset); + plane_state->gtt_offset + crtc->dspaddr_offset); I915_WRITE_FW(DSPOFFSET(plane), (y << 16) | x); } else if (INTEL_GEN(dev_priv) >= 4) { I915_WRITE_FW(DSPSURF(plane), - intel_plane_ggtt_offset(plane_state) + - crtc->dspaddr_offset); + plane_state->gtt_offset + crtc->dspaddr_offset); I915_WRITE_FW(DSPTILEOFF(plane), (y << 16) | x); I915_WRITE_FW(DSPLINOFF(plane), linear_offset); } else { I915_WRITE_FW(DSPADDR(plane), - intel_plane_ggtt_offset(plane_state) + - crtc->dspaddr_offset); + plane_state->gtt_offset + crtc->dspaddr_offset); } POSTING_READ_FW(reg);

@@ -3395,7 +3394,7 @@ static void skylake_update_primary_plane(struct intel_plane *plane, }

I915_WRITE_FW(PLANE_SURF(pipe, plane_id), - intel_plane_ggtt_offset(plane_state) + surf_addr); + plane_state->gtt_offset + surf_addr);

POSTING_READ_FW(PLANE_SURF(pipe, plane_id));

@@ -9202,15 +9201,9 @@ static u32 intel_cursor_base(const struct intel_plane_state *plane_state) struct drm_i915_private *dev_priv = to_i915(plane_state->base.plane->dev); const struct drm_framebuffer *fb = plane_state->base.fb; - const struct drm_i915_gem_object *obj = intel_fb_obj(fb); u32 base;

- if (INTEL_INFO(dev_priv)->cursor_needs_physical) - base = obj->phys_handle->busaddr; - else - base = intel_plane_ggtt_offset(plane_state); - - base += plane_state->main.offset; + base = plane_state->gtt_offset + plane_state->main.offset;

/* ILK+ do this automagically */ if (HAS_GMCH_DISPLAY(dev_priv) && @@ -10863,8 +10856,11 @@ static int intel_crtc_page_flip(struct drm_crtc *crtc,

work->old_vma = to_intel_plane_state(primary->state)->vma; to_intel_plane_state(primary->state)->vma = vma; + to_intel_plane_state(primary->state)->gtt_offset = + i915_ggtt_offset(vma);

- work->gtt_offset = i915_ggtt_offset(vma) + intel_crtc->dspaddr_offset; + work->gtt_offset = to_intel_plane_state(primary->state)->gtt_offset + + intel_crtc->dspaddr_offset; work->rotation = crtc->primary->state->rotation;

/* @@ -10920,6 +10916,8 @@ static int intel_crtc_page_flip(struct drm_crtc *crtc, i915_add_request(request); cleanup_unpin: to_intel_plane_state(primary->state)->vma = work->old_vma; + to_intel_plane_state(primary->state)->gtt_offset = + i915_ggtt_offset(work->old_vma); intel_unpin_fb_vma(vma); cleanup_pending: atomic_dec(&intel_crtc->unpin_work_count); @@ -13361,6 +13359,8 @@ intel_prepare_plane_fb(struct drm_plane *plane, DRM_DEBUG_KMS("failed to attach phys object\n"); return ret; } + to_intel_plane_state(new_state)->gtt_offset = + obj->phys_handle->busaddr; } else { struct i915_vma *vma;

@@ -13371,6 +13371,8 @@ intel_prepare_plane_fb(struct drm_plane *plane, }

to_intel_plane_state(new_state)->vma = vma; + to_intel_plane_state(new_state)->gtt_offset = + i915_ggtt_offset(vma); } }

@@ -13680,6 +13682,8 @@ intel_legacy_cursor_update(struct drm_plane *plane, DRM_DEBUG_KMS("failed to attach phys object\n"); goto out_unlock; } + to_intel_plane_state(new_plane_state)->gtt_offset = + intel_fb_obj(fb)->phys_handle->busaddr; } else { struct i915_vma *vma;

@@ -13692,6 +13696,8 @@ intel_legacy_cursor_update(struct drm_plane *plane, }

to_intel_plane_state(new_plane_state)->vma = vma; + to_intel_plane_state(new_plane_state)->gtt_offset = + i915_ggtt_offset(vma); }

old_fb = old_plane_state->fb; diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h index 4be10983e7cc..e72a8e29a2b0 100644 --- a/drivers/gpu/drm/i915/intel_drv.h +++ b/drivers/gpu/drm/i915/intel_drv.h @@ -405,6 +405,7 @@ struct intel_plane_state { struct drm_plane_state base; struct drm_rect clip; struct i915_vma *vma; + u32 gtt_offset; /* GGTT offset, or bus address */

struct { u32 offset; @@ -1508,11 +1509,6 @@ void intel_mode_from_pipe_config(struct drm_display_mode *mode, int skl_update_scaler_crtc(struct intel_crtc_state *crtc_state); int skl_max_scale(struct intel_crtc *crtc, struct intel_crtc_state *crtc_state);

-static inline u32 intel_plane_ggtt_offset(const struct intel_plane_state *state) -{ - return i915_ggtt_offset(state->vma); -} - u32 skl_plane_ctl(const struct intel_crtc_state *crtc_state, const struct intel_plane_state *plane_state); u32 skl_plane_stride(const struct drm_framebuffer *fb, int plane, diff --git a/drivers/gpu/drm/i915/intel_sprite.c b/drivers/gpu/drm/i915/intel_sprite.c index 697b95016c7a..aed4fa833b48 100644 --- a/drivers/gpu/drm/i915/intel_sprite.c +++ b/drivers/gpu/drm/i915/intel_sprite.c @@ -300,7 +300,7 @@ skl_update_plane(struct intel_plane *plane,

I915_WRITE_FW(PLANE_CTL(pipe, plane_id), plane_ctl); I915_WRITE_FW(PLANE_SURF(pipe, plane_id), - intel_plane_ggtt_offset(plane_state) + surf_addr); + plane_state->gtt_offset + surf_addr); POSTING_READ_FW(PLANE_SURF(pipe, plane_id));

spin_unlock_irqrestore(&dev_priv->uncore.lock, irqflags); @@ -477,7 +477,7 @@ vlv_update_plane(struct intel_plane *plane, I915_WRITE_FW(SPSIZE(pipe, plane_id), (crtc_h << 16) | crtc_w); I915_WRITE_FW(SPCNTR(pipe, plane_id), sprctl); I915_WRITE_FW(SPSURF(pipe, plane_id), - intel_plane_ggtt_offset(plane_state) + sprsurf_offset); + plane_state->gtt_offset + sprsurf_offset); POSTING_READ_FW(SPSURF(pipe, plane_id));

spin_unlock_irqrestore(&dev_priv->uncore.lock, irqflags); @@ -615,7 +615,7 @@ ivb_update_plane(struct intel_plane *plane, I915_WRITE_FW(SPRSCALE(pipe), sprscale); I915_WRITE_FW(SPRCTL(pipe), sprctl); I915_WRITE_FW(SPRSURF(pipe), - intel_plane_ggtt_offset(plane_state) + sprsurf_offset); + plane_state->gtt_offset + sprsurf_offset); POSTING_READ_FW(SPRSURF(pipe));

spin_unlock_irqrestore(&dev_priv->uncore.lock, irqflags); @@ -747,7 +747,7 @@ g4x_update_plane(struct intel_plane *plane, I915_WRITE_FW(DVSSCALE(pipe), dvsscale); I915_WRITE_FW(DVSCNTR(pipe), dvscntr); I915_WRITE_FW(DVSSURF(pipe), - intel_plane_ggtt_offset(plane_state) + dvssurf_offset); + plane_state->gtt_offset + dvssurf_offset); POSTING_READ_FW(DVSSURF(pipe));

spin_unlock_irqrestore(&dev_priv->uncore.lock, irqflags);

From: Ville Syrjälä ville.syrjala@linux.intel.com

For i915 GPU reset handling we'll want to be able to duplicate the state that was last commited to the hardware. For that purpose let's start to track the commited state for each object and provide a way to duplicate the commmited state into a new drm_atomic_state. The locking for .commited_state must to be provided by the driver.

drm_atomic_helper_duplicate_commited_state() duplicates the state to both old_state and new_state. For the purposes of i915 GPU reset we would only need one of them, but we actually need two top level states; one for disabling everything (which would need the duplicated state to be old_state), and another to reenable everything (which would need the duplicated state to be new_state). So to make it less comples I figured I'd just always duplicate both. Might want to rethink this if for no other reason that reducing the chances of memory allocation failure. Due to the double state duplication we need drm_atomic_helper_clean_commited_state() to clean up the duplicated old_state since that's not handled by the normal drm_atomic_state cleanup code.

TODO: do we want this in the helper, or maybe it should be just in i915?

v2: s/commited/committed/ everywhere (checkpatch) Handle state duplication errors better v3: Even more care in dealing with memory allocation errors Handle private objs too Deal with the potential ordering issues between swap_state() and hw_done() by keeping track of which state was swapped in last

Signed-off-by: Ville Syrjälä ville.syrjala@linux.intel.com --- drivers/gpu/drm/drm_atomic.c | 1 + drivers/gpu/drm/drm_atomic_helper.c | 231 ++++++++++++++++++++++++++++++++++++ include/drm/drm_atomic.h | 4 + include/drm/drm_atomic_helper.h | 8 ++ include/drm/drm_connector.h | 11 ++ include/drm/drm_crtc.h | 11 ++ include/drm/drm_plane.h | 11 ++ 7 files changed, 277 insertions(+)

diff --git a/drivers/gpu/drm/drm_atomic.c b/drivers/gpu/drm/drm_atomic.c index 56925b93f598..e1578d50d66f 100644 --- a/drivers/gpu/drm/drm_atomic.c +++ b/drivers/gpu/drm/drm_atomic.c @@ -1020,6 +1020,7 @@ drm_atomic_private_obj_init(struct drm_private_obj *obj, memset(obj, 0, sizeof(*obj));

obj->state = state; + obj->committed_state = state; obj->funcs = funcs; } EXPORT_SYMBOL(drm_atomic_private_obj_init); diff --git a/drivers/gpu/drm/drm_atomic_helper.c b/drivers/gpu/drm/drm_atomic_helper.c index f0887f231fb8..c3d02f12cd5d 100644 --- a/drivers/gpu/drm/drm_atomic_helper.c +++ b/drivers/gpu/drm/drm_atomic_helper.c @@ -1815,6 +1815,11 @@ void drm_atomic_helper_wait_for_dependencies(struct drm_atomic_state *old_state) } EXPORT_SYMBOL(drm_atomic_helper_wait_for_dependencies);

+static bool state_seqno_after(unsigned int a, unsigned int b) +{ + return (int)(b - a) < 0; +} + /** * drm_atomic_helper_commit_hw_done - setup possible nonblocking commit * @old_state: atomic state object with old state structures @@ -1833,11 +1838,39 @@ EXPORT_SYMBOL(drm_atomic_helper_wait_for_dependencies); void drm_atomic_helper_commit_hw_done(struct drm_atomic_state *old_state) { struct drm_crtc *crtc; + struct drm_plane *plane; + struct drm_connector *connector; + struct drm_private_obj *obj; struct drm_crtc_state *new_crtc_state; + struct drm_plane_state *new_plane_state; + struct drm_connector_state *new_connector_state; + struct drm_private_state *new_obj_state; struct drm_crtc_commit *commit; int i; + static DEFINE_SPINLOCK(committed_state_lock); + + spin_lock(&committed_state_lock); + + for_each_new_plane_in_state(old_state, plane, new_plane_state, i) { + if (plane->committed_state && + state_seqno_after(new_plane_state->seqno, + plane->committed_state->seqno)) + plane->committed_state = new_plane_state; + } + + for_each_new_connector_in_state(old_state, connector, new_connector_state, i) { + if (connector->committed_state && + state_seqno_after(new_connector_state->seqno, + connector->committed_state->seqno)) + connector->committed_state = new_connector_state; + }

for_each_new_crtc_in_state(old_state, crtc, new_crtc_state, i) { + if (crtc->committed_state && + state_seqno_after(new_crtc_state->seqno, + crtc->committed_state->seqno)) + crtc->committed_state = new_crtc_state; + commit = old_state->crtcs[i].commit; if (!commit) continue; @@ -1846,6 +1879,15 @@ void drm_atomic_helper_commit_hw_done(struct drm_atomic_state *old_state) WARN_ON(new_crtc_state->event); complete_all(&commit->hw_done); } + + for_each_new_private_obj_in_state(old_state, obj, new_obj_state, i) { + if (obj->committed_state && + state_seqno_after(new_obj_state->seqno, + obj->committed_state->seqno)) + obj->committed_state = new_obj_state; + } + + spin_unlock(&committed_state_lock); } EXPORT_SYMBOL(drm_atomic_helper_commit_hw_done);

@@ -2296,6 +2338,7 @@ void drm_atomic_helper_swap_state(struct drm_atomic_state *state,

old_conn_state->state = state; new_conn_state->state = NULL; + new_conn_state->seqno = ++connector->state_seqno;

__drm_atomic_state_connector(state, i)->state = old_conn_state; connector->state = new_conn_state; @@ -2309,6 +2352,7 @@ void drm_atomic_helper_swap_state(struct drm_atomic_state *state,

state->crtcs[i].state = old_crtc_state; crtc->state = new_crtc_state; + new_crtc_state->seqno = ++crtc->state_seqno;

if (state->crtcs[i].commit) { spin_lock(&crtc->commit_lock); @@ -2325,6 +2369,7 @@ void drm_atomic_helper_swap_state(struct drm_atomic_state *state,

old_plane_state->state = state; new_plane_state->state = NULL; + new_plane_state->seqno = ++plane->state_seqno;

state->planes[i].state = old_plane_state; plane->state = new_plane_state; @@ -2335,6 +2380,7 @@ void drm_atomic_helper_swap_state(struct drm_atomic_state *state,

old_obj_state->state = state; new_obj_state->state = NULL; + new_obj_state->seqno = ++obj->state_seqno;

__drm_atomic_state_private_obj(state, i)->state = old_obj_state; obj->state = new_obj_state; @@ -3582,6 +3628,7 @@ __drm_atomic_helper_connector_reset(struct drm_connector *connector, conn_state->connector = connector;

connector->state = conn_state; + connector->committed_state = conn_state; } EXPORT_SYMBOL(__drm_atomic_helper_connector_reset);

@@ -3740,6 +3787,189 @@ drm_atomic_helper_duplicate_state(struct drm_device *dev, } EXPORT_SYMBOL(drm_atomic_helper_duplicate_state);

+struct drm_atomic_state * +drm_atomic_helper_duplicate_committed_state(struct drm_device *dev) +{ + struct drm_atomic_state *state; + struct drm_connector_list_iter conn_iter; + struct drm_connector *conn; + struct drm_plane *plane; + struct drm_crtc *crtc; + int err = 0; + + state = drm_atomic_state_alloc(dev); + if (!state) + return ERR_PTR(-ENOMEM); + + drm_for_each_plane(plane, dev) { + struct drm_plane_state *old_state, *new_state; + int i = drm_plane_index(plane); + + old_state = plane->funcs->atomic_duplicate_state(plane, plane->committed_state); + if (!old_state) { + err = -ENOMEM; + goto free; + } + new_state = plane->funcs->atomic_duplicate_state(plane, plane->committed_state); + if (!new_state) { + plane->funcs->atomic_destroy_state(plane, old_state); + err = -ENOMEM; + goto free; + } + + state->planes[i].state = new_state; + state->planes[i].old_state = old_state; + state->planes[i].new_state = new_state; + state->planes[i].ptr = plane; + + old_state->state = state; + } + + drm_for_each_crtc(crtc, dev) { + struct drm_crtc_state *old_state, *new_state; + int i = drm_crtc_index(crtc); + + old_state = crtc->funcs->atomic_duplicate_state(crtc, crtc->committed_state); + if (!old_state) { + err = -ENOMEM; + goto free; + } + new_state = crtc->funcs->atomic_duplicate_state(crtc, crtc->committed_state); + if (!new_state) { + crtc->funcs->atomic_destroy_state(crtc, old_state); + err = -ENOMEM; + goto free; + } + + state->crtcs[i].state = new_state; + state->crtcs[i].old_state = old_state; + state->crtcs[i].new_state = new_state; + state->crtcs[i].ptr = crtc; + + old_state->state = state; + } + + drm_connector_list_iter_begin(dev, &conn_iter); + drm_for_each_connector_iter(conn, &conn_iter) { + struct drm_connector_state *old_state, *new_state; + struct __drm_connectors_state *c; + int i = drm_connector_index(conn); + + err = drm_dynarray_reserve(&state->connectors, i); + if (err) + break; + + old_state = conn->funcs->atomic_duplicate_state(conn, conn->committed_state); + if (!old_state) { + err = -ENOMEM; + break; + } + new_state = conn->funcs->atomic_duplicate_state(conn, conn->committed_state); + if (!new_state) { + conn->funcs->atomic_destroy_state(conn, old_state); + err = -ENOMEM; + break; + } + + state->num_connector = state->connectors.num_elems; + + c = __drm_atomic_state_connector(state, i); + + c->state = new_state; + c->old_state = old_state; + c->new_state = new_state; + c->ptr = drm_connector_get(conn); + + old_state->state = state; + } + drm_connector_list_iter_end(&conn_iter); + +free: + if (err < 0) { + drm_atomic_helper_clean_committed_state(state); + drm_atomic_state_put(state); + state = ERR_PTR(err); + } + + return state; +} +EXPORT_SYMBOL(drm_atomic_helper_duplicate_committed_state); + +int drm_atomic_helper_duplicate_private_obj_committed_state(struct drm_atomic_state *state, + struct drm_private_obj *obj) +{ + struct drm_private_state *old_state, *new_state; + struct __drm_private_objs_state *p; + int ret, i = state->num_private_objs; + + ret = drm_dynarray_reserve(&state->private_objs, i); + if (ret) + return ret; + + old_state = obj->funcs->atomic_duplicate_state(obj, obj->committed_state); + if (!old_state) + return -ENOMEM; + + new_state = obj->funcs->atomic_duplicate_state(obj, obj->committed_state); + if (!new_state) { + obj->funcs->atomic_destroy_state(obj, obj->committed_state); + return -ENOMEM; + } + + state->num_private_objs = state->private_objs.num_elems; + + p = __drm_atomic_state_private_obj(state, i); + + p->state = new_state; + p->old_state = old_state; + p->new_state = new_state; + p->ptr = obj; + + old_state->state = state; + + return 0; +} +EXPORT_SYMBOL(drm_atomic_helper_duplicate_private_obj_committed_state); + +void +drm_atomic_helper_clean_committed_state(struct drm_atomic_state *state) +{ + struct drm_plane *plane; + struct drm_crtc *crtc; + struct drm_connector *conn; + struct drm_plane_state *plane_state; + struct drm_crtc_state *crtc_state; + struct drm_connector_state *conn_state; + struct drm_private_obj *obj; + struct drm_private_state *obj_state; + int i; + + /* restore the correct state->state */ + for_each_new_plane_in_state(state, plane, plane_state, i) { + plane->funcs->atomic_destroy_state(plane, state->planes[i].old_state); + state->planes[i].old_state = NULL; + } + for_each_new_crtc_in_state(state, crtc, crtc_state, i) { + crtc->funcs->atomic_destroy_state(crtc, state->crtcs[i].old_state); + state->crtcs[i].old_state = NULL; + } + for_each_new_connector_in_state(state, conn, conn_state, i) { + struct __drm_connectors_state *c = + __drm_atomic_state_connector(state, i); + + conn->funcs->atomic_destroy_state(conn, c->old_state); + c->old_state = NULL; + } + for_each_new_private_obj_in_state(state, obj, obj_state, i) { + struct __drm_private_objs_state *p = + __drm_atomic_state_private_obj(state, i); + + obj->funcs->atomic_destroy_state(obj, p->old_state); + p->old_state = NULL; + } +} +EXPORT_SYMBOL(drm_atomic_helper_clean_committed_state); + /** * __drm_atomic_helper_connector_destroy_state - release connector state * @state: connector state object to release @@ -3856,6 +4086,7 @@ 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 + * @old_state: old 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. diff --git a/include/drm/drm_atomic.h b/include/drm/drm_atomic.h index 0e6c54b3e0af..9ff4fb46d500 100644 --- a/include/drm/drm_atomic.h +++ b/include/drm/drm_atomic.h @@ -194,12 +194,16 @@ struct drm_private_state_funcs {

struct drm_private_obj { struct drm_private_state *state; + struct drm_private_state *committed_state;

const struct drm_private_state_funcs *funcs; + + unsigned int state_seqno; };

struct drm_private_state { struct drm_atomic_state *state; + unsigned int seqno; };

struct __drm_private_objs_state { diff --git a/include/drm/drm_atomic_helper.h b/include/drm/drm_atomic_helper.h index b799687a4b09..3a609bbb5818 100644 --- a/include/drm/drm_atomic_helper.h +++ b/include/drm/drm_atomic_helper.h @@ -185,6 +185,14 @@ 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); +struct drm_atomic_state * +drm_atomic_helper_duplicate_committed_state(struct drm_device *dev); +struct drm_private_obj; +int +drm_atomic_helper_duplicate_private_obj_committed_state(struct drm_atomic_state *state, + struct drm_private_obj *obj); +void +drm_atomic_helper_clean_committed_state(struct drm_atomic_state *state); void __drm_atomic_helper_connector_destroy_state(struct drm_connector_state *state); void drm_atomic_helper_connector_destroy_state(struct drm_connector *connector, diff --git a/include/drm/drm_connector.h b/include/drm/drm_connector.h index 8f26166f78b4..a38ba05db4fa 100644 --- a/include/drm/drm_connector.h +++ b/include/drm/drm_connector.h @@ -306,6 +306,8 @@ struct drm_tv_connector_state { struct drm_connector_state { struct drm_connector *connector;

+ unsigned int seqno; + /** * @crtc: CRTC to connect connector to, NULL if disabled. * @@ -707,6 +709,8 @@ struct drm_connector {

char *name;

+ unsigned int state_seqno; + /** * @mutex: Lock for general connector state, but currently only protects * @registered. Most of the connector state is still protected by @@ -868,6 +872,13 @@ struct drm_connector { */ struct drm_connector_state *state;

+ /** + * @committed_state: + * + * Current committed atomic state for this connector. + */ + struct drm_connector_state *committed_state; + /* DisplayID bits */ bool has_tile; struct drm_tile_group *tile_group; diff --git a/include/drm/drm_crtc.h b/include/drm/drm_crtc.h index 8bfbc54660ab..2a1897d76c71 100644 --- a/include/drm/drm_crtc.h +++ b/include/drm/drm_crtc.h @@ -108,6 +108,8 @@ struct drm_plane_helper_funcs; struct drm_crtc_state { struct drm_crtc *crtc;

+ unsigned int seqno; + bool enable; bool active;

@@ -750,6 +752,8 @@ struct drm_crtc {

char *name;

+ unsigned int state_seqno; + /** * @mutex: * @@ -816,6 +820,13 @@ struct drm_crtc { struct drm_crtc_state *state;

/** + * @committed_state: + * + * Current committed atomic state for this CRTC. + */ + struct drm_crtc_state *committed_state; + + /** * @commit_list: * * List of &drm_crtc_commit structures tracking pending commits. diff --git a/include/drm/drm_plane.h b/include/drm/drm_plane.h index 08ad4b58adbe..ff3495705e63 100644 --- a/include/drm/drm_plane.h +++ b/include/drm/drm_plane.h @@ -59,6 +59,8 @@ struct drm_modeset_acquire_ctx; struct drm_plane_state { struct drm_plane *plane;

+ unsigned int seqno; + /** * @crtc: * @@ -470,6 +472,8 @@ struct drm_plane {

char *name;

+ unsigned int state_seqno; + /** * @mutex: * @@ -522,6 +526,13 @@ struct drm_plane { */ struct drm_plane_state *state;

+ /** + * @committed_state: + * + * Current committed atomic state for this plane. + */ + struct drm_plane_state *committed_state; + struct drm_property *zpos_property; struct drm_property *rotation_property; };