X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=tests%2Fmodetest%2Fmodetest.c;h=f0ed56b390b0dc20603865643117a4ea18a75ed9;hb=4a8da02e524d5d70ec638477e36fcafd2c8152ec;hp=1f241c769cc20f3b80222e105b8667df53fd1d06;hpb=dab3c80203e562cfdbe33e7d1627c9dde2f5a7de;p=platform%2Fupstream%2Flibdrm.git

diff --git a/tests/modetest/modetest.c b/tests/modetest/modetest.c
index 1f241c7..f0ed56b 100644
--- a/tests/modetest/modetest.c
+++ b/tests/modetest/modetest.c
@@ -40,6 +40,7 @@
 #include "config.h"
 
 #include <assert.h>
+#include <ctype.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -62,6 +63,7 @@ struct crtc {
 	drmModeCrtc *crtc;
 	drmModeObjectProperties *props;
 	drmModePropertyRes **props_info;
+	drmModeModeInfo *mode;
 };
 
 struct encoder {
@@ -95,8 +97,20 @@ struct resources {
 	struct plane *planes;
 };
 
-struct resources *resources;
-int fd;
+struct device {
+	int fd;
+
+	struct resources *resources;
+	struct kms_driver *kms;
+
+	struct {
+		unsigned int width;
+		unsigned int height;
+
+		unsigned int fb_id;
+		struct kms_bo *bo;
+	} mode;
+};
 
 #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
 
@@ -197,15 +211,15 @@ static const char *mode_flag_names[] = {
 
 static bit_name_fn(mode_flag)
 
-static void dump_encoders(void)
+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 < resources->res->count_encoders; i++) {
-		encoder = resources->encoders[i].encoder;
+	for (i = 0; i < dev->resources->res->count_encoders; i++) {
+		encoder = dev->resources->encoders[i].encoder;
 		if (!encoder)
 			continue;
 
@@ -240,14 +254,13 @@ static void dump_mode(drmModeModeInfo *mode)
 	printf("\n");
 }
 
-static void
-dump_blob(uint32_t blob_id)
+static void dump_blob(struct device *dev, uint32_t blob_id)
 {
 	uint32_t i;
 	unsigned char *blob_data;
 	drmModePropertyBlobPtr blob;
 
-	blob = drmModeGetPropertyBlob(fd, blob_id);
+	blob = drmModeGetPropertyBlob(dev->fd, blob_id);
 	if (!blob)
 		return;
 
@@ -263,8 +276,8 @@ dump_blob(uint32_t blob_id)
 	drmModeFreePropertyBlob(blob);
 }
 
-static void
-dump_prop(drmModePropertyPtr prop, uint32_t prop_id, uint64_t value)
+static void dump_prop(struct device *dev, drmModePropertyPtr prop,
+		      uint32_t prop_id, uint64_t value)
 {
 	int i;
 	printf("\t%d", prop_id);
@@ -316,7 +329,7 @@ dump_prop(drmModePropertyPtr prop, uint32_t prop_id, uint64_t value)
 	if (prop->flags & DRM_MODE_PROP_BLOB) {
 		printf("\t\tblobs:\n");
 		for (i = 0; i < prop->count_blobs; i++)
-			dump_blob(prop->blob_ids[i]);
+			dump_blob(dev, prop->blob_ids[i]);
 		printf("\n");
 	} else {
 		assert(prop->count_blobs == 0);
@@ -324,19 +337,19 @@ dump_prop(drmModePropertyPtr prop, uint32_t prop_id, uint64_t value)
 
 	printf("\t\tvalue:");
 	if (prop->flags & DRM_MODE_PROP_BLOB)
-		dump_blob(value);
+		dump_blob(dev, value);
 	else
 		printf(" %"PRIu64"\n", value);
 }
 
-static void dump_connectors(void)
+static void dump_connectors(struct device *dev)
 {
 	int i, j;
 
 	printf("Connectors:\n");
 	printf("id\tencoder\tstatus\t\ttype\tsize (mm)\tmodes\tencoders\n");
-	for (i = 0; i < resources->res->count_connectors; i++) {
-		struct connector *_connector = &resources->connectors[i];
+	for (i = 0; i < dev->resources->res->count_connectors; i++) {
+		struct connector *_connector = &dev->resources->connectors[i];
 		drmModeConnector *connector = _connector->connector;
 		if (!connector)
 			continue;
@@ -364,7 +377,7 @@ static void dump_connectors(void)
 		if (_connector->props) {
 			printf("  props:\n");
 			for (j = 0; j < (int)_connector->props->count_props; j++)
-				dump_prop(_connector->props_info[j],
+				dump_prop(dev, _connector->props_info[j],
 					  _connector->props->props[j],
 					  _connector->props->prop_values[j]);
 		}
@@ -372,15 +385,15 @@ static void dump_connectors(void)
 	printf("\n");
 }
 
-static void dump_crtcs(void)
+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 < resources->res->count_crtcs; i++) {
-		struct crtc *_crtc = &resources->crtcs[i];
+	for (i = 0; i < dev->resources->res->count_crtcs; i++) {
+		struct crtc *_crtc = &dev->resources->crtcs[i];
 		drmModeCrtc *crtc = _crtc->crtc;
 		if (!crtc)
 			continue;
@@ -395,7 +408,7 @@ static void dump_crtcs(void)
 		if (_crtc->props) {
 			printf("  props:\n");
 			for (j = 0; j < _crtc->props->count_props; j++)
-				dump_prop(_crtc->props_info[j],
+				dump_prop(dev, _crtc->props_info[j],
 					  _crtc->props->props[j],
 					  _crtc->props->prop_values[j]);
 		} else {
@@ -405,15 +418,15 @@ static void dump_crtcs(void)
 	printf("\n");
 }
 
-static void dump_framebuffers(void)
+static void dump_framebuffers(struct device *dev)
 {
 	drmModeFB *fb;
 	int i;
 
 	printf("Frame buffers:\n");
 	printf("id\tsize\tpitch\n");
-	for (i = 0; i < resources->res->count_fbs; i++) {
-		fb = resources->fbs[i].fb;
+	for (i = 0; i < dev->resources->res->count_fbs; i++) {
+		fb = dev->resources->fbs[i].fb;
 		if (!fb)
 			continue;
 
@@ -425,18 +438,18 @@ static void dump_framebuffers(void)
 	printf("\n");
 }
 
-static void dump_planes(void)
+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 (!resources->plane_res)
+	if (!dev->resources->plane_res)
 		return;
 
-	for (i = 0; i < resources->plane_res->count_planes; i++) {
-		struct plane *plane = &resources->planes[i];
+	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;
@@ -457,7 +470,7 @@ static void dump_planes(void)
 		if (plane->props) {
 			printf("  props:\n");
 			for (j = 0; j < plane->props->count_props; j++)
-				dump_prop(plane->props_info[j],
+				dump_prop(dev, plane->props_info[j],
 					  plane->props->props[j],
 					  plane->props->prop_values[j]);
 		} else {
@@ -518,9 +531,10 @@ static void free_resources(struct resources *res)
 	free(res);
 }
 
-static struct resources *get_resources(int fd)
+static struct resources *get_resources(struct device *dev)
 {
 	struct resources *res;
+	int i;
 
 	res = malloc(sizeof *res);
 	if (res == 0)
@@ -528,7 +542,7 @@ static struct resources *get_resources(int fd)
 
 	memset(res, 0, sizeof *res);
 
-	res->res = drmModeGetResources(fd);
+	res->res = drmModeGetResources(dev->fd);
 	if (!res->res) {
 		fprintf(stderr, "drmModeGetResources failed: %s\n",
 			strerror(errno));
@@ -553,7 +567,7 @@ static struct resources *get_resources(int fd)
 		int i;								\
 		for (i = 0; i < (int)(_res)->__res->count_##type##s; ++i) {	\
 			(_res)->type##s[i].type =				\
-				drmModeGet##Type(fd, (_res)->__res->type##s[i]); \
+				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],	\
@@ -573,7 +587,7 @@ static struct resources *get_resources(int fd)
 			struct type *obj = &res->type##s[i];			\
 			unsigned int j;						\
 			obj->props =						\
-				drmModeObjectGetProperties(fd, obj->type->type##_id, \
+				drmModeObjectGetProperties(dev->fd, obj->type->type##_id, \
 							   DRM_MODE_OBJECT_##Type); \
 			if (!obj->props) {					\
 				fprintf(stderr,					\
@@ -588,14 +602,17 @@ static struct resources *get_resources(int fd)
 				continue;					\
 			for (j = 0; j < obj->props->count_props; ++j)		\
 				obj->props_info[j] =				\
-					drmModeGetProperty(fd, obj->props->props[j]); \
+					drmModeGetProperty(dev->fd, obj->props->props[j]); \
 		}								\
 	} while (0)
 
 	get_properties(res, res, crtc, CRTC);
 	get_properties(res, res, connector, CONNECTOR);
 
-	res->plane_res = drmModeGetPlaneResources(fd);
+	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));
@@ -618,8 +635,49 @@ error:
 	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_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;
+}
+
 /* -----------------------------------------------------------------------------
- * Connectors and planes
+ * Pipes and planes
  */
 
 /*
@@ -629,15 +687,15 @@ error:
  * Then you need to find the encoder attached to that connector so you
  * can bind it with a free crtc.
  */
-struct connector_arg {
-	uint32_t id;
+struct pipe_arg {
+	uint32_t *con_ids;
+	unsigned int num_cons;
+	uint32_t crtc_id;
 	char mode_str[64];
 	char format_str[5];
 	unsigned int fourcc;
 	drmModeModeInfo *mode;
-	drmModeEncoder *encoder;
-	int crtc;
-	int pipe;
+	struct crtc *crtc;
 	unsigned int fb_id[2], current_fb_id;
 	struct timeval start;
 
@@ -645,7 +703,7 @@ struct connector_arg {
 };
 
 struct plane_arg {
-	uint32_t con_id;  /* the id of connector to bind to */
+	uint32_t crtc_id;  /* the id of CRTC to bind to */
 	bool has_position;
 	int32_t x, y;
 	uint32_t w, h;
@@ -654,62 +712,116 @@ struct plane_arg {
 	unsigned int fourcc;
 };
 
-static void
-connector_find_mode(struct connector_arg *c)
+static drmModeModeInfo *
+connector_find_mode(struct device *dev, uint32_t con_id, const char *mode_str)
 {
 	drmModeConnector *connector;
-	int i, j;
+	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))
+			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;
 
-	/* First, find the connector & mode */
-	c->mode = NULL;
-	for (i = 0; i < resources->res->count_connectors; i++) {
-		connector = resources->connectors[i].connector;
+		connector = get_connector_by_id(dev, pipe->con_ids[i]);
 		if (!connector)
-			continue;
+			return NULL;
 
-		if (!connector->count_modes)
-			continue;
+		for (j = 0; j < connector->count_encoders; ++j) {
+			encoder = get_encoder_by_id(dev, connector->encoders[j]);
+			if (!encoder)
+				continue;
 
-		if (connector->connector_id != c->id)
-			continue;
+			crtcs_for_connector |= encoder->possible_crtcs;
 
-		for (j = 0; j < connector->count_modes; j++) {
-			c->mode = &connector->modes[j];
-			if (!strcmp(c->mode->name, c->mode_str))
-				break;
+			idx = get_crtc_index(dev, encoder->crtc_id);
+			if (idx >= 0)
+				active_crtcs |= 1 << idx;
 		}
 
-		/* Found it, break out */
-		if (c->mode)
-			break;
+		possible_crtcs &= crtcs_for_connector;
 	}
 
-	if (!c->mode) {
-		fprintf(stderr, "failed to find mode \"%s\"\n", c->mode_str);
-		return;
-	}
+	if (!possible_crtcs)
+		return NULL;
 
-	/* Now get the encoder */
-	for (i = 0; i < resources->res->count_encoders; i++) {
-		c->encoder = resources->encoders[i].encoder;
-		if (!c->encoder)
-			continue;
+	/* Return the first possible and active CRTC if one exists, or the first
+	 * possible CRTC otherwise.
+	 */
+	if (possible_crtcs & active_crtcs)
+		crtc_idx = ffs(possible_crtcs & active_crtcs);
+	else
+		crtc_idx = ffs(possible_crtcs);
 
-		if (c->encoder->encoder_id  == connector->encoder_id)
-			break;
+	return &dev->resources->crtcs[crtc_idx - 1];
+}
+
+static int pipe_find_crtc_and_mode(struct device *dev, struct pipe_arg *pipe)
+{
+	drmModeModeInfo *mode = NULL;
+	int i;
+
+	pipe->mode = NULL;
+
+	for (i = 0; i < (int)pipe->num_cons; i++) {
+		mode = connector_find_mode(dev, pipe->con_ids[i],
+					   pipe->mode_str);
+		if (mode == NULL) {
+			fprintf(stderr,
+				"failed to find mode \"%s\" for connector %u\n",
+				pipe->mode_str, pipe->con_ids[i]);
+			return -EINVAL;
+		}
 	}
 
-	if (c->crtc == -1)
-		c->crtc = c->encoder->crtc_id;
+	/* If the CRTC ID was specified, get the corresponding CRTC. Otherwise
+	 * locate a CRTC that can be attached to all the connectors.
+	 */
+	if (pipe->crtc_id != (uint32_t)-1) {
+		for (i = 0; i < dev->resources->res->count_crtcs; i++) {
+			struct crtc *crtc = &dev->resources->crtcs[i];
 
-	/* and figure out which crtc index it is: */
-	for (i = 0; i < resources->res->count_crtcs; i++) {
-		if (c->crtc == (int)resources->res->crtcs[i]) {
-			c->pipe = i;
-			break;
+			if (pipe->crtc_id == crtc->crtc->crtc_id) {
+				pipe->crtc = crtc;
+				break;
+			}
 		}
+	} else {
+		pipe->crtc = pipe_find_crtc(dev, pipe);
 	}
 
+	if (!pipe->crtc) {
+		fprintf(stderr, "failed to find CRTC for pipe\n");
+		return -EINVAL;
+	}
+
+	pipe->mode = mode;
+	pipe->crtc->mode = mode;
+
+	return 0;
 }
 
 /* -----------------------------------------------------------------------------
@@ -724,10 +836,10 @@ struct property_arg {
 	uint64_t value;
 };
 
-static void set_property(struct property_arg *p)
+static void set_property(struct device *dev, struct property_arg *p)
 {
-	drmModeObjectProperties *props;
-	drmModePropertyRes **props_info;
+	drmModeObjectProperties *props = NULL;
+	drmModePropertyRes **props_info = NULL;
 	const char *obj_type;
 	int ret;
 	int i;
@@ -748,11 +860,11 @@ static void set_property(struct property_arg *p)
 		}								\
 	} while(0)								\
 
-	find_object(resources, res, crtc, CRTC);
+	find_object(dev->resources, res, crtc, CRTC);
 	if (p->obj_type == 0)
-		find_object(resources, res, connector, CONNECTOR);
+		find_object(dev->resources, res, connector, CONNECTOR);
 	if (p->obj_type == 0)
-		find_object(resources, plane_res, plane, PLANE);
+		find_object(dev->resources, plane_res, plane, PLANE);
 	if (p->obj_type == 0) {
 		fprintf(stderr, "Object %i not found, can't set property\n",
 			p->obj_id);
@@ -780,7 +892,8 @@ static void set_property(struct property_arg *p)
 
 	p->prop_id = props->props[i];
 
-	ret = drmModeObjectSetProperty(fd, p->obj_id, p->obj_type, p->prop_id, p->value);
+	ret = drmModeObjectSetProperty(dev->fd, p->obj_id, p->obj_type,
+				       p->prop_id, p->value);
 	if (ret < 0)
 		fprintf(stderr, "failed to set %s %i property %s to %" PRIu64 ": %s\n",
 			obj_type, p->obj_id, p->name, p->value, strerror(errno));
@@ -792,33 +905,32 @@ static void
 page_flip_handler(int fd, unsigned int frame,
 		  unsigned int sec, unsigned int usec, void *data)
 {
-	struct connector_arg *c;
+	struct pipe_arg *pipe;
 	unsigned int new_fb_id;
 	struct timeval end;
 	double t;
 
-	c = data;
-	if (c->current_fb_id == c->fb_id[0])
-		new_fb_id = c->fb_id[1];
+	pipe = data;
+	if (pipe->current_fb_id == pipe->fb_id[0])
+		new_fb_id = pipe->fb_id[1];
 	else
-		new_fb_id = c->fb_id[0];
+		new_fb_id = pipe->fb_id[0];
 
-	drmModePageFlip(fd, c->crtc, new_fb_id,
-			DRM_MODE_PAGE_FLIP_EVENT, c);
-	c->current_fb_id = new_fb_id;
-	c->swap_count++;
-	if (c->swap_count == 60) {
+	drmModePageFlip(fd, pipe->crtc->crtc->crtc_id, new_fb_id,
+			DRM_MODE_PAGE_FLIP_EVENT, pipe);
+	pipe->current_fb_id = new_fb_id;
+	pipe->swap_count++;
+	if (pipe->swap_count == 60) {
 		gettimeofday(&end, NULL);
 		t = end.tv_sec + end.tv_usec * 1e-6 -
-			(c->start.tv_sec + c->start.tv_usec * 1e-6);
-		fprintf(stderr, "freq: %.02fHz\n", c->swap_count / t);
-		c->swap_count = 0;
-		c->start = end;
+			(pipe->start.tv_sec + pipe->start.tv_usec * 1e-6);
+		fprintf(stderr, "freq: %.02fHz\n", pipe->swap_count / t);
+		pipe->swap_count = 0;
+		pipe->start = end;
 	}
 }
 
-static int
-set_plane(struct kms_driver *kms, struct connector_arg *c, struct plane_arg *p)
+static int set_plane(struct device *dev, struct plane_arg *p)
 {
 	drmModePlane *ovr;
 	uint32_t handles[4], pitches[4], offsets[4] = {0}; /* we only use [0] */
@@ -826,33 +938,51 @@ set_plane(struct kms_driver *kms, struct connector_arg *c, struct plane_arg *p)
 	struct kms_bo *plane_bo;
 	uint32_t plane_flags = 0;
 	int crtc_x, crtc_y, crtc_w, crtc_h;
+	struct crtc *crtc = NULL;
+	unsigned int pipe;
 	unsigned int i;
 
-	/* find an unused plane which can be connected to our crtc */
-	for (i = 0; i < resources->plane_res->count_planes && !plane_id; i++) {
-		ovr = resources->planes[i].plane;
+	/* Find an unused plane which can be connected to our CRTC. Find the
+	 * CRTC index first, then iterate over available planes.
+	 */
+	for (i = 0; i < (unsigned int)dev->resources->res->count_crtcs; i++) {
+		if (p->crtc_id == dev->resources->res->crtcs[i]) {
+			crtc = &dev->resources->crtcs[i];
+			pipe = i;
+			break;
+		}
+	}
+
+	if (!crtc) {
+		fprintf(stderr, "CRTC %u not found\n", p->crtc_id);
+		return -1;
+	}
+
+	for (i = 0; i < dev->resources->plane_res->count_planes && !plane_id; i++) {
+		ovr = dev->resources->planes[i].plane;
 		if (!ovr)
 			continue;
 
-		if ((ovr->possible_crtcs & (1 << c->pipe)) && !ovr->crtc_id)
+		if ((ovr->possible_crtcs & (1 << pipe)) && !ovr->crtc_id)
 			plane_id = ovr->plane_id;
 	}
 
 	if (!plane_id) {
-		fprintf(stderr, "no unused plane available for CRTC %u\n", c->crtc);
+		fprintf(stderr, "no unused plane available for CRTC %u\n",
+			crtc->crtc->crtc_id);
 		return -1;
 	}
 
 	fprintf(stderr, "testing %dx%d@%s overlay plane %u\n",
 		p->w, p->h, p->format_str, plane_id);
 
-	plane_bo = create_test_buffer(kms, p->fourcc, p->w, p->h, handles,
+	plane_bo = create_test_buffer(dev->kms, p->fourcc, p->w, p->h, handles,
 				      pitches, offsets, PATTERN_TILES);
 	if (plane_bo == NULL)
 		return -1;
 
 	/* just use single plane format for now.. */
-	if (drmModeAddFB2(fd, p->w, p->h, p->fourcc,
+	if (drmModeAddFB2(dev->fd, p->w, p->h, p->fourcc,
 			handles, pitches, offsets, &p->fb_id, plane_flags)) {
 		fprintf(stderr, "failed to add fb: %s\n", strerror(errno));
 		return -1;
@@ -860,8 +990,8 @@ set_plane(struct kms_driver *kms, struct connector_arg *c, struct plane_arg *p)
 
 	if (!p->has_position) {
 		/* Default to the middle of the screen */
-		crtc_x = (c->mode->hdisplay - p->w) / 2;
-		crtc_y = (c->mode->vdisplay - p->h) / 2;
+		crtc_x = (crtc->mode->hdisplay - p->w) / 2;
+		crtc_y = (crtc->mode->vdisplay - p->h) / 2;
 	} else {
 		crtc_x = p->x;
 		crtc_y = p->y;
@@ -870,7 +1000,7 @@ set_plane(struct kms_driver *kms, struct connector_arg *c, struct plane_arg *p)
 	crtc_h = p->h;
 
 	/* note src coords (last 4 args) are in Q16 format */
-	if (drmModeSetPlane(fd, plane_id, c->crtc, p->fb_id,
+	if (drmModeSetPlane(dev->fd, plane_id, crtc->crtc->crtc_id, p->fb_id,
 			    plane_flags, crtc_x, crtc_y, crtc_w, crtc_h,
 			    0, 0, p->w << 16, p->h << 16)) {
 		fprintf(stderr, "failed to enable plane: %s\n",
@@ -878,90 +1008,108 @@ set_plane(struct kms_driver *kms, struct connector_arg *c, struct plane_arg *p)
 		return -1;
 	}
 
-	ovr->crtc_id = c->crtc;
+	ovr->crtc_id = crtc->crtc->crtc_id;
 
 	return 0;
 }
 
-static void
-set_mode(struct connector_arg *c, int count, struct plane_arg *p, int plane_count,
-		int page_flip)
+static void set_mode(struct device *dev, struct pipe_arg *pipes, unsigned int count)
 {
-	struct kms_driver *kms;
-	struct kms_bo *bo, *other_bo;
-	unsigned int fb_id, other_fb_id;
-	int i, j, ret, width, height, x;
 	uint32_t handles[4], pitches[4], offsets[4] = {0}; /* we only use [0] */
-	drmEventContext evctx;
+	unsigned int fb_id;
+	struct kms_bo *bo;
+	unsigned int i;
+	unsigned int j;
+	int ret, x;
+
+	dev->mode.width = 0;
+	dev->mode.height = 0;
 
-	width = 0;
-	height = 0;
 	for (i = 0; i < count; i++) {
-		connector_find_mode(&c[i]);
-		if (c[i].mode == NULL)
+		struct pipe_arg *pipe = &pipes[i];
+
+		ret = pipe_find_crtc_and_mode(dev, pipe);
+		if (ret < 0)
 			continue;
-		width += c[i].mode->hdisplay;
-		if (height < c[i].mode->vdisplay)
-			height = c[i].mode->vdisplay;
-	}
 
-	ret = kms_create(fd, &kms);
-	if (ret) {
-		fprintf(stderr, "failed to create kms driver: %s\n",
-			strerror(-ret));
-		return;
+		dev->mode.width += pipe->mode->hdisplay;
+		if (dev->mode.height < pipe->mode->vdisplay)
+			dev->mode.height = pipe->mode->vdisplay;
 	}
 
-	bo = create_test_buffer(kms, c->fourcc, width, height, handles,
-				pitches, offsets, PATTERN_SMPTE);
+	bo = create_test_buffer(dev->kms, pipes[0].fourcc,
+				dev->mode.width, dev->mode.height,
+				handles, pitches, offsets, PATTERN_SMPTE);
 	if (bo == NULL)
 		return;
 
-	ret = drmModeAddFB2(fd, width, height, c->fourcc,
-			    handles, pitches, offsets, &fb_id, 0);
+	ret = drmModeAddFB2(dev->fd, dev->mode.width, dev->mode.height,
+			    pipes[0].fourcc, handles, pitches, offsets, &fb_id, 0);
 	if (ret) {
 		fprintf(stderr, "failed to add fb (%ux%u): %s\n",
-			width, height, strerror(errno));
+			dev->mode.width, dev->mode.height, strerror(errno));
 		return;
 	}
 
 	x = 0;
 	for (i = 0; i < count; i++) {
-		if (c[i].mode == NULL)
+		struct pipe_arg *pipe = &pipes[i];
+
+		if (pipe->mode == NULL)
 			continue;
 
-		printf("setting mode %s@%s on connector %d, crtc %d\n",
-		       c[i].mode_str, c[i].format_str, c[i].id, c[i].crtc);
+		printf("setting mode %s@%s on connectors ",
+		       pipe->mode_str, pipe->format_str);
+		for (j = 0; j < pipe->num_cons; ++j)
+			printf("%u, ", pipe->con_ids[j]);
+		printf("crtc %d\n", pipe->crtc->crtc->crtc_id);
 
-		ret = drmModeSetCrtc(fd, c[i].crtc, fb_id, x, 0,
-				     &c[i].id, 1, c[i].mode);
+		ret = drmModeSetCrtc(dev->fd, pipe->crtc->crtc->crtc_id, fb_id,
+				     x, 0, pipe->con_ids, pipe->num_cons,
+				     pipe->mode);
 
 		/* XXX: Actually check if this is needed */
-		drmModeDirtyFB(fd, fb_id, NULL, 0);
+		drmModeDirtyFB(dev->fd, fb_id, NULL, 0);
 
-		x += c[i].mode->hdisplay;
+		x += pipe->mode->hdisplay;
 
 		if (ret) {
 			fprintf(stderr, "failed to set mode: %s\n", strerror(errno));
 			return;
 		}
-
-		/* if we have a plane/overlay to show, set that up now: */
-		for (j = 0; j < plane_count; j++)
-			if (p[j].con_id == c[i].id)
-				if (set_plane(kms, &c[i], &p[j]))
-					return;
 	}
 
-	if (!page_flip)
-		return;
-	
-	other_bo = create_test_buffer(kms, c->fourcc, width, height, handles,
-				      pitches, offsets, PATTERN_PLAIN);
+	dev->mode.bo = bo;
+	dev->mode.fb_id = fb_id;
+}
+
+static void set_planes(struct device *dev, struct plane_arg *p, unsigned int count)
+{
+	unsigned int i;
+
+	/* set up planes/overlays */
+	for (i = 0; i < count; i++)
+		if (set_plane(dev, &p[i]))
+			return;
+}
+
+static void test_page_flip(struct device *dev, struct pipe_arg *pipes, unsigned int count)
+{
+	uint32_t handles[4], pitches[4], offsets[4] = {0}; /* we only use [0] */
+	unsigned int other_fb_id;
+	struct kms_bo *other_bo;
+	drmEventContext evctx;
+	unsigned int i;
+	int ret;
+
+	other_bo = create_test_buffer(dev->kms, pipes[0].fourcc,
+				      dev->mode.width, dev->mode.height,
+				      handles, pitches, offsets, PATTERN_PLAIN);
 	if (other_bo == NULL)
 		return;
 
-	ret = drmModeAddFB2(fd, width, height, c->fourcc, handles, pitches, offsets,
+	ret = drmModeAddFB2(dev->fd, dev->mode.width, dev->mode.height,
+			    pipes[0].fourcc, handles, pitches, offsets,
 			    &other_fb_id, 0);
 	if (ret) {
 		fprintf(stderr, "failed to add fb: %s\n", strerror(errno));
@@ -969,20 +1117,23 @@ set_mode(struct connector_arg *c, int count, struct plane_arg *p, int plane_coun
 	}
 
 	for (i = 0; i < count; i++) {
-		if (c[i].mode == NULL)
+		struct pipe_arg *pipe = &pipes[i];
+
+		if (pipe->mode == NULL)
 			continue;
 
-		ret = drmModePageFlip(fd, c[i].crtc, other_fb_id,
-				      DRM_MODE_PAGE_FLIP_EVENT, &c[i]);
+		ret = drmModePageFlip(dev->fd, pipe->crtc->crtc->crtc_id,
+				      other_fb_id, DRM_MODE_PAGE_FLIP_EVENT,
+				      pipe);
 		if (ret) {
 			fprintf(stderr, "failed to page flip: %s\n", strerror(errno));
 			return;
 		}
-		gettimeofday(&c[i].start, NULL);
-		c[i].swap_count = 0;
-		c[i].fb_id[0] = fb_id;
-		c[i].fb_id[1] = other_fb_id;
-		c[i].current_fb_id = other_fb_id;
+		gettimeofday(&pipe->start, NULL);
+		pipe->swap_count = 0;
+		pipe->fb_id[0] = dev->mode.fb_id;
+		pipe->fb_id[1] = other_fb_id;
+		pipe->current_fb_id = other_fb_id;
 	}
 
 	memset(&evctx, 0, sizeof evctx);
@@ -1013,8 +1164,8 @@ set_mode(struct connector_arg *c, int count, struct plane_arg *p, int plane_coun
 
 		FD_ZERO(&fds);
 		FD_SET(0, &fds);
-		FD_SET(fd, &fds);
-		ret = select(fd + 1, &fds, NULL, NULL, &timeout);
+		FD_SET(dev->fd, &fds);
+		ret = select(dev->fd + 1, &fds, NULL, NULL, &timeout);
 
 		if (ret <= 0) {
 			fprintf(stderr, "select timed out or error (ret %d)\n",
@@ -1025,29 +1176,49 @@ set_mode(struct connector_arg *c, int count, struct plane_arg *p, int plane_coun
 		}
 #endif
 
-		drmHandleEvent(fd, &evctx);
+		drmHandleEvent(dev->fd, &evctx);
 	}
 
-	kms_bo_destroy(&bo);
 	kms_bo_destroy(&other_bo);
-	kms_destroy(&kms);
 }
 
 #define min(a, b)	((a) < (b) ? (a) : (b))
 
-static int parse_connector(struct connector_arg *c, const char *arg)
+static int parse_connector(struct pipe_arg *pipe, const char *arg)
 {
 	unsigned int len;
+	unsigned int i;
 	const char *p;
 	char *endp;
 
-	c->crtc = -1;
-	strcpy(c->format_str, "XR24");
+	pipe->crtc_id = (uint32_t)-1;
+	strcpy(pipe->format_str, "XR24");
+
+	/* Count the number of connectors and allocate them. */
+	pipe->num_cons = 1;
+	for (p = arg; isdigit(*p) || *p == ','; ++p) {
+		if (*p == ',')
+			pipe->num_cons++;
+	}
+
+	pipe->con_ids = malloc(pipe->num_cons * sizeof *pipe->con_ids);
+	if (pipe->con_ids == NULL)
+		return -1;
 
-	c->id = strtoul(arg, &endp, 10);
+	/* Parse the connectors. */
+	for (i = 0, p = arg; i < pipe->num_cons; ++i, p = endp + 1) {
+		pipe->con_ids[i] = strtoul(p, &endp, 10);
+		if (*endp != ',')
+			break;
+	}
+
+	if (i != pipe->num_cons - 1)
+		return -1;
+
+	/* Parse the remaining parameters. */
 	if (*endp == '@') {
 		arg = endp + 1;
-		c->crtc = strtoul(arg, &endp, 10);
+		pipe->crtc_id = strtoul(arg, &endp, 10);
 	}
 	if (*endp != ':')
 		return -1;
@@ -1055,18 +1226,18 @@ static int parse_connector(struct connector_arg *c, const char *arg)
 	arg = endp + 1;
 
 	p = strchrnul(arg, '@');
-	len = min(sizeof c->mode_str - 1, (unsigned int)(p - arg));
-	strncpy(c->mode_str, arg, len);
-	c->mode_str[len] = '\0';
+	len = min(sizeof pipe->mode_str - 1, (unsigned int)(p - arg));
+	strncpy(pipe->mode_str, arg, len);
+	pipe->mode_str[len] = '\0';
 
 	if (*p == '@') {
-		strncpy(c->format_str, p + 1, 4);
-		c->format_str[4] = '\0';
+		strncpy(pipe->format_str, p + 1, 4);
+		pipe->format_str[4] = '\0';
 	}
 
-	c->fourcc = format_fourcc(c->format_str);
-	if (c->fourcc == 0)  {
-		fprintf(stderr, "unknown format %s\n", c->format_str);
+	pipe->fourcc = format_fourcc(pipe->format_str);
+	if (pipe->fourcc == 0)  {
+		fprintf(stderr, "unknown format %s\n", pipe->format_str);
 		return -1;
 	}
 
@@ -1079,7 +1250,7 @@ static int parse_plane(struct plane_arg *plane, const char *p)
 
 	memset(plane, 0, sizeof *plane);
 
-	plane->con_id = strtoul(p, &end, 10);
+	plane->crtc_id = strtoul(p, &end, 10);
 	if (*end != ':')
 		return -EINVAL;
 
@@ -1141,8 +1312,8 @@ static void usage(char *name)
 	fprintf(stderr, "\t-p\tlist CRTCs and planes (pipes)\n");
 
 	fprintf(stderr, "\n Test options:\n\n");
-	fprintf(stderr, "\t-P <connector_id>:<w>x<h>[+<x>+<y>][@<format>]\tset a plane\n");
-	fprintf(stderr, "\t-s <connector_id>[@<crtc_id>]:<mode>[@<format>]\tset a mode\n");
+	fprintf(stderr, "\t-P <crtc_id>:<w>x<h>[+<x>+<y>][@<format>]\tset a plane\n");
+	fprintf(stderr, "\t-s <connector_id>[,<connector_id>][@<crtc_id>]:<mode>[@<format>]\tset a mode\n");
 	fprintf(stderr, "\t-v\ttest vsynced page flipping\n");
 	fprintf(stderr, "\t-w <obj_id>:<prop_name>:<value>\tset property\n");
 
@@ -1154,8 +1325,6 @@ static void usage(char *name)
 	exit(0);
 }
 
-#define dump_resource(res) if (res) dump_##res()
-
 static int page_flipping_supported(void)
 {
 	/*FIXME: generic ioctl needed? */
@@ -1181,20 +1350,25 @@ static char optstr[] = "cdefM:P:ps:vw:";
 
 int main(int argc, char **argv)
 {
+	struct device dev;
+
 	int c;
 	int encoders = 0, connectors = 0, crtcs = 0, planes = 0, framebuffers = 0;
 	int drop_master = 0;
 	int test_vsync = 0;
-	const char *modules[] = { "i915", "radeon", "nouveau", "vmwgfx", "omapdrm", "exynos", "tilcdc" };
+	const char *modules[] = { "i915", "radeon", "nouveau", "vmwgfx", "omapdrm", "exynos", "tilcdc", "msm" };
 	char *module = NULL;
 	unsigned int i;
 	int count = 0, plane_count = 0;
 	unsigned int prop_count = 0;
-	struct connector_arg *con_args = NULL;
+	struct pipe_arg *pipe_args = NULL;
 	struct plane_arg *plane_args = NULL;
 	struct property_arg *prop_args = NULL;
 	unsigned int args = 0;
-	
+	int ret;
+
+	memset(&dev, 0, sizeof dev);
+
 	opterr = 0;
 	while ((c = getopt(argc, argv, optstr)) != -1) {
 		args++;
@@ -1235,14 +1409,14 @@ int main(int argc, char **argv)
 			planes = 1;
 			break;
 		case 's':
-			con_args = realloc(con_args,
-					   (count + 1) * sizeof *con_args);
-			if (con_args == NULL) {
+			pipe_args = realloc(pipe_args,
+					    (count + 1) * sizeof *pipe_args);
+			if (pipe_args == NULL) {
 				fprintf(stderr, "memory allocation failed\n");
 				return 1;
 			}
 
-			if (parse_connector(&con_args[count], optarg) < 0)
+			if (parse_connector(&pipe_args[count], optarg) < 0)
 				usage(argv[0]);
 
 			count++;				      
@@ -1273,16 +1447,16 @@ int main(int argc, char **argv)
 		encoders = connectors = crtcs = planes = framebuffers = 1;
 
 	if (module) {
-		fd = drmOpen(module, NULL);
-		if (fd < 0) {
+		dev.fd = drmOpen(module, NULL);
+		if (dev.fd < 0) {
 			fprintf(stderr, "failed to open device '%s'.\n", module);
 			return 1;
 		}
 	} else {
 		for (i = 0; i < ARRAY_SIZE(modules); i++) {
 			printf("trying to open device '%s'...", modules[i]);
-			fd = drmOpen(modules[i], NULL);
-			if (fd < 0) {
+			dev.fd = drmOpen(modules[i], NULL);
+			if (dev.fd < 0) {
 				printf("failed.\n");
 			} else {
 				printf("success.\n");
@@ -1290,7 +1464,7 @@ int main(int argc, char **argv)
 			}
 		}
 
-		if (fd < 0) {
+		if (dev.fd < 0) {
 			fprintf(stderr, "no device found.\n");
 			return 1;
 		}
@@ -1301,29 +1475,55 @@ int main(int argc, char **argv)
 		return -1;
 	}
 
-	resources = get_resources(fd);
-	if (!resources) {
-		drmClose(fd);
+	if (test_vsync && !count) {
+		fprintf(stderr, "page flipping requires at least one -s option.\n");
+		return -1;
+	}
+
+	dev.resources = get_resources(&dev);
+	if (!dev.resources) {
+		drmClose(dev.fd);
 		return 1;
 	}
 
-	dump_resource(encoders);
-	dump_resource(connectors);
-	dump_resource(crtcs);
-	dump_resource(planes);
-	dump_resource(framebuffers);
+#define dump_resource(dev, res) if (res) dump_##res(dev)
+
+	dump_resource(&dev, encoders);
+	dump_resource(&dev, connectors);
+	dump_resource(&dev, crtcs);
+	dump_resource(&dev, planes);
+	dump_resource(&dev, framebuffers);
 
 	for (i = 0; i < prop_count; ++i)
-		set_property(&prop_args[i]);
+		set_property(&dev, &prop_args[i]);
+
+	if (count || plane_count) {
+		ret = kms_create(dev.fd, &dev.kms);
+		if (ret) {
+			fprintf(stderr, "failed to create kms driver: %s\n",
+				strerror(-ret));
+			return 1;
+		}
+
+		if (count)
+			set_mode(&dev, pipe_args, count);
+
+		if (plane_count)
+			set_planes(&dev, plane_args, plane_count);
+
+		if (test_vsync)
+			test_page_flip(&dev, pipe_args, count);
 
-	if (count > 0) {
-		set_mode(con_args, count, plane_args, plane_count, test_vsync);
 		if (drop_master)
-			drmDropMaster(fd);
+			drmDropMaster(dev.fd);
+
+		kms_bo_destroy(&dev.mode.bo);
+		kms_destroy(&dev.kms);
+
 		getchar();
 	}
 
-	free_resources(resources);
+	free_resources(dev.resources);
 
 	return 0;
 }