2018-07-23 18:30 GMT+02:00 Eric Engestrom <eric.engestrom@xxxxxxxxx>:
> On Friday, 2018-07-20 13:33:29 +0200, Benjamin Gaignard wrote:
>> This is a modetest like tool but using atomic API.
>>
>> With modetest_atomic it is mandatory to specify a mode ("-s")
>> and a plane ("-P") to display a pattern on screen.
>>
>> "-v" does a loop swapping between two framebuffers for each
>> active planes.
>>
>> modetest_atomic doesn't offer cursor support
>>
>> Signed-off-by: Benjamin Gaignard <benjamin.gaignard@xxxxxxxxxx>
>> ---
>>
>> The code is based on modetest and keep most of it infrastructure
>> like arguments parsing, finding properties id from their name,
>> resources dumping or the general way of working.
>> It duplicates modetest code but adding compilation flags or
>> conditional tests everywhere in modetest would have made it
>> more complex and unreadable.
>
> I don't have an opinion on whether duplicating the test is the right
> thing, but if you do, please also duplicate the lines in
> tests/modetest/meson.build :)
You are right, I will also make it compile for Android.
>
>>
>> Creating modetest_atomic could allow to test atomic API without
>> need to use "big" frameworks like weston, drm_hwcomposer or igt
>> with all their dependencies.
>> kmscube could also be used to test atomic API but it need EGL.
>>
>> It have been tested (only) on stm driver with one or two planes
>> actived.
>>
>> tests/modetest/Makefile.am | 13 +-
>> tests/modetest/Makefile.sources | 7 +
>> tests/modetest/modetest_atomic.c | 1546 ++++++++++++++++++++++++++++++++++++++
>> 3 files changed, 1564 insertions(+), 2 deletions(-)
>> create mode 100644 tests/modetest/modetest_atomic.c
>>
>> diff --git a/tests/modetest/Makefile.am b/tests/modetest/Makefile.am
>> index 4b296c83..8f697bb3 100644
>> --- a/tests/modetest/Makefile.am
>> +++ b/tests/modetest/Makefile.am
>> @@ -10,10 +10,12 @@ AM_CFLAGS += \
>>
>> if HAVE_INSTALL_TESTS
>> bin_PROGRAMS = \
>> - modetest
>> + modetest \
>> + modetest_atomic
>> else
>> noinst_PROGRAMS = \
>> - modetest
>> + modetest \
>> + modetest_atomic
>> endif
>>
>> modetest_SOURCES = $(MODETEST_FILES)
>> @@ -22,3 +24,10 @@ modetest_LDADD = \
>> $(top_builddir)/libdrm.la \
>> $(top_builddir)/tests/util/libutil.la \
>> $(CAIRO_LIBS)
>> +
>> +modetest_atomic_SOURCES = $(MODETEST_ATOMIC_FILES)
>> +
>> +modetest_atomic_LDADD = \
>> + $(top_builddir)/libdrm.la \
>> + $(top_builddir)/tests/util/libutil.la \
>> + $(CAIRO_LIBS)
>> diff --git a/tests/modetest/Makefile.sources b/tests/modetest/Makefile.sources
>> index 399af0df..0a1df4c0 100644
>> --- a/tests/modetest/Makefile.sources
>> +++ b/tests/modetest/Makefile.sources
>> @@ -4,3 +4,10 @@ MODETEST_FILES := \
>> cursor.c \
>> cursor.h \
>> modetest.c
>> +
>> +MODETEST_ATOMIC_FILES := \
>> + buffers.c \
>> + buffers.h \
>> + cursor.c \
>> + cursor.h \
>> + modetest_atomic.c
>> diff --git a/tests/modetest/modetest_atomic.c b/tests/modetest/modetest_atomic.c
>> new file mode 100644
>> index 00000000..8c877860
>> --- /dev/null
>> +++ b/tests/modetest/modetest_atomic.c
>> @@ -0,0 +1,1546 @@
>> +/*
>> + * DRM based mode setting test program
>> + * Copyright 2008 Tungsten Graphics
>> + * Jakob Bornecrantz <jakob@xxxxxxxxxxxxxxxxxxxx>
>> + * Copyright 2008 Intel Corporation
>> + * Jesse Barnes <jesse.barnes@xxxxxxxxx>
>> + *
>> + * 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.
>> + */
>> +
>> +#ifdef HAVE_CONFIG_H
>> +#include "config.h"
>> +#endif
>> +
>> +#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"
>> +
>> +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;
>> + 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 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);
>> +}
>> +
>> +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;
>> + }
>> +
>> + possible_crtcs &= crtcs_for_connector;
>> + }
>> +
>> + if (!possible_crtcs)
>> + return NULL;
>> +
>> + /* 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);
>> +
>> + 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, pipe->vrefresh);
>> + if (mode == NULL) {
>> + fprintf(stderr,
>> + "failed to find mode \"%s\" for connector %s\n",
>> + pipe->mode_str, pipe->cons[i]);
>> + return -EINVAL;
>> + }
>> + }
>> +
>> + /* 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];
>> +
>> + 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;
>> +}
>> +
>> +/* -----------------------------------------------------------------------------
>> + * Properties
>> + */
>> +
>> +struct property_arg {
>> + uint32_t obj_id;
>> + uint32_t obj_type;
>> + char name[DRM_PROP_NAME_LEN+1];
>> + uint32_t prop_id;
>> + uint64_t value;
>> +};
>> +
>> +static void set_property(struct device *dev, struct property_arg *p)
>> +{
>> + drmModeObjectProperties *props = NULL;
>> + drmModePropertyRes **props_info = NULL;
>> + const char *obj_type;
>> + int ret;
>> + int i;
>> +
>> + p->obj_type = 0;
>> + p->prop_id = 0;
>> +
>> +#define find_object(_res, __res, type, Type) \
>> + do { \
>> + for (i = 0; i < (int)(_res)->__res->count_##type##s; ++i) { \
>> + struct type *obj = &(_res)->type##s[i]; \
>> + if (obj->type->type##_id != p->obj_id) \
>> + continue; \
>> + p->obj_type = DRM_MODE_OBJECT_##Type; \
>> + obj_type = #Type; \
>> + props = obj->props; \
>> + props_info = obj->props_info; \
>> + } \
>> + } while(0) \
>> +
>> + find_object(dev->resources, res, crtc, CRTC);
>> + if (p->obj_type == 0)
>> + find_object(dev->resources, res, connector, CONNECTOR);
>> + if (p->obj_type == 0)
>> + 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);
>> + return;
>> + }
>> +
>> + if (!props) {
>> + fprintf(stderr, "%s %i has no properties\n",
>> + obj_type, p->obj_id);
>> + return;
>> + }
>> +
>> + for (i = 0; i < (int)props->count_props; ++i) {
>> + if (!props_info[i])
>> + continue;
>> + if (strcmp(props_info[i]->name, p->name) == 0)
>> + break;
>> + }
>> +
>> + if (i == (int)props->count_props) {
>> + fprintf(stderr, "%s %i has no %s property\n",
>> + obj_type, p->obj_id, p->name);
>> + return;
>> + }
>> +
>> + p->prop_id = props->props[i];
>> +
>> + ret = drmModeAtomicAddProperty(dev->req, p->obj_id, 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));
>> +}
>> +
>> +/* -------------------------------------------------------------------------- */
>> +
>> +/*static bool format_support(const drmModePlanePtr ovr, uint32_t fmt)
>> +{
>> + unsigned int i;
>> +
>> + for (i = 0; i < ovr->count_formats; ++i) {
>> + if (ovr->formats[i] == fmt)
>> + return true;
>> + }
>> +
>> + return false;
>> +}*/
>> +
>> +static void add_property(struct device *dev, uint32_t obj_id,
>> + const char *name, uint64_t value)
>> +{
>> + struct property_arg p;
>> +
>> + p.obj_id = obj_id;
>> + strcpy(p.name, name);
>> + p.value = value;
>> +
>> + set_property(dev, &p);
>> +}
>> +
>> +static int set_plane(struct device *dev, struct plane_arg *p,
>> + int pattern, bool update)
>> +{
>> + uint32_t handles[4] = {0}, pitches[4] = {0}, offsets[4] = {0};
>> + struct bo *plane_bo;
>> + int crtc_x, crtc_y, crtc_w, crtc_h;
>> + struct crtc *crtc = NULL;
>> + unsigned int i;
>> + unsigned int old_fb_id;
>> +
>> + /* 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];
>> + break;
>> + }
>> + }
>> +
>> + if (!crtc) {
>> + fprintf(stderr, "CRTC %u not found\n", p->crtc_id);
>> + return -1;
>> + }
>> +
>> + if (!update)
>> + fprintf(stderr, "testing %dx%d@%s on plane %u, crtc %u\n",
>> + p->w, p->h, p->format_str, p->plane_id, p->crtc_id);
>> +
>> + plane_bo = p->old_bo;
>> + p->old_bo = p->bo;
>> +
>> + if (!plane_bo) {
>> + plane_bo = bo_create(dev->fd, p->fourcc, p->w, p->h,
>> + handles, pitches, offsets, pattern);
>> +
>> + if (plane_bo == NULL)
>> + return -1;
>> +
>> + if (drmModeAddFB2(dev->fd, p->w, p->h, p->fourcc,
>> + handles, pitches, offsets, &p->fb_id, 0)) {
>> + fprintf(stderr, "failed to add fb: %s\n", strerror(errno));
>> + return -1;
>> + }
>> + }
>> +
>> + p->bo = plane_bo;
>> +
>> + old_fb_id = p->fb_id;
>> + p->old_fb_id = old_fb_id;
>> +
>> + crtc_w = p->w * p->scale;
>> + crtc_h = p->h * p->scale;
>> + if (!p->has_position) {
>> + /* Default to the middle of the screen */
>> + crtc_x = (crtc->mode->hdisplay - crtc_w) / 2;
>> + crtc_y = (crtc->mode->vdisplay - crtc_h) / 2;
>> + } else {
>> + crtc_x = p->x;
>> + crtc_y = p->y;
>> + }
>> +
>> + add_property(dev, p->plane_id, "FB_ID", p->fb_id);
>> + add_property(dev, p->plane_id, "CRTC_ID", p->crtc_id);
>> + add_property(dev, p->plane_id, "SRC_X", 0);
>> + add_property(dev, p->plane_id, "SRC_Y", 0);
>> + add_property(dev, p->plane_id, "SRC_W", p->w << 16);
>> + add_property(dev, p->plane_id, "SRC_H", p->h << 16);
>> + add_property(dev, p->plane_id, "CRTC_X", crtc_x);
>> + add_property(dev, p->plane_id, "CRTC_Y", crtc_y);
>> + add_property(dev, p->plane_id, "CRTC_W", crtc_w);
>> + add_property(dev, p->plane_id, "CRTC_H", crtc_h);
>> +
>> + return 0;
>> +}
>> +
>> +static void set_planes(struct device *dev, struct plane_arg *p,
>> + unsigned int count, bool update)
>> +{
>> + unsigned int i, pattern = UTIL_PATTERN_SMPTE;
>> +
>> + /* set up planes */
>> + for (i = 0; i < count; i++) {
>> + if (i > 0)
>> + pattern = UTIL_PATTERN_TILES;
>> +
>> + if (set_plane(dev, &p[i], pattern, update))
>> + return;
>> + }
>> +}
>> +
>> +static void clear_planes(struct device *dev, struct plane_arg *p, unsigned int count)
>> +{
>> + unsigned int i;
>> +
>> + for (i = 0; i < count; i++) {
>> + add_property(dev, p[i].plane_id, "FB_ID", 0);
>> + add_property(dev, p[i].plane_id, "CRTC_ID", 0);
>> + add_property(dev, p[i].plane_id, "SRC_X", 0);
>> + add_property(dev, p[i].plane_id, "SRC_Y", 0);
>> + add_property(dev, p[i].plane_id, "SRC_W", 0);
>> + add_property(dev, p[i].plane_id, "SRC_H", 0);
>> + add_property(dev, p[i].plane_id, "CRTC_X", 0);
>> + add_property(dev, p[i].plane_id, "CRTC_Y", 0);
>> + add_property(dev, p[i].plane_id, "CRTC_W", 0);
>> + add_property(dev, p[i].plane_id, "CRTC_H", 0);
>> + }
>> +}
>> +
>> +static void clear_FB(struct device *dev, struct plane_arg *p, unsigned int count)
>> +{
>> + unsigned int i;
>> +
>> + for (i = 0; i < count; i++) {
>> + if (p[i].fb_id) {
>> + drmModeRmFB(dev->fd, p[i].fb_id);
>> + p[i].fb_id = 0;
>> + }
>> + if (p[i].old_fb_id) {
>> + drmModeRmFB(dev->fd, p[i].old_fb_id);
>> + p[i].old_fb_id = 0;
>> + }
>> + if (p[i].bo) {
>> + bo_destroy(p[i].bo);
>> + p[i].bo = NULL;
>> + }
>> + if (p[i].old_bo) {
>> + bo_destroy(p[i].old_bo);
>> + p[i].old_bo = NULL;
>> + }
>> +
>> + }
>> +}
>> +
>> +static void set_mode(struct device *dev, struct pipe_arg *pipes, unsigned int count)
>> +{
>> + unsigned int i;
>> + unsigned int j;
>> + int ret;
>> +
>> + for (i = 0; i < count; i++) {
>> + struct pipe_arg *pipe = &pipes[i];
>> +
>> + ret = pipe_find_crtc_and_mode(dev, pipe);
>> + if (ret < 0)
>> + continue;
>> + }
>> +
>> + for (i = 0; i < count; i++) {
>> + struct pipe_arg *pipe = &pipes[i];
>> + uint32_t blob_id;
>> +
>> + if (pipe->mode == NULL)
>> + continue;
>> +
>> + printf("setting mode %s-%dHz@%s on connectors ",
>> + pipe->mode_str, pipe->mode->vrefresh, pipe->format_str);
>> + for (j = 0; j < pipe->num_cons; ++j) {
>> + printf("%s, ", pipe->cons[j]);
>> + add_property(dev, pipe->con_ids[j], "CRTC_ID", pipe->crtc->crtc->crtc_id);
>> + }
>> + printf("crtc %d\n", pipe->crtc->crtc->crtc_id);
>> +
>> + drmModeCreatePropertyBlob(dev->fd, pipe->mode, sizeof(*pipe->mode), &blob_id);
>> + add_property(dev, pipe->crtc->crtc->crtc_id, "MODE_ID", blob_id);
>> + add_property(dev, pipe->crtc->crtc->crtc_id, "ACTIVE", 1);
>> + }
>> +}
>> +
>> +static void clear_mode(struct device *dev, struct pipe_arg *pipes, unsigned int count)
>> +{
>> + unsigned int i;
>> + unsigned int j;
>> +
>> + for (i = 0; i < count; i++) {
>> + struct pipe_arg *pipe = &pipes[i];
>> +
>> + if (pipe->mode == NULL)
>> + continue;
>> +
>> + for (j = 0; j < pipe->num_cons; ++j)
>> + add_property(dev, pipe->con_ids[j], "CRTC_ID",0);
>> +
>> + add_property(dev, pipe->crtc->crtc->crtc_id, "MODE_ID", 0);
>> + add_property(dev, pipe->crtc->crtc->crtc_id, "ACTIVE", 0);
>> + }
>> +
>> +}
>> +
>> +#define min(a, b) ((a) < (b) ? (a) : (b))
>> +
>> +static int parse_connector(struct pipe_arg *pipe, const char *arg)
>> +{
>> + unsigned int len;
>> + unsigned int i;
>> + const char *p;
>> + char *endp;
>> +
>> + pipe->vrefresh = 0;
>> + 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; *p && *p != ':' && *p != '@'; ++p) {
>> + if (*p == ',')
>> + pipe->num_cons++;
>> + }
>> +
>> + pipe->con_ids = calloc(pipe->num_cons, sizeof(*pipe->con_ids));
>> + pipe->cons = calloc(pipe->num_cons, sizeof(*pipe->cons));
>> + if (pipe->con_ids == NULL || pipe->cons == NULL)
>> + return -1;
>> +
>> + /* Parse the connectors. */
>> + for (i = 0, p = arg; i < pipe->num_cons; ++i, p = endp + 1) {
>> + endp = strpbrk(p, ",@:");
>> + if (!endp)
>> + break;
>> +
>> + pipe->cons[i] = strndup(p, endp - p);
>> +
>> + if (*endp != ',')
>> + break;
>> + }
>> +
>> + if (i != pipe->num_cons - 1)
>> + return -1;
>> +
>> + /* Parse the remaining parameters. */
>> + if (*endp == '@') {
>> + arg = endp + 1;
>> + pipe->crtc_id = strtoul(arg, &endp, 10);
>> + }
>> + if (*endp != ':')
>> + return -1;
>> +
>> + arg = endp + 1;
>> +
>> + /* Search for the vertical refresh or the format. */
>> + p = strpbrk(arg, "-@");
>> + if (p == NULL)
>> + p = arg + strlen(arg);
>> + len = min(sizeof pipe->mode_str - 1, (unsigned int)(p - arg));
>> + strncpy(pipe->mode_str, arg, len);
>> + pipe->mode_str[len] = '\0';
>> +
>> + if (*p == '-') {
>> + pipe->vrefresh = strtoul(p + 1, &endp, 10);
>> + p = endp;
>> + }
>> +
>> + if (*p == '@') {
>> + strncpy(pipe->format_str, p + 1, 4);
>> + pipe->format_str[4] = '\0';
>> + }
>> +
>> + pipe->fourcc = util_format_fourcc(pipe->format_str);
>> + if (pipe->fourcc == 0) {
>> + fprintf(stderr, "unknown format %s\n", pipe->format_str);
>> + return -1;
>> + }
>> +
>> + return 0;
>> +}
>> +
>> +static int parse_plane(struct plane_arg *plane, const char *p)
>> +{
>> + char *end;
>> +
>> + plane->plane_id = strtoul(p, &end, 10);
>> + if (*end != '@')
>> + return -EINVAL;
>> +
>> + p = end + 1;
>> + plane->crtc_id = strtoul(p, &end, 10);
>> + if (*end != ':')
>> + return -EINVAL;
>> +
>> + p = end + 1;
>> + plane->w = strtoul(p, &end, 10);
>> + if (*end != 'x')
>> + return -EINVAL;
>> +
>> + p = end + 1;
>> + plane->h = strtoul(p, &end, 10);
>> +
>> + if (*end == '+' || *end == '-') {
>> + plane->x = strtol(end, &end, 10);
>> + if (*end != '+' && *end != '-')
>> + return -EINVAL;
>> + plane->y = strtol(end, &end, 10);
>> +
>> + plane->has_position = true;
>> + }
>> +
>> + if (*end == '*') {
>> + p = end + 1;
>> + plane->scale = strtod(p, &end);
>> + if (plane->scale <= 0.0)
>> + return -EINVAL;
>> + } else {
>> + plane->scale = 1.0;
>> + }
>> +
>> + if (*end == '@') {
>> + p = end + 1;
>> + if (strlen(p) != 4)
>> + return -EINVAL;
>> +
>> + strcpy(plane->format_str, p);
>> + } else {
>> + strcpy(plane->format_str, "XR24");
>> + }
>> +
>> + plane->fourcc = util_format_fourcc(plane->format_str);
>> + if (plane->fourcc == 0) {
>> + fprintf(stderr, "unknown format %s\n", plane->format_str);
>> + return -EINVAL;
>> + }
>> +
>> + return 0;
>> +}
>> +
>> +static int parse_property(struct property_arg *p, const char *arg)
>> +{
>> + if (sscanf(arg, "%d:%32[^:]:%" SCNu64, &p->obj_id, p->name, &p->value) != 3)
>> + return -1;
>> +
>> + p->obj_type = 0;
>> + p->name[DRM_PROP_NAME_LEN] = '\0';
>> +
>> + return 0;
>> +}
>> +
>> +static void usage(char *name)
>> +{
>> + fprintf(stderr, "usage: %s [-cDdefMPpsCvw]\n", name);
>> +
>> + fprintf(stderr, "\n Query options:\n\n");
>> + fprintf(stderr, "\t-c\tlist connectors\n");
>> + fprintf(stderr, "\t-e\tlist encoders\n");
>> + fprintf(stderr, "\t-f\tlist framebuffers\n");
>> + fprintf(stderr, "\t-p\tlist CRTCs and planes (pipes)\n");
>> +
>> + fprintf(stderr, "\n Test options:\n\n");
>> + fprintf(stderr, "\t-P <plane_id>@<crtc_id>:<w>x<h>[+<x>+<y>][*<scale>][@<format>]\tset a plane\n");
>> + fprintf(stderr, "\t-s <connector_id>[,<connector_id>][@<crtc_id>]:<mode>[-<vrefresh>][@<format>]\tset a mode\n");
>> + fprintf(stderr, "\t-v\ttest loop\n");
>> + fprintf(stderr, "\t-w <obj_id>:<prop_name>:<value>\tset property\n");
>> +
>> + fprintf(stderr, "\n Generic options:\n\n");
>> + fprintf(stderr, "\t-d\tdrop master after mode set\n");
>> + fprintf(stderr, "\t-M module\tuse the given driver\n");
>> + fprintf(stderr, "\t-D device\tuse the given device\n");
>> +
>> + fprintf(stderr, "\n\tDefault is to dump all info.\n");
>> + exit(0);
>> +}
>> +
>> +static int pipe_resolve_connectors(struct device *dev, struct pipe_arg *pipe)
>> +{
>> + drmModeConnector *connector;
>> + unsigned int i;
>> + uint32_t id;
>> + char *endp;
>> +
>> + for (i = 0; i < pipe->num_cons; i++) {
>> + id = strtoul(pipe->cons[i], &endp, 10);
>> + if (endp == pipe->cons[i]) {
>> + connector = get_connector_by_name(dev, pipe->cons[i]);
>> + if (!connector) {
>> + fprintf(stderr, "no connector named '%s'\n",
>> + pipe->cons[i]);
>> + return -ENODEV;
>> + }
>> +
>> + id = connector->connector_id;
>> + }
>> +
>> + pipe->con_ids[i] = id;
>> + }
>> +
>> + return 0;
>> +}
>> +
>> +static char optstr[] = "cdD:efM: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_loop = 0;
>> + char *device = NULL;
>> + char *module = NULL;
>> + unsigned int i;
>> + unsigned int count = 0, plane_count = 0;
>> + unsigned int prop_count = 0;
>> + 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++;
>> +
>> + switch (c) {
>> + case 'c':
>> + connectors = 1;
>> + break;
>> + case 'D':
>> + device = optarg;
>> + args--;
>> + break;
>> + case 'd':
>> + drop_master = 1;
>> + break;
>> + case 'e':
>> + encoders = 1;
>> + break;
>> + case 'f':
>> + framebuffers = 1;
>> + break;
>> + case 'M':
>> + module = optarg;
>> + /* Preserve the default behaviour of dumping all information. */
>> + args--;
>> + break;
>> + case 'P':
>> + plane_args = realloc(plane_args,
>> + (plane_count + 1) * sizeof *plane_args);
>> + if (plane_args == NULL) {
>> + fprintf(stderr, "memory allocation failed\n");
>> + return 1;
>> + }
>> + memset(&plane_args[plane_count], 0, sizeof(*plane_args));
>> +
>> + if (parse_plane(&plane_args[plane_count], optarg) < 0)
>> + usage(argv[0]);
>> +
>> + plane_count++;
>> + break;
>> + case 'p':
>> + crtcs = 1;
>> + planes = 1;
>> + break;
>> + case 's':
>> + pipe_args = realloc(pipe_args,
>> + (count + 1) * sizeof *pipe_args);
>> + if (pipe_args == NULL) {
>> + fprintf(stderr, "memory allocation failed\n");
>> + return 1;
>> + }
>> + memset(&pipe_args[count], 0, sizeof(*pipe_args));
>> +
>> + if (parse_connector(&pipe_args[count], optarg) < 0)
>> + usage(argv[0]);
>> +
>> + count++;
>> + break;
>> + case 'v':
>> + test_loop = 1;
>> + break;
>> + case 'w':
>> + prop_args = realloc(prop_args,
>> + (prop_count + 1) * sizeof *prop_args);
>> + if (prop_args == NULL) {
>> + fprintf(stderr, "memory allocation failed\n");
>> + return 1;
>> + }
>> + memset(&prop_args[prop_count], 0, sizeof(*prop_args));
>> +
>> + if (parse_property(&prop_args[prop_count], optarg) < 0)
>> + usage(argv[0]);
>> +
>> + prop_count++;
>> + break;
>> + default:
>> + usage(argv[0]);
>> + break;
>> + }
>> + }
>> +
>> + if (!args)
>> + encoders = connectors = crtcs = planes = framebuffers = 1;
>> +
>> + dev.fd = util_open(device, module);
>> + if (dev.fd < 0)
>> + return -1;
>> +
>> + ret = drmSetClientCap(dev.fd, DRM_CLIENT_CAP_ATOMIC, 1);
>> + if (ret) {
>> + fprintf(stderr, "no atomic modesetting support: %s\n", strerror(errno));
>> + drmClose(dev.fd);
>> + return -1;
>> + }
>> +
>> + dev.resources = get_resources(&dev);
>> + if (!dev.resources) {
>> + drmClose(dev.fd);
>> + return 1;
>> + }
>> +
>> + for (i = 0; i < count; i++) {
>> + if (pipe_resolve_connectors(&dev, &pipe_args[i]) < 0) {
>> + free_resources(dev.resources);
>> + drmClose(dev.fd);
>> + return 1;
>> + }
>> + }
>> +
>> +#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);
>> +
>> + dev.req = drmModeAtomicAlloc();
>> +
>> + for (i = 0; i < prop_count; ++i)
>> + set_property(&dev, &prop_args[i]);
>> +
>> + if (count && plane_count) {
>> + uint64_t cap = 0;
>> +
>> + ret = drmGetCap(dev.fd, DRM_CAP_DUMB_BUFFER, &cap);
>> + if (ret || cap == 0) {
>> + fprintf(stderr, "driver doesn't support the dumb buffer API\n");
>> + drmModeAtomicFree(dev.req);
>> + return 1;
>> + }
>> +
>> + set_mode(&dev, pipe_args, count);
>> + set_planes(&dev, plane_args, plane_count, false);
>> +
>> + ret = drmModeAtomicCommit(dev.fd, dev.req, DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
>> + if (ret) {
>> + fprintf(stderr, "Atomic Commit failed [1]\n");
>> + return 1;
>> + }
>> +
>> + gettimeofday(&pipe_args->start, NULL);
>> + pipe_args->swap_count = 0;
>> +
>> + while (test_loop) {
>> + drmModeAtomicFree(dev.req);
>> + dev.req = drmModeAtomicAlloc();
>> + set_planes(&dev, plane_args, plane_count, true);
>> +
>> + ret = drmModeAtomicCommit(dev.fd, dev.req, DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
>> + if (ret) {
>> + fprintf(stderr, "Atomic Commit failed [2]\n");
>> + return 1;
>> + }
>> +
>> + pipe_args->swap_count++;
>> + if (pipe_args->swap_count == 60) {
>> + struct timeval end;
>> + double t;
>> +
>> + gettimeofday(&end, NULL);
>> + t = end.tv_sec + end.tv_usec * 1e-6 -
>> + (pipe_args->start.tv_sec + pipe_args->start.tv_usec * 1e-6);
>> + fprintf(stderr, "freq: %.02fHz\n", pipe_args->swap_count / t);
>> + pipe_args->swap_count = 0;
>> + pipe_args->start = end;
>> + }
>> + }
>> +
>> + if (drop_master)
>> + drmDropMaster(dev.fd);
>> +
>> + getchar();
>> +
>> + drmModeAtomicFree(dev.req);
>> + dev.req = drmModeAtomicAlloc();
>> +
>> + clear_mode(&dev, pipe_args, count);
>> + clear_planes(&dev, plane_args, plane_count);
>> + ret = drmModeAtomicCommit(dev.fd, dev.req, DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
>> + if (ret) {
>> + fprintf(stderr, "Atomic Commit failed\n");
>> + return 1;
>> + }
>> +
>> + clear_FB(&dev, plane_args, plane_count);
>> + }
>> +
>> + drmModeAtomicFree(dev.req);
>> + free_resources(dev.resources);
>> +
>> + return 0;
>> +}
>> --
>> 2.15.0
>>
>> _______________________________________________
>> dri-devel mailing list
>> dri-devel@xxxxxxxxxxxxxxxxxxxxx
>> https://lists.freedesktop.org/mailman/listinfo/dri-devel
_______________________________________________
dri-devel mailing list
dri-devel@xxxxxxxxxxxxxxxxxxxxx
https://lists.freedesktop.org/mailman/listinfo/dri-devel
