drm 之modes

显示mode 各参数含义：

hdisplay：有效显示区水平像素数量，对应Active Width

hsync_start：水平同步开始，对应hdispay + HFP

hsync_end：水平同步结束，对应hdisplay + HFP + HSYNC width(HPW)

htotal：水平总像素，对应hdisplay + HFP + HSYNC width + HBP

vdisplay：垂直显示像素，对应Active Height

vsync_start：垂直同步开始，对应vdispay + VFP

vsync_end：垂直像素结束，对应vdisplay + VFP + VSYNC width(VPW)

vtotal：垂直总像素，对应vdisplay + VFP + VSYNC width + VBP

vrefresh：刷新率

 hdmi 通过i2c 读取屏幕edid ，解析出各分辨率mode参数：

#define _GNU_SOURCE
#include <errno.h>
#include <fcntl.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <time.h>
#include <unistd.h>
#include <xf86drm.h>
#include <xf86drmMode.h>

struct modeset_buf;
struct modeset_dev;
static int modeset_find_crtc(int fd, drmModeRes *res, drmModeConnector *conn,
			     struct modeset_dev *dev);
static int modeset_create_fb(int fd, struct modeset_buf *buf);
static void modeset_destroy_fb(int fd, struct modeset_buf *buf);
static int modeset_setup_dev(int fd, drmModeRes *res, drmModeConnector *conn,
			     struct modeset_dev *dev);
static int modeset_open(int *out, const char *node);
static int modeset_prepare(int fd);
static void modeset_draw(int fd);
static void modeset_draw_dev(int fd, struct modeset_dev *dev);
static void modeset_cleanup(int fd);

/*
 * modeset_open() stays the same.
 */

static int modeset_open(int *out, const char *node)
{
	int fd, ret;
	uint64_t has_dumb;

	fd = open(node, O_RDWR | O_CLOEXEC);
	if (fd < 0) {
		ret = -errno;
		fprintf(stderr, "cannot open '%s': %m\n", node);
		return ret;
	}

	if (drmGetCap(fd, DRM_CAP_DUMB_BUFFER, &has_dumb) < 0 ||
	    !has_dumb) {
		fprintf(stderr, "drm device '%s' does not support dumb buffers\n",
			node);
		close(fd);
		return -EOPNOTSUPP;
	}

	*out = fd;
	return 0;
}


struct modeset_buf {
	uint32_t width;
	uint32_t height;
	uint32_t stride;
	uint32_t size;
	uint32_t handle;
	uint8_t *map;
	uint32_t fb;
};

struct modeset_dev {
	struct modeset_dev *next;

	unsigned int front_buf;
	struct modeset_buf bufs[2];

	drmModeModeInfo mode;
	uint32_t conn;
	uint32_t crtc;
	drmModeCrtc *saved_crtc;

	bool pflip_pending;
	bool cleanup;

	uint8_t r, g, b;
	bool r_up, g_up, b_up;
};

static struct modeset_dev *modeset_list = NULL;

/*
 * modeset_prepare() stays the same.
 */

static int modeset_prepare(int fd)
{
	drmModeRes *res;
	drmModeConnector *conn;
	unsigned int i;
	struct modeset_dev *dev;
	int ret;

	/* retrieve resources */
	res = drmModeGetResources(fd);
	if (!res) {
		fprintf(stderr, "cannot retrieve DRM resources (%d): %m\n",
			errno);
		return -errno;
	}

	/* iterate all connectors */
	for (i = 0; i < res->count_connectors; ++i) {
		/* get information for each connector */
		conn = drmModeGetConnector(fd, res->connectors[i]);
		if (!conn) {
			fprintf(stderr, "cannot retrieve DRM connector %u:%u (%d): %m\n",
				i, res->connectors[i], errno);
			continue;
		}

		/* create a device structure */
		dev = malloc(sizeof(*dev));
		memset(dev, 0, sizeof(*dev));
		dev->conn = conn->connector_id;

		/* call helper function to prepare this connector */
		ret = modeset_setup_dev(fd, res, conn, dev);
		if (ret) {
			if (ret != -ENOENT) {
				errno = -ret;
				fprintf(stderr, "cannot setup device for connector %u:%u (%d): %m\n",
					i, res->connectors[i], errno);
			}
			free(dev);
			drmModeFreeConnector(conn);
			continue;
		}

		/* free connector data and link device into global list */
		drmModeFreeConnector(conn);
		dev->next = modeset_list;
		modeset_list = dev;
	}

	/* free resources again */
	drmModeFreeResources(res);
	return 0;
}

/*
 * modeset_setup_dev() stays the same.
 */

static int modeset_setup_dev(int fd, drmModeRes *res, drmModeConnector *conn,
			     struct modeset_dev *dev)
{
	int ret;

	/* check if a monitor is connected */
	if (conn->connection != DRM_MODE_CONNECTED) {
		fprintf(stderr, "ignoring unused connector %u\n",
			conn->connector_id);
		return -ENOENT;
	}

	/* check if there is at least one valid mode */
	if (conn->count_modes == 0) {
		fprintf(stderr, "no valid mode for connector %u\n",
			conn->connector_id);
		return -EFAULT;
	}

	for (int i = 0; i < conn->count_modes; i++) {
		printf("%d: %ux%u [%s]\n", i, conn->modes[i].hdisplay, conn->modes[i].vdisplay, conn->modes[i].name);
		printf(
			"\tclock: %d, vrefresh: %d, flags: %d, type: %d\n",
			conn->modes[i].clock,
			conn->modes[i].vrefresh,
			conn->modes[i].flags,
			conn->modes[i].type);
		printf(
			"\thdisplay: %d, hsync_start: %d, hsync_end: %d, htotal: %d, hskew: %d\n",
			conn->modes[i].hdisplay,
			conn->modes[i].hsync_start,
			conn->modes[i].hsync_end,
			conn->modes[i].htotal,
			conn->modes[i].hskew);
		printf(
			"\tvdisplay: %d, vsync_start: %d, vsync_end: %d, vtotal: %d, vskew: %d\n",
			conn->modes[i].vdisplay,
			conn->modes[i].vsync_start,
			conn->modes[i].vsync_end,
			conn->modes[i].vtotal,
			conn->modes[i].vscan);
	}

	int mode = 10;

	/* copy the mode information into our device structure and into both
	 * buffers */
	memcpy(&dev->mode, &conn->modes[mode], sizeof(dev->mode));
#if 1
	dev->bufs[0].width = conn->modes[mode].hdisplay;
	dev->bufs[0].height = conn->modes[mode].vdisplay;
	dev->bufs[1].width = conn->modes[mode].hdisplay;
	dev->bufs[1].height = conn->modes[mode].vdisplay;
#else
	dev->mode.hdisplay = 1920;
	dev->mode.hsync_start = 2008;
	dev->mode.hsync_end = 2052;
	dev->mode.htotal = 2200;
	dev->mode.vdisplay = 1080;
	dev->mode.vsync_start = 1084;
	dev->mode.vsync_end = 1089;
	dev->mode.vtotal = 1125;
	dev->bufs[0].width = 1920;
	dev->bufs[0].height = 1080;
	dev->bufs[1].width = 1920;
	dev->bufs[1].height = 1080;
	fprintf(stderr, "mode for connector %u is %ux%u\n",
		conn->connector_id, dev->bufs[0].width, dev->bufs[0].height);
#endif
	/* find a crtc for this connector */
	ret = modeset_find_crtc(fd, res, conn, dev);
	if (ret) {
		fprintf(stderr, "no valid crtc for connector %u\n",
			conn->connector_id);
		return ret;
	}

	/* create framebuffer #1 for this CRTC */
	ret = modeset_create_fb(fd, &dev->bufs[0]);
	if (ret) {
		fprintf(stderr, "cannot create framebuffer for connector %u\n",
			conn->connector_id);
		return ret;
	}

	/* create framebuffer #2 for this CRTC */
	ret = modeset_create_fb(fd, &dev->bufs[1]);
	if (ret) {
		fprintf(stderr, "cannot create framebuffer for connector %u\n",
			conn->connector_id);
		modeset_destroy_fb(fd, &dev->bufs[0]);
		return ret;
	}

	return 0;
}

/*
 * modeset_find_crtc() stays the same.
 */

static int modeset_find_crtc(int fd, drmModeRes *res, drmModeConnector *conn,
			     struct modeset_dev *dev)
{
	drmModeEncoder *enc;
	unsigned int i, j;
	int32_t crtc;
	struct modeset_dev *iter;

	/* first try the currently conected encoder+crtc */
	if (conn->encoder_id)
		enc = drmModeGetEncoder(fd, conn->encoder_id);
	else
		enc = NULL;

	if (enc) {
		if (enc->crtc_id) {
			crtc = enc->crtc_id;
			for (iter = modeset_list; iter; iter = iter->next) {
				if (iter->crtc == crtc) {
					crtc = -1;
					break;
				}
			}

			if (crtc >= 0) {
				drmModeFreeEncoder(enc);
				dev->crtc = crtc;
				return 0;
			}
		}

		drmModeFreeEncoder(enc);
	}

	/* If the connector is not currently bound to an encoder or if the
	 * encoder+crtc is already used by another connector (actually unlikely
	 * but lets be safe), iterate all other available encoders to find a
	 * matching CRTC. */
	for (i = 0; i < conn->count_encoders; ++i) {
		enc = drmModeGetEncoder(fd, conn->encoders[i]);
		if (!enc) {
			fprintf(stderr, "cannot retrieve encoder %u:%u (%d): %m\n",
				i, conn->encoders[i], errno);
			continue;
		}

		/* iterate all global CRTCs */
		for (j = 0; j < res->count_crtcs; ++j) {
			/* check whether this CRTC works with the encoder */
			if (!(enc->possible_crtcs & (1 << j)))
				continue;

			/* check that no other device already uses this CRTC */
			crtc = res->crtcs[j];
			for (iter = modeset_list; iter; iter = iter->next) {
				if (iter->crtc == crtc) {
					crtc = -1;
					break;
				}
			}

			/* we have found a CRTC, so save it and return */
			if (crtc >= 0) {
				drmModeFreeEncoder(enc);
				dev->crtc = crtc;
				return 0;
			}
		}

		drmModeFreeEncoder(enc);
	}

	fprintf(stderr, "cannot find suitable CRTC for connector %u\n",
		conn->connector_id);
	return -ENOENT;
}

/*
 * modeset_create_fb() stays the same.
 */

static int modeset_create_fb(int fd, struct modeset_buf *buf)
{
	struct drm_mode_create_dumb creq;
	struct drm_mode_destroy_dumb dreq;
	struct drm_mode_map_dumb mreq;
	int ret;

	/* create dumb buffer */
	memset(&creq, 0, sizeof(creq));
	creq.width = buf->width;
	creq.height = buf->height;
	creq.bpp = 32;
	ret = drmIoctl(fd, DRM_IOCTL_MODE_CREATE_DUMB, &creq);
	if (ret < 0) {
		fprintf(stderr, "cannot create dumb buffer (%d): %m\n",
			errno);
		return -errno;
	}
	buf->stride = creq.pitch;
	buf->size = creq.size;
	buf->handle = creq.handle;

	/* create framebuffer object for the dumb-buffer */
	ret = drmModeAddFB(fd, buf->width, buf->height, 24, 32, buf->stride,
			   buf->handle, &buf->fb);
	if (ret) {
		fprintf(stderr, "cannot create framebuffer (%d): %m\n",
			errno);
		ret = -errno;
		goto err_destroy;
	}

	/* prepare buffer for memory mapping */
	memset(&mreq, 0, sizeof(mreq));
	mreq.handle = buf->handle;
	ret = drmIoctl(fd, DRM_IOCTL_MODE_MAP_DUMB, &mreq);
	if (ret) {
		fprintf(stderr, "cannot map dumb buffer (%d): %m\n",
			errno);
		ret = -errno;
		goto err_fb;
	}

	/* perform actual memory mapping */
	buf->map = mmap(0, buf->size, PROT_READ | PROT_WRITE, MAP_SHARED,
		        fd, mreq.offset);
	if (buf->map == MAP_FAILED) {
		fprintf(stderr, "cannot mmap dumb buffer (%d): %m\n",
			errno);
		ret = -errno;
		goto err_fb;
	}

	/* clear the framebuffer to 0 */
	memset(buf->map, 0, buf->size);

	return 0;

err_fb:
	drmModeRmFB(fd, buf->fb);
err_destroy:
	memset(&dreq, 0, sizeof(dreq));
	dreq.handle = buf->handle;
	drmIoctl(fd, DRM_IOCTL_MODE_DESTROY_DUMB, &dreq);
	return ret;
}

/*
 * modeset_destroy_fb() stays the same.
 */

static void modeset_destroy_fb(int fd, struct modeset_buf *buf)
{
	struct drm_mode_destroy_dumb dreq;

	/* unmap buffer */
	munmap(buf->map, buf->size);

	/* delete framebuffer */
	drmModeRmFB(fd, buf->fb);

	/* delete dumb buffer */
	memset(&dreq, 0, sizeof(dreq));
	dreq.handle = buf->handle;
	drmIoctl(fd, DRM_IOCTL_MODE_DESTROY_DUMB, &dreq);
}

/*
 * main() also stays the same.
 */

int main(int argc, char **argv)
{
	int ret, fd;
	const char *card;
	struct modeset_dev *iter;
	struct modeset_buf *buf;

	/* check which DRM device to open */
	if (argc > 1)
		card = argv[1];
	else
		card = "/dev/dri/card0";

	fprintf(stderr, "using card '%s'\n", card);

	/* open the DRM device */
	ret = modeset_open(&fd, card);
	if (ret)
		goto out_return;

	/* prepare all connectors and CRTCs */
	ret = modeset_prepare(fd);
	if (ret)
		goto out_close;

	/* perform actual modesetting on each found connector+CRTC */
	for (iter = modeset_list; iter; iter = iter->next) {
		iter->saved_crtc = drmModeGetCrtc(fd, iter->crtc);
		buf = &iter->bufs[iter->front_buf];
		ret = drmModeSetCrtc(fd, iter->crtc, buf->fb, 0, 0,
				     &iter->conn, 1, &iter->mode);
		if (ret)
			fprintf(stderr, "cannot set CRTC for connector %u (%d): %m\n",
				iter->conn, errno);
	}

	/* draw some colors for 5seconds */
	modeset_draw(fd);

	/* cleanup everything */
	modeset_cleanup(fd);

	ret = 0;

out_close:
	close(fd);
out_return:
	if (ret) {
		errno = -ret;
		fprintf(stderr, "modeset failed with error %d: %m\n", errno);
	} else {
		fprintf(stderr, "exiting\n");
	}
	return ret;
}

/*
 * modeset_page_flip_event() is a callback-helper for modeset_draw() below.
 * Please see modeset_draw() for more information.
 *
 * Note that this does nothing if the device is currently cleaned up. This
 * allows to wait for outstanding page-flips during cleanup.
 */

static void modeset_page_flip_event(int fd, unsigned int frame,
				    unsigned int sec, unsigned int usec,
				    void *data)
{
	struct modeset_dev *dev = data;

	dev->pflip_pending = false;
	if (!dev->cleanup)
		modeset_draw_dev(fd, dev);
}



static void modeset_draw(int fd)
{
	int ret;
	fd_set fds;
	time_t start, cur;
	struct timeval v;
	drmEventContext ev;
	struct modeset_dev *iter;

	/* init variables */
	srand(time(&start));
	FD_ZERO(&fds);
	memset(&v, 0, sizeof(v));
	memset(&ev, 0, sizeof(ev));
	ev.version = DRM_EVENT_CONTEXT_VERSION;
	ev.page_flip_handler = modeset_page_flip_event;

	/* redraw all outputs */
	for (iter = modeset_list; iter; iter = iter->next) {
		printf("%s %d\n",__FUNCTION__,__LINE__);
		iter->r = rand() % 0xff;
		iter->g = rand() % 0xff;
		iter->b = rand() % 0xff;
		iter->r_up = iter->g_up = iter->b_up = true;

		modeset_draw_dev(fd, iter);
	}
#if 1
	/* wait 5s for VBLANK or input events */
	while (time(&cur) < start + 5) {
		FD_SET(0, &fds);
		FD_SET(fd, &fds);
		v.tv_sec = start + 5 - cur;

		ret = select(fd + 1, &fds, NULL, NULL, &v);
		if (ret < 0) {
			fprintf(stderr, "select() failed with %d: %m\n", errno);
			break;
		} else if (FD_ISSET(0, &fds)) {
			fprintf(stderr, "exit due to user-input\n");
			break;
		} else if (FD_ISSET(fd, &fds)) {
			drmHandleEvent(fd, &ev);
		}
	}
#else
	 while (1) {
		drmHandleEvent(fd, &ev);
	}
#endif
}

/*
 * A short helper function to compute a changing color value. No need to
 * understand it.
 */

static uint8_t next_color(bool *up, uint8_t cur, unsigned int mod)
{
	uint8_t next;

	next = cur + (*up ? 1 : -1) * (rand() % mod);
	if ((*up && next < cur) || (!*up && next > cur)) {
		*up = !*up;
		next = cur;
	}

	return next;
}



static void modeset_draw_dev(int fd, struct modeset_dev *dev)
{
	struct modeset_buf *buf;
	unsigned int j, k, off;
	int ret;

	dev->r = next_color(&dev->r_up, dev->r, 20);
	dev->g = next_color(&dev->g_up, dev->g, 10);
	dev->b = next_color(&dev->b_up, dev->b, 5);


	buf = &dev->bufs[dev->front_buf ^ 1];
	
	for (j = 0; j < buf->height; ++j) {
		for (k = 0; k < buf->width; ++k) {
			off = buf->stride * j + k * 4;
			*(uint32_t*)&buf->map[off] =
				     (dev->r << 16) | (dev->g << 8) | dev->b;
		}
	}

	ret = drmModePageFlip(fd, dev->crtc, buf->fb,
			      DRM_MODE_PAGE_FLIP_EVENT, dev);
	if (ret) {
		fprintf(stderr, "cannot flip CRTC for connector %u (%d): %m\n",
			dev->conn, errno);
	} else {
		dev->front_buf ^= 1;
		dev->pflip_pending = true;
	}
	sleep(1);
}



static void modeset_cleanup(int fd)
{
	struct modeset_dev *iter;
	drmEventContext ev;
	int ret;

	/* init variables */
	memset(&ev, 0, sizeof(ev));
	ev.version = DRM_EVENT_CONTEXT_VERSION;
	ev.page_flip_handler = modeset_page_flip_event;

	while (modeset_list) {
		/* remove from global list */
		iter = modeset_list;
		modeset_list = iter->next;

		/* if a pageflip is pending, wait for it to complete */
		iter->cleanup = true;
		fprintf(stderr, "wait for pending page-flip to complete...\n");
		while (iter->pflip_pending) {
			ret = drmHandleEvent(fd, &ev);
			if (ret)
				break;
		}

		/* restore saved CRTC configuration */
		if (!iter->pflip_pending)
			drmModeSetCrtc(fd,
				       iter->saved_crtc->crtc_id,
				       iter->saved_crtc->buffer_id,
				       iter->saved_crtc->x,
				       iter->saved_crtc->y,
				       &iter->conn,
				       1,
				       &iter->saved_crtc->mode);
		drmModeFreeCrtc(iter->saved_crtc);

		/* destroy framebuffers */
		modeset_destroy_fb(fd, &iter->bufs[1]);
		modeset_destroy_fb(fd, &iter->bufs[0]);

		/* free allocated memory */
		free(iter);
	}
}

 下面是modeset-vsync ：打印mode的日志

root@rk3399:/]# modeset-vsync 
using card '/dev/dri/card0'
0: 1920x1080 [1920x1080]
        clock: 148500, vrefresh: 60, flags: 5, type: 72
        hdisplay: 1920, hsync_start: 2008, hsync_end: 2052, htotal: 2200, hskew: 0
        vdisplay: 1080, vsync_start: 1084, vsync_end: 1089, vtotal: 1125, vskew: 0
1: 1920x1080 [1920x1080]
        clock: 148352, vrefresh: 60, flags: 5, type: 64
        hdisplay: 1920, hsync_start: 2008, hsync_end: 2052, htotal: 2200, hskew: 0
        vdisplay: 1080, vsync_start: 1084, vsync_end: 1089, vtotal: 1125, vskew: 0
2: 1920x1080 [1920x1080i]
        clock: 74250, vrefresh: 60, flags: 21, type: 64
        hdisplay: 1920, hsync_start: 2008, hsync_end: 2052, htotal: 2200, hskew: 0
        vdisplay: 1080, vsync_start: 1084, vsync_end: 1094, vtotal: 1125, vskew: 0
3: 1920x1080 [1920x1080i]
        clock: 74176, vrefresh: 60, flags: 21, type: 64
        hdisplay: 1920, hsync_start: 2008, hsync_end: 2052, htotal: 2200, hskew: 0
        vdisplay: 1080, vsync_start: 1084, vsync_end: 1094, vtotal: 1125, vskew: 0
4: 1920x1080 [1920x1080]
        clock: 148500, vrefresh: 50, flags: 5, type: 64
        hdisplay: 1920, hsync_start: 2448, hsync_end: 2492, htotal: 2640, hskew: 0
        vdisplay: 1080, vsync_start: 1084, vsync_end: 1089, vtotal: 1125, vskew: 0
5: 1920x1080 [1920x1080i]
        clock: 74250, vrefresh: 50, flags: 21, type: 64
        hdisplay: 1920, hsync_start: 2448, hsync_end: 2492, htotal: 2640, hskew: 0
        vdisplay: 1080, vsync_start: 1084, vsync_end: 1094, vtotal: 1125, vskew: 0
6: 1680x1050 [1680x1050]
        clock: 119000, vrefresh: 60, flags: 9, type: 64
        hdisplay: 1680, hsync_start: 1728, hsync_end: 1760, htotal: 1840, hskew: 0
        vdisplay: 1050, vsync_start: 1053, vsync_end: 1059, vtotal: 1080, vskew: 0
7: 1280x1024 [1280x1024]
        clock: 135000, vrefresh: 75, flags: 5, type: 64
        hdisplay: 1280, hsync_start: 1296, hsync_end: 1440, htotal: 1688, hskew: 0
        vdisplay: 1024, vsync_start: 1025, vsync_end: 1028, vtotal: 1066, vskew: 0
8: 1280x1024 [1280x1024]
        clock: 108000, vrefresh: 60, flags: 5, type: 64
        hdisplay: 1280, hsync_start: 1328, hsync_end: 1440, htotal: 1688, hskew: 0
        vdisplay: 1024, vsync_start: 1025, vsync_end: 1028, vtotal: 1066, vskew: 0
9: 1440x900 [1440x900]
        clock: 88750, vrefresh: 60, flags: 9, type: 64
        hdisplay: 1440, hsync_start: 1488, hsync_end: 1520, htotal: 1600, hskew: 0
        vdisplay: 900, vsync_start: 903, vsync_end: 909, vtotal: 926, vskew: 0
10: 1280x960 [1280x960]
        clock: 108000, vrefresh: 60, flags: 5, type: 64
        hdisplay: 1280, hsync_start: 1376, hsync_end: 1488, htotal: 1800, hskew: 0
        vdisplay: 960, vsync_start: 961, vsync_end: 964, vtotal: 1000, vskew: 0
11: 1280x720 [1280x720]
        clock: 74250, vrefresh: 60, flags: 5, type: 64
        hdisplay: 1280, hsync_start: 1390, hsync_end: 1430, htotal: 1650, hskew: 0
        vdisplay: 720, vsync_start: 725, vsync_end: 730, vtotal: 750, vskew: 0
12: 1280x720 [1280x720]
        clock: 74176, vrefresh: 60, flags: 5, type: 64
        hdisplay: 1280, hsync_start: 1390, hsync_end: 1430, htotal: 1650, hskew: 0
        vdisplay: 720, vsync_start: 725, vsync_end: 730, vtotal: 750, vskew: 0
13: 1280x720 [1280x720]
        clock: 74250, vrefresh: 50, flags: 5, type: 64
        hdisplay: 1280, hsync_start: 1720, hsync_end: 1760, htotal: 1980, hskew: 0
        vdisplay: 720, vsync_start: 725, vsync_end: 730, vtotal: 750, vskew: 0
14: 1024x768 [1024x768]
        clock: 78750, vrefresh: 75, flags: 5, type: 64
        hdisplay: 1024, hsync_start: 1040, hsync_end: 1136, htotal: 1312, hskew: 0
        vdisplay: 768, vsync_start: 769, vsync_end: 772, vtotal: 800, vskew: 0
15: 1024x768 [1024x768]
        clock: 75000, vrefresh: 70, flags: 10, type: 64
        hdisplay: 1024, hsync_start: 1048, hsync_end: 1184, htotal: 1328, hskew: 0
        vdisplay: 768, vsync_start: 771, vsync_end: 777, vtotal: 806, vskew: 0
16: 1024x768 [1024x768]
        clock: 65000, vrefresh: 60, flags: 10, type: 64
        hdisplay: 1024, hsync_start: 1048, hsync_end: 1184, htotal: 1344, hskew: 0
        vdisplay: 768, vsync_start: 771, vsync_end: 777, vtotal: 806, vskew: 0
17: 832x624 [832x624]
        clock: 57284, vrefresh: 75, flags: 10, type: 64
        hdisplay: 832, hsync_start: 864, hsync_end: 928, htotal: 1152, hskew: 0
        vdisplay: 624, vsync_start: 625, vsync_end: 628, vtotal: 667, vskew: 0
18: 800x600 [800x600]
        clock: 49500, vrefresh: 75, flags: 5, type: 64
        hdisplay: 800, hsync_start: 816, hsync_end: 896, htotal: 1056, hskew: 0
        vdisplay: 600, vsync_start: 601, vsync_end: 604, vtotal: 625, vskew: 0
19: 800x600 [800x600]
        clock: 50000, vrefresh: 72, flags: 5, type: 64
        hdisplay: 800, hsync_start: 856, hsync_end: 976, htotal: 1040, hskew: 0
        vdisplay: 600, vsync_start: 637, vsync_end: 643, vtotal: 666, vskew: 0
20: 800x600 [800x600]
        clock: 40000, vrefresh: 60, flags: 5, type: 64
        hdisplay: 800, hsync_start: 840, hsync_end: 968, htotal: 1056, hskew: 0
        vdisplay: 600, vsync_start: 601, vsync_end: 605, vtotal: 628, vskew: 0
21: 800x600 [800x600]
        clock: 36000, vrefresh: 56, flags: 5, type: 64
        hdisplay: 800, hsync_start: 824, hsync_end: 896, htotal: 1024, hskew: 0
        vdisplay: 600, vsync_start: 601, vsync_end: 603, vtotal: 625, vskew: 0
22: 720x576 [720x576]
        clock: 27000, vrefresh: 50, flags: 10, type: 64
        hdisplay: 720, hsync_start: 732, hsync_end: 796, htotal: 864, hskew: 0
        vdisplay: 576, vsync_start: 581, vsync_end: 586, vtotal: 625, vskew: 0
23: 720x480 [720x480]
        clock: 27027, vrefresh: 60, flags: 10, type: 64
        hdisplay: 720, hsync_start: 736, hsync_end: 798, htotal: 858, hskew: 0
        vdisplay: 480, vsync_start: 489, vsync_end: 495, vtotal: 525, vskew: 0
24: 720x480 [720x480]
        clock: 27000, vrefresh: 60, flags: 10, type: 64
        hdisplay: 720, hsync_start: 736, hsync_end: 798, htotal: 858, hskew: 0
        vdisplay: 480, vsync_start: 489, vsync_end: 495, vtotal: 525, vskew: 0
25: 640x480 [640x480]
        clock: 31500, vrefresh: 75, flags: 10, type: 64
        hdisplay: 640, hsync_start: 656, hsync_end: 720, htotal: 840, hskew: 0
        vdisplay: 480, vsync_start: 481, vsync_end: 484, vtotal: 500, vskew: 0
26: 640x480 [640x480]
        clock: 31500, vrefresh: 73, flags: 10, type: 64
        hdisplay: 640, hsync_start: 664, hsync_end: 704, htotal: 832, hskew: 0
        vdisplay: 480, vsync_start: 489, vsync_end: 492, vtotal: 520, vskew: 0
27: 640x480 [640x480]
        clock: 30240, vrefresh: 67, flags: 10, type: 64
        hdisplay: 640, hsync_start: 704, hsync_end: 768, htotal: 864, hskew: 0
        vdisplay: 480, vsync_start: 483, vsync_end: 486, vtotal: 525, vskew: 0
28: 640x480 [640x480]
        clock: 25200, vrefresh: 60, flags: 10, type: 64
        hdisplay: 640, hsync_start: 656, hsync_end: 752, htotal: 800, hskew: 0
        vdisplay: 480, vsync_start: 490, vsync_end: 492, vtotal: 525, vskew: 0
29: 640x480 [640x480]
        clock: 25175, vrefresh: 60, flags: 10, type: 64
        hdisplay: 640, hsync_start: 656, hsync_end: 752, htotal: 800, hskew: 0
        vdisplay: 480, vsync_start: 490, vsync_end: 492, vtotal: 525, vskew: 0
30: 720x400 [720x400]
        clock: 28320, vrefresh: 70, flags: 6, type: 64
        hdisplay: 720, hsync_start: 738, hsync_end: 846, htotal: 900, hskew: 0
        vdisplay: 400, vsync_start: 412, vsync_end: 414, vtotal: 449, vskew: 0
ignoring unused connector 99
[  195.865891] rockchip-vop ff900000.vop: [drm:vop_crtc_enable] Update mode to 1280x960p60, type: 11
modeset_draw 607