kms_setmode.c 21.6 KB
Newer Older
Imre Deak's avatar
Imre Deak committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
/*
 * 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>
 */
#include "config.h"

25
#include "igt.h"
Imre Deak's avatar
Imre Deak committed
26 27 28 29 30 31
#include <cairo.h>
#include <errno.h>
#include <stdint.h>
#include <unistd.h>
#include <string.h>
#include <sys/time.h>
32
#include <math.h>
Imre Deak's avatar
Imre Deak committed
33 34 35
#include "intel_bufmgr.h"

#define MAX_CONNECTORS  10
36
#define MAX_CRTCS       6
Imre Deak's avatar
Imre Deak committed
37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68

/* max combinations with repetitions */
#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,
69
	TEST_STEALING			= 0x10,
70
	TEST_TIMINGS			= 0x20,
Imre Deak's avatar
Imre Deak committed
71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90
};

struct test_config {
	const char *name;
	enum test_flags flags;
	drmModeRes *resources;
};

struct connector_config {
	drmModeConnector *connector;
	int crtc_idx;
	drmModeModeInfo default_mode;
};

struct crtc_config {
	int crtc_idx;
	int crtc_id;
	int pipe_id;
	int connector_count;
	struct connector_config *cconfs;
91
	struct igt_fb fb_info;
Imre Deak's avatar
Imre Deak committed
92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136
	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;
}

137
static int paint_fb(struct igt_fb *fb, const char *test_name,
Imre Deak's avatar
Imre Deak committed
138 139 140 141 142 143
		    const char **crtc_str, int crtc_count, int current_crtc_idx)
{
	double x, y;
	cairo_t *cr;
	int i;

144
	cr = igt_get_cairo_ctx(drm_fd, fb);
Imre Deak's avatar
Imre Deak committed
145 146 147

	cairo_move_to(cr, fb->width / 2, fb->height / 2);
	cairo_set_font_size(cr, 24);
148
	igt_cairo_printf_line(cr, align_hcenter, 40, "%s", test_name);
Imre Deak's avatar
Imre Deak committed
149 150 151 152 153 154 155 156

	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);
157
			igt_cairo_printf_line(cr, align_right, 20, "X");
Imre Deak's avatar
Imre Deak committed
158 159
			cairo_move_to(cr, x, y);
		}
160
		igt_cairo_printf_line(cr, align_left, 20, "%s",
Imre Deak's avatar
Imre Deak committed
161 162 163
					  crtc_str[i]);
	}

164
	igt_put_cairo_ctx(drm_fd, fb, cr);
165

Imre Deak's avatar
Imre Deak committed
166 167 168 169
	return 0;
}

static void create_fb_for_crtc(struct crtc_config *crtc,
170
			       struct igt_fb *fb_info)
Imre Deak's avatar
Imre Deak committed
171 172 173 174 175 176 177
{
	int bpp;
	int depth;
	int fb_id;

	bpp = 32;
	depth = 24;
178 179 180 181 182
	fb_id = igt_create_pattern_fb(drm_fd, crtc->mode.hdisplay,
				      crtc->mode.vdisplay,
				      igt_bpp_depth_to_drm_format(bpp, depth),
				      LOCAL_DRM_FORMAT_MOD_NONE,
				      fb_info);
183
	igt_assert_lt(0, fb_id);
Imre Deak's avatar
Imre Deak committed
184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228
}

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;
229
	igt_assert(0);
Imre Deak's avatar
Imre Deak committed
230 231 232 233 234 235 236 237 238 239
}

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: ",
240
		       crtc->crtc_id, kmstest_pipe_name(crtc->pipe_id),
Imre Deak's avatar
Imre Deak committed
241 242 243 244 245 246 247
		       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,
248
			"%s%s-%d[%d]", i ? ", " : "",
Imre Deak's avatar
Imre Deak committed
249
			kmstest_connector_type_str(connector->connector_type),
250
			connector->connector_type_id, connector->connector_id);
Imre Deak's avatar
Imre Deak committed
251 252 253 254 255 256 257 258 259 260 261 262 263
		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;
264
	int encoder_usage_count[resources->count_encoders];
Imre Deak's avatar
Imre Deak committed
265

266 267
	kmstest_unset_all_crtcs(drm_fd, resources);

Imre Deak's avatar
Imre Deak committed
268 269 270 271 272 273 274 275 276 277
	i = 0;
	crtc_count = 0;
	crtc = crtcs;
	config_valid = true;

	while (i < connector_count) {
		drmModeCrtc *drm_crtc;
		unsigned long encoder_mask;
		int j;

278
		igt_assert_lt(crtc_count, MAX_CRTCS);
Imre Deak's avatar
Imre Deak committed
279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294

		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);
295
		igt_assert(crtc->cconfs);
Imre Deak's avatar
Imre Deak committed
296 297 298 299 300 301 302 303 304 305

		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 */
306 307 308 309 310 311 312 313 314 315 316
			if (connector->count_encoders == 1) {
				encoder = drmModeGetEncoder(drm_fd,
							    connector->encoders[0]);
			} else {
				igt_assert_eq(connector->connector_type,
					      DRM_MODE_CONNECTOR_DisplayPort);

				igt_assert(connector->count_encoders >= crtc->crtc_idx);
				encoder = drmModeGetEncoder(drm_fd,
					connector->encoders[crtc_count]);
			}
317
			igt_assert(encoder);
Imre Deak's avatar
Imre Deak committed
318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336

			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++;
	}

337 338 339 340
	memset(encoder_usage_count, 0, sizeof(encoder_usage_count));
	for (i = 0; i < connector_count; i++) {
		drmModeConnector *connector = cconf[i].connector;
		drmModeEncoder *encoder;
341
		int idx = 0;
342

343 344 345 346 347
		/* DP MST configs are presumed valid */
		if (connector->count_encoders > 1)
			idx = cconf[i].crtc_idx;

		encoder = drmModeGetEncoder(drm_fd, connector->encoders[idx]);
348 349 350 351 352 353 354
		encoder_usage_count[get_encoder_idx(resources, encoder)]++;
		drmModeFreeEncoder(encoder);
	}
	for (i = 0; i < resources->count_encoders; i++)
		if (encoder_usage_count[i] > 1)
			config_valid = false;

Imre Deak's avatar
Imre Deak committed
355 356 357 358 359 360 361 362 363
	*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++) {
364 365 366
		igt_remove_fb(drm_fd, &crtcs[i].fb_info);
		drmModeSetCrtc(drm_fd, crtcs[i].crtc_id, 0, 0, 0, NULL, 0, NULL);

Imre Deak's avatar
Imre Deak committed
367 368 369 370 371 372 373 374 375 376
		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);
377
	igt_assert(ids);
Imre Deak's avatar
Imre Deak committed
378 379 380 381 382 383
	for (i = 0; i < crtc->connector_count; i++)
		ids[i] = crtc->cconfs[i].connector->connector_id;

	return ids;
}

384
static int test_stealing(int fd, struct crtc_config *crtc, uint32_t *ids)
385 386 387 388
{
	int i, ret = 0;

	if (!crtc->connector_count)
389
		return drmModeSetCrtc(fd, crtc->crtc_id,
390 391 392 393
				     crtc->fb_info.fb_id, 0, 0,
				     ids, crtc->connector_count, &crtc->mode);

	for (i = 0; i < crtc->connector_count; ++i) {
394
		ret = drmModeSetCrtc(fd, crtc->crtc_id,
395 396 397 398 399
				     crtc->fb_info.fb_id, 0, 0,
				     &ids[i], 1, &crtc->mode);

		igt_assert_eq(ret, 0);

400
		ret = drmModeSetCrtc(fd, crtc->crtc_id,
401 402 403 404 405 406 407 408 409 410 411
				     crtc->fb_info.fb_id, 0, 0,
				     ids, crtc->connector_count, &crtc->mode);

		/* This should fail with -EINVAL */
		if (!ret)
			return 0;
	}

	return ret;
}

412 413 414 415 416
static double frame_time(const drmModeModeInfo *kmode)
{
	return 1000.0 * kmode->htotal * kmode->vtotal / kmode->clock;
}

417 418 419 420 421
static double line_time(const drmModeModeInfo *kmode)
{
	return 1000.0 * kmode->htotal / kmode->clock;
}

422 423 424 425 426 427 428 429
static void check_timings(int crtc_idx, const drmModeModeInfo *kmode)
{
#define CALIBRATE_TS_STEPS 120 /* ~2s has to be less than 128! */
	drmVBlank wait;
	igt_stats_t stats;
	uint32_t last_seq;
	uint64_t last_timestamp;
	double expected;
430
	double accuracy;
431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475
	double mean;
	double stddev;
	int n;

	memset(&wait, 0, sizeof(wait));
	wait.request.type = kmstest_get_vbl_flag(crtc_idx);
	wait.request.type |= DRM_VBLANK_ABSOLUTE | DRM_VBLANK_NEXTONMISS;
	do_or_die(drmWaitVBlank(drm_fd, &wait));

	last_seq = wait.reply.sequence;
	last_timestamp = wait.reply.tval_sec;
	last_timestamp *= 1000000;
	last_timestamp += wait.reply.tval_usec;

	memset(&wait, 0, sizeof(wait));
	wait.request.type = kmstest_get_vbl_flag(crtc_idx);
	wait.request.type |= DRM_VBLANK_ABSOLUTE | DRM_VBLANK_EVENT;
	wait.request.sequence = last_seq;
	for (n = 0; n < CALIBRATE_TS_STEPS; n++) {
		++wait.request.sequence;
		do_or_die(drmWaitVBlank(drm_fd, &wait));
	}

	igt_stats_init_with_size(&stats, CALIBRATE_TS_STEPS);
	for (n = 0; n < CALIBRATE_TS_STEPS; n++) {
		struct drm_event_vblank ev;
		uint64_t now;

		igt_assert(read(drm_fd, &ev, sizeof(ev)) == sizeof(ev));
		igt_assert_eq(ev.sequence, last_seq + 1);

		now = ev.tv_sec;
		now *= 1000000;
		now += ev.tv_usec;

		igt_stats_push(&stats, now - last_timestamp);

		last_timestamp = now;
		last_seq = ev.sequence;
	}

	expected = frame_time(kmode);

	mean = igt_stats_get_mean(&stats);
	stddev = igt_stats_get_std_deviation(&stats);
476 477 478 479 480 481 482 483 484 485

	/* 99.7% samples fall within `accuracy` on both sides of mean in normal
	 * distribution if `accuracy = 3 * sigma`.
	 * https://en.wikipedia.org/wiki/68%E2%80%9395%E2%80%9399.7_rule
	 *
	 * The value of 99.7% was chosen to suit requirements of test cases
	 * which depend on timing, giving the lowest acceptable MTBF of 5.6s
	 * for 60Hz sampling rate.
	 */
	accuracy = 3. * stddev;
486 487 488 489

	igt_info("Expected frametime: %.0fus; measured %.1fus +- %.3fus accuracy %.2f%% [%.2f scanlines]\n",
		 expected, mean, stddev,
		 100 * accuracy / mean, accuracy / line_time(kmode));
490

491
	/* 99.7% samples within one scanline on each side of mean */
492 493 494
	igt_assert_f(accuracy < line_time(kmode),
		     "vblank accuracy (%.3fus, %.1f%%) worse than a scanline (%.3fus)\n",
		     accuracy, 100 * accuracy / mean, line_time(kmode));
495

496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517
	/* At least 90% of frame times fall within the one scanline on each
	 * side of expected mean.
	 *
	 * Expected scanline duration:
	 * 	(expected - accuracy, expected + accuracy).
	 * Assuming maximum difference allowed:
	 * 	expected = mean + n * sigma
	 * the scanline duration becomes:
	 * 	(mean - accuracy + n * sigma, mean + accuracy + n * sigma)
	 * The expected scanline captures the following number of samples
	 * from each side of expected:
	 * 	(erf(abs(-(accuracy/sigma) + n) / sqrt(2))
	 * 	+ erf((accuracy/sigma) + n) / sqrt(2))) / 2
	 * 	= samples
	 *
	 * Solving for samples = 0.9:
	 * 	n = 1.718
	 *
	 * See:
	 * https://en.wikipedia.org/wiki/Standard_deviation#Rules_for_normally_distributed_data
	 */
	igt_assert_f(fabs(mean - expected) < 1.718 * stddev,
518 519 520
		     "vblank interval differs from modeline! expected %.1fus, measured %1.fus +- %.3fus, difference %.1fus (%.1f sigma)\n",
		     expected, mean, stddev,
		     fabs(mean - expected), fabs(mean - expected) / stddev);
521 522
}

Imre Deak's avatar
Imre Deak committed
523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538
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;
	int ret = 0;
	int i;

	test_id++;

	if (filter_test_id && filter_test_id != test_id)
		return;

539
	igt_info("  Test id#%d CRTC count %d\n", test_id, crtc_count);
Imre Deak's avatar
Imre Deak committed
540 541 542 543 544 545 546 547

	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++)
548
			igt_info("    %s\n", crtc_strs[i]);
Imre Deak's avatar
Imre Deak committed
549 550 551 552 553 554 555 556
		return;
	}

	for (i = 0; i < crtc_count; i++) {
		uint32_t *ids;

		crtc = &crtcs[i];

557
		igt_info("    %s\n", crtc_strs[i]);
Imre Deak's avatar
Imre Deak committed
558 559 560 561 562

		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);
563 564 565 566 567 568 569
		if (tconf->flags & TEST_STEALING)
			ret = test_stealing(drm_fd, crtc, ids);
		else
			ret = drmModeSetCrtc(drm_fd, crtc->crtc_id,
					     crtc->fb_info.fb_id, 0, 0, ids,
					     crtc->connector_count, &crtc->mode);

Imre Deak's avatar
Imre Deak committed
570 571 572
		free(ids);

		if (ret < 0) {
573
			igt_assert_eq(errno, EINVAL);
Imre Deak's avatar
Imre Deak committed
574 575 576 577 578 579
			config_failed = true;
		}
	}

	igt_assert(config_failed == !!(tconf->flags & TEST_INVALID));

580
	if (ret == 0 && tconf->flags & TEST_TIMINGS)
581
		check_timings(crtcs[0].crtc_idx, &crtcs[0].mode);
Imre Deak's avatar
Imre Deak committed
582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634

	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;

635
	connector = drmModeGetConnectorCurrent(drm_fd, connector_id);
636
	igt_assert(connector);
Imre Deak's avatar
Imre Deak committed
637 638
	cconf->connector = connector;

639 640 641
	if (connector->connection != DRM_MODE_CONNECTED) {
		drmModeFreeConnector(connector);
		return -1;
Imre Deak's avatar
Imre Deak committed
642 643
	}

644 645 646 647
	if (!kmstest_get_connector_default_mode(drm_fd, connector,
						&cconf->default_mode)) {
		drmModeFreeConnector(connector);
		return -1;
Imre Deak's avatar
Imre Deak committed
648 649 650 651 652 653 654 655 656 657 658 659 660 661 662
	}

	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];
663
		igt_assert_lt(connector_idx, resources->count_connectors);
Imre Deak's avatar
Imre Deak committed
664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694
		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;
695 696
	int capacity;
	struct combination *items;
Imre Deak's avatar
Imre Deak committed
697 698 699 700 701 702 703 704 705 706 707 708 709
};

/*
 * 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) {
710
		igt_assert(set->count < set->capacity);
Imre Deak's avatar
Imre Deak committed
711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728
		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;

729
	igt_assert(k <= ARRAY_SIZE(set->items[0].elems));
Imre Deak's avatar
Imre Deak committed
730 731 732 733 734 735 736 737 738 739 740 741
	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;

742 743 744
	if (connector_count > 2 && (tconf->flags & TEST_STEALING))
		return;

745 746 747 748 749 750 751 752 753 754
	igt_assert(tconf->resources);

	connector_combs.capacity = pow(tconf->resources->count_connectors,
				       tconf->resources->count_crtcs + 1);
	crtc_combs.capacity = pow(tconf->resources->count_crtcs,
				  tconf->resources->count_crtcs + 1);

	connector_combs.items = malloc(connector_combs.capacity * sizeof(struct combination));
	crtc_combs.items = malloc(crtc_combs.capacity * sizeof(struct combination));

Imre Deak's avatar
Imre Deak committed
755 756 757 758 759
	get_combinations(tconf->resources->count_connectors, connector_count,
			 false, &connector_combs);
	get_combinations(tconf->resources->count_crtcs, connector_count,
			 true, &crtc_combs);

760 761
	igt_info("Testing: %s %d connector combinations\n", tconf->name,
		 connector_count);
Imre Deak's avatar
Imre Deak committed
762 763 764 765 766 767
	for (i = 0; i < connector_combs.count; i++) {
		int *connector_idxs;
		int ret;
		int j;

		cconfs = malloc(sizeof(*cconfs) * connector_count);
768
		igt_assert(cconfs);
Imre Deak's avatar
Imre Deak committed
769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790

		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);
	}
791 792 793

	free(connector_combs.items);
	free(crtc_combs.items);
Imre Deak's avatar
Imre Deak committed
794 795 796 797 798 799 800 801 802 803 804
}

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);
}

805
static int opt_handler(int opt, int opt_index, void *data)
Imre Deak's avatar
Imre Deak committed
806 807 808 809 810 811 812 813 814
{
	switch (opt) {
	case 'd':
		dry_run = true;
		break;
	case 't':
		filter_test_id = atoi(optarg);
		break;
	default:
815
		igt_assert(0);
Imre Deak's avatar
Imre Deak committed
816 817 818 819 820 821 822 823 824 825 826
	}

	return 0;
}

int main(int argc, char **argv)
{
	const struct {
		enum test_flags flags;
		const char *name;
	} tests[] = {
827
		{ TEST_TIMINGS, "basic" },
828
		{ TEST_CLONE | TEST_SINGLE_CRTC_CLONE,
829
					"basic-clone-single-crtc" },
Imre Deak's avatar
Imre Deak committed
830 831 832 833 834 835
		{ 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" },
836 837
		{ TEST_INVALID | TEST_CLONE | TEST_SINGLE_CRTC_CLONE | TEST_STEALING,
					"invalid-clone-single-crtc-stealing" }
Imre Deak's avatar
Imre Deak committed
838 839 840 841 842 843 844
	};
	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;

845
	ret = igt_subtest_init_parse_opts(&argc, argv, "dt:", NULL, help_str,
846
					  opt_handler, NULL);
Imre Deak's avatar
Imre Deak committed
847 848 849 850 851
	if (ret < 0)
		return ret == -1 ? 0 : ret;

	igt_skip_on_simulation();

852 853
	igt_assert_f(!(dry_run && filter_test_id),
		     "only one of -d and -t is accepted\n");
Imre Deak's avatar
Imre Deak committed
854 855

	igt_fixture {
Tomeu Vizoso's avatar
Tomeu Vizoso committed
856
		drm_fd = drm_open_driver_master(DRIVER_ANY);
857
		if (!dry_run)
858
			kmstest_set_vt_graphics_mode();
Imre Deak's avatar
Imre Deak committed
859 860

		drm_resources = drmModeGetResources(drm_fd);
861
		igt_assert(drm_resources);
Imre Deak's avatar
Imre Deak committed
862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882
	}

	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();
}