drm/i915: Add kerneldoc for intel_pipe_update_{start, end}
Subsystems (2)
PATCH 1/3 drm/i915: Add kerneldoc for intel_pipe_update_{start, end}
--- drivers/gpu/drm/i915/intel_sprite.c | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+)
drivers/gpu/drm/i915/intel_sprite.c +25 -0
@@ -46,6 +46,22 @@ static int usecs_to_scanlines(const struct drm_display_mode *mode, int usecs)return DIV_ROUND_UP (usecs * mode->crtc_clock,1000 * mode->crtc_htotal); } +/** +* 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 +* +* Mark the start of an update to pipe registers that should be updated +* atomically regarding vblank. If the next vblank will happens within +* the next 100 us, this function waits until the vblank passes. +* +* 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. +* +* Return: true if the call was successful +*/ static bool intel_pipe_update_start (struct intel_crtc *crtc,uint32_t *start_vbl_count) {struct drm_device *dev = crtc->base.dev;
@@ -112,6 +128,15 @@ static bool intel_pipe_update_start(struct intel_crtc *crtc, uint32_t *start_vblreturn true; } +/** +* 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) +* +* 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. +*/ static void intel_pipe_update_end (struct intel_crtc *crtc,u32 start_vbl_count) {struct drm_device *dev = crtc->base.dev;
Signature · 6 lines
1.9.1 _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH 2/3 drm/i915: Remove modeset lock check from intel_pipe_update_start()
A follow up patch will call this funcion from a work context for the mmio flip, in which case we cannot acquire the modeset locks. That's not a problem though, since the check is there to protect vblank and the mode, but the code that changes that waits for pending flips first.
--- drivers/gpu/drm/i915/intel_sprite.c | 2 -- 1 file changed, 2 deletions(-)
drivers/gpu/drm/i915/intel_sprite.c +0 -2
@@ -72,8 +72,6 @@ static bool intel_pipe_update_start(struct intel_crtc *crtc, uint32_t *start_vblwait_queue_head_t *wq =drm_crtc_vblank_waitqueue (&crtc->base);DEFINE_WAIT (wait); -WARN_ON (!drm_modeset_is_locked (&crtc->base.mutex)); - vblank_start = mode->crtc_vblank_start;if (mode->flags &DRM_MODE_FLAG_INTERLACE ) vblank_start =DIV_ROUND_UP (vblank_start,2 );
Signature · 6 lines
1.9.1 _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH 3/3 drm/i915: Use vblank evade mechanism in mmio_flip
In reply to Ander Conselvan de OliveiraCurrently we program just DPSCNTR and DSPSTRIDE directly from the ring interrupt handler, which is fine since the hardware guarantees that those are update atomically. When we have atomic page flips we'll want to be able to update also the offset registers, and then we need to use the vblank evade mechanism to guarantee atomicity. Since that mechanism introduces a wait, we need to do the actual register write from a work when it is triggered by the ring interrupt.
v2: Explain the need for mmio_flip.work in the commit message (Paulo)
Initialize the mmio_flip work in intel_crtc_init() (Paulo) Prevent new flips the previous flip work finishes (Paulo) Don't acquire modeset locks for mmio flip work
--- drivers/gpu/drm/i915/intel_display.c | 30 ++++++++++++++++++++++++++---- drivers/gpu/drm/i915/intel_drv.h | 12 +++++++++++- drivers/gpu/drm/i915/intel_sprite.c | 4 ++-- 3 files changed, 39 insertions(+), 7 deletions(-)
drivers/gpu/drm/i915/intel_display.c +26 -4
@@ -9314,11 +9314,15 @@ static void intel_do_mmio_flip(struct intel_crtc *intel_crtc)struct intel_framebuffer *intel_fb =to_intel_framebuffer (intel_crtc->base.primary->fb);struct drm_i915_gem_object *obj = intel_fb->obj; +bool atomic_update; +u32 start_vbl_count;u32 dspcntr;u32 reg;intel_mark_page_flip_active (intel_crtc); + atomic_update =intel_pipe_update_start (intel_crtc, &start_vbl_count); + reg =DSPCNTR (intel_crtc->plane); dspcntr =I915_READ (reg);
@@ -9332,6 +9336,21 @@ static void intel_do_mmio_flip(struct intel_crtc *intel_crtc)I915_WRITE (DSPSURF (intel_crtc->plane), intel_crtc->unpin_work->gtt_offset);POSTING_READ (DSPSURF (intel_crtc->plane)); + +if (atomic_update) +intel_pipe_update_end (intel_crtc, start_vbl_count); + +spin_lock_irq (&dev_priv->mmio_flip_lock); + intel_crtc->mmio_flip.status =INTEL_MMIO_FLIP_IDLE ; +spin_unlock_irq (&dev_priv->mmio_flip_lock); +} + +static void intel_mmio_flip_work_func (struct work_struct *work) +{ +struct intel_crtc *intel_crtc = + container_of(work, struct intel_crtc, mmio_flip.work); + +intel_do_mmio_flip (intel_crtc); }static int intel_postpone_flip (struct drm_i915_gem_object *obj)
@@ -9374,15 +9393,15 @@ void intel_notify_mmio_flip(struct intel_engine_cs *ring)struct intel_mmio_flip *mmio_flip; mmio_flip = &intel_crtc->mmio_flip; -if (mmio_flip->seqno ==0 ) +if (mmio_flip->status !=INTEL_MMIO_FLIP_WAIT_RING )continue ;if (ring->id != mmio_flip->ring_id)continue ;if (i915_seqno_passed (seqno, mmio_flip->seqno)) { -intel_do_mmio_flip (intel_crtc); - mmio_flip->seqno =0 ; +schedule_work (&intel_crtc->mmio_flip.work); + mmio_flip->status =INTEL_MMIO_FLIP_WORK_SCHEDULED ; ring->irq_put (ring); } }
@@ -9400,7 +9419,7 @@ static int intel_queue_mmio_flip(struct drm_device *dev,struct intel_crtc *intel_crtc =to_intel_crtc (crtc);int ret; -if (WARN_ON (intel_crtc->mmio_flip.seqno)) +if (WARN_ON (intel_crtc->mmio_flip.status !=INTEL_MMIO_FLIP_IDLE ))return -EBUSY ; ret =intel_postpone_flip (obj);
@@ -9412,6 +9431,7 @@ static int intel_queue_mmio_flip(struct drm_device *dev, }spin_lock_irq (&dev_priv->mmio_flip_lock); + intel_crtc->mmio_flip.status =INTEL_MMIO_FLIP_WAIT_RING ; intel_crtc->mmio_flip.seqno = obj->last_write_seqno; intel_crtc->mmio_flip.ring_id = obj->ring->id;spin_unlock_irq (&dev_priv->mmio_flip_lock);
@@ -11883,6 +11903,8 @@ static void intel_crtc_init(struct drm_device *dev, int pipe) dev_priv->plane_to_crtc_mapping[intel_crtc->plane] = &intel_crtc->base; dev_priv->pipe_to_crtc_mapping[intel_crtc->pipe] = &intel_crtc->base; +INIT_WORK (&intel_crtc->mmio_flip.work, intel_mmio_flip_work_func); +drm_crtc_helper_add (&intel_crtc->base, &intel_helper_funcs);WARN_ON (drm_crtc_index (&intel_crtc->base) != intel_crtc->pipe);
drivers/gpu/drm/i915/intel_drv.h +11 -1
@@ -399,9 +399,17 @@ struct intel_pipe_wm {bool sprites_scaled; }; +enum intel_mmio_flip_status { +INTEL_MMIO_FLIP_IDLE =0 , +INTEL_MMIO_FLIP_WAIT_RING , +INTEL_MMIO_FLIP_WORK_SCHEDULED , +}; +struct intel_mmio_flip {u32 seqno;u32 ring_id; +enum intel_mmio_flip_status status; +struct work_struct work; };struct intel_crtc {
@@ -1168,7 +1176,9 @@ int intel_sprite_set_colorkey(struct drm_device *dev, void *data, struct drm_file *file_priv);int intel_sprite_get_colorkey (struct drm_device *dev,void *data,struct drm_file *file_priv); - +bool intel_pipe_update_start (struct intel_crtc *crtc, +uint32_t *start_vbl_count); +void intel_pipe_update_end (struct intel_crtc *crtc,u32 start_vbl_count);/* intel_tv.c */ void intel_tv_init (struct drm_device *dev);
drivers/gpu/drm/i915/intel_sprite.c +2 -2
@@ -62,7 +62,7 @@ static int usecs_to_scanlines(const struct drm_display_mode *mode, int usecs)* * Return: true if the call was successful */ -static bool intel_pipe_update_start (struct intel_crtc *crtc,uint32_t *start_vbl_count) +bool intel_pipe_update_start (struct intel_crtc *crtc,uint32_t *start_vbl_count) {struct drm_device *dev = crtc->base.dev;const struct drm_display_mode *mode = &crtc->config.adjusted_mode;
@@ -135,7 +135,7 @@ static bool intel_pipe_update_start(struct intel_crtc *crtc, uint32_t *start_vbl* re-enables interrupts and verifies the update was actually completed * before a vblank using the value of @start_vbl_count. */ -static void intel_pipe_update_end (struct intel_crtc *crtc,u32 start_vbl_count) +void intel_pipe_update_end (struct intel_crtc *crtc,u32 start_vbl_count) {struct drm_device *dev = crtc->base.dev;enum pipe pipe = crtc->pipe;
Signature · 6 lines
1.9.1 _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Re: [PATCH 3/3] drm/i915: Use vblank evade mechanism in mmio_flip
Quoted 8 lines · Ander Conselvan de Oliveira
Currently we program just DPSCNTR and DSPSTRIDE directly from the ring interrupt handler, which is fine since the hardware guarantees that those are update atomically. When we have atomic page flips we'll want to be able to update also the offset registers, and then we need to use the vblank evade mechanism to guarantee atomicity. Since that mechanism introduces a wait, we need to do the actual register write from a work when it is triggered by the ring interrupt.
Quoted 4 lines
v2: Explain the need for mmio_flip.work in the commit message (Paulo)
Initialize themmio_flipwork inintel_crtc_init()(Paulo) Prevent new flips the previous flip work finishes (Paulo) Don't acquire modeset locks for mmio flip work
So that means you can replace the content of intel_do_mmio() by a call to dev_priv->display.update_primary_plane() on top of this patch? That'd do the right thing on SKL, which would make me happy.
Signature · 5 lines
Damien _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Re: [PATCH 3/3] drm/i915: Use vblank evade mechanism in mmio_flip
In reply to Ander Conselvan de Oliveira2014-10-28 11:10 GMT-02:00 Ander Conselvan de Oliveira <[email protected]>:
Quoted 26 lines
Currently we program just DPSCNTR and DSPSTRIDE directly from the ring interrupt handler, which is fine since the hardware guarantees that those are update atomically. When we have atomic page flips we'll want to be able to update also the offset registers, and then we need to use the vblank evade mechanism to guarantee atomicity. Since that mechanism introduces a wait, we need to do the actual register write from a work when it is triggered by the ring interrupt.
v2: Explain the need for mmio_flip.work in the commit message (Paulo)
Initialize themmio_flipwork inintel_crtc_init()(Paulo) Prevent new flips the previous flip work finishes (Paulo) Don't acquire modeset locks for mmio flip workSigned-off-by Ander Conselvan de Oliveira <[email protected]>--- drivers/gpu/drm/i915/intel_display.c | 30 ++++++++++++++++++++++++++---- drivers/gpu/drm/i915/intel_drv.h | 12 +++++++++++- drivers/gpu/drm/i915/intel_sprite.c | 4 ++-- 3 files changed, 39 insertions(+), 7 deletions(-)drivers/gpu/drm/i915/intel_display.c +0
-0@@ -9314,11 +9314,15 @@ static void intel_do_mmio_flip(struct intel_crtc *intel_crtc) struct intel_framebuffer *intel_fb =
drivers/gpu/drm/i915/intel_display.c static void intel_do_mmio_flip(struct intel_crtc *intel_crtc) · line 9324
Quoted 10 lines
drivers/gpu/drm/i915/intel_display.c +3
-0to_intel_framebuffer (intel_crtc->base.primary->fb);struct drm_i915_gem_object *obj = intel_fb->obj; +bool atomic_update; +u32 start_vbl_count;u32 dspcntr;u32 reg;intel_mark_page_flip_active (intel_crtc); + atomic_update =intel_pipe_update_start (intel_crtc, &start_vbl_count);
Don't we want to print something (error message?) in case this returns false?
Besides this, my only worry is what is going to happen if we disable the CRTC or plane (or even suspend - S3 or runtime - or something like that) after we schedule the work, but before the work actually happens. Isn't it possible to end up accidentally reenabling something that was just disabled? We can't seem to queue a new flip before the current one finishes, but maybe we can shut down the CRTC while the work is scheduled? I don't know much about vblanks to properly answer that, so I'll let Daniel/Ville take a look at this.
Everything else looks correct, so if someone guarantees the above question is not a problem: Reviewed-by: Paulo Zanoni <[email protected]>
Quoted 133 lines
drivers/gpu/drm/i915/intel_display.c +23
-4+ reg =DSPCNTR (intel_crtc->plane); dspcntr =I915_READ (reg);@@ -9332,6 +9336,21 @@ static void intel_do_mmio_flip(struct intel_crtc *intel_crtc)I915_WRITE (DSPSURF (intel_crtc->plane), intel_crtc->unpin_work->gtt_offset);POSTING_READ (DSPSURF (intel_crtc->plane)); + +if (atomic_update) +intel_pipe_update_end (intel_crtc, start_vbl_count); + +spin_lock_irq (&dev_priv->mmio_flip_lock); + intel_crtc->mmio_flip.status =INTEL_MMIO_FLIP_IDLE ; +spin_unlock_irq (&dev_priv->mmio_flip_lock); +} + +static void intel_mmio_flip_work_func (struct work_struct *work) +{ +struct intel_crtc *intel_crtc = + container_of(work, struct intel_crtc, mmio_flip.work); + +intel_do_mmio_flip (intel_crtc); }static int intel_postpone_flip (struct drm_i915_gem_object *obj)@@ -9374,15 +9393,15 @@ void intel_notify_mmio_flip(struct intel_engine_cs *ring)struct intel_mmio_flip *mmio_flip; mmio_flip = &intel_crtc->mmio_flip; -if (mmio_flip->seqno ==0 ) +if (mmio_flip->status !=INTEL_MMIO_FLIP_WAIT_RING )continue ;if (ring->id != mmio_flip->ring_id)continue ;if (i915_seqno_passed (seqno, mmio_flip->seqno)) { -intel_do_mmio_flip (intel_crtc); - mmio_flip->seqno =0 ; +schedule_work (&intel_crtc->mmio_flip.work); + mmio_flip->status =INTEL_MMIO_FLIP_WORK_SCHEDULED ; ring->irq_put (ring); } }@@ -9400,7 +9419,7 @@ static int intel_queue_mmio_flip(struct drm_device *dev,struct intel_crtc *intel_crtc =to_intel_crtc (crtc);int ret; -if (WARN_ON (intel_crtc->mmio_flip.seqno)) +if (WARN_ON (intel_crtc->mmio_flip.status !=INTEL_MMIO_FLIP_IDLE ))return -EBUSY ; ret =intel_postpone_flip (obj);@@ -9412,6 +9431,7 @@ static int intel_queue_mmio_flip(struct drm_device *dev, }spin_lock_irq (&dev_priv->mmio_flip_lock); + intel_crtc->mmio_flip.status =INTEL_MMIO_FLIP_WAIT_RING ; intel_crtc->mmio_flip.seqno = obj->last_write_seqno; intel_crtc->mmio_flip.ring_id = obj->ring->id;spin_unlock_irq (&dev_priv->mmio_flip_lock);@@ -11883,6 +11903,8 @@ static void intel_crtc_init(struct drm_device *dev, int pipe) dev_priv->plane_to_crtc_mapping[intel_crtc->plane] = &intel_crtc->base; dev_priv->pipe_to_crtc_mapping[intel_crtc->pipe] = &intel_crtc->base; +INIT_WORK (&intel_crtc->mmio_flip.work, intel_mmio_flip_work_func); +drm_crtc_helper_add (&intel_crtc->base, &intel_helper_funcs);WARN_ON (drm_crtc_index (&intel_crtc->base) != intel_crtc->pipe);drivers/gpu/drm/i915/intel_drv.h +11
-1@@ -399,9 +399,17 @@ struct intel_pipe_wm {bool sprites_scaled; }; +enum intel_mmio_flip_status { +INTEL_MMIO_FLIP_IDLE =0 , +INTEL_MMIO_FLIP_WAIT_RING , +INTEL_MMIO_FLIP_WORK_SCHEDULED , +}; +struct intel_mmio_flip {u32 seqno;u32 ring_id; +enum intel_mmio_flip_status status; +struct work_struct work; };struct intel_crtc {@@ -1168,7 +1176,9 @@ int intel_sprite_set_colorkey(struct drm_device *dev, void *data, struct drm_file *file_priv);int intel_sprite_get_colorkey (struct drm_device *dev,void *data,struct drm_file *file_priv); - +bool intel_pipe_update_start (struct intel_crtc *crtc, +uint32_t *start_vbl_count); +void intel_pipe_update_end (struct intel_crtc *crtc,u32 start_vbl_count);/* intel_tv.c */ void intel_tv_init (struct drm_device *dev);drivers/gpu/drm/i915/intel_sprite.c +2
-3@@ -62,7 +62,7 @@ static int usecs_to_scanlines(const struct drm_display_mode *mode, int usecs)* * Return: true if the call was successful */ -static bool intel_pipe_update_start (struct intel_crtc *crtc,uint32_t *start_vbl_count) +bool intel_pipe_update_start (struct intel_crtc *crtc,uint32_t *start_vbl_count) {struct drm_device *dev = crtc->base.dev;const struct drm_display_mode *mode = &crtc->config.adjusted_mode;@@ -135,7 +135,7 @@ static bool intel_pipe_update_start(struct intel_crtc *crtc, uint32_t *start_vbl* re-enables interrupts and verifies the update was actually completed * before a vblank using the value of @start_vbl_count. */ -static void intel_pipe_update_end (struct intel_crtc *crtc,u32 start_vbl_count) +void intel_pipe_update_end (struct intel_crtc *crtc,u32 start_vbl_count) {struct drm_device *dev = crtc->base.dev;enum pipe pipe = crtc->pipe; --1.9.1
_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Signature · 5 lines
Paulo Zanoni _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Re: [PATCH 3/3] drm/i915: Use vblank evade mechanism in mmio_flip
Quoted 8 lines · Paulo Zanoni
Besides this, my only worry is what is going to happen if we disable the CRTC or plane (or even suspend - S3 or runtime - or something like that) after we schedule the work, but before the work actually happens. Isn't it possible to end up accidentally reenabling something that was just disabled? We can't seem to queue a new flip before the current one finishes, but maybe we can shut down the CRTC while the work is scheduled? I don't know much about vblanks to properly answer that, so I'll let Daniel/Ville take a look at this.
We do wait for pageflips to complete before disabling the crtc or updating the framebuffer. But I don't think we actually lack the corresponding code to do the same when disabling the pipe with dpms off. We have extensive sets of testcases to race pageflips against almost any combination of dpms calls, setCrtc changes, vblank waits or any other nonsense, so if that still works we should be good I think.
Or maybe that's the reason why kms_flip has such a poor pass-rate? -Daniel
Signature · 7 lines
Daniel Vetter Software Engineer, Intel Corporation +41 (0) 79 365 57 48 - http://blog.ffwll.ch _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Re: [PATCH 3/3] drm/i915: Use vblank evade mechanism in mmio_flip
2014-11-03 16:53 GMT-02:00 Daniel Vetter <[email protected]>:
Quoted 10 lines · Paulo Zanoni
Quoted 8 lines
Besides this, my only worry is what is going to happen if we disable the CRTC or plane (or even suspend - S3 or runtime - or something like that) after we schedule the work, but before the work actually happens. Isn't it possible to end up accidentally reenabling something that was just disabled? We can't seem to queue a new flip before the current one finishes, but maybe we can shut down the CRTC while the work is scheduled? I don't know much about vblanks to properly answer that, so I'll let Daniel/Ville take a look at this.
Quoted 2 lines
We do wait for pageflips to complete before disabling the crtc or updating the framebuffer.
But, as far as I can see, those functions do not take into consideration the new workqueue added by this patch.
Quoted 12 lines
But I don't think we actually lack the
corresponding code to do the same when disabling the pipe with dpms off. We have extensive sets of testcases to race pageflips against almost any combination of dpms calls, setCrtc changes, vblank waits or any other nonsense, so if that still works we should be good I think.Or maybe that's the reason why
kms_fliphas such a poor pass-rate? -Daniel
--
Daniel Vetter
Software Engineer, Intel Corporation
+41 (0) 79 365 57 48 - http://blog.ffwll.ch
Signature · 5 lines
Paulo Zanoni _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Re: [PATCH 3/3] drm/i915: Use vblank evade mechanism in mmio_flip
Quoted 11 lines · Paulo Zanoni
2014-11-03 16:53 GMT-02:00 Daniel Vetter <[email protected]>:
Quoted 10 lines · Paulo Zanoni
Quoted 8 lines
Besides this, my only worry is what is going to happen if we disable the CRTC or plane (or even suspend - S3 or runtime - or something like that) after we schedule the work, but before the work actually happens. Isn't it possible to end up accidentally reenabling something that was just disabled? We can't seem to queue a new flip before the current one finishes, but maybe we can shut down the CRTC while the work is scheduled? I don't know much about vblanks to properly answer that, so I'll let Daniel/Ville take a look at this.
Quoted 5 lines
Quoted 2 lines
We do wait for pageflips to complete before disabling the crtc or updating the framebuffer.
But, as far as I can see, those functions do not take into consideration the new workqueue added by this patch.
Well we wait for the flip to happen. How that happens shouldn't really matter at all - the flip only completes on the next vblank, which might actaully be a lot later than when the work item has run. It's guaranteed to be after the mmio writes though.
-Daniel
Signature · 7 lines
Daniel Vetter Software Engineer, Intel Corporation +41 (0) 79 365 57 48 - http://blog.ffwll.ch _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Re: [PATCH 3/3] drm/i915: Use vblank evade mechanism in mmio_flip
In reply to Paulo ZanoniHi Paulo,
Thanks for reviewing.
Quoted 35 lines · Paulo Zanoni
2014-10-28 11:10 GMT-02:00 Ander Conselvan de Oliveira <[email protected]>:
Quoted 33 lines
Currently we program just DPSCNTR and DSPSTRIDE directly from the ring interrupt handler, which is fine since the hardware guarantees that those are update atomically. When we have atomic page flips we'll want to be able to update also the offset registers, and then we need to use the vblank evade mechanism to guarantee atomicity. Since that mechanism introduces a wait, we need to do the actual register write from a work when it is triggered by the ring interrupt.
v2: Explain the need for mmio_flip.work in the commit message (Paulo)
Initialize themmio_flipwork inintel_crtc_init()(Paulo) Prevent new flips the previous flip work finishes (Paulo) Don't acquire modeset locks for mmio flip workSigned-off-by Ander Conselvan de Oliveira <[email protected]>--- drivers/gpu/drm/i915/intel_display.c | 30 ++++++++++++++++++++++++++---- drivers/gpu/drm/i915/intel_drv.h | 12 +++++++++++- drivers/gpu/drm/i915/intel_sprite.c | 4 ++-- 3 files changed, 39 insertions(+), 7 deletions(-)drivers/gpu/drm/i915/intel_display.c +2
-0@@ -9314,11 +9314,15 @@ static void intel_do_mmio_flip(struct intel_crtc *intel_crtc)struct intel_framebuffer *intel_fb =to_intel_framebuffer (intel_crtc->base.primary->fb);struct drm_i915_gem_object *obj = intel_fb->obj; +bool atomic_update; +u32 start_vbl_count;u32 dspcntr;u32 reg;
Quoted 5 lines
drivers/gpu/drm/i915/intel_display.c static void intel_do_mmio_flip(struct intel_crtc *intel_crtc) · line 9324
Quoted 3 lines
drivers/gpu/drm/i915/intel_display.c +1
-0intel_mark_page_flip_active (intel_crtc); + atomic_update =intel_pipe_update_start (intel_crtc, &start_vbl_count);Don't we want to print something (error message?) in case this returns false?
Good question. The function itself has a warn for one of the failure cases (when drm_vblank_get() fails) but it doesn't print anything if the calculation for min and max scanlines fails. It seems the latter case would fail if we have a bad mode (with vblank_start <= 1) or in some unrealistic scenarios involving a combination of low pixel clocks and high htotal.
In any case, I guess we would be better to add a the warning to intel_pipe_update_start() itself, since there are other users that follow the same pattern.
Ander
Quoted 142 lines
Besides this, my only worry is what is going to happen if we disable the CRTC or plane (or even suspend - S3 or runtime - or something like that) after we schedule the work, but before the work actually happens. Isn't it possible to end up accidentally reenabling something that was just disabled? We can't seem to queue a new flip before the current one finishes, but maybe we can shut down the CRTC while the work is scheduled? I don't know much about vblanks to properly answer that, so I'll let Daniel/Ville take a look at this.
Everything else looks correct, so if someone guarantees the above question is not a problem: Reviewed-by: Paulo Zanoni <[email protected]>
Quoted 129 lines
drivers/gpu/drm/i915/intel_display.c +23
-4+ reg =DSPCNTR (intel_crtc->plane); dspcntr =I915_READ (reg);@@ -9332,6 +9336,21 @@ static void intel_do_mmio_flip(struct intel_crtc *intel_crtc)I915_WRITE (DSPSURF (intel_crtc->plane), intel_crtc->unpin_work->gtt_offset);POSTING_READ (DSPSURF (intel_crtc->plane)); + +if (atomic_update) +intel_pipe_update_end (intel_crtc, start_vbl_count); + +spin_lock_irq (&dev_priv->mmio_flip_lock); + intel_crtc->mmio_flip.status =INTEL_MMIO_FLIP_IDLE ; +spin_unlock_irq (&dev_priv->mmio_flip_lock); +} + +static void intel_mmio_flip_work_func (struct work_struct *work) +{ +struct intel_crtc *intel_crtc = + container_of(work, struct intel_crtc, mmio_flip.work); + +intel_do_mmio_flip (intel_crtc); }static int intel_postpone_flip (struct drm_i915_gem_object *obj)@@ -9374,15 +9393,15 @@ void intel_notify_mmio_flip(struct intel_engine_cs *ring)struct intel_mmio_flip *mmio_flip; mmio_flip = &intel_crtc->mmio_flip; -if (mmio_flip->seqno ==0 ) +if (mmio_flip->status !=INTEL_MMIO_FLIP_WAIT_RING )continue ;if (ring->id != mmio_flip->ring_id)continue ;if (i915_seqno_passed (seqno, mmio_flip->seqno)) { -intel_do_mmio_flip (intel_crtc); - mmio_flip->seqno =0 ; +schedule_work (&intel_crtc->mmio_flip.work); + mmio_flip->status =INTEL_MMIO_FLIP_WORK_SCHEDULED ; ring->irq_put (ring); } }@@ -9400,7 +9419,7 @@ static int intel_queue_mmio_flip(struct drm_device *dev,struct intel_crtc *intel_crtc =to_intel_crtc (crtc);int ret; -if (WARN_ON (intel_crtc->mmio_flip.seqno)) +if (WARN_ON (intel_crtc->mmio_flip.status !=INTEL_MMIO_FLIP_IDLE ))return -EBUSY ; ret =intel_postpone_flip (obj);@@ -9412,6 +9431,7 @@ static int intel_queue_mmio_flip(struct drm_device *dev, }spin_lock_irq (&dev_priv->mmio_flip_lock); + intel_crtc->mmio_flip.status =INTEL_MMIO_FLIP_WAIT_RING ; intel_crtc->mmio_flip.seqno = obj->last_write_seqno; intel_crtc->mmio_flip.ring_id = obj->ring->id;spin_unlock_irq (&dev_priv->mmio_flip_lock);@@ -11883,6 +11903,8 @@ static void intel_crtc_init(struct drm_device *dev, int pipe) dev_priv->plane_to_crtc_mapping[intel_crtc->plane] = &intel_crtc->base; dev_priv->pipe_to_crtc_mapping[intel_crtc->pipe] = &intel_crtc->base; +INIT_WORK (&intel_crtc->mmio_flip.work, intel_mmio_flip_work_func); +drm_crtc_helper_add (&intel_crtc->base, &intel_helper_funcs);WARN_ON (drm_crtc_index (&intel_crtc->base) != intel_crtc->pipe);drivers/gpu/drm/i915/intel_drv.h +11
-1@@ -399,9 +399,17 @@ struct intel_pipe_wm {bool sprites_scaled; }; +enum intel_mmio_flip_status { +INTEL_MMIO_FLIP_IDLE =0 , +INTEL_MMIO_FLIP_WAIT_RING , +INTEL_MMIO_FLIP_WORK_SCHEDULED , +}; +struct intel_mmio_flip {u32 seqno;u32 ring_id; +enum intel_mmio_flip_status status; +struct work_struct work; };struct intel_crtc {@@ -1168,7 +1176,9 @@ int intel_sprite_set_colorkey(struct drm_device *dev, void *data, struct drm_file *file_priv);int intel_sprite_get_colorkey (struct drm_device *dev,void *data,struct drm_file *file_priv); - +bool intel_pipe_update_start (struct intel_crtc *crtc, +uint32_t *start_vbl_count); +void intel_pipe_update_end (struct intel_crtc *crtc,u32 start_vbl_count);/* intel_tv.c */ void intel_tv_init (struct drm_device *dev);drivers/gpu/drm/i915/intel_sprite.c +2
-3@@ -62,7 +62,7 @@ static int usecs_to_scanlines(const struct drm_display_mode *mode, int usecs)* * Return: true if the call was successful */ -static bool intel_pipe_update_start (struct intel_crtc *crtc,uint32_t *start_vbl_count) +bool intel_pipe_update_start (struct intel_crtc *crtc,uint32_t *start_vbl_count) {struct drm_device *dev = crtc->base.dev;const struct drm_display_mode *mode = &crtc->config.adjusted_mode;@@ -135,7 +135,7 @@ static bool intel_pipe_update_start(struct intel_crtc *crtc, uint32_t *start_vbl* re-enables interrupts and verifies the update was actually completed * before a vblank using the value of @start_vbl_count. */ -static void intel_pipe_update_end (struct intel_crtc *crtc,u32 start_vbl_count) +void intel_pipe_update_end (struct intel_crtc *crtc,u32 start_vbl_count) {struct drm_device *dev = crtc->base.dev;enum pipe pipe = crtc->pipe; --1.9.1
Quoted 7 lines
Quoted 4 lines
_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
---------------------------------------------------------------------
Intel Finland Oy
Registered Address: PL 281, 00181 Helsinki Business Identity Code: 0357606 - 4 Domiciled in Helsinki
This e-mail and any attachments may contain confidential material for the sole use of the intended recipient(s). Any review or distribution by others is strictly prohibited. If you are not the intended recipient, please contact the sender and delete all copies.
_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Re: [PATCH 3/3] drm/i915: Use vblank evade mechanism in mmio_flip
In reply to Ander Conselvan de Oliveiradrivers/gpu/drm/i915/intel_display.c static int intel_queue_mmio_flip(struct drm_device *dev, · line 9423
Quoted 7 lines · Ander Conselvan de Oliveira
drivers/gpu/drm/i915/intel_display.c +1
-1@@ -9400,7 +9419,7 @@ static int intel_queue_mmio_flip(struct drm_device *dev,struct intel_crtc *intel_crtc =to_intel_crtc (crtc);int ret; -if (WARN_ON (intel_crtc->mmio_flip.seqno)) +if (WARN_ON (intel_crtc->mmio_flip.status !=INTEL_MMIO_FLIP_IDLE ))return -EBUSY ;
Ok I've merged the patch, but I think this check is wrong. do_mmio_flip only sets this to idle _after_ the hw register writing is done. Which means the flip could complete and userspace could receive the event all before we set status to IDLE. Which means you can WARN and return -EBUSY here when the flip definitely completed.
So either clear IDLE at the head of do_mmio_flip before doing anything, or drop this state again. After all the previous seqno check only looked for waiting or not. tbh I'm not even sure whether this buys us anything at all
- we already check that the flip completed, which should ensure ordering. I think we could just rip out mmio_flip.status completely.
Can you pls do a fixup patch?
Thanks, Daniel
Signature · 7 lines
Daniel Vetter Software Engineer, Intel Corporation +41 (0) 79 365 57 48 - http://blog.ffwll.ch _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Re: [PATCH 3/3] drm/i915: Use vblank evade mechanism in mmio_flip
Quoted 15 lines · Daniel Vetter
drivers/gpu/drm/i915/intel_display.c static int intel_queue_mmio_flip(struct drm_device *dev, · line 9423
Quoted 7 lines · Ander Conselvan de Oliveira
drivers/gpu/drm/i915/intel_display.c +1
-1@@ -9400,7 +9419,7 @@ static int intel_queue_mmio_flip(struct drm_device *dev,struct intel_crtc *intel_crtc =to_intel_crtc (crtc);int ret; -if (WARN_ON (intel_crtc->mmio_flip.seqno)) +if (WARN_ON (intel_crtc->mmio_flip.status !=INTEL_MMIO_FLIP_IDLE ))return -EBUSY ;Ok I've merged the patch, but I think this check is wrong.
do_mmio_fliponly sets this to idle _after_ the hw register writing is done. Which means the flip could complete and userspace could receive the event all before we set status to IDLE. Which means you can WARN and return-EBUSYhere when the flip definitely completed.
Quoted 7 lines
So either clear IDLE at the head of
do_mmio_flipbefore doing anything, or drop this state again. After all the previous seqno check only looked for waiting or not. tbh I'm not even sure whether this buys us anything at all
- we already check that the flip completed, which should ensure ordering. I think we could just rip out mmio_flip.status completely.Can you pls do a fixup patch?
A better strategy would be to use the generic seqno mechanism for the flip from a worker which then wouldn't need this extra vblank state machinery on top of the vblank evade...
-Chris
Signature · 5 lines
Chris Wilson, Intel Open Source Technology Centre _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH 1/1 drm/i915: Make mmio flip wait for seqno in the work function
This simplifies the code quite a bit compared to iterating over all rings during the ring interrupt.
Also, it allows us to drop the mmio_flip spinlock, since the mmio_flip struct is only accessed in two places. The first is when the flip is queued and the other when the mmio writes are done. Since a flip cannot be queued while there is a pending flip, the two paths shouldn't ever run in parallel. We might need to revisit that if support for replacing flips is implemented though.
---
I'm not sure if locking dev->struct_mutex in the work function might have any ill effects, so I'd appreciate if someone could enlighten me.
Thanks,
Ander
--- drivers/gpu/drm/i915/i915_irq.c | 3 -- drivers/gpu/drm/i915/intel_display.c | 91 +++++------------------------------- drivers/gpu/drm/i915/intel_drv.h | 9 +--- 3 files changed, 13 insertions(+), 90 deletions(-)
drivers/gpu/drm/i915/i915_irq.c +0 -3
@@ -979,9 +979,6 @@ static void notify_ring(struct drm_device *dev,trace_i915_gem_request_complete (ring); -if (drm_core_check_feature (dev,DRIVER_MODESET )) -intel_notify_mmio_flip (ring); -wake_up_all (&ring->irq_queue);i915_queue_hangcheck (dev); }
drivers/gpu/drm/i915/intel_display.c +12 -79
117 lines not on this page · raw message
drivers/gpu/drm/i915/intel_drv.h +1 -8
@@ -399,16 +399,9 @@ struct intel_pipe_wm {bool sprites_scaled; }; -enum intel_mmio_flip_status { -INTEL_MMIO_FLIP_IDLE =0 , -INTEL_MMIO_FLIP_WAIT_RING , -INTEL_MMIO_FLIP_WORK_SCHEDULED , -}; -struct intel_mmio_flip {u32 seqno; -u32 ring_id; -enum intel_mmio_flip_status status; +struct intel_engine_cs *ring;struct work_struct work; };
Signature · 6 lines
1.8.3.2 _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Re: [PATCH] drm/i915: Make mmio flip wait for seqno in the work function
Quoted 10 lines · Ander Conselvan de Oliveira
This simplifies the code quite a bit compared to iterating over all rings during the ring interrupt.
Also, it allows us to drop the
mmio_flipspinlock, since themmio_flipstruct is only accessed in two places. The first is when the flip is queued and the other when the mmio writes are done. Since a flip cannot be queued while there is a pending flip, the two paths shouldn't ever run in parallel. We might need to revisit that if support for replacing flips is implemented though.
Quoted 5 lines
Signed-off-by Ander Conselvan de Oliveira <[email protected]>---
I'm not sure if locking
dev->struct_mutexin the work function might have any ill effects, so I'd appreciate if someone could enlighten me.
Good news is you can wait on the seqno without holding any locks. You need to use the lower level entry point __wait_seqno() though.
Overall it looked good.
-Chris
Signature · 5 lines
Chris Wilson, Intel Open Source Technology Centre _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Re: [PATCH] drm/i915: Make mmio flip wait for seqno in the work function
Quoted 11 lines · Chris Wilson
Quoted 10 lines · Ander Conselvan de Oliveira
This simplifies the code quite a bit compared to iterating over all rings during the ring interrupt.
Also, it allows us to drop the
mmio_flipspinlock, since themmio_flipstruct is only accessed in two places. The first is when the flip is queued and the other when the mmio writes are done. Since a flip cannot be queued while there is a pending flip, the two paths shouldn't ever run in parallel. We might need to revisit that if support for replacing flips is implemented though.
Quoted 8 lines
Quoted 5 lines
Signed-off-by Ander Conselvan de Oliveira <[email protected]>---
I'm not sure if locking
dev->struct_mutexin the work function might have any ill effects, so I'd appreciate if someone could enlighten me.Good news is you can wait on the seqno without holding any locks. You need to use the lower level entry point
__wait_seqno()though.
I considered the fact that __wait_seqno() is static as a warning that I shouldn't use it directly. Should I just change that so I can use it intel_display.c?
The other reason I avoided it is because I didn't really understand how the barrier for reading the reset_counter should work. Is it sufficient that I do
atomic_read(&dev_priv->gpu_error.reset_counter))
before calling __wait_seqno() or is there something more to it?
Thanks,
ander
---------------------------------------------------------------------
Intel Finland Oy
Registered Address: PL 281, 00181 Helsinki Business Identity Code: 0357606 - 4 Domiciled in Helsinki
This e-mail and any attachments may contain confidential material for the sole use of the intended recipient(s). Any review or distribution by others is strictly prohibited. If you are not the intended recipient, please contact the sender and delete all copies.
_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Re: [PATCH] drm/i915: Make mmio flip wait for seqno in the work function
Quoted 25 lines · Ander Conselvan de Oliveira
Quoted 11 lines · Chris Wilson
Quoted 10 lines · Ander Conselvan de Oliveira
This simplifies the code quite a bit compared to iterating over all rings during the ring interrupt.
Also, it allows us to drop the
mmio_flipspinlock, since themmio_flipstruct is only accessed in two places. The first is when the flip is queued and the other when the mmio writes are done. Since a flip cannot be queued while there is a pending flip, the two paths shouldn't ever run in parallel. We might need to revisit that if support for replacing flips is implemented though.Quoted 8 lines
Quoted 5 lines
Signed-off-by Ander Conselvan de Oliveira <[email protected]>---
I'm not sure if locking
dev->struct_mutexin the work function might have any ill effects, so I'd appreciate if someone could enlighten me.Good news is you can wait on the seqno without holding any locks. You need to use the lower level entry point
__wait_seqno()though.I considered the fact that
__wait_seqno()is static as a warning that I shouldn't use it directly. Should I just change that so I can use itintel_display.c?
Quoted 7 lines
The other reason I avoided it is because I didn't really understand how the barrier for reading the
reset_countershould work. Is it sufficient that I do
atomic_read(&dev_priv->gpu_error.reset_counter))before calling
__wait_seqno()or is there something more to it?
We should already have a reset counter associated with the flip (at least I do...) But yes, the least you need to do is pass down the current atomic_read(&reset_counter).
That it is __wait_seqno() is indeed meant to make you think twice before using it, but really the only problem with is the name and cumbersome arguments. I have no qualms about renaming it as __i915_wait_seqno() and using it here - it is what I settled on in the requests conversion. -Chris
Signature · 5 lines
Chris Wilson, Intel Open Source Technology Centre _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH 1/2 drm/i915: Make __wait_seqno non-static and rename to __i915_wait_seqno
So that it can be used by the flip code to wait for rendering without holding any locks.
--- drivers/gpu/drm/i915/i915_drv.h | 5 +++++ drivers/gpu/drm/i915/i915_gem.c | 20 +++++++++++--------- 2 files changed, 16 insertions(+), 9 deletions(-)
drivers/gpu/drm/i915/i915_drv.h +5 -0
@@ -2535,6 +2535,11 @@ int __i915_add_request(struct intel_engine_cs *ring, u32 *seqno);#define i915_add_request (ring, seqno) \ __i915_add_request(ring, NULL, NULL, seqno) +int __i915_wait_seqno (struct intel_engine_cs *ring,u32 seqno, +unsigned reset_counter, +bool interruptible, +s64 *timeout, +struct drm_i915_file_private *file_priv);int __must_check i915_wait_seqno (struct intel_engine_cs *ring,uint32_t seqno);int i915_gem_fault (struct vm_area_struct *vma,struct vm_fault *vmf);
drivers/gpu/drm/i915/i915_gem.c +11 -9
@@ -1134,7 +1134,7 @@ static bool can_wait_boost(struct drm_i915_file_private *file_priv) }/** -* __wait_seqno - wait until execution of seqno has finished +* __i915_wait_seqno - wait until execution of seqno has finished * @ring: the ring expected to report seqno * @seqno: duh! * @reset_counter: reset sequence associated with the given seqno
@@ -1151,7 +1151,7 @@ static bool can_wait_boost(struct drm_i915_file_private *file_priv)* Returns 0 if the seqno was found within the alloted time. Else returns the * errno with remaining time filled in timeout argument. */ -static int __wait_seqno(struct intel_engine_cs *ring, u32 seqno, +int __i915_wait_seqno(struct intel_engine_cs *ring, u32 seqno, unsigned reset_counter, bool interruptible, s64 *timeout,
@@ -1262,6 +1262,7 @@ i915_wait_seqno(struct intel_engine_cs *ring, uint32_t seqno)struct drm_device *dev = ring->dev;struct drm_i915_private *dev_priv = dev->dev_private;bool interruptible = dev_priv->mm.interruptible; +unsigned reset_counter;int ret;BUG_ON (!mutex_is_locked (&dev->struct_mutex));
@@ -1275,9 +1276,9 @@ i915_wait_seqno(struct intel_engine_cs *ring, uint32_t seqno)if (ret)return ret; -return __wait_seqno (ring, seqno, -atomic_read (&dev_priv->gpu_error.reset_counter), - interruptible,NULL ,NULL ); + reset_counter =atomic_read (&dev_priv->gpu_error.reset_counter); +return __i915_wait_seqno (ring, seqno, reset_counter, interruptible, +NULL ,NULL ); } static int
@@ -1353,7 +1354,8 @@ i915_gem_object_wait_rendering__nonblocking(struct drm_i915_gem_object *obj, reset_counter =atomic_read (&dev_priv->gpu_error.reset_counter);mutex_unlock (&dev->struct_mutex); - ret =__wait_seqno (ring, seqno, reset_counter, true,NULL , file_priv); + ret =__i915_wait_seqno (ring, seqno, reset_counter, true,NULL , + file_priv);mutex_lock (&dev->struct_mutex);if (ret)return ret;
@@ -2847,8 +2849,8 @@ i915_gem_wait_ioctl(struct drm_device *dev, void *data, struct drm_file *file) reset_counter =atomic_read (&dev_priv->gpu_error.reset_counter);mutex_unlock (&dev->struct_mutex); -return __wait_seqno (ring, seqno, reset_counter, true, &args->timeout_ns, - file->driver_priv); +return __i915_wait_seqno (ring, seqno, reset_counter, true, + &args->timeout_ns, file->driver_priv); out:drm_gem_object_unreference (&obj->base);
@@ -4013,7 +4015,7 @@ i915_gem_ring_throttle(struct drm_device *dev, struct drm_file *file)if (seqno ==0 )return 0 ; - ret =__wait_seqno (ring, seqno, reset_counter, true,NULL ,NULL ); + ret =__i915_wait_seqno (ring, seqno, reset_counter, true,NULL ,NULL );if (ret ==0 )queue_delayed_work (dev_priv->wq, &dev_priv->mm.retire_work,0 );
Signature · 6 lines
1.8.3.2 _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH 2/2 drm/i915: Make mmio flip wait for seqno in the work function
This simplifies the code quite a bit compared to iterating over all rings during the ring interrupt.
Also, it allows us to drop the mmio_flip spinlock, since the mmio_flip struct is only accessed in two places. The first is when the flip is queued and the other when the mmio writes are done. Since a flip cannot be queued while there is a pending flip, the two paths shouldn't ever run in parallel. We might need to revisit that if support for replacing flips is implemented though.
v2: Don't hold dev->struct_mutext while waiting (Chris)
--- drivers/gpu/drm/i915/i915_irq.c | 3 -- drivers/gpu/drm/i915/intel_display.c | 90 +++++------------------------------- drivers/gpu/drm/i915/intel_drv.h | 9 +--- 3 files changed, 12 insertions(+), 90 deletions(-)
drivers/gpu/drm/i915/i915_irq.c +0 -3
@@ -979,9 +979,6 @@ static void notify_ring(struct drm_device *dev,trace_i915_gem_request_complete (ring); -if (drm_core_check_feature (dev,DRIVER_MODESET )) -intel_notify_mmio_flip (ring); -wake_up_all (&ring->irq_queue);i915_queue_hangcheck (dev); }
drivers/gpu/drm/i915/intel_display.c +11 -79
116 lines not on this page · raw message
drivers/gpu/drm/i915/intel_drv.h +1 -8
@@ -399,16 +399,9 @@ struct intel_pipe_wm {bool sprites_scaled; }; -enum intel_mmio_flip_status { -INTEL_MMIO_FLIP_IDLE =0 , -INTEL_MMIO_FLIP_WAIT_RING , -INTEL_MMIO_FLIP_WORK_SCHEDULED , -}; -struct intel_mmio_flip {u32 seqno; -u32 ring_id; -enum intel_mmio_flip_status status; +struct intel_engine_cs *ring;struct work_struct work; };
Signature · 6 lines
1.8.3.2 _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Re: [PATCH 2/2] drm/i915: Make mmio flip wait for seqno in the work function
Quoted 53 lines · Ander Conselvan de Oliveira
drivers/gpu/drm/i915/intel_display.c +1
-40@@ -9424,73 +9424,24 @@ static void intel_do_mmio_flip(struct intel_crtc *intel_crtc)if (atomic_update)intel_pipe_update_end (intel_crtc, start_vbl_count); - -spin_lock_irq (&dev_priv->mmio_flip_lock); - intel_crtc->mmio_flip.status =INTEL_MMIO_FLIP_IDLE ; -spin_unlock_irq (&dev_priv->mmio_flip_lock); }static void intel_mmio_flip_work_func (struct work_struct *work) {struct intel_crtc *intel_crtc = container_of(work, struct intel_crtc, mmio_flip.work); - -intel_do_mmio_flip (intel_crtc); -} - -static int intel_postpone_flip (struct drm_i915_gem_object *obj) -{struct intel_engine_cs *ring; -int ret; - -lockdep_assert_held (&obj->base.dev->struct_mutex); - -if (!obj->last_write_seqno) -return 0 ; - - ring = obj->ring; - -if (i915_seqno_passed (ring->get_seqno (ring, true), - obj->last_write_seqno)) -return 0 ; - - ret =i915_gem_check_olr (ring, obj->last_write_seqno); -if (ret) -return ret; - -if (WARN_ON (!ring->irq_get (ring))) -return 0 ; - -return 1 ; -} +uint32_t seqno; -void intel_notify_mmio_flip (struct intel_engine_cs *ring) -{ -struct drm_i915_private *dev_priv =to_i915 (ring->dev); -struct intel_crtc *intel_crtc; -unsigned long irq_flags; -u32 seqno; - - seqno = ring->get_seqno (ring, false);
drivers/gpu/drm/i915/intel_display.c static void intel_do_mmio_flip(struct intel_crtc *intel_crtc) · line 9442
Quoted 10 lines
drivers/gpu/drm/i915/intel_display.c +6
-3+ seqno = intel_crtc->mmio_flip.seqno; + ring = intel_crtc->mmio_flip.ring; -spin_lock_irqsave (&dev_priv->mmio_flip_lock, irq_flags); -for_each_intel_crtc (ring->dev, intel_crtc) { -struct intel_mmio_flip *mmio_flip; +if (seqno) +WARN_ON (__i915_wait_seqno (ring, seqno, + intel_crtc->reset_counter, + true,NULL ,NULL ) !=0 );
interruptible needs to be false
That's the only thing I spotted wrong.
-Chris
Signature · 5 lines
Chris Wilson, Intel Open Source Technology Centre _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH 1/1 drm/i915: Make mmio flip wait for seqno in the work function
This simplifies the code quite a bit compared to iterating over all rings during the ring interrupt.
Also, it allows us to drop the mmio_flip spinlock, since the mmio_flip struct is only accessed in two places. The first is when the flip is queued and the other when the mmio writes are done. Since a flip cannot be queued while there is a pending flip, the two paths shouldn't ever run in parallel. We might need to revisit that if support for replacing flips is implemented though.
v2: Don't hold dev->struct_mutext while waiting (Chris)
v3: Make the wait uninterruptable (Chris)
--- drivers/gpu/drm/i915/i915_irq.c | 3 -- drivers/gpu/drm/i915/intel_display.c | 90 +++++------------------------------- drivers/gpu/drm/i915/intel_drv.h | 9 +--- 3 files changed, 12 insertions(+), 90 deletions(-)
drivers/gpu/drm/i915/i915_irq.c +0 -3
@@ -979,9 +979,6 @@ static void notify_ring(struct drm_device *dev,trace_i915_gem_request_complete (ring); -if (drm_core_check_feature (dev,DRIVER_MODESET )) -intel_notify_mmio_flip (ring); -wake_up_all (&ring->irq_queue);i915_queue_hangcheck (dev); }
drivers/gpu/drm/i915/intel_display.c +11 -79
116 lines not on this page · raw message
drivers/gpu/drm/i915/intel_drv.h +1 -8
@@ -399,16 +399,9 @@ struct intel_pipe_wm {bool sprites_scaled; }; -enum intel_mmio_flip_status { -INTEL_MMIO_FLIP_IDLE =0 , -INTEL_MMIO_FLIP_WAIT_RING , -INTEL_MMIO_FLIP_WORK_SCHEDULED , -}; -struct intel_mmio_flip {u32 seqno; -u32 ring_id; -enum intel_mmio_flip_status status; +struct intel_engine_cs *ring;struct work_struct work; };
Signature · 6 lines
1.8.3.2 _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Re: [PATCH] drm/i915: Make mmio flip wait for seqno in the work function
Quoted 10 lines · Ander Conselvan de Oliveira
This simplifies the code quite a bit compared to iterating over all rings during the ring interrupt.
Also, it allows us to drop the
mmio_flipspinlock, since themmio_flipstruct is only accessed in two places. The first is when the flip is queued and the other when the mmio writes are done. Since a flip cannot be queued while there is a pending flip, the two paths shouldn't ever run in parallel. We might need to revisit that if support for replacing flips is implemented though.
Quoted 5 lines
v2: Don't hold
dev->struct_mutextwhile waiting (Chris)v3: Make the wait uninterruptable (Chris)
Signed-off-by Ander Conselvan de Oliveira <[email protected]>
drivers/gpu/drm/i915/intel_display.c static void intel_do_mmio_flip(struct intel_crtc *intel_crtc) · line 9442
Quoted 3 lines
drivers/gpu/drm/i915/intel_display.c +3
-0+WARN_ON (__i915_wait_seqno (ring, seqno, + intel_crtc->reset_counter, + false,NULL ,NULL ) !=0 );
Should probably mention the caveat that this wants RPS boost tweaks, which have been posted to the list as well.
-Chris
Signature · 5 lines
Chris Wilson, Intel Open Source Technology Centre _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Daniel Vetter
AppliedRe: [PATCH] drm/i915: Make mmio flip wait for seqno in the work function
Quoted 11 lines · Chris Wilson
Quoted 10 lines · Ander Conselvan de Oliveira
This simplifies the code quite a bit compared to iterating over all rings during the ring interrupt.
Also, it allows us to drop the
mmio_flipspinlock, since themmio_flipstruct is only accessed in two places. The first is when the flip is queued and the other when the mmio writes are done. Since a flip cannot be queued while there is a pending flip, the two paths shouldn't ever run in parallel. We might need to revisit that if support for replacing flips is implemented though.
Quoted 3 lines
Quoted 3 lines
v2: Don't hold
dev->struct_mutextwhile waiting (Chris)v3: Make the wait uninterruptable (Chris)
Can we actually send singals to kworker threads? Just out of curiosity ...
Quoted 3 lines
Quoted 1 line
Signed-off-by Ander Conselvan de Oliveira <[email protected]>Reviewed-by Chris Wilson <[email protected]>
Queued for -next, thanks for the patch.
Quoted 6 lines
drivers/gpu/drm/i915/intel_display.c static void intel_do_mmio_flip(struct intel_crtc *intel_crtc) · line 9442
Quoted 3 lines
drivers/gpu/drm/i915/intel_display.c +3
-0+WARN_ON (__i915_wait_seqno (ring, seqno, + intel_crtc->reset_counter, + false,NULL ,NULL ) !=0 );Should probably mention the caveat that this wants RPS boost tweaks, which have been posted to the list as well.
Yeah I guess we don't want to boost here by default (since userspace might send the pageflip right after having queued the pageflip), but only when we indeed missed the next vblank. So I guess we should disable the boosting here and get your pageflip booster in. Can you please rebase/adapt and Ander could perhaps review?
-Daniel
Signature · 7 lines
Daniel Vetter Software Engineer, Intel Corporation +41 (0) 79 365 57 48 - http://blog.ffwll.ch _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Re: [PATCH] drm/i915: Make mmio flip wait for seqno in the work function
Quoted 12 lines · Daniel Vetter
Quoted 11 lines · Chris Wilson
Quoted 10 lines · Ander Conselvan de Oliveira
This simplifies the code quite a bit compared to iterating over all rings during the ring interrupt.
Also, it allows us to drop the
mmio_flipspinlock, since themmio_flipstruct is only accessed in two places. The first is when the flip is queued and the other when the mmio writes are done. Since a flip cannot be queued while there is a pending flip, the two paths shouldn't ever run in parallel. We might need to revisit that if support for replacing flips is implemented though.
Quoted 5 lines
Quoted 3 lines
Quoted 3 lines
v2: Don't hold
dev->struct_mutextwhile waiting (Chris)v3: Make the wait uninterruptable (Chris)
Can we actually send singals to kworker threads? Just out of curiosity ...
Some, at least. Probably not the system workqueues we use here, but interruptible=false also has the semantics of "no errors. please". Definitely useful here.
Quoted 7 lines
Quoted 6 lines
drivers/gpu/drm/i915/intel_display.c static void intel_do_mmio_flip(struct intel_crtc *intel_crtc) · line 9442
Quoted 3 lines
drivers/gpu/drm/i915/intel_display.c +3
-0+WARN_ON (__i915_wait_seqno (ring, seqno, + intel_crtc->reset_counter, + false,NULL ,NULL ) !=0 );Should probably mention the caveat that this wants RPS boost tweaks, which have been posted to the list as well.
Quoted 5 lines
Yeah I guess we don't want to boost here by default (since userspace might send the pageflip right after having queued the pageflip), but only when we indeed missed the next vblank. So I guess we should disable the boosting here and get your pageflip booster in. Can you please rebase/adapt and Ander could perhaps review?
Yes.
-Chris
Signature · 5 lines
Chris Wilson, Intel Open Source Technology Centre _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Quoted 19 lines · Ander Conselvan de Oliveira
Signed-off-by Ander Conselvan de Oliveira <[email protected]>--- drivers/gpu/drm/i915/intel_sprite.c | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+)drivers/gpu/drm/i915/intel_sprite.c +6
-0@@ -46,6 +46,22 @@ static int usecs_to_scanlines(const struct drm_display_mode *mode, int usecs)return DIV_ROUND_UP (usecs * mode->crtc_clock,1000 * mode->crtc_htotal); } +/** +* 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 +* +* Mark the start of an update to pipe registers that should be updated
drivers/gpu/drm/i915/intel_sprite.c static int usecs_to_scanlines(const struct drm_display_mode *mode, int usecs) · line 64
Quoted 10 lines
drivers/gpu/drm/i915/intel_sprite.c +10
-0+* atomically regarding vblank. If the next vblank will happens within +* the next 100 us, this function waits until the vblank passes. +* +* 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. +* +* Return: true if the call was successful +*/
It's nice that people now go overboard with kerneldoc, but I think we need to strike a good balance. And in general I think documenting static inline functions isn't worth it - they really should be self-explanatory as-is.
Documentation is imo only really useful for the bigger stuff, which usually means it's used in a few places all over. So non-static functions.
This one here is a bit a corner-case since it's more of a generic piece of infrastructure. But otoh I think in the end we'll have exactly one caller of these functions for all atomic plane updates we'll need. Everyone else (legacy code, modeset code, ...) will just call that higher-level function. Not sure what to do here.
-Daniel
Signature · 7 lines
Daniel Vetter Software Engineer, Intel Corporation +41 (0) 79 365 57 48 - http://blog.ffwll.ch _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Quoted 35 lines · Daniel Vetter
Quoted 19 lines · Ander Conselvan de Oliveira
Signed-off-by Ander Conselvan de Oliveira <[email protected]>--- drivers/gpu/drm/i915/intel_sprite.c | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+)drivers/gpu/drm/i915/intel_sprite.c +6
-0@@ -46,6 +46,22 @@ static int usecs_to_scanlines(const struct drm_display_mode *mode, int usecs)return DIV_ROUND_UP (usecs * mode->crtc_clock,1000 * mode->crtc_htotal); } +/** +* 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 +* +* Mark the start of an update to pipe registers that should be updated drivers/gpu/drm/i915/intel_sprite.c static int usecs_to_scanlines(const struct drm_display_mode *mode, int usecs) · line 64
Quoted 10 lines
drivers/gpu/drm/i915/intel_sprite.c +10
-0+* atomically regarding vblank. If the next vblank will happens within +* the next 100 us, this function waits until the vblank passes. +* +* 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. +* +* Return: true if the call was successful +*/ It's nice that people now go overboard with kerneldoc, but I think we need to strike a good balance. And in general I think documenting static inline functions isn't worth it - they really should be self-explanatory as-is.
Quoted 8 lines
Documentation is imo only really useful for the bigger stuff, which usually means it's used in a few places all over. So non-static functions.
This one here is a bit a corner-case since it's more of a generic piece of infrastructure. But otoh I think in the end we'll have exactly one caller of these functions for all atomic plane updates we'll need. Everyone else (legacy code, modeset code, ...) will just call that higher-level function. Not sure what to do here.
s/**/*/ ?
Cheers,
Ander
---------------------------------------------------------------------
Intel Finland Oy
Registered Address: PL 281, 00181 Helsinki Business Identity Code: 0357606 - 4 Domiciled in Helsinki
This e-mail and any attachments may contain confidential material for the sole use of the intended recipient(s). Any review or distribution by others is strictly prohibited. If you are not the intended recipient, please contact the sender and delete all copies.
_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Paulo Zanoni
Reviewed-by2014-11-03 10:33 GMT-02:00 Daniel Vetter <[email protected]>:
Quoted 26 lines · Ander Conselvan de Oliveira
Quoted 25 lines
Signed-off-by Ander Conselvan de Oliveira <[email protected]>--- drivers/gpu/drm/i915/intel_sprite.c | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+)drivers/gpu/drm/i915/intel_sprite.c +12
-0@@ -46,6 +46,22 @@ static int usecs_to_scanlines(const struct drm_display_mode *mode, int usecs)return DIV_ROUND_UP (usecs * mode->crtc_clock,1000 * mode->crtc_htotal); } +/** +* 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 +* +* Mark the start of an update to pipe registers that should be updated +* atomically regarding vblank. If the next vblank will happens within +* the next 100 us, this function waits until the vblank passes. +* +* 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
Quoted 8 lines
drivers/gpu/drm/i915/intel_sprite.c static int usecs_to_scanlines(const struct drm_display_mode *mode, int usecs) · line 64
Quoted 4 lines
drivers/gpu/drm/i915/intel_sprite.c +4
-0+* supplied to intel_pipe_update_end() for error checking. +* +* Return: true if the call was successful +*/ It's nice that people now go overboard with kerneldoc, but I think we need to strike a good balance. And in general I think documenting static inline functions isn't worth it - they really should be self-explanatory as-is.
But patch 3 exports these functions and uses them from another file.
Quoted 3 lines
Documentation is imo only really useful for the bigger stuff, which usually means it's used in a few places all over. So non-static functions.
The comments he introduced are useful and helped me review patch 3 without having to look at the function implementation and waste 20 minutes wondering what it was supposed to do.
To me, this patch is an improvement to the codebase, so with or without the extra '*' chars:
Quoted 15 lines
This one here is a bit a corner-case since it's more of a generic piece of infrastructure. But otoh I think in the end we'll have exactly one caller of these functions for all atomic plane updates we'll need. Everyone else (legacy code, modeset code, ...) will just call that higher-level function. Not sure what to do here.
-Daniel
--
Daniel Vetter
Software Engineer, Intel Corporation
+41 (0) 79 365 57 48 - http://blog.ffwll.ch
_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Signature · 5 lines
Paulo Zanoni _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Quoted 36 lines · Paulo Zanoni
2014-11-03 10:33 GMT-02:00 Daniel Vetter <[email protected]>:
Quoted 26 lines · Ander Conselvan de Oliveira
Quoted 25 lines
Signed-off-by Ander Conselvan de Oliveira <[email protected]>--- drivers/gpu/drm/i915/intel_sprite.c | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+)drivers/gpu/drm/i915/intel_sprite.c +12
-0@@ -46,6 +46,22 @@ static int usecs_to_scanlines(const struct drm_display_mode *mode, int usecs)return DIV_ROUND_UP (usecs * mode->crtc_clock,1000 * mode->crtc_htotal); } +/** +* 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 +* +* Mark the start of an update to pipe registers that should be updated +* atomically regarding vblank. If the next vblank will happens within +* the next 100 us, this function waits until the vblank passes. +* +* 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 Quoted 8 lines
drivers/gpu/drm/i915/intel_sprite.c static int usecs_to_scanlines(const struct drm_display_mode *mode, int usecs) · line 64
Quoted 4 lines
drivers/gpu/drm/i915/intel_sprite.c +4
-0+* supplied to intel_pipe_update_end() for error checking. +* +* Return: true if the call was successful +*/ It's nice that people now go overboard with kerneldoc, but I think we need to strike a good balance. And in general I think documenting static inline functions isn't worth it - they really should be self-explanatory as-is.
Quoted 1 line
But patch 3 exports these functions and uses them from another file.
Ah, I've missed that, comment retracted ...
Quoted 5 lines
Quoted 4 lines
Documentation is imo only really useful for the bigger stuff, which usually means it's used in a few places all over. So non-static functions.
Quoted 7 lines
The comments he introduced are useful and helped me review patch 3 without having to look at the function implementation and waste 20 minutes wondering what it was supposed to do.
To me, this patch is an improvement to the codebase, so with or without the extra '*' chars:
Reviewed-by Paulo Zanoni <[email protected]>
... and patch merged.
Thanks, Daniel
Signature · 7 lines
Daniel Vetter Software Engineer, Intel Corporation +41 (0) 79 365 57 48 - http://blog.ffwll.ch _______________________________________________ Intel-gfx mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/intel-gfx