kms_flip.c 41.3 KB
Newer Older
Jesse Barnes's avatar
Jesse Barnes committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
/*
 * Copyright 2012 Intel Corporation
 *   Jesse Barnes <jesse.barnes@intel.com>
 *
 * 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.
 */

24
#ifdef HAVE_CONFIG_H
Jesse Barnes's avatar
Jesse Barnes committed
25
#include "config.h"
26
#endif
Jesse Barnes's avatar
Jesse Barnes committed
27 28 29

#include <cairo.h>
#include <errno.h>
30
#include <fcntl.h>
Jesse Barnes's avatar
Jesse Barnes committed
31 32 33 34 35 36
#include <math.h>
#include <stdint.h>
#include <unistd.h>
#include <sys/poll.h>
#include <sys/time.h>
#include <sys/ioctl.h>
Imre Deak's avatar
Imre Deak committed
37
#include <linux/kd.h>
Jesse Barnes's avatar
Jesse Barnes committed
38 39 40 41

#include "i915_drm.h"
#include "drmtest.h"
#include "testdisplay.h"
42
#include "rendercopy.h"
43
#include "igt_kms.h"
Jesse Barnes's avatar
Jesse Barnes committed
44

45
#define TEST_DPMS		(1 << 0)
46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64
#define TEST_WITH_DUMMY_BCS	(1 << 1)
#define TEST_WITH_DUMMY_RCS	(1 << 2)
#define TEST_PAN		(1 << 3)
#define TEST_MODESET		(1 << 4)
#define TEST_CHECK_TS		(1 << 5)
#define TEST_EBUSY		(1 << 6)
#define TEST_EINVAL		(1 << 7)
#define TEST_FLIP		(1 << 8)
#define TEST_VBLANK		(1 << 9)
#define TEST_VBLANK_BLOCK	(1 << 10)
#define TEST_VBLANK_ABSOLUTE	(1 << 11)
#define TEST_VBLANK_EXPIRED_SEQ	(1 << 12)
#define TEST_FB_RECREATE	(1 << 13)
#define TEST_RMFB		(1 << 14)
#define TEST_HANG		(1 << 15)
#define TEST_NOEVENT		(1 << 16)
#define TEST_FB_BAD_TILING	(1 << 17)
#define TEST_SINGLE_BUFFER	(1 << 18)
#define TEST_DPMS_OFF		(1 << 19)
65 66
#define TEST_NO_2X_OUTPUT	(1 << 20)
#define TEST_DPMS_OFF_OTHERS	(1 << 21)
67
#define TEST_ENOENT		(1 << 22)
68
#define TEST_FENCE_STRESS	(1 << 23)
69

70
#define EVENT_FLIP		(1 << 0)
71
#define EVENT_VBLANK		(1 << 1)
72

73 74 75 76
#ifndef DRM_CAP_TIMESTAMP_MONOTONIC
#define DRM_CAP_TIMESTAMP_MONOTONIC 6
#endif

77 78
#define max(a, b) ((a) > (b) ? (a) : (b))

Jesse Barnes's avatar
Jesse Barnes committed
79 80
drmModeRes *resources;
int drm_fd;
81 82 83
static drm_intel_bufmgr *bufmgr;
struct intel_batchbuffer *batch;
uint32_t devid;
Jesse Barnes's avatar
Jesse Barnes committed
84
int test_time = 3;
85
static bool monotonic_timestamp;
Jesse Barnes's avatar
Jesse Barnes committed
86

87 88
static drmModeConnector *last_connector;

Jesse Barnes's avatar
Jesse Barnes committed
89 90 91 92 93 94 95
uint32_t *fb_ptr;

struct type_name {
	int type;
	const char *name;
};

96 97 98 99 100 101 102 103 104
struct event_state {
	const char *name;

	/*
	 * Event data for the last event that has already passed our check.
	 * Updated using the below current_* vars in update_state().
	 */
	struct timeval last_ts;			/* kernel reported timestamp */
	struct timeval last_received_ts;	/* the moment we received it */
105
	unsigned int last_seq;			/* kernel reported seq. num */
106 107 108 109 110 111 112

	/*
	 * Event data for for the current event that we just received and
	 * going to check for validity. Set in event_handler().
	 */
	struct timeval current_ts;		/* kernel reported timestamp */
	struct timeval current_received_ts;	/* the moment we received it */
113
	unsigned int current_seq;		/* kernel reported seq. num */
114 115

	int count;				/* # of events of this type */
116 117 118

	/* Step between the current and next 'target' sequence number. */
	int seq_step;
119 120
};

Jesse Barnes's avatar
Jesse Barnes committed
121 122
struct test_output {
	int mode_valid;
123 124 125 126 127 128
	drmModeModeInfo kmode[4];
	drmModeEncoder *kencoder[4];
	drmModeConnector *kconnector[4];
	uint32_t _connector[4];
	uint32_t _crtc[4];
	int count; /* 1:1 mapping between crtc:connector */
129
	int flags;
130
	int pipe; /* primary pipe for vblank */
Jesse Barnes's avatar
Jesse Barnes committed
131
	unsigned int current_fb_id;
132 133
	unsigned int fb_width;
	unsigned int fb_height;
134
	unsigned int fb_ids[3];
Daniel Vetter's avatar
Daniel Vetter committed
135
	int bpp, depth;
136
	struct kmstest_fb fb_info[3];
137 138

	struct event_state flip_state;
139
	struct event_state vblank_state;
140 141
	/* Overall step between each round */
	int seq_step;
142
	unsigned int pending_events;
143
	int flip_count;
Jesse Barnes's avatar
Jesse Barnes committed
144 145
};

146 147 148 149 150 151 152 153 154 155

static unsigned long gettime_us(void)
{
	struct timespec ts;

	clock_gettime(CLOCK_MONOTONIC, &ts);

	return ts.tv_sec * 1000000 + ts.tv_nsec / 1000;
}

156
static void emit_dummy_load__bcs(struct test_output *o)
157
{
158
	int i, limit;
159 160 161 162
	drm_intel_bo *dummy_bo, *target_bo, *tmp_bo;
	struct kmstest_fb *fb_info = &o->fb_info[o->current_fb_id];
	unsigned pitch = fb_info->stride;

163 164
	limit = intel_gen(devid) < 6 ? 500 : 5000;

165
	dummy_bo = drm_intel_bo_alloc(bufmgr, "dummy_bo", fb_info->size, 4096);
Daniel Vetter's avatar
Daniel Vetter committed
166
	igt_assert(dummy_bo);
167
	target_bo = gem_handle_to_libdrm_bo(bufmgr, drm_fd, "imported", fb_info->gem_handle);
Daniel Vetter's avatar
Daniel Vetter committed
168
	igt_assert(target_bo);
169

170
	for (i = 0; i < limit; i++) {
171
		BLIT_COPY_BATCH_START(devid, 0);
172 173 174 175
		OUT_BATCH((3 << 24) | /* 32 bits */
			  (0xcc << 16) | /* copy ROP */
			  pitch);
		OUT_BATCH(0 << 16 | 0);
176
		OUT_BATCH(o->fb_height << 16 | o->fb_width);
177
		OUT_RELOC_FENCED(dummy_bo, I915_GEM_DOMAIN_RENDER, I915_GEM_DOMAIN_RENDER, 0);
178
		BLIT_RELOC_UDW(devid);
179 180 181
		OUT_BATCH(0 << 16 | 0);
		OUT_BATCH(pitch);
		OUT_RELOC_FENCED(target_bo, I915_GEM_DOMAIN_RENDER, 0, 0);
182
		BLIT_RELOC_UDW(devid);
183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202
		ADVANCE_BATCH();

		if (IS_GEN6(devid) || IS_GEN7(devid)) {
			BEGIN_BATCH(3);
			OUT_BATCH(XY_SETUP_CLIP_BLT_CMD);
			OUT_BATCH(0);
			OUT_BATCH(0);
			ADVANCE_BATCH();
		}

		tmp_bo = dummy_bo;
		dummy_bo = target_bo;
		target_bo = tmp_bo;
	}
	intel_batchbuffer_flush(batch);

	drm_intel_bo_unreference(dummy_bo);
	drm_intel_bo_unreference(target_bo);
}

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 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244
static void emit_fence_stress(struct test_output *o)
{
	const int num_fences = gem_available_fences(drm_fd);
	struct kmstest_fb *fb_info = &o->fb_info[o->current_fb_id];
	struct drm_i915_gem_execbuffer2 execbuf;
	struct drm_i915_gem_exec_object2 *exec;
	uint32_t buf[2] = { MI_BATCH_BUFFER_END, 0 };
	drm_intel_bo **bo;
	int i;

	bo = calloc(sizeof(*bo), num_fences);
	exec = calloc(sizeof(*exec), num_fences+1);
	for (i = 0; i < num_fences - 1; i++) {
		uint32_t tiling = I915_TILING_X;
		unsigned long pitch = 0;
		bo[i] = drm_intel_bo_alloc_tiled(bufmgr,
						 "tiled bo", 1024, 1024, 4,
						 &tiling, &pitch, 0);
		exec[i].handle = bo[i]->handle;
		exec[i].flags = EXEC_OBJECT_NEEDS_FENCE;
	}
	exec[i].handle = fb_info->gem_handle;
	exec[i].flags = EXEC_OBJECT_NEEDS_FENCE;
	exec[++i].handle = gem_create(drm_fd, 4096);
	gem_write(drm_fd, exec[i].handle, 0, buf, sizeof(buf));

	memset(&execbuf, 0, sizeof(execbuf));
	execbuf.buffers_ptr = (uintptr_t)exec;
	execbuf.buffer_count = i + 1;
	execbuf.batch_len = sizeof(buf);
	if (HAS_BLT_RING(intel_get_drm_devid(drm_fd)))
		execbuf.flags = I915_EXEC_BLT;

	gem_execbuf(drm_fd, &execbuf);

	gem_close(drm_fd, exec[i].handle);
	for (i = 0; i < num_fences - 1; i++)
		drm_intel_bo_unreference(bo[i]);
	free(bo);
	free(exec);
}

245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263
static void emit_dummy_load__rcs(struct test_output *o)
{
	const struct kmstest_fb *fb_info = &o->fb_info[o->current_fb_id];
	render_copyfunc_t copyfunc;
	struct scratch_buf sb[2], *src, *dst;
	int i, limit;

	copyfunc = get_render_copyfunc(devid);
	if (copyfunc == NULL)
		return emit_dummy_load__bcs(o);

	limit = intel_gen(devid) < 6 ? 500 : 5000;

	sb[0].bo = drm_intel_bo_alloc(bufmgr, "dummy_bo", fb_info->size, 4096);
	igt_assert(sb[0].bo);
	sb[0].size = sb[0].bo->size;
	sb[0].tiling = I915_TILING_NONE;
	sb[0].data = NULL;
	sb[0].num_tiles = sb[0].bo->size;
264
	sb[0].stride = 4 * o->fb_width;
265 266 267 268 269 270 271 272 273 274 275 276 277 278 279

	sb[1].bo = gem_handle_to_libdrm_bo(bufmgr, drm_fd, "imported", fb_info->gem_handle);
	igt_assert(sb[1].bo);
	sb[1].size = sb[1].bo->size;
	sb[1].tiling = fb_info->tiling;
	sb[1].data = NULL;
	sb[1].num_tiles = sb[1].bo->size;
	sb[1].stride = fb_info->stride;

	src = &sb[0];
	dst = &sb[1];

	for (i = 0; i < limit; i++) {
		struct scratch_buf *tmp;

280
		copyfunc(batch, NULL,
281
			 src, 0, 0,
282
			 o->fb_width, o->fb_height,
283 284 285 286 287 288 289 290 291 292 293 294
			 dst, 0, 0);

		tmp = src;
		src = dst;
		dst = tmp;
	}
	intel_batchbuffer_flush(batch);

	drm_intel_bo_unreference(sb[0].bo);
	drm_intel_bo_unreference(sb[1].bo);
}

295
static void set_connector_dpms(drmModeConnector *connector, int mode)
296 297
{
	int i, dpms = 0;
298
	bool found_it = false;
299

300
	for (i = 0; i < connector->count_props; i++) {
301 302
		struct drm_mode_get_property prop;

303
		prop.prop_id = connector->props[i];
304 305 306 307 308 309 310 311 312
		prop.count_values = 0;
		prop.count_enum_blobs = 0;
		if (drmIoctl(drm_fd, DRM_IOCTL_MODE_GETPROPERTY, &prop))
			continue;

		if (strcmp(prop.name, "DPMS"))
			continue;

		dpms = prop.prop_id;
313
		found_it = true;
314 315
		break;
	}
316 317
	igt_assert_f(found_it, "DPMS property not found on %d\n",
		     connector->connector_id);
318

319 320
	igt_assert(drmModeConnectorSetProperty(drm_fd, connector->connector_id,
					       dpms, mode) == 0);
321 322
}

323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338
static void dpms_off_other_outputs(struct test_output *o)
{
	int i, n;
	drmModeConnector *connector;
	uint32_t connector_id;

	for (i = 0; i < resources->count_connectors; i++) {
		connector_id = resources->connectors[i];

		for (n = 0; n < o->count; n++) {
			if (connector_id == o->kconnector[n]->connector_id)
				goto next;
		}

		connector = drmModeGetConnector(drm_fd, connector_id);

339 340
		set_connector_dpms(connector,  DRM_MODE_DPMS_ON);
		set_connector_dpms(connector,  DRM_MODE_DPMS_OFF);
341 342

		drmModeFreeConnector(connector);
343 344 345 346 347
next:
		;
	}
}

348
static void set_dpms(struct test_output *o, int mode)
349
{
350 351
	for (int n = 0; n < o->count; n++)
		set_connector_dpms(o->kconnector[n], mode);
352 353
}

354 355
static void set_flag(unsigned int *v, unsigned int flag)
{
Daniel Vetter's avatar
Daniel Vetter committed
356
	igt_assert(!(*v & flag));
357 358 359 360 361
	*v |= flag;
}

static void clear_flag(unsigned int *v, unsigned int flag)
{
Daniel Vetter's avatar
Daniel Vetter committed
362
	igt_assert(*v & flag);
363 364 365
	*v &= ~flag;
}

366
static int do_page_flip(struct test_output *o, uint32_t fb_id, bool event)
367
{
368
	int n, ret = 0;
369

370 371 372 373 374 375 376 377 378
	o->flip_count = 0;

	for (n = 0; ret == 0 && n < o->count; n++)
		ret = drmModePageFlip(drm_fd, o->_crtc[n], fb_id,
				      event ? DRM_MODE_PAGE_FLIP_EVENT : 0,
				      event ? (void *)((unsigned long)o | (n==0)) : NULL);

	if (ret == 0 && event)
		set_flag(&o->pending_events, EVENT_FLIP);
379 380

	return ret;
381 382
}

383 384 385 386 387
struct vblank_reply {
	unsigned int sequence;
	struct timeval ts;
};

388 389 390
static int __wait_for_vblank(unsigned int flags, int crtc_idx,
			      int target_seq, unsigned long ret_data,
			      struct vblank_reply *reply)
391 392 393 394
{
	drmVBlank wait_vbl;
	int ret;
	unsigned crtc_idx_mask;
395
	bool event = !(flags & TEST_VBLANK_BLOCK);
396 397 398 399

	memset(&wait_vbl, 0, sizeof(wait_vbl));

	crtc_idx_mask = crtc_idx << DRM_VBLANK_HIGH_CRTC_SHIFT;
Daniel Vetter's avatar
Daniel Vetter committed
400
	igt_assert(!(crtc_idx_mask & ~DRM_VBLANK_HIGH_CRTC_MASK));
401 402

	wait_vbl.request.type = crtc_idx_mask;
403
	if (flags & TEST_VBLANK_ABSOLUTE)
404 405 406 407 408
		wait_vbl.request.type |= DRM_VBLANK_ABSOLUTE;
	else
		wait_vbl.request.type |= DRM_VBLANK_RELATIVE;
	if (event) {
		wait_vbl.request.type |= DRM_VBLANK_EVENT;
409
		wait_vbl.request.signal = ret_data;
410 411 412 413 414 415 416 417 418
	}
	wait_vbl.request.sequence = target_seq;

	ret = drmWaitVBlank(drm_fd, &wait_vbl);

	if (ret == 0) {
		reply->ts.tv_sec = wait_vbl.reply.tval_sec;
		reply->ts.tv_usec = wait_vbl.reply.tval_usec;
		reply->sequence = wait_vbl.reply.sequence;
419 420
	} else
		ret = -errno;
421 422 423 424

	return ret;
}

425 426 427 428
static int do_wait_for_vblank(struct test_output *o, int pipe_id,
			      int target_seq, struct vblank_reply *reply)
{
	int ret;
429
	unsigned flags = o->flags;
430

431 432 433 434 435
	/* Absolute waits only works once we have a frame counter. */
	if (!(o->vblank_state.count > 0))
		flags &= ~TEST_VBLANK_ABSOLUTE;

	ret = __wait_for_vblank(flags, pipe_id, target_seq, (unsigned long)o,
436 437 438 439 440 441 442
				reply);
	if (ret == 0 && !(o->flags & TEST_VBLANK_BLOCK))
		set_flag(&o->pending_events, EVENT_VBLANK);

	return ret;
}

443 444 445
static bool
analog_tv_connector(struct test_output *o)
{
446
	uint32_t connector_type = o->kconnector[0]->connector_type;
447 448 449 450 451 452 453

	return connector_type == DRM_MODE_CONNECTOR_TV ||
		connector_type == DRM_MODE_CONNECTOR_9PinDIN ||
		connector_type == DRM_MODE_CONNECTOR_SVIDEO ||
		connector_type == DRM_MODE_CONNECTOR_Composite;
}

454 455 456
static void event_handler(struct event_state *es, unsigned int frame,
			  unsigned int sec, unsigned int usec)
{
457 458 459 460 461 462 463 464 465 466 467 468 469
	struct timeval now;

	if (monotonic_timestamp) {
		struct timespec ts;

		clock_gettime(CLOCK_MONOTONIC, &ts);
		now.tv_sec = ts.tv_sec;
		now.tv_usec = ts.tv_nsec / 1000;
	} else {
		gettimeofday(&now, NULL);
	}
	es->current_received_ts = now;

470 471
	es->current_ts.tv_sec = sec;
	es->current_ts.tv_usec = usec;
472
	es->current_seq = frame;
473 474
}

Jesse Barnes's avatar
Jesse Barnes committed
475 476 477
static void page_flip_handler(int fd, unsigned int frame, unsigned int sec,
			      unsigned int usec, void *data)
{
478 479
	int primary = (unsigned long)data & 1;
	struct test_output *o = (void *)((unsigned long)data & ~ 1);
480

481 482 483 484
	if (++o->flip_count == o->count)
		clear_flag(&o->pending_events, EVENT_FLIP);
	if (primary)
		event_handler(&o->flip_state, frame, sec, usec);
485 486
}

487 488
static double frame_time(struct test_output *o)
{
489
	return 1000.0 * 1000.0 / o->kmode[0].vrefresh;
490 491
}

492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515
static void fixup_premature_vblank_ts(struct test_output *o,
				      struct event_state *es)
{
	/*
	 * In case a power off event preempts the completion of a
	 * wait-for-vblank event the kernel will return a wf-vblank event with
	 * a zeroed-out timestamp. In order that check_state() doesn't
	 * complain replace this ts with a valid ts. As we can't calculate the
	 * exact timestamp, just use the time we received the event.
	 */
	struct timeval tv;

	if (!(o->flags & (TEST_DPMS | TEST_MODESET)))
		return;

	if (o->vblank_state.current_ts.tv_sec != 0 ||
	    o->vblank_state.current_ts.tv_usec != 0)
		return;

	tv.tv_sec = 0;
	tv.tv_usec = 1;
	timersub(&es->current_received_ts, &tv, &es->current_ts);
}

516 517 518 519 520 521 522
static void vblank_handler(int fd, unsigned int frame, unsigned int sec,
			      unsigned int usec, void *data)
{
	struct test_output *o = data;

	clear_flag(&o->pending_events, EVENT_VBLANK);
	event_handler(&o->vblank_state, frame, sec, usec);
523
	fixup_premature_vblank_ts(o, &o->vblank_state);
524 525
}

526
static void check_state(struct test_output *o, struct event_state *es)
527 528 529
{
	struct timeval diff;
	double usec_interflip;
530

531
	timersub(&es->current_ts, &es->current_received_ts, &diff);
532 533
	if ((!analog_tv_connector(o)) &&
	    (diff.tv_sec > 0 || (diff.tv_sec == 0 && diff.tv_usec > 2000))) {
534 535
		fprintf(stderr, "%s ts delayed for too long: %is, %iusec\n",
			es->name, (int)diff.tv_sec, (int)diff.tv_usec);
536
		igt_fail(5);
537
	}
Jesse Barnes's avatar
Jesse Barnes committed
538

539 540 541
	if (es->count == 0)
		return;

542 543 544 545 546
	if (!timercmp(&es->last_received_ts, &es->current_ts, <)) {
		fprintf(stderr, "%s ts before the %s was issued!\n",
				es->name, es->name);

		timersub(&es->current_ts, &es->last_received_ts, &diff);
547 548
		fprintf(stderr, "timerdiff %is, %ius\n",
			(int) diff.tv_sec, (int) diff.tv_usec);
549
		igt_fail(6);
550 551
	}

552
	/* This bounding matches the one in DRM_IOCTL_WAIT_VBLANK. */
553 554 555
	if (!(o->flags & (TEST_DPMS | TEST_MODESET))) {
		/* check only valid if no modeset happens in between, that
		 * increments by (1 << 23) on each step. */
556
		if (es->current_seq - (es->last_seq + o->seq_step) > 1UL << 23) {
557
			fprintf(stderr, "unexpected %s seq %u, should be >= %u\n",
558
				es->name, es->current_seq, es->last_seq + o->seq_step);
559
			igt_fail(10);
560
		}
561 562 563
	}

	if ((o->flags & TEST_CHECK_TS) && (!analog_tv_connector(o))) {
564
		timersub(&es->current_ts, &es->last_ts, &diff);
565
		usec_interflip = (double)o->seq_step * frame_time(o);
566 567 568 569
		if (fabs((((double) diff.tv_usec) - usec_interflip) /
		    usec_interflip) > 0.005) {
			fprintf(stderr, "inter-%s ts jitter: %is, %ius\n",
				es->name,
570
				(int) diff.tv_sec, (int) diff.tv_usec);
571
			igt_fail(9);
572
		}
573

574
		if (es->current_seq != es->last_seq + o->seq_step) {
575 576
			fprintf(stderr, "unexpected %s seq %u, expected %u\n",
					es->name, es->current_seq,
577
					es->last_seq + o->seq_step);
578
			igt_fail(9);
579
		}
580
	}
581 582
}

583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601
static void check_state_correlation(struct test_output *o,
				    struct event_state *es1,
				    struct event_state *es2)
{
	struct timeval tv_diff;
	double ftime;
	double usec_diff;
	int seq_diff;

	if (es1->count == 0 || es2->count == 0)
		return;

	timersub(&es2->current_ts, &es1->current_ts, &tv_diff);
	usec_diff = tv_diff.tv_sec * 1000 * 1000 + tv_diff.tv_usec;

	seq_diff = es2->current_seq - es1->current_seq;
	ftime = frame_time(o);
	usec_diff -= seq_diff * ftime;

602 603 604
	igt_assert_f(fabs(usec_diff) / ftime <= 0.005,
		     "timestamp mismatch between %s and %s (diff %.4f sec)\n",
		     es1->name, es2->name, usec_diff / 1000 / 1000);
605 606
}

607 608
static void check_all_state(struct test_output *o,
			    unsigned int completed_events)
609
{
610 611 612 613 614 615
	bool flip, vblank;

	flip = completed_events & EVENT_FLIP;
	vblank = completed_events & EVENT_VBLANK;

	if (flip)
616
		check_state(o, &o->flip_state);
617
	if (vblank)
618
		check_state(o, &o->vblank_state);
619

620 621
	/* FIXME: Correlation check is broken. */
	if (flip && vblank && 0)
622
		check_state_correlation(o, &o->flip_state, &o->vblank_state);
623 624
}

Daniel Vetter's avatar
Daniel Vetter committed
625 626 627 628 629 630 631 632
static void recreate_fb(struct test_output *o)
{
	drmModeFBPtr r;
	struct kmstest_fb *fb_info = &o->fb_info[o->current_fb_id];
	uint32_t new_fb_id;

	/* Call rmfb/getfb/addfb to ensure those don't introduce stalls */
	r = drmModeGetFB(drm_fd, fb_info->fb_id);
Daniel Vetter's avatar
Daniel Vetter committed
633
	igt_assert(r);
Daniel Vetter's avatar
Daniel Vetter committed
634 635 636 637 638 639

	do_or_die(drmModeAddFB(drm_fd, o->fb_width, o->fb_height, o->depth,
			       o->bpp, fb_info->stride,
			       r->handle, &new_fb_id));

	gem_close(drm_fd, r->handle);
640
	drmFree(r);
Daniel Vetter's avatar
Daniel Vetter committed
641 642 643 644 645 646
	do_or_die(drmModeRmFB(drm_fd, fb_info->fb_id));

	o->fb_ids[o->current_fb_id] = new_fb_id;
	o->fb_info[o->current_fb_id].fb_id = new_fb_id;
}

647 648 649 650 651 652 653
static void set_y_tiling(struct test_output *o, int fb_idx)
{
	drmModeFBPtr r;
	struct kmstest_fb *fb_info = &o->fb_info[fb_idx];

	/* Call rmfb/getfb/addfb to ensure those don't introduce stalls */
	r = drmModeGetFB(drm_fd, fb_info->fb_id);
Daniel Vetter's avatar
Daniel Vetter committed
654
	igt_assert(r);
655 656
	/* Newer kernels don't allow such shenagians any more, so skip the test. */
	igt_require(__gem_set_tiling(drm_fd, r->handle, I915_TILING_Y, fb_info->stride) == 0);
657 658 659 660
	gem_close(drm_fd, r->handle);
	drmFree(r);
}

661
static void stop_rings(bool stop)
662
{
663 664
	static const char dfs_base[] = "/sys/kernel/debug/dri";
	static const char dfs_entry[] = "i915_ring_stop";
665 666
	static const char stop_data[] = "0xf";
	static const char run_data[] = "0x0";
667 668 669 670 671 672
	char fname[FILENAME_MAX];
	int card_index = drm_get_card();
	int fd;

	snprintf(fname, FILENAME_MAX, "%s/%i/%s",
		 dfs_base, card_index, dfs_entry);
673

674 675
	fd = open(fname, O_WRONLY);
	igt_assert(fd >= 0);
676

677 678 679 680
	if (stop)
		igt_assert(write(fd, stop_data, sizeof(stop_data)) == sizeof(stop_data));
	else
		igt_assert(write(fd, run_data, sizeof(run_data)) == sizeof(run_data));
681

682
	close(fd);
683 684
}

685
static void eat_error_state(void)
686 687 688 689 690 691 692
{
	static const char dfs_base[] = "/sys/kernel/debug/dri";
	static const char dfs_entry_error[] = "i915_error_state";
	static const char dfs_entry_stop[] = "i915_ring_stop";
	static const char data[] = "";
	static char tmp[128];
	char fname[FILENAME_MAX];
693
	int card_index = drm_get_card();
694 695
	int fd;

Daniel Vetter's avatar
Daniel Vetter committed
696
	igt_assert(card_index != -1);
697 698 699 700 701 702

	/* clear the error state */
	snprintf(fname, FILENAME_MAX, "%s/%i/%s",
		 dfs_base, card_index, dfs_entry_error);

	fd = open(fname, O_WRONLY);
703
	igt_assert(fd >= 0);
704

705
	igt_assert(write(fd, data, sizeof(data)) == sizeof(data));
706 707 708 709 710 711 712 713
	close(fd);

	/* and check whether stop_rings is not reset, i.e. the hang has indeed
	 * happened */
	snprintf(fname, FILENAME_MAX, "%s/%i/%s",
		 dfs_base, card_index, dfs_entry_stop);

	fd = open(fname, O_RDONLY);
714
	igt_assert(fd >= 0);
715

716
	igt_assert(read(fd, tmp, sizeof tmp) > 0);
717

718 719
	igt_assert_f(atoi(tmp) == 0,
		     "no gpu hang detected, stop_rings is still %s\n", tmp);
720 721 722 723

	close(fd);
}

724
static void unhang_gpu(int fd, uint32_t handle)
725
{
726 727 728
	gem_sync(drm_fd, handle);
	gem_close(drm_fd, handle);
	eat_error_state();
729
	stop_rings(false);
730
}
731

732 733 734 735 736
static uint32_t hang_gpu(int fd)
{
	struct drm_i915_gem_execbuffer2 execbuf;
	struct drm_i915_gem_exec_object2 gem_exec;
	uint32_t b[2] = {MI_BATCH_BUFFER_END};
737

738
	stop_rings(true);
739

740 741 742
	memset(&gem_exec, 0, sizeof(gem_exec));
	gem_exec.handle = gem_create(fd, 4096);
	gem_write(fd, gem_exec.handle, 0, b, sizeof(b));
743

744 745 746 747 748 749 750 751 752 753 754
	memset(&execbuf, 0, sizeof(execbuf));
	execbuf.buffers_ptr = (uintptr_t)&gem_exec;
	execbuf.buffer_count = 1;
	execbuf.batch_len = sizeof(b);

	if (drmIoctl(fd, DRM_IOCTL_I915_GEM_EXECBUFFER2, &execbuf)) {
		unhang_gpu(fd, gem_exec.handle);
		gem_exec.handle = 0;
	}

	return gem_exec.handle;
755 756
}

757
static int set_mode(struct test_output *o, uint32_t fb, int x, int y)
758 759 760 761
{
	int n;

	for (n = 0; n < o->count; n++) {
762
		if (fb == 0) {
763 764 765 766 767
			int ret = drmModeSetCrtc(drm_fd, o->_crtc[n],
						 0, 0, 0,
						 0, 0, 0);
			if (ret)
				return ret;
768
		} else {
769 770 771 772 773
			int ret = drmModeSetCrtc(drm_fd, o->_crtc[n],
						 fb, x, y,
						 &o->_connector[n], 1, &o->kmode[n]);
			if (ret)
				return ret;
774
		}
775 776 777 778 779
	}

	return 0;
}

780 781
/* Return mask of completed events. */
static unsigned int run_test_step(struct test_output *o)
782 783 784 785
{
	unsigned int new_fb_id;
	/* for funny reasons page_flip returns -EBUSY on disabled crtcs ... */
	int expected_einval = o->flags & TEST_MODESET ? -EBUSY : -EINVAL;
786
	unsigned int completed_events = 0;
787
	bool do_flip;
788
	bool do_vblank;
789 790
	struct vblank_reply vbl_reply;
	unsigned int target_seq;
791
	uint32_t hang = 0;	/* Suppress GCC warning */
792 793

	target_seq = o->vblank_state.seq_step;
794 795
	/* Absolute waits only works once we have a frame counter. */
	if (o->flags & TEST_VBLANK_ABSOLUTE && o->vblank_state.count > 0)
796
		target_seq += o->vblank_state.last_seq;
797

798 799 800 801 802
	/*
	 * It's possible that we don't have a pending flip here, in case both
	 * wf-vblank and flip were scheduled and the wf-vblank event was
	 * delivered earlier. The same applies to vblank events w.r.t flip.
	 */
803
	do_flip = (o->flags & TEST_FLIP) && !(o->pending_events & EVENT_FLIP);
804 805
	do_vblank = (o->flags & TEST_VBLANK) &&
		    !(o->pending_events & EVENT_VBLANK);
806

807 808 809
	if (o->flags & TEST_DPMS_OFF_OTHERS)
		dpms_off_other_outputs(o);

810 811
	if (o->flags & TEST_WITH_DUMMY_BCS)
		emit_dummy_load__bcs(o);
812

813 814
	if (o->flags & TEST_WITH_DUMMY_RCS)
		emit_dummy_load__rcs(o);
815

816 817 818
	if (!(o->flags & TEST_SINGLE_BUFFER))
		o->current_fb_id = !o->current_fb_id;

Daniel Vetter's avatar
Daniel Vetter committed
819 820
	if (o->flags & TEST_FB_RECREATE)
		recreate_fb(o);
821 822
	new_fb_id = o->fb_ids[o->current_fb_id];

823 824 825
	if (o->flags & TEST_FB_BAD_TILING)
		new_fb_id = o->fb_ids[2];

826 827 828 829 830 831 832 833 834 835 836
	if ((o->flags & TEST_VBLANK_EXPIRED_SEQ) &&
	    !(o->pending_events & EVENT_VBLANK) && o->flip_state.count > 0) {
		struct vblank_reply reply;
		unsigned int exp_seq;
		unsigned long start;

		exp_seq = o->flip_state.current_seq;
		start = gettime_us();
		do_or_die(__wait_for_vblank(TEST_VBLANK_ABSOLUTE |
					    TEST_VBLANK_BLOCK, o->pipe, exp_seq,
					    0, &reply));
Daniel Vetter's avatar
Daniel Vetter committed
837 838 839
		igt_assert(gettime_us() - start < 500);
		igt_assert(reply.sequence == exp_seq);
		igt_assert(timercmp(&reply.ts, &o->flip_state.last_ts, ==));
840 841
	}

842 843 844 845 846 847
	if (o->flags & TEST_ENOENT) {
		/* hope that fb 0xfffffff0 does not exist */
		igt_assert(do_page_flip(o, 0xfffffff0, false) == -ENOENT);
		igt_assert(set_mode(o, 0xfffffff0, 0, 0) == -ENOENT);
	}

848
	if (do_flip && (o->flags & TEST_EINVAL) && o->flip_state.count > 0)
Daniel Vetter's avatar
Daniel Vetter committed
849
		igt_assert(do_page_flip(o, new_fb_id, true) == expected_einval);
850

851 852 853
	if (o->flags & TEST_FB_BAD_TILING)
		new_fb_id = o->fb_ids[o->current_fb_id];

854
	if (do_vblank && (o->flags & TEST_EINVAL) && o->vblank_state.count > 0)
Daniel Vetter's avatar
Daniel Vetter committed
855
		igt_assert(do_wait_for_vblank(o, o->pipe, target_seq, &vbl_reply)
856 857
		       == -EINVAL);

858
	if (o->flags & TEST_DPMS_OFF)
859
		set_dpms(o, DRM_MODE_DPMS_OFF);
860

861 862
	if (o->flags & TEST_MODESET)
		igt_assert(set_mode(o, o->fb_ids[o->current_fb_id], 0, 0) == 0);
863

864
	if (o->flags & TEST_DPMS)
865
		set_dpms(o, DRM_MODE_DPMS_ON);
Jesse Barnes's avatar
Jesse Barnes committed
866

867
	igt_info("."); fflush(stdout);
868

869 870
	if (do_flip && (o->flags & TEST_HANG))
		hang = hang_gpu(drm_fd);
871

872
	if (do_flip)
873
		do_or_die(do_page_flip(o, new_fb_id, !(o->flags & TEST_NOEVENT)));
874

875 876 877
	if (o->flags & TEST_FENCE_STRESS)
		emit_fence_stress(o);

878 879 880 881 882 883 884 885 886 887 888
	if (do_vblank) {
		do_or_die(do_wait_for_vblank(o, o->pipe, target_seq,
					     &vbl_reply));
		if (o->flags & TEST_VBLANK_BLOCK) {
			event_handler(&o->vblank_state, vbl_reply.sequence,
				      vbl_reply.ts.tv_sec,
				      vbl_reply.ts.tv_usec);
			completed_events = EVENT_VBLANK;
		}
	}

889
	if (do_flip && (o->flags & TEST_EBUSY))
Daniel Vetter's avatar
Daniel Vetter committed
890
		igt_assert(do_page_flip(o, new_fb_id, true) == -EBUSY);
891

892 893 894
	if (do_flip && (o->flags & TEST_RMFB))
		recreate_fb(o);

895 896
	/* pan before the flip completes */
	if (o->flags & TEST_PAN) {
897 898
		int count = do_flip ?
			o->flip_state.count : o->vblank_state.count;
899
		int x_ofs = count * 10 > o->fb_width - o->kmode[0].hdisplay ? o->fb_width - o->kmode[0].hdisplay : count * 10;
900

901 902 903 904
		igt_assert_f(set_mode(o, o->fb_ids[o->current_fb_id], x_ofs, 0) == 0,
			     "failed to pan (%dx%d@%dHz)+%d: %s\n",
			     o->kmode[0].hdisplay, o->kmode[0].vdisplay, o->kmode[0].vrefresh,
			     x_ofs, strerror(errno));
905 906
	}

907
	if (o->flags & TEST_DPMS)
908
		set_dpms(o, DRM_MODE_DPMS_OFF);
909

910
	if (o->flags & TEST_MODESET && !(o->flags & TEST_RMFB))
911
		igt_assert_f(set_mode(o, 0 /* no fb */, 0, 0) == 0,
912 913
			     "failed to disable output: %s\n",
			     strerror(errno));
914

915
	if (do_vblank && (o->flags & TEST_EINVAL) && o->vblank_state.count > 0)
Daniel Vetter's avatar
Daniel Vetter committed
916
		igt_assert(do_wait_for_vblank(o, o->pipe, target_seq, &vbl_reply)
917
			   == -EINVAL);
918

919
	if (do_flip && (o->flags & TEST_EINVAL) && !(o->flags & TEST_FB_BAD_TILING))
Daniel Vetter's avatar
Daniel Vetter committed
920
		igt_assert(do_page_flip(o, new_fb_id, true) == expected_einval);
921

922 923
	if (hang)
		unhang_gpu(drm_fd, hang);
924

925 926 927
	igt_assert_f(!(do_flip && (o->flags & TEST_HANG)) || hang,
		     "failed to exercise page flip hang recovery\n");

928
	return completed_events;
929
}
930

931 932 933 934
static void update_state(struct event_state *es)
{
	es->last_received_ts = es->current_received_ts;
	es->last_ts = es->current_ts;
935
	es->last_seq = es->current_seq;
936 937 938
	es->count++;
}

939 940
static void update_all_state(struct test_output *o,
			     unsigned int completed_events)
941
{
942 943
	if (completed_events & EVENT_FLIP)
		update_state(&o->flip_state);
944 945 946

	if (completed_events & EVENT_VBLANK)
		update_state(&o->vblank_state);
Jesse Barnes's avatar
Jesse Barnes committed
947 948
}

949 950
static void connector_find_preferred_mode(uint32_t connector_id, int crtc_idx,
					  struct test_output *o)
Jesse Barnes's avatar
Jesse Barnes committed
951
{
952
	struct kmstest_connector_config config;
Jesse Barnes's avatar
Jesse Barnes committed
953

954 955
	if (kmstest_get_connector_config(drm_fd, connector_id, 1 << crtc_idx,
					 &config) < 0) {
956
		o->mode_valid = 0;
Jesse Barnes's avatar
Jesse Barnes committed
957 958 959
		return;
	}

960
	o->pipe = config.pipe;
961 962 963 964
	o->kconnector[0] = config.connector;
	o->kencoder[0] = config.encoder;
	o->_crtc[0] = config.crtc->crtc_id;
	o->kmode[0] = config.default_mode;
965
	o->mode_valid = 1;
966 967 968

	o->fb_width = o->kmode[0].hdisplay;
	o->fb_height = o->kmode[0].vdisplay;
969 970

	drmModeFreeCrtc(config.crtc);
Jesse Barnes's avatar
Jesse Barnes committed
971 972
}

973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001
static bool mode_compatible(const drmModeModeInfo *a, const drmModeModeInfo *b)
{
	int d_refresh;

	if (a->hdisplay != b->hdisplay)
		return false;

	if (a->vdisplay != b->vdisplay)
		return false;

	d_refresh = a->vrefresh - b->vrefresh;
	if (d_refresh < -1 || d_refresh > 1)
		return false;

	return true;
}

static void connector_find_compatible_mode(int crtc_idx0, int crtc_idx1,
					   struct test_output *o)
{
	struct kmstest_connector_config config[2];
	drmModeModeInfo *mode[2];
	int n, m;

	if (kmstest_get_connector_config(drm_fd, o->_connector[0],
					 1 << crtc_idx0, &config[0]) < 0)
		return;

	if (kmstest_get_connector_config(drm_fd, o->_connector[1],
1002 1003
					 1 << crtc_idx1, &config[1]) < 0) {
		kmstest_free_connector_config(&config[0]);
1004
		return;
1005
	}
1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017

	mode[0] = &config[0].default_mode;
	mode[1] = &config[1].default_mode;
	if (!mode_compatible(mode[0], mode[1])) {
		for (n = 0; n < config[0].connector->count_modes; n++) {
			mode[0] = &config[0].connector->modes[n];
			for (m = 0; m < config[1].connector->count_modes; m++) {
				mode[1] = &config[1].connector->modes[m];
				if (mode_compatible(mode[0], mode[1]))
					goto found;
			}
		}
1018 1019 1020

		/* hope for the best! */
		mode[1] = mode[0] = &config[0].default_mode;
1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037
	}

found:
	o->pipe = config[0].pipe;
	o->fb_width = mode[0]->hdisplay;
	o->fb_height = mode[0]->vdisplay;
	o->mode_valid = 1;

	o->kconnector[0] = config[0].connector;
	o->kencoder[0] = config[0].encoder;
	o->_crtc[0] = config[0].crtc->crtc_id;
	o->kmode[0] = *mode[0];

	o->kconnector[1] = config[1].connector;
	o->kencoder[1] = config[1].encoder;
	o->_crtc[1] = config[1].crtc->crtc_id;
	o->kmode[1] = *mode[1];
1038 1039 1040

	drmModeFreeCrtc(config[0].crtc);
	drmModeFreeCrtc(config[1].crtc);
1041 1042
}

Imre Deak's avatar
Imre Deak committed
1043
static void paint_flip_mode(struct kmstest_fb *fb, bool odd_frame)
Jesse Barnes's avatar
Jesse Barnes committed
1044
{
Imre Deak's avatar
Imre Deak committed
1045 1046 1047 1048 1049
	cairo_t *cr = kmstest_get_cairo_ctx(drm_fd, fb);
	int width = fb->width;
	int height = fb->height;

	kmstest_paint_test_pattern(cr, width, height);
Jesse Barnes's avatar
Jesse Barnes committed
1050

1051 1052 1053 1054
	if (odd_frame)
		cairo_rectangle(cr, width/4, height/2, width/4, height/8);
	else
		cairo_rectangle(cr, width/2, height/2, width/4, height/8);
Jesse Barnes's avatar
Jesse Barnes committed
1055 1056 1057

	cairo_set_source_rgb(cr, 1, 1, 1);
	cairo_fill(cr);
Imre Deak's avatar
Imre Deak committed
1058

Daniel Vetter's avatar
Daniel Vetter committed
1059
	igt_assert(!cairo_status(cr));
1060
	cairo_destroy(cr);
Jesse Barnes's avatar
Jesse Barnes committed
1061 1062
}

1063 1064 1065
static int
fb_is_bound(struct test_output *o, int fb)
{
1066
	int n;
1067

1068 1069
	for (n = 0; n < o->count; n++) {
		struct drm_mode_crtc mode;
1070

1071 1072 1073 1074 1075 1076 1077 1078 1079
		mode.crtc_id = o->_crtc[n];
		if (drmIoctl(drm_fd, DRM_IOCTL_MODE_GETCRTC, &mode))
			return 0;

		if (!mode.mode_valid || mode.fb_id != fb)
			return false;
	}

	return true;
1080 1081
}

1082
static void check_final_state(struct test_output *o, struct event_state *es,
1083
			      unsigned int elapsed)
1084
{
1085 1086
	igt_assert_f(es->count > 0,
		     "no %s event received\n", es->name);
1087

1088 1089 1090 1091
	/* Verify we drop no frames, but only if it's not a TV encoder, since
	 * those use some funny fake timings behind userspace's back. */
	if (o->flags & TEST_CHECK_TS && !analog_tv_connector(o)) {
		int expected;
1092
		int count = es->count;
1093

1094
		count *= o->seq_step;
1095
		expected = elapsed * o->kmode[0].vrefresh / (1000 * 1000);
1096 1097 1098
		igt_assert_f(count >= expected * 99/100 && count <= expected * 101/100,
			     "dropped frames, expected %d, counted %d, encoder type %d\n",
			     expected, count, o->kencoder[0]->encoder_type);
1099 1100 1101
	}
}

1102 1103 1104 1105 1106
/*
 * Wait until at least one pending event completes. Return mask of completed
 * events.
 */
static unsigned int wait_for_events(struct test_output *o)
Jesse Barnes's avatar
Jesse Barnes committed
1107
{
1108 1109 1110
	drmEventContext evctx;
	struct timeval timeout = { .tv_sec = 3, .tv_usec = 0 };
	fd_set fds;
1111
	unsigned int event_mask;
Jesse Barnes's avatar
Jesse Barnes committed
1112
	int ret;
1113

1114
	event_mask = o->pending_events;
Daniel Vetter's avatar
Daniel Vetter committed
1115
	igt_assert(event_mask);
1116

1117 1118
	memset(&evctx, 0, sizeof evctx);
	evctx.version = DRM_EVENT_CONTEXT_VERSION;
1119
	evctx.vblank_handler = vblank_handler;
1120 1121 1122
	evctx.page_flip_handler = page_flip_handler;

	/* make timeout lax with the dummy load */
1123
	if (o->flags & (TEST_WITH_DUMMY_BCS | TEST_WITH_DUMMY_RCS))
1124
		timeout.tv_sec *= 60;
1125 1126 1127

	FD_ZERO(&fds);
	FD_SET(drm_fd, &fds);
1128
	do {
1129 1130 1131
		do {
			ret = select(drm_fd + 1, &fds, NULL, NULL, &timeout);
		} while (ret < 0 && errno == EINTR);
1132

1133 1134
		igt_assert_f(ret >= 0,
			     "select error (errno %i)\n", errno);
1135 1136 1137 1138
		igt_assert_f(ret > 0,
			     "select timed out or error (ret %d)\n", ret);
		igt_assert_f(!FD_ISSET(0, &fds),
			     "no fds active, breaking\n");
1139

1140 1141
		do_or_die(drmHandleEvent(drm_fd, &evctx));
	} while (o->pending_events);
1142 1143

	event_mask ^= o->pending_events;
Daniel Vetter's avatar
Daniel Vetter committed
1144
	igt_assert(event_mask);
1145 1146

	return event_mask;
1147 1148
}

1149
/* Returned the elapsed time in us */
1150
static unsigned event_loop(struct test_output *o, unsigned duration_ms)
1151
{
1152
	unsigned long start, end;
1153

Imre Deak's avatar