Linux DRM how-to 例子

/* * modeset - DRM Modesetting Example * * Written 2012 by David Herrmann <dh.herrmann@googlemail.com> * Dedicated to the Public Domain. */ /* * DRM Modesetting Howto * This document describes the DRM modesetting API. Before we can use the DRM * API, we have to include xf86drm.h and xf86drmMode.h. Both are provided by * libdrm which every major distribution ships by default. It has no other * dependencies and is pretty small. * * Please ignore all forward-declarations of functions which are used later. I * reordered the functions so you can read this document from top to bottom. If * you reimplement it, you would probably reorder the functions to avoid all the * nasty forward declarations. * * For easier reading, we ignore all memory-allocation errors of malloc() and * friends here. However, we try to correctly handle all other kinds of errors * that may occur. * * All functions and global variables are prefixed with "modeset_*" in this * file. So it should be clear whether a function is a local helper or if it is * provided by some external library. */ #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_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_dev *dev); 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(void); static void modeset_cleanup(int fd); /* * When the linux kernel detects a graphics-card on your machine, it loads the * correct device driver (located in kernel-tree at ./drivers/gpu/drm/<xy>) and * provides two character-devices to control it. Udev (or whatever hotplugging * application you use) will create them as: * /dev/dri/card0 * /dev/dri/controlID64 * We only need the first one. You can hard-code this path into your application * like we do here, but it is recommended to use libudev with real hotplugging * and multi-seat support. However, this is beyond the scope of this document. * Also note that if you have multiple graphics-cards, there may also be * /dev/dri/card1, /dev/dri/card2, ... * * We simply use /dev/dri/card0 here but the user can specify another path on * the command line. * * modeset_open(out, node): This small helper function opens the DRM device * which is given as @node. The new fd is stored in @out on success. On failure, * a negative error code is returned. * After opening the file, we also check for the DRM_CAP_DUMB_BUFFER capability. * If the driver supports this capability, we can create simple memory-mapped * buffers without any driver-dependent code. As we want to avoid any radeon, * nvidia, intel, etc. specific code, we depend on DUMB_BUFFERs here. */ 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; } /* * As a next step we need to find our available display devices. libdrm provides * a drmModeRes structure that contains all the needed information. We can * retrieve it via drmModeGetResources(fd) and free it via * drmModeFreeResources(res) again. * * A physical connector on your graphics card is called a "connector". You can * plug a monitor into it and control what is displayed. We are definitely * interested in what connectors are currently used, so we simply iterate * through the list of connectors and try to display a test-picture on each * available monitor. * However, this isn't as easy as it sounds. First, we need to check whether the * connector is actually used (a monitor is plugged in and turned on). Then we * need to find a CRTC that can control this connector. CRTCs are described * later on. After that we create a framebuffer object. If we have all this, we * can mmap() the framebuffer and draw a test-picture into it. Then we can tell * the DRM device to show the framebuffer on the given CRTC with the selected * connector. * * As we want to draw moving pictures on the framebuffer, we actually have to * remember all these settings. Therefore, we create one "struct modeset_dev" * object for each connector+crtc+framebuffer pair that we successfully * initialized and push it into the global device-list. * * Each field of this structure is described when it is first used. But as a * summary: * "struct modeset_dev" contains: { * - @next: points to the next device in the single-linked list * * - @width: width of our buffer object * - @height: height of our buffer object * - @stride: stride value of our buffer object * - @size: size of the memory mapped buffer * - @handle: a DRM handle to the buffer object that we can draw into * - @map: pointer to the memory mapped buffer * * - @mode: the display mode that we want to use * - @fb: a framebuffer handle with our buffer object as scanout buffer * - @conn: the connector ID that we want to use with this buffer * - @crtc: the crtc ID that we want to use with this connector * - @saved_crtc: the configuration of the crtc before we changed it. We use it * so we can restore the same mode when we exit. * } */ struct modeset_dev { struct modeset_dev *next; uint32_t width; uint32_t height; uint32_t stride; uint32_t size; uint32_t handle; uint8_t *map; drmModeModeInfo mode; uint32_t fb; uint32_t conn; uint32_t crtc; drmModeCrtc *saved_crtc; }; static struct modeset_dev *modeset_list = NULL; /* * So as next step we need to actually prepare all connectors that we find. We * do this in this little helper function: * * modeset_prepare(fd): This helper function takes the DRM fd as argument and * then simply retrieves the resource-info from the device. It then iterates * through all connectors and calls other helper functions to initialize this * connector (described later on). * If the initialization was successful, we simply add this object as new device * into the global modeset device list. * * The resource-structure contains a list of all connector-IDs. We use the * helper function drmModeGetConnector() to retrieve more information on each * connector. After we are done with it, we free it again with * drmModeFreeConnector(). * Our helper modeset_setup_dev() returns -ENOENT if the connector is currently * unused and no monitor is plugged in. So we can ignore this connector. */ 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 f