tests: add kms_setmode

Iterate through all valid/invalid crtc/connector combinations. At the
moment only clone configurations are tested as the single output cases
are tested already by testdisplay. Also from combinations where all
connectors are on the same crtc (clone-single-crtc) only those are
tested that are invalid, as I haven't found any machine that supports
these (have to be GT2 with dvo and vga output).

For configurations with one crtc per connector the FBs are per-crtc atm.

Signed-off-by: Imre Deak <imre.deak@intel.com>

1 files changed, 728 insertions, 0 deletions

diff --git a/tests/kms_setmode.c b/tests/kms_setmode.c
new file mode 100644
index 00000000..47fab25a
--- /dev/null
+++ b/tests/kms_setmode.c
@@ -0,0 +1,728 @@
+/*
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * 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:
+ *    Imre Deak <imre.deak@intel.com>
+ */
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <assert.h>
+#include <cairo.h>
+#include <errno.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <string.h>
+#include <getopt.h>
+#include <sys/time.h>
+
+#include "drm_fourcc.h"
+#include "drmtest.h"
+#include "intel_bufmgr.h"
+#include "intel_batchbuffer.h"
+#include "intel_gpu_tools.h"
+
+#define MAX_CONNECTORS  10
+#define MAX_CRTCS       3
+
+/* max combinations with repetitions */
+#define MAX_COMBINATION_COUNT   \
+	(MAX_CONNECTORS * MAX_CONNECTORS * MAX_CONNECTORS)
+#define MAX_COMBINATION_ELEMS   MAX_CRTCS
+
+static int drm_fd;
+static drmModeRes *drm_resources;
+static int filter_test_id;
+static bool dry_run;
+
+const drmModeModeInfo mode_640_480 = {
+	.name		= "640x480",
+	.vrefresh	= 60,
+	.clock		= 25200,
+
+	.hdisplay	= 640,
+	.hsync_start	= 656,
+	.hsync_end	= 752,
+	.htotal		= 800,
+
+	.vdisplay	= 480,
+	.vsync_start	= 490,
+	.vsync_end	= 492,
+	.vtotal		= 525,
+
+	.flags		= DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC,
+};
+
+enum test_flags {
+	TEST_INVALID			= 0x01,
+	TEST_CLONE			= 0x02,
+	TEST_SINGLE_CRTC_CLONE		= 0x04,
+	TEST_EXCLUSIVE_CRTC_CLONE	= 0x08,
+};
+
+struct test_config {
+	const char *name;
+	enum test_flags flags;
+	drmModeRes *resources;
+};
+
+struct connector_config {
+	drmModeConnector *connector;
+	int crtc_idx;
+	bool connected;
+	drmModeModeInfo default_mode;
+};
+
+struct crtc_config {
+	int crtc_idx;
+	int crtc_id;
+	int pipe_id;
+	int connector_count;
+	struct connector_config *cconfs;
+	struct kmstest_fb fb_info;
+	drmModeModeInfo mode;
+};
+
+static bool drm_mode_equal(drmModeModeInfo *m1, drmModeModeInfo *m2)
+{
+#define COMP(x) do { if (m1->x != m2->x) return false; } while (0)
+	COMP(vrefresh);
+	COMP(clock);
+	COMP(hdisplay);
+	COMP(hsync_start);
+	COMP(hsync_end);
+	COMP(htotal);
+	COMP(vdisplay);
+	COMP(vsync_start);
+	COMP(vsync_end);
+	COMP(vtotal);
+	COMP(flags);
+
+	return true;
+}
+
+static bool connector_supports_mode(drmModeConnector *connector,
+				    drmModeModeInfo *mode)
+{
+	int i;
+
+	for (i = 0; i < connector->count_modes; i++)
+		if (drm_mode_equal(&connector->modes[i], mode))
+			return true;
+
+	return false;
+}
+
+static bool crtc_supports_mode(struct crtc_config *crtc, drmModeModeInfo *mode)
+{
+	int i;
+
+	for (i = 0; i < crtc->connector_count; i++) {
+		if (!connector_supports_mode(crtc->cconfs[i].connector, mode))
+			return false;
+	}
+
+	return true;
+}
+
+static int paint_fb(struct kmstest_fb *fb, const char *test_name,
+		    const char **crtc_str, int crtc_count, int current_crtc_idx)
+{
+	double x, y;
+	cairo_t *cr;
+	int i;
+
+	cr = kmstest_get_cairo_ctx(drm_fd, fb);
+	if (!cr)
+		return -1;
+
+	kmstest_paint_test_pattern(cr, fb->width, fb->height);
+
+	cairo_select_font_face(cr, "Helvetica", CAIRO_FONT_SLANT_NORMAL,
+			       CAIRO_FONT_WEIGHT_NORMAL);
+	cairo_move_to(cr, fb->width / 2, fb->height / 2);
+	cairo_set_font_size(cr, 24);
+	kmstest_cairo_printf_line(cr, align_hcenter, 40, "%s", test_name);
+
+	cairo_get_current_point(cr, &x, &y);
+	cairo_move_to(cr, 60, y);
+
+	for (i = 0; i < crtc_count; i++) {
+		if (i == current_crtc_idx) {
+			cairo_get_current_point(cr, &x, &y);
+			cairo_move_to(cr, x - 20, y);
+			kmstest_cairo_printf_line(cr, align_right, 20, "X");
+			cairo_move_to(cr, x, y);
+		}
+		kmstest_cairo_printf_line(cr, align_left, 20, "%s",
+					  crtc_str[i]);
+	}
+
+	return 0;
+}
+
+static void create_fb_for_crtc(struct crtc_config *crtc,
+			       struct kmstest_fb *fb_info)
+{
+	int bpp;
+	int depth;
+	bool enable_tiling;
+	int fb_id;
+
+	bpp = 32;
+	depth = 24;
+	enable_tiling = false;
+	fb_id = kmstest_create_fb(drm_fd, crtc->mode.hdisplay,
+				  crtc->mode.vdisplay, bpp, depth,
+				  enable_tiling, fb_info);
+	assert(fb_id > 0);
+}
+
+static void get_mode_for_crtc(struct crtc_config *crtc,
+			      drmModeModeInfo *mode_ret)
+{
+	drmModeModeInfo mode;
+	int i;
+
+	/*
+	 * First try to select a default mode that is supported by all
+	 * connectors.
+	 */
+	for (i = 0; i < crtc->connector_count; i++) {
+		mode = crtc->cconfs[i].default_mode;
+		if (crtc_supports_mode(crtc, &mode))
+			goto found;
+	}
+
+	/*
+	 * Then just fall back to find any that is supported by all
+	 * connectors.
+	 */
+	for (i = 0; i < crtc->cconfs[0].connector->count_modes; i++) {
+		mode = crtc->cconfs[0].connector->modes[i];
+		if (crtc_supports_mode(crtc, &mode))
+			goto found;
+	}
+
+	/*
+	 * If none is found then just pick the default mode of the first
+	 * connector and hope the other connectors can support it by scaling
+	 * etc.
+	 */
+	mode = crtc->cconfs[0].default_mode;
+found:
+	*mode_ret = mode;
+}
+
+static int get_encoder_idx(drmModeRes *resources, drmModeEncoder *encoder)
+{
+	int i;
+
+	for (i = 0; i < resources->count_encoders; i++)
+		if (resources->encoders[i] == encoder->encoder_id)
+			return i;
+	assert(0);
+}
+
+static void get_crtc_config_str(struct crtc_config *crtc, char *buf,
+				size_t buf_size)
+{
+	int pos;
+	int i;
+
+	pos = snprintf(buf, buf_size,
+		       "CRTC[%d] [Pipe %s] Mode: %s@%dHz Connectors: ",
+		       crtc->crtc_id, kmstest_pipe_str(crtc->pipe_id),
+		       crtc->mode.name, crtc->mode.vrefresh);
+	if (pos > buf_size)
+		return;
+	for (i = 0; i < crtc->connector_count; i++) {
+		drmModeConnector *connector = crtc->cconfs[i].connector;
+
+		pos += snprintf(&buf[pos], buf_size - pos,
+			"%s%s-%d[%d]%s", i ? ", " : "",
+			kmstest_connector_type_str(connector->connector_type),
+			connector->connector_type_id, connector->connector_id,
+			crtc->cconfs[i].connected ? "" : " (NC)");
+		if (pos > buf_size)
+			return;
+	}
+}
+
+static void setup_crtcs(drmModeRes *resources, struct connector_config *cconf,
+			int connector_count, struct crtc_config *crtcs,
+			int *crtc_count_ret, bool *config_valid_ret)
+{
+	struct crtc_config *crtc;
+	int crtc_count;
+	bool config_valid;
+	int i;
+
+	i = 0;
+	crtc_count = 0;
+	crtc = crtcs;
+	config_valid = true;
+
+	while (i < connector_count) {
+		drmModeCrtc *drm_crtc;
+		unsigned long encoder_mask;
+		int j;
+
+		igt_assert(crtc_count < MAX_CRTCS);
+
+		crtc->crtc_idx = cconf[i].crtc_idx;
+		drm_crtc = drmModeGetCrtc(drm_fd,
+					  resources->crtcs[crtc->crtc_idx]);
+		crtc->crtc_id = drm_crtc->crtc_id;
+		drmModeFreeCrtc(drm_crtc);
+		crtc->pipe_id = kmstest_get_pipe_from_crtc_id(drm_fd,
+							      crtc->crtc_id);
+
+		crtc->connector_count = 1;
+		for (j = i + 1; j < connector_count; j++)
+			if (cconf[j].crtc_idx == crtc->crtc_idx)
+				crtc->connector_count++;
+
+		crtc->cconfs = malloc(sizeof(*crtc->cconfs) *
+				      crtc->connector_count);
+		assert(crtc->cconfs);
+
+		encoder_mask = 0;
+		for (j = 0; j < crtc->connector_count; j++) {
+			drmModeConnector *connector;
+			drmModeEncoder *encoder;
+
+			crtc->cconfs[j] = cconf[i + j];
+			connector = cconf[i + j].connector;
+
+			/* Intel connectors have only a single encoder */
+			igt_assert(connector->count_encoders == 1);
+			encoder = drmModeGetEncoder(drm_fd,
+						    connector->encoders[0]);
+			assert(encoder);
+
+			config_valid &= !!(encoder->possible_crtcs &
+					  (1 << crtc->crtc_idx));
+
+			encoder_mask |= 1 << get_encoder_idx(resources,
+							     encoder);
+			config_valid &= !(encoder_mask &
+					  ~encoder->possible_clones);
+
+			drmModeFreeEncoder(encoder);
+		}
+		get_mode_for_crtc(crtc, &crtc->mode);
+		create_fb_for_crtc(crtc, &crtc->fb_info);
+
+		i += crtc->connector_count;
+		crtc_count++;
+		crtc++;
+	}
+
+	*crtc_count_ret = crtc_count;
+	*config_valid_ret = config_valid;
+}
+
+static void cleanup_crtcs(struct crtc_config *crtcs, int crtc_count)
+{
+	int i;
+
+	for (i = 0; i < crtc_count; i++) {
+		free(crtcs[i].cconfs);
+	}
+}
+
+static uint32_t *get_connector_ids(struct crtc_config *crtc)
+{
+	uint32_t *ids;
+	int i;
+
+	ids = malloc(sizeof(*ids) * crtc->connector_count);
+	assert(ids);
+	for (i = 0; i < crtc->connector_count; i++)
+		ids[i] = crtc->cconfs[i].connector->connector_id;
+
+	return ids;
+}
+
+static void test_crtc_config(const struct test_config *tconf,
+			     struct crtc_config *crtcs, int crtc_count)
+{
+	char str_buf[MAX_CRTCS][1024];
+	const char *crtc_strs[MAX_CRTCS];
+	struct crtc_config *crtc;
+	static int test_id;
+	bool config_failed = false;
+	bool connector_connected = false;
+	int ret = 0;
+	int i;
+
+	test_id++;
+
+	if (filter_test_id && filter_test_id != test_id)
+		return;
+
+	printf("  Test id#%d CRTC count %d\n", test_id, crtc_count);
+
+	for (i = 0; i < crtc_count; i++) {
+		get_crtc_config_str(&crtcs[i], str_buf[i], sizeof(str_buf[i]));
+		crtc_strs[i] = &str_buf[i][0];
+	}
+
+	if (dry_run) {
+		for (i = 0; i < crtc_count; i++)
+			printf("    %s\n", crtc_strs[i]);
+		return;
+	}
+
+	for (i = 0; i < crtc_count; i++) {
+		uint32_t *ids;
+		int j;
+
+		crtc = &crtcs[i];
+
+		printf("    %s\n", crtc_strs[i]);
+
+		create_fb_for_crtc(crtc, &crtc->fb_info);
+		paint_fb(&crtc->fb_info, tconf->name, crtc_strs, crtc_count, i);
+
+		ids = get_connector_ids(crtc);
+		ret = drmModeSetCrtc(drm_fd, crtc->crtc_id,
+				     crtc->fb_info.fb_id, 0, 0, ids,
+				     crtc->connector_count, &crtc->mode);
+		free(ids);
+
+		if (ret < 0) {
+			igt_assert(errno == EINVAL);
+			config_failed = true;
+		}
+
+		for (j = 0; j < crtc->connector_count; j++)
+			connector_connected |= crtc->cconfs[j].connected;
+	}
+
+	igt_assert(config_failed == !!(tconf->flags & TEST_INVALID));
+
+	if (ret == 0 && connector_connected && !(tconf->flags & TEST_INVALID))
+		sleep(5);
+
+	for (i = 0; i < crtc_count; i++) {
+		if (crtcs[i].fb_info.fb_id) {
+			drmModeSetCrtc(drm_fd, crtcs[i].crtc_id, 0, 0, 0, NULL,
+					0, NULL);
+			drmModeRmFB(drm_fd, crtcs[i].fb_info.fb_id);
+			crtcs[i].fb_info.fb_id = 0;
+		}
+	}
+
+	return;
+}
+
+static void test_one_combination(const struct test_config *tconf,
+				 struct connector_config *cconfs,
+				 int connector_count)
+{
+	struct crtc_config crtcs[MAX_CRTCS];
+	int crtc_count;
+	bool config_valid;
+
+	setup_crtcs(tconf->resources, cconfs, connector_count, crtcs,
+		    &crtc_count, &config_valid);
+
+	if (config_valid == !(tconf->flags & TEST_INVALID))
+		test_crtc_config(tconf, crtcs, crtc_count);
+
+	cleanup_crtcs(crtcs, crtc_count);
+}
+
+static int assign_crtc_to_connectors(const struct test_config *tconf,
+				     int *crtc_idxs, int connector_count,
+				     struct connector_config *cconfs)
+{
+	unsigned long crtc_idx_mask;
+	int i;
+
+	crtc_idx_mask = 0;
+	for (i = 0; i < connector_count; i++) {
+		int crtc_idx = crtc_idxs[i];
+
+		if ((tconf->flags & TEST_SINGLE_CRTC_CLONE) &&
+		    crtc_idx_mask & ~(1 << crtc_idx))
+			return -1;
+
+		if ((tconf->flags & TEST_EXCLUSIVE_CRTC_CLONE) &&
+		    crtc_idx_mask & (1 << crtc_idx))
+			return -1;
+
+		crtc_idx_mask |= 1 << crtc_idx;
+
+		cconfs[i].crtc_idx = crtc_idx;
+	}
+
+	return 0;
+}
+
+static int get_one_connector(drmModeRes *resources, int connector_id,
+			     struct connector_config *cconf)
+{
+	drmModeConnector *connector;
+	drmModeModeInfo mode;
+
+	connector = drmModeGetConnector(drm_fd, connector_id);
+	assert(connector);
+	cconf->connector = connector;
+
+	cconf->connected = connector->connection == DRM_MODE_CONNECTED;
+
+	/*
+	 * For DP/eDP we need a connected sink, since mode setting depends
+	 * on successful link training and retrieved DPCD parameters.
+	 */
+	switch (connector->connector_type) {
+	case DRM_MODE_CONNECTOR_DisplayPort:
+	case DRM_MODE_CONNECTOR_eDP:
+		if (!cconf->connected) {
+			drmModeFreeConnector(connector);
+			return -1;
+		}
+	}
+
+	if (cconf->connected) {
+		if (kmstest_get_connector_default_mode(drm_fd, connector,
+							&mode) < 0)
+			mode = mode_640_480;
+	} else {
+		mode = mode_640_480;
+	}
+
+	cconf->default_mode = mode;
+
+	return 0;
+}
+
+static int get_connectors(drmModeRes *resources, int *connector_idxs,
+			  int connector_count, struct connector_config *cconfs)
+{
+	int i;
+
+	for (i = 0; i < connector_count; i++) {
+		int connector_idx;
+		int connector_id;
+
+		connector_idx = connector_idxs[i];
+		assert(connector_idx < resources->count_connectors);
+		connector_id = resources->connectors[connector_idx];
+
+		if (get_one_connector(resources, connector_id, &cconfs[i]) < 0)
+			goto err;
+
+	}
+
+	return 0;
+
+err:
+	while (i--)
+		drmModeFreeConnector(cconfs[i].connector);
+
+	return -1;
+}
+
+static void free_connectors(struct connector_config *cconfs,
+			    int connector_count)
+{
+	int i;
+
+	for (i = 0; i < connector_count; i++)
+		drmModeFreeConnector(cconfs[i].connector);
+}
+
+struct combination {
+	int elems[MAX_COMBINATION_ELEMS];
+};
+
+struct combination_set {
+	int count;
+	struct combination items[MAX_COMBINATION_COUNT];
+};
+
+/*
+ * Get all possible selection of k elements from n elements with or without
+ * repetitions.
+ */
+static void iterate_combinations(int n, int k, bool allow_repetitions,
+				 int depth, int base, struct combination *comb,
+				 struct combination_set *set)
+{
+	int v;
+
+	if (!k) {
+		assert(set->count < ARRAY_SIZE(set->items));
+		set->items[set->count++] = *comb;
+		return;
+	}
+
+	for (v = base; v < n; v++) {
+		comb->elems[depth] = v;
+		iterate_combinations(n, k - 1, allow_repetitions,
+				     depth + 1, allow_repetitions ? 0 : v + 1,
+				     comb, set);
+	}
+
+}
+
+static void get_combinations(int n, int k, bool allow_repetitions,
+			     struct combination_set *set)
+{
+	struct combination comb;
+
+	assert(k <= ARRAY_SIZE(set->items[0].elems));
+	set->count = 0;
+	iterate_combinations(n, k, allow_repetitions, 0, 0, &comb, set);
+}
+
+static void test_combinations(const struct test_config *tconf,
+			      int connector_count)
+{
+	struct combination_set connector_combs;
+	struct combination_set crtc_combs;
+	struct connector_config *cconfs;
+	int i;
+
+	get_combinations(tconf->resources->count_connectors, connector_count,
+			 false, &connector_combs);
+	get_combinations(tconf->resources->count_crtcs, connector_count,
+			 true, &crtc_combs);
+
+	printf("Testing: %s %d connector combinations\n", tconf->name,
+		connector_count);
+	for (i = 0; i < connector_combs.count; i++) {
+		int *connector_idxs;
+		int ret;
+		int j;
+
+		cconfs = malloc(sizeof(*cconfs) * connector_count);
+		assert(cconfs);
+
+		connector_idxs = &connector_combs.items[i].elems[0];
+		ret = get_connectors(tconf->resources, connector_idxs,
+				     connector_count, cconfs);
+		if (ret < 0)
+			goto free_cconfs;
+
+		for (j = 0; j < crtc_combs.count; j++) {
+			int *crtc_idxs = &crtc_combs.items[j].elems[0];
+			ret = assign_crtc_to_connectors(tconf, crtc_idxs,
+							connector_count,
+						        cconfs);
+			if (ret < 0)
+				continue;
+
+			test_one_combination(tconf, cconfs, connector_count);
+		}
+
+		free_connectors(cconfs, connector_count);
+free_cconfs:
+		free(cconfs);
+	}
+}
+
+static void run_test(const struct test_config *tconf)
+{
+	int connector_num;
+
+	connector_num = tconf->flags & TEST_CLONE ? 2 : 1;
+	for (; connector_num <= tconf->resources->count_crtcs; connector_num++)
+		test_combinations(tconf, connector_num);
+}
+
+static int opt_handler(int opt, int opt_index)
+{
+	switch (opt) {
+	case 'd':
+		dry_run = true;
+		break;
+	case 't':
+		filter_test_id = atoi(optarg);
+		break;
+	default:
+		assert(0);
+	}
+
+	return 0;
+}
+
+int main(int argc, char **argv)
+{
+	const struct {
+		enum test_flags flags;
+		const char *name;
+	} tests[] = {
+		{ TEST_INVALID | TEST_CLONE | TEST_SINGLE_CRTC_CLONE,
+					"invalid-clone-single-crtc" },
+		{ TEST_INVALID | TEST_CLONE | TEST_EXCLUSIVE_CRTC_CLONE,
+					"invalid-clone-exclusive-crtc" },
+		{ TEST_CLONE | TEST_EXCLUSIVE_CRTC_CLONE,
+					"clone-exclusive-crtc" },
+	};
+	const char *help_str =
+	       "  -d\t\tDon't run any test, only print what would be done. (still needs DRM access)\n"
+	       "  -t <test id>\tRun only the test with this id.";
+	int i;
+	int ret;
+
+	ret = igt_subtest_init_parse_opts(argc, argv, "dt:", NULL, help_str,
+					  opt_handler);
+	if (ret < 0)
+		return ret == -1 ? 0 : ret;
+
+	igt_skip_on_simulation();
+
+	if (dry_run && filter_test_id) {
+		fprintf(stderr, "only one of -d and -t is accepted\n");
+		exit(1);
+	}
+
+	igt_fixture {
+		drm_fd = drm_open_any();
+		do_or_die(igt_set_vt_graphics_mode());
+
+		drm_resources = drmModeGetResources(drm_fd);
+		assert(drm_resources);
+	}
+
+	for (i = 0; i < ARRAY_SIZE(tests); i++) {
+		igt_subtest(tests[i].name) {
+			struct test_config tconf = {
+				.flags		= tests[i].flags,
+				.name		= tests[i].name,
+				.resources	= drm_resources,
+			};
+			run_test(&tconf);
+		}
+	}
+
+	igt_fixture {
+		drmModeFreeResources(drm_resources);
+
+		close(drm_fd);
+	}
+
+	igt_exit();
+}