#include "config.h"
#include <assert.h>
+#include <ctype.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
drmModeCrtc *crtc;
drmModeObjectProperties *props;
drmModePropertyRes **props_info;
+ drmModeModeInfo *mode;
};
struct encoder {
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]))
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;
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;
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);
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);
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;
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]);
}
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;
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 {
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;
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;
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 {
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)
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));
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], \
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, \
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));
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
*/
/*
* 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;
};
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;
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;
}
/* -----------------------------------------------------------------------------
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;
} \
} 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);
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));
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] */
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;
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;
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",
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));
}
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);
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",
}
#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;
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;
}
memset(plane, 0, sizeof *plane);
- plane->con_id = strtoul(p, &end, 10);
+ plane->crtc_id = strtoul(p, &end, 10);
if (*end != ':')
return -EINVAL;
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");
exit(0);
}
-#define dump_resource(res) if (res) dump_##res()
-
static int page_flipping_supported(void)
{
/*FIXME: generic ioctl needed? */
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++;
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++;
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");
}
}
- if (fd < 0) {
+ if (dev.fd < 0) {
fprintf(stderr, "no device found.\n");
return 1;
}
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;
}
projects / platform / upstream / libdrm.git / blobdiff