/*

 * DRM based mode setting test program

 * Copyright 2008 Tungsten Graphics

 *   Jakob Bornecrantz <jakob@tungstengraphics.com>

 * Copyright 2008 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.

 */

/*

 * This fairly simple test program dumps output in a similar format to the

 * "xrandr" tool everyone knows & loves.  It's necessarily slightly different

 * since the kernel separates outputs into encoder and connector structures,

 * each with their own unique ID.  The program also allows test testing of the

 * memory management and mode setting APIs by allowing the user to specify a

 * connector and mode to use for mode setting.  If all works as expected, a

 * blue background should be painted on the monitor attached to the specified

 * connector after the selected mode is set.

 *

 * TODO: use cairo to write the mode info on the selected output once

 *       the mode has been programmed, along with possible test patterns.

 */

#include <assert.h>

#include <ctype.h>

#include <stdbool.h>

#include <stdio.h>

#include <stdlib.h>

#include <stdint.h>

#include <inttypes.h>

#include <unistd.h>

#include <string.h>

#include <strings.h>

#include <errno.h>

#include <poll.h>

#include <sys/time.h>

#ifdef HAVE_SYS_SELECT_H

#include <sys/select.h>

#endif

#include "xf86drm.h"

#include "xf86drmMode.h"

#include "drm_fourcc.h"

#include "util/common.h"

#include "util/format.h"

#include "util/kms.h"

#include "util/pattern.h"

#include "buffers.h"

#include "cursor.h"

static enum util_fill_pattern primary_fill = UTIL_PATTERN_SMPTE;

static enum util_fill_pattern secondary_fill = UTIL_PATTERN_TILES;

struct crtc {

	drmModeCrtc *crtc;

	drmModeObjectProperties *props;

	drmModePropertyRes **props_info;

	drmModeModeInfo *mode;

};

struct encoder {

	drmModeEncoder *encoder;

};

struct connector {

	drmModeConnector *connector;

	drmModeObjectProperties *props;

	drmModePropertyRes **props_info;

	char *name;

};

struct fb {

	drmModeFB *fb;

};

struct plane {

	drmModePlane *plane;

	drmModeObjectProperties *props;

	drmModePropertyRes **props_info;

};

struct resources {

	drmModeRes *res;

	drmModePlaneRes *plane_res;

	struct crtc *crtcs;

	struct encoder *encoders;

	struct connector *connectors;

	struct fb *fbs;

	struct plane *planes;

};

struct device {

	int fd;

	struct resources *resources;

	struct {

		unsigned int width;

		unsigned int height;

		unsigned int fb_id;

		struct bo *bo;

		struct bo *cursor_bo;

	} mode;

	int use_atomic;

	drmModeAtomicReq *req;

};

static inline int64_t U642I64(uint64_t val)

{

	return (int64_t)*((int64_t *)&val;;

}

#define bit_name_fn(res)					\

const char * res##_str(int type) {				\

	unsigned int i;						\

	const char *sep = "";					\

	for (i = 0; i < ARRAY_SIZE(res##_names); i++) {		\

		if (type & (1 << i)) {				\

			printf("%s%s", sep, res##_names[i]);	\

			sep = ", ";				\

		}						\

	}							\

	return NULL;						\

}

static const char *mode_type_names[] = {

	"builtin",

	"clock_c",

	"crtc_c",

	"preferred",

	"default",

	"userdef",

	"driver",

};

static bit_name_fn(mode_type)

static const char *mode_flag_names[] = {

	"phsync",

	"nhsync",

	"pvsync",

	"nvsync",

	"interlace",

	"dblscan",

	"csync",

	"pcsync",

	"ncsync",

	"hskew",

	"bcast",

	"pixmux",

	"dblclk",

	"clkdiv2"

};

static bit_name_fn(mode_flag)

static void dump_fourcc(uint32_t fourcc)

{

	printf(" %c%c%c%c",

		fourcc,

		fourcc >> 8,

		fourcc >> 16,

		fourcc >> 24);

}

static void dump_encoders(struct device *dev)

{

	drmModeEncoder *encoder;

	int i;

	printf("Encoders:\n");

	printf("id\tcrtc\ttype\tpossible crtcs\tpossible clones\t\n");

	for (i = 0; i < dev->resources->res->count_encoders; i++) {

		encoder = dev->resources->encoders[i].encoder;

		if (!encoder)

			continue;

		printf("%d\t%d\t%s\t0x%08x\t0x%08x\n",

		       encoder->encoder_id,

		       encoder->crtc_id,

		       util_lookup_encoder_type_name(encoder->encoder_type),

		       encoder->possible_crtcs,

		       encoder->possible_clones);

	}

	printf("\n");

}

static void dump_mode(drmModeModeInfo *mode)

{

	printf("  %s %d %d %d %d %d %d %d %d %d %d",

	       mode->name,

	       mode->vrefresh,

	       mode->hdisplay,

	       mode->hsync_start,

	       mode->hsync_end,

	       mode->htotal,

	       mode->vdisplay,

	       mode->vsync_start,

	       mode->vsync_end,

	       mode->vtotal,

	       mode->clock);

	printf(" flags: ");

	mode_flag_str(mode->flags);

	printf("; type: ");

	mode_type_str(mode->type);

	printf("\n");

}

static void dump_blob(struct device *dev, uint32_t blob_id)

{

	uint32_t i;

	unsigned char *blob_data;

	drmModePropertyBlobPtr blob;

	blob = drmModeGetPropertyBlob(dev->fd, blob_id);

	if (!blob) {

		printf("\n");

		return;

	}

	blob_data = blob->data;

	for (i = 0; i < blob->length; i++) {

		if (i % 16 == 0)

			printf("\n\t\t\t");

		printf("%.2hhx", blob_data[i]);

	}

	printf("\n");

	drmModeFreePropertyBlob(blob);

}

static const char *modifier_to_string(uint64_t modifier)

{

	switch (modifier) {

	case DRM_FORMAT_MOD_INVALID:

		return "INVALID";

	case DRM_FORMAT_MOD_LINEAR:

		return "LINEAR";

	case I915_FORMAT_MOD_X_TILED:

		return "X_TILED";

	case I915_FORMAT_MOD_Y_TILED:

		return "Y_TILED";

	case I915_FORMAT_MOD_Yf_TILED:

		return "Yf_TILED";

	case I915_FORMAT_MOD_Y_TILED_CCS:

		return "Y_TILED_CCS";

	case I915_FORMAT_MOD_Yf_TILED_CCS:

		return "Yf_TILED_CCS";

	case DRM_FORMAT_MOD_SAMSUNG_64_32_TILE:

		return "SAMSUNG_64_32_TILE";

	case DRM_FORMAT_MOD_VIVANTE_TILED:

		return "VIVANTE_TILED";

	case DRM_FORMAT_MOD_VIVANTE_SUPER_TILED:

		return "VIVANTE_SUPER_TILED";

	case DRM_FORMAT_MOD_VIVANTE_SPLIT_TILED:

		return "VIVANTE_SPLIT_TILED";

	case DRM_FORMAT_MOD_VIVANTE_SPLIT_SUPER_TILED:

		return "VIVANTE_SPLIT_SUPER_TILED";

	case DRM_FORMAT_MOD_NVIDIA_TEGRA_TILED:

		return "NVIDIA_TEGRA_TILED";

	case DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK(0):

		return "NVIDIA_16BX2_BLOCK(0)";

	case DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK(1):

		return "NVIDIA_16BX2_BLOCK(1)";

	case DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK(2):

		return "NVIDIA_16BX2_BLOCK(2)";

	case DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK(3):

		return "NVIDIA_16BX2_BLOCK(3)";

	case DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK(4):

		return "NVIDIA_16BX2_BLOCK(4)";

	case DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK(5):

		return "NVIDIA_16BX2_BLOCK(5)";

	case DRM_FORMAT_MOD_BROADCOM_VC4_T_TILED:

		return "MOD_BROADCOM_VC4_T_TILED";

	case DRM_FORMAT_MOD_QCOM_COMPRESSED:

		return "QCOM_COMPRESSED";

	default:

		return "(UNKNOWN MODIFIER)";

	}

}

static void dump_in_formats(struct device *dev, uint32_t blob_id)

{

	uint32_t i, j;

	drmModePropertyBlobPtr blob;

	struct drm_format_modifier_blob *header;

	uint32_t *formats;

	struct drm_format_modifier *modifiers;

	printf("\t\tin_formats blob decoded:\n");

	blob = drmModeGetPropertyBlob(dev->fd, blob_id);

	if (!blob) {

		printf("\n");

		return;

	}

	header = blob->data;

	formats = (uint32_t *) ((char *) header + header->formats_offset);

	modifiers = (struct drm_format_modifier *)

		((char *) header + header->modifiers_offset);

	for (i = 0; i < header->count_formats; i++) {

		printf("\t\t\t");

		dump_fourcc(formats[i]);

		printf(": ");

		for (j = 0; j < header->count_modifiers; j++) {

			uint64_t mask = 1ULL << i;

			if (modifiers[j].formats & mask)

				printf(" %s", modifier_to_string(modifiers[j].modifier));

		}

		printf("\n");

	}

	drmModeFreePropertyBlob(blob);

}

static void dump_prop(struct device *dev, drmModePropertyPtr prop,

		      uint32_t prop_id, uint64_t value)

{

	int i;

	printf("\t%d", prop_id);

	if (!prop) {

		printf("\n");

		return;

	}

	printf(" %s:\n", prop->name);

	printf("\t\tflags:");

	if (prop->flags & DRM_MODE_PROP_PENDING)

		printf(" pending");

	if (prop->flags & DRM_MODE_PROP_IMMUTABLE)

		printf(" immutable");

	if (drm_property_type_is(prop, DRM_MODE_PROP_SIGNED_RANGE))

		printf(" signed range");

	if (drm_property_type_is(prop, DRM_MODE_PROP_RANGE))

		printf(" range");

	if (drm_property_type_is(prop, DRM_MODE_PROP_ENUM))

		printf(" enum");

	if (drm_property_type_is(prop, DRM_MODE_PROP_BITMASK))

		printf(" bitmask");

	if (drm_property_type_is(prop, DRM_MODE_PROP_BLOB))

		printf(" blob");

	if (drm_property_type_is(prop, DRM_MODE_PROP_OBJECT))

		printf(" object");

	printf("\n");

	if (drm_property_type_is(prop, DRM_MODE_PROP_SIGNED_RANGE)) {

		printf("\t\tvalues:");

		for (i = 0; i < prop->count_values; i++)

			printf(" %"PRId64, U642I64(prop->values[i]));

		printf("\n");

	}

	if (drm_property_type_is(prop, DRM_MODE_PROP_RANGE)) {

		printf("\t\tvalues:");

		for (i = 0; i < prop->count_values; i++)

			printf(" %"PRIu64, prop->values[i]);

		printf("\n");

	}

	if (drm_property_type_is(prop, DRM_MODE_PROP_ENUM)) {

		printf("\t\tenums:");

		for (i = 0; i < prop->count_enums; i++)

			printf(" %s=%llu", prop->enums[i].name,

			       prop->enums[i].value);

		printf("\n");

	} else if (drm_property_type_is(prop, DRM_MODE_PROP_BITMASK)) {

		printf("\t\tvalues:");

		for (i = 0; i < prop->count_enums; i++)

			printf(" %s=0x%llx", prop->enums[i].name,

			       (1LL << prop->enums[i].value));

		printf("\n");

	} else {

		assert(prop->count_enums == 0);

	}

	if (drm_property_type_is(prop, DRM_MODE_PROP_BLOB)) {

		printf("\t\tblobs:\n");

		for (i = 0; i < prop->count_blobs; i++)

			dump_blob(dev, prop->blob_ids[i]);

		printf("\n");

	} else {

		assert(prop->count_blobs == 0);

	}

	printf("\t\tvalue:");

	if (drm_property_type_is(prop, DRM_MODE_PROP_BLOB))

		dump_blob(dev, value);

	else if (drm_property_type_is(prop, DRM_MODE_PROP_SIGNED_RANGE))

		printf(" %"PRId64"\n", value);

	else

		printf(" %"PRIu64"\n", value);

	if (strcmp(prop->name, "IN_FORMATS") == 0)

		dump_in_formats(dev, value);

}

static void dump_connectors(struct device *dev)

{

	int i, j;

	printf("Connectors:\n");

	printf("id\tencoder\tstatus\t\tname\t\tsize (mm)\tmodes\tencoders\n");

	for (i = 0; i < dev->resources->res->count_connectors; i++) {

		struct connector *_connector = &dev->resources->connectors[i];

		drmModeConnector *connector = _connector->connector;

		if (!connector)

			continue;

		printf("%d\t%d\t%s\t%-15s\t%dx%d\t\t%d\t",

		       connector->connector_id,

		       connector->encoder_id,

		       util_lookup_connector_status_name(connector->connection),

		       _connector->name,

		       connector->mmWidth, connector->mmHeight,

		       connector->count_modes);

		for (j = 0; j < connector->count_encoders; j++)

			printf("%s%d", j > 0 ? ", " : "", connector->encoders[j]);

		printf("\n");

		if (connector->count_modes) {

			printf("  modes:\n");

			printf("\tname refresh (Hz) hdisp hss hse htot vdisp "

			       "vss vse vtot)\n");

			for (j = 0; j < connector->count_modes; j++)

				dump_mode(&connector->modes[j]);

		}

		if (_connector->props) {

			printf("  props:\n");

			for (j = 0; j < (int)_connector->props->count_props; j++)

				dump_prop(dev, _connector->props_info[j],

					  _connector->props->props[j],

					  _connector->props->prop_values[j]);

		}

	}

	printf("\n");

}

static void dump_crtcs(struct device *dev)

{

	int i;

	uint32_t j;

	printf("CRTCs:\n");

	printf("id\tfb\tpos\tsize\n");

	for (i = 0; i < dev->resources->res->count_crtcs; i++) {

		struct crtc *_crtc = &dev->resources->crtcs[i];

		drmModeCrtc *crtc = _crtc->crtc;

		if (!crtc)

			continue;

		printf("%d\t%d\t(%d,%d)\t(%dx%d)\n",

		       crtc->crtc_id,

		       crtc->buffer_id,

		       crtc->x, crtc->y,

		       crtc->width, crtc->height);

		dump_mode(&crtc->mode);

		if (_crtc->props) {

			printf("  props:\n");

			for (j = 0; j < _crtc->props->count_props; j++)

				dump_prop(dev, _crtc->props_info[j],

					  _crtc->props->props[j],

					  _crtc->props->prop_values[j]);

		} else {

			printf("  no properties found\n");

		}

	}

	printf("\n");

}

static void dump_framebuffers(struct device *dev)

{

	drmModeFB *fb;

	int i;

	printf("Frame buffers:\n");

	printf("id\tsize\tpitch\n");

	for (i = 0; i < dev->resources->res->count_fbs; i++) {

		fb = dev->resources->fbs[i].fb;

		if (!fb)

			continue;

		printf("%u\t(%ux%u)\t%u\n",

		       fb->fb_id,

		       fb->width, fb->height,

		       fb->pitch);

	}

	printf("\n");

}

static void dump_planes(struct device *dev)

{

	unsigned int i, j;

	printf("Planes:\n");

	printf("id\tcrtc\tfb\tCRTC x,y\tx,y\tgamma size\tpossible crtcs\n");

	if (!dev->resources->plane_res)

		return;

	for (i = 0; i < dev->resources->plane_res->count_planes; i++) {

		struct plane *plane = &dev->resources->planes[i];

		drmModePlane *ovr = plane->plane;

		if (!ovr)

			continue;

		printf("%d\t%d\t%d\t%d,%d\t\t%d,%d\t%-8d\t0x%08x\n",

		       ovr->plane_id, ovr->crtc_id, ovr->fb_id,

		       ovr->crtc_x, ovr->crtc_y, ovr->x, ovr->y,

		       ovr->gamma_size, ovr->possible_crtcs);

		if (!ovr->count_formats)

			continue;

		printf("  formats:");

		for (j = 0; j < ovr->count_formats; j++)

			dump_fourcc(ovr->formats[j]);

		printf("\n");

		if (plane->props) {

			printf("  props:\n");

			for (j = 0; j < plane->props->count_props; j++)

				dump_prop(dev, plane->props_info[j],

					  plane->props->props[j],

					  plane->props->prop_values[j]);

		} else {

			printf("  no properties found\n");

		}

	}

	printf("\n");

	return;

}

static void free_resources(struct resources *res)

{

	int i;

	if (!res)

		return;

#define free_resource(_res, __res, type, Type)					\

	do {									\

		if (!(_res)->type##s)						\

			break;							\

		for (i = 0; i < (int)(_res)->__res->count_##type##s; ++i) {	\

			if (!(_res)->type##s[i].type)				\

				break;						\

			drmModeFree##Type((_res)->type##s[i].type);		\

		}								\

		free((_res)->type##s);						\

	} while (0)

#define free_properties(_res, __res, type)					\

	do {									\

		for (i = 0; i < (int)(_res)->__res->count_##type##s; ++i) {	\

			drmModeFreeObjectProperties(res->type##s[i].props);	\

			free(res->type##s[i].props_info);			\

		}								\

	} while (0)

	if (res->res) {

		free_properties(res, res, crtc);

		free_resource(res, res, crtc, Crtc);

		free_resource(res, res, encoder, Encoder);

		for (i = 0; i < res->res->count_connectors; i++)

			free(res->connectors[i].name);

		free_resource(res, res, connector, Connector);

		free_resource(res, res, fb, FB);

		drmModeFreeResources(res->res);

	}

	if (res->plane_res) {

		free_properties(res, plane_res, plane);

		free_resource(res, plane_res, plane, Plane);

		drmModeFreePlaneResources(res->plane_res);

	}

	free(res);

}

static struct resources *get_resources(struct device *dev)

{

	struct resources *res;

	int i;

	res = calloc(1, sizeof(*res));

	if (res == 0)

		return NULL;

	drmSetClientCap(dev->fd, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1);

	res->res = drmModeGetResources(dev->fd);

	if (!res->res) {

		fprintf(stderr, "drmModeGetResources failed: %s\n",

			strerror(errno));

		goto error;

	}

	res->crtcs = calloc(res->res->count_crtcs, sizeof(*res->crtcs));

	res->encoders = calloc(res->res->count_encoders, sizeof(*res->encoders));

	res->connectors = calloc(res->res->count_connectors, sizeof(*res->connectors));

	res->fbs = calloc(res->res->count_fbs, sizeof(*res->fbs));

	if (!res->crtcs || !res->encoders || !res->connectors || !res->fbs)

		goto error;

#define get_resource(_res, __res, type, Type)					\

	do {									\

		for (i = 0; i < (int)(_res)->__res->count_##type##s; ++i) {	\

			(_res)->type##s[i].type =				\

				drmModeGet##Type(dev->fd, (_res)->__res->type##s[i]); \

			if (!(_res)->type##s[i].type)				\

				fprintf(stderr, "could not get %s %i: %s\n",	\

					#type, (_res)->__res->type##s[i],	\

					strerror(errno));			\

		}								\

	} while (0)

	get_resource(res, res, crtc, Crtc);

	get_resource(res, res, encoder, Encoder);

	get_resource(res, res, connector, Connector);

	get_resource(res, res, fb, FB);

	/* Set the name of all connectors based on the type name and the per-type ID. */

	for (i = 0; i < res->res->count_connectors; i++) {

		struct connector *connector = &res->connectors[i];

		drmModeConnector *conn = connector->connector;

		int num;

		num = asprintf(&connector->name, "%s-%u",

			 util_lookup_connector_type_name(conn->connector_type),

			 conn->connector_type_id);

		if (num < 0)

			goto error;

	}

#define get_properties(_res, __res, type, Type)					\

	do {									\

		for (i = 0; i < (int)(_res)->__res->count_##type##s; ++i) {	\

			struct type *obj = &res->type##s[i];			\

			unsigned int j;						\

			obj->props =						\

				drmModeObjectGetProperties(dev->fd, obj->type->type##_id, \

							   DRM_MODE_OBJECT_##Type); \

			if (!obj->props) {					\

				fprintf(stderr,					\

					"could not get %s %i properties: %s\n", \

					#type, obj->type->type##_id,		\

					strerror(errno));			\

				continue;					\

			}							\

			obj->props_info = calloc(obj->props->count_props,	\

						 sizeof(*obj->props_info));	\

			if (!obj->props_info)					\

				continue;					\

			for (j = 0; j < obj->props->count_props; ++j)		\

				obj->props_info[j] =				\

					drmModeGetProperty(dev->fd, obj->props->props[j]); \

		}								\

	} while (0)

	get_properties(res, res, crtc, CRTC);

	get_properties(res, res, connector, CONNECTOR);

	for (i = 0; i < res->res->count_crtcs; ++i)

		res->crtcs[i].mode = &res->crtcs[i].crtc->mode;

	res->plane_res = drmModeGetPlaneResources(dev->fd);

	if (!res->plane_res) {

		fprintf(stderr, "drmModeGetPlaneResources failed: %s\n",

			strerror(errno));

		return res;

	}

	res->planes = calloc(res->plane_res->count_planes, sizeof(*res->planes));

	if (!res->planes)

		goto error;

	get_resource(res, plane_res, plane, Plane);

	get_properties(res, plane_res, plane, PLANE);

	return res;

error:

	free_resources(res);

	return NULL;

}

static int get_crtc_index(struct device *dev, uint32_t id)

{

	int i;

	for (i = 0; i < dev->resources->res->count_crtcs; ++i) {

		drmModeCrtc *crtc = dev->resources->crtcs[i].crtc;

		if (crtc && crtc->crtc_id == id)

			return i;

	}

	return -1;

}

static drmModeConnector *get_connector_by_name(struct device *dev, const char *name)

{

	struct connector *connector;

	int i;

	for (i = 0; i < dev->resources->res->count_connectors; i++) {

		connector = &dev->resources->connectors[i];

		if (strcmp(connector->name, name) == 0)

			return connector->connector;

	}

	return NULL;

}

static drmModeConnector *get_connector_by_id(struct device *dev, uint32_t id)

{

	drmModeConnector *connector;

	int i;

	for (i = 0; i < dev->resources->res->count_connectors; i++) {

		connector = dev->resources->connectors[i].connector;

		if (connector && connector->connector_id == id)

			return connector;

	}

	return NULL;

}

static drmModeEncoder *get_encoder_by_id(struct device *dev, uint32_t id)

{

	drmModeEncoder *encoder;

	int i;

	for (i = 0; i < dev->resources->res->count_encoders; i++) {

		encoder = dev->resources->encoders[i].encoder;

		if (encoder && encoder->encoder_id == id)

			return encoder;

	}

	return NULL;

}

/* -----------------------------------------------------------------------------

 * Pipes and planes

 */

/*

 * Mode setting with the kernel interfaces is a bit of a chore.

 * First you have to find the connector in question and make sure the

 * requested mode is available.

 * Then you need to find the encoder attached to that connector so you

 * can bind it with a free crtc.

 */

struct pipe_arg {

	const char **cons;

	uint32_t *con_ids;

	unsigned int num_cons;

	uint32_t crtc_id;

	char mode_str[64];

	char format_str[5];

	unsigned int vrefresh;

	unsigned int fourcc;

	drmModeModeInfo *mode;

	struct crtc *crtc;

	unsigned int fb_id[2], current_fb_id;

	struct timeval start;

	int swap_count;

};

struct plane_arg {

	uint32_t plane_id;  /* the id of plane to use */

	uint32_t crtc_id;  /* the id of CRTC to bind to */

	bool has_position;

	int32_t x, y;

	uint32_t w, h;

	double scale;

	unsigned int fb_id;

	unsigned int old_fb_id;

	struct bo *bo;

	struct bo *old_bo;

	char format_str[5]; /* need to leave room for terminating \0 */

	unsigned int fourcc;

};

static drmModeModeInfo *

connector_find_mode(struct device *dev, uint32_t con_id, const char *mode_str,

        const unsigned int vrefresh)

{

	drmModeConnector *connector;

	drmModeModeInfo *mode;

	int i;

	connector = get_connector_by_id(dev, con_id);

	if (!connector || !connector->count_modes)

		return NULL;

	for (i = 0; i < connector->count_modes; i++) {

		mode = &connector->modes[i];

		if (!strcmp(mode->name, mode_str)) {

			/* If the vertical refresh frequency is not specified then return the

			 * first mode that match with the name. Else, return the mode that match

			 * the name and the specified vertical refresh frequency.

			 */

			if (vrefresh == 0)

				return mode;

			else if (mode->vrefresh == vrefresh)

				return mode;

		}

	}

	return NULL;

}

static struct crtc *pipe_find_crtc(struct device *dev, struct pipe_arg *pipe)

{

	uint32_t possible_crtcs = ~0;

	uint32_t active_crtcs = 0;

	unsigned int crtc_idx;

	unsigned int i;

	int j;

	for (i = 0; i < pipe->num_cons; ++i) {

		uint32_t crtcs_for_connector = 0;

		drmModeConnector *connector;

		drmModeEncoder *encoder;

		int idx;

		connector = get_connector_by_id(dev, pipe->con_ids[i]);

		if (!connector)

			return NULL;

		for (j = 0; j < connector->count_encoders; ++j) {

			encoder = get_encoder_by_id(dev, connector->encoders[j]);

			if (!encoder)

				continue;

			crtcs_for_connector |= encoder->possible_crtcs;

			idx = get_crtc_index(dev, encoder->crtc_id);

			if (idx >= 0)

				active_crtcs |= 1 << idx;

		}