[igt-dev] [PATCH v2] [DO NOT REVIEW] testing headers in CI

Jani Nikula jani.nikula at linux.intel.com
Fri Dec 30 12:51:13 UTC 2022


On Thu, 29 Dec 2022, Mark Yacoub <markyacoub at chromium.org> wrote:
> From: Mark Yacoub <markyacoub at google.com>

A commit message would be appreciated to let us know what you're doing,
regardless of the "DO NOT REVIEW" part.

Thanks,
Jani.

>
> ---
>  docs/chamelium.txt                            |    2 +-
>  lib/igt_edid.h                                |    1 +
>  lib/igt_eld.h                                 |    1 +
>  lib/monitor_edids/monitor_edids_helper.c      |    2 +-
>  tests/chamelium/kms_chamelium.c               | 3132 -----------------
>  tests/chamelium/kms_chamelium_audio.c         |  858 +++++
>  ...olor_chamelium.c => kms_chamelium_color.c} |    0
>  tests/chamelium/kms_chamelium_edid.c          |  543 +++
>  tests/chamelium/kms_chamelium_frames.c        | 1085 ++++++
>  tests/chamelium/kms_chamelium_helper.c        |  330 ++
>  tests/chamelium/kms_chamelium_helper.h        |   74 +
>  tests/chamelium/kms_chamelium_hpd.c           |  512 +++
>  tests/intel-ci/blacklist.txt                  |    2 +-
>  tests/intel-ci/fast-feedback.testlist         |   18 +-
>  tests/kms_color_helper.h                      |    2 +-
>  tests/meson.build                             |   14 +-
>  tests/vc4_ci/vc4-chamelium-fast.testlist      |   28 +-
>  17 files changed, 3440 insertions(+), 3164 deletions(-)
>  delete mode 100644 tests/chamelium/kms_chamelium.c
>  create mode 100644 tests/chamelium/kms_chamelium_audio.c
>  rename tests/chamelium/{kms_color_chamelium.c => kms_chamelium_color.c} (100%)
>  create mode 100644 tests/chamelium/kms_chamelium_edid.c
>  create mode 100644 tests/chamelium/kms_chamelium_frames.c
>  create mode 100644 tests/chamelium/kms_chamelium_helper.c
>  create mode 100644 tests/chamelium/kms_chamelium_helper.h
>  create mode 100644 tests/chamelium/kms_chamelium_hpd.c
>
> diff --git a/docs/chamelium.txt b/docs/chamelium.txt
> index c4c22468..f82c8b0c 100644
> --- a/docs/chamelium.txt
> +++ b/docs/chamelium.txt
> @@ -241,7 +241,7 @@ Current Support in IGT
>  
>  Support for the Chamelium platform in IGT is found in the following places:
>  * lib/igt_chamelium.c: library with Chamelium-related helpers
> -* tests/kms_chamelium.c: sub-tests using the Chamelium
> +* tests/kms_chamelium_*.c: sub-tests using the Chamelium
>  
>  As of early April 2019, the following features are tested by IGT:
>  * Pixel-by-pixel frame integrity tests for DP and HDMI
> diff --git a/lib/igt_edid.h b/lib/igt_edid.h
> index 477f16c2..85a9ef5e 100644
> --- a/lib/igt_edid.h
> +++ b/lib/igt_edid.h
> @@ -29,6 +29,7 @@
>  #include "config.h"
>  
>  #include <stdint.h>
> +#include <stddef.h>
>  
>  #include <xf86drmMode.h>
>  
> diff --git a/lib/igt_eld.h b/lib/igt_eld.h
> index 30d7012d..1a46b6d2 100644
> --- a/lib/igt_eld.h
> +++ b/lib/igt_eld.h
> @@ -29,6 +29,7 @@
>  #include "config.h"
>  
>  #include <stdbool.h>
> +#include <stddef.h>
>  
>  #include "igt_edid.h"
>  
> diff --git a/lib/monitor_edids/monitor_edids_helper.c b/lib/monitor_edids/monitor_edids_helper.c
> index 41f199bd..1cbf1c22 100644
> --- a/lib/monitor_edids/monitor_edids_helper.c
> +++ b/lib/monitor_edids/monitor_edids_helper.c
> @@ -1,4 +1,4 @@
> -// SPDX-License-Identifier: GPL-2.0
> +// SPDX-License-Identifier: MIT
>  /*
>   * A helper library for parsing and making use of real EDID data from monitors
>   * and make them compatible with IGT and Chamelium.
> diff --git a/tests/chamelium/kms_chamelium.c b/tests/chamelium/kms_chamelium.c
> deleted file mode 100644
> index 3c4b4d75..00000000
> --- a/tests/chamelium/kms_chamelium.c
> +++ /dev/null
> @@ -1,3132 +0,0 @@
> -/*
> - * Copyright © 2016 Red Hat Inc.
> - *
> - * Permission is hereby granted, free of charge, to any person obtaining a
> - * copy of this software and associated documentation files (the "Software"),
> - * to deal in the Software without restriction, including without limitation
> - * the rights to use, copy, modify, merge, publish, distribute, sublicense,
> - * and/or sell copies of the Software, and to permit persons to whom the
> - * Software is furnished to do so, subject to the following conditions:
> - *
> - * The above copyright notice and this permission notice (including the next
> - * paragraph) shall be included in all copies or substantial portions of the
> - * Software.
> - *
> - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
> - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
> - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
> - * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
> - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
> - * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
> - * IN THE SOFTWARE.
> - *
> - * Authors:
> - *    Lyude Paul <lyude at redhat.com>
> - */
> -
> -#include "config.h"
> -#include "igt.h"
> -#include "igt_vc4.h"
> -#include "igt_edid.h"
> -#include "igt_eld.h"
> -#include "igt_infoframe.h"
> -#include "monitor_edids/dp_edids.h"
> -#include "monitor_edids/hdmi_edids.h"
> -#include "monitor_edids/monitor_edids_helper.h"
> -
> -#include <fcntl.h>
> -#include <pthread.h>
> -#include <string.h>
> -#include <stdatomic.h>
> -// #include <stdio.h>
> -
> -// struct chamelium_edid;
> -
> -enum test_modeset_mode {
> -	TEST_MODESET_ON,
> -	TEST_MODESET_ON_OFF,
> -	TEST_MODESET_OFF,
> -};
> -
> -typedef struct {
> -	struct chamelium *chamelium;
> -	struct chamelium_port **ports;
> -	igt_display_t display;
> -	int port_count;
> -
> -	int drm_fd;
> -
> -	struct chamelium_edid *edids[IGT_CUSTOM_EDID_COUNT];
> -} data_t;
> -
> -#define ONLINE_TIMEOUT 20 /* seconds */
> -
> -#define HPD_STORM_PULSE_INTERVAL_DP 100 /* ms */
> -#define HPD_STORM_PULSE_INTERVAL_HDMI 200 /* ms */
> -
> -#define HPD_TOGGLE_COUNT_VGA 5
> -#define HPD_TOGGLE_COUNT_DP_HDMI 15
> -#define HPD_TOGGLE_COUNT_FAST 3
> -
> -static void
> -get_connectors_link_status_failed(data_t *data, bool *link_status_failed)
> -{
> -	drmModeConnector *connector;
> -	uint64_t link_status;
> -	drmModePropertyPtr prop;
> -	int p;
> -
> -	for (p = 0; p < data->port_count; p++) {
> -		connector = chamelium_port_get_connector(data->chamelium,
> -							 data->ports[p], false);
> -
> -		igt_assert(kmstest_get_property(data->drm_fd,
> -						connector->connector_id,
> -						DRM_MODE_OBJECT_CONNECTOR,
> -						"link-status", NULL,
> -						&link_status, &prop));
> -
> -		link_status_failed[p] = link_status == DRM_MODE_LINK_STATUS_BAD;
> -
> -		drmModeFreeProperty(prop);
> -		drmModeFreeConnector(connector);
> -	}
> -}
> -
> -/* Wait for hotplug and return the remaining time left from timeout */
> -static bool wait_for_hotplug(struct udev_monitor *mon, int *timeout)
> -{
> -	struct timespec start, end;
> -	int elapsed;
> -	bool detected;
> -
> -	igt_assert_eq(igt_gettime(&start), 0);
> -	detected = igt_hotplug_detected(mon, *timeout);
> -	igt_assert_eq(igt_gettime(&end), 0);
> -
> -	elapsed = igt_time_elapsed(&start, &end);
> -	igt_assert_lte(0, elapsed);
> -	*timeout = max(0, *timeout - elapsed);
> -
> -	return detected;
> -}
> -
> -static void
> -wait_for_connector_after_hotplug(data_t *data, struct udev_monitor *mon,
> -				 struct chamelium_port *port,
> -				 drmModeConnection status)
> -{
> -	int timeout = CHAMELIUM_HOTPLUG_TIMEOUT;
> -	int hotplug_count = 0;
> -
> -	igt_debug("Waiting for %s to get %s after a hotplug event...\n",
> -			  chamelium_port_get_name(port),
> -			  kmstest_connector_status_str(status));
> -
> -	while (timeout > 0) {
> -		if (!wait_for_hotplug(mon, &timeout))
> -			break;
> -
> -		hotplug_count++;
> -
> -		if (chamelium_reprobe_connector(&data->display, data->chamelium,
> -						port) == status)
> -			return;
> -	}
> -
> -	igt_assert_f(false, "Timed out waiting for %s to get %s after a hotplug. Current state %s hotplug_count %d\n",
> -			    chamelium_port_get_name(port),
> -			    kmstest_connector_status_str(status),
> -			    kmstest_connector_status_str(chamelium_reprobe_connector(&data->display, data->chamelium, port)), hotplug_count);
> -}
> -
> -
> -static int chamelium_vga_modes[][2] = {
> -	{ 1600, 1200 },
> -	{ 1920, 1200 },
> -	{ 1920, 1080 },
> -	{ 1680, 1050 },
> -	{ 1280, 1024 },
> -	{ 1280, 960 },
> -	{ 1440, 900 },
> -	{ 1280, 800 },
> -	{ 1024, 768 },
> -	{ 1360, 768 },
> -	{ 1280, 720 },
> -	{ 800, 600 },
> -	{ 640, 480 },
> -	{ -1, -1 },
> -};
> -
> -static bool
> -prune_vga_mode(data_t *data, drmModeModeInfo *mode)
> -{
> -	int i = 0;
> -
> -	while (chamelium_vga_modes[i][0] != -1) {
> -		if (mode->hdisplay == chamelium_vga_modes[i][0] &&
> -		    mode->vdisplay == chamelium_vga_modes[i][1])
> -			return false;
> -
> -		i++;
> -	}
> -
> -	return true;
> -}
> -
> -static bool
> -check_analog_bridge(data_t *data, struct chamelium_port *port)
> -{
> -	drmModePropertyBlobPtr edid_blob = NULL;
> -	drmModeConnector *connector = chamelium_port_get_connector(
> -	    data->chamelium, port, false);
> -	uint64_t edid_blob_id;
> -	const struct edid *edid;
> -	char edid_vendor[3];
> -
> -	if (chamelium_port_get_type(port) != DRM_MODE_CONNECTOR_VGA) {
> -		drmModeFreeConnector(connector);
> -		return false;
> -	}
> -
> -	igt_assert(kmstest_get_property(data->drm_fd, connector->connector_id,
> -					DRM_MODE_OBJECT_CONNECTOR, "EDID", NULL,
> -					&edid_blob_id, NULL));
> -	igt_assert(edid_blob = drmModeGetPropertyBlob(data->drm_fd,
> -						      edid_blob_id));
> -
> -	edid = (const struct edid *) edid_blob->data;
> -	edid_get_mfg(edid, edid_vendor);
> -
> -	drmModeFreePropertyBlob(edid_blob);
> -	drmModeFreeConnector(connector);
> -
> -	/* Analog bridges provide their own EDID */
> -	if (edid_vendor[0] != 'I' || edid_vendor[1] != 'G' ||
> -	    edid_vendor[2] != 'T')
> -		return true;
> -
> -	return false;
> -}
> -
> -static void chamelium_paint_xr24_pattern(uint32_t *data,
> -					 size_t width, size_t height,
> -					 size_t stride, size_t block_size)
> -{
> -	uint32_t colors[] = { 0xff000000,
> -			      0xffff0000,
> -			      0xff00ff00,
> -			      0xff0000ff,
> -			      0xffffffff };
> -	unsigned i, j;
> -
> -	for (i = 0; i < height; i++)
> -		for (j = 0; j < width; j++)
> -			*(data + i * stride / 4 + j) = colors[((j / block_size) + (i / block_size)) % 5];
> -}
> -
> -static int chamelium_get_pattern_fb(data_t *data, size_t width, size_t height,
> -				    uint32_t fourcc, size_t block_size,
> -				    struct igt_fb *fb)
> -{
> -	int fb_id;
> -	void *ptr;
> -
> -	igt_assert(fourcc == DRM_FORMAT_XRGB8888);
> -
> -	fb_id = igt_create_fb(data->drm_fd, width, height, fourcc,
> -			      DRM_FORMAT_MOD_LINEAR, fb);
> -	igt_assert(fb_id > 0);
> -
> -	ptr = igt_fb_map_buffer(fb->fd, fb);
> -	igt_assert(ptr);
> -
> -	chamelium_paint_xr24_pattern(ptr, width, height, fb->strides[0],
> -				     block_size);
> -	igt_fb_unmap_buffer(fb, ptr);
> -
> -	return fb_id;
> -}
> -
> -static void
> -enable_output(data_t *data,
> -	      struct chamelium_port *port,
> -	      igt_output_t *output,
> -	      drmModeModeInfo *mode,
> -	      struct igt_fb *fb)
> -{
> -	igt_display_t *display = output->display;
> -	igt_plane_t *primary = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY);
> -	drmModeConnector *connector = chamelium_port_get_connector(
> -	    data->chamelium, port, false);
> -
> -	igt_assert(primary);
> -
> -	igt_plane_set_size(primary, mode->hdisplay, mode->vdisplay);
> -	igt_plane_set_fb(primary, fb);
> -	igt_output_override_mode(output, mode);
> -
> -	/* Clear any color correction values that might be enabled */
> -	if (igt_pipe_obj_has_prop(primary->pipe, IGT_CRTC_DEGAMMA_LUT))
> -		igt_pipe_obj_replace_prop_blob(primary->pipe, IGT_CRTC_DEGAMMA_LUT, NULL, 0);
> -	if (igt_pipe_obj_has_prop(primary->pipe, IGT_CRTC_GAMMA_LUT))
> -		igt_pipe_obj_replace_prop_blob(primary->pipe, IGT_CRTC_GAMMA_LUT, NULL, 0);
> -	if (igt_pipe_obj_has_prop(primary->pipe, IGT_CRTC_CTM))
> -		igt_pipe_obj_replace_prop_blob(primary->pipe, IGT_CRTC_CTM, NULL, 0);
> -
> -	igt_display_commit2(display, COMMIT_ATOMIC);
> -
> -	if (chamelium_port_get_type(port) == DRM_MODE_CONNECTOR_VGA)
> -		usleep(250000);
> -
> -	drmModeFreeConnector(connector);
> -}
> -
> -static enum pipe get_pipe_for_output(igt_display_t *display, igt_output_t *output)
> -{
> -	enum pipe pipe;
> -
> -	for_each_pipe(display, pipe) {
> -		if (igt_pipe_connector_valid(pipe, output)) {
> -			return pipe;
> -		}
> -	}
> -
> -	igt_assert_f(false, "No pipe found for output %s\n",
> -		     igt_output_name(output));
> -}
> -
> -static void create_fb_for_mode(data_t *data, struct igt_fb *fb, drmModeModeInfo *mode)
> -{
> -	int fb_id;
> -
> -	fb_id = chamelium_get_pattern_fb(data, mode->hdisplay, mode->vdisplay,
> -					 DRM_FORMAT_XRGB8888, 64, fb);
> -
> -	igt_assert(fb_id > 0);
> -}
> -
> -static drmModeModeInfo get_mode_for_port(struct chamelium *chamelium,
> -					 struct chamelium_port *port)
> -{
> -	drmModeConnector *connector = chamelium_port_get_connector(chamelium,
> -								   port, false);
> -	drmModeModeInfo mode;
> -	igt_assert(&connector->modes[0] != NULL);
> -	memcpy(&mode, &connector->modes[0], sizeof(mode));
> -	drmModeFreeConnector(connector);
> -	return mode;
> -}
> -
> -static igt_output_t *get_output_for_port(data_t *data,
> -					 struct chamelium_port *port)
> -{
> -	drmModeConnector *connector =
> -		chamelium_port_get_connector(data->chamelium, port, true);
> -	igt_output_t *output = igt_output_from_connector(&data->display,
> -							 connector);
> -	drmModeFreeConnector(connector);
> -	igt_assert(output != NULL);
> -	return output;
> -}
> -
> -static const char test_hotplug_for_each_pipe_desc[] =
> -	"Check that we get uevents and updated connector status on "
> -	"hotplug and unplug for each pipe with valid output";
> -static void
> -test_hotplug_for_each_pipe(data_t *data, struct chamelium_port *port)
> -{
> -	igt_output_t *output;
> -	enum pipe pipe;
> -	struct udev_monitor *mon = igt_watch_uevents();
> -
> -	chamelium_reset_state(&data->display,
> -			      data->chamelium,
> -			      port,
> -			      data->ports,
> -			      data->port_count);
> -
> -	igt_hpd_storm_set_threshold(data->drm_fd, 0);
> -	/* Disconnect if any port got connected */
> -	chamelium_unplug(data->chamelium, port);
> -	wait_for_connector_after_hotplug(data, mon, port,
> -			DRM_MODE_DISCONNECTED);
> -
> -	for_each_pipe(&data->display, pipe) {
> -		igt_flush_uevents(mon);
> -		/* Check if we get a sysfs hotplug event */
> -		chamelium_plug(data->chamelium, port);
> -		wait_for_connector_after_hotplug(data, mon, port,
> -				DRM_MODE_CONNECTED);
> -		igt_flush_uevents(mon);
> -		output = get_output_for_port(data, port);
> -
> -		/* If pipe is valid for output then set it */
> -		if (igt_pipe_connector_valid(pipe, output)) {
> -			igt_output_set_pipe(output, pipe);
> -			igt_display_commit2(&data->display, COMMIT_ATOMIC);
> -		}
> -
> -		chamelium_unplug(data->chamelium, port);
> -		wait_for_connector_after_hotplug(data, mon, port,
> -				DRM_MODE_DISCONNECTED);
> -		igt_flush_uevents(mon);
> -	}
> -
> -	igt_cleanup_uevents(mon);
> -	igt_hpd_storm_reset(data->drm_fd);
> -}
> -
> -static const char test_basic_hotplug_desc[] =
> -	"Check that we get uevents and updated connector status on "
> -	"hotplug and unplug";
> -static void
> -test_hotplug(data_t *data, struct chamelium_port *port, int toggle_count,
> -	     enum test_modeset_mode modeset_mode)
> -{
> -	int i;
> -	enum pipe pipe;
> -	struct igt_fb fb = {0};
> -	drmModeModeInfo mode;
> -	struct udev_monitor *mon = igt_watch_uevents();
> -	igt_output_t *output = get_output_for_port(data, port);
> -
> -	igt_modeset_disable_all_outputs(&data->display);
> -	chamelium_reset_state(&data->display, data->chamelium, NULL,
> -			      data->ports, data->port_count);
> -
> -
> -	igt_hpd_storm_set_threshold(data->drm_fd, 0);
> -
> -	for (i = 0; i < toggle_count; i++) {
> -		igt_flush_uevents(mon);
> -
> -		/* Check if we get a sysfs hotplug event */
> -		chamelium_plug(data->chamelium, port);
> -
> -		wait_for_connector_after_hotplug(data, mon, port,
> -						 DRM_MODE_CONNECTED);
> -		igt_flush_uevents(mon);
> -
> -		if (modeset_mode == TEST_MODESET_ON_OFF ||
> -		    (modeset_mode == TEST_MODESET_ON && i == 0 )) {
> -			if (i == 0) {
> -				/* We can only get mode and pipe once we are connected */
> -				output = get_output_for_port(data, port);
> -				pipe = get_pipe_for_output(&data->display, output);
> -				mode = get_mode_for_port(data->chamelium, port);
> -				create_fb_for_mode(data, &fb, &mode);
> -			}
> -
> -			igt_output_set_pipe(output, pipe);
> -			enable_output(data, port, output, &mode, &fb);
> -		}
> -
> -		/* Now check if we get a hotplug from disconnection */
> -		chamelium_unplug(data->chamelium, port);
> -
> -		wait_for_connector_after_hotplug(data, mon, port,
> -						 DRM_MODE_DISCONNECTED);
> -
> -		igt_flush_uevents(mon);
> -
> -		if (modeset_mode == TEST_MODESET_ON_OFF) {
> -			igt_output_set_pipe(output, PIPE_NONE);
> -			igt_display_commit2(&data->display, COMMIT_ATOMIC);
> -		}
> -	}
> -
> -	igt_cleanup_uevents(mon);
> -	igt_hpd_storm_reset(data->drm_fd);
> -	igt_remove_fb(data->drm_fd, &fb);
> -}
> -
> -static void set_edid(data_t *data, struct chamelium_port *port,
> -		     enum igt_custom_edid_type edid)
> -{
> -	chamelium_port_set_edid(data->chamelium, port, data->edids[edid]);
> -}
> -
> -static const char igt_custom_edid_type_read_desc[] =
> -	"Make sure the EDID exposed by KMS is the same as the screen's";
> -static void
> -igt_custom_edid_type_read(data_t *data, struct chamelium_port *port, enum igt_custom_edid_type edid)
> -{
> -	drmModePropertyBlobPtr edid_blob = NULL;
> -	drmModeConnector *connector;
> -	size_t raw_edid_size;
> -	const struct edid *raw_edid;
> -	uint64_t edid_blob_id;
> -
> -	igt_modeset_disable_all_outputs(&data->display);
> -	chamelium_reset_state(&data->display, data->chamelium,
> -			      port, data->ports, data->port_count);
> -
> -	set_edid(data, port, edid);
> -	chamelium_plug(data->chamelium, port);
> -	chamelium_wait_for_conn_status_change(&data->display, data->chamelium,
> -					      port, DRM_MODE_CONNECTED);
> -
> -	igt_skip_on(check_analog_bridge(data, port));
> -
> -	connector = chamelium_port_get_connector(data->chamelium, port, true);
> -	igt_assert(kmstest_get_property(data->drm_fd, connector->connector_id,
> -					DRM_MODE_OBJECT_CONNECTOR, "EDID", NULL,
> -					&edid_blob_id, NULL));
> -	igt_assert(edid_blob_id != 0);
> -	igt_assert(edid_blob = drmModeGetPropertyBlob(data->drm_fd,
> -						      edid_blob_id));
> -
> -	raw_edid = chamelium_edid_get_raw(data->edids[edid], port);
> -	raw_edid_size = edid_get_size(raw_edid);
> -	igt_assert(memcmp(raw_edid, edid_blob->data, raw_edid_size) == 0);
> -
> -	drmModeFreePropertyBlob(edid_blob);
> -	drmModeFreeConnector(connector);
> -}
> -
> -static void
> -try_suspend_resume_hpd(data_t *data, struct chamelium_port *port,
> -		       enum igt_suspend_state state, enum igt_suspend_test test,
> -		       struct udev_monitor *mon, bool connected)
> -{
> -	drmModeConnection target_state = connected ? DRM_MODE_DISCONNECTED :
> -						     DRM_MODE_CONNECTED;
> -	int timeout = CHAMELIUM_HOTPLUG_TIMEOUT;
> -	int delay;
> -	int p;
> -
> -	igt_flush_uevents(mon);
> -
> -	delay = igt_get_autoresume_delay(state) * 1000 / 2;
> -
> -	if (port) {
> -		chamelium_schedule_hpd_toggle(data->chamelium, port, delay,
> -					      !connected);
> -	} else {
> -		for (p = 0; p < data->port_count; p++) {
> -			port = data->ports[p];
> -			chamelium_schedule_hpd_toggle(data->chamelium, port,
> -						      delay, !connected);
> -		}
> -
> -		port = NULL;
> -	}
> -
> -	igt_system_suspend_autoresume(state, test);
> -	igt_assert(wait_for_hotplug(mon, &timeout));
> -	chamelium_assert_reachable(data->chamelium, ONLINE_TIMEOUT);
> -
> -	if (port) {
> -		igt_assert_eq(chamelium_reprobe_connector(&data->display,
> -							  data->chamelium,
> -							  port),
> -							  target_state);
> -	} else {
> -		for (p = 0; p < data->port_count; p++) {
> -			drmModeConnection current_state;
> -
> -			port = data->ports[p];
> -			/*
> -			 * There could be as many hotplug events sent by
> -			 * driver as connectors we scheduled an HPD toggle on
> -			 * above, depending on timing. So if we're not seeing
> -			 * the expected connector state try to wait for an HPD
> -			 * event for each connector/port.
> -			 */
> -			current_state = chamelium_reprobe_connector(&data->display, data->chamelium, port);
> -			if (p > 0 && current_state != target_state) {
> -				igt_assert(wait_for_hotplug(mon, &timeout));
> -				current_state = chamelium_reprobe_connector(&data->display, data->chamelium, port);
> -			}
> -
> -			igt_assert_eq(current_state, target_state);
> -		}
> -
> -		port = NULL;
> -	}
> -}
> -
> -static const char test_suspend_resume_hpd_desc[] =
> -	"Toggle HPD during suspend, check that uevents are sent and connector "
> -	"status is updated";
> -static void
> -test_suspend_resume_hpd(data_t *data, struct chamelium_port *port,
> -			enum igt_suspend_state state,
> -			enum igt_suspend_test test)
> -{
> -	struct udev_monitor *mon = igt_watch_uevents();
> -
> -	igt_modeset_disable_all_outputs(&data->display);
> -	chamelium_reset_state(&data->display, data->chamelium,
> -			      port, data->ports, data->port_count);
> -
> -	/* Make sure we notice new connectors after resuming */
> -	try_suspend_resume_hpd(data, port, state, test, mon, false);
> -
> -	/* Now make sure we notice disconnected connectors after resuming */
> -	try_suspend_resume_hpd(data, port, state, test, mon, true);
> -
> -	igt_cleanup_uevents(mon);
> -}
> -
> -static const char test_suspend_resume_hpd_common_desc[] =
> -	"Toggle HPD during suspend on all connectors, check that uevents are "
> -	"sent and connector status is updated";
> -static void
> -test_suspend_resume_hpd_common(data_t *data, enum igt_suspend_state state,
> -			       enum igt_suspend_test test)
> -{
> -	struct udev_monitor *mon = igt_watch_uevents();
> -	struct chamelium_port *port;
> -	int p;
> -
> -	for (p = 0; p < data->port_count; p++) {
> -		port = data->ports[p];
> -		igt_debug("Testing port %s\n", chamelium_port_get_name(port));
> -	}
> -
> -	igt_modeset_disable_all_outputs(&data->display);
> -	chamelium_reset_state(&data->display, data->chamelium, NULL,
> -			      data->ports, data->port_count);
> -
> -	/* Make sure we notice new connectors after resuming */
> -	try_suspend_resume_hpd(data, NULL, state, test, mon, false);
> -
> -	/* Now make sure we notice disconnected connectors after resuming */
> -	try_suspend_resume_hpd(data, NULL, state, test, mon, true);
> -
> -	igt_cleanup_uevents(mon);
> -}
> -
> -static const char test_suspend_resume_edid_change_desc[] =
> -	"Simulate a screen being unplugged and another screen being plugged "
> -	"during suspend, check that a uevent is sent and connector status is "
> -	"updated";
> -static void
> -test_suspend_resume_edid_change(data_t *data, struct chamelium_port *port,
> -				enum igt_suspend_state state,
> -				enum igt_suspend_test test,
> -				enum igt_custom_edid_type edid,
> -				enum igt_custom_edid_type alt_edid)
> -{
> -	struct udev_monitor *mon = igt_watch_uevents();
> -	bool link_status_failed[2][data->port_count];
> -	int p;
> -
> -	igt_modeset_disable_all_outputs(&data->display);
> -	chamelium_reset_state(&data->display, data->chamelium,
> -			      port, data->ports, data->port_count);
> -
> -	/* Catch the event and flush all remaining ones. */
> -	igt_assert(igt_hotplug_detected(mon, CHAMELIUM_HOTPLUG_TIMEOUT));
> -	igt_flush_uevents(mon);
> -
> -	/* First plug in the port */
> -	set_edid(data, port, edid);
> -	chamelium_plug(data->chamelium, port);
> -	igt_assert(igt_hotplug_detected(mon, CHAMELIUM_HOTPLUG_TIMEOUT));
> -
> -	chamelium_wait_for_conn_status_change(&data->display, data->chamelium,
> -					      port, DRM_MODE_CONNECTED);
> -
> -	/*
> -	 * Change the edid before we suspend. On resume, the machine should
> -	 * notice the EDID change and fire a hotplug event.
> -	 */
> -	set_edid(data, port, alt_edid);
> -
> -	get_connectors_link_status_failed(data, link_status_failed[0]);
> -
> -	igt_flush_uevents(mon);
> -
> -	igt_system_suspend_autoresume(state, test);
> -	igt_assert(igt_hotplug_detected(mon, CHAMELIUM_HOTPLUG_TIMEOUT));
> -	chamelium_assert_reachable(data->chamelium, ONLINE_TIMEOUT);
> -
> -	get_connectors_link_status_failed(data, link_status_failed[1]);
> -
> -	for (p = 0; p < data->port_count; p++)
> -		igt_skip_on(!link_status_failed[0][p] && link_status_failed[1][p]);
> -}
> -
> -static igt_output_t *
> -prepare_output(data_t *data, struct chamelium_port *port, enum igt_custom_edid_type edid)
> -{
> -	igt_display_t *display = &data->display;
> -	igt_output_t *output;
> -	enum pipe pipe;
> -
> -	/* The chamelium's default EDID has a lot of resolutions, way more then
> -	 * we need to test. Additionally the default EDID doesn't support HDMI
> -	 * audio.
> -	 */
> -	set_edid(data, port, edid);
> -
> -	chamelium_plug(data->chamelium, port);
> -	chamelium_wait_for_conn_status_change(&data->display, data->chamelium,
> -					      port, DRM_MODE_CONNECTED);
> -
> -	igt_display_reset(display);
> -
> -	output = get_output_for_port(data, port);
> -
> -	/* Refresh pipe to update connected status */
> -	igt_output_set_pipe(output, PIPE_NONE);
> -
> -	pipe = get_pipe_for_output(display, output);
> -	igt_output_set_pipe(output, pipe);
> -
> -	return output;
> -}
> -
> -static void do_test_display(data_t *data, struct chamelium_port *port,
> -			    igt_output_t *output, drmModeModeInfo *mode,
> -			    uint32_t fourcc, enum chamelium_check check,
> -			    int count)
> -{
> -	struct chamelium_fb_crc_async_data *fb_crc;
> -	struct igt_fb frame_fb, fb;
> -	int i, fb_id, captured_frame_count;
> -	int frame_id;
> -
> -	fb_id = chamelium_get_pattern_fb(data, mode->hdisplay, mode->vdisplay,
> -					 DRM_FORMAT_XRGB8888, 64, &fb);
> -	igt_assert(fb_id > 0);
> -
> -	frame_id = igt_fb_convert(&frame_fb, &fb, fourcc,
> -				  DRM_FORMAT_MOD_LINEAR);
> -	igt_assert(frame_id > 0);
> -
> -	if (check == CHAMELIUM_CHECK_CRC)
> -		fb_crc = chamelium_calculate_fb_crc_async_start(data->drm_fd,
> -								&fb);
> -
> -	enable_output(data, port, output, mode, &frame_fb);
> -
> -	if (check == CHAMELIUM_CHECK_CRC) {
> -		igt_crc_t *expected_crc;
> -		igt_crc_t *crc;
> -
> -		/* We want to keep the display running for a little bit, since
> -		 * there's always the potential the driver isn't able to keep
> -		 * the display running properly for very long
> -		 */
> -		chamelium_capture(data->chamelium, port, 0, 0, 0, 0, count);
> -		crc = chamelium_read_captured_crcs(data->chamelium,
> -						   &captured_frame_count);
> -
> -		igt_assert(captured_frame_count == count);
> -
> -		igt_debug("Captured %d frames\n", captured_frame_count);
> -
> -		expected_crc = chamelium_calculate_fb_crc_async_finish(fb_crc);
> -
> -		for (i = 0; i < captured_frame_count; i++)
> -			chamelium_assert_crc_eq_or_dump(data->chamelium,
> -							expected_crc, &crc[i],
> -							&fb, i);
> -
> -		free(expected_crc);
> -		free(crc);
> -	} else if (check == CHAMELIUM_CHECK_ANALOG ||
> -		   check == CHAMELIUM_CHECK_CHECKERBOARD) {
> -		struct chamelium_frame_dump *dump;
> -
> -		igt_assert(count == 1);
> -
> -		dump = chamelium_port_dump_pixels(data->chamelium, port, 0, 0,
> -						  0, 0);
> -
> -		if (check == CHAMELIUM_CHECK_ANALOG)
> -			chamelium_crop_analog_frame(dump, mode->hdisplay,
> -						    mode->vdisplay);
> -
> -		chamelium_assert_frame_match_or_dump(data->chamelium, port,
> -						     dump, &fb, check);
> -		chamelium_destroy_frame_dump(dump);
> -	}
> -
> -	igt_remove_fb(data->drm_fd, &frame_fb);
> -	igt_remove_fb(data->drm_fd, &fb);
> -}
> -
> -static const char test_display_one_mode_desc[] =
> -	"Pick the first mode of the IGT base EDID, display and capture a few "
> -	"frames, then check captured frames are correct";
> -static void test_display_one_mode(data_t *data, struct chamelium_port *port,
> -				  uint32_t fourcc, enum chamelium_check check,
> -				  int count)
> -{
> -	drmModeConnector *connector;
> -	drmModeModeInfo *mode;
> -	igt_output_t *output;
> -	igt_plane_t *primary;
> -
> -	igt_modeset_disable_all_outputs(&data->display);
> -	chamelium_reset_state(&data->display, data->chamelium,
> -			      port, data->ports, data->port_count);
> -
> -	output = prepare_output(data, port, IGT_CUSTOM_EDID_BASE);
> -	connector = chamelium_port_get_connector(data->chamelium, port, false);
> -	primary = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY);
> -	igt_assert(primary);
> -
> -	igt_require(igt_plane_has_format_mod(primary, fourcc, DRM_FORMAT_MOD_LINEAR));
> -
> -	mode = &connector->modes[0];
> -	if (check == CHAMELIUM_CHECK_ANALOG) {
> -		bool bridge = check_analog_bridge(data, port);
> -
> -		igt_assert(!(bridge && prune_vga_mode(data, mode)));
> -	}
> -
> -	do_test_display(data, port, output, mode, fourcc, check, count);
> -
> -	drmModeFreeConnector(connector);
> -}
> -
> -static const char test_display_all_modes_desc[] =
> -	"For each mode of the IGT base EDID, display and capture a few "
> -	"frames, then check captured frames are correct";
> -static void test_display_all_modes(data_t *data, struct chamelium_port *port,
> -				   uint32_t fourcc, enum chamelium_check check,
> -				   int count)
> -{
> -	bool bridge;
> -	int i, count_modes;
> -
> -	if (check == CHAMELIUM_CHECK_ANALOG)
> -		bridge = check_analog_bridge(data, port);
> -
> -	i = 0;
> -	do {
> -		igt_output_t *output;
> -		igt_plane_t *primary;
> -		drmModeConnector *connector;
> -		drmModeModeInfo *mode;
> -
> -		/*
> -		 * let's reset state each mode so we will get the
> -		 * HPD pulses realibably
> -		 */
> -		igt_modeset_disable_all_outputs(&data->display);
> -		chamelium_reset_state(&data->display, data->chamelium,
> -				      port, data->ports, data->port_count);
> -
> -		/*
> -		 * modes may change due to mode pruining and link issues, so we
> -		 * need to refresh the connector
> -		 */
> -		output = prepare_output(data, port, IGT_CUSTOM_EDID_BASE);
> -		connector = chamelium_port_get_connector(data->chamelium, port,
> -							 false);
> -		primary = igt_output_get_plane_type(output,
> -						    DRM_PLANE_TYPE_PRIMARY);
> -		igt_assert(primary);
> -		igt_require(igt_plane_has_format_mod(primary, fourcc,
> -			    DRM_FORMAT_MOD_LINEAR));
> -
> -		/* we may skip some modes due to above but that's ok */
> -		count_modes = connector->count_modes;
> -		if (i >= count_modes)
> -			break;
> -
> -		mode = &connector->modes[i];
> -
> -		if (check == CHAMELIUM_CHECK_ANALOG && bridge &&
> -		    prune_vga_mode(data, mode))
> -			continue;
> -
> -		do_test_display(data, port, output, mode, fourcc, check,
> -				count);
> -		drmModeFreeConnector(connector);
> -	} while (++i < count_modes);
> -}
> -
> -static const char test_display_frame_dump_desc[] =
> -	"For each mode of the IGT base EDID, display and capture a few "
> -	"frames, then download the captured frames and compare them "
> -	"bit-by-bit to the sent ones";
> -static void
> -test_display_frame_dump(data_t *data, struct chamelium_port *port)
> -{
> -
> -	int i, count_modes;
> -
> -	i = 0;
> -	do {
> -		igt_output_t *output;
> -		igt_plane_t *primary;
> -		struct igt_fb fb;
> -		struct chamelium_frame_dump *frame;
> -		drmModeModeInfo *mode;
> -		drmModeConnector *connector;
> -		int fb_id, j;
> -
> -		/*
> -		 * let's reset state each mode so we will get the
> -		 * HPD pulses realibably
> -		 */
> -		igt_modeset_disable_all_outputs(&data->display);
> -		chamelium_reset_state(&data->display, data->chamelium,
> -				      port, data->ports, data->port_count);
> -
> -		/*
> -		 * modes may change due to mode pruining and link issues, so we
> -		 * need to refresh the connector
> -		 */
> -		output = prepare_output(data, port, IGT_CUSTOM_EDID_BASE);
> -		connector = chamelium_port_get_connector(data->chamelium, port,
> -							 false);
> -		primary = igt_output_get_plane_type(output,
> -						    DRM_PLANE_TYPE_PRIMARY);
> -		igt_assert(primary);
> -
> -		/* we may skip some modes due to above but that's ok */
> -		count_modes = connector->count_modes;
> -		if (i >= count_modes)
> -			break;
> -
> -		mode = &connector->modes[i];
> -
> -		fb_id = igt_create_color_pattern_fb(data->drm_fd,
> -						    mode->hdisplay, mode->vdisplay,
> -						    DRM_FORMAT_XRGB8888,
> -						    DRM_FORMAT_MOD_LINEAR,
> -						    0, 0, 0, &fb);
> -		igt_assert(fb_id > 0);
> -
> -		enable_output(data, port, output, mode, &fb);
> -
> -		igt_debug("Reading frame dumps from Chamelium...\n");
> -		chamelium_capture(data->chamelium, port, 0, 0, 0, 0, 5);
> -		for (j = 0; j < 5; j++) {
> -			frame = chamelium_read_captured_frame(data->chamelium,
> -							      j);
> -			chamelium_assert_frame_eq(data->chamelium, frame, &fb);
> -			chamelium_destroy_frame_dump(frame);
> -		}
> -
> -		igt_remove_fb(data->drm_fd, &fb);
> -		drmModeFreeConnector(connector);
> -	} while (++i < count_modes);
> -}
> -
> -#define MODE_CLOCK_ACCURACY 0.05 /* 5% */
> -
> -static void check_mode(struct chamelium *chamelium, struct chamelium_port *port,
> -		       drmModeModeInfo *mode)
> -{
> -	struct chamelium_video_params video_params = {0};
> -	double mode_clock;
> -	int mode_hsync_offset, mode_vsync_offset;
> -	int mode_hsync_width, mode_vsync_width;
> -	int mode_hsync_polarity, mode_vsync_polarity;
> -
> -	chamelium_port_get_video_params(chamelium, port, &video_params);
> -
> -	mode_clock = (double) mode->clock / 1000;
> -
> -	if (chamelium_port_get_type(port) == DRM_MODE_CONNECTOR_DisplayPort) {
> -		/* this is what chamelium understands as offsets for DP */
> -		mode_hsync_offset = mode->htotal - mode->hsync_start;
> -		mode_vsync_offset = mode->vtotal - mode->vsync_start;
> -	} else {
> -		/* and this is what they are for other connectors */
> -		mode_hsync_offset = mode->hsync_start - mode->hdisplay;
> -		mode_vsync_offset = mode->vsync_start - mode->vdisplay;
> -	}
> -
> -	mode_hsync_width = mode->hsync_end - mode->hsync_start;
> -	mode_vsync_width = mode->vsync_end - mode->vsync_start;
> -
> -	mode_hsync_polarity = !!(mode->flags & DRM_MODE_FLAG_PHSYNC);
> -	mode_vsync_polarity = !!(mode->flags & DRM_MODE_FLAG_PVSYNC);
> -
> -	igt_debug("Checking video mode:\n");
> -	igt_debug("clock: got %f, expected %f ± %f%%\n",
> -		  video_params.clock, mode_clock, MODE_CLOCK_ACCURACY * 100);
> -	igt_debug("hactive: got %d, expected %d\n",
> -		  video_params.hactive, mode->hdisplay);
> -	igt_debug("vactive: got %d, expected %d\n",
> -		  video_params.vactive, mode->vdisplay);
> -	igt_debug("hsync_offset: got %d, expected %d\n",
> -		  video_params.hsync_offset, mode_hsync_offset);
> -	igt_debug("vsync_offset: got %d, expected %d\n",
> -		  video_params.vsync_offset, mode_vsync_offset);
> -	igt_debug("htotal: got %d, expected %d\n",
> -		  video_params.htotal, mode->htotal);
> -	igt_debug("vtotal: got %d, expected %d\n",
> -		  video_params.vtotal, mode->vtotal);
> -	igt_debug("hsync_width: got %d, expected %d\n",
> -		  video_params.hsync_width, mode_hsync_width);
> -	igt_debug("vsync_width: got %d, expected %d\n",
> -		  video_params.vsync_width, mode_vsync_width);
> -	igt_debug("hsync_polarity: got %d, expected %d\n",
> -		  video_params.hsync_polarity, mode_hsync_polarity);
> -	igt_debug("vsync_polarity: got %d, expected %d\n",
> -		  video_params.vsync_polarity, mode_vsync_polarity);
> -
> -	if (!isnan(video_params.clock)) {
> -		igt_assert(video_params.clock >
> -			   mode_clock * (1 - MODE_CLOCK_ACCURACY));
> -		igt_assert(video_params.clock <
> -			   mode_clock * (1 + MODE_CLOCK_ACCURACY));
> -	}
> -	igt_assert(video_params.hactive == mode->hdisplay);
> -	igt_assert(video_params.vactive == mode->vdisplay);
> -	igt_assert(video_params.hsync_offset == mode_hsync_offset);
> -	igt_assert(video_params.vsync_offset == mode_vsync_offset);
> -	igt_assert(video_params.htotal == mode->htotal);
> -	igt_assert(video_params.vtotal == mode->vtotal);
> -	igt_assert(video_params.hsync_width == mode_hsync_width);
> -	igt_assert(video_params.vsync_width == mode_vsync_width);
> -	igt_assert(video_params.hsync_polarity == mode_hsync_polarity);
> -	igt_assert(video_params.vsync_polarity == mode_vsync_polarity);
> -}
> -
> -static const char test_mode_timings_desc[] =
> -	"For each mode of the IGT base EDID, perform a modeset and check the "
> -	"mode detected by the Chamelium receiver matches the mode we set";
> -static void test_mode_timings(data_t *data, struct chamelium_port *port)
> -{
> -	int i, count_modes;
> -
> -	i = 0;
> -	igt_require(chamelium_supports_get_video_params(data->chamelium));
> -	do {
> -		igt_output_t *output;
> -		igt_plane_t *primary;
> -		drmModeConnector *connector;
> -		drmModeModeInfo *mode;
> -		int fb_id;
> -		struct igt_fb fb;
> -
> -		/*
> -		 * let's reset state each mode so we will get the
> -		 * HPD pulses realibably
> -		 */
> -		igt_modeset_disable_all_outputs(&data->display);
> -		chamelium_reset_state(&data->display, data->chamelium,
> -				      port, data->ports, data->port_count);
> -
> -		/*
> -		 * modes may change due to mode pruining and link issues, so we
> -		 * need to refresh the connector
> -		 */
> -		output = prepare_output(data, port, IGT_CUSTOM_EDID_BASE);
> -		connector = chamelium_port_get_connector(data->chamelium, port, false);
> -		primary = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY);
> -		igt_assert(primary);
> -
> -		/* we may skip some modes due to above but that's ok */
> -		count_modes = connector->count_modes;
> -		if (i >= count_modes)
> -			break;
> -
> -		mode = &connector->modes[i];
> -
> -		fb_id = igt_create_color_pattern_fb(data->drm_fd,
> -						    mode->hdisplay, mode->vdisplay,
> -						    DRM_FORMAT_XRGB8888,
> -						    DRM_FORMAT_MOD_LINEAR,
> -						    0, 0, 0, &fb);
> -		igt_assert(fb_id > 0);
> -
> -		enable_output(data, port, output, mode, &fb);
> -
> -		/* Trigger the FSM */
> -		chamelium_capture(data->chamelium, port, 0, 0, 0, 0, 0);
> -
> -		check_mode(data->chamelium, port, mode);
> -
> -		igt_remove_fb(data->drm_fd, &fb);
> -		drmModeFreeConnector(connector);
> -	} while (++i < count_modes);
> -}
> -
> -struct vic_mode {
> -	int hactive, vactive;
> -	int vrefresh; /* Hz */
> -	uint32_t picture_ar;
> -};
> -
> -/* Maps Video Identification Codes to a mode */
> -static const struct vic_mode vic_modes[] = {
> -	[16] = {
> -		.hactive = 1920,
> -		.vactive = 1080,
> -		.vrefresh = 60,
> -		.picture_ar = DRM_MODE_PICTURE_ASPECT_16_9,
> -	},
> -};
> -
> -/* Maps aspect ratios to their mode flag */
> -static const uint32_t mode_ar_flags[] = {
> -	[DRM_MODE_PICTURE_ASPECT_16_9] = DRM_MODE_FLAG_PIC_AR_16_9,
> -};
> -
> -static enum infoframe_avi_picture_aspect_ratio
> -get_infoframe_avi_picture_ar(uint32_t aspect_ratio)
> -{
> -	/* The AVI picture aspect ratio field only supports 4:3 and 16:9 */
> -	switch (aspect_ratio) {
> -	case DRM_MODE_PICTURE_ASPECT_4_3:
> -		return INFOFRAME_AVI_PIC_AR_4_3;
> -	case DRM_MODE_PICTURE_ASPECT_16_9:
> -		return INFOFRAME_AVI_PIC_AR_16_9;
> -	default:
> -		return INFOFRAME_AVI_PIC_AR_UNSPECIFIED;
> -	}
> -}
> -
> -static bool vic_mode_matches_drm(const struct vic_mode *vic_mode,
> -				 drmModeModeInfo *drm_mode)
> -{
> -	uint32_t ar_flag = mode_ar_flags[vic_mode->picture_ar];
> -
> -	return vic_mode->hactive == drm_mode->hdisplay &&
> -	       vic_mode->vactive == drm_mode->vdisplay &&
> -	       vic_mode->vrefresh == drm_mode->vrefresh &&
> -	       ar_flag == (drm_mode->flags & DRM_MODE_FLAG_PIC_AR_MASK);
> -}
> -
> -static const char test_display_aspect_ratio_desc[] =
> -	"Pick a mode with a picture aspect-ratio, capture AVI InfoFrames and "
> -	"check they include the relevant fields";
> -static void test_display_aspect_ratio(data_t *data, struct chamelium_port *port)
> -{
> -	igt_output_t *output;
> -	igt_plane_t *primary;
> -	drmModeConnector *connector;
> -	drmModeModeInfo *mode;
> -	int fb_id, i;
> -	struct igt_fb fb;
> -	bool found, ok;
> -	struct chamelium_infoframe *infoframe;
> -	struct infoframe_avi infoframe_avi;
> -	uint8_t vic = 16; /* TODO: test more VICs */
> -	const struct vic_mode *vic_mode;
> -	uint32_t aspect_ratio;
> -	enum infoframe_avi_picture_aspect_ratio frame_ar;
> -
> -	igt_require(chamelium_supports_get_last_infoframe(data->chamelium));
> -
> -	igt_modeset_disable_all_outputs(&data->display);
> -	chamelium_reset_state(&data->display, data->chamelium,
> -			      port, data->ports, data->port_count);
> -
> -	output = prepare_output(data, port, IGT_CUSTOM_EDID_ASPECT_RATIO);
> -	connector = chamelium_port_get_connector(data->chamelium, port, false);
> -	primary = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY);
> -	igt_assert(primary);
> -
> -	vic_mode = &vic_modes[vic];
> -	aspect_ratio = vic_mode->picture_ar;
> -
> -	found = false;
> -	igt_assert(connector->count_modes > 0);
> -	for (i = 0; i < connector->count_modes; i++) {
> -		mode = &connector->modes[i];
> -
> -		if (vic_mode_matches_drm(vic_mode, mode)) {
> -			found = true;
> -			break;
> -		}
> -	}
> -	igt_assert_f(found,
> -		     "Failed to find mode with the correct aspect ratio\n");
> -
> -	fb_id = igt_create_color_pattern_fb(data->drm_fd,
> -					    mode->hdisplay, mode->vdisplay,
> -					    DRM_FORMAT_XRGB8888,
> -					    DRM_FORMAT_MOD_LINEAR,
> -					    0, 0, 0, &fb);
> -	igt_assert(fb_id > 0);
> -
> -	enable_output(data, port, output, mode, &fb);
> -
> -	infoframe = chamelium_get_last_infoframe(data->chamelium, port,
> -						 CHAMELIUM_INFOFRAME_AVI);
> -	igt_assert_f(infoframe, "AVI InfoFrame not received\n");
> -
> -	ok = infoframe_avi_parse(&infoframe_avi, infoframe->version,
> -				 infoframe->payload, infoframe->payload_size);
> -	igt_assert_f(ok, "Failed to parse AVI InfoFrame\n");
> -
> -	frame_ar = get_infoframe_avi_picture_ar(aspect_ratio);
> -
> -	igt_debug("Checking AVI InfoFrame\n");
> -	igt_debug("Picture aspect ratio: got %d, expected %d\n",
> -		  infoframe_avi.picture_aspect_ratio, frame_ar);
> -	igt_debug("Video Identification Code (VIC): got %d, expected %d\n",
> -		  infoframe_avi.vic, vic);
> -
> -	igt_assert(infoframe_avi.picture_aspect_ratio == frame_ar);
> -	igt_assert(infoframe_avi.vic == vic);
> -
> -	chamelium_infoframe_destroy(infoframe);
> -	igt_remove_fb(data->drm_fd, &fb);
> -	drmModeFreeConnector(connector);
> -}
> -
> -
> -/* Playback parameters control the audio signal we synthesize and send */
> -#define PLAYBACK_CHANNELS 2
> -#define PLAYBACK_SAMPLES 1024
> -
> -/* Capture paremeters control the audio signal we receive */
> -#define CAPTURE_SAMPLES 2048
> -
> -#define AUDIO_TIMEOUT 2000 /* ms */
> -/* A streak of 3 gives confidence that the signal is good. */
> -#define MIN_STREAK 3
> -
> -#define FLATLINE_AMPLITUDE 0.1 /* normalized, ie. in [0, 1] */
> -#define FLATLINE_AMPLITUDE_ACCURACY 0.001 /* ± 0.1 % of the full amplitude */
> -#define FLATLINE_ALIGN_ACCURACY 0 /* number of samples */
> -
> -/* TODO: enable >48KHz rates, these are not reliable */
> -static int test_sampling_rates[] = {
> -	32000,
> -	44100,
> -	48000,
> -	/* 88200, */
> -	/* 96000, */
> -	/* 176400, */
> -	/* 192000, */
> -};
> -
> -static int test_sampling_rates_count = sizeof(test_sampling_rates) / sizeof(int);
> -
> -/* Test frequencies (Hz): a sine signal will be generated for each.
> - *
> - * Depending on the sampling rate chosen, it might not be possible to properly
> - * detect the generated sine (see Nyquist–Shannon sampling theorem).
> - * Frequencies that can't be reliably detected will be automatically pruned in
> - * #audio_signal_add_frequency. For instance, the 80KHz frequency can only be
> - * tested with a 192KHz sampling rate.
> - */
> -static int test_frequencies[] = {
> -	300,
> -	600,
> -	1200,
> -	10000,
> -	80000,
> -};
> -
> -static int test_frequencies_count = sizeof(test_frequencies) / sizeof(int);
> -
> -static const snd_pcm_format_t test_formats[] = {
> -	SND_PCM_FORMAT_S16_LE,
> -	SND_PCM_FORMAT_S24_LE,
> -	SND_PCM_FORMAT_S32_LE,
> -};
> -
> -static const size_t test_formats_count = sizeof(test_formats) / sizeof(test_formats[0]);
> -
> -struct audio_state {
> -	struct alsa *alsa;
> -	struct chamelium *chamelium;
> -	struct chamelium_port *port;
> -	struct chamelium_stream *stream;
> -
> -	/* The capture format is only available after capture has started. */
> -	struct {
> -		snd_pcm_format_t format;
> -		int channels;
> -		int rate;
> -	} playback, capture;
> -
> -	char *name;
> -	struct audio_signal *signal; /* for frequencies test only */
> -	int channel_mapping[CHAMELIUM_MAX_AUDIO_CHANNELS];
> -
> -	size_t recv_pages;
> -	int msec;
> -
> -	int dump_fd;
> -	char *dump_path;
> -
> -	pthread_t thread;
> -	atomic_bool run;
> -	atomic_bool positive; /* for pulse test only */
> -};
> -
> -static void audio_state_init(struct audio_state *state, data_t *data,
> -			     struct alsa *alsa, struct chamelium_port *port,
> -			     snd_pcm_format_t format, int channels, int rate)
> -{
> -	memset(state, 0, sizeof(*state));
> -	state->dump_fd = -1;
> -
> -	state->alsa = alsa;
> -	state->chamelium = data->chamelium;
> -	state->port = port;
> -
> -	state->playback.format = format;
> -	state->playback.channels = channels;
> -	state->playback.rate = rate;
> -
> -	alsa_configure_output(alsa, format, channels, rate);
> -
> -	state->stream = chamelium_stream_init();
> -	igt_assert_f(state->stream,
> -		     "Failed to initialize Chamelium stream client\n");
> -}
> -
> -static void audio_state_fini(struct audio_state *state)
> -{
> -	chamelium_stream_deinit(state->stream);
> -	free(state->name);
> -}
> -
> -static void *run_audio_thread(void *data)
> -{
> -	struct alsa *alsa = data;
> -
> -	alsa_run(alsa, -1);
> -	return NULL;
> -}
> -
> -static void audio_state_start(struct audio_state *state, const char *name)
> -{
> -	int ret;
> -	bool ok;
> -	size_t i, j;
> -	enum chamelium_stream_realtime_mode stream_mode;
> -	char dump_suffix[64];
> -
> -	free(state->name);
> -	state->name = strdup(name);
> -	state->recv_pages = 0;
> -	state->msec = 0;
> -
> -	igt_debug("Starting %s test with playback format %s, "
> -		  "sampling rate %d Hz and %d channels\n",
> -		  name, snd_pcm_format_name(state->playback.format),
> -		  state->playback.rate, state->playback.channels);
> -
> -	chamelium_start_capturing_audio(state->chamelium, state->port, false);
> -
> -	stream_mode = CHAMELIUM_STREAM_REALTIME_STOP_WHEN_OVERFLOW;
> -	ok = chamelium_stream_dump_realtime_audio(state->stream, stream_mode);
> -	igt_assert_f(ok, "Failed to start streaming audio capture\n");
> -
> -	/* Start playing audio */
> -	state->run = true;
> -	ret = pthread_create(&state->thread, NULL,
> -			     run_audio_thread, state->alsa);
> -	igt_assert_f(ret == 0, "Failed to start audio playback thread\n");
> -
> -	/* The Chamelium device only supports this PCM format. */
> -	state->capture.format = SND_PCM_FORMAT_S32_LE;
> -
> -	/* Only after we've started playing audio, we can retrieve the capture
> -	 * format used by the Chamelium device. */
> -	chamelium_get_audio_format(state->chamelium, state->port,
> -				   &state->capture.rate,
> -				   &state->capture.channels);
> -	if (state->capture.rate == 0) {
> -		igt_debug("Audio receiver doesn't indicate the capture "
> -			 "sampling rate, assuming it's %d Hz\n",
> -			 state->playback.rate);
> -		state->capture.rate = state->playback.rate;
> -	}
> -
> -	chamelium_get_audio_channel_mapping(state->chamelium, state->port,
> -					    state->channel_mapping);
> -	/* Make sure we can capture all channels we send. */
> -	for (i = 0; i < state->playback.channels; i++) {
> -		ok = false;
> -		for (j = 0; j < state->capture.channels; j++) {
> -			if (state->channel_mapping[j] == i) {
> -				ok = true;
> -				break;
> -			}
> -		}
> -		igt_assert_f(ok, "Cannot capture all channels\n");
> -	}
> -
> -	if (igt_frame_dump_is_enabled()) {
> -		snprintf(dump_suffix, sizeof(dump_suffix),
> -			 "capture-%s-%s-%dch-%dHz",
> -			 name, snd_pcm_format_name(state->playback.format),
> -			 state->playback.channels, state->playback.rate);
> -
> -		state->dump_fd = audio_create_wav_file_s32_le(dump_suffix,
> -							      state->capture.rate,
> -							      state->capture.channels,
> -							      &state->dump_path);
> -		igt_assert_f(state->dump_fd >= 0,
> -			     "Failed to create audio dump file\n");
> -	}
> -}
> -
> -static void audio_state_receive(struct audio_state *state,
> -				int32_t **recv, size_t *recv_len)
> -{
> -	bool ok;
> -	size_t page_count;
> -	size_t recv_size;
> -
> -	ok = chamelium_stream_receive_realtime_audio(state->stream,
> -						     &page_count,
> -						     recv, recv_len);
> -	igt_assert_f(ok, "Failed to receive audio from stream server\n");
> -
> -	state->msec = state->recv_pages * *recv_len
> -		      / (double) state->capture.channels
> -		      / (double) state->capture.rate * 1000;
> -	state->recv_pages++;
> -
> -	if (state->dump_fd >= 0) {
> -		recv_size = *recv_len * sizeof(int32_t);
> -		igt_assert_f(write(state->dump_fd, *recv, recv_size) == recv_size,
> -			     "Failed to write to audio dump file\n");
> -	}
> -}
> -
> -static void audio_state_stop(struct audio_state *state, bool success)
> -{
> -	bool ok;
> -	int ret;
> -	struct chamelium_audio_file *audio_file;
> -	enum igt_log_level log_level;
> -
> -	igt_debug("Stopping audio playback\n");
> -	state->run = false;
> -	ret = pthread_join(state->thread, NULL);
> -	igt_assert_f(ret == 0, "Failed to join audio playback thread\n");
> -
> -	ok = chamelium_stream_stop_realtime_audio(state->stream);
> -	igt_assert_f(ok, "Failed to stop streaming audio capture\n");
> -
> -	audio_file = chamelium_stop_capturing_audio(state->chamelium,
> -						    state->port);
> -	if (audio_file) {
> -		igt_debug("Audio file saved on the Chamelium in %s\n",
> -			  audio_file->path);
> -		chamelium_destroy_audio_file(audio_file);
> -	}
> -
> -	if (state->dump_fd >= 0) {
> -		close(state->dump_fd);
> -		state->dump_fd = -1;
> -
> -		if (success) {
> -			/* Test succeeded, no need to keep the captured data */
> -			unlink(state->dump_path);
> -		} else
> -			igt_debug("Saved captured audio data to %s\n",
> -				  state->dump_path);
> -		free(state->dump_path);
> -		state->dump_path = NULL;
> -	}
> -
> -	if (success)
> -		log_level = IGT_LOG_DEBUG;
> -	else
> -		log_level = IGT_LOG_CRITICAL;
> -
> -	igt_log(IGT_LOG_DOMAIN, log_level, "Audio %s test result for format %s, "
> -		"sampling rate %d Hz and %d channels: %s\n",
> -		state->name, snd_pcm_format_name(state->playback.format),
> -		state->playback.rate, state->playback.channels,
> -		success ? "ALL GREEN" : "FAILED");
> -
> -}
> -
> -static void check_audio_infoframe(struct audio_state *state)
> -{
> -	struct chamelium_infoframe *infoframe;
> -	struct infoframe_audio infoframe_audio;
> -	struct infoframe_audio expected = {0};
> -	bool ok;
> -
> -	if (!chamelium_supports_get_last_infoframe(state->chamelium)) {
> -		igt_debug("Skipping audio InfoFrame check: "
> -			  "Chamelium board doesn't support GetLastInfoFrame\n");
> -		return;
> -	}
> -
> -	expected.coding_type = INFOFRAME_AUDIO_CT_PCM;
> -	expected.channel_count = state->playback.channels;
> -	expected.sampling_freq = state->playback.rate;
> -	expected.sample_size = snd_pcm_format_width(state->playback.format);
> -
> -	infoframe = chamelium_get_last_infoframe(state->chamelium, state->port,
> -						 CHAMELIUM_INFOFRAME_AUDIO);
> -	if (infoframe == NULL && state->playback.channels <= 2) {
> -		/* Audio InfoFrames are optional for mono and stereo audio */
> -		igt_debug("Skipping audio InfoFrame check: "
> -			  "no InfoFrame received\n");
> -		return;
> -	}
> -	igt_assert_f(infoframe != NULL, "no audio InfoFrame received\n");
> -
> -	ok = infoframe_audio_parse(&infoframe_audio, infoframe->version,
> -				   infoframe->payload, infoframe->payload_size);
> -	chamelium_infoframe_destroy(infoframe);
> -	igt_assert_f(ok, "failed to parse audio InfoFrame\n");
> -
> -	igt_debug("Checking audio InfoFrame:\n");
> -	igt_debug("coding_type: got %d, expected %d\n",
> -		  infoframe_audio.coding_type, expected.coding_type);
> -	igt_debug("channel_count: got %d, expected %d\n",
> -		  infoframe_audio.channel_count, expected.channel_count);
> -	igt_debug("sampling_freq: got %d, expected %d\n",
> -		  infoframe_audio.sampling_freq, expected.sampling_freq);
> -	igt_debug("sample_size: got %d, expected %d\n",
> -		  infoframe_audio.sample_size, expected.sample_size);
> -
> -	if (infoframe_audio.coding_type != INFOFRAME_AUDIO_CT_UNSPECIFIED)
> -		igt_assert(infoframe_audio.coding_type == expected.coding_type);
> -	if (infoframe_audio.channel_count >= 0)
> -		igt_assert(infoframe_audio.channel_count == expected.channel_count);
> -	if (infoframe_audio.sampling_freq >= 0)
> -		igt_assert(infoframe_audio.sampling_freq == expected.sampling_freq);
> -	if (infoframe_audio.sample_size >= 0)
> -		igt_assert(infoframe_audio.sample_size == expected.sample_size);
> -}
> -
> -static int
> -audio_output_frequencies_callback(void *data, void *buffer, int samples)
> -{
> -	struct audio_state *state = data;
> -	double *tmp;
> -	size_t len;
> -
> -	len = samples * state->playback.channels;
> -	tmp = malloc(len * sizeof(double));
> -	audio_signal_fill(state->signal, tmp, samples);
> -	audio_convert_to(buffer, tmp, len, state->playback.format);
> -	free(tmp);
> -
> -	return state->run ? 0 : -1;
> -}
> -
> -static bool test_audio_frequencies(struct audio_state *state)
> -{
> -	int freq, step;
> -	int32_t *recv, *buf;
> -	double *channel;
> -	size_t i, j, streak;
> -	size_t recv_len, buf_len, buf_cap, channel_len;
> -	bool success;
> -	int capture_chan;
> -
> -	state->signal = audio_signal_init(state->playback.channels,
> -					  state->playback.rate);
> -	igt_assert_f(state->signal, "Failed to initialize audio signal\n");
> -
> -	/* We'll choose different frequencies per channel to make sure they are
> -	 * independent from each other. To do so, we'll add a different offset
> -	 * to the base frequencies for each channel. We need to choose a big
> -	 * enough offset so that we're sure to detect mixed up channels. We
> -	 * choose an offset of two 2 bins in the final FFT to enforce a clear
> -	 * difference.
> -	 *
> -	 * Note that we assume capture_rate == playback_rate. We'll assert this
> -	 * later on. We cannot retrieve the capture rate before starting
> -	 * playing audio, so we don't really have the choice.
> -	 */
> -	step = 2 * state->playback.rate / CAPTURE_SAMPLES;
> -	for (i = 0; i < test_frequencies_count; i++) {
> -		for (j = 0; j < state->playback.channels; j++) {
> -			freq = test_frequencies[i] + j * step;
> -			audio_signal_add_frequency(state->signal, freq, j);
> -		}
> -	}
> -	audio_signal_synthesize(state->signal);
> -
> -	alsa_register_output_callback(state->alsa,
> -				      audio_output_frequencies_callback, state,
> -				      PLAYBACK_SAMPLES);
> -
> -	audio_state_start(state, "frequencies");
> -
> -	igt_assert_f(state->capture.rate == state->playback.rate,
> -		     "Capture rate (%dHz) doesn't match playback rate (%dHz)\n",
> -		     state->capture.rate, state->playback.rate);
> -
> -	/* Needs to be a multiple of 128, because that's the number of samples
> -	 * we get per channel each time we receive an audio page from the
> -	 * Chamelium device.
> -	 *
> -	 * Additionally, this value needs to be high enough to guarantee we
> -	 * capture a full period of each sine we generate. If we capture 2048
> -	 * samples at a 192KHz sampling rate, we get a full period for a >94Hz
> -	 * sines. For lower sampling rates, the capture duration will be
> -	 * longer.
> -	 */
> -	channel_len = CAPTURE_SAMPLES;
> -	channel = malloc(sizeof(double) * channel_len);
> -
> -	buf_cap = state->capture.channels * channel_len;
> -	buf = malloc(sizeof(int32_t) * buf_cap);
> -	buf_len = 0;
> -
> -	recv = NULL;
> -	recv_len = 0;
> -
> -	success = false;
> -	streak = 0;
> -	while (!success && state->msec < AUDIO_TIMEOUT) {
> -		audio_state_receive(state, &recv, &recv_len);
> -
> -		memcpy(&buf[buf_len], recv, recv_len * sizeof(int32_t));
> -		buf_len += recv_len;
> -
> -		if (buf_len < buf_cap)
> -			continue;
> -		igt_assert(buf_len == buf_cap);
> -
> -		igt_debug("Detecting audio signal, t=%d msec\n", state->msec);
> -
> -		for (j = 0; j < state->playback.channels; j++) {
> -			capture_chan = state->channel_mapping[j];
> -			igt_assert(capture_chan >= 0);
> -			igt_debug("Processing channel %zu (captured as "
> -				  "channel %d)\n", j, capture_chan);
> -
> -			audio_extract_channel_s32_le(channel, channel_len,
> -						     buf, buf_len,
> -						     state->capture.channels,
> -						     capture_chan);
> -
> -			if (audio_signal_detect(state->signal,
> -						state->capture.rate, j,
> -						channel, channel_len))
> -				streak++;
> -			else
> -				streak = 0;
> -		}
> -
> -		buf_len = 0;
> -
> -		success = streak == MIN_STREAK * state->playback.channels;
> -	}
> -
> -	audio_state_stop(state, success);
> -
> -	free(recv);
> -	free(buf);
> -	free(channel);
> -	audio_signal_fini(state->signal);
> -
> -	check_audio_infoframe(state);
> -
> -	return success;
> -}
> -
> -static int audio_output_flatline_callback(void *data, void *buffer,
> -					     int samples)
> -{
> -	struct audio_state *state = data;
> -	double *tmp;
> -	size_t len, i;
> -
> -	len = samples * state->playback.channels;
> -	tmp = malloc(len * sizeof(double));
> -	for (i = 0; i < len; i++)
> -		tmp[i] = (state->positive ? 1 : -1) * FLATLINE_AMPLITUDE;
> -	audio_convert_to(buffer, tmp, len, state->playback.format);
> -	free(tmp);
> -
> -	return state->run ? 0 : -1;
> -}
> -
> -static bool detect_flatline_amplitude(double *buf, size_t buf_len, bool pos)
> -{
> -	double expected, min, max;
> -	size_t i;
> -	bool ok;
> -
> -	min = max = NAN;
> -	for (i = 0; i < buf_len; i++) {
> -		if (isnan(min) || buf[i] < min)
> -			min = buf[i];
> -		if (isnan(max) || buf[i] > max)
> -			max = buf[i];
> -	}
> -
> -	expected = (pos ? 1 : -1) * FLATLINE_AMPLITUDE;
> -	ok = (min >= expected - FLATLINE_AMPLITUDE_ACCURACY &&
> -	      max <= expected + FLATLINE_AMPLITUDE_ACCURACY);
> -	if (ok)
> -		igt_debug("Flatline wave amplitude detected\n");
> -	else
> -		igt_debug("Flatline amplitude not detected (min=%f, max=%f)\n",
> -			  min, max);
> -	return ok;
> -}
> -
> -static ssize_t detect_falling_edge(double *buf, size_t buf_len)
> -{
> -	size_t i;
> -
> -	for (i = 0; i < buf_len; i++) {
> -		if (buf[i] < 0)
> -			return i;
> -	}
> -
> -	return -1;
> -}
> -
> -/** test_audio_flatline:
> - *
> - * Send a constant value (one positive, then a negative one) and check that:
> - *
> - * - The amplitude of the flatline is correct
> - * - All channels switch from a positive signal to a negative one at the same
> - *   time (ie. all channels are aligned)
> - */
> -static bool test_audio_flatline(struct audio_state *state)
> -{
> -	bool success, amp_success, align_success;
> -	int32_t *recv;
> -	size_t recv_len, i, channel_len;
> -	ssize_t j;
> -	int streak, capture_chan;
> -	double *channel;
> -	int falling_edges[CHAMELIUM_MAX_AUDIO_CHANNELS];
> -
> -	alsa_register_output_callback(state->alsa,
> -				      audio_output_flatline_callback, state,
> -				      PLAYBACK_SAMPLES);
> -
> -	/* Start by sending a positive signal */
> -	state->positive = true;
> -
> -	audio_state_start(state, "flatline");
> -
> -	for (i = 0; i < state->playback.channels; i++)
> -		falling_edges[i] = -1;
> -
> -	recv = NULL;
> -	recv_len = 0;
> -	amp_success = false;
> -	streak = 0;
> -	while (!amp_success && state->msec < AUDIO_TIMEOUT) {
> -		audio_state_receive(state, &recv, &recv_len);
> -
> -		igt_debug("Detecting audio signal, t=%d msec\n", state->msec);
> -
> -		for (i = 0; i < state->playback.channels; i++) {
> -			capture_chan = state->channel_mapping[i];
> -			igt_assert(capture_chan >= 0);
> -			igt_debug("Processing channel %zu (captured as "
> -				  "channel %d)\n", i, capture_chan);
> -
> -			channel_len = audio_extract_channel_s32_le(NULL, 0,
> -								   recv, recv_len,
> -								   state->capture.channels,
> -								   capture_chan);
> -			channel = malloc(channel_len * sizeof(double));
> -			audio_extract_channel_s32_le(channel, channel_len,
> -						     recv, recv_len,
> -						     state->capture.channels,
> -						     capture_chan);
> -
> -			/* Check whether the amplitude is fine */
> -			if (detect_flatline_amplitude(channel, channel_len,
> -						      state->positive))
> -				streak++;
> -			else
> -				streak = 0;
> -
> -			/* If we're now sending a negative signal, detect the
> -			 * falling edge */
> -			j = detect_falling_edge(channel, channel_len);
> -			if (!state->positive && j >= 0) {
> -				falling_edges[i] = recv_len * state->recv_pages
> -						   + j;
> -			}
> -
> -			free(channel);
> -		}
> -
> -		amp_success = streak == MIN_STREAK * state->playback.channels;
> -
> -		if (amp_success && state->positive) {
> -			/* Switch to a negative signal after we've detected the
> -			 * positive one. */
> -			state->positive = false;
> -			amp_success = false;
> -			streak = 0;
> -			igt_debug("Switching to negative square wave\n");
> -		}
> -	}
> -
> -	/* Check alignment between all channels by comparing the index of the
> -	 * falling edge. */
> -	align_success = true;
> -	for (i = 0; i < state->playback.channels; i++) {
> -		if (falling_edges[i] < 0) {
> -			igt_critical("Falling edge not detected for channel %zu\n",
> -				     i);
> -			align_success = false;
> -			continue;
> -		}
> -
> -		if (abs(falling_edges[0] - falling_edges[i]) >
> -		    FLATLINE_ALIGN_ACCURACY) {
> -			igt_critical("Channel alignment mismatch: "
> -				     "channel 0 has a falling edge at index %d "
> -				     "while channel %zu has index %d\n",
> -				     falling_edges[0], i, falling_edges[i]);
> -			align_success = false;
> -		}
> -	}
> -
> -	success = amp_success && align_success;
> -	audio_state_stop(state, success);
> -
> -	free(recv);
> -
> -	return success;
> -}
> -
> -static bool check_audio_configuration(struct alsa *alsa, snd_pcm_format_t format,
> -				      int channels, int sampling_rate)
> -{
> -	if (!alsa_test_output_configuration(alsa, format, channels,
> -					    sampling_rate)) {
> -		igt_debug("Skipping test with format %s, sampling rate %d Hz "
> -			  "and %d channels because at least one of the "
> -			  "selected output devices doesn't support this "
> -			  "configuration\n",
> -			  snd_pcm_format_name(format),
> -			  sampling_rate, channels);
> -		return false;
> -	}
> -	/* TODO: the Chamelium device sends a malformed signal for some audio
> -	 * configurations. See crbug.com/950917 */
> -	if ((format != SND_PCM_FORMAT_S16_LE && sampling_rate >= 44100) ||
> -			channels > 2) {
> -		igt_debug("Skipping test with format %s, sampling rate %d Hz "
> -			  "and %d channels because the Chamelium device "
> -			  "doesn't support this configuration\n",
> -			  snd_pcm_format_name(format),
> -			  sampling_rate, channels);
> -		return false;
> -	}
> -	return true;
> -}
> -
> -static const char test_display_audio_desc[] =
> -	"Playback various audio signals with various audio formats/rates, "
> -	"capture them and check they are correct";
> -static void
> -test_display_audio(data_t *data, struct chamelium_port *port,
> -		   const char *audio_device, enum igt_custom_edid_type edid)
> -{
> -	bool run, success;
> -	struct alsa *alsa;
> -	int ret;
> -	igt_output_t *output;
> -	igt_plane_t *primary;
> -	struct igt_fb fb;
> -	drmModeModeInfo *mode;
> -	drmModeConnector *connector;
> -	int fb_id, i, j;
> -	int channels, sampling_rate;
> -	snd_pcm_format_t format;
> -	struct audio_state state;
> -
> -	igt_require(alsa_has_exclusive_access());
> -
> -	/* Old Chamelium devices need an update for DisplayPort audio and
> -	 * chamelium_get_audio_format support. */
> -	igt_require(chamelium_has_audio_support(data->chamelium, port));
> -
> -	alsa = alsa_init();
> -	igt_assert(alsa);
> -
> -	igt_modeset_disable_all_outputs(&data->display);
> -	chamelium_reset_state(&data->display, data->chamelium,
> -			      port, data->ports, data->port_count);
> -
> -	output = prepare_output(data, port, edid);
> -	connector = chamelium_port_get_connector(data->chamelium, port, false);
> -	primary = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY);
> -	igt_assert(primary);
> -
> -	/* Enable the output because the receiver won't try to receive audio if
> -	 * it doesn't receive video. */
> -	igt_assert(connector->count_modes > 0);
> -	mode = &connector->modes[0];
> -
> -	fb_id = igt_create_color_pattern_fb(data->drm_fd,
> -					    mode->hdisplay, mode->vdisplay,
> -					    DRM_FORMAT_XRGB8888,
> -					    DRM_FORMAT_MOD_LINEAR,
> -					    0, 0, 0, &fb);
> -	igt_assert(fb_id > 0);
> -
> -	enable_output(data, port, output, mode, &fb);
> -
> -	run = false;
> -	success = true;
> -	for (i = 0; i < test_sampling_rates_count; i++) {
> -		for (j = 0; j < test_formats_count; j++) {
> -			ret = alsa_open_output(alsa, audio_device);
> -			igt_assert_f(ret >= 0, "Failed to open ALSA output\n");
> -
> -			/* TODO: playback on all 8 available channels (this
> -			 * isn't supported by Chamelium devices yet, see
> -			 * https://crbug.com/950917) */
> -			format = test_formats[j];
> -			channels = PLAYBACK_CHANNELS;
> -			sampling_rate = test_sampling_rates[i];
> -
> -			if (!check_audio_configuration(alsa, format, channels,
> -						       sampling_rate))
> -				continue;
> -
> -			run = true;
> -
> -			audio_state_init(&state, data, alsa, port,
> -					 format, channels, sampling_rate);
> -			success &= test_audio_frequencies(&state);
> -			success &= test_audio_flatline(&state);
> -			audio_state_fini(&state);
> -
> -			alsa_close_output(alsa);
> -		}
> -	}
> -
> -	/* Make sure we tested at least one frequency and format. */
> -	igt_assert(run);
> -	/* Make sure all runs were successful. */
> -	igt_assert(success);
> -
> -	igt_remove_fb(data->drm_fd, &fb);
> -
> -	drmModeFreeConnector(connector);
> -
> -	free(alsa);
> -}
> -
> -static const char test_display_audio_edid_desc[] =
> -	"Plug a connector with an EDID suitable for audio, check ALSA's "
> -	"EDID-Like Data reports the correct audio parameters";
> -static void
> -test_display_audio_edid(data_t *data, struct chamelium_port *port,
> -			enum igt_custom_edid_type edid)
> -{
> -	igt_output_t *output;
> -	igt_plane_t *primary;
> -	struct igt_fb fb;
> -	drmModeModeInfo *mode;
> -	drmModeConnector *connector;
> -	int fb_id;
> -	struct eld_entry eld;
> -	struct eld_sad *sad;
> -
> -	igt_require(eld_is_supported());
> -
> -	igt_modeset_disable_all_outputs(&data->display);
> -	chamelium_reset_state(&data->display, data->chamelium,
> -			      port, data->ports, data->port_count);
> -
> -	output = prepare_output(data, port, edid);
> -	connector = chamelium_port_get_connector(data->chamelium, port, false);
> -	primary = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY);
> -	igt_assert(primary);
> -
> -	/* Enable the output because audio cannot be played on inactive
> -	 * connectors. */
> -	igt_assert(connector->count_modes > 0);
> -	mode = &connector->modes[0];
> -
> -	fb_id = igt_create_color_pattern_fb(data->drm_fd,
> -					    mode->hdisplay, mode->vdisplay,
> -					    DRM_FORMAT_XRGB8888,
> -					    DRM_FORMAT_MOD_LINEAR,
> -					    0, 0, 0, &fb);
> -	igt_assert(fb_id > 0);
> -
> -	enable_output(data, port, output, mode, &fb);
> -
> -	igt_assert(eld_get_igt(&eld));
> -	igt_assert(eld.sads_len == 1);
> -
> -	sad = &eld.sads[0];
> -	igt_assert(sad->coding_type == CEA_SAD_FORMAT_PCM);
> -	igt_assert(sad->channels == 2);
> -	igt_assert(sad->rates == (CEA_SAD_SAMPLING_RATE_32KHZ |
> -		   CEA_SAD_SAMPLING_RATE_44KHZ | CEA_SAD_SAMPLING_RATE_48KHZ));
> -	igt_assert(sad->bits == (CEA_SAD_SAMPLE_SIZE_16 |
> -		   CEA_SAD_SAMPLE_SIZE_20 | CEA_SAD_SAMPLE_SIZE_24));
> -
> -	igt_remove_fb(data->drm_fd, &fb);
> -
> -	drmModeFreeConnector(connector);
> -}
> -
> -static void randomize_plane_stride(data_t *data,
> -				   uint32_t width, uint32_t height,
> -				   uint32_t format, uint64_t modifier,
> -				   size_t *stride)
> -{
> -	size_t stride_min;
> -	uint32_t max_tile_w = 4, tile_w, tile_h;
> -	int i;
> -	struct igt_fb dummy;
> -
> -	stride_min = width * igt_format_plane_bpp(format, 0) / 8;
> -
> -	/* Randomize the stride to less than twice the minimum. */
> -	*stride = (rand() % stride_min) + stride_min;
> -
> -	/*
> -	 * Create a dummy FB to determine bpp for each plane, and calculate
> -	 * the maximum tile width from that.
> -	 */
> -	igt_create_fb(data->drm_fd, 64, 64, format, modifier, &dummy);
> -	for (i = 0; i < dummy.num_planes; i++) {
> -		igt_get_fb_tile_size(data->drm_fd, modifier, dummy.plane_bpp[i], &tile_w, &tile_h);
> -
> -		if (tile_w > max_tile_w)
> -			max_tile_w = tile_w;
> -	}
> -	igt_remove_fb(data->drm_fd, &dummy);
> -
> -	/*
> -	 * Pixman requires the stride to be aligned to 32-bits, which is
> -	 * reflected in the initial value of max_tile_w and the hw
> -	 * may require a multiple of tile width, choose biggest of the 2.
> -	 */
> -	*stride = ALIGN(*stride, max_tile_w);
> -}
> -
> -static void update_tiled_modifier(igt_plane_t *plane, uint32_t width,
> -				  uint32_t height, uint32_t format,
> -				  uint64_t *modifier)
> -{
> -	if (*modifier == DRM_FORMAT_MOD_BROADCOM_SAND256) {
> -		/* Randomize the column height to less than twice the minimum. */
> -		size_t column_height = (rand() % height) + height;
> -
> -		igt_debug("Selecting VC4 SAND256 tiling with column height %ld\n",
> -			  column_height);
> -
> -		*modifier = DRM_FORMAT_MOD_BROADCOM_SAND256_COL_HEIGHT(column_height);
> -	}
> -}
> -
> -static void randomize_plane_setup(data_t *data, igt_plane_t *plane,
> -				  drmModeModeInfo *mode,
> -				  uint32_t *width, uint32_t *height,
> -				  uint32_t *format, uint64_t *modifier,
> -				  bool allow_yuv)
> -{
> -	int min_dim;
> -	uint32_t idx[plane->format_mod_count];
> -	unsigned int count = 0;
> -	unsigned int i;
> -
> -	/* First pass to count the supported formats. */
> -	for (i = 0; i < plane->format_mod_count; i++)
> -		if (igt_fb_supported_format(plane->formats[i]) &&
> -		    (allow_yuv || !igt_format_is_yuv(plane->formats[i])))
> -			idx[count++] = i;
> -
> -	igt_assert(count > 0);
> -
> -	i = idx[rand() % count];
> -	*format = plane->formats[i];
> -	*modifier = plane->modifiers[i];
> -
> -	update_tiled_modifier(plane, *width, *height, *format, modifier);
> -
> -	/*
> -	 * Randomize width and height in the mode dimensions range.
> -	 *
> -	 * Restrict to a min of 2 * min_dim, this way src_w/h are always at
> -	 * least min_dim, because src_w = width - (rand % w / 2).
> -	 *
> -	 * Use a minimum dimension of 16 for YUV, because planar YUV
> -	 * subsamples the UV plane.
> -	 */
> -	min_dim = igt_format_is_yuv(*format) ? 16 : 8;
> -
> -	*width = max((rand() % mode->hdisplay) + 1, 2 * min_dim);
> -	*height = max((rand() % mode->vdisplay) + 1, 2 * min_dim);
> -}
> -
> -static void configure_plane(igt_plane_t *plane, uint32_t src_w, uint32_t src_h,
> -			    uint32_t src_x, uint32_t src_y, uint32_t crtc_w,
> -			    uint32_t crtc_h, int32_t crtc_x, int32_t crtc_y,
> -			    struct igt_fb *fb)
> -{
> -	igt_plane_set_fb(plane, fb);
> -
> -	igt_plane_set_position(plane, crtc_x, crtc_y);
> -	igt_plane_set_size(plane, crtc_w, crtc_h);
> -
> -	igt_fb_set_position(fb, plane, src_x, src_y);
> -	igt_fb_set_size(fb, plane, src_w, src_h);
> -}
> -
> -static void randomize_plane_coordinates(data_t *data, igt_plane_t *plane,
> -					drmModeModeInfo *mode,
> -					struct igt_fb *fb,
> -					uint32_t *src_w, uint32_t *src_h,
> -					uint32_t *src_x, uint32_t *src_y,
> -					uint32_t *crtc_w, uint32_t *crtc_h,
> -					int32_t *crtc_x, int32_t *crtc_y,
> -					bool allow_scaling)
> -{
> -	bool is_yuv = igt_format_is_yuv(fb->drm_format);
> -	uint32_t width = fb->width, height = fb->height;
> -	double ratio;
> -	int ret;
> -
> -	/* Randomize source offset in the first half of the original size. */
> -	*src_x = rand() % (width / 2);
> -	*src_y = rand() % (height / 2);
> -
> -	/* The source size only includes the active source area. */
> -	*src_w = width - *src_x;
> -	*src_h = height - *src_y;
> -
> -	if (allow_scaling) {
> -		*crtc_w = (rand() % mode->hdisplay) + 1;
> -		*crtc_h = (rand() % mode->vdisplay) + 1;
> -
> -		/*
> -		 * Don't bother with scaling if dimensions are quite close in
> -		 * order to get non-scaling cases more frequently. Also limit
> -		 * scaling to 3x to avoid agressive filtering that makes
> -		 * comparison less reliable, and don't go above 2x downsampling
> -		 * to avoid possible hw limitations.
> -		 */
> -
> -		ratio = ((double) *crtc_w / *src_w);
> -		if (ratio < 0.5)
> -			*src_w = *crtc_w * 2;
> -		else if (ratio > 0.8 && ratio < 1.2)
> -			*crtc_w = *src_w;
> -		else if (ratio > 3.0)
> -			*crtc_w = *src_w * 3;
> -
> -		ratio = ((double) *crtc_h / *src_h);
> -		if (ratio < 0.5)
> -			*src_h = *crtc_h * 2;
> -		else if (ratio > 0.8 && ratio < 1.2)
> -			*crtc_h = *src_h;
> -		else if (ratio > 3.0)
> -			*crtc_h = *src_h * 3;
> -	} else {
> -		*crtc_w = *src_w;
> -		*crtc_h = *src_h;
> -	}
> -
> -	if (*crtc_w != *src_w || *crtc_h != *src_h) {
> -		/*
> -		 * When scaling is involved, make sure to not go off-bounds or
> -		 * scaled clipping may result in decimal dimensions, that most
> -		 * drivers don't support.
> -		 */
> -		if (*crtc_w < mode->hdisplay)
> -			*crtc_x = rand() % (mode->hdisplay - *crtc_w);
> -		else
> -			*crtc_x = 0;
> -
> -		if (*crtc_h < mode->vdisplay)
> -			*crtc_y = rand() % (mode->vdisplay - *crtc_h);
> -		else
> -			*crtc_y = 0;
> -	} else {
> -		/*
> -		 * Randomize the on-crtc position and allow the plane to go
> -		 * off-display by less than half of its on-crtc dimensions.
> -		 */
> -		*crtc_x = (rand() % mode->hdisplay) - *crtc_w / 2;
> -		*crtc_y = (rand() % mode->vdisplay) - *crtc_h / 2;
> -	}
> -
> -	configure_plane(plane, *src_w, *src_h, *src_x, *src_y,
> -			*crtc_w, *crtc_h, *crtc_x, *crtc_y, fb);
> -	ret = igt_display_try_commit_atomic(&data->display,
> -					    DRM_MODE_ATOMIC_TEST_ONLY |
> -					    DRM_MODE_ATOMIC_ALLOW_MODESET,
> -					    NULL);
> -	if (!ret)
> -		return;
> -
> -	/* Coordinates are logged in the dumped debug log, so only report w/h on failure here. */
> -	igt_assert_f(ret != -ENOSPC,"Failure in testcase, invalid coordinates on a %ux%u fb\n", width, height);
> -
> -	/* Make YUV coordinates a multiple of 2 and retry the math. */
> -	if (is_yuv) {
> -		*src_x &= ~1;
> -		*src_y &= ~1;
> -		*src_w &= ~1;
> -		*src_h &= ~1;
> -		/* To handle 1:1 scaling, clear crtc_w/h too. */
> -		*crtc_w &= ~1;
> -		*crtc_h &= ~1;
> -
> -		if (*crtc_x < 0 && (*crtc_x & 1))
> -			(*crtc_x)++;
> -		else
> -			*crtc_x &= ~1;
> -
> -		/* If negative, round up to 0 instead of down */
> -		if (*crtc_y < 0 && (*crtc_y & 1))
> -			(*crtc_y)++;
> -		else
> -			*crtc_y &= ~1;
> -
> -		configure_plane(plane, *src_w, *src_h, *src_x, *src_y, *crtc_w,
> -				*crtc_h, *crtc_x, *crtc_y, fb);
> -		ret = igt_display_try_commit_atomic(&data->display,
> -						DRM_MODE_ATOMIC_TEST_ONLY |
> -						DRM_MODE_ATOMIC_ALLOW_MODESET,
> -						NULL);
> -		if (!ret)
> -			return;
> -	}
> -
> -	igt_assert(!ret || allow_scaling);
> -	igt_info("Scaling ratio %g / %g failed, trying without scaling.\n",
> -		  ((double) *crtc_w / *src_w), ((double) *crtc_h / *src_h));
> -
> -	*crtc_w = *src_w;
> -	*crtc_h = *src_h;
> -
> -	configure_plane(plane, *src_w, *src_h, *src_x, *src_y, *crtc_w,
> -			*crtc_h, *crtc_x, *crtc_y, fb);
> -	igt_display_commit_atomic(&data->display,
> -				  DRM_MODE_ATOMIC_TEST_ONLY |
> -				  DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
> -}
> -
> -static void blit_plane_cairo(data_t *data, cairo_surface_t *result,
> -			     uint32_t src_w, uint32_t src_h,
> -			     uint32_t src_x, uint32_t src_y,
> -			     uint32_t crtc_w, uint32_t crtc_h,
> -			     int32_t crtc_x, int32_t crtc_y,
> -			     struct igt_fb *fb)
> -{
> -	cairo_surface_t *surface;
> -	cairo_surface_t *clipped_surface;
> -	cairo_t *cr;
> -
> -	surface = igt_get_cairo_surface(data->drm_fd, fb);
> -
> -	if (src_x || src_y) {
> -		clipped_surface = cairo_image_surface_create(CAIRO_FORMAT_RGB24,
> -							     src_w, src_h);
> -
> -		cr = cairo_create(clipped_surface);
> -
> -		cairo_translate(cr, -1. * src_x, -1. * src_y);
> -
> -		cairo_set_source_surface(cr, surface, 0, 0);
> -
> -		cairo_paint(cr);
> -		cairo_surface_flush(clipped_surface);
> -
> -		cairo_destroy(cr);
> -	} else {
> -		clipped_surface = surface;
> -	}
> -
> -	cr = cairo_create(result);
> -
> -	cairo_translate(cr, crtc_x, crtc_y);
> -
> -	if (src_w != crtc_w || src_h != crtc_h) {
> -		cairo_scale(cr, (double) crtc_w / src_w,
> -			    (double) crtc_h / src_h);
> -	}
> -
> -	cairo_set_source_surface(cr, clipped_surface, 0, 0);
> -	cairo_surface_destroy(clipped_surface);
> -
> -	if (src_w != crtc_w || src_h != crtc_h) {
> -		cairo_pattern_set_filter(cairo_get_source(cr),
> -					 CAIRO_FILTER_BILINEAR);
> -		cairo_pattern_set_extend(cairo_get_source(cr),
> -					 CAIRO_EXTEND_NONE);
> -	}
> -
> -	cairo_paint(cr);
> -	cairo_surface_flush(result);
> -
> -	cairo_destroy(cr);
> -}
> -
> -static void prepare_randomized_plane(data_t *data,
> -				     drmModeModeInfo *mode,
> -				     igt_plane_t *plane,
> -				     struct igt_fb *overlay_fb,
> -				     unsigned int index,
> -				     cairo_surface_t *result_surface,
> -				     bool allow_scaling, bool allow_yuv)
> -{
> -	struct igt_fb pattern_fb;
> -	uint32_t overlay_fb_w, overlay_fb_h;
> -	uint32_t overlay_src_w, overlay_src_h;
> -	uint32_t overlay_src_x, overlay_src_y;
> -	int32_t overlay_crtc_x, overlay_crtc_y;
> -	uint32_t overlay_crtc_w, overlay_crtc_h;
> -	uint32_t format;
> -	uint64_t modifier;
> -	size_t stride;
> -	bool tiled;
> -	int fb_id;
> -
> -	randomize_plane_setup(data, plane, mode, &overlay_fb_w, &overlay_fb_h,
> -			      &format, &modifier, allow_yuv);
> -
> -	tiled = (modifier != DRM_FORMAT_MOD_LINEAR);
> -	igt_debug("Plane %d: framebuffer size %dx%d %s format (%s)\n",
> -		  index, overlay_fb_w, overlay_fb_h,
> -		  igt_format_str(format), tiled ? "tiled" : "linear");
> -
> -	/* Get a pattern framebuffer for the overlay plane. */
> -	fb_id = chamelium_get_pattern_fb(data, overlay_fb_w, overlay_fb_h,
> -					 DRM_FORMAT_XRGB8888, 32, &pattern_fb);
> -	igt_assert(fb_id > 0);
> -
> -	randomize_plane_stride(data, overlay_fb_w, overlay_fb_h,
> -			       format, modifier, &stride);
> -
> -	igt_debug("Plane %d: stride %ld\n", index, stride);
> -
> -	fb_id = igt_fb_convert_with_stride(overlay_fb, &pattern_fb, format,
> -					   modifier, stride);
> -	igt_assert(fb_id > 0);
> -
> -	randomize_plane_coordinates(data, plane, mode, overlay_fb,
> -				    &overlay_src_w, &overlay_src_h,
> -				    &overlay_src_x, &overlay_src_y,
> -				    &overlay_crtc_w, &overlay_crtc_h,
> -				    &overlay_crtc_x, &overlay_crtc_y,
> -				    allow_scaling);
> -
> -	igt_debug("Plane %d: in-framebuffer size %dx%d\n", index,
> -		  overlay_src_w, overlay_src_h);
> -	igt_debug("Plane %d: in-framebuffer position %dx%d\n", index,
> -		  overlay_src_x, overlay_src_y);
> -	igt_debug("Plane %d: on-crtc size %dx%d\n", index,
> -		  overlay_crtc_w, overlay_crtc_h);
> -	igt_debug("Plane %d: on-crtc position %dx%d\n", index,
> -		  overlay_crtc_x, overlay_crtc_y);
> -
> -	blit_plane_cairo(data, result_surface, overlay_src_w, overlay_src_h,
> -			 overlay_src_x, overlay_src_y,
> -			 overlay_crtc_w, overlay_crtc_h,
> -			 overlay_crtc_x, overlay_crtc_y, &pattern_fb);
> -
> -	/* Remove the original pattern framebuffer. */
> -	igt_remove_fb(data->drm_fd, &pattern_fb);
> -}
> -
> -static const char test_display_planes_random_desc[] =
> -	"Setup a few overlay planes with random parameters, capture the frame "
> -	"and check it matches the expected output";
> -static void test_display_planes_random(data_t *data,
> -				       struct chamelium_port *port,
> -				       enum chamelium_check check)
> -{
> -	igt_output_t *output;
> -	drmModeModeInfo *mode;
> -	igt_plane_t *primary_plane;
> -	struct igt_fb primary_fb;
> -	struct igt_fb result_fb;
> -	struct igt_fb *overlay_fbs;
> -	igt_crc_t *crc;
> -	igt_crc_t *expected_crc;
> -	struct chamelium_fb_crc_async_data *fb_crc;
> -	unsigned int overlay_planes_max = 0;
> -	unsigned int overlay_planes_count;
> -	cairo_surface_t *result_surface;
> -	int captured_frame_count;
> -	bool allow_scaling;
> -	bool allow_yuv;
> -	unsigned int i;
> -	unsigned int fb_id;
> -
> -	switch (check) {
> -	case CHAMELIUM_CHECK_CRC:
> -		allow_scaling = false;
> -		allow_yuv = false;
> -		break;
> -	case CHAMELIUM_CHECK_CHECKERBOARD:
> -		allow_scaling = true;
> -		allow_yuv = true;
> -		break;
> -	default:
> -		igt_assert(false);
> -	}
> -
> -	srand(time(NULL));
> -
> -	igt_modeset_disable_all_outputs(&data->display);
> -	chamelium_reset_state(&data->display, data->chamelium,
> -			      port, data->ports, data->port_count);
> -
> -	/* Find the connector and pipe. */
> -	output = prepare_output(data, port, IGT_CUSTOM_EDID_BASE);
> -
> -	mode = igt_output_get_mode(output);
> -
> -	/* Get a framebuffer for the primary plane. */
> -	primary_plane = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY);
> -	igt_assert(primary_plane);
> -
> -	fb_id = chamelium_get_pattern_fb(data, mode->hdisplay, mode->vdisplay,
> -					 DRM_FORMAT_XRGB8888, 64, &primary_fb);
> -	igt_assert(fb_id > 0);
> -
> -	/* Get a framebuffer for the cairo composition result. */
> -	fb_id = igt_create_fb(data->drm_fd, mode->hdisplay,
> -			      mode->vdisplay, DRM_FORMAT_XRGB8888,
> -			      DRM_FORMAT_MOD_LINEAR, &result_fb);
> -	igt_assert(fb_id > 0);
> -
> -	result_surface = igt_get_cairo_surface(data->drm_fd, &result_fb);
> -
> -	/* Paint the primary framebuffer on the result surface. */
> -	blit_plane_cairo(data, result_surface, 0, 0, 0, 0, 0, 0, 0, 0,
> -			 &primary_fb);
> -
> -	/* Configure the primary plane. */
> -	igt_plane_set_fb(primary_plane, &primary_fb);
> -
> -	overlay_planes_max =
> -		igt_output_count_plane_type(output, DRM_PLANE_TYPE_OVERLAY);
> -
> -	/* Limit the number of planes to a reasonable scene. */
> -	overlay_planes_max = min(overlay_planes_max, 4u);
> -
> -	overlay_planes_count = (rand() % overlay_planes_max) + 1;
> -	igt_debug("Using %d overlay planes\n", overlay_planes_count);
> -
> -	overlay_fbs = calloc(sizeof(struct igt_fb), overlay_planes_count);
> -
> -	for (i = 0; i < overlay_planes_count; i++) {
> -		struct igt_fb *overlay_fb = &overlay_fbs[i];
> -		igt_plane_t *plane =
> -			igt_output_get_plane_type_index(output,
> -							DRM_PLANE_TYPE_OVERLAY,
> -							i);
> -		igt_assert(plane);
> -
> -		prepare_randomized_plane(data, mode, plane, overlay_fb, i,
> -					 result_surface, allow_scaling,
> -					 allow_yuv);
> -	}
> -
> -	cairo_surface_destroy(result_surface);
> -
> -	if (check == CHAMELIUM_CHECK_CRC)
> -		fb_crc = chamelium_calculate_fb_crc_async_start(data->drm_fd,
> -								&result_fb);
> -
> -	igt_display_commit2(&data->display, COMMIT_ATOMIC);
> -
> -	if (check == CHAMELIUM_CHECK_CRC) {
> -		chamelium_capture(data->chamelium, port, 0, 0, 0, 0, 1);
> -		crc = chamelium_read_captured_crcs(data->chamelium,
> -						   &captured_frame_count);
> -
> -		igt_assert(captured_frame_count == 1);
> -
> -		expected_crc = chamelium_calculate_fb_crc_async_finish(fb_crc);
> -
> -		chamelium_assert_crc_eq_or_dump(data->chamelium,
> -						expected_crc, crc,
> -						&result_fb, 0);
> -
> -		free(expected_crc);
> -		free(crc);
> -	} else if (check == CHAMELIUM_CHECK_CHECKERBOARD) {
> -		struct chamelium_frame_dump *dump;
> -
> -		dump = chamelium_port_dump_pixels(data->chamelium, port, 0, 0,
> -						  0, 0);
> -		chamelium_assert_frame_match_or_dump(data->chamelium, port,
> -						     dump, &result_fb, check);
> -		chamelium_destroy_frame_dump(dump);
> -	}
> -
> -	for (i = 0; i < overlay_planes_count; i++)
> -		igt_remove_fb(data->drm_fd, &overlay_fbs[i]);
> -
> -	free(overlay_fbs);
> -
> -	igt_remove_fb(data->drm_fd, &primary_fb);
> -	igt_remove_fb(data->drm_fd, &result_fb);
> -}
> -
> -static const char test_hpd_without_ddc_desc[] =
> -	"Disable DDC on a VGA connector, check we still get a uevent on hotplug";
> -static void
> -test_hpd_without_ddc(data_t *data, struct chamelium_port *port)
> -{
> -	struct udev_monitor *mon = igt_watch_uevents();
> -
> -	igt_modeset_disable_all_outputs(&data->display);
> -	chamelium_reset_state(&data->display, data->chamelium,
> -			      port, data->ports, data->port_count);
> -	igt_flush_uevents(mon);
> -
> -	/* Disable the DDC on the connector and make sure we still get a
> -	 * hotplug
> -	 */
> -	chamelium_port_set_ddc_state(data->chamelium, port, false);
> -	chamelium_plug(data->chamelium, port);
> -
> -	igt_assert(igt_hotplug_detected(mon, CHAMELIUM_HOTPLUG_TIMEOUT));
> -	igt_assert_eq(chamelium_reprobe_connector(&data->display,
> -						  data->chamelium, port),
> -						  DRM_MODE_CONNECTED);
> -
> -	igt_cleanup_uevents(mon);
> -}
> -
> -static const char test_hpd_storm_detect_desc[] =
> -	"Trigger a series of hotplugs in a very small timeframe to simulate a"
> -	"bad cable, check the kernel falls back to polling to avoid a hotplug "
> -	"storm";
> -static void
> -test_hpd_storm_detect(data_t *data, struct chamelium_port *port, int width)
> -{
> -	struct udev_monitor *mon;
> -	int count = 0;
> -
> -	igt_require_hpd_storm_ctl(data->drm_fd);
> -	igt_modeset_disable_all_outputs(&data->display);
> -	chamelium_reset_state(&data->display, data->chamelium,
> -			      port, data->ports, data->port_count);
> -
> -	igt_hpd_storm_set_threshold(data->drm_fd, 1);
> -	chamelium_fire_hpd_pulses(data->chamelium, port, width, 10);
> -	igt_assert(igt_hpd_storm_detected(data->drm_fd));
> -
> -	mon = igt_watch_uevents();
> -	chamelium_fire_hpd_pulses(data->chamelium, port, width, 10);
> -
> -	/*
> -	 * Polling should have been enabled by the HPD storm at this point,
> -	 * so we should only get at most 1 hotplug event
> -	 */
> -	igt_until_timeout(5)
> -		count += igt_hotplug_detected(mon, 1);
> -	igt_assert_lt(count, 2);
> -
> -	igt_cleanup_uevents(mon);
> -	igt_hpd_storm_reset(data->drm_fd);
> -}
> -
> -static const char test_hpd_storm_disable_desc[] =
> -	"Disable HPD storm detection, trigger a storm and check the kernel "
> -	"doesn't detect one";
> -static void
> -test_hpd_storm_disable(data_t *data, struct chamelium_port *port, int width)
> -{
> -	igt_require_hpd_storm_ctl(data->drm_fd);
> -	igt_modeset_disable_all_outputs(&data->display);
> -	chamelium_reset_state(&data->display, data->chamelium,
> -			      port, data->ports, data->port_count);
> -
> -	igt_hpd_storm_set_threshold(data->drm_fd, 0);
> -	chamelium_fire_hpd_pulses(data->chamelium, port,
> -				  width, 10);
> -	igt_assert(!igt_hpd_storm_detected(data->drm_fd));
> -
> -	igt_hpd_storm_reset(data->drm_fd);
> -}
> -
> -static const char igt_edid_stress_resolution_desc[] =
> -	"Stress test the DUT by testing multiple EDIDs, one right after the other,"
> -	"and ensure their validity by check the real screen resolution vs the"
> -	"advertised mode resultion.";
> -static void edid_stress_resolution(data_t *data, struct chamelium_port *port,
> -				   monitor_edid edids_list[],
> -				   size_t edids_list_len)
> -{
> -	int i;
> -	struct chamelium *chamelium = data->chamelium;
> -	struct udev_monitor *mon = igt_watch_uevents();
> -
> -	for (i = 0; i < edids_list_len; ++i) {
> -		struct chamelium_edid *chamelium_edid;
> -		drmModeModeInfo mode;
> -		struct igt_fb fb = { 0 };
> -		igt_output_t *output;
> -		enum pipe pipe;
> -		bool is_video_stable;
> -		int screen_res_w, screen_res_h;
> -
> -		monitor_edid *edid = &edids_list[i];
> -		igt_info("Testing out the EDID for %s\n",
> -			 monitor_edid_get_name(edid));
> -
> -		/* Getting and Setting the EDID on Chamelium. */
> -		chamelium_edid =
> -			get_chameleon_edid_from_monitor_edid(chamelium, edid);
> -		chamelium_port_set_edid(data->chamelium, port, chamelium_edid);
> -		free_chamelium_edid_from_monitor_edid(chamelium_edid);
> -
> -		igt_flush_uevents(mon);
> -		chamelium_plug(chamelium, port);
> -		wait_for_connector_after_hotplug(data, mon, port,
> -						 DRM_MODE_CONNECTED);
> -		igt_flush_uevents(mon);
> -
> -		/* Setting an output on the screen to turn it on. */
> -		mode = get_mode_for_port(chamelium, port);
> -		create_fb_for_mode(data, &fb, &mode);
> -		output = get_output_for_port(data, port);
> -		pipe = get_pipe_for_output(&data->display, output);
> -		igt_output_set_pipe(output, pipe);
> -		enable_output(data, port, output, &mode, &fb);
> -
> -		/* Capture the screen resolution and verify. */
> -		is_video_stable = chamelium_port_wait_video_input_stable(
> -			chamelium, port, 5);
> -		igt_assert(is_video_stable);
> -
> -		chamelium_port_get_resolution(chamelium, port, &screen_res_w,
> -					      &screen_res_h);
> -		igt_assert(screen_res_w == fb.width);
> -		igt_assert(screen_res_h == fb.height);
> -
> -		// Clean up
> -		igt_remove_fb(data->drm_fd, &fb);
> -		igt_modeset_disable_all_outputs(&data->display);
> -		chamelium_unplug(chamelium, port);
> -	}
> -
> -	chamelium_reset_state(&data->display, data->chamelium, port,
> -			      data->ports, data->port_count);
> -}
> -
> -static const char igt_edid_resolution_list_desc[] =
> -	"Get an EDID with many modes of different configurations, set them on the screen and check the"
> -	" screen resolution matches the mode resolution.";
> -
> -static void edid_resolution_list(data_t *data, struct chamelium_port *port)
> -{
> -	struct chamelium *chamelium = data->chamelium;
> -	struct udev_monitor *mon = igt_watch_uevents();
> -	drmModeConnector *connector;
> -	drmModeModeInfoPtr modes;
> -	int count_modes;
> -	int i;
> -	igt_output_t *output;
> -	enum pipe pipe;
> -
> -	chamelium_unplug(chamelium, port);
> -	set_edid(data, port, IGT_CUSTOM_EDID_FULL);
> -
> -	igt_flush_uevents(mon);
> -	chamelium_plug(chamelium, port);
> -	wait_for_connector_after_hotplug(data, mon, port, DRM_MODE_CONNECTED);
> -	igt_flush_uevents(mon);
> -
> -	connector = chamelium_port_get_connector(chamelium, port, true);
> -	modes = connector->modes;
> -	count_modes = connector->count_modes;
> -
> -	output = get_output_for_port(data, port);
> -	pipe = get_pipe_for_output(&data->display, output);
> -	igt_output_set_pipe(output, pipe);
> -
> -	for (i = 0; i < count_modes; ++i)
> -		igt_debug("#%d %s %uHz\n", i, modes[i].name, modes[i].vrefresh);
> -
> -	for (i = 0; i < count_modes; ++i) {
> -		struct igt_fb fb = { 0 };
> -		bool is_video_stable;
> -		int screen_res_w, screen_res_h;
> -
> -		igt_info("Testing #%d %s %uHz\n", i, modes[i].name,
> -			 modes[i].vrefresh);
> -
> -		/* Set the screen mode with the one we chose. */
> -		create_fb_for_mode(data, &fb, &modes[i]);
> -		enable_output(data, port, output, &modes[i], &fb);
> -		is_video_stable = chamelium_port_wait_video_input_stable(
> -			chamelium, port, 10);
> -		igt_assert(is_video_stable);
> -
> -		chamelium_port_get_resolution(chamelium, port, &screen_res_w,
> -					      &screen_res_h);
> -		igt_assert_eq(screen_res_w, modes[i].hdisplay);
> -		igt_assert_eq(screen_res_h, modes[i].vdisplay);
> -
> -		igt_remove_fb(data->drm_fd, &fb);
> -	}
> -
> -	igt_modeset_disable_all_outputs(&data->display);
> -	drmModeFreeConnector(connector);
> -}
> -
> -#define for_each_port(p, port)            \
> -	for (p = 0, port = data.ports[p]; \
> -	     p < data.port_count;         \
> -	     p++, port = data.ports[p])
> -
> -#define connector_subtest(name__, type__)                    \
> -	igt_subtest(name__)                                  \
> -		for_each_port(p, port)                       \
> -			if (chamelium_port_get_type(port) == \
> -			    DRM_MODE_CONNECTOR_ ## type__)
> -
> -#define connector_dynamic_subtest(name__, type__)            \
> -	igt_subtest_with_dynamic(name__)                     \
> -		for_each_port(p, port)                       \
> -			if (chamelium_port_get_type(port) == \
> -			    DRM_MODE_CONNECTOR_ ## type__)
> -
> -
> -static data_t data;
> -
> -IGT_TEST_DESCRIPTION("Tests requiring a Chamelium board");
> -igt_main
> -{
> -	struct chamelium_port *port;
> -	int p;
> -	size_t i;
> -
> -	igt_fixture {
> -		/* So fbcon doesn't try to reprobe things itself */
> -		kmstest_set_vt_graphics_mode();
> -
> -		data.drm_fd = drm_open_driver_master(DRIVER_ANY);
> -		igt_display_require(&data.display, data.drm_fd);
> -		igt_require(data.display.is_atomic);
> -
> -		/*
> -		 * XXX: disabling modeset, can be removed when
> -		 * igt_display_require will start doing this for us
> -		 */
> -		igt_display_commit2(&data.display, COMMIT_ATOMIC);
> -
> -		/* we need to initalize chamelium after igt_display_require */
> -		data.chamelium = chamelium_init(data.drm_fd, &data.display);
> -		igt_require(data.chamelium);
> -
> -		data.ports = chamelium_get_ports(data.chamelium,
> -						 &data.port_count);
> -
> -		for (i = 0; i < IGT_CUSTOM_EDID_COUNT; ++i) {
> -			data.edids[i] = chamelium_new_edid(data.chamelium,
> -							   igt_kms_get_custom_edid(i));
> -		}
> -	}
> -
> -	igt_describe("DisplayPort tests");
> -	igt_subtest_group {
> -		igt_fixture {
> -			chamelium_require_connector_present(data.ports, DRM_MODE_CONNECTOR_DisplayPort,
> -							    data.port_count, 1);
> -		}
> -
> -		igt_describe(test_basic_hotplug_desc);
> -		connector_subtest("dp-hpd", DisplayPort)
> -			test_hotplug(&data, port,
> -				     HPD_TOGGLE_COUNT_DP_HDMI,
> -				     TEST_MODESET_OFF);
> -
> -		igt_describe(test_basic_hotplug_desc);
> -		connector_subtest("dp-hpd-fast", DisplayPort)
> -			test_hotplug(&data, port,
> -				     HPD_TOGGLE_COUNT_FAST,
> -				     TEST_MODESET_OFF);
> -
> -		igt_describe(test_basic_hotplug_desc);
> -		connector_subtest("dp-hpd-enable-disable-mode", DisplayPort)
> -			test_hotplug(&data, port,
> -				     HPD_TOGGLE_COUNT_FAST,
> -				     TEST_MODESET_ON_OFF);
> -
> -		igt_describe(test_basic_hotplug_desc);
> -		connector_subtest("dp-hpd-with-enabled-mode", DisplayPort)
> -			test_hotplug(&data, port,
> -				     HPD_TOGGLE_COUNT_FAST,
> -				     TEST_MODESET_ON);
> -
> -		igt_describe(igt_custom_edid_type_read_desc);
> -		connector_subtest("dp-edid-read", DisplayPort) {
> -			igt_custom_edid_type_read(&data, port, IGT_CUSTOM_EDID_BASE);
> -			igt_custom_edid_type_read(&data, port, IGT_CUSTOM_EDID_ALT);
> -		}
> -
> -		igt_describe(igt_edid_stress_resolution_desc);
> -		connector_subtest("dp-edid-stress-resolution-4k", DisplayPort)
> -			edid_stress_resolution(&data, port, DP_EDIDS_4K,
> -					       ARRAY_SIZE(DP_EDIDS_4K));
> -
> -		igt_describe(igt_edid_stress_resolution_desc);
> -		connector_subtest("dp-edid-stress-resolution-non-4k",
> -				  DisplayPort)
> -			edid_stress_resolution(&data, port, DP_EDIDS_NON_4K,
> -					       ARRAY_SIZE(DP_EDIDS_NON_4K));
> -
> -		igt_describe(igt_edid_resolution_list_desc);
> -		connector_subtest("dp-edid-resolution-list", DisplayPort)
> -			edid_resolution_list(&data, port);
> -
> -		igt_describe(test_suspend_resume_hpd_desc);
> -		connector_subtest("dp-hpd-after-suspend", DisplayPort)
> -			test_suspend_resume_hpd(&data, port,
> -						SUSPEND_STATE_MEM,
> -						SUSPEND_TEST_NONE);
> -
> -		igt_describe(test_suspend_resume_hpd_desc);
> -		connector_subtest("dp-hpd-after-hibernate", DisplayPort)
> -			test_suspend_resume_hpd(&data, port,
> -						SUSPEND_STATE_DISK,
> -						SUSPEND_TEST_DEVICES);
> -
> -		igt_describe(test_hpd_storm_detect_desc);
> -		connector_subtest("dp-hpd-storm", DisplayPort)
> -			test_hpd_storm_detect(&data, port,
> -					      HPD_STORM_PULSE_INTERVAL_DP);
> -
> -		igt_describe(test_hpd_storm_disable_desc);
> -		connector_subtest("dp-hpd-storm-disable", DisplayPort)
> -			test_hpd_storm_disable(&data, port,
> -					       HPD_STORM_PULSE_INTERVAL_DP);
> -
> -		igt_describe(test_suspend_resume_edid_change_desc);
> -		connector_subtest("dp-edid-change-during-suspend", DisplayPort)
> -			test_suspend_resume_edid_change(&data, port,
> -							SUSPEND_STATE_MEM,
> -							SUSPEND_TEST_NONE,
> -							IGT_CUSTOM_EDID_BASE,
> -							IGT_CUSTOM_EDID_ALT);
> -
> -		igt_describe(test_suspend_resume_edid_change_desc);
> -		connector_subtest("dp-edid-change-during-hibernate", DisplayPort)
> -			test_suspend_resume_edid_change(&data, port,
> -							SUSPEND_STATE_DISK,
> -							SUSPEND_TEST_DEVICES,
> -							IGT_CUSTOM_EDID_BASE,
> -							IGT_CUSTOM_EDID_ALT);
> -
> -		igt_describe(test_display_all_modes_desc);
> -		connector_subtest("dp-crc-single", DisplayPort)
> -			test_display_all_modes(&data, port, DRM_FORMAT_XRGB8888,
> -					       CHAMELIUM_CHECK_CRC, 1);
> -
> -		igt_describe(test_display_one_mode_desc);
> -		connector_subtest("dp-crc-fast", DisplayPort)
> -			test_display_one_mode(&data, port, DRM_FORMAT_XRGB8888,
> -					      CHAMELIUM_CHECK_CRC, 1);
> -
> -		igt_describe(test_display_all_modes_desc);
> -		connector_subtest("dp-crc-multiple", DisplayPort)
> -			test_display_all_modes(&data, port, DRM_FORMAT_XRGB8888,
> -					       CHAMELIUM_CHECK_CRC, 3);
> -
> -		igt_describe(test_display_frame_dump_desc);
> -		connector_subtest("dp-frame-dump", DisplayPort)
> -			test_display_frame_dump(&data, port);
> -
> -		igt_describe(test_mode_timings_desc);
> -		connector_subtest("dp-mode-timings", DisplayPort)
> -			test_mode_timings(&data, port);
> -
> -		igt_describe(test_display_audio_desc);
> -		connector_subtest("dp-audio", DisplayPort)
> -			test_display_audio(&data, port, "HDMI",
> -					   IGT_CUSTOM_EDID_DP_AUDIO);
> -
> -		igt_describe(test_display_audio_edid_desc);
> -		connector_subtest("dp-audio-edid", DisplayPort)
> -			test_display_audio_edid(&data, port,
> -						IGT_CUSTOM_EDID_DP_AUDIO);
> -
> -		igt_describe(test_hotplug_for_each_pipe_desc);
> -		connector_subtest("dp-hpd-for-each-pipe", DisplayPort)
> -			test_hotplug_for_each_pipe(&data, port);
> -	}
> -
> -	igt_describe("HDMI tests");
> -	igt_subtest_group {
> -		igt_fixture {
> -			chamelium_require_connector_present(data.ports, DRM_MODE_CONNECTOR_HDMIA,
> -							    data.port_count, 1);
> -		}
> -
> -		igt_describe(test_basic_hotplug_desc);
> -		connector_subtest("hdmi-hpd", HDMIA)
> -			test_hotplug(&data, port,
> -				     HPD_TOGGLE_COUNT_DP_HDMI,
> -				     TEST_MODESET_OFF);
> -
> -		igt_describe(test_basic_hotplug_desc);
> -		connector_subtest("hdmi-hpd-fast", HDMIA)
> -			test_hotplug(&data, port,
> -				     HPD_TOGGLE_COUNT_FAST,
> -				     TEST_MODESET_OFF);
> -
> -		igt_describe(test_basic_hotplug_desc);
> -		connector_subtest("hdmi-hpd-enable-disable-mode", HDMIA)
> -			test_hotplug(&data, port,
> -				     HPD_TOGGLE_COUNT_FAST,
> -				     TEST_MODESET_ON_OFF);
> -
> -		igt_describe(test_basic_hotplug_desc);
> -		connector_subtest("hdmi-hpd-with-enabled-mode", HDMIA)
> -			test_hotplug(&data, port,
> -				     HPD_TOGGLE_COUNT_FAST,
> -				     TEST_MODESET_ON);
> -
> -		igt_describe(igt_custom_edid_type_read_desc);
> -		connector_subtest("hdmi-edid-read", HDMIA) {
> -			igt_custom_edid_type_read(&data, port, IGT_CUSTOM_EDID_BASE);
> -			igt_custom_edid_type_read(&data, port, IGT_CUSTOM_EDID_ALT);
> -		}
> -
> -		igt_describe(igt_edid_stress_resolution_desc);
> -		connector_subtest("hdmi-edid-stress-resolution-4k", HDMIA)
> -			edid_stress_resolution(&data, port, HDMI_EDIDS_4K,
> -					       ARRAY_SIZE(HDMI_EDIDS_4K));
> -
> -		igt_describe(igt_edid_stress_resolution_desc);
> -		connector_subtest("hdmi-edid-stress-resolution-non-4k", HDMIA)
> -			edid_stress_resolution(&data, port, HDMI_EDIDS_NON_4K,
> -					       ARRAY_SIZE(HDMI_EDIDS_NON_4K));
> -
> -		igt_describe(test_suspend_resume_hpd_desc);
> -		connector_subtest("hdmi-hpd-after-suspend", HDMIA)
> -			test_suspend_resume_hpd(&data, port,
> -						SUSPEND_STATE_MEM,
> -						SUSPEND_TEST_NONE);
> -
> -		igt_describe(test_suspend_resume_hpd_desc);
> -		connector_subtest("hdmi-hpd-after-hibernate", HDMIA)
> -			test_suspend_resume_hpd(&data, port,
> -						SUSPEND_STATE_DISK,
> -						SUSPEND_TEST_DEVICES);
> -
> -		igt_describe(test_hpd_storm_detect_desc);
> -		connector_subtest("hdmi-hpd-storm", HDMIA)
> -			test_hpd_storm_detect(&data, port,
> -					      HPD_STORM_PULSE_INTERVAL_HDMI);
> -
> -		igt_describe(test_hpd_storm_disable_desc);
> -		connector_subtest("hdmi-hpd-storm-disable", HDMIA)
> -			test_hpd_storm_disable(&data, port,
> -					       HPD_STORM_PULSE_INTERVAL_HDMI);
> -
> -		igt_describe(test_suspend_resume_edid_change_desc);
> -		connector_subtest("hdmi-edid-change-during-suspend", HDMIA)
> -			test_suspend_resume_edid_change(&data, port,
> -							SUSPEND_STATE_MEM,
> -							SUSPEND_TEST_NONE,
> -							IGT_CUSTOM_EDID_BASE,
> -							IGT_CUSTOM_EDID_ALT);
> -
> -		igt_describe(test_suspend_resume_edid_change_desc);
> -		connector_subtest("hdmi-edid-change-during-hibernate", HDMIA)
> -			test_suspend_resume_edid_change(&data, port,
> -							SUSPEND_STATE_DISK,
> -							SUSPEND_TEST_DEVICES,
> -							IGT_CUSTOM_EDID_BASE,
> -							IGT_CUSTOM_EDID_ALT);
> -
> -		igt_describe(test_display_all_modes_desc);
> -		connector_subtest("hdmi-crc-single", HDMIA)
> -			test_display_all_modes(&data, port, DRM_FORMAT_XRGB8888,
> -					       CHAMELIUM_CHECK_CRC, 1);
> -
> -		igt_describe(test_display_one_mode_desc);
> -		connector_subtest("hdmi-crc-fast", HDMIA)
> -			test_display_one_mode(&data, port, DRM_FORMAT_XRGB8888,
> -					      CHAMELIUM_CHECK_CRC, 1);
> -
> -		igt_describe(test_display_all_modes_desc);
> -		connector_subtest("hdmi-crc-multiple", HDMIA)
> -			test_display_all_modes(&data, port, DRM_FORMAT_XRGB8888,
> -					       CHAMELIUM_CHECK_CRC, 3);
> -
> -		igt_describe(test_display_one_mode_desc);
> -		connector_dynamic_subtest("hdmi-crc-nonplanar-formats", HDMIA) {
> -			int k;
> -			igt_output_t *output;
> -			igt_plane_t *primary;
> -
> -			output = prepare_output(&data, port, IGT_CUSTOM_EDID_BASE);
> -			primary = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY);
> -			igt_assert(primary);
> -
> -			for (k = 0; k < primary->format_mod_count; k++) {
> -				if (!igt_fb_supported_format(primary->formats[k]))
> -					continue;
> -
> -				if (igt_format_is_yuv(primary->formats[k]))
> -					continue;
> -
> -				if (primary->modifiers[k] != DRM_FORMAT_MOD_LINEAR)
> -					continue;
> -
> -				igt_dynamic_f("%s", igt_format_str(primary->formats[k]))
> -					test_display_one_mode(&data, port, primary->formats[k],
> -							      CHAMELIUM_CHECK_CRC, 1);
> -			}
> -		}
> -
> -		igt_describe(test_display_planes_random_desc);
> -		connector_subtest("hdmi-crc-planes-random", HDMIA)
> -			test_display_planes_random(&data, port,
> -						   CHAMELIUM_CHECK_CRC);
> -
> -		igt_describe(test_display_one_mode_desc);
> -		connector_dynamic_subtest("hdmi-cmp-planar-formats", HDMIA) {
> -			int k;
> -			igt_output_t *output;
> -			igt_plane_t *primary;
> -
> -			output = prepare_output(&data, port, IGT_CUSTOM_EDID_BASE);
> -			primary = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY);
> -			igt_assert(primary);
> -
> -			for (k = 0; k < primary->format_mod_count; k++) {
> -				if (!igt_fb_supported_format(primary->formats[k]))
> -					continue;
> -
> -				if (!igt_format_is_yuv(primary->formats[k]))
> -					continue;
> -
> -				if (primary->modifiers[k] != DRM_FORMAT_MOD_LINEAR)
> -					continue;
> -
> -				igt_dynamic_f("%s", igt_format_str(primary->formats[k]))
> -					test_display_one_mode(&data, port, primary->formats[k],
> -							      CHAMELIUM_CHECK_CHECKERBOARD, 1);
> -			}
> -		}
> -
> -		igt_describe(test_display_planes_random_desc);
> -		connector_subtest("hdmi-cmp-planes-random", HDMIA)
> -			test_display_planes_random(&data, port,
> -						   CHAMELIUM_CHECK_CHECKERBOARD);
> -
> -		igt_describe(test_display_frame_dump_desc);
> -		connector_subtest("hdmi-frame-dump", HDMIA)
> -			test_display_frame_dump(&data, port);
> -
> -		igt_describe(test_mode_timings_desc);
> -		connector_subtest("hdmi-mode-timings", HDMIA)
> -			test_mode_timings(&data, port);
> -
> -		igt_describe(test_display_audio_desc);
> -		connector_subtest("hdmi-audio", HDMIA)
> -			test_display_audio(&data, port, "HDMI",
> -					   IGT_CUSTOM_EDID_HDMI_AUDIO);
> -
> -		igt_describe(test_display_audio_edid_desc);
> -		connector_subtest("hdmi-audio-edid", HDMIA)
> -			test_display_audio_edid(&data, port,
> -						IGT_CUSTOM_EDID_HDMI_AUDIO);
> -
> -		igt_describe(test_display_aspect_ratio_desc);
> -		connector_subtest("hdmi-aspect-ratio", HDMIA)
> -			test_display_aspect_ratio(&data, port);
> -
> -		igt_describe(test_hotplug_for_each_pipe_desc);
> -		connector_subtest("hdmi-hpd-for-each-pipe", HDMIA)
> -			test_hotplug_for_each_pipe(&data, port);
> -	}
> -
> -	igt_describe("VGA tests");
> -	igt_subtest_group {
> -		igt_fixture {
> -			chamelium_require_connector_present(data.ports, DRM_MODE_CONNECTOR_VGA,
> -							    data.port_count, 1);
> -		}
> -
> -		igt_describe(test_basic_hotplug_desc);
> -		connector_subtest("vga-hpd", VGA)
> -			test_hotplug(&data, port, HPD_TOGGLE_COUNT_VGA,
> -				     TEST_MODESET_OFF);
> -
> -		igt_describe(test_basic_hotplug_desc);
> -		connector_subtest("vga-hpd-fast", VGA)
> -			test_hotplug(&data, port, HPD_TOGGLE_COUNT_FAST,
> -				     TEST_MODESET_OFF);
> -
> -		igt_describe(test_basic_hotplug_desc);
> -		connector_subtest("vga-hpd-enable-disable-mode", VGA)
> -			test_hotplug(&data, port,
> -				     HPD_TOGGLE_COUNT_FAST,
> -				     TEST_MODESET_ON_OFF);
> -
> -		igt_describe(test_basic_hotplug_desc);
> -		connector_subtest("vga-hpd-with-enabled-mode", VGA)
> -			test_hotplug(&data, port,
> -				     HPD_TOGGLE_COUNT_FAST,
> -				     TEST_MODESET_ON);
> -
> -		igt_describe(igt_custom_edid_type_read_desc);
> -		connector_subtest("vga-edid-read", VGA) {
> -			igt_custom_edid_type_read(&data, port, IGT_CUSTOM_EDID_BASE);
> -			igt_custom_edid_type_read(&data, port, IGT_CUSTOM_EDID_ALT);
> -		}
> -
> -		igt_describe(test_suspend_resume_hpd_desc);
> -		connector_subtest("vga-hpd-after-suspend", VGA)
> -			test_suspend_resume_hpd(&data, port,
> -						SUSPEND_STATE_MEM,
> -						SUSPEND_TEST_NONE);
> -
> -		igt_describe(test_suspend_resume_hpd_desc);
> -		connector_subtest("vga-hpd-after-hibernate", VGA)
> -			test_suspend_resume_hpd(&data, port,
> -						SUSPEND_STATE_DISK,
> -						SUSPEND_TEST_DEVICES);
> -
> -		igt_describe(test_hpd_without_ddc_desc);
> -		connector_subtest("vga-hpd-without-ddc", VGA)
> -			test_hpd_without_ddc(&data, port);
> -
> -		igt_describe(test_display_all_modes_desc);
> -		connector_subtest("vga-frame-dump", VGA)
> -			test_display_all_modes(&data, port, DRM_FORMAT_XRGB8888,
> -					       CHAMELIUM_CHECK_ANALOG, 1);
> -	}
> -
> -	igt_describe("Tests that operate on all connectors");
> -	igt_subtest_group {
> -
> -		igt_fixture {
> -			igt_require(data.port_count);
> -		}
> -
> -		igt_describe(test_suspend_resume_hpd_common_desc);
> -		igt_subtest("common-hpd-after-suspend")
> -			test_suspend_resume_hpd_common(&data,
> -						       SUSPEND_STATE_MEM,
> -						       SUSPEND_TEST_NONE);
> -
> -		igt_describe(test_suspend_resume_hpd_common_desc);
> -		igt_subtest("common-hpd-after-hibernate")
> -			test_suspend_resume_hpd_common(&data,
> -						       SUSPEND_STATE_DISK,
> -						       SUSPEND_TEST_DEVICES);
> -	}
> -
> -	igt_describe(test_hotplug_for_each_pipe_desc);
> -	connector_subtest("vga-hpd-for-each-pipe", VGA)
> -		test_hotplug_for_each_pipe(&data, port);
> -
> -	igt_fixture {
> -		igt_display_fini(&data.display);
> -		close(data.drm_fd);
> -	}
> -}
> diff --git a/tests/chamelium/kms_chamelium_audio.c b/tests/chamelium/kms_chamelium_audio.c
> new file mode 100644
> index 00000000..4d13744c
> --- /dev/null
> +++ b/tests/chamelium/kms_chamelium_audio.c
> @@ -0,0 +1,858 @@
> +// SPDX-License-Identifier: MIT
> +/*
> + * A Chamelium test for testing the Audio functionality.
> + *
> + * Copyright 2022 Google LLC.
> + *
> + * Authors: Mark Yacoub <markyacoub at chromium.org>
> + */
> +
> +#include "igt_eld.h"
> +#include "igt_infoframe.h"
> +#include "kms_chamelium_helper.h"
> +
> +/* Playback parameters control the audio signal we synthesize and send */
> +#define PLAYBACK_CHANNELS 2
> +#define PLAYBACK_SAMPLES 1024
> +
> +/* Capture paremeters control the audio signal we receive */
> +#define CAPTURE_SAMPLES 2048
> +
> +#define AUDIO_TIMEOUT 2000 /* ms */
> +/* A streak of 3 gives confidence that the signal is good. */
> +#define MIN_STREAK 3
> +
> +#define FLATLINE_AMPLITUDE 0.1 /* normalized, ie. in [0, 1] */
> +#define FLATLINE_AMPLITUDE_ACCURACY 0.001 /* ± 0.1 % of the full amplitude */
> +#define FLATLINE_ALIGN_ACCURACY 0 /* number of samples */
> +
> +struct audio_state {
> +	struct alsa *alsa;
> +	struct chamelium *chamelium;
> +	struct chamelium_port *port;
> +	struct chamelium_stream *stream;
> +
> +	/* The capture format is only available after capture has started. */
> +	struct {
> +		snd_pcm_format_t format;
> +		int channels;
> +		int rate;
> +	} playback, capture;
> +
> +	char *name;
> +	struct audio_signal *signal; /* for frequencies test only */
> +	int channel_mapping[CHAMELIUM_MAX_AUDIO_CHANNELS];
> +
> +	size_t recv_pages;
> +	int msec;
> +
> +	int dump_fd;
> +	char *dump_path;
> +
> +	pthread_t thread;
> +	atomic_bool run;
> +	atomic_bool positive; /* for pulse test only */
> +};
> +
> +/* TODO: enable >48KHz rates, these are not reliable */
> +static int test_sampling_rates[] = {
> +	32000, 44100, 48000,
> +	/* 88200, */
> +	/* 96000, */
> +	/* 176400, */
> +	/* 192000, */
> +};
> +
> +static int test_sampling_rates_count =
> +	sizeof(test_sampling_rates) / sizeof(int);
> +
> +/* Test frequencies (Hz): a sine signal will be generated for each.
> + *
> + * Depending on the sampling rate chosen, it might not be possible to properly
> + * detect the generated sine (see Nyquist–Shannon sampling theorem).
> + * Frequencies that can't be reliably detected will be automatically pruned in
> + * #audio_signal_add_frequency. For instance, the 80KHz frequency can only be
> + * tested with a 192KHz sampling rate.
> + */
> +static int test_frequencies[] = {
> +	300, 600, 1200, 10000, 80000,
> +};
> +
> +static int test_frequencies_count = sizeof(test_frequencies) / sizeof(int);
> +
> +static const snd_pcm_format_t test_formats[] = {
> +	SND_PCM_FORMAT_S16_LE,
> +	SND_PCM_FORMAT_S24_LE,
> +	SND_PCM_FORMAT_S32_LE,
> +};
> +
> +static const size_t test_formats_count =
> +	sizeof(test_formats) / sizeof(test_formats[0]);
> +
> +static void audio_state_init(struct audio_state *state, chamelium_data_t *data,
> +			     struct alsa *alsa, struct chamelium_port *port,
> +			     snd_pcm_format_t format, int channels, int rate)
> +{
> +	memset(state, 0, sizeof(*state));
> +	state->dump_fd = -1;
> +
> +	state->alsa = alsa;
> +	state->chamelium = data->chamelium;
> +	state->port = port;
> +
> +	state->playback.format = format;
> +	state->playback.channels = channels;
> +	state->playback.rate = rate;
> +
> +	alsa_configure_output(alsa, format, channels, rate);
> +
> +	state->stream = chamelium_stream_init();
> +	igt_assert_f(state->stream,
> +		     "Failed to initialize Chamelium stream client\n");
> +}
> +
> +static void audio_state_fini(struct audio_state *state)
> +{
> +	chamelium_stream_deinit(state->stream);
> +	free(state->name);
> +}
> +
> +static void *run_audio_thread(void *data)
> +{
> +	struct alsa *alsa = data;
> +
> +	alsa_run(alsa, -1);
> +	return NULL;
> +}
> +
> +static void audio_state_start(struct audio_state *state, const char *name)
> +{
> +	int ret;
> +	bool ok;
> +	size_t i, j;
> +	enum chamelium_stream_realtime_mode stream_mode;
> +	char dump_suffix[64];
> +
> +	free(state->name);
> +	state->name = strdup(name);
> +	state->recv_pages = 0;
> +	state->msec = 0;
> +
> +	igt_debug("Starting %s test with playback format %s, "
> +		  "sampling rate %d Hz and %d channels\n",
> +		  name, snd_pcm_format_name(state->playback.format),
> +		  state->playback.rate, state->playback.channels);
> +
> +	chamelium_start_capturing_audio(state->chamelium, state->port, false);
> +
> +	stream_mode = CHAMELIUM_STREAM_REALTIME_STOP_WHEN_OVERFLOW;
> +	ok = chamelium_stream_dump_realtime_audio(state->stream, stream_mode);
> +	igt_assert_f(ok, "Failed to start streaming audio capture\n");
> +
> +	/* Start playing audio */
> +	state->run = true;
> +	ret = pthread_create(&state->thread, NULL, run_audio_thread,
> +			     state->alsa);
> +	igt_assert_f(ret == 0, "Failed to start audio playback thread\n");
> +
> +	/* The Chamelium device only supports this PCM format. */
> +	state->capture.format = SND_PCM_FORMAT_S32_LE;
> +
> +	/* Only after we've started playing audio, we can retrieve the capture
> +	 * format used by the Chamelium device. */
> +	chamelium_get_audio_format(state->chamelium, state->port,
> +				   &state->capture.rate,
> +				   &state->capture.channels);
> +	if (state->capture.rate == 0) {
> +		igt_debug("Audio receiver doesn't indicate the capture "
> +			  "sampling rate, assuming it's %d Hz\n",
> +			  state->playback.rate);
> +		state->capture.rate = state->playback.rate;
> +	}
> +
> +	chamelium_get_audio_channel_mapping(state->chamelium, state->port,
> +					    state->channel_mapping);
> +	/* Make sure we can capture all channels we send. */
> +	for (i = 0; i < state->playback.channels; i++) {
> +		ok = false;
> +		for (j = 0; j < state->capture.channels; j++) {
> +			if (state->channel_mapping[j] == i) {
> +				ok = true;
> +				break;
> +			}
> +		}
> +		igt_assert_f(ok, "Cannot capture all channels\n");
> +	}
> +
> +	if (igt_frame_dump_is_enabled()) {
> +		snprintf(dump_suffix, sizeof(dump_suffix),
> +			 "capture-%s-%s-%dch-%dHz", name,
> +			 snd_pcm_format_name(state->playback.format),
> +			 state->playback.channels, state->playback.rate);
> +
> +		state->dump_fd = audio_create_wav_file_s32_le(
> +			dump_suffix, state->capture.rate,
> +			state->capture.channels, &state->dump_path);
> +		igt_assert_f(state->dump_fd >= 0,
> +			     "Failed to create audio dump file\n");
> +	}
> +}
> +
> +static void audio_state_receive(struct audio_state *state, int32_t **recv,
> +				size_t *recv_len)
> +{
> +	bool ok;
> +	size_t page_count;
> +	size_t recv_size;
> +
> +	ok = chamelium_stream_receive_realtime_audio(state->stream, &page_count,
> +						     recv, recv_len);
> +	igt_assert_f(ok, "Failed to receive audio from stream server\n");
> +
> +	state->msec = state->recv_pages * *recv_len /
> +		      (double)state->capture.channels /
> +		      (double)state->capture.rate * 1000;
> +	state->recv_pages++;
> +
> +	if (state->dump_fd >= 0) {
> +		recv_size = *recv_len * sizeof(int32_t);
> +		igt_assert_f(write(state->dump_fd, *recv, recv_size) ==
> +				     recv_size,
> +			     "Failed to write to audio dump file\n");
> +	}
> +}
> +
> +static void audio_state_stop(struct audio_state *state, bool success)
> +{
> +	bool ok;
> +	int ret;
> +	struct chamelium_audio_file *audio_file;
> +	enum igt_log_level log_level;
> +
> +	igt_debug("Stopping audio playback\n");
> +	state->run = false;
> +	ret = pthread_join(state->thread, NULL);
> +	igt_assert_f(ret == 0, "Failed to join audio playback thread\n");
> +
> +	ok = chamelium_stream_stop_realtime_audio(state->stream);
> +	igt_assert_f(ok, "Failed to stop streaming audio capture\n");
> +
> +	audio_file =
> +		chamelium_stop_capturing_audio(state->chamelium, state->port);
> +	if (audio_file) {
> +		igt_debug("Audio file saved on the Chamelium in %s\n",
> +			  audio_file->path);
> +		chamelium_destroy_audio_file(audio_file);
> +	}
> +
> +	if (state->dump_fd >= 0) {
> +		close(state->dump_fd);
> +		state->dump_fd = -1;
> +
> +		if (success) {
> +			/* Test succeeded, no need to keep the captured data */
> +			unlink(state->dump_path);
> +		} else
> +			igt_debug("Saved captured audio data to %s\n",
> +				  state->dump_path);
> +		free(state->dump_path);
> +		state->dump_path = NULL;
> +	}
> +
> +	if (success)
> +		log_level = IGT_LOG_DEBUG;
> +	else
> +		log_level = IGT_LOG_CRITICAL;
> +
> +	igt_log(IGT_LOG_DOMAIN, log_level,
> +		"Audio %s test result for format %s, "
> +		"sampling rate %d Hz and %d channels: %s\n",
> +		state->name, snd_pcm_format_name(state->playback.format),
> +		state->playback.rate, state->playback.channels,
> +		success ? "ALL GREEN" : "FAILED");
> +}
> +
> +static void check_audio_infoframe(struct audio_state *state)
> +{
> +	struct chamelium_infoframe *infoframe;
> +	struct infoframe_audio infoframe_audio;
> +	struct infoframe_audio expected = { 0 };
> +	bool ok;
> +
> +	if (!chamelium_supports_get_last_infoframe(state->chamelium)) {
> +		igt_debug("Skipping audio InfoFrame check: "
> +			  "Chamelium board doesn't support GetLastInfoFrame\n");
> +		return;
> +	}
> +
> +	expected.coding_type = INFOFRAME_AUDIO_CT_PCM;
> +	expected.channel_count = state->playback.channels;
> +	expected.sampling_freq = state->playback.rate;
> +	expected.sample_size = snd_pcm_format_width(state->playback.format);
> +
> +	infoframe = chamelium_get_last_infoframe(state->chamelium, state->port,
> +						 CHAMELIUM_INFOFRAME_AUDIO);
> +	if (infoframe == NULL && state->playback.channels <= 2) {
> +		/* Audio InfoFrames are optional for mono and stereo audio */
> +		igt_debug("Skipping audio InfoFrame check: "
> +			  "no InfoFrame received\n");
> +		return;
> +	}
> +	igt_assert_f(infoframe != NULL, "no audio InfoFrame received\n");
> +
> +	ok = infoframe_audio_parse(&infoframe_audio, infoframe->version,
> +				   infoframe->payload, infoframe->payload_size);
> +	chamelium_infoframe_destroy(infoframe);
> +	igt_assert_f(ok, "failed to parse audio InfoFrame\n");
> +
> +	igt_debug("Checking audio InfoFrame:\n");
> +	igt_debug("coding_type: got %d, expected %d\n",
> +		  infoframe_audio.coding_type, expected.coding_type);
> +	igt_debug("channel_count: got %d, expected %d\n",
> +		  infoframe_audio.channel_count, expected.channel_count);
> +	igt_debug("sampling_freq: got %d, expected %d\n",
> +		  infoframe_audio.sampling_freq, expected.sampling_freq);
> +	igt_debug("sample_size: got %d, expected %d\n",
> +		  infoframe_audio.sample_size, expected.sample_size);
> +
> +	if (infoframe_audio.coding_type != INFOFRAME_AUDIO_CT_UNSPECIFIED)
> +		igt_assert(infoframe_audio.coding_type == expected.coding_type);
> +	if (infoframe_audio.channel_count >= 0)
> +		igt_assert(infoframe_audio.channel_count ==
> +			   expected.channel_count);
> +	if (infoframe_audio.sampling_freq >= 0)
> +		igt_assert(infoframe_audio.sampling_freq ==
> +			   expected.sampling_freq);
> +	if (infoframe_audio.sample_size >= 0)
> +		igt_assert(infoframe_audio.sample_size == expected.sample_size);
> +}
> +
> +static int audio_output_frequencies_callback(void *data, void *buffer,
> +					     int samples)
> +{
> +	struct audio_state *state = data;
> +	double *tmp;
> +	size_t len;
> +
> +	len = samples * state->playback.channels;
> +	tmp = malloc(len * sizeof(double));
> +	audio_signal_fill(state->signal, tmp, samples);
> +	audio_convert_to(buffer, tmp, len, state->playback.format);
> +	free(tmp);
> +
> +	return state->run ? 0 : -1;
> +}
> +
> +static bool test_audio_frequencies(struct audio_state *state)
> +{
> +	int freq, step;
> +	int32_t *recv, *buf;
> +	double *channel;
> +	size_t i, j, streak;
> +	size_t recv_len, buf_len, buf_cap, channel_len;
> +	bool success;
> +	int capture_chan;
> +
> +	state->signal = audio_signal_init(state->playback.channels,
> +					  state->playback.rate);
> +	igt_assert_f(state->signal, "Failed to initialize audio signal\n");
> +
> +	/* We'll choose different frequencies per channel to make sure they are
> +	 * independent from each other. To do so, we'll add a different offset
> +	 * to the base frequencies for each channel. We need to choose a big
> +	 * enough offset so that we're sure to detect mixed up channels. We
> +	 * choose an offset of two 2 bins in the final FFT to enforce a clear
> +	 * difference.
> +	 *
> +	 * Note that we assume capture_rate == playback_rate. We'll assert this
> +	 * later on. We cannot retrieve the capture rate before starting
> +	 * playing audio, so we don't really have the choice.
> +	 */
> +	step = 2 * state->playback.rate / CAPTURE_SAMPLES;
> +	for (i = 0; i < test_frequencies_count; i++) {
> +		for (j = 0; j < state->playback.channels; j++) {
> +			freq = test_frequencies[i] + j * step;
> +			audio_signal_add_frequency(state->signal, freq, j);
> +		}
> +	}
> +	audio_signal_synthesize(state->signal);
> +
> +	alsa_register_output_callback(state->alsa,
> +				      audio_output_frequencies_callback, state,
> +				      PLAYBACK_SAMPLES);
> +
> +	audio_state_start(state, "frequencies");
> +
> +	igt_assert_f(state->capture.rate == state->playback.rate,
> +		     "Capture rate (%dHz) doesn't match playback rate (%dHz)\n",
> +		     state->capture.rate, state->playback.rate);
> +
> +	/* Needs to be a multiple of 128, because that's the number of samples
> +	 * we get per channel each time we receive an audio page from the
> +	 * Chamelium device.
> +	 *
> +	 * Additionally, this value needs to be high enough to guarantee we
> +	 * capture a full period of each sine we generate. If we capture 2048
> +	 * samples at a 192KHz sampling rate, we get a full period for a >94Hz
> +	 * sines. For lower sampling rates, the capture duration will be
> +	 * longer.
> +	 */
> +	channel_len = CAPTURE_SAMPLES;
> +	channel = malloc(sizeof(double) * channel_len);
> +
> +	buf_cap = state->capture.channels * channel_len;
> +	buf = malloc(sizeof(int32_t) * buf_cap);
> +	buf_len = 0;
> +
> +	recv = NULL;
> +	recv_len = 0;
> +
> +	success = false;
> +	streak = 0;
> +	while (!success && state->msec < AUDIO_TIMEOUT) {
> +		audio_state_receive(state, &recv, &recv_len);
> +
> +		memcpy(&buf[buf_len], recv, recv_len * sizeof(int32_t));
> +		buf_len += recv_len;
> +
> +		if (buf_len < buf_cap)
> +			continue;
> +		igt_assert(buf_len == buf_cap);
> +
> +		igt_debug("Detecting audio signal, t=%d msec\n", state->msec);
> +
> +		for (j = 0; j < state->playback.channels; j++) {
> +			capture_chan = state->channel_mapping[j];
> +			igt_assert(capture_chan >= 0);
> +			igt_debug("Processing channel %zu (captured as "
> +				  "channel %d)\n",
> +				  j, capture_chan);
> +
> +			audio_extract_channel_s32_le(channel, channel_len, buf,
> +						     buf_len,
> +						     state->capture.channels,
> +						     capture_chan);
> +
> +			if (audio_signal_detect(state->signal,
> +						state->capture.rate, j, channel,
> +						channel_len))
> +				streak++;
> +			else
> +				streak = 0;
> +		}
> +
> +		buf_len = 0;
> +
> +		success = streak == MIN_STREAK * state->playback.channels;
> +	}
> +
> +	audio_state_stop(state, success);
> +
> +	free(recv);
> +	free(buf);
> +	free(channel);
> +	audio_signal_fini(state->signal);
> +
> +	check_audio_infoframe(state);
> +
> +	return success;
> +}
> +
> +static int audio_output_flatline_callback(void *data, void *buffer, int samples)
> +{
> +	struct audio_state *state = data;
> +	double *tmp;
> +	size_t len, i;
> +
> +	len = samples * state->playback.channels;
> +	tmp = malloc(len * sizeof(double));
> +	for (i = 0; i < len; i++)
> +		tmp[i] = (state->positive ? 1 : -1) * FLATLINE_AMPLITUDE;
> +	audio_convert_to(buffer, tmp, len, state->playback.format);
> +	free(tmp);
> +
> +	return state->run ? 0 : -1;
> +}
> +
> +static bool detect_flatline_amplitude(double *buf, size_t buf_len, bool pos)
> +{
> +	double expected, min, max;
> +	size_t i;
> +	bool ok;
> +
> +	min = max = NAN;
> +	for (i = 0; i < buf_len; i++) {
> +		if (isnan(min) || buf[i] < min)
> +			min = buf[i];
> +		if (isnan(max) || buf[i] > max)
> +			max = buf[i];
> +	}
> +
> +	expected = (pos ? 1 : -1) * FLATLINE_AMPLITUDE;
> +	ok = (min >= expected - FLATLINE_AMPLITUDE_ACCURACY &&
> +	      max <= expected + FLATLINE_AMPLITUDE_ACCURACY);
> +	if (ok)
> +		igt_debug("Flatline wave amplitude detected\n");
> +	else
> +		igt_debug("Flatline amplitude not detected (min=%f, max=%f)\n",
> +			  min, max);
> +	return ok;
> +}
> +
> +static ssize_t detect_falling_edge(double *buf, size_t buf_len)
> +{
> +	size_t i;
> +
> +	for (i = 0; i < buf_len; i++) {
> +		if (buf[i] < 0)
> +			return i;
> +	}
> +
> +	return -1;
> +}
> +
> +/** test_audio_flatline:
> + *
> + * Send a constant value (one positive, then a negative one) and check that:
> + *
> + * - The amplitude of the flatline is correct
> + * - All channels switch from a positive signal to a negative one at the same
> + *   time (ie. all channels are aligned)
> + */
> +static bool test_audio_flatline(struct audio_state *state)
> +{
> +	bool success, amp_success, align_success;
> +	int32_t *recv;
> +	size_t recv_len, i, channel_len;
> +	ssize_t j;
> +	int streak, capture_chan;
> +	double *channel;
> +	int falling_edges[CHAMELIUM_MAX_AUDIO_CHANNELS];
> +
> +	alsa_register_output_callback(state->alsa,
> +				      audio_output_flatline_callback, state,
> +				      PLAYBACK_SAMPLES);
> +
> +	/* Start by sending a positive signal */
> +	state->positive = true;
> +
> +	audio_state_start(state, "flatline");
> +
> +	for (i = 0; i < state->playback.channels; i++)
> +		falling_edges[i] = -1;
> +
> +	recv = NULL;
> +	recv_len = 0;
> +	amp_success = false;
> +	streak = 0;
> +	while (!amp_success && state->msec < AUDIO_TIMEOUT) {
> +		audio_state_receive(state, &recv, &recv_len);
> +
> +		igt_debug("Detecting audio signal, t=%d msec\n", state->msec);
> +
> +		for (i = 0; i < state->playback.channels; i++) {
> +			capture_chan = state->channel_mapping[i];
> +			igt_assert(capture_chan >= 0);
> +			igt_debug("Processing channel %zu (captured as "
> +				  "channel %d)\n",
> +				  i, capture_chan);
> +
> +			channel_len = audio_extract_channel_s32_le(
> +				NULL, 0, recv, recv_len,
> +				state->capture.channels, capture_chan);
> +			channel = malloc(channel_len * sizeof(double));
> +			audio_extract_channel_s32_le(channel, channel_len, recv,
> +						     recv_len,
> +						     state->capture.channels,
> +						     capture_chan);
> +
> +			/* Check whether the amplitude is fine */
> +			if (detect_flatline_amplitude(channel, channel_len,
> +						      state->positive))
> +				streak++;
> +			else
> +				streak = 0;
> +
> +			/* If we're now sending a negative signal, detect the
> +			 * falling edge */
> +			j = detect_falling_edge(channel, channel_len);
> +			if (!state->positive && j >= 0) {
> +				falling_edges[i] =
> +					recv_len * state->recv_pages + j;
> +			}
> +
> +			free(channel);
> +		}
> +
> +		amp_success = streak == MIN_STREAK * state->playback.channels;
> +
> +		if (amp_success && state->positive) {
> +			/* Switch to a negative signal after we've detected the
> +			 * positive one. */
> +			state->positive = false;
> +			amp_success = false;
> +			streak = 0;
> +			igt_debug("Switching to negative square wave\n");
> +		}
> +	}
> +
> +	/* Check alignment between all channels by comparing the index of the
> +	 * falling edge. */
> +	align_success = true;
> +	for (i = 0; i < state->playback.channels; i++) {
> +		if (falling_edges[i] < 0) {
> +			igt_critical(
> +				"Falling edge not detected for channel %zu\n",
> +				i);
> +			align_success = false;
> +			continue;
> +		}
> +
> +		if (abs(falling_edges[0] - falling_edges[i]) >
> +		    FLATLINE_ALIGN_ACCURACY) {
> +			igt_critical("Channel alignment mismatch: "
> +				     "channel 0 has a falling edge at index %d "
> +				     "while channel %zu has index %d\n",
> +				     falling_edges[0], i, falling_edges[i]);
> +			align_success = false;
> +		}
> +	}
> +
> +	success = amp_success && align_success;
> +	audio_state_stop(state, success);
> +
> +	free(recv);
> +
> +	return success;
> +}
> +
> +static bool check_audio_configuration(struct alsa *alsa,
> +				      snd_pcm_format_t format, int channels,
> +				      int sampling_rate)
> +{
> +	if (!alsa_test_output_configuration(alsa, format, channels,
> +					    sampling_rate)) {
> +		igt_debug("Skipping test with format %s, sampling rate %d Hz "
> +			  "and %d channels because at least one of the "
> +			  "selected output devices doesn't support this "
> +			  "configuration\n",
> +			  snd_pcm_format_name(format), sampling_rate, channels);
> +		return false;
> +	}
> +	/* TODO: the Chamelium device sends a malformed signal for some audio
> +	 * configurations. See crbug.com/950917 */
> +	if ((format != SND_PCM_FORMAT_S16_LE && sampling_rate >= 44100) ||
> +	    channels > 2) {
> +		igt_debug("Skipping test with format %s, sampling rate %d Hz "
> +			  "and %d channels because the Chamelium device "
> +			  "doesn't support this configuration\n",
> +			  snd_pcm_format_name(format), sampling_rate, channels);
> +		return false;
> +	}
> +	return true;
> +}
> +
> +static const char test_display_audio_desc[] =
> +	"Playback various audio signals with various audio formats/rates, "
> +	"capture them and check they are correct";
> +static void test_display_audio(chamelium_data_t *data,
> +			       struct chamelium_port *port,
> +			       const char *audio_device,
> +			       enum igt_custom_edid_type edid)
> +{
> +	bool run, success;
> +	struct alsa *alsa;
> +	int ret;
> +	igt_output_t *output;
> +	igt_plane_t *primary;
> +	struct igt_fb fb;
> +	drmModeModeInfo *mode;
> +	drmModeConnector *connector;
> +	int fb_id, i, j;
> +	int channels, sampling_rate;
> +	snd_pcm_format_t format;
> +	struct audio_state state;
> +
> +	igt_require(alsa_has_exclusive_access());
> +
> +	/* Old Chamelium devices need an update for DisplayPort audio and
> +	 * chamelium_get_audio_format support. */
> +	igt_require(chamelium_has_audio_support(data->chamelium, port));
> +
> +	alsa = alsa_init();
> +	igt_assert(alsa);
> +
> +	igt_modeset_disable_all_outputs(&data->display);
> +	chamelium_reset_state(&data->display, data->chamelium, port,
> +			      data->ports, data->port_count);
> +
> +	output = chamelium_prepare_output(data, port, edid);
> +	connector = chamelium_port_get_connector(data->chamelium, port, false);
> +	primary = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY);
> +	igt_assert(primary);
> +
> +	/* Enable the output because the receiver won't try to receive audio if
> +	 * it doesn't receive video. */
> +	igt_assert(connector->count_modes > 0);
> +	mode = &connector->modes[0];
> +
> +	fb_id = igt_create_color_pattern_fb(data->drm_fd, mode->hdisplay,
> +					    mode->vdisplay, DRM_FORMAT_XRGB8888,
> +					    DRM_FORMAT_MOD_LINEAR, 0, 0, 0,
> +					    &fb);
> +	igt_assert(fb_id > 0);
> +
> +	chamelium_enable_output(data, port, output, mode, &fb);
> +
> +	run = false;
> +	success = true;
> +	for (i = 0; i < test_sampling_rates_count; i++) {
> +		for (j = 0; j < test_formats_count; j++) {
> +			ret = alsa_open_output(alsa, audio_device);
> +			igt_assert_f(ret >= 0, "Failed to open ALSA output\n");
> +
> +			/* TODO: playback on all 8 available channels (this
> +			 * isn't supported by Chamelium devices yet, see
> +			 * https://crbug.com/950917) */
> +			format = test_formats[j];
> +			channels = PLAYBACK_CHANNELS;
> +			sampling_rate = test_sampling_rates[i];
> +
> +			if (!check_audio_configuration(alsa, format, channels,
> +						       sampling_rate))
> +				continue;
> +
> +			run = true;
> +
> +			audio_state_init(&state, data, alsa, port, format,
> +					 channels, sampling_rate);
> +			success &= test_audio_frequencies(&state);
> +			success &= test_audio_flatline(&state);
> +			audio_state_fini(&state);
> +
> +			alsa_close_output(alsa);
> +		}
> +	}
> +
> +	/* Make sure we tested at least one frequency and format. */
> +	igt_assert(run);
> +	/* Make sure all runs were successful. */
> +	igt_assert(success);
> +
> +	igt_remove_fb(data->drm_fd, &fb);
> +
> +	drmModeFreeConnector(connector);
> +
> +	free(alsa);
> +}
> +
> +static const char test_display_audio_edid_desc[] =
> +	"Plug a connector with an EDID suitable for audio, check ALSA's "
> +	"EDID-Like Data reports the correct audio parameters";
> +static void test_display_audio_edid(chamelium_data_t *data,
> +				    struct chamelium_port *port,
> +				    enum igt_custom_edid_type edid)
> +{
> +	igt_output_t *output;
> +	igt_plane_t *primary;
> +	struct igt_fb fb;
> +	drmModeModeInfo *mode;
> +	drmModeConnector *connector;
> +	int fb_id;
> +	struct eld_entry eld;
> +	struct eld_sad *sad;
> +
> +	igt_require(eld_is_supported());
> +
> +	igt_modeset_disable_all_outputs(&data->display);
> +	chamelium_reset_state(&data->display, data->chamelium, port,
> +			      data->ports, data->port_count);
> +
> +	output = chamelium_prepare_output(data, port, edid);
> +	connector = chamelium_port_get_connector(data->chamelium, port, false);
> +	primary = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY);
> +	igt_assert(primary);
> +
> +	/* Enable the output because audio cannot be played on inactive
> +	 * connectors. */
> +	igt_assert(connector->count_modes > 0);
> +	mode = &connector->modes[0];
> +
> +	fb_id = igt_create_color_pattern_fb(data->drm_fd, mode->hdisplay,
> +					    mode->vdisplay, DRM_FORMAT_XRGB8888,
> +					    DRM_FORMAT_MOD_LINEAR, 0, 0, 0,
> +					    &fb);
> +	igt_assert(fb_id > 0);
> +
> +	chamelium_enable_output(data, port, output, mode, &fb);
> +
> +	igt_assert(eld_get_igt(&eld));
> +	igt_assert(eld.sads_len == 1);
> +
> +	sad = &eld.sads[0];
> +	igt_assert(sad->coding_type == CEA_SAD_FORMAT_PCM);
> +	igt_assert(sad->channels == 2);
> +	igt_assert(sad->rates ==
> +		   (CEA_SAD_SAMPLING_RATE_32KHZ | CEA_SAD_SAMPLING_RATE_44KHZ |
> +		    CEA_SAD_SAMPLING_RATE_48KHZ));
> +	igt_assert(sad->bits ==
> +		   (CEA_SAD_SAMPLE_SIZE_16 | CEA_SAD_SAMPLE_SIZE_20 |
> +		    CEA_SAD_SAMPLE_SIZE_24));
> +
> +	igt_remove_fb(data->drm_fd, &fb);
> +
> +	drmModeFreeConnector(connector);
> +}
> +
> +IGT_TEST_DESCRIPTION("Testing Audio with a Chamelium board");
> +igt_main
> +{
> +	chamelium_data_t data;
> +	struct chamelium_port *port;
> +	int p;
> +
> +	igt_fixture {
> +		chamelium_init_test(&data);
> +	}
> +
> +	igt_describe("DisplayPort tests");
> +	igt_subtest_group {
> +		igt_fixture {
> +			chamelium_require_connector_present(
> +				data.ports, DRM_MODE_CONNECTOR_DisplayPort,
> +				data.port_count, 1);
> +		}
> +
> +		igt_describe(test_display_audio_desc);
> +		connector_subtest("dp-audio", DisplayPort) test_display_audio(
> +			&data, port, "HDMI", IGT_CUSTOM_EDID_DP_AUDIO);
> +
> +		igt_describe(test_display_audio_edid_desc);
> +		connector_subtest("dp-audio-edid", DisplayPort)
> +			test_display_audio_edid(&data, port,
> +						IGT_CUSTOM_EDID_DP_AUDIO);
> +	}
> +
> +	igt_describe("HDMI tests");
> +	igt_subtest_group {
> +		igt_fixture {
> +			chamelium_require_connector_present(
> +				data.ports, DRM_MODE_CONNECTOR_HDMIA,
> +				data.port_count, 1);
> +		}
> +
> +		igt_describe(test_display_audio_desc);
> +		connector_subtest("hdmi-audio", HDMIA) test_display_audio(
> +			&data, port, "HDMI", IGT_CUSTOM_EDID_HDMI_AUDIO);
> +
> +		igt_describe(test_display_audio_edid_desc);
> +		connector_subtest("hdmi-audio-edid", HDMIA)
> +			test_display_audio_edid(&data, port,
> +						IGT_CUSTOM_EDID_HDMI_AUDIO);
> +	}
> +
> +	igt_fixture {
> +		igt_display_fini(&data.display);
> +		close(data.drm_fd);
> +	}
> +}
> diff --git a/tests/chamelium/kms_color_chamelium.c b/tests/chamelium/kms_chamelium_color.c
> similarity index 100%
> rename from tests/chamelium/kms_color_chamelium.c
> rename to tests/chamelium/kms_chamelium_color.c
> diff --git a/tests/chamelium/kms_chamelium_edid.c b/tests/chamelium/kms_chamelium_edid.c
> new file mode 100644
> index 00000000..c9e15f41
> --- /dev/null
> +++ b/tests/chamelium/kms_chamelium_edid.c
> @@ -0,0 +1,543 @@
> +// SPDX-License-Identifier: MIT
> +/*
> + * A Chamelium test for testing the EDID functionality.
> + *
> + * Copyright 2022 Google LLC.
> + *
> + * Authors: Mark Yacoub <markyacoub at chromium.org>
> + */
> +
> +#include <fcntl.h>
> +#include <stdint.h>
> +#include <string.h>
> +#include <stdatomic.h>
> +#include <xf86drmMode.h>
> +
> +#include "config.h"
> +#include "igt.h"
> +#include "igt_chamelium.h"
> +#include "igt_edid.h"
> +#include "igt_eld.h"
> +#include "igt_vc4.h"
> +#include "igt_infoframe.h"
> +#include "kms_chamelium_helper.h"
> +#include "monitor_edids/dp_edids.h"
> +#include "monitor_edids/hdmi_edids.h"
> +#include "monitor_edids/monitor_edids_helper.h"
> +
> +#define MODE_CLOCK_ACCURACY 0.05 /* 5% */
> +
> +static void get_connectors_link_status_failed(chamelium_data_t *data,
> +					      bool *link_status_failed)
> +{
> +	drmModeConnector *connector;
> +	uint64_t link_status;
> +	drmModePropertyPtr prop;
> +	int p;
> +
> +	for (p = 0; p < data->port_count; p++) {
> +		connector = chamelium_port_get_connector(data->chamelium,
> +							 data->ports[p], false);
> +
> +		igt_assert(kmstest_get_property(
> +			data->drm_fd, connector->connector_id,
> +			DRM_MODE_OBJECT_CONNECTOR, "link-status", NULL,
> +			&link_status, &prop));
> +
> +		link_status_failed[p] = link_status == DRM_MODE_LINK_STATUS_BAD;
> +
> +		drmModeFreeProperty(prop);
> +		drmModeFreeConnector(connector);
> +	}
> +}
> +
> +static void check_mode(struct chamelium *chamelium, struct chamelium_port *port,
> +		       drmModeModeInfo *mode)
> +{
> +	struct chamelium_video_params video_params = { 0 };
> +	double mode_clock;
> +	int mode_hsync_offset, mode_vsync_offset;
> +	int mode_hsync_width, mode_vsync_width;
> +	int mode_hsync_polarity, mode_vsync_polarity;
> +
> +	chamelium_port_get_video_params(chamelium, port, &video_params);
> +
> +	mode_clock = (double)mode->clock / 1000;
> +
> +	if (chamelium_port_get_type(port) == DRM_MODE_CONNECTOR_DisplayPort) {
> +		/* this is what chamelium understands as offsets for DP */
> +		mode_hsync_offset = mode->htotal - mode->hsync_start;
> +		mode_vsync_offset = mode->vtotal - mode->vsync_start;
> +	} else {
> +		/* and this is what they are for other connectors */
> +		mode_hsync_offset = mode->hsync_start - mode->hdisplay;
> +		mode_vsync_offset = mode->vsync_start - mode->vdisplay;
> +	}
> +
> +	mode_hsync_width = mode->hsync_end - mode->hsync_start;
> +	mode_vsync_width = mode->vsync_end - mode->vsync_start;
> +
> +	mode_hsync_polarity = !!(mode->flags & DRM_MODE_FLAG_PHSYNC);
> +	mode_vsync_polarity = !!(mode->flags & DRM_MODE_FLAG_PVSYNC);
> +
> +	igt_debug("Checking video mode:\n");
> +	igt_debug("clock: got %f, expected %f ± %f%%\n", video_params.clock,
> +		  mode_clock, MODE_CLOCK_ACCURACY * 100);
> +	igt_debug("hactive: got %d, expected %d\n", video_params.hactive,
> +		  mode->hdisplay);
> +	igt_debug("vactive: got %d, expected %d\n", video_params.vactive,
> +		  mode->vdisplay);
> +	igt_debug("hsync_offset: got %d, expected %d\n",
> +		  video_params.hsync_offset, mode_hsync_offset);
> +	igt_debug("vsync_offset: got %d, expected %d\n",
> +		  video_params.vsync_offset, mode_vsync_offset);
> +	igt_debug("htotal: got %d, expected %d\n", video_params.htotal,
> +		  mode->htotal);
> +	igt_debug("vtotal: got %d, expected %d\n", video_params.vtotal,
> +		  mode->vtotal);
> +	igt_debug("hsync_width: got %d, expected %d\n",
> +		  video_params.hsync_width, mode_hsync_width);
> +	igt_debug("vsync_width: got %d, expected %d\n",
> +		  video_params.vsync_width, mode_vsync_width);
> +	igt_debug("hsync_polarity: got %d, expected %d\n",
> +		  video_params.hsync_polarity, mode_hsync_polarity);
> +	igt_debug("vsync_polarity: got %d, expected %d\n",
> +		  video_params.vsync_polarity, mode_vsync_polarity);
> +
> +	if (!isnan(video_params.clock)) {
> +		igt_assert(video_params.clock >
> +			   mode_clock * (1 - MODE_CLOCK_ACCURACY));
> +		igt_assert(video_params.clock <
> +			   mode_clock * (1 + MODE_CLOCK_ACCURACY));
> +	}
> +	igt_assert(video_params.hactive == mode->hdisplay);
> +	igt_assert(video_params.vactive == mode->vdisplay);
> +	igt_assert(video_params.hsync_offset == mode_hsync_offset);
> +	igt_assert(video_params.vsync_offset == mode_vsync_offset);
> +	igt_assert(video_params.htotal == mode->htotal);
> +	igt_assert(video_params.vtotal == mode->vtotal);
> +	igt_assert(video_params.hsync_width == mode_hsync_width);
> +	igt_assert(video_params.vsync_width == mode_vsync_width);
> +	igt_assert(video_params.hsync_polarity == mode_hsync_polarity);
> +	igt_assert(video_params.vsync_polarity == mode_vsync_polarity);
> +}
> +
> +static const char igt_custom_edid_type_read_desc[] =
> +	"Make sure the EDID exposed by KMS is the same as the screen's";
> +static void igt_custom_edid_type_read(chamelium_data_t *data,
> +				      struct chamelium_port *port,
> +				      enum igt_custom_edid_type edid)
> +{
> +	drmModePropertyBlobPtr edid_blob = NULL;
> +	drmModeConnector *connector;
> +	size_t raw_edid_size;
> +	const struct edid *raw_edid;
> +	uint64_t edid_blob_id;
> +
> +	igt_modeset_disable_all_outputs(&data->display);
> +	chamelium_reset_state(&data->display, data->chamelium, port,
> +			      data->ports, data->port_count);
> +
> +	chamelium_set_edid(data, port, edid);
> +	chamelium_plug(data->chamelium, port);
> +	chamelium_wait_for_conn_status_change(&data->display, data->chamelium,
> +					      port, DRM_MODE_CONNECTED);
> +
> +	igt_skip_on(chamelium_check_analog_bridge(data, port));
> +
> +	connector = chamelium_port_get_connector(data->chamelium, port, true);
> +	igt_assert(kmstest_get_property(data->drm_fd, connector->connector_id,
> +					DRM_MODE_OBJECT_CONNECTOR, "EDID", NULL,
> +					&edid_blob_id, NULL));
> +	igt_assert(edid_blob_id != 0);
> +	edid_blob = drmModeGetPropertyBlob(data->drm_fd, edid_blob_id);
> +	igt_assert(edid_blob);
> +
> +	raw_edid = chamelium_edid_get_raw(data->edids[edid], port);
> +	raw_edid_size = edid_get_size(raw_edid);
> +	igt_assert(memcmp(raw_edid, edid_blob->data, raw_edid_size) == 0);
> +
> +	drmModeFreePropertyBlob(edid_blob);
> +	drmModeFreeConnector(connector);
> +}
> +
> +static const char igt_edid_stress_resolution_desc[] =
> +	"Stress test the DUT by testing multiple EDIDs, one right after the other,"
> +	"and ensure their validity by check the real screen resolution vs the"
> +	"advertised mode resultion.";
> +static void edid_stress_resolution(chamelium_data_t *data,
> +				   struct chamelium_port *port,
> +				   monitor_edid edids_list[],
> +				   size_t edids_list_len)
> +{
> +	int i;
> +	struct chamelium *chamelium = data->chamelium;
> +	struct udev_monitor *mon = igt_watch_uevents();
> +
> +	for (i = 0; i < edids_list_len; ++i) {
> +		struct chamelium_edid *chamelium_edid;
> +		drmModeModeInfo mode;
> +		struct igt_fb fb = { 0 };
> +		igt_output_t *output;
> +		enum pipe pipe;
> +		bool is_video_stable;
> +		int screen_res_w, screen_res_h;
> +
> +		monitor_edid *edid = &edids_list[i];
> +		igt_info("Testing out the EDID for %s\n",
> +			 monitor_edid_get_name(edid));
> +
> +		/* Getting and Setting the EDID on Chamelium. */
> +		chamelium_edid =
> +			get_chameleon_edid_from_monitor_edid(chamelium, edid);
> +		chamelium_port_set_edid(data->chamelium, port, chamelium_edid);
> +		free_chamelium_edid_from_monitor_edid(chamelium_edid);
> +
> +		igt_flush_uevents(mon);
> +		chamelium_plug(chamelium, port);
> +		chamelium_wait_for_connector_after_hotplug(data, mon, port,
> +							   DRM_MODE_CONNECTED);
> +		igt_flush_uevents(mon);
> +
> +		/* Setting an output on the screen to turn it on. */
> +		mode = chamelium_get_mode_for_port(chamelium, port);
> +		chamelium_create_fb_for_mode(data, &fb, &mode);
> +		output = chamelium_get_output_for_port(data, port);
> +		pipe = chamelium_get_pipe_for_output(&data->display, output);
> +		igt_output_set_pipe(output, pipe);
> +		chamelium_enable_output(data, port, output, &mode, &fb);
> +
> +		/* Capture the screen resolution and verify. */
> +		is_video_stable = chamelium_port_wait_video_input_stable(
> +			chamelium, port, 5);
> +		igt_assert(is_video_stable);
> +
> +		chamelium_port_get_resolution(chamelium, port, &screen_res_w,
> +					      &screen_res_h);
> +		igt_assert(screen_res_w == fb.width);
> +		igt_assert(screen_res_h == fb.height);
> +
> +		// Clean up
> +		igt_remove_fb(data->drm_fd, &fb);
> +		igt_modeset_disable_all_outputs(&data->display);
> +		chamelium_unplug(chamelium, port);
> +	}
> +
> +	chamelium_reset_state(&data->display, data->chamelium, port,
> +			      data->ports, data->port_count);
> +}
> +
> +static const char igt_edid_resolution_list_desc[] =
> +	"Get an EDID with many modes of different configurations, set them on the screen and check the"
> +	" screen resolution matches the mode resolution.";
> +
> +static void edid_resolution_list(chamelium_data_t *data,
> +				 struct chamelium_port *port)
> +{
> +	struct chamelium *chamelium = data->chamelium;
> +	struct udev_monitor *mon = igt_watch_uevents();
> +	drmModeConnector *connector;
> +	drmModeModeInfoPtr modes;
> +	int count_modes;
> +	int i;
> +	igt_output_t *output;
> +	enum pipe pipe;
> +
> +	chamelium_unplug(chamelium, port);
> +	chamelium_set_edid(data, port, IGT_CUSTOM_EDID_FULL);
> +
> +	igt_flush_uevents(mon);
> +	chamelium_plug(chamelium, port);
> +	chamelium_wait_for_connector_after_hotplug(data, mon, port,
> +						   DRM_MODE_CONNECTED);
> +	igt_flush_uevents(mon);
> +
> +	connector = chamelium_port_get_connector(chamelium, port, true);
> +	modes = connector->modes;
> +	count_modes = connector->count_modes;
> +
> +	output = chamelium_get_output_for_port(data, port);
> +	pipe = chamelium_get_pipe_for_output(&data->display, output);
> +	igt_output_set_pipe(output, pipe);
> +
> +	for (i = 0; i < count_modes; ++i)
> +		igt_debug("#%d %s %uHz\n", i, modes[i].name, modes[i].vrefresh);
> +
> +	for (i = 0; i < count_modes; ++i) {
> +		struct igt_fb fb = { 0 };
> +		bool is_video_stable;
> +		int screen_res_w, screen_res_h;
> +
> +		igt_info("Testing #%d %s %uHz\n", i, modes[i].name,
> +			 modes[i].vrefresh);
> +
> +		/* Set the screen mode with the one we chose. */
> +		chamelium_create_fb_for_mode(data, &fb, &modes[i]);
> +		chamelium_enable_output(data, port, output, &modes[i], &fb);
> +		is_video_stable = chamelium_port_wait_video_input_stable(
> +			chamelium, port, 10);
> +		igt_assert(is_video_stable);
> +
> +		chamelium_port_get_resolution(chamelium, port, &screen_res_w,
> +					      &screen_res_h);
> +		igt_assert_eq(screen_res_w, modes[i].hdisplay);
> +		igt_assert_eq(screen_res_h, modes[i].vdisplay);
> +
> +		igt_remove_fb(data->drm_fd, &fb);
> +	}
> +
> +	igt_modeset_disable_all_outputs(&data->display);
> +	drmModeFreeConnector(connector);
> +}
> +
> +static const char test_suspend_resume_edid_change_desc[] =
> +	"Simulate a screen being unplugged and another screen being plugged "
> +	"during suspend, check that a uevent is sent and connector status is "
> +	"updated";
> +static void test_suspend_resume_edid_change(chamelium_data_t *data,
> +					    struct chamelium_port *port,
> +					    enum igt_suspend_state state,
> +					    enum igt_suspend_test test,
> +					    enum igt_custom_edid_type edid,
> +					    enum igt_custom_edid_type alt_edid)
> +{
> +	struct udev_monitor *mon = igt_watch_uevents();
> +	bool link_status_failed[2][data->port_count];
> +	int p;
> +
> +	igt_modeset_disable_all_outputs(&data->display);
> +	chamelium_reset_state(&data->display, data->chamelium, port,
> +			      data->ports, data->port_count);
> +
> +	/* Catch the event and flush all remaining ones. */
> +	igt_assert(igt_hotplug_detected(mon, CHAMELIUM_HOTPLUG_TIMEOUT));
> +	igt_flush_uevents(mon);
> +
> +	/* First plug in the port */
> +	chamelium_set_edid(data, port, edid);
> +	chamelium_plug(data->chamelium, port);
> +	igt_assert(igt_hotplug_detected(mon, CHAMELIUM_HOTPLUG_TIMEOUT));
> +
> +	chamelium_wait_for_conn_status_change(&data->display, data->chamelium,
> +					      port, DRM_MODE_CONNECTED);
> +
> +	/*
> +	 * Change the edid before we suspend. On resume, the machine should
> +	 * notice the EDID change and fire a hotplug event.
> +	 */
> +	chamelium_set_edid(data, port, alt_edid);
> +
> +	get_connectors_link_status_failed(data, link_status_failed[0]);
> +
> +	igt_flush_uevents(mon);
> +
> +	igt_system_suspend_autoresume(state, test);
> +	igt_assert(igt_hotplug_detected(mon, CHAMELIUM_HOTPLUG_TIMEOUT));
> +	chamelium_assert_reachable(data->chamelium, ONLINE_TIMEOUT);
> +
> +	get_connectors_link_status_failed(data, link_status_failed[1]);
> +
> +	for (p = 0; p < data->port_count; p++)
> +		igt_skip_on(!link_status_failed[0][p] &&
> +			    link_status_failed[1][p]);
> +}
> +
> +static const char test_mode_timings_desc[] =
> +	"For each mode of the IGT base EDID, perform a modeset and check the "
> +	"mode detected by the Chamelium receiver matches the mode we set";
> +static void test_mode_timings(chamelium_data_t *data,
> +			      struct chamelium_port *port)
> +{
> +	int i, count_modes;
> +
> +	i = 0;
> +	igt_require(chamelium_supports_get_video_params(data->chamelium));
> +	do {
> +		igt_output_t *output;
> +		igt_plane_t *primary;
> +		drmModeConnector *connector;
> +		drmModeModeInfo *mode;
> +		int fb_id;
> +		struct igt_fb fb;
> +
> +		/*
> +		 * let's reset state each mode so we will get the
> +		 * HPD pulses realibably
> +		 */
> +		igt_modeset_disable_all_outputs(&data->display);
> +		chamelium_reset_state(&data->display, data->chamelium, port,
> +				      data->ports, data->port_count);
> +
> +		/*
> +		 * modes may change due to mode pruining and link issues, so we
> +		 * need to refresh the connector
> +		 */
> +		output = chamelium_prepare_output(data, port,
> +						  IGT_CUSTOM_EDID_BASE);
> +		connector = chamelium_port_get_connector(data->chamelium, port,
> +							 false);
> +		primary = igt_output_get_plane_type(output,
> +						    DRM_PLANE_TYPE_PRIMARY);
> +		igt_assert(primary);
> +
> +		/* we may skip some modes due to above but that's ok */
> +		count_modes = connector->count_modes;
> +		if (i >= count_modes)
> +			break;
> +
> +		mode = &connector->modes[i];
> +
> +		fb_id = igt_create_color_pattern_fb(
> +			data->drm_fd, mode->hdisplay, mode->vdisplay,
> +			DRM_FORMAT_XRGB8888, DRM_FORMAT_MOD_LINEAR, 0, 0, 0,
> +			&fb);
> +		igt_assert(fb_id > 0);
> +
> +		chamelium_enable_output(data, port, output, mode, &fb);
> +
> +		/* Trigger the FSM */
> +		chamelium_capture(data->chamelium, port, 0, 0, 0, 0, 0);
> +
> +		check_mode(data->chamelium, port, mode);
> +
> +		igt_remove_fb(data->drm_fd, &fb);
> +		drmModeFreeConnector(connector);
> +	} while (++i < count_modes);
> +}
> +
> +IGT_TEST_DESCRIPTION("Testing EDID with a Chamelium board");
> +igt_main
> +{
> +	chamelium_data_t data;
> +	struct chamelium_port *port;
> +	int p;
> +
> +	igt_fixture {
> +		chamelium_init_test(&data);
> +	}
> +
> +	igt_describe("DisplayPort tests");
> +	igt_subtest_group {
> +		igt_fixture {
> +			chamelium_require_connector_present(
> +				data.ports, DRM_MODE_CONNECTOR_DisplayPort,
> +				data.port_count, 1);
> +		}
> +
> +		igt_describe(igt_custom_edid_type_read_desc);
> +		connector_subtest("dp-edid-read", DisplayPort)
> +		{
> +			igt_custom_edid_type_read(&data, port,
> +						  IGT_CUSTOM_EDID_BASE);
> +			igt_custom_edid_type_read(&data, port,
> +						  IGT_CUSTOM_EDID_ALT);
> +		}
> +
> +		igt_describe(igt_edid_stress_resolution_desc);
> +		connector_subtest("dp-edid-stress-resolution-4k", DisplayPort)
> +			edid_stress_resolution(&data, port, DP_EDIDS_4K,
> +					       ARRAY_SIZE(DP_EDIDS_4K));
> +
> +		igt_describe(igt_edid_stress_resolution_desc);
> +		connector_subtest("dp-edid-stress-resolution-non-4k",
> +				  DisplayPort)
> +			edid_stress_resolution(&data, port, DP_EDIDS_NON_4K,
> +					       ARRAY_SIZE(DP_EDIDS_NON_4K));
> +
> +		igt_describe(igt_edid_resolution_list_desc);
> +		connector_subtest("dp-edid-resolution-list", DisplayPort)
> +			edid_resolution_list(&data, port);
> +
> +		igt_describe(test_suspend_resume_edid_change_desc);
> +		connector_subtest("dp-edid-change-during-suspend", DisplayPort)
> +			test_suspend_resume_edid_change(&data, port,
> +							SUSPEND_STATE_MEM,
> +							SUSPEND_TEST_NONE,
> +							IGT_CUSTOM_EDID_BASE,
> +							IGT_CUSTOM_EDID_ALT);
> +
> +		igt_describe(test_suspend_resume_edid_change_desc);
> +		connector_subtest("dp-edid-change-during-hibernate",
> +				  DisplayPort)
> +			test_suspend_resume_edid_change(&data, port,
> +							SUSPEND_STATE_DISK,
> +							SUSPEND_TEST_DEVICES,
> +							IGT_CUSTOM_EDID_BASE,
> +							IGT_CUSTOM_EDID_ALT);
> +
> +		igt_describe(test_mode_timings_desc);
> +		connector_subtest("dp-mode-timings", DisplayPort)
> +			test_mode_timings(&data, port);
> +	}
> +
> +	igt_describe("HDMI tests");
> +	igt_subtest_group {
> +		igt_fixture {
> +			chamelium_require_connector_present(
> +				data.ports, DRM_MODE_CONNECTOR_HDMIA,
> +				data.port_count, 1);
> +		}
> +
> +		igt_describe(igt_custom_edid_type_read_desc);
> +		connector_subtest("hdmi-edid-read", HDMIA)
> +		{
> +			igt_custom_edid_type_read(&data, port,
> +						  IGT_CUSTOM_EDID_BASE);
> +			igt_custom_edid_type_read(&data, port,
> +						  IGT_CUSTOM_EDID_ALT);
> +		}
> +
> +		igt_describe(igt_edid_stress_resolution_desc);
> +		connector_subtest("hdmi-edid-stress-resolution-4k", HDMIA)
> +			edid_stress_resolution(&data, port, HDMI_EDIDS_4K,
> +					       ARRAY_SIZE(HDMI_EDIDS_4K));
> +
> +		igt_describe(igt_edid_stress_resolution_desc);
> +		connector_subtest("hdmi-edid-stress-resolution-non-4k", HDMIA)
> +			edid_stress_resolution(&data, port, HDMI_EDIDS_NON_4K,
> +					       ARRAY_SIZE(HDMI_EDIDS_NON_4K));
> +
> +		igt_describe(test_suspend_resume_edid_change_desc);
> +		connector_subtest("hdmi-edid-change-during-suspend", HDMIA)
> +			test_suspend_resume_edid_change(&data, port,
> +							SUSPEND_STATE_MEM,
> +							SUSPEND_TEST_NONE,
> +							IGT_CUSTOM_EDID_BASE,
> +							IGT_CUSTOM_EDID_ALT);
> +
> +		igt_describe(test_suspend_resume_edid_change_desc);
> +		connector_subtest("hdmi-edid-change-during-hibernate", HDMIA)
> +			test_suspend_resume_edid_change(&data, port,
> +							SUSPEND_STATE_DISK,
> +							SUSPEND_TEST_DEVICES,
> +							IGT_CUSTOM_EDID_BASE,
> +							IGT_CUSTOM_EDID_ALT);
> +
> +		igt_describe(test_mode_timings_desc);
> +		connector_subtest("hdmi-mode-timings", HDMIA)
> +			test_mode_timings(&data, port);
> +	}
> +
> +	igt_describe("VGA tests");
> +	igt_subtest_group {
> +		igt_fixture {
> +			chamelium_require_connector_present(
> +				data.ports, DRM_MODE_CONNECTOR_VGA,
> +				data.port_count, 1);
> +		}
> +
> +		igt_describe(igt_custom_edid_type_read_desc);
> +		connector_subtest("vga-edid-read", VGA)
> +		{
> +			igt_custom_edid_type_read(&data, port,
> +						  IGT_CUSTOM_EDID_BASE);
> +			igt_custom_edid_type_read(&data, port,
> +						  IGT_CUSTOM_EDID_ALT);
> +		}
> +	}
> +
> +	igt_fixture {
> +		igt_display_fini(&data.display);
> +		close(data.drm_fd);
> +	}
> +}
> diff --git a/tests/chamelium/kms_chamelium_frames.c b/tests/chamelium/kms_chamelium_frames.c
> new file mode 100644
> index 00000000..008bc34b
> --- /dev/null
> +++ b/tests/chamelium/kms_chamelium_frames.c
> @@ -0,0 +1,1085 @@
> +/*
> + * Copyright © 2016 Red Hat Inc.
> + *
> + * Permission is hereby granted, free of charge, to any person obtaining a
> + * copy of this software and associated documentation files (the "Software"),
> + * to deal in the Software without restriction, including without limitation
> + * the rights to use, copy, modify, merge, publish, distribute, sublicense,
> + * and/or sell copies of the Software, and to permit persons to whom the
> + * Software is furnished to do so, subject to the following conditions:
> + *
> + * The above copyright notice and this permission notice (including the next
> + * paragraph) shall be included in all copies or substantial portions of the
> + * Software.
> + *
> + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
> + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
> + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
> + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
> + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
> + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
> + * IN THE SOFTWARE.
> + *
> + * Authors:
> + *    Lyude Paul <lyude at redhat.com>
> + */
> +
> +#include "igt_eld.h"
> +#include "igt_infoframe.h"
> +#include "kms_chamelium_helper.h"
> +
> +#define connector_dynamic_subtest(name__, type__)                   \
> +	igt_subtest_with_dynamic(name__)                            \
> +	for_each_port(p, port) if (chamelium_port_get_type(port) == \
> +				   DRM_MODE_CONNECTOR_##type__)
> +
> +struct vic_mode {
> +	int hactive, vactive;
> +	int vrefresh; /* Hz */
> +	uint32_t picture_ar;
> +};
> +
> +static int chamelium_vga_modes[][2] = {
> +	{ 1600, 1200 }, { 1920, 1200 }, { 1920, 1080 }, { 1680, 1050 },
> +	{ 1280, 1024 }, { 1280, 960 },	{ 1440, 900 },	{ 1280, 800 },
> +	{ 1024, 768 },	{ 1360, 768 },	{ 1280, 720 },	{ 800, 600 },
> +	{ 640, 480 },	{ -1, -1 },
> +};
> +
> +/* Maps Video Identification Codes to a mode */
> +static const struct vic_mode vic_modes[] = {
> +	[16] = {
> +		.hactive = 1920,
> +		.vactive = 1080,
> +		.vrefresh = 60,
> +		.picture_ar = DRM_MODE_PICTURE_ASPECT_16_9,
> +	},
> +};
> +
> +/* Maps aspect ratios to their mode flag */
> +static const uint32_t mode_ar_flags[] = {
> +	[DRM_MODE_PICTURE_ASPECT_16_9] = DRM_MODE_FLAG_PIC_AR_16_9,
> +};
> +
> +static bool prune_vga_mode(chamelium_data_t *data, drmModeModeInfo *mode)
> +{
> +	int i = 0;
> +
> +	while (chamelium_vga_modes[i][0] != -1) {
> +		if (mode->hdisplay == chamelium_vga_modes[i][0] &&
> +		    mode->vdisplay == chamelium_vga_modes[i][1])
> +			return false;
> +
> +		i++;
> +	}
> +
> +	return true;
> +}
> +
> +static void do_test_display(chamelium_data_t *data, struct chamelium_port *port,
> +			    igt_output_t *output, drmModeModeInfo *mode,
> +			    uint32_t fourcc, enum chamelium_check check,
> +			    int count)
> +{
> +	struct chamelium_fb_crc_async_data *fb_crc;
> +	struct igt_fb frame_fb, fb;
> +	int i, fb_id, captured_frame_count;
> +	int frame_id;
> +
> +	fb_id = chamelium_get_pattern_fb(data, mode->hdisplay, mode->vdisplay,
> +					 DRM_FORMAT_XRGB8888, 64, &fb);
> +	igt_assert(fb_id > 0);
> +
> +	frame_id =
> +		igt_fb_convert(&frame_fb, &fb, fourcc, DRM_FORMAT_MOD_LINEAR);
> +	igt_assert(frame_id > 0);
> +
> +	if (check == CHAMELIUM_CHECK_CRC)
> +		fb_crc = chamelium_calculate_fb_crc_async_start(data->drm_fd,
> +								&fb);
> +
> +	chamelium_enable_output(data, port, output, mode, &frame_fb);
> +
> +	if (check == CHAMELIUM_CHECK_CRC) {
> +		igt_crc_t *expected_crc;
> +		igt_crc_t *crc;
> +
> +		/* We want to keep the display running for a little bit, since
> +		 * there's always the potential the driver isn't able to keep
> +		 * the display running properly for very long
> +		 */
> +		chamelium_capture(data->chamelium, port, 0, 0, 0, 0, count);
> +		crc = chamelium_read_captured_crcs(data->chamelium,
> +						   &captured_frame_count);
> +
> +		igt_assert(captured_frame_count == count);
> +
> +		igt_debug("Captured %d frames\n", captured_frame_count);
> +
> +		expected_crc = chamelium_calculate_fb_crc_async_finish(fb_crc);
> +
> +		for (i = 0; i < captured_frame_count; i++)
> +			chamelium_assert_crc_eq_or_dump(
> +				data->chamelium, expected_crc, &crc[i], &fb, i);
> +
> +		free(expected_crc);
> +		free(crc);
> +	} else if (check == CHAMELIUM_CHECK_ANALOG ||
> +		   check == CHAMELIUM_CHECK_CHECKERBOARD) {
> +		struct chamelium_frame_dump *dump;
> +
> +		igt_assert(count == 1);
> +
> +		dump = chamelium_port_dump_pixels(data->chamelium, port, 0, 0,
> +						  0, 0);
> +
> +		if (check == CHAMELIUM_CHECK_ANALOG)
> +			chamelium_crop_analog_frame(dump, mode->hdisplay,
> +						    mode->vdisplay);
> +
> +		chamelium_assert_frame_match_or_dump(data->chamelium, port,
> +						     dump, &fb, check);
> +		chamelium_destroy_frame_dump(dump);
> +	}
> +
> +	igt_remove_fb(data->drm_fd, &frame_fb);
> +	igt_remove_fb(data->drm_fd, &fb);
> +}
> +
> +static enum infoframe_avi_picture_aspect_ratio
> +get_infoframe_avi_picture_ar(uint32_t aspect_ratio)
> +{
> +	/* The AVI picture aspect ratio field only supports 4:3 and 16:9 */
> +	switch (aspect_ratio) {
> +	case DRM_MODE_PICTURE_ASPECT_4_3:
> +		return INFOFRAME_AVI_PIC_AR_4_3;
> +	case DRM_MODE_PICTURE_ASPECT_16_9:
> +		return INFOFRAME_AVI_PIC_AR_16_9;
> +	default:
> +		return INFOFRAME_AVI_PIC_AR_UNSPECIFIED;
> +	}
> +}
> +
> +static bool vic_mode_matches_drm(const struct vic_mode *vic_mode,
> +				 drmModeModeInfo *drm_mode)
> +{
> +	uint32_t ar_flag = mode_ar_flags[vic_mode->picture_ar];
> +
> +	return vic_mode->hactive == drm_mode->hdisplay &&
> +	       vic_mode->vactive == drm_mode->vdisplay &&
> +	       vic_mode->vrefresh == drm_mode->vrefresh &&
> +	       ar_flag == (drm_mode->flags & DRM_MODE_FLAG_PIC_AR_MASK);
> +}
> +
> +static void randomize_plane_stride(chamelium_data_t *data, uint32_t width,
> +				   uint32_t height, uint32_t format,
> +				   uint64_t modifier, size_t *stride)
> +{
> +	size_t stride_min;
> +	uint32_t max_tile_w = 4, tile_w, tile_h;
> +	int i;
> +	struct igt_fb dummy;
> +
> +	stride_min = width * igt_format_plane_bpp(format, 0) / 8;
> +
> +	/* Randomize the stride to less than twice the minimum. */
> +	*stride = (rand() % stride_min) + stride_min;
> +
> +	/*
> +	 * Create a dummy FB to determine bpp for each plane, and calculate
> +	 * the maximum tile width from that.
> +	 */
> +	igt_create_fb(data->drm_fd, 64, 64, format, modifier, &dummy);
> +	for (i = 0; i < dummy.num_planes; i++) {
> +		igt_get_fb_tile_size(data->drm_fd, modifier, dummy.plane_bpp[i],
> +				     &tile_w, &tile_h);
> +
> +		if (tile_w > max_tile_w)
> +			max_tile_w = tile_w;
> +	}
> +	igt_remove_fb(data->drm_fd, &dummy);
> +
> +	/*
> +	 * Pixman requires the stride to be aligned to 32-bits, which is
> +	 * reflected in the initial value of max_tile_w and the hw
> +	 * may require a multiple of tile width, choose biggest of the 2.
> +	 */
> +	*stride = ALIGN(*stride, max_tile_w);
> +}
> +
> +static void update_tiled_modifier(igt_plane_t *plane, uint32_t width,
> +				  uint32_t height, uint32_t format,
> +				  uint64_t *modifier)
> +{
> +	if (*modifier == DRM_FORMAT_MOD_BROADCOM_SAND256) {
> +		/* Randomize the column height to less than twice the minimum.
> +		 */
> +		size_t column_height = (rand() % height) + height;
> +
> +		igt_debug(
> +			"Selecting VC4 SAND256 tiling with column height %ld\n",
> +			column_height);
> +
> +		*modifier = DRM_FORMAT_MOD_BROADCOM_SAND256_COL_HEIGHT(
> +			column_height);
> +	}
> +}
> +
> +static void randomize_plane_setup(chamelium_data_t *data, igt_plane_t *plane,
> +				  drmModeModeInfo *mode, uint32_t *width,
> +				  uint32_t *height, uint32_t *format,
> +				  uint64_t *modifier, bool allow_yuv)
> +{
> +	int min_dim;
> +	uint32_t idx[plane->format_mod_count];
> +	unsigned int count = 0;
> +	unsigned int i;
> +
> +	/* First pass to count the supported formats. */
> +	for (i = 0; i < plane->format_mod_count; i++)
> +		if (igt_fb_supported_format(plane->formats[i]) &&
> +		    (allow_yuv || !igt_format_is_yuv(plane->formats[i])))
> +			idx[count++] = i;
> +
> +	igt_assert(count > 0);
> +
> +	i = idx[rand() % count];
> +	*format = plane->formats[i];
> +	*modifier = plane->modifiers[i];
> +
> +	update_tiled_modifier(plane, *width, *height, *format, modifier);
> +
> +	/*
> +	 * Randomize width and height in the mode dimensions range.
> +	 *
> +	 * Restrict to a min of 2 * min_dim, this way src_w/h are always at
> +	 * least min_dim, because src_w = width - (rand % w / 2).
> +	 *
> +	 * Use a minimum dimension of 16 for YUV, because planar YUV
> +	 * subsamples the UV plane.
> +	 */
> +	min_dim = igt_format_is_yuv(*format) ? 16 : 8;
> +
> +	*width = max((rand() % mode->hdisplay) + 1, 2 * min_dim);
> +	*height = max((rand() % mode->vdisplay) + 1, 2 * min_dim);
> +}
> +
> +static void configure_plane(igt_plane_t *plane, uint32_t src_w, uint32_t src_h,
> +			    uint32_t src_x, uint32_t src_y, uint32_t crtc_w,
> +			    uint32_t crtc_h, int32_t crtc_x, int32_t crtc_y,
> +			    struct igt_fb *fb)
> +{
> +	igt_plane_set_fb(plane, fb);
> +
> +	igt_plane_set_position(plane, crtc_x, crtc_y);
> +	igt_plane_set_size(plane, crtc_w, crtc_h);
> +
> +	igt_fb_set_position(fb, plane, src_x, src_y);
> +	igt_fb_set_size(fb, plane, src_w, src_h);
> +}
> +
> +static void randomize_plane_coordinates(
> +	chamelium_data_t *data, igt_plane_t *plane, drmModeModeInfo *mode,
> +	struct igt_fb *fb, uint32_t *src_w, uint32_t *src_h, uint32_t *src_x,
> +	uint32_t *src_y, uint32_t *crtc_w, uint32_t *crtc_h, int32_t *crtc_x,
> +	int32_t *crtc_y, bool allow_scaling)
> +{
> +	bool is_yuv = igt_format_is_yuv(fb->drm_format);
> +	uint32_t width = fb->width, height = fb->height;
> +	double ratio;
> +	int ret;
> +
> +	/* Randomize source offset in the first half of the original size. */
> +	*src_x = rand() % (width / 2);
> +	*src_y = rand() % (height / 2);
> +
> +	/* The source size only includes the active source area. */
> +	*src_w = width - *src_x;
> +	*src_h = height - *src_y;
> +
> +	if (allow_scaling) {
> +		*crtc_w = (rand() % mode->hdisplay) + 1;
> +		*crtc_h = (rand() % mode->vdisplay) + 1;
> +
> +		/*
> +		 * Don't bother with scaling if dimensions are quite close in
> +		 * order to get non-scaling cases more frequently. Also limit
> +		 * scaling to 3x to avoid aggressive filtering that makes
> +		 * comparison less reliable, and don't go above 2x downsampling
> +		 * to avoid possible hw limitations.
> +		 */
> +
> +		ratio = ((double)*crtc_w / *src_w);
> +		if (ratio < 0.5)
> +			*src_w = *crtc_w * 2;
> +		else if (ratio > 0.8 && ratio < 1.2)
> +			*crtc_w = *src_w;
> +		else if (ratio > 3.0)
> +			*crtc_w = *src_w * 3;
> +
> +		ratio = ((double)*crtc_h / *src_h);
> +		if (ratio < 0.5)
> +			*src_h = *crtc_h * 2;
> +		else if (ratio > 0.8 && ratio < 1.2)
> +			*crtc_h = *src_h;
> +		else if (ratio > 3.0)
> +			*crtc_h = *src_h * 3;
> +	} else {
> +		*crtc_w = *src_w;
> +		*crtc_h = *src_h;
> +	}
> +
> +	if (*crtc_w != *src_w || *crtc_h != *src_h) {
> +		/*
> +		 * When scaling is involved, make sure to not go off-bounds or
> +		 * scaled clipping may result in decimal dimensions, that most
> +		 * drivers don't support.
> +		 */
> +		if (*crtc_w < mode->hdisplay)
> +			*crtc_x = rand() % (mode->hdisplay - *crtc_w);
> +		else
> +			*crtc_x = 0;
> +
> +		if (*crtc_h < mode->vdisplay)
> +			*crtc_y = rand() % (mode->vdisplay - *crtc_h);
> +		else
> +			*crtc_y = 0;
> +	} else {
> +		/*
> +		 * Randomize the on-crtc position and allow the plane to go
> +		 * off-display by less than half of its on-crtc dimensions.
> +		 */
> +		*crtc_x = (rand() % mode->hdisplay) - *crtc_w / 2;
> +		*crtc_y = (rand() % mode->vdisplay) - *crtc_h / 2;
> +	}
> +
> +	configure_plane(plane, *src_w, *src_h, *src_x, *src_y, *crtc_w, *crtc_h,
> +			*crtc_x, *crtc_y, fb);
> +	ret = igt_display_try_commit_atomic(
> +		&data->display,
> +		DRM_MODE_ATOMIC_TEST_ONLY | DRM_MODE_ATOMIC_ALLOW_MODESET,
> +		NULL);
> +	if (!ret)
> +		return;
> +
> +	/* Coordinates are logged in the dumped debug log, so only report w/h on
> +	 * failure here. */
> +	igt_assert_f(ret != -ENOSPC,
> +		     "Failure in testcase, invalid coordinates on a %ux%u fb\n",
> +		     width, height);
> +
> +	/* Make YUV coordinates a multiple of 2 and retry the math. */
> +	if (is_yuv) {
> +		*src_x &= ~1;
> +		*src_y &= ~1;
> +		*src_w &= ~1;
> +		*src_h &= ~1;
> +		/* To handle 1:1 scaling, clear crtc_w/h too. */
> +		*crtc_w &= ~1;
> +		*crtc_h &= ~1;
> +
> +		if (*crtc_x < 0 && (*crtc_x & 1))
> +			(*crtc_x)++;
> +		else
> +			*crtc_x &= ~1;
> +
> +		/* If negative, round up to 0 instead of down */
> +		if (*crtc_y < 0 && (*crtc_y & 1))
> +			(*crtc_y)++;
> +		else
> +			*crtc_y &= ~1;
> +
> +		configure_plane(plane, *src_w, *src_h, *src_x, *src_y, *crtc_w,
> +				*crtc_h, *crtc_x, *crtc_y, fb);
> +		ret = igt_display_try_commit_atomic(
> +			&data->display,
> +			DRM_MODE_ATOMIC_TEST_ONLY |
> +				DRM_MODE_ATOMIC_ALLOW_MODESET,
> +			NULL);
> +		if (!ret)
> +			return;
> +	}
> +
> +	igt_assert(!ret || allow_scaling);
> +	igt_info("Scaling ratio %g / %g failed, trying without scaling.\n",
> +		 ((double)*crtc_w / *src_w), ((double)*crtc_h / *src_h));
> +
> +	*crtc_w = *src_w;
> +	*crtc_h = *src_h;
> +
> +	configure_plane(plane, *src_w, *src_h, *src_x, *src_y, *crtc_w, *crtc_h,
> +			*crtc_x, *crtc_y, fb);
> +	igt_display_commit_atomic(&data->display,
> +				  DRM_MODE_ATOMIC_TEST_ONLY |
> +					  DRM_MODE_ATOMIC_ALLOW_MODESET,
> +				  NULL);
> +}
> +
> +static void blit_plane_cairo(chamelium_data_t *data, cairo_surface_t *result,
> +			     uint32_t src_w, uint32_t src_h, uint32_t src_x,
> +			     uint32_t src_y, uint32_t crtc_w, uint32_t crtc_h,
> +			     int32_t crtc_x, int32_t crtc_y, struct igt_fb *fb)
> +{
> +	cairo_surface_t *surface;
> +	cairo_surface_t *clipped_surface;
> +	cairo_t *cr;
> +
> +	surface = igt_get_cairo_surface(data->drm_fd, fb);
> +
> +	if (src_x || src_y) {
> +		clipped_surface = cairo_image_surface_create(CAIRO_FORMAT_RGB24,
> +							     src_w, src_h);
> +
> +		cr = cairo_create(clipped_surface);
> +
> +		cairo_translate(cr, -1. * src_x, -1. * src_y);
> +
> +		cairo_set_source_surface(cr, surface, 0, 0);
> +
> +		cairo_paint(cr);
> +		cairo_surface_flush(clipped_surface);
> +
> +		cairo_destroy(cr);
> +	} else {
> +		clipped_surface = surface;
> +	}
> +
> +	cr = cairo_create(result);
> +
> +	cairo_translate(cr, crtc_x, crtc_y);
> +
> +	if (src_w != crtc_w || src_h != crtc_h) {
> +		cairo_scale(cr, (double)crtc_w / src_w, (double)crtc_h / src_h);
> +	}
> +
> +	cairo_set_source_surface(cr, clipped_surface, 0, 0);
> +	cairo_surface_destroy(clipped_surface);
> +
> +	if (src_w != crtc_w || src_h != crtc_h) {
> +		cairo_pattern_set_filter(cairo_get_source(cr),
> +					 CAIRO_FILTER_BILINEAR);
> +		cairo_pattern_set_extend(cairo_get_source(cr),
> +					 CAIRO_EXTEND_NONE);
> +	}
> +
> +	cairo_paint(cr);
> +	cairo_surface_flush(result);
> +
> +	cairo_destroy(cr);
> +}
> +
> +static void prepare_randomized_plane(chamelium_data_t *data,
> +				     drmModeModeInfo *mode, igt_plane_t *plane,
> +				     struct igt_fb *overlay_fb,
> +				     unsigned int index,
> +				     cairo_surface_t *result_surface,
> +				     bool allow_scaling, bool allow_yuv)
> +{
> +	struct igt_fb pattern_fb;
> +	uint32_t overlay_fb_w, overlay_fb_h;
> +	uint32_t overlay_src_w, overlay_src_h;
> +	uint32_t overlay_src_x, overlay_src_y;
> +	int32_t overlay_crtc_x, overlay_crtc_y;
> +	uint32_t overlay_crtc_w, overlay_crtc_h;
> +	uint32_t format;
> +	uint64_t modifier;
> +	size_t stride;
> +	bool tiled;
> +	int fb_id;
> +
> +	randomize_plane_setup(data, plane, mode, &overlay_fb_w, &overlay_fb_h,
> +			      &format, &modifier, allow_yuv);
> +
> +	tiled = (modifier != DRM_FORMAT_MOD_LINEAR);
> +	igt_debug("Plane %d: framebuffer size %dx%d %s format (%s)\n", index,
> +		  overlay_fb_w, overlay_fb_h, igt_format_str(format),
> +		  tiled ? "tiled" : "linear");
> +
> +	/* Get a pattern framebuffer for the overlay plane. */
> +	fb_id = chamelium_get_pattern_fb(data, overlay_fb_w, overlay_fb_h,
> +					 DRM_FORMAT_XRGB8888, 32, &pattern_fb);
> +	igt_assert(fb_id > 0);
> +
> +	randomize_plane_stride(data, overlay_fb_w, overlay_fb_h, format,
> +			       modifier, &stride);
> +
> +	igt_debug("Plane %d: stride %ld\n", index, stride);
> +
> +	fb_id = igt_fb_convert_with_stride(overlay_fb, &pattern_fb, format,
> +					   modifier, stride);
> +	igt_assert(fb_id > 0);
> +
> +	randomize_plane_coordinates(data, plane, mode, overlay_fb,
> +				    &overlay_src_w, &overlay_src_h,
> +				    &overlay_src_x, &overlay_src_y,
> +				    &overlay_crtc_w, &overlay_crtc_h,
> +				    &overlay_crtc_x, &overlay_crtc_y,
> +				    allow_scaling);
> +
> +	igt_debug("Plane %d: in-framebuffer size %dx%d\n", index, overlay_src_w,
> +		  overlay_src_h);
> +	igt_debug("Plane %d: in-framebuffer position %dx%d\n", index,
> +		  overlay_src_x, overlay_src_y);
> +	igt_debug("Plane %d: on-crtc size %dx%d\n", index, overlay_crtc_w,
> +		  overlay_crtc_h);
> +	igt_debug("Plane %d: on-crtc position %dx%d\n", index, overlay_crtc_x,
> +		  overlay_crtc_y);
> +
> +	blit_plane_cairo(data, result_surface, overlay_src_w, overlay_src_h,
> +			 overlay_src_x, overlay_src_y, overlay_crtc_w,
> +			 overlay_crtc_h, overlay_crtc_x, overlay_crtc_y,
> +			 &pattern_fb);
> +
> +	/* Remove the original pattern framebuffer. */
> +	igt_remove_fb(data->drm_fd, &pattern_fb);
> +}
> +
> +static const char test_display_one_mode_desc[] =
> +	"Pick the first mode of the IGT base EDID, display and capture a few "
> +	"frames, then check captured frames are correct";
> +static void test_display_one_mode(chamelium_data_t *data,
> +				  struct chamelium_port *port, uint32_t fourcc,
> +				  enum chamelium_check check, int count)
> +{
> +	drmModeConnector *connector;
> +	drmModeModeInfo *mode;
> +	igt_output_t *output;
> +	igt_plane_t *primary;
> +
> +	igt_modeset_disable_all_outputs(&data->display);
> +	chamelium_reset_state(&data->display, data->chamelium, port,
> +			      data->ports, data->port_count);
> +
> +	output = chamelium_prepare_output(data, port, IGT_CUSTOM_EDID_BASE);
> +	connector = chamelium_port_get_connector(data->chamelium, port, false);
> +	primary = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY);
> +	igt_assert(primary);
> +
> +	igt_require(igt_plane_has_format_mod(primary, fourcc,
> +					     DRM_FORMAT_MOD_LINEAR));
> +
> +	mode = &connector->modes[0];
> +	if (check == CHAMELIUM_CHECK_ANALOG) {
> +		bool bridge = chamelium_check_analog_bridge(data, port);
> +
> +		igt_assert(!(bridge && prune_vga_mode(data, mode)));
> +	}
> +
> +	do_test_display(data, port, output, mode, fourcc, check, count);
> +
> +	drmModeFreeConnector(connector);
> +}
> +
> +static const char test_display_all_modes_desc[] =
> +	"For each mode of the IGT base EDID, display and capture a few "
> +	"frames, then check captured frames are correct";
> +static void test_display_all_modes(chamelium_data_t *data,
> +				   struct chamelium_port *port, uint32_t fourcc,
> +				   enum chamelium_check check, int count)
> +{
> +	bool bridge;
> +	int i, count_modes;
> +
> +	if (check == CHAMELIUM_CHECK_ANALOG)
> +		bridge = chamelium_check_analog_bridge(data, port);
> +
> +	i = 0;
> +	do {
> +		igt_output_t *output;
> +		igt_plane_t *primary;
> +		drmModeConnector *connector;
> +		drmModeModeInfo *mode;
> +
> +		/*
> +		 * let's reset state each mode so we will get the
> +		 * HPD pulses realibably
> +		 */
> +		igt_modeset_disable_all_outputs(&data->display);
> +		chamelium_reset_state(&data->display, data->chamelium, port,
> +				      data->ports, data->port_count);
> +
> +		/*
> +		 * modes may change due to mode pruining and link issues, so we
> +		 * need to refresh the connector
> +		 */
> +		output = chamelium_prepare_output(data, port,
> +						  IGT_CUSTOM_EDID_BASE);
> +		connector = chamelium_port_get_connector(data->chamelium, port,
> +							 false);
> +		primary = igt_output_get_plane_type(output,
> +						    DRM_PLANE_TYPE_PRIMARY);
> +		igt_assert(primary);
> +		igt_require(igt_plane_has_format_mod(primary, fourcc,
> +						     DRM_FORMAT_MOD_LINEAR));
> +
> +		/* we may skip some modes due to above but that's ok */
> +		count_modes = connector->count_modes;
> +		if (i >= count_modes)
> +			break;
> +
> +		mode = &connector->modes[i];
> +
> +		if (check == CHAMELIUM_CHECK_ANALOG && bridge &&
> +		    prune_vga_mode(data, mode))
> +			continue;
> +
> +		do_test_display(data, port, output, mode, fourcc, check, count);
> +		drmModeFreeConnector(connector);
> +	} while (++i < count_modes);
> +}
> +
> +static const char test_display_frame_dump_desc[] =
> +	"For each mode of the IGT base EDID, display and capture a few "
> +	"frames, then download the captured frames and compare them "
> +	"bit-by-bit to the sent ones";
> +static void test_display_frame_dump(chamelium_data_t *data,
> +				    struct chamelium_port *port)
> +{
> +	int i, count_modes;
> +
> +	i = 0;
> +	do {
> +		igt_output_t *output;
> +		igt_plane_t *primary;
> +		struct igt_fb fb;
> +		struct chamelium_frame_dump *frame;
> +		drmModeModeInfo *mode;
> +		drmModeConnector *connector;
> +		int fb_id, j;
> +
> +		/*
> +		 * let's reset state each mode so we will get the
> +		 * HPD pulses realibably
> +		 */
> +		igt_modeset_disable_all_outputs(&data->display);
> +		chamelium_reset_state(&data->display, data->chamelium, port,
> +				      data->ports, data->port_count);
> +
> +		/*
> +		 * modes may change due to mode pruining and link issues, so we
> +		 * need to refresh the connector
> +		 */
> +		output = chamelium_prepare_output(data, port,
> +						  IGT_CUSTOM_EDID_BASE);
> +		connector = chamelium_port_get_connector(data->chamelium, port,
> +							 false);
> +		primary = igt_output_get_plane_type(output,
> +						    DRM_PLANE_TYPE_PRIMARY);
> +		igt_assert(primary);
> +
> +		/* we may skip some modes due to above but that's ok */
> +		count_modes = connector->count_modes;
> +		if (i >= count_modes)
> +			break;
> +
> +		mode = &connector->modes[i];
> +
> +		fb_id = igt_create_color_pattern_fb(
> +			data->drm_fd, mode->hdisplay, mode->vdisplay,
> +			DRM_FORMAT_XRGB8888, DRM_FORMAT_MOD_LINEAR, 0, 0, 0,
> +			&fb);
> +		igt_assert(fb_id > 0);
> +
> +		chamelium_enable_output(data, port, output, mode, &fb);
> +
> +		igt_debug("Reading frame dumps from Chamelium...\n");
> +		chamelium_capture(data->chamelium, port, 0, 0, 0, 0, 5);
> +		for (j = 0; j < 5; j++) {
> +			frame = chamelium_read_captured_frame(data->chamelium,
> +							      j);
> +			chamelium_assert_frame_eq(data->chamelium, frame, &fb);
> +			chamelium_destroy_frame_dump(frame);
> +		}
> +
> +		igt_remove_fb(data->drm_fd, &fb);
> +		drmModeFreeConnector(connector);
> +	} while (++i < count_modes);
> +}
> +
> +static const char test_display_aspect_ratio_desc[] =
> +	"Pick a mode with a picture aspect-ratio, capture AVI InfoFrames and "
> +	"check they include the relevant fields";
> +static void test_display_aspect_ratio(chamelium_data_t *data,
> +				      struct chamelium_port *port)
> +{
> +	igt_output_t *output;
> +	igt_plane_t *primary;
> +	drmModeConnector *connector;
> +	drmModeModeInfo *mode;
> +	int fb_id, i;
> +	struct igt_fb fb;
> +	bool found, ok;
> +	struct chamelium_infoframe *infoframe;
> +	struct infoframe_avi infoframe_avi;
> +	uint8_t vic = 16; /* TODO: test more VICs */
> +	const struct vic_mode *vic_mode;
> +	uint32_t aspect_ratio;
> +	enum infoframe_avi_picture_aspect_ratio frame_ar;
> +
> +	igt_require(chamelium_supports_get_last_infoframe(data->chamelium));
> +
> +	igt_modeset_disable_all_outputs(&data->display);
> +	chamelium_reset_state(&data->display, data->chamelium, port,
> +			      data->ports, data->port_count);
> +
> +	output = chamelium_prepare_output(data, port,
> +					  IGT_CUSTOM_EDID_ASPECT_RATIO);
> +	connector = chamelium_port_get_connector(data->chamelium, port, false);
> +	primary = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY);
> +	igt_assert(primary);
> +
> +	vic_mode = &vic_modes[vic];
> +	aspect_ratio = vic_mode->picture_ar;
> +
> +	found = false;
> +	igt_assert(connector->count_modes > 0);
> +	for (i = 0; i < connector->count_modes; i++) {
> +		mode = &connector->modes[i];
> +
> +		if (vic_mode_matches_drm(vic_mode, mode)) {
> +			found = true;
> +			break;
> +		}
> +	}
> +	igt_assert_f(found,
> +		     "Failed to find mode with the correct aspect ratio\n");
> +
> +	fb_id = igt_create_color_pattern_fb(data->drm_fd, mode->hdisplay,
> +					    mode->vdisplay, DRM_FORMAT_XRGB8888,
> +					    DRM_FORMAT_MOD_LINEAR, 0, 0, 0,
> +					    &fb);
> +	igt_assert(fb_id > 0);
> +
> +	chamelium_enable_output(data, port, output, mode, &fb);
> +
> +	infoframe = chamelium_get_last_infoframe(data->chamelium, port,
> +						 CHAMELIUM_INFOFRAME_AVI);
> +	igt_assert_f(infoframe, "AVI InfoFrame not received\n");
> +
> +	ok = infoframe_avi_parse(&infoframe_avi, infoframe->version,
> +				 infoframe->payload, infoframe->payload_size);
> +	igt_assert_f(ok, "Failed to parse AVI InfoFrame\n");
> +
> +	frame_ar = get_infoframe_avi_picture_ar(aspect_ratio);
> +
> +	igt_debug("Checking AVI InfoFrame\n");
> +	igt_debug("Picture aspect ratio: got %d, expected %d\n",
> +		  infoframe_avi.picture_aspect_ratio, frame_ar);
> +	igt_debug("Video Identification Code (VIC): got %d, expected %d\n",
> +		  infoframe_avi.vic, vic);
> +
> +	igt_assert(infoframe_avi.picture_aspect_ratio == frame_ar);
> +	igt_assert(infoframe_avi.vic == vic);
> +
> +	chamelium_infoframe_destroy(infoframe);
> +	igt_remove_fb(data->drm_fd, &fb);
> +	drmModeFreeConnector(connector);
> +}
> +
> +static const char test_display_planes_random_desc[] =
> +	"Setup a few overlay planes with random parameters, capture the frame "
> +	"and check it matches the expected output";
> +static void test_display_planes_random(chamelium_data_t *data,
> +				       struct chamelium_port *port,
> +				       enum chamelium_check check)
> +{
> +	igt_output_t *output;
> +	drmModeModeInfo *mode;
> +	igt_plane_t *primary_plane;
> +	struct igt_fb primary_fb;
> +	struct igt_fb result_fb;
> +	struct igt_fb *overlay_fbs;
> +	igt_crc_t *crc;
> +	igt_crc_t *expected_crc;
> +	struct chamelium_fb_crc_async_data *fb_crc;
> +	unsigned int overlay_planes_max = 0;
> +	unsigned int overlay_planes_count;
> +	cairo_surface_t *result_surface;
> +	int captured_frame_count;
> +	bool allow_scaling;
> +	bool allow_yuv;
> +	unsigned int i;
> +	unsigned int fb_id;
> +
> +	switch (check) {
> +	case CHAMELIUM_CHECK_CRC:
> +		allow_scaling = false;
> +		allow_yuv = false;
> +		break;
> +	case CHAMELIUM_CHECK_CHECKERBOARD:
> +		allow_scaling = true;
> +		allow_yuv = true;
> +		break;
> +	default:
> +		igt_assert(false);
> +	}
> +
> +	srand(time(NULL));
> +
> +	igt_modeset_disable_all_outputs(&data->display);
> +	chamelium_reset_state(&data->display, data->chamelium, port,
> +			      data->ports, data->port_count);
> +
> +	/* Find the connector and pipe. */
> +	output = chamelium_prepare_output(data, port, IGT_CUSTOM_EDID_BASE);
> +
> +	mode = igt_output_get_mode(output);
> +
> +	/* Get a framebuffer for the primary plane. */
> +	primary_plane =
> +		igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY);
> +	igt_assert(primary_plane);
> +
> +	fb_id = chamelium_get_pattern_fb(data, mode->hdisplay, mode->vdisplay,
> +					 DRM_FORMAT_XRGB8888, 64, &primary_fb);
> +	igt_assert(fb_id > 0);
> +
> +	/* Get a framebuffer for the cairo composition result. */
> +	fb_id = igt_create_fb(data->drm_fd, mode->hdisplay, mode->vdisplay,
> +			      DRM_FORMAT_XRGB8888, DRM_FORMAT_MOD_LINEAR,
> +			      &result_fb);
> +	igt_assert(fb_id > 0);
> +
> +	result_surface = igt_get_cairo_surface(data->drm_fd, &result_fb);
> +
> +	/* Paint the primary framebuffer on the result surface. */
> +	blit_plane_cairo(data, result_surface, 0, 0, 0, 0, 0, 0, 0, 0,
> +			 &primary_fb);
> +
> +	/* Configure the primary plane. */
> +	igt_plane_set_fb(primary_plane, &primary_fb);
> +
> +	overlay_planes_max =
> +		igt_output_count_plane_type(output, DRM_PLANE_TYPE_OVERLAY);
> +
> +	/* Limit the number of planes to a reasonable scene. */
> +	overlay_planes_max = min(overlay_planes_max, 4u);
> +
> +	overlay_planes_count = (rand() % overlay_planes_max) + 1;
> +	igt_debug("Using %d overlay planes\n", overlay_planes_count);
> +
> +	overlay_fbs = calloc(sizeof(struct igt_fb), overlay_planes_count);
> +
> +	for (i = 0; i < overlay_planes_count; i++) {
> +		struct igt_fb *overlay_fb = &overlay_fbs[i];
> +		igt_plane_t *plane = igt_output_get_plane_type_index(
> +			output, DRM_PLANE_TYPE_OVERLAY, i);
> +		igt_assert(plane);
> +
> +		prepare_randomized_plane(data, mode, plane, overlay_fb, i,
> +					 result_surface, allow_scaling,
> +					 allow_yuv);
> +	}
> +
> +	cairo_surface_destroy(result_surface);
> +
> +	if (check == CHAMELIUM_CHECK_CRC)
> +		fb_crc = chamelium_calculate_fb_crc_async_start(data->drm_fd,
> +								&result_fb);
> +
> +	igt_display_commit2(&data->display, COMMIT_ATOMIC);
> +
> +	if (check == CHAMELIUM_CHECK_CRC) {
> +		chamelium_capture(data->chamelium, port, 0, 0, 0, 0, 1);
> +		crc = chamelium_read_captured_crcs(data->chamelium,
> +						   &captured_frame_count);
> +
> +		igt_assert(captured_frame_count == 1);
> +
> +		expected_crc = chamelium_calculate_fb_crc_async_finish(fb_crc);
> +
> +		chamelium_assert_crc_eq_or_dump(data->chamelium, expected_crc,
> +						crc, &result_fb, 0);
> +
> +		free(expected_crc);
> +		free(crc);
> +	} else if (check == CHAMELIUM_CHECK_CHECKERBOARD) {
> +		struct chamelium_frame_dump *dump;
> +
> +		dump = chamelium_port_dump_pixels(data->chamelium, port, 0, 0,
> +						  0, 0);
> +		chamelium_assert_frame_match_or_dump(data->chamelium, port,
> +						     dump, &result_fb, check);
> +		chamelium_destroy_frame_dump(dump);
> +	}
> +
> +	for (i = 0; i < overlay_planes_count; i++)
> +		igt_remove_fb(data->drm_fd, &overlay_fbs[i]);
> +
> +	free(overlay_fbs);
> +
> +	igt_remove_fb(data->drm_fd, &primary_fb);
> +	igt_remove_fb(data->drm_fd, &result_fb);
> +}
> +
> +IGT_TEST_DESCRIPTION("Tests requiring a Chamelium board");
> +igt_main
> +{
> +	chamelium_data_t data;
> +	struct chamelium_port *port;
> +	int p;
> +
> +	igt_fixture {
> +		chamelium_init_test(&data);
> +	}
> +
> +	igt_describe("DisplayPort tests");
> +	igt_subtest_group {
> +		igt_fixture {
> +			chamelium_require_connector_present(
> +				data.ports, DRM_MODE_CONNECTOR_DisplayPort,
> +				data.port_count, 1);
> +		}
> +
> +		igt_describe(test_display_all_modes_desc);
> +		connector_subtest("dp-crc-single", DisplayPort)
> +			test_display_all_modes(&data, port, DRM_FORMAT_XRGB8888,
> +					       CHAMELIUM_CHECK_CRC, 1);
> +
> +		igt_describe(test_display_one_mode_desc);
> +		connector_subtest("dp-crc-fast", DisplayPort)
> +			test_display_one_mode(&data, port, DRM_FORMAT_XRGB8888,
> +					      CHAMELIUM_CHECK_CRC, 1);
> +
> +		igt_describe(test_display_all_modes_desc);
> +		connector_subtest("dp-crc-multiple", DisplayPort)
> +			test_display_all_modes(&data, port, DRM_FORMAT_XRGB8888,
> +					       CHAMELIUM_CHECK_CRC, 3);
> +
> +		igt_describe(test_display_frame_dump_desc);
> +		connector_subtest("dp-frame-dump", DisplayPort)
> +			test_display_frame_dump(&data, port);
> +	}
> +
> +	igt_describe("HDMI tests");
> +	igt_subtest_group {
> +		igt_fixture {
> +			chamelium_require_connector_present(
> +				data.ports, DRM_MODE_CONNECTOR_HDMIA,
> +				data.port_count, 1);
> +		}
> +
> +		igt_describe(test_display_all_modes_desc);
> +		connector_subtest("hdmi-crc-single", HDMIA)
> +			test_display_all_modes(&data, port, DRM_FORMAT_XRGB8888,
> +					       CHAMELIUM_CHECK_CRC, 1);
> +
> +		igt_describe(test_display_one_mode_desc);
> +		connector_subtest("hdmi-crc-fast", HDMIA)
> +			test_display_one_mode(&data, port, DRM_FORMAT_XRGB8888,
> +					      CHAMELIUM_CHECK_CRC, 1);
> +
> +		igt_describe(test_display_all_modes_desc);
> +		connector_subtest("hdmi-crc-multiple", HDMIA)
> +			test_display_all_modes(&data, port, DRM_FORMAT_XRGB8888,
> +					       CHAMELIUM_CHECK_CRC, 3);
> +
> +		igt_describe(test_display_one_mode_desc);
> +		connector_dynamic_subtest("hdmi-crc-nonplanar-formats", HDMIA)
> +		{
> +			int k;
> +			igt_output_t *output;
> +			igt_plane_t *primary;
> +
> +			output = chamelium_prepare_output(&data, port,
> +							  IGT_CUSTOM_EDID_BASE);
> +			primary = igt_output_get_plane_type(
> +				output, DRM_PLANE_TYPE_PRIMARY);
> +			igt_assert(primary);
> +
> +			for (k = 0; k < primary->format_mod_count; k++) {
> +				if (!igt_fb_supported_format(
> +					    primary->formats[k]))
> +					continue;
> +
> +				if (igt_format_is_yuv(primary->formats[k]))
> +					continue;
> +
> +				if (primary->modifiers[k] !=
> +				    DRM_FORMAT_MOD_LINEAR)
> +					continue;
> +
> +				igt_dynamic_f(
> +					"%s",
> +					igt_format_str(primary->formats[k]))
> +					test_display_one_mode(
> +						&data, port,
> +						primary->formats[k],
> +						CHAMELIUM_CHECK_CRC, 1);
> +			}
> +		}
> +
> +		igt_describe(test_display_planes_random_desc);
> +		connector_subtest("hdmi-crc-planes-random", HDMIA)
> +			test_display_planes_random(&data, port,
> +						   CHAMELIUM_CHECK_CRC);
> +
> +		igt_describe(test_display_one_mode_desc);
> +		connector_dynamic_subtest("hdmi-cmp-planar-formats", HDMIA)
> +		{
> +			int k;
> +			igt_output_t *output;
> +			igt_plane_t *primary;
> +
> +			output = chamelium_prepare_output(&data, port,
> +							  IGT_CUSTOM_EDID_BASE);
> +			primary = igt_output_get_plane_type(
> +				output, DRM_PLANE_TYPE_PRIMARY);
> +			igt_assert(primary);
> +
> +			for (k = 0; k < primary->format_mod_count; k++) {
> +				if (!igt_fb_supported_format(
> +					    primary->formats[k]))
> +					continue;
> +
> +				if (!igt_format_is_yuv(primary->formats[k]))
> +					continue;
> +
> +				if (primary->modifiers[k] !=
> +				    DRM_FORMAT_MOD_LINEAR)
> +					continue;
> +
> +				igt_dynamic_f(
> +					"%s",
> +					igt_format_str(primary->formats[k]))
> +					test_display_one_mode(
> +						&data, port,
> +						primary->formats[k],
> +						CHAMELIUM_CHECK_CHECKERBOARD,
> +						1);
> +			}
> +		}
> +
> +		igt_describe(test_display_planes_random_desc);
> +		connector_subtest("hdmi-cmp-planes-random", HDMIA)
> +			test_display_planes_random(
> +				&data, port, CHAMELIUM_CHECK_CHECKERBOARD);
> +
> +		igt_describe(test_display_frame_dump_desc);
> +		connector_subtest("hdmi-frame-dump", HDMIA)
> +			test_display_frame_dump(&data, port);
> +
> +		igt_describe(test_display_aspect_ratio_desc);
> +		connector_subtest("hdmi-aspect-ratio", HDMIA)
> +			test_display_aspect_ratio(&data, port);
> +	}
> +
> +	igt_describe("VGA tests");
> +	igt_subtest_group {
> +		igt_fixture {
> +			chamelium_require_connector_present(
> +				data.ports, DRM_MODE_CONNECTOR_VGA,
> +				data.port_count, 1);
> +		}
> +
> +		igt_describe(test_display_all_modes_desc);
> +		connector_subtest("vga-frame-dump", VGA)
> +			test_display_all_modes(&data, port, DRM_FORMAT_XRGB8888,
> +					       CHAMELIUM_CHECK_ANALOG, 1);
> +	}
> +
> +	igt_fixture {
> +		igt_display_fini(&data.display);
> +		close(data.drm_fd);
> +	}
> +}
> diff --git a/tests/chamelium/kms_chamelium_helper.c b/tests/chamelium/kms_chamelium_helper.c
> new file mode 100644
> index 00000000..b9544288
> --- /dev/null
> +++ b/tests/chamelium/kms_chamelium_helper.c
> @@ -0,0 +1,330 @@
> +// SPDX-License-Identifier: MIT
> +/*
> + * A helper library for all Chamelium tests.
> + *
> + * Copyright 2022 Google LLC.
> + *
> + * Authors: Mark Yacoub <markyacoub at chromium.org>
> + */
> +
> +#include "igt_edid.h"
> +#include "kms_chamelium_helper.h"
> +
> +void chamelium_init_test(chamelium_data_t *data)
> +{
> +	int i;
> +
> +	/* So fbcon doesn't try to reprobe things itself */
> +	kmstest_set_vt_graphics_mode();
> +
> +	data->drm_fd = drm_open_driver_master(DRIVER_ANY);
> +	igt_display_require(&data->display, data->drm_fd);
> +	igt_require(data->display.is_atomic);
> +
> +	/*
> +	 * XXX: disabling modeset, can be removed when
> +	 * igt_display_require will start doing this for us
> +	 */
> +	igt_display_commit2(&data->display, COMMIT_ATOMIC);
> +
> +	/* we need to initalize chamelium after igt_display_require */
> +	data->chamelium = chamelium_init(data->drm_fd, &data->display);
> +	igt_require(data->chamelium);
> +
> +	data->ports = chamelium_get_ports(data->chamelium, &data->port_count);
> +
> +	for (i = 0; i < IGT_CUSTOM_EDID_COUNT; ++i) {
> +		data->edids[i] = chamelium_new_edid(data->chamelium,
> +						    igt_kms_get_custom_edid(i));
> +	}
> +}
> +
> +/* Wait for hotplug and return the remaining time left from timeout */
> +bool chamelium_wait_for_hotplug(struct udev_monitor *mon, int *timeout)
> +{
> +	struct timespec start, end;
> +	int elapsed;
> +	bool detected;
> +
> +	igt_assert_eq(igt_gettime(&start), 0);
> +	detected = igt_hotplug_detected(mon, *timeout);
> +	igt_assert_eq(igt_gettime(&end), 0);
> +
> +	elapsed = igt_time_elapsed(&start, &end);
> +	igt_assert_lte(0, elapsed);
> +	*timeout = max(0, *timeout - elapsed);
> +
> +	return detected;
> +}
> +
> +/**
> + * chamelium_wait_for_connector_after_hotplug:
> + *
> + * Waits for the connector attached to @port to have a status of @status after
> + * it's plugged/unplugged.
> + *
> + */
> +void chamelium_wait_for_connector_after_hotplug(chamelium_data_t *data,
> +						struct udev_monitor *mon,
> +						struct chamelium_port *port,
> +						drmModeConnection status)
> +{
> +	int timeout = CHAMELIUM_HOTPLUG_TIMEOUT;
> +	int hotplug_count = 0;
> +
> +	igt_debug("Waiting for %s to get %s after a hotplug event...\n",
> +		  chamelium_port_get_name(port),
> +		  kmstest_connector_status_str(status));
> +
> +	while (timeout > 0) {
> +		if (!chamelium_wait_for_hotplug(mon, &timeout))
> +			break;
> +
> +		hotplug_count++;
> +
> +		if (chamelium_reprobe_connector(&data->display, data->chamelium,
> +						port) == status)
> +			return;
> +	}
> +
> +	igt_assert_f(
> +		false,
> +		"Timed out waiting for %s to get %s after a hotplug. Current state %s hotplug_count %d\n",
> +		chamelium_port_get_name(port),
> +		kmstest_connector_status_str(status),
> +		kmstest_connector_status_str(chamelium_reprobe_connector(
> +			&data->display, data->chamelium, port)),
> +		hotplug_count);
> +}
> +
> +/**
> + * chamelium_port_get_connector:
> + * @data: The Chamelium data instance to use
> + * @port: The chamelium port to prepare its connector
> + * @edid: The chamelium's default EDID has a lot of resolutions, way more then
> + * 		  we need to test. Additionally the default EDID doesn't support
> + *        HDMI audio.
> + *
> + * Makes sure the output display of the connector attached to @port is connected
> + * and ready for use.
> + *
> + * Returns: a pointer to the enabled igt_output_t
> + */
> +igt_output_t *chamelium_prepare_output(chamelium_data_t *data,
> +				       struct chamelium_port *port,
> +				       enum igt_custom_edid_type edid)
> +{
> +	igt_display_t *display = &data->display;
> +	igt_output_t *output;
> +	enum pipe pipe;
> +
> +	/* The chamelium's default EDID has a lot of resolutions, way more then
> +	 * we need to test. Additionally the default EDID doesn't support HDMI
> +	 * audio.
> +	 */
> +	chamelium_set_edid(data, port, edid);
> +
> +	chamelium_plug(data->chamelium, port);
> +	chamelium_wait_for_conn_status_change(&data->display, data->chamelium,
> +					      port, DRM_MODE_CONNECTED);
> +
> +	igt_display_reset(display);
> +
> +	output = chamelium_get_output_for_port(data, port);
> +
> +	/* Refresh pipe to update connected status */
> +	igt_output_set_pipe(output, PIPE_NONE);
> +
> +	pipe = chamelium_get_pipe_for_output(display, output);
> +	igt_output_set_pipe(output, pipe);
> +
> +	return output;
> +}
> +
> +/**
> + * chamelium_enable_output:
> + *
> + * Modesets the connector attached to @port for the assigned @mode and draws the
> + * @fb.
> + *
> + */
> +void chamelium_enable_output(chamelium_data_t *data,
> +			     struct chamelium_port *port, igt_output_t *output,
> +			     drmModeModeInfo *mode, struct igt_fb *fb)
> +{
> +	igt_display_t *display = output->display;
> +	igt_plane_t *primary =
> +		igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY);
> +	drmModeConnector *connector =
> +		chamelium_port_get_connector(data->chamelium, port, false);
> +
> +	igt_assert(primary);
> +
> +	igt_plane_set_size(primary, mode->hdisplay, mode->vdisplay);
> +	igt_plane_set_fb(primary, fb);
> +	igt_output_override_mode(output, mode);
> +
> +	/* Clear any color correction values that might be enabled */
> +	if (igt_pipe_obj_has_prop(primary->pipe, IGT_CRTC_DEGAMMA_LUT))
> +		igt_pipe_obj_replace_prop_blob(primary->pipe,
> +					       IGT_CRTC_DEGAMMA_LUT, NULL, 0);
> +	if (igt_pipe_obj_has_prop(primary->pipe, IGT_CRTC_GAMMA_LUT))
> +		igt_pipe_obj_replace_prop_blob(primary->pipe,
> +					       IGT_CRTC_GAMMA_LUT, NULL, 0);
> +	if (igt_pipe_obj_has_prop(primary->pipe, IGT_CRTC_CTM))
> +		igt_pipe_obj_replace_prop_blob(primary->pipe, IGT_CRTC_CTM,
> +					       NULL, 0);
> +
> +	igt_display_commit2(display, COMMIT_ATOMIC);
> +
> +	if (chamelium_port_get_type(port) == DRM_MODE_CONNECTOR_VGA)
> +		usleep(250000);
> +
> +	drmModeFreeConnector(connector);
> +}
> +
> +/* Return pipe attached to @outpu.t */
> +enum pipe chamelium_get_pipe_for_output(igt_display_t *display,
> +					igt_output_t *output)
> +{
> +	enum pipe pipe;
> +
> +	for_each_pipe(display, pipe) {
> +		if (igt_pipe_connector_valid(pipe, output)) {
> +			return pipe;
> +		}
> +	}
> +
> +	igt_assert_f(false, "No pipe found for output %s\n",
> +		     igt_output_name(output));
> +}
> +
> +static void chamelium_paint_xr24_pattern(uint32_t *data, size_t width,
> +					 size_t height, size_t stride,
> +					 size_t block_size)
> +{
> +	uint32_t colors[] = { 0xff000000, 0xffff0000, 0xff00ff00, 0xff0000ff,
> +			      0xffffffff };
> +	unsigned i, j;
> +
> +	for (i = 0; i < height; i++)
> +		for (j = 0; j < width; j++)
> +			*(data + i * stride / 4 +
> +			  j) = colors[((j / block_size) + (i / block_size)) % 5];
> +}
> +
> +/**
> + * chamelium_get_pattern_fb:
> + *
> + * Creates an @fb with an xr24 pattern and returns the fb_id.
> + *
> + */
> +int chamelium_get_pattern_fb(chamelium_data_t *data, size_t width,
> +			     size_t height, uint32_t fourcc, size_t block_size,
> +			     struct igt_fb *fb)
> +{
> +	int fb_id;
> +	void *ptr;
> +
> +	igt_assert(fourcc == DRM_FORMAT_XRGB8888);
> +
> +	fb_id = igt_create_fb(data->drm_fd, width, height, fourcc,
> +			      DRM_FORMAT_MOD_LINEAR, fb);
> +	igt_assert(fb_id > 0);
> +
> +	ptr = igt_fb_map_buffer(fb->fd, fb);
> +	igt_assert(ptr);
> +
> +	chamelium_paint_xr24_pattern(ptr, width, height, fb->strides[0],
> +				     block_size);
> +	igt_fb_unmap_buffer(fb, ptr);
> +
> +	return fb_id;
> +}
> +
> +/* Generate a simple @fb for the size of @mode. */
> +void chamelium_create_fb_for_mode(chamelium_data_t *data, struct igt_fb *fb,
> +				  drmModeModeInfo *mode)
> +{
> +	int fb_id;
> +
> +	fb_id = chamelium_get_pattern_fb(data, mode->hdisplay, mode->vdisplay,
> +					 DRM_FORMAT_XRGB8888, 64, fb);
> +
> +	igt_assert(fb_id > 0);
> +}
> +
> +/* Returns the first preferred mode for the connector attached to @port. */
> +drmModeModeInfo chamelium_get_mode_for_port(struct chamelium *chamelium,
> +					    struct chamelium_port *port)
> +{
> +	drmModeConnector *connector =
> +		chamelium_port_get_connector(chamelium, port, false);
> +	drmModeModeInfo mode;
> +	igt_assert(&connector->modes[0] != NULL);
> +	memcpy(&mode, &connector->modes[0], sizeof(mode));
> +	drmModeFreeConnector(connector);
> +	return mode;
> +}
> +
> +/* Returns the igt display output for the connector attached to @port. */
> +igt_output_t *chamelium_get_output_for_port(chamelium_data_t *data,
> +					    struct chamelium_port *port)
> +{
> +	drmModeConnector *connector =
> +		chamelium_port_get_connector(data->chamelium, port, true);
> +	igt_output_t *output =
> +		igt_output_from_connector(&data->display, connector);
> +	drmModeFreeConnector(connector);
> +	igt_assert(output != NULL);
> +	return output;
> +}
> +
> +/* Set the EDID of index @edid to Chamelium's @port. */
> +void chamelium_set_edid(chamelium_data_t *data, struct chamelium_port *port,
> +			enum igt_custom_edid_type edid)
> +{
> +	chamelium_port_set_edid(data->chamelium, port, data->edids[edid]);
> +}
> +
> +/**
> + * chamelium_check_analog_bridge:
> + *
> + * Check if the connector associalted to @port is an analog bridge by checking
> + * if it has its own EDID.
> + *
> + */
> +bool chamelium_check_analog_bridge(chamelium_data_t *data,
> +				   struct chamelium_port *port)
> +{
> +	drmModePropertyBlobPtr edid_blob = NULL;
> +	drmModeConnector *connector =
> +		chamelium_port_get_connector(data->chamelium, port, false);
> +	uint64_t edid_blob_id;
> +	const struct edid *edid;
> +	char edid_vendor[3];
> +
> +	if (chamelium_port_get_type(port) != DRM_MODE_CONNECTOR_VGA) {
> +		drmModeFreeConnector(connector);
> +		return false;
> +	}
> +
> +	igt_assert(kmstest_get_property(data->drm_fd, connector->connector_id,
> +					DRM_MODE_OBJECT_CONNECTOR, "EDID", NULL,
> +					&edid_blob_id, NULL));
> +	igt_assert(edid_blob =
> +			   drmModeGetPropertyBlob(data->drm_fd, edid_blob_id));
> +
> +	edid = (const struct edid *)edid_blob->data;
> +	edid_get_mfg(edid, edid_vendor);
> +
> +	drmModeFreePropertyBlob(edid_blob);
> +	drmModeFreeConnector(connector);
> +
> +	/* Analog bridges provide their own EDID */
> +	if (edid_vendor[0] != 'I' || edid_vendor[1] != 'G' ||
> +	    edid_vendor[2] != 'T')
> +		return true;
> +
> +	return false;
> +}
> \ No newline at end of file
> diff --git a/tests/chamelium/kms_chamelium_helper.h b/tests/chamelium/kms_chamelium_helper.h
> new file mode 100644
> index 00000000..09fa4829
> --- /dev/null
> +++ b/tests/chamelium/kms_chamelium_helper.h
> @@ -0,0 +1,74 @@
> +/* SPDX-License-Identifier: MIT */
> +/*
> + * A helper library for all Chamelium tests.
> + *
> + * Copyright 2022 Google LLC.
> + *
> + * Authors: Mark Yacoub <markyacoub at chromium.org>
> + */
> +
> +#ifndef TESTS_CHAMELIUM_CHAMELIUM_HELPER_H
> +#define TESTS_CHAMELIUM_CHAMELIUM_HELPER_H
> +
> +#include "igt.h"
> +
> +#define ONLINE_TIMEOUT 20 /* seconds */
> +
> +#define for_each_port(p, port)                                 \
> +	for (p = 0, port = data.ports[p]; p < data.port_count; \
> +	     p++, port = data.ports[p])
> +
> +#define connector_subtest(name__, type__)                           \
> +	igt_subtest(name__)                                         \
> +	for_each_port(p, port) if (chamelium_port_get_type(port) == \
> +				   DRM_MODE_CONNECTOR_##type__)
> +
> +/*
> + * The chamelium data structure is used to store all the information known about
> + * chamelium to run the tests.
> + */
> +typedef struct {
> +	struct chamelium *chamelium;
> +	struct chamelium_port **ports;
> +	igt_display_t display;
> +	int port_count;
> +
> +	int drm_fd;
> +
> +	struct chamelium_edid *edids[IGT_CUSTOM_EDID_COUNT];
> +} chamelium_data_t;
> +
> +void chamelium_init_test(chamelium_data_t *data);
> +
> +bool chamelium_wait_for_hotplug(struct udev_monitor *mon, int *timeout);
> +void chamelium_wait_for_connector_after_hotplug(chamelium_data_t *data,
> +						struct udev_monitor *mon,
> +						struct chamelium_port *port,
> +						drmModeConnection status);
> +
> +igt_output_t *chamelium_prepare_output(chamelium_data_t *data,
> +				       struct chamelium_port *port,
> +				       enum igt_custom_edid_type edid);
> +void chamelium_enable_output(chamelium_data_t *data,
> +			     struct chamelium_port *port, igt_output_t *output,
> +			     drmModeModeInfo *mode, struct igt_fb *fb);
> +enum pipe chamelium_get_pipe_for_output(igt_display_t *display,
> +					igt_output_t *output);
> +
> +int chamelium_get_pattern_fb(chamelium_data_t *data, size_t width,
> +			     size_t height, uint32_t fourcc, size_t block_size,
> +			     struct igt_fb *fb);
> +void chamelium_create_fb_for_mode(chamelium_data_t *data, struct igt_fb *fb,
> +				  drmModeModeInfo *mode);
> +drmModeModeInfo chamelium_get_mode_for_port(struct chamelium *chamelium,
> +					    struct chamelium_port *port);
> +igt_output_t *chamelium_get_output_for_port(chamelium_data_t *data,
> +					    struct chamelium_port *port);
> +
> +void chamelium_set_edid(chamelium_data_t *data, struct chamelium_port *port,
> +			enum igt_custom_edid_type edid);
> +
> +bool chamelium_check_analog_bridge(chamelium_data_t *data,
> +				   struct chamelium_port *port);
> +
> +#endif /* TESTS_CHAMELIUM_CHAMELIUM_HELPER_H */
> diff --git a/tests/chamelium/kms_chamelium_hpd.c b/tests/chamelium/kms_chamelium_hpd.c
> new file mode 100644
> index 00000000..8a4e1aba
> --- /dev/null
> +++ b/tests/chamelium/kms_chamelium_hpd.c
> @@ -0,0 +1,512 @@
> +// SPDX-License-Identifier: MIT
> +/*
> + * A Chamelium test for testing the HPD functionality.
> + *
> + * Copyright 2022 Google LLC.
> + *
> + * Authors: Mark Yacoub <markyacoub at chromium.org>
> + */
> +
> +#include "kms_chamelium_helper.h"
> +
> +#define HPD_STORM_PULSE_INTERVAL_DP 100 /* ms */
> +#define HPD_STORM_PULSE_INTERVAL_HDMI 200 /* ms */
> +
> +#define HPD_TOGGLE_COUNT_VGA 5
> +#define HPD_TOGGLE_COUNT_DP_HDMI 15
> +#define HPD_TOGGLE_COUNT_FAST 3
> +
> +enum test_modeset_mode {
> +	TEST_MODESET_ON,
> +	TEST_MODESET_ON_OFF,
> +	TEST_MODESET_OFF,
> +};
> +
> +static void try_suspend_resume_hpd(chamelium_data_t *data,
> +				   struct chamelium_port *port,
> +				   enum igt_suspend_state state,
> +				   enum igt_suspend_test test,
> +				   struct udev_monitor *mon, bool connected)
> +{
> +	drmModeConnection target_state = connected ? DRM_MODE_DISCONNECTED :
> +						     DRM_MODE_CONNECTED;
> +	int timeout = CHAMELIUM_HOTPLUG_TIMEOUT;
> +	int delay;
> +	int p;
> +
> +	igt_flush_uevents(mon);
> +
> +	delay = igt_get_autoresume_delay(state) * 1000 / 2;
> +
> +	if (port) {
> +		chamelium_schedule_hpd_toggle(data->chamelium, port, delay,
> +					      !connected);
> +	} else {
> +		for (p = 0; p < data->port_count; p++) {
> +			port = data->ports[p];
> +			chamelium_schedule_hpd_toggle(data->chamelium, port,
> +						      delay, !connected);
> +		}
> +
> +		port = NULL;
> +	}
> +
> +	igt_system_suspend_autoresume(state, test);
> +	igt_assert(chamelium_wait_for_hotplug(mon, &timeout));
> +	chamelium_assert_reachable(data->chamelium, ONLINE_TIMEOUT);
> +
> +	if (port) {
> +		igt_assert_eq(chamelium_reprobe_connector(
> +				      &data->display, data->chamelium, port),
> +			      target_state);
> +	} else {
> +		for (p = 0; p < data->port_count; p++) {
> +			drmModeConnection current_state;
> +
> +			port = data->ports[p];
> +			/*
> +			 * There could be as many hotplug events sent by
> +			 * driver as connectors we scheduled an HPD toggle on
> +			 * above, depending on timing. So if we're not seeing
> +			 * the expected connector state try to wait for an HPD
> +			 * event for each connector/port.
> +			 */
> +			current_state = chamelium_reprobe_connector(
> +				&data->display, data->chamelium, port);
> +			if (p > 0 && current_state != target_state) {
> +				igt_assert(chamelium_wait_for_hotplug(
> +					mon, &timeout));
> +				current_state = chamelium_reprobe_connector(
> +					&data->display, data->chamelium, port);
> +			}
> +
> +			igt_assert_eq(current_state, target_state);
> +		}
> +
> +		port = NULL;
> +	}
> +}
> +
> +static const char test_basic_hotplug_desc[] =
> +	"Check that we get uevents and updated connector status on "
> +	"hotplug and unplug";
> +static void test_hotplug(chamelium_data_t *data, struct chamelium_port *port,
> +			 int toggle_count, enum test_modeset_mode modeset_mode)
> +{
> +	int i;
> +	enum pipe pipe;
> +	struct igt_fb fb = { 0 };
> +	drmModeModeInfo mode;
> +	struct udev_monitor *mon = igt_watch_uevents();
> +	igt_output_t *output = chamelium_get_output_for_port(data, port);
> +
> +	igt_modeset_disable_all_outputs(&data->display);
> +	chamelium_reset_state(&data->display, data->chamelium, NULL,
> +			      data->ports, data->port_count);
> +
> +	igt_hpd_storm_set_threshold(data->drm_fd, 0);
> +
> +	for (i = 0; i < toggle_count; i++) {
> +		igt_flush_uevents(mon);
> +
> +		/* Check if we get a sysfs hotplug event */
> +		chamelium_plug(data->chamelium, port);
> +
> +		chamelium_wait_for_connector_after_hotplug(data, mon, port,
> +							   DRM_MODE_CONNECTED);
> +		igt_flush_uevents(mon);
> +
> +		if (modeset_mode == TEST_MODESET_ON_OFF ||
> +		    (modeset_mode == TEST_MODESET_ON && i == 0)) {
> +			if (i == 0) {
> +				/* We can only get mode and pipe once we are
> +				 * connected */
> +				output = chamelium_get_output_for_port(data,
> +								       port);
> +				pipe = chamelium_get_pipe_for_output(
> +					&data->display, output);
> +				mode = chamelium_get_mode_for_port(
> +					data->chamelium, port);
> +				chamelium_create_fb_for_mode(data, &fb, &mode);
> +			}
> +
> +			igt_output_set_pipe(output, pipe);
> +			chamelium_enable_output(data, port, output, &mode, &fb);
> +		}
> +
> +		/* Now check if we get a hotplug from disconnection */
> +		chamelium_unplug(data->chamelium, port);
> +
> +		chamelium_wait_for_connector_after_hotplug(
> +			data, mon, port, DRM_MODE_DISCONNECTED);
> +
> +		igt_flush_uevents(mon);
> +
> +		if (modeset_mode == TEST_MODESET_ON_OFF) {
> +			igt_output_set_pipe(output, PIPE_NONE);
> +			igt_display_commit2(&data->display, COMMIT_ATOMIC);
> +		}
> +	}
> +
> +	igt_cleanup_uevents(mon);
> +	igt_hpd_storm_reset(data->drm_fd);
> +	igt_remove_fb(data->drm_fd, &fb);
> +}
> +
> +static const char test_hotplug_for_each_pipe_desc[] =
> +	"Check that we get uevents and updated connector status on "
> +	"hotplug and unplug for each pipe with valid output";
> +static void test_hotplug_for_each_pipe(chamelium_data_t *data,
> +				       struct chamelium_port *port)
> +{
> +	igt_output_t *output;
> +	enum pipe pipe;
> +	struct udev_monitor *mon = igt_watch_uevents();
> +
> +	chamelium_reset_state(&data->display, data->chamelium, port,
> +			      data->ports, data->port_count);
> +
> +	igt_hpd_storm_set_threshold(data->drm_fd, 0);
> +	/* Disconnect if any port got connected */
> +	chamelium_unplug(data->chamelium, port);
> +	chamelium_wait_for_connector_after_hotplug(data, mon, port,
> +						   DRM_MODE_DISCONNECTED);
> +
> +	for_each_pipe(&data->display, pipe) {
> +		igt_flush_uevents(mon);
> +		/* Check if we get a sysfs hotplug event */
> +		chamelium_plug(data->chamelium, port);
> +		chamelium_wait_for_connector_after_hotplug(data, mon, port,
> +							   DRM_MODE_CONNECTED);
> +		igt_flush_uevents(mon);
> +		output = chamelium_get_output_for_port(data, port);
> +
> +		/* If pipe is valid for output then set it */
> +		if (igt_pipe_connector_valid(pipe, output)) {
> +			igt_output_set_pipe(output, pipe);
> +			igt_display_commit2(&data->display, COMMIT_ATOMIC);
> +		}
> +
> +		chamelium_unplug(data->chamelium, port);
> +		chamelium_wait_for_connector_after_hotplug(
> +			data, mon, port, DRM_MODE_DISCONNECTED);
> +		igt_flush_uevents(mon);
> +	}
> +
> +	igt_cleanup_uevents(mon);
> +	igt_hpd_storm_reset(data->drm_fd);
> +}
> +
> +static const char test_suspend_resume_hpd_desc[] =
> +	"Toggle HPD during suspend, check that uevents are sent and connector "
> +	"status is updated";
> +static void test_suspend_resume_hpd(chamelium_data_t *data,
> +				    struct chamelium_port *port,
> +				    enum igt_suspend_state state,
> +				    enum igt_suspend_test test)
> +{
> +	struct udev_monitor *mon = igt_watch_uevents();
> +
> +	igt_modeset_disable_all_outputs(&data->display);
> +	chamelium_reset_state(&data->display, data->chamelium, port,
> +			      data->ports, data->port_count);
> +
> +	/* Make sure we notice new connectors after resuming */
> +	try_suspend_resume_hpd(data, port, state, test, mon, false);
> +
> +	/* Now make sure we notice disconnected connectors after resuming */
> +	try_suspend_resume_hpd(data, port, state, test, mon, true);
> +
> +	igt_cleanup_uevents(mon);
> +}
> +
> +static const char test_suspend_resume_hpd_common_desc[] =
> +	"Toggle HPD during suspend on all connectors, check that uevents are "
> +	"sent and connector status is updated";
> +static void test_suspend_resume_hpd_common(chamelium_data_t *data,
> +					   enum igt_suspend_state state,
> +					   enum igt_suspend_test test)
> +{
> +	struct udev_monitor *mon = igt_watch_uevents();
> +	struct chamelium_port *port;
> +	int p;
> +
> +	for (p = 0; p < data->port_count; p++) {
> +		port = data->ports[p];
> +		igt_debug("Testing port %s\n", chamelium_port_get_name(port));
> +	}
> +
> +	igt_modeset_disable_all_outputs(&data->display);
> +	chamelium_reset_state(&data->display, data->chamelium, NULL,
> +			      data->ports, data->port_count);
> +
> +	/* Make sure we notice new connectors after resuming */
> +	try_suspend_resume_hpd(data, NULL, state, test, mon, false);
> +
> +	/* Now make sure we notice disconnected connectors after resuming */
> +	try_suspend_resume_hpd(data, NULL, state, test, mon, true);
> +
> +	igt_cleanup_uevents(mon);
> +}
> +
> +static const char test_hpd_without_ddc_desc[] =
> +	"Disable DDC on a VGA connector, check we still get a uevent on hotplug";
> +static void test_hpd_without_ddc(chamelium_data_t *data,
> +				 struct chamelium_port *port)
> +{
> +	struct udev_monitor *mon = igt_watch_uevents();
> +
> +	igt_modeset_disable_all_outputs(&data->display);
> +	chamelium_reset_state(&data->display, data->chamelium, port,
> +			      data->ports, data->port_count);
> +	igt_flush_uevents(mon);
> +
> +	/* Disable the DDC on the connector and make sure we still get a
> +	 * hotplug
> +	 */
> +	chamelium_port_set_ddc_state(data->chamelium, port, false);
> +	chamelium_plug(data->chamelium, port);
> +
> +	igt_assert(igt_hotplug_detected(mon, CHAMELIUM_HOTPLUG_TIMEOUT));
> +	igt_assert_eq(chamelium_reprobe_connector(&data->display,
> +						  data->chamelium, port),
> +		      DRM_MODE_CONNECTED);
> +
> +	igt_cleanup_uevents(mon);
> +}
> +
> +static const char test_hpd_storm_detect_desc[] =
> +	"Trigger a series of hotplugs in a very small timeframe to simulate a"
> +	"bad cable, check the kernel falls back to polling to avoid a hotplug "
> +	"storm";
> +static void test_hpd_storm_detect(chamelium_data_t *data,
> +				  struct chamelium_port *port, int width)
> +{
> +	struct udev_monitor *mon;
> +	int count = 0;
> +
> +	igt_require_hpd_storm_ctl(data->drm_fd);
> +	igt_modeset_disable_all_outputs(&data->display);
> +	chamelium_reset_state(&data->display, data->chamelium, port,
> +			      data->ports, data->port_count);
> +
> +	igt_hpd_storm_set_threshold(data->drm_fd, 1);
> +	chamelium_fire_hpd_pulses(data->chamelium, port, width, 10);
> +	igt_assert(igt_hpd_storm_detected(data->drm_fd));
> +
> +	mon = igt_watch_uevents();
> +	chamelium_fire_hpd_pulses(data->chamelium, port, width, 10);
> +
> +	/*
> +	 * Polling should have been enabled by the HPD storm at this point,
> +	 * so we should only get at most 1 hotplug event
> +	 */
> +	igt_until_timeout(5)
> +		count += igt_hotplug_detected(mon, 1);
> +	igt_assert_lt(count, 2);
> +
> +	igt_cleanup_uevents(mon);
> +	igt_hpd_storm_reset(data->drm_fd);
> +}
> +
> +static const char test_hpd_storm_disable_desc[] =
> +	"Disable HPD storm detection, trigger a storm and check the kernel "
> +	"doesn't detect one";
> +static void test_hpd_storm_disable(chamelium_data_t *data,
> +				   struct chamelium_port *port, int width)
> +{
> +	igt_require_hpd_storm_ctl(data->drm_fd);
> +	igt_modeset_disable_all_outputs(&data->display);
> +	chamelium_reset_state(&data->display, data->chamelium, port,
> +			      data->ports, data->port_count);
> +
> +	igt_hpd_storm_set_threshold(data->drm_fd, 0);
> +	chamelium_fire_hpd_pulses(data->chamelium, port, width, 10);
> +	igt_assert(!igt_hpd_storm_detected(data->drm_fd));
> +
> +	igt_hpd_storm_reset(data->drm_fd);
> +}
> +
> +IGT_TEST_DESCRIPTION("Testing HPD with a Chamelium board");
> +igt_main
> +{
> +	chamelium_data_t data;
> +	struct chamelium_port *port;
> +	int p;
> +
> +	igt_fixture {
> +		chamelium_init_test(&data);
> +	}
> +
> +	igt_describe("DisplayPort tests");
> +	igt_subtest_group {
> +		igt_fixture {
> +			chamelium_require_connector_present(
> +				data.ports, DRM_MODE_CONNECTOR_DisplayPort,
> +				data.port_count, 1);
> +		}
> +
> +		igt_describe(test_basic_hotplug_desc);
> +		connector_subtest("dp-hpd", DisplayPort)
> +			test_hotplug(&data, port, HPD_TOGGLE_COUNT_DP_HDMI,
> +				     TEST_MODESET_OFF);
> +
> +		igt_describe(test_basic_hotplug_desc);
> +		connector_subtest("dp-hpd-fast", DisplayPort) test_hotplug(
> +			&data, port, HPD_TOGGLE_COUNT_FAST, TEST_MODESET_OFF);
> +
> +		igt_describe(test_basic_hotplug_desc);
> +		connector_subtest("dp-hpd-enable-disable-mode", DisplayPort)
> +			test_hotplug(&data, port, HPD_TOGGLE_COUNT_FAST,
> +				     TEST_MODESET_ON_OFF);
> +
> +		igt_describe(test_basic_hotplug_desc);
> +		connector_subtest("dp-hpd-with-enabled-mode", DisplayPort)
> +			test_hotplug(&data, port, HPD_TOGGLE_COUNT_FAST,
> +				     TEST_MODESET_ON);
> +
> +		igt_describe(test_hotplug_for_each_pipe_desc);
> +		connector_subtest("dp-hpd-for-each-pipe", DisplayPort)
> +			test_hotplug_for_each_pipe(&data, port);
> +
> +		igt_describe(test_suspend_resume_hpd_desc);
> +		connector_subtest("dp-hpd-after-suspend", DisplayPort)
> +			test_suspend_resume_hpd(&data, port, SUSPEND_STATE_MEM,
> +						SUSPEND_TEST_NONE);
> +
> +		igt_describe(test_suspend_resume_hpd_desc);
> +		connector_subtest("dp-hpd-after-hibernate", DisplayPort)
> +			test_suspend_resume_hpd(&data, port, SUSPEND_STATE_DISK,
> +						SUSPEND_TEST_DEVICES);
> +
> +		igt_describe(test_hpd_storm_detect_desc);
> +		connector_subtest("dp-hpd-storm", DisplayPort)
> +			test_hpd_storm_detect(&data, port,
> +					      HPD_STORM_PULSE_INTERVAL_DP);
> +
> +		igt_describe(test_hpd_storm_disable_desc);
> +		connector_subtest("dp-hpd-storm-disable", DisplayPort)
> +			test_hpd_storm_disable(&data, port,
> +					       HPD_STORM_PULSE_INTERVAL_DP);
> +	}
> +
> +	igt_describe("HDMI tests");
> +	igt_subtest_group {
> +		igt_fixture {
> +			chamelium_require_connector_present(
> +				data.ports, DRM_MODE_CONNECTOR_HDMIA,
> +				data.port_count, 1);
> +		}
> +
> +		igt_describe(test_basic_hotplug_desc);
> +		connector_subtest("hdmi-hpd", HDMIA)
> +			test_hotplug(&data, port, HPD_TOGGLE_COUNT_DP_HDMI,
> +				     TEST_MODESET_OFF);
> +
> +		igt_describe(test_basic_hotplug_desc);
> +		connector_subtest("hdmi-hpd-fast", HDMIA) test_hotplug(
> +			&data, port, HPD_TOGGLE_COUNT_FAST, TEST_MODESET_OFF);
> +
> +		igt_describe(test_basic_hotplug_desc);
> +		connector_subtest("hdmi-hpd-enable-disable-mode", HDMIA)
> +			test_hotplug(&data, port, HPD_TOGGLE_COUNT_FAST,
> +				     TEST_MODESET_ON_OFF);
> +
> +		igt_describe(test_basic_hotplug_desc);
> +		connector_subtest("hdmi-hpd-with-enabled-mode", HDMIA)
> +			test_hotplug(&data, port, HPD_TOGGLE_COUNT_FAST,
> +				     TEST_MODESET_ON);
> +
> +		igt_describe(test_hotplug_for_each_pipe_desc);
> +		connector_subtest("hdmi-hpd-for-each-pipe", HDMIA)
> +			test_hotplug_for_each_pipe(&data, port);
> +
> +		igt_describe(test_suspend_resume_hpd_desc);
> +		connector_subtest("hdmi-hpd-after-suspend", HDMIA)
> +			test_suspend_resume_hpd(&data, port, SUSPEND_STATE_MEM,
> +						SUSPEND_TEST_NONE);
> +
> +		igt_describe(test_suspend_resume_hpd_desc);
> +		connector_subtest("hdmi-hpd-after-hibernate", HDMIA)
> +			test_suspend_resume_hpd(&data, port, SUSPEND_STATE_DISK,
> +						SUSPEND_TEST_DEVICES);
> +
> +		igt_describe(test_hpd_storm_detect_desc);
> +		connector_subtest("hdmi-hpd-storm", HDMIA)
> +			test_hpd_storm_detect(&data, port,
> +					      HPD_STORM_PULSE_INTERVAL_HDMI);
> +
> +		igt_describe(test_hpd_storm_disable_desc);
> +		connector_subtest("hdmi-hpd-storm-disable", HDMIA)
> +			test_hpd_storm_disable(&data, port,
> +					       HPD_STORM_PULSE_INTERVAL_HDMI);
> +	}
> +
> +	igt_describe("VGA tests");
> +	igt_subtest_group {
> +		igt_fixture {
> +			chamelium_require_connector_present(
> +				data.ports, DRM_MODE_CONNECTOR_VGA,
> +				data.port_count, 1);
> +		}
> +
> +		igt_describe(test_basic_hotplug_desc);
> +		connector_subtest("vga-hpd", VGA) test_hotplug(
> +			&data, port, HPD_TOGGLE_COUNT_VGA, TEST_MODESET_OFF);
> +
> +		igt_describe(test_basic_hotplug_desc);
> +		connector_subtest("vga-hpd-fast", VGA) test_hotplug(
> +			&data, port, HPD_TOGGLE_COUNT_FAST, TEST_MODESET_OFF);
> +
> +		igt_describe(test_basic_hotplug_desc);
> +		connector_subtest("vga-hpd-enable-disable-mode", VGA)
> +			test_hotplug(&data, port, HPD_TOGGLE_COUNT_FAST,
> +				     TEST_MODESET_ON_OFF);
> +
> +		igt_describe(test_basic_hotplug_desc);
> +		connector_subtest("vga-hpd-with-enabled-mode", VGA)
> +			test_hotplug(&data, port, HPD_TOGGLE_COUNT_FAST,
> +				     TEST_MODESET_ON);
> +
> +		igt_describe(test_suspend_resume_hpd_desc);
> +		connector_subtest("vga-hpd-after-suspend", VGA)
> +			test_suspend_resume_hpd(&data, port, SUSPEND_STATE_MEM,
> +						SUSPEND_TEST_NONE);
> +
> +		igt_describe(test_suspend_resume_hpd_desc);
> +		connector_subtest("vga-hpd-after-hibernate", VGA)
> +			test_suspend_resume_hpd(&data, port, SUSPEND_STATE_DISK,
> +						SUSPEND_TEST_DEVICES);
> +
> +		igt_describe(test_hpd_without_ddc_desc);
> +		connector_subtest("vga-hpd-without-ddc", VGA)
> +			test_hpd_without_ddc(&data, port);
> +	}
> +
> +	igt_describe("Tests that operate on all connectors");
> +	igt_subtest_group {
> +		igt_fixture {
> +			igt_require(data.port_count);
> +		}
> +
> +		igt_describe(test_suspend_resume_hpd_common_desc);
> +		igt_subtest("common-hpd-after-suspend")
> +			test_suspend_resume_hpd_common(&data, SUSPEND_STATE_MEM,
> +						       SUSPEND_TEST_NONE);
> +
> +		igt_describe(test_suspend_resume_hpd_common_desc);
> +		igt_subtest("common-hpd-after-hibernate")
> +			test_suspend_resume_hpd_common(&data,
> +						       SUSPEND_STATE_DISK,
> +						       SUSPEND_TEST_DEVICES);
> +	}
> +
> +	igt_describe(test_hotplug_for_each_pipe_desc);
> +	connector_subtest("vga-hpd-for-each-pipe", VGA)
> +		test_hotplug_for_each_pipe(&data, port);
> +
> +	igt_fixture {
> +		igt_display_fini(&data.display);
> +		close(data.drm_fd);
> +	}
> +}
> diff --git a/tests/intel-ci/blacklist.txt b/tests/intel-ci/blacklist.txt
> index 0d307730..6e5cc436 100644
> --- a/tests/intel-ci/blacklist.txt
> +++ b/tests/intel-ci/blacklist.txt
> @@ -77,7 +77,7 @@ igt at kms_frontbuffer_tracking@.*drrs.*
>  # is too costly in comparison to the value
>  # provided.
>  ###############################################
> -igt at kms_chamelium@hdmi-.*-planes-random
> +igt at kms_chamelium_frames@hdmi-.*-planes-random
>  ###############################################
>  # Broadcom
>  ###############################################
> diff --git a/tests/intel-ci/fast-feedback.testlist b/tests/intel-ci/fast-feedback.testlist
> index f57f8ff3..fb4c0f73 100644
> --- a/tests/intel-ci/fast-feedback.testlist
> +++ b/tests/intel-ci/fast-feedback.testlist
> @@ -92,14 +92,14 @@ igt at kms_addfb_basic@unused-modifier
>  igt at kms_addfb_basic@unused-offsets
>  igt at kms_addfb_basic@unused-pitches
>  igt at kms_busy@basic
> -igt at kms_chamelium@dp-hpd-fast
> -igt at kms_chamelium@dp-edid-read
> -igt at kms_chamelium@dp-crc-fast
> -igt at kms_chamelium@hdmi-hpd-fast
> -igt at kms_chamelium@hdmi-edid-read
> -igt at kms_chamelium@hdmi-crc-fast
> -igt at kms_chamelium@vga-hpd-fast
> -igt at kms_chamelium@vga-edid-read
> +igt at kms_chamelium_hpd@dp-hpd-fast
> +igt at kms_chamelium_edid@dp-edid-read
> +igt at kms_chamelium_frames@dp-crc-fast
> +igt at kms_chamelium_hpd@hdmi-hpd-fast
> +igt at kms_chamelium_edid@hdmi-edid-read
> +igt at kms_chamelium_frames@hdmi-crc-fast
> +igt at kms_chamelium_hpd@vga-hpd-fast
> +igt at kms_chamelium_edid@vga-edid-read
>  igt at kms_prop_blob@basic
>  igt at kms_cursor_legacy@basic-busy-flip-before-cursor
>  igt at kms_cursor_legacy@basic-flip-after-cursor
> @@ -174,5 +174,5 @@ igt at i915_suspend@basic-s2idle-without-i915
>  igt at i915_suspend@basic-s3-without-i915
>  igt at gem_exec_suspend@basic-s0
>  igt at gem_exec_suspend@basic-s3
> -igt at kms_chamelium@common-hpd-after-suspend
> +igt at kms_chamelium_hpd@common-hpd-after-suspend
>  igt at kms_pipe_crc_basic@suspend-read-crc
> diff --git a/tests/kms_color_helper.h b/tests/kms_color_helper.h
> index f0ae30e3..f9242232 100644
> --- a/tests/kms_color_helper.h
> +++ b/tests/kms_color_helper.h
> @@ -27,7 +27,7 @@
>  
>  /*
>   * This header is for code that is shared between kms_color.c and
> - * kms_color_chamelium.c. Reusability elsewhere can be questionable.
> + * kms_chamelium_color.c. Reusability elsewhere can be questionable.
>   */
>  
>  #include <math.h>
> diff --git a/tests/meson.build b/tests/meson.build
> index 5c052e73..b52399d5 100644
> --- a/tests/meson.build
> +++ b/tests/meson.build
> @@ -260,7 +260,10 @@ msm_progs = [
>  ]
>  
>  chamelium_progs = [
> -	'kms_chamelium',
> +	'kms_chamelium_audio',
> +	'kms_chamelium_edid',
> +	'kms_chamelium_frames',
> +	'kms_chamelium_hpd',
>  ]
>  
>  test_deps = [ igt_deps ]
> @@ -309,7 +312,8 @@ endforeach
>  if chamelium.found()
>  	foreach prog : chamelium_progs
>  		test_executables += executable(prog,
> -				 join_paths('chamelium', prog + '.c'),
> +				 [join_paths('chamelium', prog + '.c'), 
> +				 	join_paths('chamelium', 'kms_chamelium_helper.c')],
>  				 dependencies : test_deps,
>  				 install_dir : libexecdir,
>  				 install_rpath : libexecdir_rpathdir,
> @@ -436,13 +440,13 @@ test_executables += executable('kms_color',
>  test_list += 'kms_color'
>  
>  if chamelium.found()
> -       test_executables += executable('kms_color_chamelium',
> -                             [ 'chamelium/kms_color_chamelium.c', 'kms_color_helper.c' ],
> +       test_executables += executable('kms_chamelium_color',
> +                             [ 'chamelium/kms_chamelium_color.c', 'kms_color_helper.c' ],
>                               dependencies : test_deps + [ chamelium ],
>                               install_dir : libexecdir,
>                               install_rpath : libexecdir_rpathdir,
>                               install : true)
> -       test_list += 'kms_color_chamelium'
> +       test_list += 'kms_chamelium_color'
>  endif
>  
>  test_executables += executable('sw_sync', 'sw_sync.c',
> diff --git a/tests/vc4_ci/vc4-chamelium-fast.testlist b/tests/vc4_ci/vc4-chamelium-fast.testlist
> index dd45d12a..a5521021 100644
> --- a/tests/vc4_ci/vc4-chamelium-fast.testlist
> +++ b/tests/vc4_ci/vc4-chamelium-fast.testlist
> @@ -1,14 +1,14 @@
> -igt at kms_chamelium@hdmi-crc-abgr8888
> -igt at kms_chamelium@hdmi-crc-argb1555
> -igt at kms_chamelium@hdmi-crc-argb8888
> -igt at kms_chamelium@hdmi-crc-bgr565
> -igt at kms_chamelium@hdmi-crc-bgr888
> -igt at kms_chamelium@hdmi-crc-fast
> -igt at kms_chamelium@hdmi-crc-rgb565
> -igt at kms_chamelium@hdmi-crc-rgb888
> -igt at kms_chamelium@hdmi-crc-xbgr8888
> -igt at kms_chamelium@hdmi-crc-xrgb1555
> -igt at kms_chamelium@hdmi-crc-xrgb8888
> -igt at kms_chamelium@hdmi-edid-read
> -igt at kms_chamelium@hdmi-hpd
> -igt at kms_chamelium@hdmi-hpd-fast
> +igt at kms_chamelium_frames@hdmi-crc-abgr8888
> +igt at kms_chamelium_frames@hdmi-crc-argb1555
> +igt at kms_chamelium_frames@hdmi-crc-argb8888
> +igt at kms_chamelium_frames@hdmi-crc-bgr565
> +igt at kms_chamelium_frames@hdmi-crc-bgr888
> +igt at kms_chamelium_frames@hdmi-crc-fast
> +igt at kms_chamelium_frames@hdmi-crc-rgb565
> +igt at kms_chamelium_frames@hdmi-crc-rgb888
> +igt at kms_chamelium_frames@hdmi-crc-xbgr8888
> +igt at kms_chamelium_frames@hdmi-crc-xrgb1555
> +igt at kms_chamelium_frames@hdmi-crc-xrgb8888
> +igt at kms_chamelium_edid@hdmi-edid-read
> +igt at kms_chamelium_hpd@hdmi-hpd
> +igt at kms_chamelium_hpd@hdmi-hpd-fast

-- 
Jani Nikula, Intel Open Source Graphics Center


More information about the igt-dev mailing list