igt_kms.h 19.6 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
/*
 * Copyright © 2013 Intel Corporation
 *
 * 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.
 *
Daniel Vetter's avatar
Daniel Vetter committed
23 24 25
 * Authors:
 * 	Daniel Vetter <daniel.vetter@ffwll.ch>
 * 	Damien Lespiau <damien.lespiau@intel.com>
26 27 28 29 30
 */

#ifndef __IGT_KMS_H__
#define __IGT_KMS_H__

31
#include <stdbool.h>
32
#include <stdint.h>
33
#include <stddef.h>
34
#include <assert.h>
35

36 37
#include <xf86drmMode.h>

38
#include "igt_fb.h"
39
#include "ioctl_wrappers.h"
40

41 42
/* Low-level helpers with kmstest_ prefix */

43 44 45 46 47 48 49
/**
 * pipe:
 * @PIPE_NONE: Invalid pipe, used for disconnecting a output from a pipe.
 * @PIPE_ANY: Deprecated alias for @PIPE_NONE.
 * @PIPE_A: First crtc.
 * @PIPE_B: Second crtc.
 * @PIPE_C: Third crtc.
50 51
 * ... and so on.
 * @IGT_MAX_PIPES: Max number of pipes allowed.
52
 */
53
enum pipe {
54 55
        PIPE_NONE = -1,
        PIPE_ANY = PIPE_NONE,
56 57 58
        PIPE_A = 0,
        PIPE_B,
        PIPE_C,
59 60 61
        PIPE_D,
        PIPE_E,
        PIPE_F,
62
        IGT_MAX_PIPES
63
};
64
const char *kmstest_pipe_name(enum pipe pipe);
65
int kmstest_pipe_to_index(char pipe);
66
const char *kmstest_plane_type_name(int plane_type);
67 68 69 70 71 72 73 74 75

enum port {
        PORT_A = 0,
        PORT_B,
        PORT_C,
        PORT_D,
        PORT_E,
        I915_MAX_PORTS
};
76 77 78 79 80

/**
 * kmstest_port_name:
 * @port: display plane
 *
81
 * Returns: String representing @port, e.g. "A".
82 83
 */
#define kmstest_port_name(port) ((port) + 'A')
84

85 86 87
const char *kmstest_encoder_type_str(int type);
const char *kmstest_connector_status_str(int status);
const char *kmstest_connector_type_str(int type);
88

89 90 91 92
void kmstest_dump_mode(drmModeModeInfo *mode);

int kmstest_get_pipe_from_crtc_id(int fd, int crtc_id);
void kmstest_set_vt_graphics_mode(void);
Thomas Wood's avatar
Thomas Wood committed
93
void kmstest_restore_vt_mode(void);
94

95 96
enum igt_atomic_crtc_properties {
       IGT_CRTC_BACKGROUND = 0,
97 98
       IGT_CRTC_CTM,
       IGT_CRTC_GAMMA_LUT,
99 100 101
       IGT_CRTC_GAMMA_LUT_SIZE,
       IGT_CRTC_DEGAMMA_LUT,
       IGT_CRTC_DEGAMMA_LUT_SIZE,
102 103
       IGT_CRTC_MODE_ID,
       IGT_CRTC_ACTIVE,
104
       IGT_CRTC_OUT_FENCE_PTR,
105 106 107
       IGT_NUM_CRTC_PROPS
};

108 109 110 111 112 113 114 115
/**
 * igt_crtc_prop_names
 *
 * igt_crtc_prop_names contains a list of crtc property names,
 * as indexed by the igt_atomic_crtc_properties enum.
 */
extern const char *igt_crtc_prop_names[];

116 117
enum igt_atomic_connector_properties {
       IGT_CONNECTOR_SCALING_MODE = 0,
118
       IGT_CONNECTOR_CRTC_ID,
119
       IGT_CONNECTOR_DPMS,
120
       IGT_CONNECTOR_BROADCAST_RGB,
121 122 123
       IGT_NUM_CONNECTOR_PROPS
};

124 125 126 127 128 129 130 131
/**
 * igt_connector_prop_names
 *
 * igt_connector_prop_names contains a list of crtc property names,
 * as indexed by the igt_atomic_connector_properties enum.
 */
extern const char *igt_connector_prop_names[];

132 133 134 135 136
struct kmstest_connector_config {
	drmModeCrtc *crtc;
	drmModeConnector *connector;
	drmModeEncoder *encoder;
	drmModeModeInfo default_mode;
137

138
	int pipe;
139
	unsigned valid_crtc_idx_mask;
140 141
};

142 143
struct kmstest_plane {
	int id;
144
	int index;
145
	int type;
146 147 148 149 150 151 152 153 154 155 156 157
	int pos_x;
	int pos_y;
	int width;
	int height;
};

struct kmstest_crtc {
	int id;
	int pipe;
	bool active;
	int width;
	int height;
158 159
	int n_planes;
	struct kmstest_plane *planes;
160 161
};

162 163 164 165 166 167 168 169 170 171 172 173 174 175
/**
 * kmstest_force_connector_state:
 * @FORCE_CONNECTOR_UNSPECIFIED: Unspecified
 * @FORCE_CONNECTOR_ON: On
 * @FORCE_CONNECTOR_DIGITAL: Digital
 * @FORCE_CONNECTOR_OFF: Off
 */
enum kmstest_force_connector_state {
	FORCE_CONNECTOR_UNSPECIFIED,
	FORCE_CONNECTOR_ON,
	FORCE_CONNECTOR_DIGITAL,
	FORCE_CONNECTOR_OFF
};

176
/**
177
 * intel_broadcast_rgb_mode:
178 179 180 181 182
 * @BROADCAST_RGB_AUTO: Choose the color range to use automatically
 * @BROADCAST_RGB_FULL: Force the connector to use full color range
 * @BROADCAST_RGB_16_235: Force the connector to use a limited 16:235 color
 * range
 */
183
enum intel_broadcast_rgb_mode {
184 185 186 187 188 189
	BROADCAST_RGB_AUTO = 0,
	BROADCAST_RGB_FULL,
	BROADCAST_RGB_16_235
};


190 191
bool kmstest_force_connector(int fd, drmModeConnector *connector,
			     enum kmstest_force_connector_state state);
Thomas Wood's avatar
Thomas Wood committed
192
void kmstest_edid_add_3d(const unsigned char *edid, size_t length, unsigned char *new_edid_ptr[], size_t *new_length);
193 194
void kmstest_edid_add_4k(const unsigned char *edid, size_t length, unsigned char *new_edid_ptr[], size_t *new_length);
void kmstest_edid_add_audio(const unsigned char *edid, size_t length, unsigned char *new_edid_ptr[], size_t *new_length);
195 196
void kmstest_force_edid(int drm_fd, drmModeConnector *connector,
			const unsigned char *edid, size_t length);
197

198 199
bool kmstest_get_connector_default_mode(int drm_fd, drmModeConnector *connector,
					drmModeModeInfo *mode);
200 201 202
bool kmstest_get_connector_config(int drm_fd, uint32_t connector_id,
				  unsigned long crtc_idx_mask,
				  struct kmstest_connector_config *config);
203 204 205
bool kmstest_probe_connector_config(int drm_fd, uint32_t connector_id,
				    unsigned long crtc_idx_mask,
				    struct kmstest_connector_config *config);
206 207
void kmstest_free_connector_config(struct kmstest_connector_config *config);

208
void kmstest_set_connector_dpms(int fd, drmModeConnector *connector, int mode);
209 210 211
bool kmstest_get_property(int drm_fd, uint32_t object_id, uint32_t object_type,
			  const char *name, uint32_t *prop_id, uint64_t *value,
			  drmModePropertyPtr *prop);
212
void kmstest_unset_all_crtcs(int drm_fd, drmModeResPtr resources);
213
int kmstest_get_crtc_idx(drmModeRes *res, uint32_t crtc_id);
214 215 216
uint32_t kmstest_find_crtc_for_connector(int fd, drmModeRes *res,
					 drmModeConnector *connector,
					 uint32_t crtc_blacklist_idx_mask);
217

218 219 220
uint32_t kmstest_dumb_create(int fd, int width, int height, int bpp,
			     unsigned *stride, unsigned *size);

221 222
void *kmstest_dumb_map_buffer(int fd, uint32_t handle, uint64_t size,
			      unsigned prot);
223
unsigned int kmstest_get_vblank(int fd, int pipe, unsigned int flags);
224 225
void kmstest_get_crtc(int fd, enum pipe pipe, struct kmstest_crtc *crtc);
void igt_assert_plane_visible(int fd, enum pipe pipe, bool visibility);
226

227 228 229 230
/*
 * A small modeset API
 */

231
/* High-level kms api with igt_ prefix */
232 233 234 235 236 237 238

/**
 * igt_commit_style:
 * @COMMIT_LEGACY: Changes will be committed using the legacy API.
 * @COMMIT_UNIVERSAL: Changes will be committed with the universal plane API, no modesets are allowed.
 * @COMMIT_ATOMIC: Changes will be committed using the atomic API.
 */
239 240 241
enum igt_commit_style {
	COMMIT_LEGACY = 0,
	COMMIT_UNIVERSAL,
242
	COMMIT_ATOMIC,
243 244
};

245 246 247 248 249 250 251 252 253 254 255
enum igt_atomic_plane_properties {
       IGT_PLANE_SRC_X = 0,
       IGT_PLANE_SRC_Y,
       IGT_PLANE_SRC_W,
       IGT_PLANE_SRC_H,

       IGT_PLANE_CRTC_X,
       IGT_PLANE_CRTC_Y,
       IGT_PLANE_CRTC_W,
       IGT_PLANE_CRTC_H,

256 257 258
/* Append new properties after IGT_PLANE_COORD_CHANGED_MASK */
#define IGT_PLANE_COORD_CHANGED_MASK 0xff

259 260
       IGT_PLANE_FB_ID,
       IGT_PLANE_CRTC_ID,
261
       IGT_PLANE_IN_FENCE_FD,
262 263 264 265 266
       IGT_PLANE_TYPE,
       IGT_PLANE_ROTATION,
       IGT_NUM_PLANE_PROPS
};

267 268 269 270 271 272 273
/**
 * igt_plane_prop_names
 *
 * igt_plane_prop_names contains a list of crtc property names,
 * as indexed by the igt_atomic_plane_properties enum.
 */
extern const char *igt_plane_prop_names[];
274

275 276
typedef struct igt_display igt_display_t;
typedef struct igt_pipe igt_pipe_t;
277
typedef uint32_t igt_fixed_t;			/* 16.16 fixed point */
278

279 280 281 282 283 284 285 286
typedef enum {
	/* this maps to the kernel API */
	IGT_ROTATION_0   = 1 << 0,
	IGT_ROTATION_90  = 1 << 1,
	IGT_ROTATION_180 = 1 << 2,
	IGT_ROTATION_270 = 1 << 3,
} igt_rotation_t;

287
typedef struct {
288
	/*< private >*/
289 290
	igt_pipe_t *pipe;
	int index;
291
	/* capabilities */
292
	int type;
293

294 295 296 297 298
	/*
	 * drm_plane can be NULL for primary and cursor planes (when not
	 * using the atomic modeset API)
	 */
	drmModePlane *drm_plane;
299

300 301
	/* gem handle for fb */
	uint32_t gem_handle;
302

303 304 305
	uint64_t changed;
	uint32_t props[IGT_NUM_PLANE_PROPS];
	uint64_t values[IGT_NUM_PLANE_PROPS];
306 307 308 309 310
} igt_plane_t;

struct igt_pipe {
	igt_display_t *display;
	enum pipe pipe;
311

312
	int n_planes;
313 314 315
	int plane_cursor;
	int plane_primary;
	igt_plane_t *planes;
316

317 318 319
	uint64_t changed;
	uint32_t props[IGT_NUM_CRTC_PROPS];
	uint64_t values[IGT_NUM_CRTC_PROPS];
320

321
	uint32_t crtc_id;
322

323
	int32_t out_fence_fd;
324 325 326
};

typedef struct {
327
	/*< private >*/
328 329 330 331
	igt_display_t *display;
	uint32_t id;					/* KMS id */
	struct kmstest_connector_config config;
	char *name;
332
	bool force_reprobe;
333
	enum pipe pending_pipe;
334 335
	bool use_override_mode;
	drmModeModeInfo override_mode;
336 337 338 339 340 341

	/* bitmask of changed properties */
	uint64_t changed;

	uint32_t props[IGT_NUM_CONNECTOR_PROPS];
	uint64_t values[IGT_NUM_CONNECTOR_PROPS];
342 343 344 345 346 347 348 349
} igt_output_t;

struct igt_display {
	int drm_fd;
	int log_shift;
	int n_pipes;
	int n_outputs;
	igt_output_t *outputs;
350
	igt_pipe_t *pipes;
351
	bool has_cursor_plane;
352
	bool is_atomic;
353 354 355 356
};

void igt_display_init(igt_display_t *display, int drm_fd);
void igt_display_fini(igt_display_t *display);
357
int  igt_display_commit2(igt_display_t *display, enum igt_commit_style s);
358
int  igt_display_commit(igt_display_t *display);
359 360
int  igt_display_try_commit_atomic(igt_display_t *display, uint32_t flags, void *user_data);
void igt_display_commit_atomic(igt_display_t *display, uint32_t flags, void *user_data);
361
int  igt_display_try_commit2(igt_display_t *display, enum igt_commit_style s);
362
int  igt_display_get_n_pipes(igt_display_t *display);
363 364
void igt_display_require_output(igt_display_t *display);
void igt_display_require_output_on_pipe(igt_display_t *display, enum pipe pipe);
365 366 367

const char *igt_output_name(igt_output_t *output);
drmModeModeInfo *igt_output_get_mode(igt_output_t *output);
368
void igt_output_override_mode(igt_output_t *output, drmModeModeInfo *mode);
369
void igt_output_set_pipe(igt_output_t *output, enum pipe pipe);
370 371
igt_plane_t *igt_output_get_plane(igt_output_t *output, int plane_idx);
igt_plane_t *igt_output_get_plane_type(igt_output_t *output, int plane_type);
372
igt_output_t *igt_output_from_connector(igt_display_t *display,
373 374
    drmModeConnector *connector);
igt_plane_t *igt_pipe_get_plane_type(igt_pipe_t *pipe, int plane_type);
375

376
void igt_pipe_request_out_fence(igt_pipe_t *pipe);
377

378
void igt_plane_set_fb(igt_plane_t *plane, struct igt_fb *fb);
379
void igt_plane_set_fence_fd(igt_plane_t *plane, int fence_fd);
380
void igt_plane_set_position(igt_plane_t *plane, int x, int y);
381
void igt_plane_set_size(igt_plane_t *plane, int w, int h);
382
void igt_plane_set_rotation(igt_plane_t *plane, igt_rotation_t rotation);
383 384 385 386
void igt_fb_set_position(struct igt_fb *fb, igt_plane_t *plane,
	uint32_t x, uint32_t y);
void igt_fb_set_size(struct igt_fb *fb, igt_plane_t *plane,
	uint32_t w, uint32_t h);
387

388
void igt_wait_for_vblank(int drm_fd, enum pipe pipe);
389
void igt_wait_for_vblank_count(int drm_fd, enum pipe pipe, int count);
390

391 392 393 394 395 396 397 398 399 400 401 402
static inline bool igt_output_is_connected(igt_output_t *output)
{
	/* Something went wrong during probe? */
	if (!output->config.connector)
		return false;

	if (output->config.connector->connection == DRM_MODE_CONNECTED)
		return true;

	return false;
}

403 404 405 406 407 408 409 410 411 412
/**
 * igt_pipe_connector_valid:
 * @pipe: pipe to check.
 * @output: #igt_output_t to check.
 *
 * Checks whether the given pipe and output can be used together.
 */
#define igt_pipe_connector_valid(pipe, output) \
	(igt_output_is_connected((output)) && \
	       (output->config.valid_crtc_idx_mask & (1 << (pipe))))
413 414 415

#define for_each_if(condition) if (!(condition)) {} else

416 417 418 419 420 421 422
/**
 * for_each_connected_output:
 * @display: a pointer to an #igt_display_t structure
 * @output: The output to iterate.
 *
 * This for loop iterates over all outputs.
 */
423
#define for_each_connected_output(display, output)		\
424
	for (int i__ = 0;  assert(igt_can_fail()), i__ < (display)->n_outputs; i__++)	\
425 426
		for_each_if (((output = &(display)->outputs[i__]), \
			      igt_output_is_connected(output)))
427

428 429 430 431 432 433 434 435 436 437 438 439
/**
 * for_each_pipe:
 * @pipe: The pipe to iterate.
 *
 * This for loop iterates over all pipes supported by IGT libraries.
 *
 * This should be used to enumerate per-pipe subtests since it has no runtime
 * depencies.
 */
#define for_each_pipe_static(pipe) \
	for (pipe = 0; pipe < IGT_MAX_PIPES; pipe++)

440 441 442 443 444 445
/**
 * for_each_pipe:
 * @display: a pointer to an #igt_display_t structure
 * @pipe: The pipe to iterate.
 *
 * This for loop iterates over all pipes.
446 447 448 449
 *
 * Note that this cannot be used to enumerate per-pipe subtest names since it
 * depends upon runtime probing of the actual kms driver that is being tested.
 * Used #for_each_pipe_static instead.
450
 */
451
#define for_each_pipe(display, pipe)					\
452
	for (pipe = 0; assert(igt_can_fail()), pipe < igt_display_get_n_pipes(display); pipe++)
453

454 455 456 457 458 459 460 461 462
/**
 * for_each_pipe_with_valid_output:
 * @display: a pointer to an #igt_display_t structure
 * @pipe: The pipe for which this @pipe / @output combination is valid.
 * @output: The output for which this @pipe / @output combination is valid.
 *
 * This for loop is called over all connected outputs. This function
 * will try every combination of @pipe and @output.
 */
463 464
#define for_each_pipe_with_valid_output(display, pipe, output) \
	for (int con__ = pipe = 0; \
465
	     assert(igt_can_fail()), pipe < igt_display_get_n_pipes((display)) && con__ < (display)->n_outputs; \
466 467 468 469
	     con__ = (con__ + 1 < (display)->n_outputs) ? con__ + 1 : (pipe = pipe + 1, 0)) \
		for_each_if (((output = &(display)->outputs[con__]), \
			     igt_pipe_connector_valid(pipe, output)))

470 471 472 473 474 475 476 477 478 479
/**
 * for_each_valid_output_on_pipe:
 * @display: a pointer to an #igt_display_t structure
 * @pipe: Pipe to enumerate valid outputs over
 * @output: The enumerated output.
 *
 * This for loop is called over all connected @output that can be used
 * on this @pipe . If there are no valid outputs for this pipe, nothing
 * happens.
 */
480
#define for_each_valid_output_on_pipe(display, pipe, output) \
481
	for_each_connected_output(display, output) \
482 483
		for_each_if (igt_pipe_connector_valid(pipe, output))

484
#define for_each_plane_on_pipe(display, pipe, plane)			\
485
	for (int j__ = 0; assert(igt_can_fail()), (plane) = &(display)->pipes[(pipe)].planes[j__], \
486
		     j__ < (display)->pipes[(pipe)].n_planes; j__++)
487

488 489
#define IGT_FIXED(i,f)	((i) << 16 | (f))

490 491 492 493 494 495 496 497 498 499 500 501 502 503
/**
 * igt_plane_has_prop - Check whether plane supports a given property.
 *
 * @plane: Plane to check.
 * @prop: Property to check.
 *
 * Returns: True if the property is supported, otherwise false.
 */
static inline bool
igt_plane_has_prop(igt_plane_t *plane, enum igt_atomic_plane_properties prop)
{
	return plane->props[prop];
}

504 505
uint64_t igt_plane_get_prop(igt_plane_t *plane, enum igt_atomic_plane_properties prop);

506 507 508 509 510 511 512 513 514 515 516 517 518 519
#define igt_plane_is_prop_changed(plane, prop) \
	(!!((plane)->changed & (1 << (prop))))

#define igt_plane_set_prop_changed(plane, prop) \
	(plane)->changed |= 1 << (prop)

#define igt_plane_clear_prop_changed(plane, prop) \
	(plane)->changed &= ~(1 << (prop))

#define igt_plane_set_prop_value(plane, prop, value) \
	do { \
		plane->values[prop] = value; \
		igt_plane_set_prop_changed(plane, prop); \
	} while (0)
520

521 522 523 524
extern void igt_plane_replace_prop_blob(igt_plane_t *plane,
					enum igt_atomic_plane_properties prop,
					const void *ptr, size_t length);

525 526 527 528 529 530 531 532 533 534 535 536 537 538
/**
 * igt_output_has_prop - Check whether output supports a given property.
 *
 * @output: Output to check.
 * @prop: Property to check.
 *
 * Returns: True if the property is supported, otherwise false.
 */
static inline bool
igt_output_has_prop(igt_output_t *output, enum igt_atomic_connector_properties prop)
{
	return output->props[prop];
}

539 540
uint64_t igt_output_get_prop(igt_output_t *output, enum igt_atomic_connector_properties prop);

541 542 543 544 545 546 547 548 549 550 551 552 553
#define igt_output_is_prop_changed(output, prop) \
	(!!((output)->changed & (1 << (prop))))
#define igt_output_set_prop_changed(output, prop) \
	(output)->changed |= 1 << (prop)

#define igt_output_clear_prop_changed(output, prop) \
	(output)->changed &= ~(1 << (prop))

#define igt_output_set_prop_value(output, prop, value) \
	do { \
		(output)->values[prop] = (value); \
		igt_output_set_prop_changed(output, prop); \
	} while (0)
554

555 556 557 558
extern void igt_output_replace_prop_blob(igt_output_t *output,
					 enum igt_atomic_connector_properties prop,
					 const void *ptr, size_t length);

559 560 561 562 563 564 565 566 567 568 569 570 571 572
/**
 * igt_pipe_obj_has_prop - Check whether pipe supports a given property.
 *
 * @pipe: Pipe to check.
 * @prop: Property to check.
 *
 * Returns: True if the property is supported, otherwise false.
 */
static inline bool
igt_pipe_obj_has_prop(igt_pipe_t *pipe, enum igt_atomic_crtc_properties prop)
{
	return pipe->props[prop];
}

573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592
uint64_t igt_pipe_obj_get_prop(igt_pipe_t *pipe, enum igt_atomic_crtc_properties prop);

/**
 * igt_pipe_get_prop - Return current value on a pipe for a given property.
 *
 * @display: Pointer to display.
 * @pipe: Target pipe.
 * @prop: Property to return.
 *
 * Returns: The value the property is set to, if this
 * is a blob, the blob id is returned. This can be passed
 * to drmModeGetPropertyBlob() to get the contents of the blob.
 */
static inline uint64_t
igt_pipe_get_prop(igt_display_t *display, enum pipe pipe,
		  enum igt_atomic_crtc_properties prop)
{
	return igt_pipe_obj_get_prop(&display->pipes[pipe], prop);
}

593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608
/**
 * igt_pipe_has_prop - Check whether pipe supports a given property.
 *
 * @display: Pointer to display.
 * @pipe: Pipe to check.
 * @prop: Property to check.
 *
 * Returns: True if the property is supported, otherwise false.
 */
static inline bool
igt_pipe_has_prop(igt_display_t *display, enum pipe pipe,
		  enum igt_atomic_connector_properties prop)
{
	return display->pipes[pipe].props[prop];
}

609 610
#define igt_pipe_obj_is_prop_changed(pipe_obj, prop) \
	(!!((pipe_obj)->changed & (1 << (prop))))
611

612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635
#define igt_pipe_is_prop_changed(display, pipe, prop) \
	igt_pipe_obj_is_prop_changed(&(display)->pipes[(pipe)], prop)

#define igt_pipe_obj_set_prop_changed(pipe_obj, prop) \
	(pipe_obj)->changed |= 1 << (prop)

#define igt_pipe_set_prop_changed(display, pipe, prop) \
	igt_pipe_obj_set_prop_changed(&(display)->pipes[(pipe)], prop)

#define igt_pipe_obj_clear_prop_changed(pipe_obj, prop) \
	(pipe_obj)->changed &= ~(1 << (prop))

#define igt_pipe_clear_prop_changed(display, pipe, prop) \
	igt_pipe_obj_clear_prop_changed(&(display)->pipes[(pipe)], prop)

#define igt_pipe_obj_set_prop_value(pipe_obj, prop, value) \
	do { \
		(pipe_obj)->values[prop] = (value); \
		igt_pipe_obj_set_prop_changed(pipe_obj, prop); \
	} while (0)

#define igt_pipe_set_prop_value(display, pipe, prop, value) \
	igt_pipe_obj_set_prop_value(&(display)->pipes[(pipe)], prop, value)

636 637 638 639 640 641 642
extern void igt_pipe_obj_replace_prop_blob(igt_pipe_t *pipe_obj,
					   enum igt_atomic_crtc_properties prop,
					   const void *ptr, size_t length);

#define igt_pipe_replace_prop_blob(display, pipe, prop, ptr, length) \
	igt_pipe_obj_replace_prop_blob(&(display)->pipes[(pipe)], prop, ptr, length)

643
void igt_pipe_refresh(igt_display_t *display, enum pipe pipe, bool force);
644

645 646 647
void igt_enable_connectors(void);
void igt_reset_connectors(void);

648 649
uint32_t kmstest_get_vbl_flag(uint32_t pipe_id);

Thomas Wood's avatar
Thomas Wood committed
650
#define EDID_LENGTH 128
Thomas Wood's avatar
Thomas Wood committed
651
const unsigned char* igt_kms_get_base_edid(void);
652
const unsigned char* igt_kms_get_alt_edid(void);
Thomas Wood's avatar
Thomas Wood committed
653

654 655 656 657 658 659 660
#ifdef HAVE_UDEV
struct udev_monitor *igt_watch_hotplug(void);
bool igt_hotplug_detected(struct udev_monitor *mon,
			  int timeout_secs);
void igt_flush_hotplugs(struct udev_monitor *mon);
void igt_cleanup_hotplug(struct udev_monitor *mon);
#endif
Thomas Wood's avatar
Thomas Wood committed
661

662
#endif /* __IGT_KMS_H__ */