[igt-dev] [RFC PATCH 0/2] New subtest for VRR Flipline mode

[igt-dev] [RFC PATCH 0/2] New subtest for VRR Flipline mode

[bhanuprakash.modem]

From: Bhanuprakash Modem <bhanuprakash.modem@intel.com>

To validate Adaptive-Sync's Flipline mode, make sure that flips happen at
flipline decision boundary.

Example: if monitor vrr range is 40 - 60Hz and

* flip at refresh_rate > 60Hz:
        Flip should happen at the flipline boundary & returned refresh rate
        would be 60Hz.
* flip at refresh_rate == 50Hz:
        Flip should happen right away so returned refresh rate is 50Hz.
* flip at refresh_rate < 40Hz:
        Flip should happen at the vmax so the returned refresh rate
        would be 40Hz.

Bhanuprakash Modem (2):
  tests/kms_vrr: Use atomic API for page flip
  tests/kms_vrr: Add new subtest to validate Flipline mode

 tests/kms_vrr.c | 136 ++++++++++++++++++++++++++++++------------------
 1 file changed, 84 insertions(+), 52 deletions(-)

-- 
2.24.1.1.gb6d4d82bd5

_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

[igt-dev] [RFC PATCH 1/2] tests/kms_vrr: Use atomic API for page flip

[bhanuprakash.modem]

From: Bhanuprakash Modem <bhanuprakash.modem@intel.com>

We should avoid using drmModePageFlip as it'll only be used for
legacy drivers, instead, use igt_display_commit_atomic() API to
page flip for atomic display code path.

Cc: Harry Wentland <harry.wentland@amd.com>
Cc: Nicholas Kazlauskas <nicholas.kazlauskas@amd.com>
Cc: Manasi Navare <manasi.d.navare@intel.com>
Signed-off-by: Bhanuprakash Modem <bhanuprakash.modem@intel.com>
---
 tests/kms_vrr.c | 39 ++++++++++-----------------------------
 1 file changed, 10 insertions(+), 29 deletions(-)

diff --git a/tests/kms_vrr.c b/tests/kms_vrr.c
index 73115fef..0fe28931 100644
--- a/tests/kms_vrr.c
+++ b/tests/kms_vrr.c
@@ -126,11 +126,11 @@ static range_t get_vrr_range(data_t *data, igt_output_t *output)
 }
 
 /* Returns a suitable vrr test frequency. */
-static uint32_t get_test_rate_ns(data_t *data, igt_output_t *output)
+static uint64_t get_test_rate_ns(data_t *data, igt_output_t *output)
 {
 	drmModeModeInfo *mode = igt_output_get_mode(output);
 	range_t range;
-	uint32_t vtest;
+	uint64_t vtest;
 
 	/*
 	 * The frequency with the fastest convergence speed should be
@@ -210,32 +210,18 @@ wait_for_vblank(data_t *data, enum pipe pipe)
 	return get_vblank_event_ns(data);
 }
 
-/* Performs an asynchronous non-blocking page-flip on a pipe. */
-static int
+/* Performs an atomic non-blocking page-flip on a pipe. */
+static void
 do_flip(data_t *data, enum pipe pipe_id, igt_fb_t *fb)
 {
-	igt_pipe_t *pipe = &data->display.pipes[pipe_id];
-	int ret;
-
 	igt_set_timeout(1, "Scheduling page flip\n");
 
-	/*
-	 * Only the legacy flip ioctl supports async flips.
-	 * It's also non-blocking, but returns -EBUSY if flipping too fast.
-	 * 2x monitor tests will need async flips in the atomic API.
-	 */
-	do {
-		ret = drmModePageFlip(data->drm_fd, pipe->crtc_id,
-				      fb->fb_id,
-				      DRM_MODE_PAGE_FLIP_EVENT |
-				      DRM_MODE_PAGE_FLIP_ASYNC,
-				      data);
-	} while (ret == -EBUSY);
-
-	igt_assert_eq(ret, 0);
-	igt_reset_timeout();
+	igt_display_commit_atomic(&data->display,
+				  DRM_MODE_ATOMIC_NONBLOCK |
+				  DRM_MODE_PAGE_FLIP_EVENT,
+				  NULL);
 
-	return 0;
+	igt_reset_timeout();
 }
 
 /*
@@ -246,11 +232,6 @@ do_flip(data_t *data, enum pipe pipe_id, igt_fb_t *fb)
  * can arbitrarily restrict the bounds further than the absolute
  * min and max range. But VRR is really about extending the flip
  * to prevent stuttering or to match a source content rate.
- *
- * The only way to "present" at a fixed rate like userspace in a vendor
- * neutral manner is to do it with async flips. This avoids the need
- * to wait for next vblank and it should eventually converge at the
- * desired rate.
  */
 static uint32_t
 flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
@@ -271,7 +252,7 @@ flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
 		front = !front;
 		do_flip(data, pipe, front ? &data->fb1 : &data->fb0);
 
-		vblank_ns = get_vblank_event_ns(data);
+		vblank_ns = wait_for_vblank(data, pipe);
 		diff_ns = rate_ns - (vblank_ns - last_vblank_ns);
 		last_vblank_ns = vblank_ns;
 
-- 
2.24.1.1.gb6d4d82bd5

_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

Re: [igt-dev] [RFC PATCH 1/2] tests/kms_vrr: Use atomic API for page flip

[Manasi Navare]

On Mon, May 11, 2020 at 11:56:46AM +0530, bhanuprakash.modem@intel.com wrote:
> From: Bhanuprakash Modem <bhanuprakash.modem@intel.com>
> 
> We should avoid using drmModePageFlip as it'll only be used for
> legacy drivers, instead, use igt_display_commit_atomic() API to
> page flip for atomic display code path.
> 
> Cc: Harry Wentland <harry.wentland@amd.com>
> Cc: Nicholas Kazlauskas <nicholas.kazlauskas@amd.com>
> Cc: Manasi Navare <manasi.d.navare@intel.com>
> Signed-off-by: Bhanuprakash Modem <bhanuprakash.modem@intel.com>

I have tested this on i915 and the page flips are captured correctly with 
non blocking page flip requests using atomic_commit call.

@Harry, @Nicholas could you test this on AMD driver to make
sure its not breaking anything?

Manasi

> ---
>  tests/kms_vrr.c | 39 ++++++++++-----------------------------
>  1 file changed, 10 insertions(+), 29 deletions(-)
> 
> diff --git a/tests/kms_vrr.c b/tests/kms_vrr.c
> index 73115fef..0fe28931 100644
> --- a/tests/kms_vrr.c
> +++ b/tests/kms_vrr.c
> @@ -126,11 +126,11 @@ static range_t get_vrr_range(data_t *data, igt_output_t *output)
>  }
>  
>  /* Returns a suitable vrr test frequency. */
> -static uint32_t get_test_rate_ns(data_t *data, igt_output_t *output)
> +static uint64_t get_test_rate_ns(data_t *data, igt_output_t *output)
>  {
>  	drmModeModeInfo *mode = igt_output_get_mode(output);
>  	range_t range;
> -	uint32_t vtest;
> +	uint64_t vtest;
>  
>  	/*
>  	 * The frequency with the fastest convergence speed should be
> @@ -210,32 +210,18 @@ wait_for_vblank(data_t *data, enum pipe pipe)
>  	return get_vblank_event_ns(data);
>  }
>  
> -/* Performs an asynchronous non-blocking page-flip on a pipe. */
> -static int
> +/* Performs an atomic non-blocking page-flip on a pipe. */
> +static void
>  do_flip(data_t *data, enum pipe pipe_id, igt_fb_t *fb)
>  {
> -	igt_pipe_t *pipe = &data->display.pipes[pipe_id];
> -	int ret;
> -
>  	igt_set_timeout(1, "Scheduling page flip\n");
>  
> -	/*
> -	 * Only the legacy flip ioctl supports async flips.
> -	 * It's also non-blocking, but returns -EBUSY if flipping too fast.
> -	 * 2x monitor tests will need async flips in the atomic API.
> -	 */
> -	do {
> -		ret = drmModePageFlip(data->drm_fd, pipe->crtc_id,
> -				      fb->fb_id,
> -				      DRM_MODE_PAGE_FLIP_EVENT |
> -				      DRM_MODE_PAGE_FLIP_ASYNC,
> -				      data);
> -	} while (ret == -EBUSY);
> -
> -	igt_assert_eq(ret, 0);
> -	igt_reset_timeout();
> +	igt_display_commit_atomic(&data->display,
> +				  DRM_MODE_ATOMIC_NONBLOCK |
> +				  DRM_MODE_PAGE_FLIP_EVENT,
> +				  NULL);
>  
> -	return 0;
> +	igt_reset_timeout();
>  }
>  
>  /*
> @@ -246,11 +232,6 @@ do_flip(data_t *data, enum pipe pipe_id, igt_fb_t *fb)
>   * can arbitrarily restrict the bounds further than the absolute
>   * min and max range. But VRR is really about extending the flip
>   * to prevent stuttering or to match a source content rate.
> - *
> - * The only way to "present" at a fixed rate like userspace in a vendor
> - * neutral manner is to do it with async flips. This avoids the need
> - * to wait for next vblank and it should eventually converge at the
> - * desired rate.
>   */
>  static uint32_t
>  flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
> @@ -271,7 +252,7 @@ flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
>  		front = !front;
>  		do_flip(data, pipe, front ? &data->fb1 : &data->fb0);
>  
> -		vblank_ns = get_vblank_event_ns(data);
> +		vblank_ns = wait_for_vblank(data, pipe);
>  		diff_ns = rate_ns - (vblank_ns - last_vblank_ns);
>  		last_vblank_ns = vblank_ns;
>  
> -- 
> 2.24.1.1.gb6d4d82bd5
> 
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

Re: [igt-dev] [RFC PATCH 1/2] tests/kms_vrr: Use atomic API for page flip

[Modem, Bhanuprakash]

> -----Original Message-----
> From: Navare, Manasi D <manasi.d.navare@intel.com>
> Sent: Wednesday, June 3, 2020 12:41 AM
> To: Modem, Bhanuprakash <bhanuprakash.modem@intel.com>
> Cc: igt-dev@lists.freedesktop.org; harry.wentland@amd.com;
> nicholas.kazlauskas@amd.com; Kiran, Pichika Uday
> <pichika.uday.kiran@intel.com>
> Subject: Re: [RFC PATCH 1/2] tests/kms_vrr: Use atomic API for page flip
> 
> On Mon, May 11, 2020 at 11:56:46AM +0530, bhanuprakash.modem@intel.com
> wrote:
> > From: Bhanuprakash Modem <bhanuprakash.modem@intel.com>
> >
> > We should avoid using drmModePageFlip as it'll only be used for
> > legacy drivers, instead, use igt_display_commit_atomic() API to
> > page flip for atomic display code path.
> >
> > Cc: Harry Wentland <harry.wentland@amd.com>
> > Cc: Nicholas Kazlauskas <nicholas.kazlauskas@amd.com>
> > Cc: Manasi Navare <manasi.d.navare@intel.com>
> > Signed-off-by: Bhanuprakash Modem <bhanuprakash.modem@intel.com>
> 
> I have tested this on i915 and the page flips are captured correctly with
> non blocking page flip requests using atomic_commit call.
> 
> @Harry, @Nicholas could you test this on AMD driver to make
> sure its not breaking anything?
[Bhanu] 
@Harry, @Nicholas did you get a chance to check this patch?
> 
> Manasi
> 
> > ---
> >  tests/kms_vrr.c | 39 ++++++++++-----------------------------
> >  1 file changed, 10 insertions(+), 29 deletions(-)
> >
> > diff --git a/tests/kms_vrr.c b/tests/kms_vrr.c
> > index 73115fef..0fe28931 100644
> > --- a/tests/kms_vrr.c
> > +++ b/tests/kms_vrr.c
> > @@ -126,11 +126,11 @@ static range_t get_vrr_range(data_t *data,
> igt_output_t *output)
> >  }
> >
> >  /* Returns a suitable vrr test frequency. */
> > -static uint32_t get_test_rate_ns(data_t *data, igt_output_t *output)
> > +static uint64_t get_test_rate_ns(data_t *data, igt_output_t *output)
> >  {
> >  	drmModeModeInfo *mode = igt_output_get_mode(output);
> >  	range_t range;
> > -	uint32_t vtest;
> > +	uint64_t vtest;
> >
> >  	/*
> >  	 * The frequency with the fastest convergence speed should be
> > @@ -210,32 +210,18 @@ wait_for_vblank(data_t *data, enum pipe pipe)
> >  	return get_vblank_event_ns(data);
> >  }
> >
> > -/* Performs an asynchronous non-blocking page-flip on a pipe. */
> > -static int
> > +/* Performs an atomic non-blocking page-flip on a pipe. */
> > +static void
> >  do_flip(data_t *data, enum pipe pipe_id, igt_fb_t *fb)
> >  {
> > -	igt_pipe_t *pipe = &data->display.pipes[pipe_id];
> > -	int ret;
> > -
> >  	igt_set_timeout(1, "Scheduling page flip\n");
> >
> > -	/*
> > -	 * Only the legacy flip ioctl supports async flips.
> > -	 * It's also non-blocking, but returns -EBUSY if flipping too fast.
> > -	 * 2x monitor tests will need async flips in the atomic API.
> > -	 */
> > -	do {
> > -		ret = drmModePageFlip(data->drm_fd, pipe->crtc_id,
> > -				      fb->fb_id,
> > -				      DRM_MODE_PAGE_FLIP_EVENT |
> > -				      DRM_MODE_PAGE_FLIP_ASYNC,
> > -				      data);
> > -	} while (ret == -EBUSY);
> > -
> > -	igt_assert_eq(ret, 0);
> > -	igt_reset_timeout();
> > +	igt_display_commit_atomic(&data->display,
> > +				  DRM_MODE_ATOMIC_NONBLOCK |
> > +				  DRM_MODE_PAGE_FLIP_EVENT,
> > +				  NULL);
> >
> > -	return 0;
> > +	igt_reset_timeout();
> >  }
> >
> >  /*
> > @@ -246,11 +232,6 @@ do_flip(data_t *data, enum pipe pipe_id, igt_fb_t
> *fb)
> >   * can arbitrarily restrict the bounds further than the absolute
> >   * min and max range. But VRR is really about extending the flip
> >   * to prevent stuttering or to match a source content rate.
> > - *
> > - * The only way to "present" at a fixed rate like userspace in a vendor
> > - * neutral manner is to do it with async flips. This avoids the need
> > - * to wait for next vblank and it should eventually converge at the
> > - * desired rate.
> >   */
> >  static uint32_t
> >  flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
> > @@ -271,7 +252,7 @@ flip_and_measure(data_t *data, igt_output_t *output,
> enum pipe pipe,
> >  		front = !front;
> >  		do_flip(data, pipe, front ? &data->fb1 : &data->fb0);
> >
> > -		vblank_ns = get_vblank_event_ns(data);
> > +		vblank_ns = wait_for_vblank(data, pipe);
> >  		diff_ns = rate_ns - (vblank_ns - last_vblank_ns);
> >  		last_vblank_ns = vblank_ns;
> >
> > --
> > 2.24.1.1.gb6d4d82bd5
> >
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

Re: [igt-dev] [RFC PATCH 1/2] tests/kms_vrr: Use atomic API for page flip

[Navare, Manasi]

@Harry and @Nicholas, could you run kms_vrr IGT with this patch on AMD
to see that with teh atomic API, it doesnt break VRR on AMD?

Regards
Manasi

On Wed, Jul 01, 2020 at 09:16:59PM -0700, Modem, Bhanuprakash wrote:
> > -----Original Message-----
> > From: Navare, Manasi D <manasi.d.navare@intel.com>
> > Sent: Wednesday, June 3, 2020 12:41 AM
> > To: Modem, Bhanuprakash <bhanuprakash.modem@intel.com>
> > Cc: igt-dev@lists.freedesktop.org; harry.wentland@amd.com;
> > nicholas.kazlauskas@amd.com; Kiran, Pichika Uday
> > <pichika.uday.kiran@intel.com>
> > Subject: Re: [RFC PATCH 1/2] tests/kms_vrr: Use atomic API for page flip
> >
> > On Mon, May 11, 2020 at 11:56:46AM +0530, bhanuprakash.modem@intel.com
> > wrote:
> > > From: Bhanuprakash Modem <bhanuprakash.modem@intel.com>
> > >
> > > We should avoid using drmModePageFlip as it'll only be used for
> > > legacy drivers, instead, use igt_display_commit_atomic() API to
> > > page flip for atomic display code path.
> > >
> > > Cc: Harry Wentland <harry.wentland@amd.com>
> > > Cc: Nicholas Kazlauskas <nicholas.kazlauskas@amd.com>
> > > Cc: Manasi Navare <manasi.d.navare@intel.com>
> > > Signed-off-by: Bhanuprakash Modem <bhanuprakash.modem@intel.com>
> >
> > I have tested this on i915 and the page flips are captured correctly with
> > non blocking page flip requests using atomic_commit call.
> >
> > @Harry, @Nicholas could you test this on AMD driver to make
> > sure its not breaking anything?
> [Bhanu]
> @Harry, @Nicholas did you get a chance to check this patch?
> >
> > Manasi
> >
> > > ---
> > >  tests/kms_vrr.c | 39 ++++++++++-----------------------------
> > >  1 file changed, 10 insertions(+), 29 deletions(-)
> > >
> > > diff --git a/tests/kms_vrr.c b/tests/kms_vrr.c
> > > index 73115fef..0fe28931 100644
> > > --- a/tests/kms_vrr.c
> > > +++ b/tests/kms_vrr.c
> > > @@ -126,11 +126,11 @@ static range_t get_vrr_range(data_t *data,
> > igt_output_t *output)
> > >  }
> > >
> > >  /* Returns a suitable vrr test frequency. */
> > > -static uint32_t get_test_rate_ns(data_t *data, igt_output_t *output)
> > > +static uint64_t get_test_rate_ns(data_t *data, igt_output_t *output)
> > >  {
> > >  drmModeModeInfo *mode = igt_output_get_mode(output);
> > >  range_t range;
> > > -uint32_t vtest;
> > > +uint64_t vtest;
> > >
> > >  /*
> > >   * The frequency with the fastest convergence speed should be
> > > @@ -210,32 +210,18 @@ wait_for_vblank(data_t *data, enum pipe pipe)
> > >  return get_vblank_event_ns(data);
> > >  }
> > >
> > > -/* Performs an asynchronous non-blocking page-flip on a pipe. */
> > > -static int
> > > +/* Performs an atomic non-blocking page-flip on a pipe. */
> > > +static void
> > >  do_flip(data_t *data, enum pipe pipe_id, igt_fb_t *fb)
> > >  {
> > > -igt_pipe_t *pipe = &data->display.pipes[pipe_id];
> > > -int ret;
> > > -
> > >  igt_set_timeout(1, "Scheduling page flip\n");
> > >
> > > -/*
> > > - * Only the legacy flip ioctl supports async flips.
> > > - * It's also non-blocking, but returns -EBUSY if flipping too fast.
> > > - * 2x monitor tests will need async flips in the atomic API.
> > > - */
> > > -do {
> > > -ret = drmModePageFlip(data->drm_fd, pipe->crtc_id,
> > > -      fb->fb_id,
> > > -      DRM_MODE_PAGE_FLIP_EVENT |
> > > -      DRM_MODE_PAGE_FLIP_ASYNC,
> > > -      data);
> > > -} while (ret == -EBUSY);
> > > -
> > > -igt_assert_eq(ret, 0);
> > > -igt_reset_timeout();
> > > +igt_display_commit_atomic(&data->display,
> > > +  DRM_MODE_ATOMIC_NONBLOCK |
> > > +  DRM_MODE_PAGE_FLIP_EVENT,
> > > +  NULL);
> > >
> > > -return 0;
> > > +igt_reset_timeout();
> > >  }
> > >
> > >  /*
> > > @@ -246,11 +232,6 @@ do_flip(data_t *data, enum pipe pipe_id, igt_fb_t
> > *fb)
> > >   * can arbitrarily restrict the bounds further than the absolute
> > >   * min and max range. But VRR is really about extending the flip
> > >   * to prevent stuttering or to match a source content rate.
> > > - *
> > > - * The only way to "present" at a fixed rate like userspace in a vendor
> > > - * neutral manner is to do it with async flips. This avoids the need
> > > - * to wait for next vblank and it should eventually converge at the
> > > - * desired rate.
> > >   */
> > >  static uint32_t
> > >  flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
> > > @@ -271,7 +252,7 @@ flip_and_measure(data_t *data, igt_output_t *output,
> > enum pipe pipe,
> > >  front = !front;
> > >  do_flip(data, pipe, front ? &data->fb1 : &data->fb0);
> > >
> > > -vblank_ns = get_vblank_event_ns(data);
> > > +vblank_ns = wait_for_vblank(data, pipe);
> > >  diff_ns = rate_ns - (vblank_ns - last_vblank_ns);
> > >  last_vblank_ns = vblank_ns;
> > >
> > > --
> > > 2.24.1.1.gb6d4d82bd5
> > >
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

Re: [igt-dev] [RFC PATCH 1/2] tests/kms_vrr: Use atomic API for page flip

[Kazlauskas, Nicholas]

Sorry for the delay on checking this.

I've given it a spin and on Raven/Navi I see that before applying the 
patches I get SUCCESS for all 3 subtests but after applying them every 
test fails.

Patch 1 is what breaks it, but it's hard to say whether this is a test 
bug or AMDGPU driver bug from initial investigation.

I'm seeing that the vblank_ns = last_vblank_ns so I think we're still on 
the same frame when we get the event back.

I would think this would affect userspace behavior but adaptive sync 
works fine on this kernel for games and benchmarks.

Not sure if what I was doing with wait_for_vblank works is actually 
waiting for the page flip event from the driver or just the vblank 
event. We want to be comparing the delta between the page-flip events.

Regards,
Nicholas Kazlauskas

On 2020-08-03 6:17 p.m., Navare, Manasi wrote:
> 
> @Harry and @Nicholas, could you run kms_vrr IGT with this patch on AMD
> to see that with teh atomic API, it doesnt break VRR on AMD?
> 
> Regards
> Manasi
> 
> On Wed, Jul 01, 2020 at 09:16:59PM -0700, Modem, Bhanuprakash wrote:
>>> -----Original Message-----
>>> From: Navare, Manasi D <manasi.d.navare@intel.com>
>>> Sent: Wednesday, June 3, 2020 12:41 AM
>>> To: Modem, Bhanuprakash <bhanuprakash.modem@intel.com>
>>> Cc: igt-dev@lists.freedesktop.org; harry.wentland@amd.com;
>>> nicholas.kazlauskas@amd.com; Kiran, Pichika Uday
>>> <pichika.uday.kiran@intel.com>
>>> Subject: Re: [RFC PATCH 1/2] tests/kms_vrr: Use atomic API for page flip
>>>
>>> On Mon, May 11, 2020 at 11:56:46AM +0530, bhanuprakash.modem@intel.com
>>> wrote:
>>>> From: Bhanuprakash Modem <bhanuprakash.modem@intel.com>
>>>>
>>>> We should avoid using drmModePageFlip as it'll only be used for
>>>> legacy drivers, instead, use igt_display_commit_atomic() API to
>>>> page flip for atomic display code path.
>>>>
>>>> Cc: Harry Wentland <harry.wentland@amd.com>
>>>> Cc: Nicholas Kazlauskas <nicholas.kazlauskas@amd.com>
>>>> Cc: Manasi Navare <manasi.d.navare@intel.com>
>>>> Signed-off-by: Bhanuprakash Modem <bhanuprakash.modem@intel.com>
>>>
>>> I have tested this on i915 and the page flips are captured correctly with
>>> non blocking page flip requests using atomic_commit call.
>>>
>>> @Harry, @Nicholas could you test this on AMD driver to make
>>> sure its not breaking anything?
>> [Bhanu]
>> @Harry, @Nicholas did you get a chance to check this patch?
>>>
>>> Manasi
>>>
>>>> ---
>>>>   tests/kms_vrr.c | 39 ++++++++++-----------------------------
>>>>   1 file changed, 10 insertions(+), 29 deletions(-)
>>>>
>>>> diff --git a/tests/kms_vrr.c b/tests/kms_vrr.c
>>>> index 73115fef..0fe28931 100644
>>>> --- a/tests/kms_vrr.c
>>>> +++ b/tests/kms_vrr.c
>>>> @@ -126,11 +126,11 @@ static range_t get_vrr_range(data_t *data,
>>> igt_output_t *output)
>>>>   }
>>>>
>>>>   /* Returns a suitable vrr test frequency. */
>>>> -static uint32_t get_test_rate_ns(data_t *data, igt_output_t *output)
>>>> +static uint64_t get_test_rate_ns(data_t *data, igt_output_t *output)
>>>>   {
>>>>   drmModeModeInfo *mode = igt_output_get_mode(output);
>>>>   range_t range;
>>>> -uint32_t vtest;
>>>> +uint64_t vtest;
>>>>
>>>>   /*
>>>>    * The frequency with the fastest convergence speed should be
>>>> @@ -210,32 +210,18 @@ wait_for_vblank(data_t *data, enum pipe pipe)
>>>>   return get_vblank_event_ns(data);
>>>>   }
>>>>
>>>> -/* Performs an asynchronous non-blocking page-flip on a pipe. */
>>>> -static int
>>>> +/* Performs an atomic non-blocking page-flip on a pipe. */
>>>> +static void
>>>>   do_flip(data_t *data, enum pipe pipe_id, igt_fb_t *fb)
>>>>   {
>>>> -igt_pipe_t *pipe = &data->display.pipes[pipe_id];
>>>> -int ret;
>>>> -
>>>>   igt_set_timeout(1, "Scheduling page flip\n");
>>>>
>>>> -/*
>>>> - * Only the legacy flip ioctl supports async flips.
>>>> - * It's also non-blocking, but returns -EBUSY if flipping too fast.
>>>> - * 2x monitor tests will need async flips in the atomic API.
>>>> - */
>>>> -do {
>>>> -ret = drmModePageFlip(data->drm_fd, pipe->crtc_id,
>>>> -      fb->fb_id,
>>>> -      DRM_MODE_PAGE_FLIP_EVENT |
>>>> -      DRM_MODE_PAGE_FLIP_ASYNC,
>>>> -      data);
>>>> -} while (ret == -EBUSY);
>>>> -
>>>> -igt_assert_eq(ret, 0);
>>>> -igt_reset_timeout();
>>>> +igt_display_commit_atomic(&data->display,
>>>> +  DRM_MODE_ATOMIC_NONBLOCK |
>>>> +  DRM_MODE_PAGE_FLIP_EVENT,
>>>> +  NULL);
>>>>
>>>> -return 0;
>>>> +igt_reset_timeout();
>>>>   }
>>>>
>>>>   /*
>>>> @@ -246,11 +232,6 @@ do_flip(data_t *data, enum pipe pipe_id, igt_fb_t
>>> *fb)
>>>>    * can arbitrarily restrict the bounds further than the absolute
>>>>    * min and max range. But VRR is really about extending the flip
>>>>    * to prevent stuttering or to match a source content rate.
>>>> - *
>>>> - * The only way to "present" at a fixed rate like userspace in a vendor
>>>> - * neutral manner is to do it with async flips. This avoids the need
>>>> - * to wait for next vblank and it should eventually converge at the
>>>> - * desired rate.
>>>>    */
>>>>   static uint32_t
>>>>   flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
>>>> @@ -271,7 +252,7 @@ flip_and_measure(data_t *data, igt_output_t *output,
>>> enum pipe pipe,
>>>>   front = !front;
>>>>   do_flip(data, pipe, front ? &data->fb1 : &data->fb0);
>>>>
>>>> -vblank_ns = get_vblank_event_ns(data);
>>>> +vblank_ns = wait_for_vblank(data, pipe);
>>>>   diff_ns = rate_ns - (vblank_ns - last_vblank_ns);
>>>>   last_vblank_ns = vblank_ns;
>>>>
>>>> --
>>>> 2.24.1.1.gb6d4d82bd5
>>>>

_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

Re: [igt-dev] [RFC PATCH 1/2] tests/kms_vrr: Use atomic API for page flip

[Modem, Bhanuprakash]

Hi

> -----Original Message-----
> From: Kazlauskas, Nicholas <nicholas.kazlauskas@amd.com>
> Sent: Tuesday, August 4, 2020 9:41 PM
> To: Navare, Manasi D <manasi.d.navare@intel.com>; Modem, Bhanuprakash
> <bhanuprakash.modem@intel.com>
> Cc: harry.wentland@amd.com; igt-dev@lists.freedesktop.org; Kiran, Pichika
> Uday <pichika.uday.kiran@intel.com>
> Subject: Re: [RFC PATCH 1/2] tests/kms_vrr: Use atomic API for page flip
> 
> Sorry for the delay on checking this.
> 
> I've given it a spin and on Raven/Navi I see that before applying the
> patches I get SUCCESS for all 3 subtests but after applying them every
> test fails.
> 
> Patch 1 is what breaks it, but it's hard to say whether this is a test
> bug or AMDGPU driver bug from initial investigation.
> 
> I'm seeing that the vblank_ns = last_vblank_ns so I think we're still on
> the same frame when we get the event back.
> 
> I would think this would affect userspace behavior but adaptive sync
> works fine on this kernel for games and benchmarks.
> 
> Not sure if what I was doing with wait_for_vblank works is actually
> waiting for the page flip event from the driver or just the vblank
> event. We want to be comparing the delta between the page-flip events.
[Bhanu] That’s true, wait_for_vblank() is waiting for vblank event and I'll fix this in next revision.
I am not sure this can cause the failure, "delta b/w the page-flip events" vs "delta b/w the vblank events"
> 
> Regards,
> Nicholas Kazlauskas
> 
> On 2020-08-03 6:17 p.m., Navare, Manasi wrote:
> >
> > @Harry and @Nicholas, could you run kms_vrr IGT with this patch on AMD
> > to see that with teh atomic API, it doesnt break VRR on AMD?
> >
> > Regards
> > Manasi
> >
> > On Wed, Jul 01, 2020 at 09:16:59PM -0700, Modem, Bhanuprakash wrote:
> >>> -----Original Message-----
> >>> From: Navare, Manasi D <manasi.d.navare@intel.com>
> >>> Sent: Wednesday, June 3, 2020 12:41 AM
> >>> To: Modem, Bhanuprakash <bhanuprakash.modem@intel.com>
> >>> Cc: igt-dev@lists.freedesktop.org; harry.wentland@amd.com;
> >>> nicholas.kazlauskas@amd.com; Kiran, Pichika Uday
> >>> <pichika.uday.kiran@intel.com>
> >>> Subject: Re: [RFC PATCH 1/2] tests/kms_vrr: Use atomic API for page
> flip
> >>>
> >>> On Mon, May 11, 2020 at 11:56:46AM +0530, bhanuprakash.modem@intel.com
> >>> wrote:
> >>>> From: Bhanuprakash Modem <bhanuprakash.modem@intel.com>
> >>>>
> >>>> We should avoid using drmModePageFlip as it'll only be used for
> >>>> legacy drivers, instead, use igt_display_commit_atomic() API to
> >>>> page flip for atomic display code path.
> >>>>
> >>>> Cc: Harry Wentland <harry.wentland@amd.com>
> >>>> Cc: Nicholas Kazlauskas <nicholas.kazlauskas@amd.com>
> >>>> Cc: Manasi Navare <manasi.d.navare@intel.com>
> >>>> Signed-off-by: Bhanuprakash Modem <bhanuprakash.modem@intel.com>
> >>>
> >>> I have tested this on i915 and the page flips are captured correctly
> with
> >>> non blocking page flip requests using atomic_commit call.
> >>>
> >>> @Harry, @Nicholas could you test this on AMD driver to make
> >>> sure its not breaking anything?
> >> [Bhanu]
> >> @Harry, @Nicholas did you get a chance to check this patch?
> >>>
> >>> Manasi
> >>>
> >>>> ---
> >>>>   tests/kms_vrr.c | 39 ++++++++++-----------------------------
> >>>>   1 file changed, 10 insertions(+), 29 deletions(-)
> >>>>
> >>>> diff --git a/tests/kms_vrr.c b/tests/kms_vrr.c
> >>>> index 73115fef..0fe28931 100644
> >>>> --- a/tests/kms_vrr.c
> >>>> +++ b/tests/kms_vrr.c
> >>>> @@ -126,11 +126,11 @@ static range_t get_vrr_range(data_t *data,
> >>> igt_output_t *output)
> >>>>   }
> >>>>
> >>>>   /* Returns a suitable vrr test frequency. */
> >>>> -static uint32_t get_test_rate_ns(data_t *data, igt_output_t *output)
> >>>> +static uint64_t get_test_rate_ns(data_t *data, igt_output_t *output)
> >>>>   {
> >>>>   drmModeModeInfo *mode = igt_output_get_mode(output);
> >>>>   range_t range;
> >>>> -uint32_t vtest;
> >>>> +uint64_t vtest;
> >>>>
> >>>>   /*
> >>>>    * The frequency with the fastest convergence speed should be
> >>>> @@ -210,32 +210,18 @@ wait_for_vblank(data_t *data, enum pipe pipe)
> >>>>   return get_vblank_event_ns(data);
> >>>>   }
> >>>>
> >>>> -/* Performs an asynchronous non-blocking page-flip on a pipe. */
> >>>> -static int
> >>>> +/* Performs an atomic non-blocking page-flip on a pipe. */
> >>>> +static void
> >>>>   do_flip(data_t *data, enum pipe pipe_id, igt_fb_t *fb)
> >>>>   {
> >>>> -igt_pipe_t *pipe = &data->display.pipes[pipe_id];
> >>>> -int ret;
> >>>> -
> >>>>   igt_set_timeout(1, "Scheduling page flip\n");
> >>>>
> >>>> -/*
> >>>> - * Only the legacy flip ioctl supports async flips.
> >>>> - * It's also non-blocking, but returns -EBUSY if flipping too fast.
> >>>> - * 2x monitor tests will need async flips in the atomic API.
> >>>> - */
> >>>> -do {
> >>>> -ret = drmModePageFlip(data->drm_fd, pipe->crtc_id,
> >>>> -      fb->fb_id,
> >>>> -      DRM_MODE_PAGE_FLIP_EVENT |
> >>>> -      DRM_MODE_PAGE_FLIP_ASYNC,
> >>>> -      data);
> >>>> -} while (ret == -EBUSY);
> >>>> -
> >>>> -igt_assert_eq(ret, 0);
> >>>> -igt_reset_timeout();
> >>>> +igt_display_commit_atomic(&data->display,
> >>>> +  DRM_MODE_ATOMIC_NONBLOCK |
> >>>> +  DRM_MODE_PAGE_FLIP_EVENT,
> >>>> +  NULL);
> >>>>
> >>>> -return 0;
> >>>> +igt_reset_timeout();
> >>>>   }
> >>>>
> >>>>   /*
> >>>> @@ -246,11 +232,6 @@ do_flip(data_t *data, enum pipe pipe_id,
> igt_fb_t
> >>> *fb)
> >>>>    * can arbitrarily restrict the bounds further than the absolute
> >>>>    * min and max range. But VRR is really about extending the flip
> >>>>    * to prevent stuttering or to match a source content rate.
> >>>> - *
> >>>> - * The only way to "present" at a fixed rate like userspace in a
> vendor
> >>>> - * neutral manner is to do it with async flips. This avoids the need
> >>>> - * to wait for next vblank and it should eventually converge at the
> >>>> - * desired rate.
> >>>>    */
> >>>>   static uint32_t
> >>>>   flip_and_measure(data_t *data, igt_output_t *output, enum pipe
> pipe,
> >>>> @@ -271,7 +252,7 @@ flip_and_measure(data_t *data, igt_output_t
> *output,
> >>> enum pipe pipe,
> >>>>   front = !front;
> >>>>   do_flip(data, pipe, front ? &data->fb1 : &data->fb0);
> >>>>
> >>>> -vblank_ns = get_vblank_event_ns(data);
> >>>> +vblank_ns = wait_for_vblank(data, pipe);
> >>>>   diff_ns = rate_ns - (vblank_ns - last_vblank_ns);
> >>>>   last_vblank_ns = vblank_ns;
> >>>>
> >>>> --
> >>>> 2.24.1.1.gb6d4d82bd5
> >>>>

_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

[igt-dev] [PATCH v2 1/2] tests/kms_vrr: Use atomic API for page flip

[Bhanuprakash Modem]

We should avoid using drmModePageFlip as it'll only be used for
legacy drivers, instead, use igt_display_commit_atomic() API to
page flip for atomic display code path.

v2:
* Look for the page flip event not for the vblank event (Nicholas)
* Fix to flip with different FBs (Bhanu)

Cc: Harry Wentland <harry.wentland@amd.com>
Cc: Nicholas Kazlauskas <nicholas.kazlauskas@amd.com>
Cc: Manasi Navare <manasi.d.navare@intel.com>
Signed-off-by: Bhanuprakash Modem <bhanuprakash.modem@intel.com>
---
 tests/kms_vrr.c | 45 +++++++++++++++++----------------------------
 1 file changed, 17 insertions(+), 28 deletions(-)

diff --git a/tests/kms_vrr.c b/tests/kms_vrr.c
index 559ef203..b433a12e 100644
--- a/tests/kms_vrr.c
+++ b/tests/kms_vrr.c
@@ -47,6 +47,7 @@ typedef struct range {
 typedef struct data {
 	igt_display_t display;
 	int drm_fd;
+	igt_plane_t *primary;
 	igt_fb_t fb0;
 	igt_fb_t fb1;
 } data_t;
@@ -126,11 +127,11 @@ static range_t get_vrr_range(data_t *data, igt_output_t *output)
 }
 
 /* Returns a suitable vrr test frequency. */
-static uint32_t get_test_rate_ns(data_t *data, igt_output_t *output)
+static uint64_t get_test_rate_ns(data_t *data, igt_output_t *output)
 {
 	drmModeModeInfo *mode = igt_output_get_mode(output);
 	range_t range;
-	uint32_t vtest;
+	uint64_t vtest;
 
 	/*
 	 * The frequency with the fastest convergence speed should be
@@ -165,7 +166,6 @@ static void set_vrr_on_pipe(data_t *data, enum pipe pipe, bool enabled)
 static void prepare_test(data_t *data, igt_output_t *output, enum pipe pipe)
 {
 	drmModeModeInfo mode = *igt_output_get_mode(output);
-	igt_plane_t *primary;
 	cairo_t *cr;
 
 	/* Reset output */
@@ -189,8 +189,8 @@ static void prepare_test(data_t *data, igt_output_t *output, enum pipe pipe)
 	igt_put_cairo_ctx(cr);
 
 	/* Take care of any required modesetting before the test begins. */
-	primary = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY);
-	igt_plane_set_fb(primary, &data->fb0);
+	data->primary = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY);
+	igt_plane_set_fb(data->primary, &data->fb0);
 
 	igt_display_commit_atomic(&data->display,
 				  DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
@@ -210,32 +210,25 @@ wait_for_vblank(data_t *data, enum pipe pipe)
 	return get_vblank_event_ns(data);
 }
 
-/* Performs an asynchronous non-blocking page-flip on a pipe. */
-static int
-do_flip(data_t *data, enum pipe pipe_id, igt_fb_t *fb)
+/* Performs an atomic non-blocking page-flip on a pipe. */
+static void
+do_flip(data_t *data, igt_fb_t *fb)
 {
-	igt_pipe_t *pipe = &data->display.pipes[pipe_id];
-	int ret;
+	int ret = 0;
 
 	igt_set_timeout(1, "Scheduling page flip\n");
 
-	/*
-	 * Only the legacy flip ioctl supports async flips.
-	 * It's also non-blocking, but returns -EBUSY if flipping too fast.
-	 * 2x monitor tests will need async flips in the atomic API.
-	 */
+	igt_plane_set_fb(data->primary, fb);
+
 	do {
-		ret = drmModePageFlip(data->drm_fd, pipe->crtc_id,
-				      fb->fb_id,
-				      DRM_MODE_PAGE_FLIP_EVENT |
-				      DRM_MODE_PAGE_FLIP_ASYNC,
-				      data);
+		igt_display_commit_atomic(&data->display,
+				  DRM_MODE_ATOMIC_NONBLOCK |
+				  DRM_MODE_PAGE_FLIP_EVENT,
+				  data);
 	} while (ret == -EBUSY);
 
 	igt_assert_eq(ret, 0);
 	igt_reset_timeout();
-
-	return 0;
 }
 
 /*
@@ -246,11 +239,6 @@ do_flip(data_t *data, enum pipe pipe_id, igt_fb_t *fb)
  * can arbitrarily restrict the bounds further than the absolute
  * min and max range. But VRR is really about extending the flip
  * to prevent stuttering or to match a source content rate.
- *
- * The only way to "present" at a fixed rate like userspace in a vendor
- * neutral manner is to do it with async flips. This avoids the need
- * to wait for next vblank and it should eventually converge at the
- * desired rate.
  */
 static uint32_t
 flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
@@ -269,7 +257,7 @@ flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
 		int64_t diff_ns;
 
 		front = !front;
-		do_flip(data, pipe, front ? &data->fb1 : &data->fb0);
+		do_flip(data, front ? &data->fb1 : &data->fb0);
 
 		vblank_ns = get_vblank_event_ns(data);
 		diff_ns = rate_ns - (vblank_ns - last_vblank_ns);
@@ -359,6 +347,7 @@ test_basic(data_t *data, enum pipe pipe, igt_output_t *output, uint32_t flags)
 		     "Target VRR off threshold exceeded, result was %u%%\n",
 		     result);
 
+	igt_plane_set_fb(data->primary, NULL);
 	igt_remove_fb(data->drm_fd, &data->fb1);
 	igt_remove_fb(data->drm_fd, &data->fb0);
 }
-- 
2.20.1

_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

Re: [igt-dev] [PATCH v2 1/2] tests/kms_vrr: Use atomic API for page flip

[Navare, Manasi]

On Thu, Aug 06, 2020 at 12:05:05AM +0530, Bhanuprakash Modem wrote:
> We should avoid using drmModePageFlip as it'll only be used for
> legacy drivers, instead, use igt_display_commit_atomic() API to
> page flip for atomic display code path.
> 
> v2:
> * Look for the page flip event not for the vblank event (Nicholas)

Where have you done this change to wait for page flip event instead of vblank event?
I thought we would need to change the function get_vblank_event_ns() for this, I dont see
that change below, may be I am missing something?

@Nicholas, have you tested the AMD stack with the page flip event timestamp deltas
instead of the vblank event timetsmap deltas and does that work?

Manasi

> * Fix to flip with different FBs (Bhanu)
> 
> Cc: Harry Wentland <harry.wentland@amd.com>
> Cc: Nicholas Kazlauskas <nicholas.kazlauskas@amd.com>
> Cc: Manasi Navare <manasi.d.navare@intel.com>
> Signed-off-by: Bhanuprakash Modem <bhanuprakash.modem@intel.com>
> ---
>  tests/kms_vrr.c | 45 +++++++++++++++++----------------------------
>  1 file changed, 17 insertions(+), 28 deletions(-)
> 
> diff --git a/tests/kms_vrr.c b/tests/kms_vrr.c
> index 559ef203..b433a12e 100644
> --- a/tests/kms_vrr.c
> +++ b/tests/kms_vrr.c
> @@ -47,6 +47,7 @@ typedef struct range {
>  typedef struct data {
>  	igt_display_t display;
>  	int drm_fd;
> +	igt_plane_t *primary;
>  	igt_fb_t fb0;
>  	igt_fb_t fb1;
>  } data_t;
> @@ -126,11 +127,11 @@ static range_t get_vrr_range(data_t *data, igt_output_t *output)
>  }
>  
>  /* Returns a suitable vrr test frequency. */
> -static uint32_t get_test_rate_ns(data_t *data, igt_output_t *output)
> +static uint64_t get_test_rate_ns(data_t *data, igt_output_t *output)
>  {
>  	drmModeModeInfo *mode = igt_output_get_mode(output);
>  	range_t range;
> -	uint32_t vtest;
> +	uint64_t vtest;
>  
>  	/*
>  	 * The frequency with the fastest convergence speed should be
> @@ -165,7 +166,6 @@ static void set_vrr_on_pipe(data_t *data, enum pipe pipe, bool enabled)
>  static void prepare_test(data_t *data, igt_output_t *output, enum pipe pipe)
>  {
>  	drmModeModeInfo mode = *igt_output_get_mode(output);
> -	igt_plane_t *primary;
>  	cairo_t *cr;
>  
>  	/* Reset output */
> @@ -189,8 +189,8 @@ static void prepare_test(data_t *data, igt_output_t *output, enum pipe pipe)
>  	igt_put_cairo_ctx(cr);
>  
>  	/* Take care of any required modesetting before the test begins. */
> -	primary = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY);
> -	igt_plane_set_fb(primary, &data->fb0);
> +	data->primary = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY);
> +	igt_plane_set_fb(data->primary, &data->fb0);
>  
>  	igt_display_commit_atomic(&data->display,
>  				  DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
> @@ -210,32 +210,25 @@ wait_for_vblank(data_t *data, enum pipe pipe)
>  	return get_vblank_event_ns(data);
>  }
>  
> -/* Performs an asynchronous non-blocking page-flip on a pipe. */
> -static int
> -do_flip(data_t *data, enum pipe pipe_id, igt_fb_t *fb)
> +/* Performs an atomic non-blocking page-flip on a pipe. */
> +static void
> +do_flip(data_t *data, igt_fb_t *fb)
>  {
> -	igt_pipe_t *pipe = &data->display.pipes[pipe_id];
> -	int ret;
> +	int ret = 0;
>  
>  	igt_set_timeout(1, "Scheduling page flip\n");
>  
> -	/*
> -	 * Only the legacy flip ioctl supports async flips.
> -	 * It's also non-blocking, but returns -EBUSY if flipping too fast.
> -	 * 2x monitor tests will need async flips in the atomic API.
> -	 */
> +	igt_plane_set_fb(data->primary, fb);
> +
>  	do {
> -		ret = drmModePageFlip(data->drm_fd, pipe->crtc_id,
> -				      fb->fb_id,
> -				      DRM_MODE_PAGE_FLIP_EVENT |
> -				      DRM_MODE_PAGE_FLIP_ASYNC,
> -				      data);
> +		igt_display_commit_atomic(&data->display,
> +				  DRM_MODE_ATOMIC_NONBLOCK |
> +				  DRM_MODE_PAGE_FLIP_EVENT,
> +				  data);
>  	} while (ret == -EBUSY);
>  
>  	igt_assert_eq(ret, 0);
>  	igt_reset_timeout();
> -
> -	return 0;
>  }
>  
>  /*
> @@ -246,11 +239,6 @@ do_flip(data_t *data, enum pipe pipe_id, igt_fb_t *fb)
>   * can arbitrarily restrict the bounds further than the absolute
>   * min and max range. But VRR is really about extending the flip
>   * to prevent stuttering or to match a source content rate.
> - *
> - * The only way to "present" at a fixed rate like userspace in a vendor
> - * neutral manner is to do it with async flips. This avoids the need
> - * to wait for next vblank and it should eventually converge at the
> - * desired rate.
>   */
>  static uint32_t
>  flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
> @@ -269,7 +257,7 @@ flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
>  		int64_t diff_ns;
>  
>  		front = !front;
> -		do_flip(data, pipe, front ? &data->fb1 : &data->fb0);
> +		do_flip(data, front ? &data->fb1 : &data->fb0);
>  
>  		vblank_ns = get_vblank_event_ns(data);
>  		diff_ns = rate_ns - (vblank_ns - last_vblank_ns);
> @@ -359,6 +347,7 @@ test_basic(data_t *data, enum pipe pipe, igt_output_t *output, uint32_t flags)
>  		     "Target VRR off threshold exceeded, result was %u%%\n",
>  		     result);
>  
> +	igt_plane_set_fb(data->primary, NULL);
>  	igt_remove_fb(data->drm_fd, &data->fb1);
>  	igt_remove_fb(data->drm_fd, &data->fb0);
>  }
> -- 
> 2.20.1
> 
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

Re: [igt-dev] [PATCH v2 1/2] tests/kms_vrr: Use atomic API for page flip

[Modem, Bhanuprakash]

> -----Original Message-----
> From: Navare, Manasi <manasi.d.navare@intel.com>
> Sent: Thursday, August 6, 2020 12:41 AM
> To: Modem, Bhanuprakash <bhanuprakash.modem@intel.com>
> Cc: igt-dev@lists.freedesktop.org; Harry Wentland
> <harry.wentland@amd.com>; Nicholas Kazlauskas
> <nicholas.kazlauskas@amd.com>
> Subject: Re: [PATCH v2 1/2] tests/kms_vrr: Use atomic API for page flip
> 
> On Thu, Aug 06, 2020 at 12:05:05AM +0530, Bhanuprakash Modem wrote:
> > We should avoid using drmModePageFlip as it'll only be used for
> > legacy drivers, instead, use igt_display_commit_atomic() API to
> > page flip for atomic display code path.
> >
> > v2:
> > * Look for the page flip event not for the vblank event (Nicholas)
> 
> Where have you done this change to wait for page flip event instead of
> vblank event?
> I thought we would need to change the function get_vblank_event_ns() for
> this, I dont see
> that change below, may be I am missing something?
[Bhanu] I think no need to change the logic in get_vblank_event_ns(). May be we can have extra check (like "ev.base.type == event") to make sure we are reading the correct event.

Call flow:
1) drmWaitVBlank --> get_vblank_event_ns(): will get the DRM_EVENT_VBLANK event timestamp
2) igt_display_commit_atomic(DRM_MODE_PAGE_FLIP_EVENT) --> get_vblank_event_ns(): will get the DRM_EVENT_FLIP_COMPLETE event timestamp

Yeah, we can rename the get_vblank_event_ns() in a generic way like get_event_ns()
> 
> @Nicholas, have you tested the AMD stack with the page flip event
> timestamp deltas
> instead of the vblank event timetsmap deltas and does that work?
> 
> Manasi
> 
> > * Fix to flip with different FBs (Bhanu)
> >
> > Cc: Harry Wentland <harry.wentland@amd.com>
> > Cc: Nicholas Kazlauskas <nicholas.kazlauskas@amd.com>
> > Cc: Manasi Navare <manasi.d.navare@intel.com>
> > Signed-off-by: Bhanuprakash Modem <bhanuprakash.modem@intel.com>
> > ---
> >  tests/kms_vrr.c | 45 +++++++++++++++++----------------------------
> >  1 file changed, 17 insertions(+), 28 deletions(-)
> >
> > diff --git a/tests/kms_vrr.c b/tests/kms_vrr.c
> > index 559ef203..b433a12e 100644
> > --- a/tests/kms_vrr.c
> > +++ b/tests/kms_vrr.c
> > @@ -47,6 +47,7 @@ typedef struct range {
> >  typedef struct data {
> >  	igt_display_t display;
> >  	int drm_fd;
> > +	igt_plane_t *primary;
> >  	igt_fb_t fb0;
> >  	igt_fb_t fb1;
> >  } data_t;
> > @@ -126,11 +127,11 @@ static range_t get_vrr_range(data_t *data,
> igt_output_t *output)
> >  }
> >
> >  /* Returns a suitable vrr test frequency. */
> > -static uint32_t get_test_rate_ns(data_t *data, igt_output_t *output)
> > +static uint64_t get_test_rate_ns(data_t *data, igt_output_t *output)
> >  {
> >  	drmModeModeInfo *mode = igt_output_get_mode(output);
> >  	range_t range;
> > -	uint32_t vtest;
> > +	uint64_t vtest;
> >
> >  	/*
> >  	 * The frequency with the fastest convergence speed should be
> > @@ -165,7 +166,6 @@ static void set_vrr_on_pipe(data_t *data, enum pipe
> pipe, bool enabled)
> >  static void prepare_test(data_t *data, igt_output_t *output, enum pipe
> pipe)
> >  {
> >  	drmModeModeInfo mode = *igt_output_get_mode(output);
> > -	igt_plane_t *primary;
> >  	cairo_t *cr;
> >
> >  	/* Reset output */
> > @@ -189,8 +189,8 @@ static void prepare_test(data_t *data, igt_output_t
> *output, enum pipe pipe)
> >  	igt_put_cairo_ctx(cr);
> >
> >  	/* Take care of any required modesetting before the test begins. */
> > -	primary = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY);
> > -	igt_plane_set_fb(primary, &data->fb0);
> > +	data->primary = igt_output_get_plane_type(output,
> DRM_PLANE_TYPE_PRIMARY);
> > +	igt_plane_set_fb(data->primary, &data->fb0);
> >
> >  	igt_display_commit_atomic(&data->display,
> >  				  DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
> > @@ -210,32 +210,25 @@ wait_for_vblank(data_t *data, enum pipe pipe)
> >  	return get_vblank_event_ns(data);
> >  }
> >
> > -/* Performs an asynchronous non-blocking page-flip on a pipe. */
> > -static int
> > -do_flip(data_t *data, enum pipe pipe_id, igt_fb_t *fb)
> > +/* Performs an atomic non-blocking page-flip on a pipe. */
> > +static void
> > +do_flip(data_t *data, igt_fb_t *fb)
> >  {
> > -	igt_pipe_t *pipe = &data->display.pipes[pipe_id];
> > -	int ret;
> > +	int ret = 0;
> >
> >  	igt_set_timeout(1, "Scheduling page flip\n");
> >
> > -	/*
> > -	 * Only the legacy flip ioctl supports async flips.
> > -	 * It's also non-blocking, but returns -EBUSY if flipping too fast.
> > -	 * 2x monitor tests will need async flips in the atomic API.
> > -	 */
> > +	igt_plane_set_fb(data->primary, fb);
> > +
> >  	do {
> > -		ret = drmModePageFlip(data->drm_fd, pipe->crtc_id,
> > -				      fb->fb_id,
> > -				      DRM_MODE_PAGE_FLIP_EVENT |
> > -				      DRM_MODE_PAGE_FLIP_ASYNC,
> > -				      data);
> > +		igt_display_commit_atomic(&data->display,
> > +				  DRM_MODE_ATOMIC_NONBLOCK |
> > +				  DRM_MODE_PAGE_FLIP_EVENT,
> > +				  data);
> >  	} while (ret == -EBUSY);
> >
> >  	igt_assert_eq(ret, 0);
> >  	igt_reset_timeout();
> > -
> > -	return 0;
> >  }
> >
> >  /*
> > @@ -246,11 +239,6 @@ do_flip(data_t *data, enum pipe pipe_id, igt_fb_t
> *fb)
> >   * can arbitrarily restrict the bounds further than the absolute
> >   * min and max range. But VRR is really about extending the flip
> >   * to prevent stuttering or to match a source content rate.
> > - *
> > - * The only way to "present" at a fixed rate like userspace in a vendor
> > - * neutral manner is to do it with async flips. This avoids the need
> > - * to wait for next vblank and it should eventually converge at the
> > - * desired rate.
> >   */
> >  static uint32_t
> >  flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
> > @@ -269,7 +257,7 @@ flip_and_measure(data_t *data, igt_output_t *output,
> enum pipe pipe,
> >  		int64_t diff_ns;
> >
> >  		front = !front;
> > -		do_flip(data, pipe, front ? &data->fb1 : &data->fb0);
> > +		do_flip(data, front ? &data->fb1 : &data->fb0);
> >
> >  		vblank_ns = get_vblank_event_ns(data);
> >  		diff_ns = rate_ns - (vblank_ns - last_vblank_ns);
> > @@ -359,6 +347,7 @@ test_basic(data_t *data, enum pipe pipe,
> igt_output_t *output, uint32_t flags)
> >  		     "Target VRR off threshold exceeded, result was %u%%\n",
> >  		     result);
> >
> > +	igt_plane_set_fb(data->primary, NULL);
> >  	igt_remove_fb(data->drm_fd, &data->fb1);
> >  	igt_remove_fb(data->drm_fd, &data->fb0);
> >  }
> > --
> > 2.20.1
> >
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

Re: [igt-dev] [PATCH v2 1/2] tests/kms_vrr: Use atomic API for page flip

[Navare, Manasi]

On Thu, Aug 06, 2020 at 12:02:04AM -0700, Modem, Bhanuprakash wrote:
> > -----Original Message-----
> > From: Navare, Manasi <manasi.d.navare@intel.com>
> > Sent: Thursday, August 6, 2020 12:41 AM
> > To: Modem, Bhanuprakash <bhanuprakash.modem@intel.com>
> > Cc: igt-dev@lists.freedesktop.org; Harry Wentland
> > <harry.wentland@amd.com>; Nicholas Kazlauskas
> > <nicholas.kazlauskas@amd.com>
> > Subject: Re: [PATCH v2 1/2] tests/kms_vrr: Use atomic API for page flip
> >
> > On Thu, Aug 06, 2020 at 12:05:05AM +0530, Bhanuprakash Modem wrote:
> > > We should avoid using drmModePageFlip as it'll only be used for
> > > legacy drivers, instead, use igt_display_commit_atomic() API to
> > > page flip for atomic display code path.
> > >
> > > v2:
> > > * Look for the page flip event not for the vblank event (Nicholas)
> >
> > Where have you done this change to wait for page flip event instead of
> > vblank event?
> > I thought we would need to change the function get_vblank_event_ns() for
> > this, I dont see
> > that change below, may be I am missing something?
> [Bhanu] I think no need to change the logic in get_vblank_event_ns(). May be we can have extra check (like "ev.base.type == event") to make sure we are reading the correct event.
> 
> Call flow:
> 1) drmWaitVBlank --> get_vblank_event_ns(): will get the DRM_EVENT_VBLANK event timestamp
> 2) igt_display_commit_atomic(DRM_MODE_PAGE_FLIP_EVENT) --> get_vblank_event_ns(): will get the DRM_EVENT_FLIP_COMPLETE event timestamp

Okay yes this makes sense now, would be better to explain this call flow in the get_vblank_event_ns()
function header somewhere and yes good idea to make its name generic, get_kernel_event_ns()
and explain that it could be either vblank event or flip event with the above call flow.
And also explain why we should care here for flip event rather than vblank.
Because vblank is triggered after each frame but depending on vblank evasion time
flip might or might not happen in that same frame, so capture flip event.

Manasi

> 
> Yeah, we can rename the get_vblank_event_ns() in a generic way like get_event_ns()
> >
> > @Nicholas, have you tested the AMD stack with the page flip event
> > timestamp deltas
> > instead of the vblank event timetsmap deltas and does that work?
> >
> > Manasi
> >
> > > * Fix to flip with different FBs (Bhanu)
> > >
> > > Cc: Harry Wentland <harry.wentland@amd.com>
> > > Cc: Nicholas Kazlauskas <nicholas.kazlauskas@amd.com>
> > > Cc: Manasi Navare <manasi.d.navare@intel.com>
> > > Signed-off-by: Bhanuprakash Modem <bhanuprakash.modem@intel.com>
> > > ---
> > >  tests/kms_vrr.c | 45 +++++++++++++++++----------------------------
> > >  1 file changed, 17 insertions(+), 28 deletions(-)
> > >
> > > diff --git a/tests/kms_vrr.c b/tests/kms_vrr.c
> > > index 559ef203..b433a12e 100644
> > > --- a/tests/kms_vrr.c
> > > +++ b/tests/kms_vrr.c
> > > @@ -47,6 +47,7 @@ typedef struct range {
> > >  typedef struct data {
> > >  igt_display_t display;
> > >  int drm_fd;
> > > +igt_plane_t *primary;
> > >  igt_fb_t fb0;
> > >  igt_fb_t fb1;
> > >  } data_t;
> > > @@ -126,11 +127,11 @@ static range_t get_vrr_range(data_t *data,
> > igt_output_t *output)
> > >  }
> > >
> > >  /* Returns a suitable vrr test frequency. */
> > > -static uint32_t get_test_rate_ns(data_t *data, igt_output_t *output)
> > > +static uint64_t get_test_rate_ns(data_t *data, igt_output_t *output)
> > >  {
> > >  drmModeModeInfo *mode = igt_output_get_mode(output);
> > >  range_t range;
> > > -uint32_t vtest;
> > > +uint64_t vtest;
> > >
> > >  /*
> > >   * The frequency with the fastest convergence speed should be
> > > @@ -165,7 +166,6 @@ static void set_vrr_on_pipe(data_t *data, enum pipe
> > pipe, bool enabled)
> > >  static void prepare_test(data_t *data, igt_output_t *output, enum pipe
> > pipe)
> > >  {
> > >  drmModeModeInfo mode = *igt_output_get_mode(output);
> > > -igt_plane_t *primary;
> > >  cairo_t *cr;
> > >
> > >  /* Reset output */
> > > @@ -189,8 +189,8 @@ static void prepare_test(data_t *data, igt_output_t
> > *output, enum pipe pipe)
> > >  igt_put_cairo_ctx(cr);
> > >
> > >  /* Take care of any required modesetting before the test begins. */
> > > -primary = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY);
> > > -igt_plane_set_fb(primary, &data->fb0);
> > > +data->primary = igt_output_get_plane_type(output,
> > DRM_PLANE_TYPE_PRIMARY);
> > > +igt_plane_set_fb(data->primary, &data->fb0);
> > >
> > >  igt_display_commit_atomic(&data->display,
> > >    DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
> > > @@ -210,32 +210,25 @@ wait_for_vblank(data_t *data, enum pipe pipe)
> > >  return get_vblank_event_ns(data);
> > >  }
> > >
> > > -/* Performs an asynchronous non-blocking page-flip on a pipe. */
> > > -static int
> > > -do_flip(data_t *data, enum pipe pipe_id, igt_fb_t *fb)
> > > +/* Performs an atomic non-blocking page-flip on a pipe. */
> > > +static void
> > > +do_flip(data_t *data, igt_fb_t *fb)
> > >  {
> > > -igt_pipe_t *pipe = &data->display.pipes[pipe_id];
> > > -int ret;
> > > +int ret = 0;
> > >
> > >  igt_set_timeout(1, "Scheduling page flip\n");
> > >
> > > -/*
> > > - * Only the legacy flip ioctl supports async flips.
> > > - * It's also non-blocking, but returns -EBUSY if flipping too fast.
> > > - * 2x monitor tests will need async flips in the atomic API.
> > > - */
> > > +igt_plane_set_fb(data->primary, fb);
> > > +
> > >  do {
> > > -ret = drmModePageFlip(data->drm_fd, pipe->crtc_id,
> > > -      fb->fb_id,
> > > -      DRM_MODE_PAGE_FLIP_EVENT |
> > > -      DRM_MODE_PAGE_FLIP_ASYNC,
> > > -      data);
> > > +igt_display_commit_atomic(&data->display,
> > > +  DRM_MODE_ATOMIC_NONBLOCK |
> > > +  DRM_MODE_PAGE_FLIP_EVENT,
> > > +  data);
> > >  } while (ret == -EBUSY);
> > >
> > >  igt_assert_eq(ret, 0);
> > >  igt_reset_timeout();
> > > -
> > > -return 0;
> > >  }
> > >
> > >  /*
> > > @@ -246,11 +239,6 @@ do_flip(data_t *data, enum pipe pipe_id, igt_fb_t
> > *fb)
> > >   * can arbitrarily restrict the bounds further than the absolute
> > >   * min and max range. But VRR is really about extending the flip
> > >   * to prevent stuttering or to match a source content rate.
> > > - *
> > > - * The only way to "present" at a fixed rate like userspace in a vendor
> > > - * neutral manner is to do it with async flips. This avoids the need
> > > - * to wait for next vblank and it should eventually converge at the
> > > - * desired rate.
> > >   */
> > >  static uint32_t
> > >  flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
> > > @@ -269,7 +257,7 @@ flip_and_measure(data_t *data, igt_output_t *output,
> > enum pipe pipe,
> > >  int64_t diff_ns;
> > >
> > >  front = !front;
> > > -do_flip(data, pipe, front ? &data->fb1 : &data->fb0);
> > > +do_flip(data, front ? &data->fb1 : &data->fb0);
> > >
> > >  vblank_ns = get_vblank_event_ns(data);
> > >  diff_ns = rate_ns - (vblank_ns - last_vblank_ns);
> > > @@ -359,6 +347,7 @@ test_basic(data_t *data, enum pipe pipe,
> > igt_output_t *output, uint32_t flags)
> > >       "Target VRR off threshold exceeded, result was %u%%\n",
> > >       result);
> > >
> > > +igt_plane_set_fb(data->primary, NULL);
> > >  igt_remove_fb(data->drm_fd, &data->fb1);
> > >  igt_remove_fb(data->drm_fd, &data->fb0);
> > >  }
> > > --
> > > 2.20.1
> > >
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

Re: [igt-dev] [PATCH v2 1/2] tests/kms_vrr: Use atomic API for page flip

[Modem, Bhanuprakash]

> -----Original Message-----
> From: Navare, Manasi <manasi.d.navare@intel.com>
> Sent: Friday, August 14, 2020 4:51 AM
> To: Modem, Bhanuprakash <bhanuprakash.modem@intel.com>
> Cc: igt-dev@lists.freedesktop.org; Harry Wentland
> <harry.wentland@amd.com>; Nicholas Kazlauskas
> <nicholas.kazlauskas@amd.com>
> Subject: Re: [PATCH v2 1/2] tests/kms_vrr: Use atomic API for page flip
> 
> On Thu, Aug 06, 2020 at 12:02:04AM -0700, Modem, Bhanuprakash wrote:
> > > -----Original Message-----
> > > From: Navare, Manasi <manasi.d.navare@intel.com>
> > > Sent: Thursday, August 6, 2020 12:41 AM
> > > To: Modem, Bhanuprakash <bhanuprakash.modem@intel.com>
> > > Cc: igt-dev@lists.freedesktop.org; Harry Wentland
> > > <harry.wentland@amd.com>; Nicholas Kazlauskas
> > > <nicholas.kazlauskas@amd.com>
> > > Subject: Re: [PATCH v2 1/2] tests/kms_vrr: Use atomic API for page
> flip
> > >
> > > On Thu, Aug 06, 2020 at 12:05:05AM +0530, Bhanuprakash Modem wrote:
> > > > We should avoid using drmModePageFlip as it'll only be used for
> > > > legacy drivers, instead, use igt_display_commit_atomic() API to
> > > > page flip for atomic display code path.
> > > >
> > > > v2:
> > > > * Look for the page flip event not for the vblank event (Nicholas)
> > >
> > > Where have you done this change to wait for page flip event instead of
> > > vblank event?
> > > I thought we would need to change the function get_vblank_event_ns()
> for
> > > this, I dont see
> > > that change below, may be I am missing something?
> > [Bhanu] I think no need to change the logic in get_vblank_event_ns().
> May be we can have extra check (like "ev.base.type == event") to make sure
> we are reading the correct event.
> >
> > Call flow:
> > 1) drmWaitVBlank --> get_vblank_event_ns(): will get the
> DRM_EVENT_VBLANK event timestamp
> > 2) igt_display_commit_atomic(DRM_MODE_PAGE_FLIP_EVENT) -->
> get_vblank_event_ns(): will get the DRM_EVENT_FLIP_COMPLETE event
> timestamp
> 
> Okay yes this makes sense now, would be better to explain this call flow
> in the get_vblank_event_ns()
> function header somewhere and yes good idea to make its name generic,
> get_kernel_event_ns()
> and explain that it could be either vblank event or flip event with the
> above call flow.
> And also explain why we should care here for flip event rather than
> vblank.
> Because vblank is triggered after each frame but depending on vblank
> evasion time
> flip might or might not happen in that same frame, so capture flip event.
[Bhanu] 
Sure, I'll float a new revision by making these changes. But these changes don't impact the functionality, so we are good to go for testing.

@Nicholas: did you get a chance to test this patch on AMD h/w?
> 
> Manasi
> 
> >
> > Yeah, we can rename the get_vblank_event_ns() in a generic way like
> get_event_ns()
> > >
> > > @Nicholas, have you tested the AMD stack with the page flip event
> > > timestamp deltas
> > > instead of the vblank event timetsmap deltas and does that work?
> > >
> > > Manasi
> > >
> > > > * Fix to flip with different FBs (Bhanu)
> > > >
> > > > Cc: Harry Wentland <harry.wentland@amd.com>
> > > > Cc: Nicholas Kazlauskas <nicholas.kazlauskas@amd.com>
> > > > Cc: Manasi Navare <manasi.d.navare@intel.com>
> > > > Signed-off-by: Bhanuprakash Modem <bhanuprakash.modem@intel.com>
> > > > ---
> > > >  tests/kms_vrr.c | 45 +++++++++++++++++----------------------------
> > > >  1 file changed, 17 insertions(+), 28 deletions(-)
> > > >
> > > > diff --git a/tests/kms_vrr.c b/tests/kms_vrr.c
> > > > index 559ef203..b433a12e 100644
> > > > --- a/tests/kms_vrr.c
> > > > +++ b/tests/kms_vrr.c
> > > > @@ -47,6 +47,7 @@ typedef struct range {
> > > >  typedef struct data {
> > > >  igt_display_t display;
> > > >  int drm_fd;
> > > > +igt_plane_t *primary;
> > > >  igt_fb_t fb0;
> > > >  igt_fb_t fb1;
> > > >  } data_t;
> > > > @@ -126,11 +127,11 @@ static range_t get_vrr_range(data_t *data,
> > > igt_output_t *output)
> > > >  }
> > > >
> > > >  /* Returns a suitable vrr test frequency. */
> > > > -static uint32_t get_test_rate_ns(data_t *data, igt_output_t
> *output)
> > > > +static uint64_t get_test_rate_ns(data_t *data, igt_output_t
> *output)
> > > >  {
> > > >  drmModeModeInfo *mode = igt_output_get_mode(output);
> > > >  range_t range;
> > > > -uint32_t vtest;
> > > > +uint64_t vtest;
> > > >
> > > >  /*
> > > >   * The frequency with the fastest convergence speed should be
> > > > @@ -165,7 +166,6 @@ static void set_vrr_on_pipe(data_t *data, enum
> pipe
> > > pipe, bool enabled)
> > > >  static void prepare_test(data_t *data, igt_output_t *output, enum
> pipe
> > > pipe)
> > > >  {
> > > >  drmModeModeInfo mode = *igt_output_get_mode(output);
> > > > -igt_plane_t *primary;
> > > >  cairo_t *cr;
> > > >
> > > >  /* Reset output */
> > > > @@ -189,8 +189,8 @@ static void prepare_test(data_t *data,
> igt_output_t
> > > *output, enum pipe pipe)
> > > >  igt_put_cairo_ctx(cr);
> > > >
> > > >  /* Take care of any required modesetting before the test begins. */
> > > > -primary = igt_output_get_plane_type(output,
> DRM_PLANE_TYPE_PRIMARY);
> > > > -igt_plane_set_fb(primary, &data->fb0);
> > > > +data->primary = igt_output_get_plane_type(output,
> > > DRM_PLANE_TYPE_PRIMARY);
> > > > +igt_plane_set_fb(data->primary, &data->fb0);
> > > >
> > > >  igt_display_commit_atomic(&data->display,
> > > >    DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
> > > > @@ -210,32 +210,25 @@ wait_for_vblank(data_t *data, enum pipe pipe)
> > > >  return get_vblank_event_ns(data);
> > > >  }
> > > >
> > > > -/* Performs an asynchronous non-blocking page-flip on a pipe. */
> > > > -static int
> > > > -do_flip(data_t *data, enum pipe pipe_id, igt_fb_t *fb)
> > > > +/* Performs an atomic non-blocking page-flip on a pipe. */
> > > > +static void
> > > > +do_flip(data_t *data, igt_fb_t *fb)
> > > >  {
> > > > -igt_pipe_t *pipe = &data->display.pipes[pipe_id];
> > > > -int ret;
> > > > +int ret = 0;
> > > >
> > > >  igt_set_timeout(1, "Scheduling page flip\n");
> > > >
> > > > -/*
> > > > - * Only the legacy flip ioctl supports async flips.
> > > > - * It's also non-blocking, but returns -EBUSY if flipping too fast.
> > > > - * 2x monitor tests will need async flips in the atomic API.
> > > > - */
> > > > +igt_plane_set_fb(data->primary, fb);
> > > > +
> > > >  do {
> > > > -ret = drmModePageFlip(data->drm_fd, pipe->crtc_id,
> > > > -      fb->fb_id,
> > > > -      DRM_MODE_PAGE_FLIP_EVENT |
> > > > -      DRM_MODE_PAGE_FLIP_ASYNC,
> > > > -      data);
> > > > +igt_display_commit_atomic(&data->display,
> > > > +  DRM_MODE_ATOMIC_NONBLOCK |
> > > > +  DRM_MODE_PAGE_FLIP_EVENT,
> > > > +  data);
> > > >  } while (ret == -EBUSY);
> > > >
> > > >  igt_assert_eq(ret, 0);
> > > >  igt_reset_timeout();
> > > > -
> > > > -return 0;
> > > >  }
> > > >
> > > >  /*
> > > > @@ -246,11 +239,6 @@ do_flip(data_t *data, enum pipe pipe_id,
> igt_fb_t
> > > *fb)
> > > >   * can arbitrarily restrict the bounds further than the absolute
> > > >   * min and max range. But VRR is really about extending the flip
> > > >   * to prevent stuttering or to match a source content rate.
> > > > - *
> > > > - * The only way to "present" at a fixed rate like userspace in a
> vendor
> > > > - * neutral manner is to do it with async flips. This avoids the
> need
> > > > - * to wait for next vblank and it should eventually converge at the
> > > > - * desired rate.
> > > >   */
> > > >  static uint32_t
> > > >  flip_and_measure(data_t *data, igt_output_t *output, enum pipe
> pipe,
> > > > @@ -269,7 +257,7 @@ flip_and_measure(data_t *data, igt_output_t
> *output,
> > > enum pipe pipe,
> > > >  int64_t diff_ns;
> > > >
> > > >  front = !front;
> > > > -do_flip(data, pipe, front ? &data->fb1 : &data->fb0);
> > > > +do_flip(data, front ? &data->fb1 : &data->fb0);
> > > >
> > > >  vblank_ns = get_vblank_event_ns(data);
> > > >  diff_ns = rate_ns - (vblank_ns - last_vblank_ns);
> > > > @@ -359,6 +347,7 @@ test_basic(data_t *data, enum pipe pipe,
> > > igt_output_t *output, uint32_t flags)
> > > >       "Target VRR off threshold exceeded, result was %u%%\n",
> > > >       result);
> > > >
> > > > +igt_plane_set_fb(data->primary, NULL);
> > > >  igt_remove_fb(data->drm_fd, &data->fb1);
> > > >  igt_remove_fb(data->drm_fd, &data->fb0);
> > > >  }
> > > > --
> > > > 2.20.1
> > > >
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

[igt-dev] [RFC PATCH 2/2] tests/kms_vrr: Add new subtest to validate Flipline mode

[bhanuprakash.modem]

From: Bhanuprakash Modem <bhanuprakash.modem@intel.com>

Check flipline mode by making sure that flips happen at flipline
decision boundary.

Example: if monitor vrr range is 40 - 60Hz and

* flip at refresh_rate > 60Hz:
  	Flip should happen at the flipline boundary & returned refresh rate
	would be 60Hz.
* flip at refresh_rate == 50Hz:
	Flip should happen right away so returned refresh rate is 50Hz.
* flip at refresh_rate < 40Hz:
	Flip should happen at the vmax so the returned refresh rate
	would be 40Hz.

Cc: Harry Wentland <harry.wentland@amd.com>
Cc: Nicholas Kazlauskas <nicholas.kazlauskas@amd.com>
Cc: Manasi Navare <manasi.d.navare@intel.com>
Signed-off-by: Bhanuprakash Modem <bhanuprakash.modem@intel.com>
---
 tests/kms_vrr.c | 101 ++++++++++++++++++++++++++++++++++++------------
 1 file changed, 76 insertions(+), 25 deletions(-)

diff --git a/tests/kms_vrr.c b/tests/kms_vrr.c
index 0fe28931..c8a8c065 100644
--- a/tests/kms_vrr.c
+++ b/tests/kms_vrr.c
@@ -37,6 +37,7 @@ enum {
 	TEST_NONE = 0,
 	TEST_DPMS = 1 << 0,
 	TEST_SUSPEND = 1 << 1,
+	TEST_FLIPLINE = 1 << 2,
 };
 
 typedef struct range {
@@ -51,6 +52,12 @@ typedef struct data {
 	igt_fb_t fb1;
 } data_t;
 
+typedef struct vtest_ns {
+	uint64_t min;
+	uint64_t mid;
+	uint64_t max;
+} vtest_ns_t;
+
 typedef void (*test_t)(data_t*, enum pipe, igt_output_t*, uint32_t);
 
 /* Converts a timespec structure to nanoseconds. */
@@ -100,13 +107,18 @@ static uint64_t rate_from_refresh(uint64_t refresh)
 	return NSECS_PER_SEC / refresh;
 }
 
-/* Returns the min and max vrr range from the connector debugfs. */
+/* Read min and max vrr range from the connector debugfs.
+ * - min range should be less than the current mode vfreq
+ * - if max range is grater than the current mode vfreq, consider
+ *	current mode vfreq as the max range.
+ */
 static range_t get_vrr_range(data_t *data, igt_output_t *output)
 {
 	char buf[256];
 	char *start_loc;
 	int fd, res;
 	range_t range;
+	drmModeModeInfo *mode = igt_output_get_mode(output);
 
 	fd = igt_debugfs_connector_dir(data->drm_fd, output->name, O_RDONLY);
 	igt_assert(fd >= 0);
@@ -118,32 +130,28 @@ static range_t get_vrr_range(data_t *data, igt_output_t *output)
 
 	igt_assert(start_loc = strstr(buf, "Min: "));
 	igt_assert_eq(sscanf(start_loc, "Min: %u", &range.min), 1);
+	igt_require(mode->vrefresh > range.min);
 
 	igt_assert(start_loc = strstr(buf, "Max: "));
 	igt_assert_eq(sscanf(start_loc, "Max: %u", &range.max), 1);
 
+	range.max = (mode->vrefresh < range.max) ? mode->vrefresh : range.max;
+
 	return range;
 }
 
-/* Returns a suitable vrr test frequency. */
-static uint64_t get_test_rate_ns(data_t *data, igt_output_t *output)
+/* Returns vrr test frequency for min, mid & max range. */
+static vtest_ns_t get_test_rate_ns(data_t *data, igt_output_t *output)
 {
-	drmModeModeInfo *mode = igt_output_get_mode(output);
 	range_t range;
-	uint64_t vtest;
+	vtest_ns_t vtest_ns;
 
-	/*
-	 * The frequency with the fastest convergence speed should be
-	 * the midpoint between the current mode vfreq and the min
-	 * supported vfreq.
-	 */
 	range = get_vrr_range(data, output);
-	igt_require(mode->vrefresh > range.min);
+	vtest_ns.min = rate_from_refresh(range.min);
+	vtest_ns.mid = rate_from_refresh(((range.max + range.min) / 2));
+	vtest_ns.max = rate_from_refresh(range.max);
 
-	vtest = (mode->vrefresh - range.min) / 2 + range.min;
-	igt_require(vtest < mode->vrefresh);
-
-	return rate_from_refresh(vtest);
+	return vtest_ns;
 }
 
 /* Returns true if an output supports VRR. */
@@ -240,6 +248,7 @@ flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
 	uint64_t start_ns, last_vblank_ns;
 	uint32_t total_flip = 0, total_pass = 0;
 	bool front = false;
+	vtest_ns_t vtest_ns = get_test_rate_ns(data, output);
 
 	/* Align with the vblank region to speed up convergence. */
 	last_vblank_ns = wait_for_vblank(data, pipe);
@@ -253,10 +262,6 @@ flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
 		do_flip(data, pipe, front ? &data->fb1 : &data->fb0);
 
 		vblank_ns = wait_for_vblank(data, pipe);
-		diff_ns = rate_ns - (vblank_ns - last_vblank_ns);
-		last_vblank_ns = vblank_ns;
-
-		total_flip += 1;
 
 		/*
 		 * Check if the difference between the two flip timestamps
@@ -266,9 +271,19 @@ flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
 		 * difference between 144Hz and 143Hz which should give this
 		 * enough accuracy for most use cases.
 		 */
+		if ((rate_ns <= vtest_ns.min) && (rate_ns >= vtest_ns.max))
+			diff_ns = rate_ns - (vblank_ns - last_vblank_ns);
+		else if (rate_ns > vtest_ns.min)
+			diff_ns = vtest_ns.min - (vblank_ns - last_vblank_ns);
+		else if (rate_ns < vtest_ns.max)
+			diff_ns = vtest_ns.max - (vblank_ns - last_vblank_ns);
+
 		if (llabs(diff_ns) < 50000ll)
 			total_pass += 1;
 
+		last_vblank_ns = vblank_ns;
+		total_flip += 1;
+
 		now_ns = get_time_ns();
 		if (now_ns - start_ns > duration_ns)
 			break;
@@ -295,10 +310,13 @@ flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
 static void
 test_basic(data_t *data, enum pipe pipe, igt_output_t *output, uint32_t flags)
 {
-	uint64_t rate;
 	uint32_t result;
+	vtest_ns_t vtest_ns = get_test_rate_ns(data, output);
+	range_t range = get_vrr_range(data, output);
+	uint64_t rate = vtest_ns.mid;
 
-	rate = get_test_rate_ns(data, output);
+	igt_info("VRR Test execution on %s, PIPE_%s\n",
+		 output->name, kmstest_pipe_name(pipe));
 
 	prepare_test(data, output, pipe);
 
@@ -324,6 +342,35 @@ test_basic(data_t *data, enum pipe pipe, igt_output_t *output, uint32_t flags)
 		igt_system_suspend_autoresume(SUSPEND_STATE_MEM,
 					      SUSPEND_TEST_NONE);
 
+	/*
+	 * Check flipline mode by making sure that flips happen at flipline
+	 * decision boundary.
+	 *
+	 * Example: if range is 40 - 60Hz and
+	 * if refresh_rate > 60Hz:
+	 *      Flip should happen at the flipline boundary & returned refresh rate
+	 *	would be 60Hz.
+	 * if refresh_rate is 50Hz:
+	 *      Flip will happen right away so returned refresh rate is 50Hz.
+	 * if refresh_rate < 40Hz:
+	 *      Flip should happen at the vmax so the returned refresh rate
+	 *	would be 40Hz.
+	 */
+	if (flags & TEST_FLIPLINE) {
+		rate = rate_from_refresh(range.min - 5);
+		result = flip_and_measure(data, output, pipe, rate, TEST_DURATION_NS);
+		igt_assert_f(result > 75,
+			     "Refresh rate %"PRIu64"ns: Target VRR on threshold not reached, result was %u%%\n",
+			     rate, result);
+
+		rate = rate_from_refresh(range.max + 5);
+		result = flip_and_measure(data, output, pipe, rate, TEST_DURATION_NS);
+		igt_assert_f(result > 75,
+			     "Refresh rate %"PRIu64"ns: Target VRR on threshold not reached, result was %u%%\n",
+			     rate, result);
+	}
+
+	rate = vtest_ns.mid;
 	result = flip_and_measure(data, output, pipe, rate, TEST_DURATION_NS);
 
 	set_vrr_on_pipe(data, pipe, 0);
@@ -331,14 +378,14 @@ test_basic(data_t *data, enum pipe pipe, igt_output_t *output, uint32_t flags)
 	/* This check is delayed until after VRR is disabled so it isn't
 	 * left enabled if the test fails. */
 	igt_assert_f(result > 75,
-		     "Target VRR on threshold not reached, result was %u%%\n",
-		     result);
+		     "Refresh rate %"PRIu64"ns: Target VRR on threshold not reached, result was %u%%\n",
+		     rate, result);
 
 	result = flip_and_measure(data, output, pipe, rate, TEST_DURATION_NS);
 
 	igt_assert_f(result < 10,
-		     "Target VRR off threshold exceeded, result was %u%%\n",
-		     result);
+		     "Refresh rate %"PRIu64"ns: Target VRR off threshold exceeded, result was %u%%\n",
+		     rate, result);
 
 	igt_remove_fb(data->drm_fd, &data->fb1);
 	igt_remove_fb(data->drm_fd, &data->fb0);
@@ -392,6 +439,10 @@ igt_main
 	igt_subtest("flip-suspend")
 		run_vrr_test(&data, test_basic, TEST_SUSPEND);
 
+	igt_describe("Make sure that flips happen at flipline decision boundary.");
+	igt_subtest("flipline")
+		run_vrr_test(&data, test_basic, TEST_FLIPLINE);
+
 	igt_fixture {
 		igt_display_fini(&data.display);
 	}
-- 
2.24.1.1.gb6d4d82bd5

_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

Re: [igt-dev] [RFC PATCH 2/2] tests/kms_vrr: Add new subtest to validate Flipline mode

[Manasi Navare]

On Mon, May 11, 2020 at 11:56:47AM +0530, bhanuprakash.modem@intel.com wrote:
> From: Bhanuprakash Modem <bhanuprakash.modem@intel.com>
> 
> Check flipline mode by making sure that flips happen at flipline
> decision boundary.
> 
> Example: if monitor vrr range is 40 - 60Hz and
> 
> * flip at refresh_rate > 60Hz:
>   	Flip should happen at the flipline boundary & returned refresh rate
> 	would be 60Hz.
> * flip at refresh_rate == 50Hz:
> 	Flip should happen right away so returned refresh rate is 50Hz.
> * flip at refresh_rate < 40Hz:
> 	Flip should happen at the vmax so the returned refresh rate
> 	would be 40Hz.
> 
> Cc: Harry Wentland <harry.wentland@amd.com>
> Cc: Nicholas Kazlauskas <nicholas.kazlauskas@amd.com>
> Cc: Manasi Navare <manasi.d.navare@intel.com>
> Signed-off-by: Bhanuprakash Modem <bhanuprakash.modem@intel.com>
> ---
>  tests/kms_vrr.c | 101 ++++++++++++++++++++++++++++++++++++------------
>  1 file changed, 76 insertions(+), 25 deletions(-)
> 
> diff --git a/tests/kms_vrr.c b/tests/kms_vrr.c
> index 0fe28931..c8a8c065 100644
> --- a/tests/kms_vrr.c
> +++ b/tests/kms_vrr.c
> @@ -37,6 +37,7 @@ enum {
>  	TEST_NONE = 0,
>  	TEST_DPMS = 1 << 0,
>  	TEST_SUSPEND = 1 << 1,
> +	TEST_FLIPLINE = 1 << 2,
>  };
>  
>  typedef struct range {
> @@ -51,6 +52,12 @@ typedef struct data {
>  	igt_fb_t fb1;
>  } data_t;
>  
> +typedef struct vtest_ns {
> +	uint64_t min;
> +	uint64_t mid;
> +	uint64_t max;
> +} vtest_ns_t;
> +
>  typedef void (*test_t)(data_t*, enum pipe, igt_output_t*, uint32_t);
>  
>  /* Converts a timespec structure to nanoseconds. */
> @@ -100,13 +107,18 @@ static uint64_t rate_from_refresh(uint64_t refresh)
>  	return NSECS_PER_SEC / refresh;
>  }
>  
> -/* Returns the min and max vrr range from the connector debugfs. */
> +/* Read min and max vrr range from the connector debugfs.
> + * - min range should be less than the current mode vfreq
> + * - if max range is grater than the current mode vfreq, consider
> + *	current mode vfreq as the max range.
> + */
>  static range_t get_vrr_range(data_t *data, igt_output_t *output)
>  {
>  	char buf[256];
>  	char *start_loc;
>  	int fd, res;
>  	range_t range;
> +	drmModeModeInfo *mode = igt_output_get_mode(output);
>  
>  	fd = igt_debugfs_connector_dir(data->drm_fd, output->name, O_RDONLY);
>  	igt_assert(fd >= 0);
> @@ -118,32 +130,28 @@ static range_t get_vrr_range(data_t *data, igt_output_t *output)
>  
>  	igt_assert(start_loc = strstr(buf, "Min: "));
>  	igt_assert_eq(sscanf(start_loc, "Min: %u", &range.min), 1);
> +	igt_require(mode->vrefresh > range.min);

Why is it a req to have mode->vrefresh greater than Range.min? I think it also can be equal
to the min refresh rate right? Is it just to make sure that after enabling VRR, we can still
strtch the vblank further than the existing vblank to achieve even lower refresh rate?

May be in this case also better to add this comment somewhere or something under igt_debug atleast

Manasi


>  
>  	igt_assert(start_loc = strstr(buf, "Max: "));
>  	igt_assert_eq(sscanf(start_loc, "Max: %u", &range.max), 1);
>  
> +	range.max = (mode->vrefresh < range.max) ? mode->vrefresh : range.max;
> +
>  	return range;
>  }
>  
> -/* Returns a suitable vrr test frequency. */
> -static uint64_t get_test_rate_ns(data_t *data, igt_output_t *output)
> +/* Returns vrr test frequency for min, mid & max range. */
> +static vtest_ns_t get_test_rate_ns(data_t *data, igt_output_t *output)
>  {
> -	drmModeModeInfo *mode = igt_output_get_mode(output);
>  	range_t range;
> -	uint64_t vtest;
> +	vtest_ns_t vtest_ns;
>  
> -	/*
> -	 * The frequency with the fastest convergence speed should be
> -	 * the midpoint between the current mode vfreq and the min
> -	 * supported vfreq.
> -	 */
>  	range = get_vrr_range(data, output);
> -	igt_require(mode->vrefresh > range.min);
> +	vtest_ns.min = rate_from_refresh(range.min);
> +	vtest_ns.mid = rate_from_refresh(((range.max + range.min) / 2));
> +	vtest_ns.max = rate_from_refresh(range.max);
>  
> -	vtest = (mode->vrefresh - range.min) / 2 + range.min;
> -	igt_require(vtest < mode->vrefresh);
> -
> -	return rate_from_refresh(vtest);
> +	return vtest_ns;
>  }
>  
>  /* Returns true if an output supports VRR. */
> @@ -240,6 +248,7 @@ flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
>  	uint64_t start_ns, last_vblank_ns;
>  	uint32_t total_flip = 0, total_pass = 0;
>  	bool front = false;
> +	vtest_ns_t vtest_ns = get_test_rate_ns(data, output);
>  
>  	/* Align with the vblank region to speed up convergence. */
>  	last_vblank_ns = wait_for_vblank(data, pipe);
> @@ -253,10 +262,6 @@ flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
>  		do_flip(data, pipe, front ? &data->fb1 : &data->fb0);
>  
>  		vblank_ns = wait_for_vblank(data, pipe);
> -		diff_ns = rate_ns - (vblank_ns - last_vblank_ns);
> -		last_vblank_ns = vblank_ns;
> -
> -		total_flip += 1;
>  
>  		/*
>  		 * Check if the difference between the two flip timestamps
> @@ -266,9 +271,19 @@ flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
>  		 * difference between 144Hz and 143Hz which should give this
>  		 * enough accuracy for most use cases.
>  		 */
> +		if ((rate_ns <= vtest_ns.min) && (rate_ns >= vtest_ns.max))
> +			diff_ns = rate_ns - (vblank_ns - last_vblank_ns);
> +		else if (rate_ns > vtest_ns.min)
> +			diff_ns = vtest_ns.min - (vblank_ns - last_vblank_ns);
> +		else if (rate_ns < vtest_ns.max)
> +			diff_ns = vtest_ns.max - (vblank_ns - last_vblank_ns);
> +
>  		if (llabs(diff_ns) < 50000ll)
>  			total_pass += 1;
>  
> +		last_vblank_ns = vblank_ns;
> +		total_flip += 1;
> +
>  		now_ns = get_time_ns();
>  		if (now_ns - start_ns > duration_ns)
>  			break;
> @@ -295,10 +310,13 @@ flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
>  static void
>  test_basic(data_t *data, enum pipe pipe, igt_output_t *output, uint32_t flags)
>  {
> -	uint64_t rate;
>  	uint32_t result;
> +	vtest_ns_t vtest_ns = get_test_rate_ns(data, output);
> +	range_t range = get_vrr_range(data, output);
> +	uint64_t rate = vtest_ns.mid;
>  
> -	rate = get_test_rate_ns(data, output);
> +	igt_info("VRR Test execution on %s, PIPE_%s\n",
> +		 output->name, kmstest_pipe_name(pipe));
>  
>  	prepare_test(data, output, pipe);
>  
> @@ -324,6 +342,35 @@ test_basic(data_t *data, enum pipe pipe, igt_output_t *output, uint32_t flags)
>  		igt_system_suspend_autoresume(SUSPEND_STATE_MEM,
>  					      SUSPEND_TEST_NONE);
>  
> +	/*
> +	 * Check flipline mode by making sure that flips happen at flipline
> +	 * decision boundary.
> +	 *
> +	 * Example: if range is 40 - 60Hz and
> +	 * if refresh_rate > 60Hz:
> +	 *      Flip should happen at the flipline boundary & returned refresh rate
> +	 *	would be 60Hz.
> +	 * if refresh_rate is 50Hz:
> +	 *      Flip will happen right away so returned refresh rate is 50Hz.
> +	 * if refresh_rate < 40Hz:
> +	 *      Flip should happen at the vmax so the returned refresh rate
> +	 *	would be 40Hz.
> +	 */
> +	if (flags & TEST_FLIPLINE) {
> +		rate = rate_from_refresh(range.min - 5);
> +		result = flip_and_measure(data, output, pipe, rate, TEST_DURATION_NS);
> +		igt_assert_f(result > 75,
> +			     "Refresh rate %"PRIu64"ns: Target VRR on threshold not reached, result was %u%%\n",
> +			     rate, result);
> +
> +		rate = rate_from_refresh(range.max + 5);
> +		result = flip_and_measure(data, output, pipe, rate, TEST_DURATION_NS);
> +		igt_assert_f(result > 75,
> +			     "Refresh rate %"PRIu64"ns: Target VRR on threshold not reached, result was %u%%\n",
> +			     rate, result);
> +	}
> +
> +	rate = vtest_ns.mid;
>  	result = flip_and_measure(data, output, pipe, rate, TEST_DURATION_NS);
>  
>  	set_vrr_on_pipe(data, pipe, 0);
> @@ -331,14 +378,14 @@ test_basic(data_t *data, enum pipe pipe, igt_output_t *output, uint32_t flags)
>  	/* This check is delayed until after VRR is disabled so it isn't
>  	 * left enabled if the test fails. */
>  	igt_assert_f(result > 75,
> -		     "Target VRR on threshold not reached, result was %u%%\n",
> -		     result);
> +		     "Refresh rate %"PRIu64"ns: Target VRR on threshold not reached, result was %u%%\n",
> +		     rate, result);
>  
>  	result = flip_and_measure(data, output, pipe, rate, TEST_DURATION_NS);
>  
>  	igt_assert_f(result < 10,
> -		     "Target VRR off threshold exceeded, result was %u%%\n",
> -		     result);
> +		     "Refresh rate %"PRIu64"ns: Target VRR off threshold exceeded, result was %u%%\n",
> +		     rate, result);
>  
>  	igt_remove_fb(data->drm_fd, &data->fb1);
>  	igt_remove_fb(data->drm_fd, &data->fb0);
> @@ -392,6 +439,10 @@ igt_main
>  	igt_subtest("flip-suspend")
>  		run_vrr_test(&data, test_basic, TEST_SUSPEND);
>  
> +	igt_describe("Make sure that flips happen at flipline decision boundary.");
> +	igt_subtest("flipline")
> +		run_vrr_test(&data, test_basic, TEST_FLIPLINE);
> +
>  	igt_fixture {
>  		igt_display_fini(&data.display);
>  	}
> -- 
> 2.24.1.1.gb6d4d82bd5
> 
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

Re: [igt-dev] [RFC PATCH 2/2] tests/kms_vrr: Add new subtest to validate Flipline mode

[Kazlauskas, Nicholas]

On 2020-06-03 3:47 p.m., Manasi Navare wrote:
> On Mon, May 11, 2020 at 11:56:47AM +0530, bhanuprakash.modem@intel.com wrote:
>> From: Bhanuprakash Modem <bhanuprakash.modem@intel.com>
>>
>> Check flipline mode by making sure that flips happen at flipline
>> decision boundary.
>>
>> Example: if monitor vrr range is 40 - 60Hz and
>>
>> * flip at refresh_rate > 60Hz:
>>    	Flip should happen at the flipline boundary & returned refresh rate
>> 	would be 60Hz.
>> * flip at refresh_rate == 50Hz:
>> 	Flip should happen right away so returned refresh rate is 50Hz.
>> * flip at refresh_rate < 40Hz:
>> 	Flip should happen at the vmax so the returned refresh rate
>> 	would be 40Hz.
>>
>> Cc: Harry Wentland <harry.wentland@amd.com>
>> Cc: Nicholas Kazlauskas <nicholas.kazlauskas@amd.com>
>> Cc: Manasi Navare <manasi.d.navare@intel.com>
>> Signed-off-by: Bhanuprakash Modem <bhanuprakash.modem@intel.com>
>> ---
>>   tests/kms_vrr.c | 101 ++++++++++++++++++++++++++++++++++++------------
>>   1 file changed, 76 insertions(+), 25 deletions(-)
>>
>> diff --git a/tests/kms_vrr.c b/tests/kms_vrr.c
>> index 0fe28931..c8a8c065 100644
>> --- a/tests/kms_vrr.c
>> +++ b/tests/kms_vrr.c
>> @@ -37,6 +37,7 @@ enum {
>>   	TEST_NONE = 0,
>>   	TEST_DPMS = 1 << 0,
>>   	TEST_SUSPEND = 1 << 1,
>> +	TEST_FLIPLINE = 1 << 2,
>>   };
>>   
>>   typedef struct range {
>> @@ -51,6 +52,12 @@ typedef struct data {
>>   	igt_fb_t fb1;
>>   } data_t;
>>   
>> +typedef struct vtest_ns {
>> +	uint64_t min;
>> +	uint64_t mid;
>> +	uint64_t max;
>> +} vtest_ns_t;
>> +
>>   typedef void (*test_t)(data_t*, enum pipe, igt_output_t*, uint32_t);
>>   
>>   /* Converts a timespec structure to nanoseconds. */
>> @@ -100,13 +107,18 @@ static uint64_t rate_from_refresh(uint64_t refresh)
>>   	return NSECS_PER_SEC / refresh;
>>   }
>>   
>> -/* Returns the min and max vrr range from the connector debugfs. */
>> +/* Read min and max vrr range from the connector debugfs.
>> + * - min range should be less than the current mode vfreq
>> + * - if max range is grater than the current mode vfreq, consider
>> + *	current mode vfreq as the max range.
>> + */
>>   static range_t get_vrr_range(data_t *data, igt_output_t *output)
>>   {
>>   	char buf[256];
>>   	char *start_loc;
>>   	int fd, res;
>>   	range_t range;
>> +	drmModeModeInfo *mode = igt_output_get_mode(output);
>>   
>>   	fd = igt_debugfs_connector_dir(data->drm_fd, output->name, O_RDONLY);
>>   	igt_assert(fd >= 0);
>> @@ -118,32 +130,28 @@ static range_t get_vrr_range(data_t *data, igt_output_t *output)
>>   
>>   	igt_assert(start_loc = strstr(buf, "Min: "));
>>   	igt_assert_eq(sscanf(start_loc, "Min: %u", &range.min), 1);
>> +	igt_require(mode->vrefresh > range.min);
> 
> Why is it a req to have mode->vrefresh greater than Range.min? I think it also can be equal
> to the min refresh rate right? Is it just to make sure that after enabling VRR, we can still
> strtch the vblank further than the existing vblank to achieve even lower refresh rate?
> 
> May be in this case also better to add this comment somewhere or something under igt_debug atleast
> 
> Manasi

Haven't had a chance to check this update on AMD hardware yet, but I 
can respond to this at least.

Adaptive sync extends the front porch duration and there's a fixed 
portion of the front porch defined by the current refresh rate rate. You 
can't shorten the fixed portion.

The monitor will generally blank out if you try.

Regards,
Nicholas Kazlauskas

> 
> 
>>   
>>   	igt_assert(start_loc = strstr(buf, "Max: "));
>>   	igt_assert_eq(sscanf(start_loc, "Max: %u", &range.max), 1);
>>   
>> +	range.max = (mode->vrefresh < range.max) ? mode->vrefresh : range.max;
>> +
>>   	return range;
>>   }
>>   
>> -/* Returns a suitable vrr test frequency. */
>> -static uint64_t get_test_rate_ns(data_t *data, igt_output_t *output)
>> +/* Returns vrr test frequency for min, mid & max range. */
>> +static vtest_ns_t get_test_rate_ns(data_t *data, igt_output_t *output)
>>   {
>> -	drmModeModeInfo *mode = igt_output_get_mode(output);
>>   	range_t range;
>> -	uint64_t vtest;
>> +	vtest_ns_t vtest_ns;
>>   
>> -	/*
>> -	 * The frequency with the fastest convergence speed should be
>> -	 * the midpoint between the current mode vfreq and the min
>> -	 * supported vfreq.
>> -	 */
>>   	range = get_vrr_range(data, output);
>> -	igt_require(mode->vrefresh > range.min);
>> +	vtest_ns.min = rate_from_refresh(range.min);
>> +	vtest_ns.mid = rate_from_refresh(((range.max + range.min) / 2));
>> +	vtest_ns.max = rate_from_refresh(range.max);
>>   
>> -	vtest = (mode->vrefresh - range.min) / 2 + range.min;
>> -	igt_require(vtest < mode->vrefresh);
>> -
>> -	return rate_from_refresh(vtest);
>> +	return vtest_ns;
>>   }
>>   
>>   /* Returns true if an output supports VRR. */
>> @@ -240,6 +248,7 @@ flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
>>   	uint64_t start_ns, last_vblank_ns;
>>   	uint32_t total_flip = 0, total_pass = 0;
>>   	bool front = false;
>> +	vtest_ns_t vtest_ns = get_test_rate_ns(data, output);
>>   
>>   	/* Align with the vblank region to speed up convergence. */
>>   	last_vblank_ns = wait_for_vblank(data, pipe);
>> @@ -253,10 +262,6 @@ flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
>>   		do_flip(data, pipe, front ? &data->fb1 : &data->fb0);
>>   
>>   		vblank_ns = wait_for_vblank(data, pipe);
>> -		diff_ns = rate_ns - (vblank_ns - last_vblank_ns);
>> -		last_vblank_ns = vblank_ns;
>> -
>> -		total_flip += 1;
>>   
>>   		/*
>>   		 * Check if the difference between the two flip timestamps
>> @@ -266,9 +271,19 @@ flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
>>   		 * difference between 144Hz and 143Hz which should give this
>>   		 * enough accuracy for most use cases.
>>   		 */
>> +		if ((rate_ns <= vtest_ns.min) && (rate_ns >= vtest_ns.max))
>> +			diff_ns = rate_ns - (vblank_ns - last_vblank_ns);
>> +		else if (rate_ns > vtest_ns.min)
>> +			diff_ns = vtest_ns.min - (vblank_ns - last_vblank_ns);
>> +		else if (rate_ns < vtest_ns.max)
>> +			diff_ns = vtest_ns.max - (vblank_ns - last_vblank_ns);
>> +
>>   		if (llabs(diff_ns) < 50000ll)
>>   			total_pass += 1;
>>   
>> +		last_vblank_ns = vblank_ns;
>> +		total_flip += 1;
>> +
>>   		now_ns = get_time_ns();
>>   		if (now_ns - start_ns > duration_ns)
>>   			break;
>> @@ -295,10 +310,13 @@ flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
>>   static void
>>   test_basic(data_t *data, enum pipe pipe, igt_output_t *output, uint32_t flags)
>>   {
>> -	uint64_t rate;
>>   	uint32_t result;
>> +	vtest_ns_t vtest_ns = get_test_rate_ns(data, output);
>> +	range_t range = get_vrr_range(data, output);
>> +	uint64_t rate = vtest_ns.mid;
>>   
>> -	rate = get_test_rate_ns(data, output);
>> +	igt_info("VRR Test execution on %s, PIPE_%s\n",
>> +		 output->name, kmstest_pipe_name(pipe));
>>   
>>   	prepare_test(data, output, pipe);
>>   
>> @@ -324,6 +342,35 @@ test_basic(data_t *data, enum pipe pipe, igt_output_t *output, uint32_t flags)
>>   		igt_system_suspend_autoresume(SUSPEND_STATE_MEM,
>>   					      SUSPEND_TEST_NONE);
>>   
>> +	/*
>> +	 * Check flipline mode by making sure that flips happen at flipline
>> +	 * decision boundary.
>> +	 *
>> +	 * Example: if range is 40 - 60Hz and
>> +	 * if refresh_rate > 60Hz:
>> +	 *      Flip should happen at the flipline boundary & returned refresh rate
>> +	 *	would be 60Hz.
>> +	 * if refresh_rate is 50Hz:
>> +	 *      Flip will happen right away so returned refresh rate is 50Hz.
>> +	 * if refresh_rate < 40Hz:
>> +	 *      Flip should happen at the vmax so the returned refresh rate
>> +	 *	would be 40Hz.
>> +	 */
>> +	if (flags & TEST_FLIPLINE) {
>> +		rate = rate_from_refresh(range.min - 5);
>> +		result = flip_and_measure(data, output, pipe, rate, TEST_DURATION_NS);
>> +		igt_assert_f(result > 75,
>> +			     "Refresh rate %"PRIu64"ns: Target VRR on threshold not reached, result was %u%%\n",
>> +			     rate, result);
>> +
>> +		rate = rate_from_refresh(range.max + 5);
>> +		result = flip_and_measure(data, output, pipe, rate, TEST_DURATION_NS);
>> +		igt_assert_f(result > 75,
>> +			     "Refresh rate %"PRIu64"ns: Target VRR on threshold not reached, result was %u%%\n",
>> +			     rate, result);
>> +	}
>> +
>> +	rate = vtest_ns.mid;
>>   	result = flip_and_measure(data, output, pipe, rate, TEST_DURATION_NS);
>>   
>>   	set_vrr_on_pipe(data, pipe, 0);
>> @@ -331,14 +378,14 @@ test_basic(data_t *data, enum pipe pipe, igt_output_t *output, uint32_t flags)
>>   	/* This check is delayed until after VRR is disabled so it isn't
>>   	 * left enabled if the test fails. */
>>   	igt_assert_f(result > 75,
>> -		     "Target VRR on threshold not reached, result was %u%%\n",
>> -		     result);
>> +		     "Refresh rate %"PRIu64"ns: Target VRR on threshold not reached, result was %u%%\n",
>> +		     rate, result);
>>   
>>   	result = flip_and_measure(data, output, pipe, rate, TEST_DURATION_NS);
>>   
>>   	igt_assert_f(result < 10,
>> -		     "Target VRR off threshold exceeded, result was %u%%\n",
>> -		     result);
>> +		     "Refresh rate %"PRIu64"ns: Target VRR off threshold exceeded, result was %u%%\n",
>> +		     rate, result);
>>   
>>   	igt_remove_fb(data->drm_fd, &data->fb1);
>>   	igt_remove_fb(data->drm_fd, &data->fb0);
>> @@ -392,6 +439,10 @@ igt_main
>>   	igt_subtest("flip-suspend")
>>   		run_vrr_test(&data, test_basic, TEST_SUSPEND);
>>   
>> +	igt_describe("Make sure that flips happen at flipline decision boundary.");
>> +	igt_subtest("flipline")
>> +		run_vrr_test(&data, test_basic, TEST_FLIPLINE);
>> +
>>   	igt_fixture {
>>   		igt_display_fini(&data.display);
>>   	}
>> -- 
>> 2.24.1.1.gb6d4d82bd5
>>

_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

Re: [igt-dev] [RFC PATCH 2/2] tests/kms_vrr: Add new subtest to validate Flipline mode

[Manasi Navare]

On Wed, Jun 03, 2020 at 03:50:15PM -0400, Kazlauskas, Nicholas wrote:
> On 2020-06-03 3:47 p.m., Manasi Navare wrote:
> >On Mon, May 11, 2020 at 11:56:47AM +0530, bhanuprakash.modem@intel.com wrote:
> >>From: Bhanuprakash Modem <bhanuprakash.modem@intel.com>
> >>
> >>Check flipline mode by making sure that flips happen at flipline
> >>decision boundary.
> >>
> >>Example: if monitor vrr range is 40 - 60Hz and
> >>
> >>* flip at refresh_rate > 60Hz:
> >>   	Flip should happen at the flipline boundary & returned refresh rate
> >>	would be 60Hz.
> >>* flip at refresh_rate == 50Hz:
> >>	Flip should happen right away so returned refresh rate is 50Hz.
> >>* flip at refresh_rate < 40Hz:
> >>	Flip should happen at the vmax so the returned refresh rate
> >>	would be 40Hz.
> >>
> >>Cc: Harry Wentland <harry.wentland@amd.com>
> >>Cc: Nicholas Kazlauskas <nicholas.kazlauskas@amd.com>
> >>Cc: Manasi Navare <manasi.d.navare@intel.com>
> >>Signed-off-by: Bhanuprakash Modem <bhanuprakash.modem@intel.com>
> >>---
> >>  tests/kms_vrr.c | 101 ++++++++++++++++++++++++++++++++++++------------
> >>  1 file changed, 76 insertions(+), 25 deletions(-)
> >>
> >>diff --git a/tests/kms_vrr.c b/tests/kms_vrr.c
> >>index 0fe28931..c8a8c065 100644
> >>--- a/tests/kms_vrr.c
> >>+++ b/tests/kms_vrr.c
> >>@@ -37,6 +37,7 @@ enum {
> >>  	TEST_NONE = 0,
> >>  	TEST_DPMS = 1 << 0,
> >>  	TEST_SUSPEND = 1 << 1,
> >>+	TEST_FLIPLINE = 1 << 2,
> >>  };
> >>  typedef struct range {
> >>@@ -51,6 +52,12 @@ typedef struct data {
> >>  	igt_fb_t fb1;
> >>  } data_t;
> >>+typedef struct vtest_ns {
> >>+	uint64_t min;
> >>+	uint64_t mid;
> >>+	uint64_t max;
> >>+} vtest_ns_t;
> >>+
> >>  typedef void (*test_t)(data_t*, enum pipe, igt_output_t*, uint32_t);
> >>  /* Converts a timespec structure to nanoseconds. */
> >>@@ -100,13 +107,18 @@ static uint64_t rate_from_refresh(uint64_t refresh)
> >>  	return NSECS_PER_SEC / refresh;
> >>  }
> >>-/* Returns the min and max vrr range from the connector debugfs. */
> >>+/* Read min and max vrr range from the connector debugfs.
> >>+ * - min range should be less than the current mode vfreq
> >>+ * - if max range is grater than the current mode vfreq, consider
> >>+ *	current mode vfreq as the max range.
> >>+ */
> >>  static range_t get_vrr_range(data_t *data, igt_output_t *output)
> >>  {
> >>  	char buf[256];
> >>  	char *start_loc;
> >>  	int fd, res;
> >>  	range_t range;
> >>+	drmModeModeInfo *mode = igt_output_get_mode(output);
> >>  	fd = igt_debugfs_connector_dir(data->drm_fd, output->name, O_RDONLY);
> >>  	igt_assert(fd >= 0);
> >>@@ -118,32 +130,28 @@ static range_t get_vrr_range(data_t *data, igt_output_t *output)
> >>  	igt_assert(start_loc = strstr(buf, "Min: "));
> >>  	igt_assert_eq(sscanf(start_loc, "Min: %u", &range.min), 1);
> >>+	igt_require(mode->vrefresh > range.min);
> >
> >Why is it a req to have mode->vrefresh greater than Range.min? I think it also can be equal
> >to the min refresh rate right? Is it just to make sure that after enabling VRR, we can still
> >strtch the vblank further than the existing vblank to achieve even lower refresh rate?
> >
> >May be in this case also better to add this comment somewhere or something under igt_debug atleast
> >
> >Manasi
> 
> Haven't had a chance to check this update on AMD hardware yet, but I can
> respond to this at least.
> 
> Adaptive sync extends the front porch duration and there's a fixed portion
> of the front porch defined by the current refresh rate rate. You can't
> shorten the fixed portion.
> 
> The monitor will generally blank out if you try.
> 
> Regards,
> Nicholas Kazlauskas

Yes I do agree with you. But what you are saying is that basically you cannot shorten the vblank duration further
which puts limit on the maximum refresh rate that can be achieved meaning that the max refresh rate gets upper bounded
by the current refresh rate. For Eg: if we running at 60Hz, then if IGT requests a refresh rate greater than 60Hz then
the achieved refresh rate would still be 60Hz and thats done on Intel HW using something called as the flipline value
that is set to the minimum Vtotal corresponding to the max refresh rate.

But yea checking mode->vrefresh > range.min is probably a safe check, probably just add some comment to explain this.

Also Nicholas, yes it would be great if you can check that the synchronous atomic commit still work on AMD HW.


Regards
Manasi
> 
> >
> >
> >>  	igt_assert(start_loc = strstr(buf, "Max: "));
> >>  	igt_assert_eq(sscanf(start_loc, "Max: %u", &range.max), 1);
> >>+	range.max = (mode->vrefresh < range.max) ? mode->vrefresh : range.max;
> >>+
> >>  	return range;
> >>  }
> >>-/* Returns a suitable vrr test frequency. */
> >>-static uint64_t get_test_rate_ns(data_t *data, igt_output_t *output)
> >>+/* Returns vrr test frequency for min, mid & max range. */
> >>+static vtest_ns_t get_test_rate_ns(data_t *data, igt_output_t *output)
> >>  {
> >>-	drmModeModeInfo *mode = igt_output_get_mode(output);
> >>  	range_t range;
> >>-	uint64_t vtest;
> >>+	vtest_ns_t vtest_ns;
> >>-	/*
> >>-	 * The frequency with the fastest convergence speed should be
> >>-	 * the midpoint between the current mode vfreq and the min
> >>-	 * supported vfreq.
> >>-	 */
> >>  	range = get_vrr_range(data, output);
> >>-	igt_require(mode->vrefresh > range.min);
> >>+	vtest_ns.min = rate_from_refresh(range.min);
> >>+	vtest_ns.mid = rate_from_refresh(((range.max + range.min) / 2));
> >>+	vtest_ns.max = rate_from_refresh(range.max);
> >>-	vtest = (mode->vrefresh - range.min) / 2 + range.min;
> >>-	igt_require(vtest < mode->vrefresh);
> >>-
> >>-	return rate_from_refresh(vtest);
> >>+	return vtest_ns;
> >>  }
> >>  /* Returns true if an output supports VRR. */
> >>@@ -240,6 +248,7 @@ flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
> >>  	uint64_t start_ns, last_vblank_ns;
> >>  	uint32_t total_flip = 0, total_pass = 0;
> >>  	bool front = false;
> >>+	vtest_ns_t vtest_ns = get_test_rate_ns(data, output);
> >>  	/* Align with the vblank region to speed up convergence. */
> >>  	last_vblank_ns = wait_for_vblank(data, pipe);
> >>@@ -253,10 +262,6 @@ flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
> >>  		do_flip(data, pipe, front ? &data->fb1 : &data->fb0);
> >>  		vblank_ns = wait_for_vblank(data, pipe);
> >>-		diff_ns = rate_ns - (vblank_ns - last_vblank_ns);
> >>-		last_vblank_ns = vblank_ns;
> >>-
> >>-		total_flip += 1;
> >>  		/*
> >>  		 * Check if the difference between the two flip timestamps
> >>@@ -266,9 +271,19 @@ flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
> >>  		 * difference between 144Hz and 143Hz which should give this
> >>  		 * enough accuracy for most use cases.
> >>  		 */
> >>+		if ((rate_ns <= vtest_ns.min) && (rate_ns >= vtest_ns.max))
> >>+			diff_ns = rate_ns - (vblank_ns - last_vblank_ns);
> >>+		else if (rate_ns > vtest_ns.min)
> >>+			diff_ns = vtest_ns.min - (vblank_ns - last_vblank_ns);
> >>+		else if (rate_ns < vtest_ns.max)
> >>+			diff_ns = vtest_ns.max - (vblank_ns - last_vblank_ns);
> >>+
> >>  		if (llabs(diff_ns) < 50000ll)
> >>  			total_pass += 1;
> >>+		last_vblank_ns = vblank_ns;
> >>+		total_flip += 1;
> >>+
> >>  		now_ns = get_time_ns();
> >>  		if (now_ns - start_ns > duration_ns)
> >>  			break;
> >>@@ -295,10 +310,13 @@ flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
> >>  static void
> >>  test_basic(data_t *data, enum pipe pipe, igt_output_t *output, uint32_t flags)
> >>  {
> >>-	uint64_t rate;
> >>  	uint32_t result;
> >>+	vtest_ns_t vtest_ns = get_test_rate_ns(data, output);
> >>+	range_t range = get_vrr_range(data, output);
> >>+	uint64_t rate = vtest_ns.mid;
> >>-	rate = get_test_rate_ns(data, output);
> >>+	igt_info("VRR Test execution on %s, PIPE_%s\n",
> >>+		 output->name, kmstest_pipe_name(pipe));
> >>  	prepare_test(data, output, pipe);
> >>@@ -324,6 +342,35 @@ test_basic(data_t *data, enum pipe pipe, igt_output_t *output, uint32_t flags)
> >>  		igt_system_suspend_autoresume(SUSPEND_STATE_MEM,
> >>  					      SUSPEND_TEST_NONE);
> >>+	/*
> >>+	 * Check flipline mode by making sure that flips happen at flipline
> >>+	 * decision boundary.
> >>+	 *
> >>+	 * Example: if range is 40 - 60Hz and
> >>+	 * if refresh_rate > 60Hz:
> >>+	 *      Flip should happen at the flipline boundary & returned refresh rate
> >>+	 *	would be 60Hz.
> >>+	 * if refresh_rate is 50Hz:
> >>+	 *      Flip will happen right away so returned refresh rate is 50Hz.
> >>+	 * if refresh_rate < 40Hz:
> >>+	 *      Flip should happen at the vmax so the returned refresh rate
> >>+	 *	would be 40Hz.
> >>+	 */
> >>+	if (flags & TEST_FLIPLINE) {
> >>+		rate = rate_from_refresh(range.min - 5);
> >>+		result = flip_and_measure(data, output, pipe, rate, TEST_DURATION_NS);
> >>+		igt_assert_f(result > 75,
> >>+			     "Refresh rate %"PRIu64"ns: Target VRR on threshold not reached, result was %u%%\n",
> >>+			     rate, result);
> >>+
> >>+		rate = rate_from_refresh(range.max + 5);
> >>+		result = flip_and_measure(data, output, pipe, rate, TEST_DURATION_NS);
> >>+		igt_assert_f(result > 75,
> >>+			     "Refresh rate %"PRIu64"ns: Target VRR on threshold not reached, result was %u%%\n",
> >>+			     rate, result);
> >>+	}
> >>+
> >>+	rate = vtest_ns.mid;
> >>  	result = flip_and_measure(data, output, pipe, rate, TEST_DURATION_NS);
> >>  	set_vrr_on_pipe(data, pipe, 0);
> >>@@ -331,14 +378,14 @@ test_basic(data_t *data, enum pipe pipe, igt_output_t *output, uint32_t flags)
> >>  	/* This check is delayed until after VRR is disabled so it isn't
> >>  	 * left enabled if the test fails. */
> >>  	igt_assert_f(result > 75,
> >>-		     "Target VRR on threshold not reached, result was %u%%\n",
> >>-		     result);
> >>+		     "Refresh rate %"PRIu64"ns: Target VRR on threshold not reached, result was %u%%\n",
> >>+		     rate, result);
> >>  	result = flip_and_measure(data, output, pipe, rate, TEST_DURATION_NS);
> >>  	igt_assert_f(result < 10,
> >>-		     "Target VRR off threshold exceeded, result was %u%%\n",
> >>-		     result);
> >>+		     "Refresh rate %"PRIu64"ns: Target VRR off threshold exceeded, result was %u%%\n",
> >>+		     rate, result);
> >>  	igt_remove_fb(data->drm_fd, &data->fb1);
> >>  	igt_remove_fb(data->drm_fd, &data->fb0);
> >>@@ -392,6 +439,10 @@ igt_main
> >>  	igt_subtest("flip-suspend")
> >>  		run_vrr_test(&data, test_basic, TEST_SUSPEND);
> >>+	igt_describe("Make sure that flips happen at flipline decision boundary.");
> >>+	igt_subtest("flipline")
> >>+		run_vrr_test(&data, test_basic, TEST_FLIPLINE);
> >>+
> >>  	igt_fixture {
> >>  		igt_display_fini(&data.display);
> >>  	}
> >>-- 
> >>2.24.1.1.gb6d4d82bd5
> >>
> 
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

[igt-dev] [PATCH v2 2/2] tests/kms_vrr: Add new subtest to validate Flipline mode

[Bhanuprakash Modem]

Check flipline mode by making sure that flips happen at flipline
decision boundary.

Example: if monitor vrr range is 40 - 60Hz and

* flip at refresh_rate > 60Hz:
        Flip should happen at the flipline boundary & returned refresh rate
        would be 60Hz.
* flip at refresh_rate == 50Hz:
        Flip should happen right away so returned refresh rate is 50Hz.
* flip at refresh_rate < 40Hz:
        Flip should happen at the vmax so the returned refresh rate
        would be 40Hz.

Cc: Harry Wentland <harry.wentland@amd.com>
Cc: Nicholas Kazlauskas <nicholas.kazlauskas@amd.com>
Cc: Manasi Navare <manasi.d.navare@intel.com>
Signed-off-by: Bhanuprakash Modem <bhanuprakash.modem@intel.com>
---
 tests/kms_vrr.c | 101 ++++++++++++++++++++++++++++++++++++------------
 1 file changed, 76 insertions(+), 25 deletions(-)

diff --git a/tests/kms_vrr.c b/tests/kms_vrr.c
index b433a12e..3c5d572b 100644
--- a/tests/kms_vrr.c
+++ b/tests/kms_vrr.c
@@ -37,6 +37,7 @@ enum {
 	TEST_NONE = 0,
 	TEST_DPMS = 1 << 0,
 	TEST_SUSPEND = 1 << 1,
+	TEST_FLIPLINE = 1 << 2,
 };
 
 typedef struct range {
@@ -52,6 +53,12 @@ typedef struct data {
 	igt_fb_t fb1;
 } data_t;
 
+typedef struct vtest_ns {
+	uint64_t min;
+	uint64_t mid;
+	uint64_t max;
+} vtest_ns_t;
+
 typedef void (*test_t)(data_t*, enum pipe, igt_output_t*, uint32_t);
 
 /* Converts a timespec structure to nanoseconds. */
@@ -101,13 +108,18 @@ static uint64_t rate_from_refresh(uint64_t refresh)
 	return NSECS_PER_SEC / refresh;
 }
 
-/* Returns the min and max vrr range from the connector debugfs. */
+/* Read min and max vrr range from the connector debugfs.
+ *  - min range should be less than the current mode vfreq
+ *  - if max range is grater than the current mode vfreq, consider
+ *       current mode vfreq as the max range.
+ */
 static range_t get_vrr_range(data_t *data, igt_output_t *output)
 {
 	char buf[256];
 	char *start_loc;
 	int fd, res;
 	range_t range;
+	drmModeModeInfo *mode = igt_output_get_mode(output);
 
 	fd = igt_debugfs_connector_dir(data->drm_fd, output->name, O_RDONLY);
 	igt_assert(fd >= 0);
@@ -119,32 +131,28 @@ static range_t get_vrr_range(data_t *data, igt_output_t *output)
 
 	igt_assert(start_loc = strstr(buf, "Min: "));
 	igt_assert_eq(sscanf(start_loc, "Min: %u", &range.min), 1);
+	igt_require(mode->vrefresh > range.min);
 
 	igt_assert(start_loc = strstr(buf, "Max: "));
 	igt_assert_eq(sscanf(start_loc, "Max: %u", &range.max), 1);
 
+	range.max = (mode->vrefresh < range.max) ? mode->vrefresh : range.max;
+
 	return range;
 }
 
-/* Returns a suitable vrr test frequency. */
-static uint64_t get_test_rate_ns(data_t *data, igt_output_t *output)
+/* Returns vrr test frequency for min, mid & max range. */
+static vtest_ns_t get_test_rate_ns(data_t *data, igt_output_t *output)
 {
-	drmModeModeInfo *mode = igt_output_get_mode(output);
 	range_t range;
-	uint64_t vtest;
+	vtest_ns_t vtest_ns;
 
-	/*
-	 * The frequency with the fastest convergence speed should be
-	 * the midpoint between the current mode vfreq and the min
-	 * supported vfreq.
-	 */
 	range = get_vrr_range(data, output);
-	igt_require(mode->vrefresh > range.min);
+	vtest_ns.min = rate_from_refresh(range.min);
+	vtest_ns.mid = rate_from_refresh(((range.max + range.min) / 2));
+	vtest_ns.max = rate_from_refresh(range.max);
 
-	vtest = (mode->vrefresh - range.min) / 2 + range.min;
-	igt_require(vtest < mode->vrefresh);
-
-	return rate_from_refresh(vtest);
+	return vtest_ns;
 }
 
 /* Returns true if an output supports VRR. */
@@ -247,6 +255,7 @@ flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
 	uint64_t start_ns, last_vblank_ns;
 	uint32_t total_flip = 0, total_pass = 0;
 	bool front = false;
+	vtest_ns_t vtest_ns = get_test_rate_ns(data, output);
 
 	/* Align with the vblank region to speed up convergence. */
 	last_vblank_ns = wait_for_vblank(data, pipe);
@@ -260,10 +269,6 @@ flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
 		do_flip(data, front ? &data->fb1 : &data->fb0);
 
 		vblank_ns = get_vblank_event_ns(data);
-		diff_ns = rate_ns - (vblank_ns - last_vblank_ns);
-		last_vblank_ns = vblank_ns;
-
-		total_flip += 1;
 
 		/*
 		 * Check if the difference between the two flip timestamps
@@ -273,9 +278,19 @@ flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
 		 * difference between 144Hz and 143Hz which should give this
 		 * enough accuracy for most use cases.
 		 */
+		if ((rate_ns <= vtest_ns.min) && (rate_ns >= vtest_ns.max))
+			diff_ns = rate_ns - (vblank_ns - last_vblank_ns);
+		else if (rate_ns > vtest_ns.min)
+			diff_ns = vtest_ns.min - (vblank_ns - last_vblank_ns);
+		else if (rate_ns < vtest_ns.max)
+			diff_ns = vtest_ns.max - (vblank_ns - last_vblank_ns);
+
 		if (llabs(diff_ns) < 50000ll)
 			total_pass += 1;
 
+		last_vblank_ns = vblank_ns;
+		total_flip += 1;
+
 		now_ns = get_time_ns();
 		if (now_ns - start_ns > duration_ns)
 			break;
@@ -302,10 +317,13 @@ flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
 static void
 test_basic(data_t *data, enum pipe pipe, igt_output_t *output, uint32_t flags)
 {
-	uint64_t rate;
 	uint32_t result;
+	vtest_ns_t vtest_ns = get_test_rate_ns(data, output);
+	range_t range = get_vrr_range(data, output);
+	uint64_t rate = vtest_ns.mid;
 
-	rate = get_test_rate_ns(data, output);
+	igt_info("VRR Test execution on %s, PIPE_%s\n",
+		 output->name, kmstest_pipe_name(pipe));
 
 	prepare_test(data, output, pipe);
 
@@ -331,6 +349,35 @@ test_basic(data_t *data, enum pipe pipe, igt_output_t *output, uint32_t flags)
 		igt_system_suspend_autoresume(SUSPEND_STATE_MEM,
 					      SUSPEND_TEST_NONE);
 
+	/*
+	 * Check flipline mode by making sure that flips happen at flipline
+	 * decision boundary.
+	 *
+	 * Example: if range is 40 - 60Hz and
+	 * if refresh_rate > 60Hz:
+	 *      Flip should happen at the flipline boundary & returned refresh rate
+	 *      would be 60Hz.
+	 * if refresh_rate is 50Hz:
+	 *      Flip will happen right away so returned refresh rate is 50Hz.
+	 * if refresh_rate < 40Hz:
+	 *      Flip should happen at the vmax so the returned refresh rate
+	 *      would be 40Hz.
+	 */
+	if (flags & TEST_FLIPLINE) {
+		rate = rate_from_refresh(range.min - 5);
+		result = flip_and_measure(data, output, pipe, rate, TEST_DURATION_NS);
+		igt_assert_f(result > 75,
+			     "Refresh rate %"PRIu64"ns: Target VRR on threshold not reached, result was %u%%\n",
+			     rate, result);
+
+		rate = rate_from_refresh(range.max + 5);
+		result = flip_and_measure(data, output, pipe, rate, TEST_DURATION_NS);
+		igt_assert_f(result > 75,
+			     "Refresh rate %"PRIu64"ns: Target VRR on threshold not reached, result was %u%%\n",
+			     rate, result);
+	}
+
+	rate = vtest_ns.mid;
 	result = flip_and_measure(data, output, pipe, rate, TEST_DURATION_NS);
 
 	set_vrr_on_pipe(data, pipe, 0);
@@ -338,14 +385,14 @@ test_basic(data_t *data, enum pipe pipe, igt_output_t *output, uint32_t flags)
 	/* This check is delayed until after VRR is disabled so it isn't
 	 * left enabled if the test fails. */
 	igt_assert_f(result > 75,
-		     "Target VRR on threshold not reached, result was %u%%\n",
-		     result);
+		     "Refresh rate %"PRIu64"ns: Target VRR on threshold not reached, result was %u%%\n",
+		     rate, result);
 
 	result = flip_and_measure(data, output, pipe, rate, TEST_DURATION_NS);
 
 	igt_assert_f(result < 10,
-		     "Target VRR off threshold exceeded, result was %u%%\n",
-		     result);
+		     "Refresh rate %"PRIu64"ns: Target VRR off threshold exceeded, result was %u%%\n",
+		     rate, result);
 
 	igt_plane_set_fb(data->primary, NULL);
 	igt_remove_fb(data->drm_fd, &data->fb1);
@@ -400,6 +447,10 @@ igt_main
 	igt_subtest("flip-suspend")
 		run_vrr_test(&data, test_basic, TEST_SUSPEND);
 
+	igt_describe("Make sure that flips happen at flipline decision boundary.");
+	igt_subtest("flipline")
+		run_vrr_test(&data, test_basic, TEST_FLIPLINE);
+
 	igt_fixture {
 		igt_display_fini(&data.display);
 	}
-- 
2.20.1

_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

[igt-dev] ✓ Fi.CI.BAT: success for New subtest for VRR Flipline mode

[Patchwork]

== Series Details ==

Series: New subtest for VRR Flipline mode
URL   : https://patchwork.freedesktop.org/series/77128/
State : success

== Summary ==

CI Bug Log - changes from CI_DRM_8461 -> IGTPW_4553
====================================================

Summary
-------

  **SUCCESS**

  No regressions found.

  External URL: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/index.html

Known issues
------------

  Here are the changes found in IGTPW_4553 that come from known issues:

### IGT changes ###

#### Possible fixes ####

  * igt@i915_selftest@live@hangcheck:
    - fi-icl-y:           [INCOMPLETE][1] ([i915#1580]) -> [PASS][2]
   [1]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/fi-icl-y/igt@i915_selftest@live@hangcheck.html
   [2]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/fi-icl-y/igt@i915_selftest@live@hangcheck.html

  
  [i915#1580]: https://gitlab.freedesktop.org/drm/intel/issues/1580


Participating hosts (48 -> 39)
------------------------------

  Additional (1): fi-kbl-7560u 
  Missing    (10): fi-ilk-m540 fi-bxt-dsi fi-hsw-4200u fi-byt-squawks fi-bsw-cyan fi-cfl-8700k fi-whl-u fi-byt-clapper fi-bdw-samus fi-kbl-r 


Build changes
-------------

  * CI: CI-20190529 -> None
  * IGT: IGT_5644 -> IGTPW_4553

  CI-20190529: 20190529
  CI_DRM_8461: c0be14b9502e54c9ece4f4fc25872d665c6a6553 @ git://anongit.freedesktop.org/gfx-ci/linux
  IGTPW_4553: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/index.html
  IGT_5644: 16f067ae42a6a93b8f0c5835210e2575a883001b @ git://anongit.freedesktop.org/xorg/app/intel-gpu-tools



== Testlist changes ==

+igt@kms_vrr@flipline

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/index.html
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

[igt-dev] ✓ Fi.CI.IGT: success for New subtest for VRR Flipline mode

[Patchwork]

== Series Details ==

Series: New subtest for VRR Flipline mode
URL   : https://patchwork.freedesktop.org/series/77128/
State : success

== Summary ==

CI Bug Log - changes from CI_DRM_8461_full -> IGTPW_4553_full
====================================================

Summary
-------

  **SUCCESS**

  No regressions found.

  External URL: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/index.html

Possible new issues
-------------------

  Here are the unknown changes that may have been introduced in IGTPW_4553_full:

### IGT changes ###

#### Possible regressions ####

  * {igt@kms_vrr@flipline} (NEW):
    - shard-tglb:         NOTRUN -> [SKIP][1]
   [1]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-tglb2/igt@kms_vrr@flipline.html
    - shard-iclb:         NOTRUN -> [SKIP][2]
   [2]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-iclb7/igt@kms_vrr@flipline.html

  
New tests
---------

  New tests have been introduced between CI_DRM_8461_full and IGTPW_4553_full:

### New IGT tests (1) ###

  * igt@kms_vrr@flipline:
    - Statuses : 7 skip(s)
    - Exec time: [0.0] s

  

Known issues
------------

  Here are the changes found in IGTPW_4553_full that come from known issues:

### IGT changes ###

#### Issues hit ####

  * igt@gem_exec_params@invalid-bsd-ring:
    - shard-iclb:         [PASS][3] -> [SKIP][4] ([fdo#109276])
   [3]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-iclb4/igt@gem_exec_params@invalid-bsd-ring.html
   [4]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-iclb7/igt@gem_exec_params@invalid-bsd-ring.html

  * igt@gem_workarounds@suspend-resume-fd:
    - shard-kbl:          [PASS][5] -> [DMESG-WARN][6] ([i915#180]) +1 similar issue
   [5]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-kbl6/igt@gem_workarounds@suspend-resume-fd.html
   [6]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-kbl3/igt@gem_workarounds@suspend-resume-fd.html

  * igt@i915_suspend@forcewake:
    - shard-apl:          [PASS][7] -> [DMESG-WARN][8] ([i915#180]) +1 similar issue
   [7]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-apl8/igt@i915_suspend@forcewake.html
   [8]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-apl1/igt@i915_suspend@forcewake.html

  * igt@kms_big_fb@linear-32bpp-rotate-0:
    - shard-apl:          [PASS][9] -> [FAIL][10] ([i915#1119] / [i915#95])
   [9]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-apl6/igt@kms_big_fb@linear-32bpp-rotate-0.html
   [10]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-apl7/igt@kms_big_fb@linear-32bpp-rotate-0.html

  * igt@kms_cursor_crc@pipe-a-cursor-256x85-offscreen:
    - shard-kbl:          [PASS][11] -> [FAIL][12] ([i915#54] / [i915#93] / [i915#95]) +1 similar issue
   [11]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-kbl3/igt@kms_cursor_crc@pipe-a-cursor-256x85-offscreen.html
   [12]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-kbl7/igt@kms_cursor_crc@pipe-a-cursor-256x85-offscreen.html

  * igt@kms_cursor_crc@pipe-a-cursor-64x21-onscreen:
    - shard-apl:          [PASS][13] -> [FAIL][14] ([i915#54]) +1 similar issue
   [13]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-apl1/igt@kms_cursor_crc@pipe-a-cursor-64x21-onscreen.html
   [14]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-apl7/igt@kms_cursor_crc@pipe-a-cursor-64x21-onscreen.html

  * igt@kms_draw_crc@draw-method-xrgb8888-blt-untiled:
    - shard-apl:          [PASS][15] -> [FAIL][16] ([i915#52] / [i915#54] / [i915#95])
   [15]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-apl6/igt@kms_draw_crc@draw-method-xrgb8888-blt-untiled.html
   [16]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-apl8/igt@kms_draw_crc@draw-method-xrgb8888-blt-untiled.html
    - shard-kbl:          [PASS][17] -> [FAIL][18] ([i915#177] / [i915#52] / [i915#54] / [i915#93] / [i915#95])
   [17]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-kbl6/igt@kms_draw_crc@draw-method-xrgb8888-blt-untiled.html
   [18]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-kbl2/igt@kms_draw_crc@draw-method-xrgb8888-blt-untiled.html

  * igt@kms_fence_pin_leak:
    - shard-snb:          [PASS][19] -> [SKIP][20] ([fdo#109271]) +2 similar issues
   [19]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-snb1/igt@kms_fence_pin_leak.html
   [20]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-snb6/igt@kms_fence_pin_leak.html

  * igt@kms_frontbuffer_tracking@fbc-suspend:
    - shard-kbl:          [PASS][21] -> [DMESG-WARN][22] ([i915#180] / [i915#93] / [i915#95])
   [21]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-kbl4/igt@kms_frontbuffer_tracking@fbc-suspend.html
   [22]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-kbl1/igt@kms_frontbuffer_tracking@fbc-suspend.html

  * igt@kms_psr2_su@frontbuffer:
    - shard-iclb:         [PASS][23] -> [SKIP][24] ([fdo#109642] / [fdo#111068])
   [23]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-iclb2/igt@kms_psr2_su@frontbuffer.html
   [24]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-iclb7/igt@kms_psr2_su@frontbuffer.html

  * igt@kms_psr@psr2_primary_mmap_cpu:
    - shard-iclb:         [PASS][25] -> [SKIP][26] ([fdo#109441]) +2 similar issues
   [25]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-iclb2/igt@kms_psr@psr2_primary_mmap_cpu.html
   [26]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-iclb7/igt@kms_psr@psr2_primary_mmap_cpu.html

  * igt@perf@whitelisted-registers-userspace-config:
    - shard-kbl:          [PASS][27] -> [SKIP][28] ([fdo#109271])
   [27]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-kbl2/igt@perf@whitelisted-registers-userspace-config.html
   [28]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-kbl2/igt@perf@whitelisted-registers-userspace-config.html
    - shard-tglb:         [PASS][29] -> [SKIP][30] ([i915#405])
   [29]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-tglb6/igt@perf@whitelisted-registers-userspace-config.html
   [30]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-tglb5/igt@perf@whitelisted-registers-userspace-config.html
    - shard-hsw:          [PASS][31] -> [SKIP][32] ([fdo#109271])
   [31]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-hsw4/igt@perf@whitelisted-registers-userspace-config.html
   [32]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-hsw2/igt@perf@whitelisted-registers-userspace-config.html
    - shard-glk:          [PASS][33] -> [SKIP][34] ([fdo#109271])
   [33]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-glk4/igt@perf@whitelisted-registers-userspace-config.html
   [34]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-glk8/igt@perf@whitelisted-registers-userspace-config.html
    - shard-apl:          [PASS][35] -> [SKIP][36] ([fdo#109271])
   [35]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-apl7/igt@perf@whitelisted-registers-userspace-config.html
   [36]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-apl8/igt@perf@whitelisted-registers-userspace-config.html
    - shard-iclb:         [PASS][37] -> [SKIP][38] ([i915#405])
   [37]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-iclb4/igt@perf@whitelisted-registers-userspace-config.html
   [38]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-iclb1/igt@perf@whitelisted-registers-userspace-config.html

  
#### Possible fixes ####

  * {igt@gem_ctx_isolation@preservation-s3@rcs0}:
    - shard-kbl:          [INCOMPLETE][39] ([i915#155]) -> [PASS][40]
   [39]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-kbl3/igt@gem_ctx_isolation@preservation-s3@rcs0.html
   [40]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-kbl7/igt@gem_ctx_isolation@preservation-s3@rcs0.html

  * igt@gen9_exec_parse@allowed-all:
    - shard-kbl:          [DMESG-WARN][41] ([i915#1436] / [i915#716]) -> [PASS][42]
   [41]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-kbl1/igt@gen9_exec_parse@allowed-all.html
   [42]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-kbl3/igt@gen9_exec_parse@allowed-all.html

  * igt@i915_suspend@sysfs-reader:
    - shard-apl:          [DMESG-WARN][43] ([i915#180]) -> [PASS][44] +1 similar issue
   [43]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-apl6/igt@i915_suspend@sysfs-reader.html
   [44]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-apl3/igt@i915_suspend@sysfs-reader.html

  * igt@kms_cursor_legacy@cursor-vs-flip-toggle:
    - shard-hsw:          [FAIL][45] ([i915#57]) -> [PASS][46]
   [45]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-hsw6/igt@kms_cursor_legacy@cursor-vs-flip-toggle.html
   [46]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-hsw7/igt@kms_cursor_legacy@cursor-vs-flip-toggle.html

  * igt@kms_draw_crc@draw-method-xrgb8888-mmap-gtt-untiled:
    - shard-apl:          [FAIL][47] ([i915#52] / [i915#54] / [i915#95]) -> [PASS][48]
   [47]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-apl7/igt@kms_draw_crc@draw-method-xrgb8888-mmap-gtt-untiled.html
   [48]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-apl8/igt@kms_draw_crc@draw-method-xrgb8888-mmap-gtt-untiled.html
    - shard-kbl:          [FAIL][49] ([i915#177] / [i915#52] / [i915#54] / [i915#93] / [i915#95]) -> [PASS][50]
   [49]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-kbl2/igt@kms_draw_crc@draw-method-xrgb8888-mmap-gtt-untiled.html
   [50]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-kbl7/igt@kms_draw_crc@draw-method-xrgb8888-mmap-gtt-untiled.html

  * igt@kms_draw_crc@fill-fb:
    - shard-apl:          [FAIL][51] ([i915#95]) -> [PASS][52]
   [51]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-apl2/igt@kms_draw_crc@fill-fb.html
   [52]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-apl1/igt@kms_draw_crc@fill-fb.html

  * {igt@kms_flip@2x-flip-vs-suspend-interruptible@bc-vga1-hdmi-a1}:
    - shard-hsw:          [INCOMPLETE][53] ([i915#61]) -> [PASS][54]
   [53]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-hsw6/igt@kms_flip@2x-flip-vs-suspend-interruptible@bc-vga1-hdmi-a1.html
   [54]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-hsw8/igt@kms_flip@2x-flip-vs-suspend-interruptible@bc-vga1-hdmi-a1.html

  * {igt@kms_flip@flip-vs-suspend-interruptible@a-dp1}:
    - shard-kbl:          [DMESG-WARN][55] ([i915#180]) -> [PASS][56] +1 similar issue
   [55]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-kbl3/igt@kms_flip@flip-vs-suspend-interruptible@a-dp1.html
   [56]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-kbl6/igt@kms_flip@flip-vs-suspend-interruptible@a-dp1.html

  * igt@kms_plane_alpha_blend@pipe-a-coverage-vs-premult-vs-constant:
    - shard-kbl:          [FAIL][57] ([fdo#108145] / [i915#265] / [i915#93] / [i915#95]) -> [PASS][58]
   [57]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-kbl4/igt@kms_plane_alpha_blend@pipe-a-coverage-vs-premult-vs-constant.html
   [58]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-kbl3/igt@kms_plane_alpha_blend@pipe-a-coverage-vs-premult-vs-constant.html
    - shard-apl:          [FAIL][59] ([fdo#108145] / [i915#265] / [i915#95]) -> [PASS][60]
   [59]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-apl4/igt@kms_plane_alpha_blend@pipe-a-coverage-vs-premult-vs-constant.html
   [60]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-apl2/igt@kms_plane_alpha_blend@pipe-a-coverage-vs-premult-vs-constant.html

  * igt@kms_psr@psr2_basic:
    - shard-iclb:         [SKIP][61] ([fdo#109441]) -> [PASS][62] +3 similar issues
   [61]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-iclb6/igt@kms_psr@psr2_basic.html
   [62]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-iclb2/igt@kms_psr@psr2_basic.html

  
#### Warnings ####

  * igt@i915_pm_dc@dc6-psr:
    - shard-tglb:         [SKIP][63] ([i915#468]) -> [FAIL][64] ([i915#454])
   [63]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-tglb2/igt@i915_pm_dc@dc6-psr.html
   [64]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-tglb5/igt@i915_pm_dc@dc6-psr.html

  * igt@kms_content_protection@atomic-dpms:
    - shard-kbl:          [TIMEOUT][65] ([i915#1319]) -> [FAIL][66] ([fdo#110321] / [fdo#110336] / [i915#93] / [i915#95])
   [65]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-kbl1/igt@kms_content_protection@atomic-dpms.html
   [66]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-kbl2/igt@kms_content_protection@atomic-dpms.html

  * igt@kms_content_protection@lic:
    - shard-apl:          [FAIL][67] ([fdo#110321]) -> [TIMEOUT][68] ([i915#1319])
   [67]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-apl4/igt@kms_content_protection@lic.html
   [68]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-apl6/igt@kms_content_protection@lic.html

  * igt@kms_content_protection@srm:
    - shard-apl:          [TIMEOUT][69] ([i915#1319]) -> [DMESG-FAIL][70] ([fdo#110321])
   [69]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-apl1/igt@kms_content_protection@srm.html
   [70]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-apl7/igt@kms_content_protection@srm.html

  * igt@kms_fbcon_fbt@fbc:
    - shard-kbl:          [FAIL][71] ([i915#1121] / [i915#93] / [i915#95]) -> [FAIL][72] ([i915#64])
   [71]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-kbl1/igt@kms_fbcon_fbt@fbc.html
   [72]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-kbl3/igt@kms_fbcon_fbt@fbc.html
    - shard-apl:          [FAIL][73] ([i915#1121] / [i915#95]) -> [FAIL][74] ([i915#1525])
   [73]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-apl8/igt@kms_fbcon_fbt@fbc.html
   [74]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-apl2/igt@kms_fbcon_fbt@fbc.html

  * igt@kms_plane_alpha_blend@pipe-a-alpha-7efc:
    - shard-apl:          [FAIL][75] ([fdo#108145] / [i915#265]) -> [FAIL][76] ([fdo#108145] / [i915#265] / [i915#95])
   [75]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-apl2/igt@kms_plane_alpha_blend@pipe-a-alpha-7efc.html
   [76]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-apl4/igt@kms_plane_alpha_blend@pipe-a-alpha-7efc.html
    - shard-kbl:          [FAIL][77] ([fdo#108145] / [i915#265]) -> [FAIL][78] ([fdo#108145] / [i915#265] / [i915#93] / [i915#95])
   [77]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-kbl2/igt@kms_plane_alpha_blend@pipe-a-alpha-7efc.html
   [78]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-kbl4/igt@kms_plane_alpha_blend@pipe-a-alpha-7efc.html

  * igt@kms_plane_alpha_blend@pipe-a-alpha-opaque-fb:
    - shard-apl:          [FAIL][79] ([fdo#108145] / [i915#265] / [i915#95]) -> [FAIL][80] ([fdo#108145] / [i915#265])
   [79]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-apl6/igt@kms_plane_alpha_blend@pipe-a-alpha-opaque-fb.html
   [80]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-apl1/igt@kms_plane_alpha_blend@pipe-a-alpha-opaque-fb.html
    - shard-kbl:          [FAIL][81] ([fdo#108145] / [i915#265] / [i915#93] / [i915#95]) -> [FAIL][82] ([fdo#108145] / [i915#265])
   [81]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-kbl6/igt@kms_plane_alpha_blend@pipe-a-alpha-opaque-fb.html
   [82]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-kbl7/igt@kms_plane_alpha_blend@pipe-a-alpha-opaque-fb.html

  * igt@kms_setmode@basic:
    - shard-apl:          [FAIL][83] ([i915#31]) -> [FAIL][84] ([i915#31] / [i915#95])
   [83]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-apl8/igt@kms_setmode@basic.html
   [84]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-apl7/igt@kms_setmode@basic.html
    - shard-kbl:          [FAIL][85] ([i915#31]) -> [FAIL][86] ([i915#31] / [i915#93] / [i915#95])
   [85]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8461/shard-kbl7/igt@kms_setmode@basic.html
   [86]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/shard-kbl3/igt@kms_setmode@basic.html

  
  {name}: This element is suppressed. This means it is ignored when computing
          the status of the difference (SUCCESS, WARNING, or FAILURE).

  [fdo#108145]: https://bugs.freedesktop.org/show_bug.cgi?id=108145
  [fdo#109271]: https://bugs.freedesktop.org/show_bug.cgi?id=109271
  [fdo#109276]: https://bugs.freedesktop.org/show_bug.cgi?id=109276
  [fdo#109441]: https://bugs.freedesktop.org/show_bug.cgi?id=109441
  [fdo#109642]: https://bugs.freedesktop.org/show_bug.cgi?id=109642
  [fdo#110321]: https://bugs.freedesktop.org/show_bug.cgi?id=110321
  [fdo#110336]: https://bugs.freedesktop.org/show_bug.cgi?id=110336
  [fdo#111068]: https://bugs.freedesktop.org/show_bug.cgi?id=111068
  [i915#1119]: https://gitlab.freedesktop.org/drm/intel/issues/1119
  [i915#1121]: https://gitlab.freedesktop.org/drm/intel/issues/1121
  [i915#1319]: https://gitlab.freedesktop.org/drm/intel/issues/1319
  [i915#1436]: https://gitlab.freedesktop.org/drm/intel/issues/1436
  [i915#1525]: https://gitlab.freedesktop.org/drm/intel/issues/1525
  [i915#1542]: https://gitlab.freedesktop.org/drm/intel/issues/1542
  [i915#155]: https://gitlab.freedesktop.org/drm/intel/issues/155
  [i915#177]: https://gitlab.freedesktop.org/drm/intel/issues/177
  [i915#180]: https://gitlab.freedesktop.org/drm/intel/issues/180
  [i915#265]: https://gitlab.freedesktop.org/drm/intel/issues/265
  [i915#31]: https://gitlab.freedesktop.org/drm/intel/issues/31
  [i915#405]: https://gitlab.freedesktop.org/drm/intel/issues/405
  [i915#454]: https://gitlab.freedesktop.org/drm/intel/issues/454
  [i915#468]: https://gitlab.freedesktop.org/drm/intel/issues/468
  [i915#52]: https://gitlab.freedesktop.org/drm/intel/issues/52
  [i915#54]: https://gitlab.freedesktop.org/drm/intel/issues/54
  [i915#57]: https://gitlab.freedesktop.org/drm/intel/issues/57
  [i915#61]: https://gitlab.freedesktop.org/drm/intel/issues/61
  [i915#64]: https://gitlab.freedesktop.org/drm/intel/issues/64
  [i915#716]: https://gitlab.freedesktop.org/drm/intel/issues/716
  [i915#93]: https://gitlab.freedesktop.org/drm/intel/issues/93
  [i915#95]: https://gitlab.freedesktop.org/drm/intel/issues/95


Participating hosts (11 -> 8)
------------------------------

  Missing    (3): pig-skl-6260u pig-glk-j5005 pig-icl-1065g7 


Build changes
-------------

  * CI: CI-20190529 -> None
  * IGT: IGT_5644 -> IGTPW_4553
  * Piglit: piglit_4509 -> None

  CI-20190529: 20190529
  CI_DRM_8461: c0be14b9502e54c9ece4f4fc25872d665c6a6553 @ git://anongit.freedesktop.org/gfx-ci/linux
  IGTPW_4553: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/index.html
  IGT_5644: 16f067ae42a6a93b8f0c5835210e2575a883001b @ git://anongit.freedesktop.org/xorg/app/intel-gpu-tools
  piglit_4509: fdc5a4ca11124ab8413c7988896eec4c97336694 @ git://anongit.freedesktop.org/piglit

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4553/index.html
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

[igt-dev] ✓ Fi.CI.BAT: success for New subtest for VRR Flipline mode (rev3)

[Patchwork]

[-- Attachment #1.1: Type: text/plain, Size: 5078 bytes --]

== Series Details ==

Series: New subtest for VRR Flipline mode (rev3)
URL   : https://patchwork.freedesktop.org/series/77128/
State : success

== Summary ==

CI Bug Log - changes from IGT_5759 -> IGTPW_4852
====================================================

Summary
-------

  **SUCCESS**

  No regressions found.

  External URL: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/index.html

Known issues
------------

  Here are the changes found in IGTPW_4852 that come from known issues:

### IGT changes ###

#### Issues hit ####

  * igt@gem_exec_suspend@basic-s3:
    - fi-tgl-u2:          [PASS][1] -> [FAIL][2] ([i915#1888])
   [1]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/fi-tgl-u2/igt@gem_exec_suspend@basic-s3.html
   [2]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/fi-tgl-u2/igt@gem_exec_suspend@basic-s3.html

  * igt@i915_pm_rpm@basic-pci-d3-state:
    - fi-bsw-kefka:       [PASS][3] -> [DMESG-WARN][4] ([i915#1982])
   [3]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/fi-bsw-kefka/igt@i915_pm_rpm@basic-pci-d3-state.html
   [4]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/fi-bsw-kefka/igt@i915_pm_rpm@basic-pci-d3-state.html

  * igt@i915_pm_rpm@module-reload:
    - fi-byt-j1900:       [PASS][5] -> [DMESG-WARN][6] ([i915#1982])
   [5]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/fi-byt-j1900/igt@i915_pm_rpm@module-reload.html
   [6]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/fi-byt-j1900/igt@i915_pm_rpm@module-reload.html

  * igt@i915_selftest@live@execlists:
    - fi-icl-y:           [PASS][7] -> [DMESG-FAIL][8] ([i915#1993])
   [7]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/fi-icl-y/igt@i915_selftest@live@execlists.html
   [8]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/fi-icl-y/igt@i915_selftest@live@execlists.html

  * igt@kms_cursor_legacy@basic-flip-before-cursor-atomic:
    - fi-icl-u2:          [PASS][9] -> [DMESG-WARN][10] ([i915#1982])
   [9]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/fi-icl-u2/igt@kms_cursor_legacy@basic-flip-before-cursor-atomic.html
   [10]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/fi-icl-u2/igt@kms_cursor_legacy@basic-flip-before-cursor-atomic.html

  
#### Possible fixes ####

  * igt@kms_busy@basic@flip:
    - {fi-tgl-dsi}:       [DMESG-WARN][11] ([i915#1982]) -> [PASS][12]
   [11]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/fi-tgl-dsi/igt@kms_busy@basic@flip.html
   [12]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/fi-tgl-dsi/igt@kms_busy@basic@flip.html

  * igt@kms_flip@basic-flip-vs-wf_vblank@c-hdmi-a2:
    - fi-skl-guc:         [DMESG-WARN][13] ([i915#2203]) -> [PASS][14]
   [13]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/fi-skl-guc/igt@kms_flip@basic-flip-vs-wf_vblank@c-hdmi-a2.html
   [14]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/fi-skl-guc/igt@kms_flip@basic-flip-vs-wf_vblank@c-hdmi-a2.html

  
#### Warnings ####

  * igt@kms_pipe_crc_basic@read-crc-pipe-b:
    - fi-kbl-x1275:       [DMESG-WARN][15] ([i915#62] / [i915#92]) -> [DMESG-WARN][16] ([i915#62] / [i915#92] / [i915#95])
   [15]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/fi-kbl-x1275/igt@kms_pipe_crc_basic@read-crc-pipe-b.html
   [16]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/fi-kbl-x1275/igt@kms_pipe_crc_basic@read-crc-pipe-b.html

  * igt@prime_vgem@basic-fence-flip:
    - fi-kbl-x1275:       [DMESG-WARN][17] ([i915#62] / [i915#92] / [i915#95]) -> [DMESG-WARN][18] ([i915#62] / [i915#92]) +5 similar issues
   [17]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/fi-kbl-x1275/igt@prime_vgem@basic-fence-flip.html
   [18]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/fi-kbl-x1275/igt@prime_vgem@basic-fence-flip.html

  
  {name}: This element is suppressed. This means it is ignored when computing
          the status of the difference (SUCCESS, WARNING, or FAILURE).

  [i915#1888]: https://gitlab.freedesktop.org/drm/intel/issues/1888
  [i915#1982]: https://gitlab.freedesktop.org/drm/intel/issues/1982
  [i915#1993]: https://gitlab.freedesktop.org/drm/intel/issues/1993
  [i915#2203]: https://gitlab.freedesktop.org/drm/intel/issues/2203
  [i915#62]: https://gitlab.freedesktop.org/drm/intel/issues/62
  [i915#92]: https://gitlab.freedesktop.org/drm/intel/issues/92
  [i915#95]: https://gitlab.freedesktop.org/drm/intel/issues/95


Participating hosts (44 -> 37)
------------------------------

  Missing    (7): fi-ilk-m540 fi-hsw-4200u fi-byt-squawks fi-bsw-cyan fi-ctg-p8600 fi-byt-clapper fi-bdw-samus 


Build changes
-------------

  * CI: CI-20190529 -> None
  * IGT: IGT_5759 -> IGTPW_4852

  CI-20190529: 20190529
  CI_DRM_8845: a486392fed875e0b9154eaeb4bf6a4193484e0b3 @ git://anongit.freedesktop.org/gfx-ci/linux
  IGTPW_4852: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/index.html
  IGT_5759: 917b8990f87afa8a04beff8b491450f8bc9201de @ git://anongit.freedesktop.org/xorg/app/intel-gpu-tools



== Testlist changes ==

+igt@kms_vrr@flipline

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/index.html

[-- Attachment #1.2: Type: text/html, Size: 6565 bytes --]

[-- Attachment #2: Type: text/plain, Size: 154 bytes --]

_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

[igt-dev] ✗ Fi.CI.IGT: failure for New subtest for VRR Flipline mode (rev3)

[Patchwork]

[-- Attachment #1.1: Type: text/plain, Size: 25885 bytes --]

== Series Details ==

Series: New subtest for VRR Flipline mode (rev3)
URL   : https://patchwork.freedesktop.org/series/77128/
State : failure

== Summary ==

CI Bug Log - changes from IGT_5759_full -> IGTPW_4852_full
====================================================

Summary
-------

  **FAILURE**

  Serious unknown changes coming with IGTPW_4852_full absolutely need to be
  verified manually.
  
  If you think the reported changes have nothing to do with the changes
  introduced in IGTPW_4852_full, please notify your bug team to allow them
  to document this new failure mode, which will reduce false positives in CI.

  External URL: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/index.html

Possible new issues
-------------------

  Here are the unknown changes that may have been introduced in IGTPW_4852_full:

### IGT changes ###

#### Possible regressions ####

  * igt@i915_module_load@reload-with-fault-injection:
    - shard-tglb:         [PASS][1] -> [INCOMPLETE][2]
   [1]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-tglb5/igt@i915_module_load@reload-with-fault-injection.html
   [2]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-tglb6/igt@i915_module_load@reload-with-fault-injection.html
    - shard-glk:          [PASS][3] -> [INCOMPLETE][4]
   [3]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-glk4/igt@i915_module_load@reload-with-fault-injection.html
   [4]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-glk6/igt@i915_module_load@reload-with-fault-injection.html

  * igt@kms_flip@2x-flip-vs-suspend-interruptible@bc-vga1-hdmi-a1:
    - shard-hsw:          [PASS][5] -> [INCOMPLETE][6]
   [5]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-hsw1/igt@kms_flip@2x-flip-vs-suspend-interruptible@bc-vga1-hdmi-a1.html
   [6]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-hsw4/igt@kms_flip@2x-flip-vs-suspend-interruptible@bc-vga1-hdmi-a1.html

  * {igt@kms_vrr@flipline} (NEW):
    - shard-tglb:         NOTRUN -> [SKIP][7]
   [7]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-tglb6/igt@kms_vrr@flipline.html
    - shard-iclb:         NOTRUN -> [SKIP][8]
   [8]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-iclb2/igt@kms_vrr@flipline.html

  
New tests
---------

  New tests have been introduced between IGT_5759_full and IGTPW_4852_full:

### New IGT tests (1) ###

  * igt@kms_vrr@flipline:
    - Statuses : 7 skip(s)
    - Exec time: [0.0] s

  

Known issues
------------

  Here are the changes found in IGTPW_4852_full that come from known issues:

### IGT changes ###

#### Issues hit ####

  * igt@gem_ctx_isolation@preservation-s3@vcs0:
    - shard-kbl:          [PASS][9] -> [DMESG-WARN][10] ([i915#180]) +5 similar issues
   [9]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-kbl7/igt@gem_ctx_isolation@preservation-s3@vcs0.html
   [10]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-kbl7/igt@gem_ctx_isolation@preservation-s3@vcs0.html

  * igt@gem_exec_whisper@basic-contexts-all:
    - shard-glk:          [PASS][11] -> [DMESG-WARN][12] ([i915#118] / [i915#95])
   [11]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-glk2/igt@gem_exec_whisper@basic-contexts-all.html
   [12]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-glk7/igt@gem_exec_whisper@basic-contexts-all.html

  * igt@gem_tiled_pread_pwrite:
    - shard-iclb:         [PASS][13] -> [DMESG-WARN][14] ([i915#1982]) +1 similar issue
   [13]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-iclb5/igt@gem_tiled_pread_pwrite.html
   [14]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-iclb2/igt@gem_tiled_pread_pwrite.html

  * igt@gem_workarounds@suspend-resume-context:
    - shard-tglb:         [PASS][15] -> [DMESG-WARN][16] ([i915#1602] / [i915#1887])
   [15]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-tglb3/igt@gem_workarounds@suspend-resume-context.html
   [16]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-tglb6/igt@gem_workarounds@suspend-resume-context.html

  * igt@i915_module_load@reload-with-fault-injection:
    - shard-kbl:          [PASS][17] -> [INCOMPLETE][18] ([i915#1373])
   [17]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-kbl7/igt@i915_module_load@reload-with-fault-injection.html
   [18]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-kbl1/igt@i915_module_load@reload-with-fault-injection.html
    - shard-apl:          [PASS][19] -> [INCOMPLETE][20] ([i915#1373] / [i915#1635])
   [19]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-apl8/igt@i915_module_load@reload-with-fault-injection.html
   [20]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-apl4/igt@i915_module_load@reload-with-fault-injection.html
    - shard-snb:          [PASS][21] -> [INCOMPLETE][22] ([i915#82])
   [21]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-snb2/igt@i915_module_load@reload-with-fault-injection.html
   [22]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-snb2/igt@i915_module_load@reload-with-fault-injection.html
    - shard-iclb:         [PASS][23] -> [INCOMPLETE][24] ([i915#926])
   [23]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-iclb4/igt@i915_module_load@reload-with-fault-injection.html
   [24]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-iclb7/igt@i915_module_load@reload-with-fault-injection.html

  * igt@i915_pm_rpm@debugfs-forcewake-user:
    - shard-kbl:          [PASS][25] -> [SKIP][26] ([fdo#109271])
   [25]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-kbl1/igt@i915_pm_rpm@debugfs-forcewake-user.html
   [26]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-kbl6/igt@i915_pm_rpm@debugfs-forcewake-user.html

  * igt@i915_suspend@fence-restore-untiled:
    - shard-tglb:         [PASS][27] -> [INCOMPLETE][28] ([i915#1602] / [i915#1887] / [i915#456])
   [27]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-tglb2/igt@i915_suspend@fence-restore-untiled.html
   [28]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-tglb1/igt@i915_suspend@fence-restore-untiled.html

  * igt@kms_big_fb@x-tiled-64bpp-rotate-180:
    - shard-glk:          [PASS][29] -> [DMESG-WARN][30] ([i915#1982])
   [29]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-glk6/igt@kms_big_fb@x-tiled-64bpp-rotate-180.html
   [30]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-glk4/igt@kms_big_fb@x-tiled-64bpp-rotate-180.html

  * igt@kms_cursor_legacy@flip-vs-cursor-legacy:
    - shard-tglb:         [PASS][31] -> [FAIL][32] ([IGT#5])
   [31]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-tglb2/igt@kms_cursor_legacy@flip-vs-cursor-legacy.html
   [32]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-tglb6/igt@kms_cursor_legacy@flip-vs-cursor-legacy.html

  * igt@kms_flip@flip-vs-suspend@c-hdmi-a1:
    - shard-hsw:          [PASS][33] -> [INCOMPLETE][34] ([i915#2055])
   [33]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-hsw8/igt@kms_flip@flip-vs-suspend@c-hdmi-a1.html
   [34]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-hsw2/igt@kms_flip@flip-vs-suspend@c-hdmi-a1.html

  * igt@kms_frontbuffer_tracking@fbc-2p-primscrn-pri-indfb-draw-blt:
    - shard-glk:          [PASS][35] -> [FAIL][36] ([i915#49])
   [35]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-glk2/igt@kms_frontbuffer_tracking@fbc-2p-primscrn-pri-indfb-draw-blt.html
   [36]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-glk8/igt@kms_frontbuffer_tracking@fbc-2p-primscrn-pri-indfb-draw-blt.html

  * igt@kms_lease@setcrtc_implicit_plane:
    - shard-hsw:          [PASS][37] -> [TIMEOUT][38] ([i915#1958])
   [37]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-hsw4/igt@kms_lease@setcrtc_implicit_plane.html
   [38]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-hsw7/igt@kms_lease@setcrtc_implicit_plane.html
    - shard-snb:          [PASS][39] -> [TIMEOUT][40] ([i915#1958])
   [39]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-snb2/igt@kms_lease@setcrtc_implicit_plane.html
   [40]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-snb5/igt@kms_lease@setcrtc_implicit_plane.html

  * igt@kms_panel_fitting@atomic-fastset:
    - shard-iclb:         [PASS][41] -> [FAIL][42] ([i915#83])
   [41]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-iclb5/igt@kms_panel_fitting@atomic-fastset.html
   [42]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-iclb5/igt@kms_panel_fitting@atomic-fastset.html

  * igt@kms_psr@no_drrs:
    - shard-iclb:         [PASS][43] -> [FAIL][44] ([i915#173])
   [43]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-iclb8/igt@kms_psr@no_drrs.html
   [44]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-iclb1/igt@kms_psr@no_drrs.html

  * igt@kms_psr@psr2_cursor_plane_move:
    - shard-iclb:         [PASS][45] -> [SKIP][46] ([fdo#109441]) +2 similar issues
   [45]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-iclb2/igt@kms_psr@psr2_cursor_plane_move.html
   [46]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-iclb3/igt@kms_psr@psr2_cursor_plane_move.html

  * igt@kms_vblank@pipe-d-wait-busy:
    - shard-tglb:         [PASS][47] -> [DMESG-WARN][48] ([i915#1982]) +2 similar issues
   [47]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-tglb5/igt@kms_vblank@pipe-d-wait-busy.html
   [48]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-tglb6/igt@kms_vblank@pipe-d-wait-busy.html

  * igt@perf@blocking-parameterized:
    - shard-iclb:         [PASS][49] -> [FAIL][50] ([i915#1542])
   [49]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-iclb4/igt@perf@blocking-parameterized.html
   [50]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-iclb3/igt@perf@blocking-parameterized.html

  * igt@perf@polling-small-buf:
    - shard-iclb:         [PASS][51] -> [FAIL][52] ([i915#1722])
   [51]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-iclb8/igt@perf@polling-small-buf.html
   [52]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-iclb3/igt@perf@polling-small-buf.html

  * igt@prime_busy@before-wait@rcs0:
    - shard-hsw:          [PASS][53] -> [FAIL][54] ([i915#2258])
   [53]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-hsw4/igt@prime_busy@before-wait@rcs0.html
   [54]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-hsw2/igt@prime_busy@before-wait@rcs0.html

  
#### Possible fixes ####

  * {igt@feature_discovery@psr2}:
    - shard-iclb:         [SKIP][55] ([i915#658]) -> [PASS][56]
   [55]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-iclb1/igt@feature_discovery@psr2.html
   [56]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-iclb2/igt@feature_discovery@psr2.html

  * igt@gem_exec_whisper@basic-queues-forked-all:
    - shard-glk:          [DMESG-WARN][57] ([i915#118] / [i915#95]) -> [PASS][58] +1 similar issue
   [57]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-glk2/igt@gem_exec_whisper@basic-queues-forked-all.html
   [58]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-glk8/igt@gem_exec_whisper@basic-queues-forked-all.html

  * igt@gem_mmap_gtt@cpuset-basic-small-copy:
    - shard-snb:          [TIMEOUT][59] ([i915#1958]) -> [PASS][60]
   [59]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-snb2/igt@gem_mmap_gtt@cpuset-basic-small-copy.html
   [60]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-snb1/igt@gem_mmap_gtt@cpuset-basic-small-copy.html

  * igt@i915_module_load@reload-no-display:
    - shard-snb:          [INCOMPLETE][61] ([i915#82]) -> [PASS][62]
   [61]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-snb4/igt@i915_module_load@reload-no-display.html
   [62]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-snb4/igt@i915_module_load@reload-no-display.html
    - shard-iclb:         [INCOMPLETE][63] -> [PASS][64]
   [63]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-iclb1/igt@i915_module_load@reload-no-display.html
   [64]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-iclb6/igt@i915_module_load@reload-no-display.html
    - shard-apl:          [INCOMPLETE][65] ([i915#1635]) -> [PASS][66]
   [65]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-apl2/igt@i915_module_load@reload-no-display.html
   [66]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-apl8/igt@i915_module_load@reload-no-display.html
    - shard-glk:          [INCOMPLETE][67] -> [PASS][68]
   [67]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-glk3/igt@i915_module_load@reload-no-display.html
   [68]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-glk8/igt@i915_module_load@reload-no-display.html
    - shard-tglb:         [INCOMPLETE][69] -> [PASS][70]
   [69]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-tglb6/igt@i915_module_load@reload-no-display.html
   [70]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-tglb7/igt@i915_module_load@reload-no-display.html
    - shard-hsw:          [INCOMPLETE][71] -> [PASS][72]
   [71]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-hsw7/igt@i915_module_load@reload-no-display.html
   [72]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-hsw7/igt@i915_module_load@reload-no-display.html
    - shard-kbl:          [INCOMPLETE][73] -> [PASS][74]
   [73]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-kbl2/igt@i915_module_load@reload-no-display.html
   [74]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-kbl2/igt@i915_module_load@reload-no-display.html

  * igt@kms_draw_crc@draw-method-xrgb2101010-blt-ytiled:
    - shard-apl:          [DMESG-WARN][75] ([i915#1635] / [i915#1982]) -> [PASS][76]
   [75]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-apl6/igt@kms_draw_crc@draw-method-xrgb2101010-blt-ytiled.html
   [76]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-apl2/igt@kms_draw_crc@draw-method-xrgb2101010-blt-ytiled.html

  * igt@kms_flip@flip-vs-suspend-interruptible@a-dp1:
    - shard-kbl:          [DMESG-WARN][77] ([i915#180]) -> [PASS][78] +7 similar issues
   [77]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-kbl1/igt@kms_flip@flip-vs-suspend-interruptible@a-dp1.html
   [78]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-kbl7/igt@kms_flip@flip-vs-suspend-interruptible@a-dp1.html

  * igt@kms_flip@flip-vs-suspend-interruptible@c-hdmi-a1:
    - shard-hsw:          [INCOMPLETE][79] ([i915#2055]) -> [PASS][80]
   [79]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-hsw4/igt@kms_flip@flip-vs-suspend-interruptible@c-hdmi-a1.html
   [80]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-hsw2/igt@kms_flip@flip-vs-suspend-interruptible@c-hdmi-a1.html

  * igt@kms_frontbuffer_tracking@fbc-1p-offscren-pri-indfb-draw-mmap-cpu:
    - shard-kbl:          [DMESG-WARN][81] ([i915#1982]) -> [PASS][82]
   [81]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-kbl4/igt@kms_frontbuffer_tracking@fbc-1p-offscren-pri-indfb-draw-mmap-cpu.html
   [82]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-kbl1/igt@kms_frontbuffer_tracking@fbc-1p-offscren-pri-indfb-draw-mmap-cpu.html

  * igt@kms_frontbuffer_tracking@fbc-rgb565-draw-mmap-cpu:
    - shard-tglb:         [DMESG-WARN][83] ([i915#1982]) -> [PASS][84] +4 similar issues
   [83]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-tglb7/igt@kms_frontbuffer_tracking@fbc-rgb565-draw-mmap-cpu.html
   [84]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-tglb5/igt@kms_frontbuffer_tracking@fbc-rgb565-draw-mmap-cpu.html

  * igt@kms_plane_cursor@pipe-c-viewport-size-256:
    - shard-hsw:          [TIMEOUT][85] ([i915#1958]) -> [PASS][86] +2 similar issues
   [85]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-hsw8/igt@kms_plane_cursor@pipe-c-viewport-size-256.html
   [86]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-hsw2/igt@kms_plane_cursor@pipe-c-viewport-size-256.html

  * igt@kms_psr@psr2_sprite_plane_move:
    - shard-iclb:         [SKIP][87] ([fdo#109441]) -> [PASS][88]
   [87]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-iclb5/igt@kms_psr@psr2_sprite_plane_move.html
   [88]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-iclb2/igt@kms_psr@psr2_sprite_plane_move.html

  * igt@kms_setmode@basic:
    - shard-kbl:          [FAIL][89] ([i915#31]) -> [PASS][90]
   [89]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-kbl1/igt@kms_setmode@basic.html
   [90]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-kbl6/igt@kms_setmode@basic.html

  * igt@prime_busy@after-wait@vcs0:
    - shard-hsw:          [FAIL][91] ([i915#2258]) -> [PASS][92] +5 similar issues
   [91]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-hsw7/igt@prime_busy@after-wait@vcs0.html
   [92]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-hsw2/igt@prime_busy@after-wait@vcs0.html

  
#### Warnings ####

  * igt@i915_pm_dc@dc3co-vpb-simulation:
    - shard-iclb:         [SKIP][93] ([i915#588]) -> [SKIP][94] ([i915#658])
   [93]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-iclb2/igt@i915_pm_dc@dc3co-vpb-simulation.html
   [94]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-iclb1/igt@i915_pm_dc@dc3co-vpb-simulation.html

  * igt@i915_pm_dc@dc6-dpms:
    - shard-kbl:          [FAIL][95] ([i915#454]) -> [FAIL][96] ([i915#1665])
   [95]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-kbl2/igt@i915_pm_dc@dc6-dpms.html
   [96]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-kbl6/igt@i915_pm_dc@dc6-dpms.html

  * igt@kms_big_fb@y-tiled-64bpp-rotate-0:
    - shard-hsw:          [TIMEOUT][97] ([i915#1958]) -> [SKIP][98] ([fdo#109271]) +1 similar issue
   [97]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-hsw8/igt@kms_big_fb@y-tiled-64bpp-rotate-0.html
   [98]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-hsw4/igt@kms_big_fb@y-tiled-64bpp-rotate-0.html

  * igt@kms_color_chamelium@pipe-c-ctm-0-25:
    - shard-hsw:          [SKIP][99] ([fdo#109271] / [fdo#111827]) -> [TIMEOUT][100] ([i915#1958]) +1 similar issue
   [99]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-hsw4/igt@kms_color_chamelium@pipe-c-ctm-0-25.html
   [100]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-hsw7/igt@kms_color_chamelium@pipe-c-ctm-0-25.html
    - shard-snb:          [SKIP][101] ([fdo#109271] / [fdo#111827]) -> [TIMEOUT][102] ([i915#1958]) +1 similar issue
   [101]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-snb6/igt@kms_color_chamelium@pipe-c-ctm-0-25.html
   [102]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-snb5/igt@kms_color_chamelium@pipe-c-ctm-0-25.html

  * igt@kms_frontbuffer_tracking@psr-1p-primscrn-cur-indfb-move:
    - shard-hsw:          [SKIP][103] ([fdo#109271]) -> [TIMEOUT][104] ([i915#1958]) +1 similar issue
   [103]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-hsw1/igt@kms_frontbuffer_tracking@psr-1p-primscrn-cur-indfb-move.html
   [104]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-hsw7/igt@kms_frontbuffer_tracking@psr-1p-primscrn-cur-indfb-move.html

  * igt@kms_pipe_crc_basic@read-crc-pipe-d-frame-sequence:
    - shard-snb:          [TIMEOUT][105] ([i915#1958]) -> [SKIP][106] ([fdo#109271]) +4 similar issues
   [105]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-snb2/igt@kms_pipe_crc_basic@read-crc-pipe-d-frame-sequence.html
   [106]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-snb5/igt@kms_pipe_crc_basic@read-crc-pipe-d-frame-sequence.html

  * igt@kms_pipe_crc_basic@suspend-read-crc-pipe-a:
    - shard-kbl:          [INCOMPLETE][107] ([i915#155]) -> [DMESG-WARN][108] ([i915#180])
   [107]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-kbl4/igt@kms_pipe_crc_basic@suspend-read-crc-pipe-a.html
   [108]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-kbl7/igt@kms_pipe_crc_basic@suspend-read-crc-pipe-a.html

  * igt@kms_plane_alpha_blend@pipe-d-alpha-transparent-fb:
    - shard-snb:          [SKIP][109] ([fdo#109271]) -> [TIMEOUT][110] ([i915#1958]) +2 similar issues
   [109]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-snb2/igt@kms_plane_alpha_blend@pipe-d-alpha-transparent-fb.html
   [110]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-snb5/igt@kms_plane_alpha_blend@pipe-d-alpha-transparent-fb.html

  * igt@runner@aborted:
    - shard-hsw:          ([FAIL][111], [FAIL][112]) ([i915#2283]) -> ([FAIL][113], [FAIL][114]) ([i915#142] / [i915#2283])
   [111]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-hsw7/igt@runner@aborted.html
   [112]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-hsw4/igt@runner@aborted.html
   [113]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-hsw8/igt@runner@aborted.html
   [114]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-hsw7/igt@runner@aborted.html
    - shard-kbl:          [FAIL][115] ([i915#1784]) -> [FAIL][116] ([i915#1423] / [i915#1784] / [i915#92])
   [115]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-kbl2/igt@runner@aborted.html
   [116]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-kbl1/igt@runner@aborted.html
    - shard-apl:          ([FAIL][117], [FAIL][118]) ([i915#1635] / [i915#2110]) -> ([FAIL][119], [FAIL][120]) ([i915#1423] / [i915#1635] / [i915#2110])
   [117]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-apl4/igt@runner@aborted.html
   [118]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-apl2/igt@runner@aborted.html
   [119]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-apl1/igt@runner@aborted.html
   [120]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-apl4/igt@runner@aborted.html
    - shard-glk:          [FAIL][121] ([k.org#202321]) -> [FAIL][122] ([i915#1423] / [k.org#202321])
   [121]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-glk3/igt@runner@aborted.html
   [122]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-glk6/igt@runner@aborted.html
    - shard-tglb:         [FAIL][123] ([i915#1852]) -> ([FAIL][124], [FAIL][125], [FAIL][126]) ([i915#1602] / [i915#1852])
   [123]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_5759/shard-tglb6/igt@runner@aborted.html
   [124]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-tglb1/igt@runner@aborted.html
   [125]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-tglb6/igt@runner@aborted.html
   [126]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/shard-tglb6/igt@runner@aborted.html

  
  {name}: This element is suppressed. This means it is ignored when computing
          the status of the difference (SUCCESS, WARNING, or FAILURE).

  [IGT#5]: https://gitlab.freedesktop.org/drm/igt-gpu-tools/issues/5
  [fdo#109271]: https://bugs.freedesktop.org/show_bug.cgi?id=109271
  [fdo#109441]: https://bugs.freedesktop.org/show_bug.cgi?id=109441
  [fdo#111827]: https://bugs.freedesktop.org/show_bug.cgi?id=111827
  [i915#118]: https://gitlab.freedesktop.org/drm/intel/issues/118
  [i915#1373]: https://gitlab.freedesktop.org/drm/intel/issues/1373
  [i915#142]: https://gitlab.freedesktop.org/drm/intel/issues/142
  [i915#1423]: https://gitlab.freedesktop.org/drm/intel/issues/1423
  [i915#1542]: https://gitlab.freedesktop.org/drm/intel/issues/1542
  [i915#155]: https://gitlab.freedesktop.org/drm/intel/issues/155
  [i915#1602]: https://gitlab.freedesktop.org/drm/intel/issues/1602
  [i915#1635]: https://gitlab.freedesktop.org/drm/intel/issues/1635
  [i915#1665]: https://gitlab.freedesktop.org/drm/intel/issues/1665
  [i915#1722]: https://gitlab.freedesktop.org/drm/intel/issues/1722
  [i915#173]: https://gitlab.freedesktop.org/drm/intel/issues/173
  [i915#1784]: https://gitlab.freedesktop.org/drm/intel/issues/1784
  [i915#180]: https://gitlab.freedesktop.org/drm/intel/issues/180
  [i915#1852]: https://gitlab.freedesktop.org/drm/intel/issues/1852
  [i915#1887]: https://gitlab.freedesktop.org/drm/intel/issues/1887
  [i915#1958]: https://gitlab.freedesktop.org/drm/intel/issues/1958
  [i915#1982]: https://gitlab.freedesktop.org/drm/intel/issues/1982
  [i915#2055]: https://gitlab.freedesktop.org/drm/intel/issues/2055
  [i915#2110]: https://gitlab.freedesktop.org/drm/intel/issues/2110
  [i915#2258]: https://gitlab.freedesktop.org/drm/intel/issues/2258
  [i915#2283]: https://gitlab.freedesktop.org/drm/intel/issues/2283
  [i915#31]: https://gitlab.freedesktop.org/drm/intel/issues/31
  [i915#454]: https://gitlab.freedesktop.org/drm/intel/issues/454
  [i915#456]: https://gitlab.freedesktop.org/drm/intel/issues/456
  [i915#49]: https://gitlab.freedesktop.org/drm/intel/issues/49
  [i915#588]: https://gitlab.freedesktop.org/drm/intel/issues/588
  [i915#658]: https://gitlab.freedesktop.org/drm/intel/issues/658
  [i915#82]: https://gitlab.freedesktop.org/drm/intel/issues/82
  [i915#83]: https://gitlab.freedesktop.org/drm/intel/issues/83
  [i915#92]: https://gitlab.freedesktop.org/drm/intel/issues/92
  [i915#926]: https://gitlab.freedesktop.org/drm/intel/issues/926
  [i915#95]: https://gitlab.freedesktop.org/drm/intel/issues/95
  [k.org#202321]: https://bugzilla.kernel.org/show_bug.cgi?id=202321


Participating hosts (8 -> 8)
------------------------------

  No changes in participating hosts


Build changes
-------------

  * CI: CI-20190529 -> None
  * IGT: IGT_5759 -> IGTPW_4852

  CI-20190529: 20190529
  CI_DRM_8845: a486392fed875e0b9154eaeb4bf6a4193484e0b3 @ git://anongit.freedesktop.org/gfx-ci/linux
  IGTPW_4852: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/index.html
  IGT_5759: 917b8990f87afa8a04beff8b491450f8bc9201de @ git://anongit.freedesktop.org/xorg/app/intel-gpu-tools

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4852/index.html

[-- Attachment #1.2: Type: text/html, Size: 30811 bytes --]

[-- Attachment #2: Type: text/plain, Size: 154 bytes --]

_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

[igt-dev] [PATCH v2 0/2] New subtest for VRR Flipline mode

[Bhanuprakash Modem]

To validate Adaptive-Sync's Flipline mode, make sure that flips happen at
flipline decision boundary.

Example: if monitor vrr range is 40 - 60Hz and

* flip at refresh_rate > 60Hz:
        Flip should happen at the flipline boundary & returned refresh rate
        would be 60Hz.
* flip at refresh_rate == 50Hz:
        Flip should happen right away so returned refresh rate is 50Hz.
* flip at refresh_rate < 40Hz:
        Flip should happen at the vmax so the returned refresh rate
        would be 40Hz.

Bhanuprakash Modem (2):
  tests/kms_vrr: Use atomic API for page flip
  tests/kms_vrr: Add new subtest to validate Flipline mode

 tests/kms_vrr.c | 142 +++++++++++++++++++++++++++++++-----------------
 1 file changed, 91 insertions(+), 51 deletions(-)

-- 
2.20.1

_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev