Hi! This series adds support for an 8-bit clut mode in the atmel-hlcdc driver. I have now tested patch 1 with the below program (modeset.c adapted from https://github.com/dvdhrm/docs/tree/master/drm-howto to use an 8-bit mode). Since v2 I have also cleared up why the first 16 entries of the clut was not working right. It was of course my own damn fault, and the fix was in atmel_hlcdc_layer_write_clut function which called the ...write_reg function which in turn added an extra offset of 16 registers... Changes since v2: - Fix mapping to the clut registers. Changes since v1: - Move the clut update from atmel_hlcdc_crtc_mode_valid to atmel_hlcdc_plane_atomic_update. - Add default .gamma_set helper (drm_atomic_helper_legacy_gamma_set). - Don't keep a spare copy of the clut, reuse gamma_store instead. - Don't try to synchronize the legacy fb clut with the drm clut. As I said in v2, I have not added any .clut_offset to the overlay2 layer of sama5d4, since the chip does not appear to have that layer. I didn't do that to make it easier to work with the patch previously sent to remove that layer, but I suspect bad things may happen to sama5d4 users if they do not have that layer removed. Cheers, peda modeset-pal.c (didn't update any comments, sorry) ----------------8<--------------- /* * modeset - DRM Modesetting Example * * Written 2012 by David Herrmann <dh.herrmann@xxxxxxxxxxxxxx> * 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(int fd); 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 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; } /* * Now we dig deeper into setting up a single connector. As described earlier, * we need to check several things first: * * If the connector is currently unused, that is, no monitor is plugged in, * then we can ignore it. * * We have to find a suitable resolution and refresh-rate. All this is * available in drmModeModeInfo structures saved for each crtc. We simply * use the first mode that is available. This is always the mode with the * highest resolution. * A more sophisticated mode-selection should be done in real applications, * though. * * Then we need to find an CRTC that can drive this connector. A CRTC is an * internal resource of each graphics-card. The number of CRTCs controls how * many connectors can be controlled indepedently. That is, a graphics-cards * may have more connectors than CRTCs, which means, not all monitors can be * controlled independently. * There is actually the possibility to control multiple connectors via a * single CRTC if the monitors should display the same content. However, we * do not make use of this here. * So think of connectors as pipelines to the connected monitors and the * CRTCs are the controllers that manage which data goes to which pipeline. * If there are more pipelines than CRTCs, then we cannot control all of * them at the same time. * * We need to create a framebuffer for this connector. A framebuffer is a * memory buffer that we can write XRGB32 data into. So we use this to * render our graphics and then the CRTC can scan-out this data from the * framebuffer onto the monitor. */ 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; } /* copy the mode information into our device structure */ memcpy(&dev->mode, &conn->modes[0], sizeof(dev->mode)); dev->width = conn->modes[0].hdisplay; dev->height = conn->modes[0].vdisplay; fprintf(stderr, "mode for connector %u is %ux%u\n", conn->connector_id, dev->width, dev->height); /* 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 a framebuffer for this CRTC */ ret = modeset_create_fb(fd, dev); if (ret) { fprintf(stderr, "cannot create framebuffer for connector %u\n", conn->connector_id); return ret; } return 0; } /* * modeset_find_crtc(fd, res, conn, dev): This small helper tries to find a * suitable CRTC for the given connector. We have actually have to introduce one * more DRM object to make this more clear: Encoders. * Encoders help the CRTC to convert data from a framebuffer into the right * format that can be used for the chosen connector. We do not have to * understand any more of these conversions to make use of it. However, you must * know that each connector has a limited list of encoders that it can use. And * each encoder can only work with a limited list of CRTCs. So what we do is * trying each encoder that is available and looking for a CRTC that this * encoder can work with. If we find the first working combination, we are happy * and write it into the @dev structure. * But before iterating all available encoders, we first try the currently * active encoder+crtc on a connector to avoid a full modeset. * * However, before we can use a CRTC we must make sure that no other device, * that we setup previously, is already using this CRTC. Remember, we can only * drive one connector per CRTC! So we simply iterate through the "modeset_list" * of previously setup devices and check that this CRTC wasn't used before. * Otherwise, we continue with the next CRTC/Encoder combination. */ 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(fd, dev): After we have found a crtc+connector+mode * combination, we need to actually create a suitable framebuffer that we can * use with it. There are actually two ways to do that: * * We can create a so called "dumb buffer". This is a buffer that we can * memory-map via mmap() and every driver supports this. We can use it for * unaccelerated software rendering on the CPU. * * We can use libgbm to create buffers available for hardware-acceleration. * libgbm is an abstraction layer that creates these buffers for each * available DRM driver. As there is no generic API for this, each driver * provides its own way to create these buffers. * We can then use such buffers to create OpenGL contexts with the mesa3D * library. * We use the first solution here as it is much simpler and doesn't require any * external libraries. However, if you want to use hardware-acceleration via * OpenGL, it is actually pretty easy to create such buffers with libgbm and * libEGL. But this is beyond the scope of this document. * * So what we do is requesting a new dumb-buffer from the driver. We specify the * same size as the current mode that we selected for the connector. * Then we request the driver to prepare this buffer for memory mapping. After * that we perform the actual mmap() call. So we can now access the framebuffer * memory directly via the dev->map memory map. */ static int modeset_create_fb(int fd, struct modeset_dev *dev) { 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 = dev->width; creq.height = dev->height; creq.bpp = 8; ret = drmIoctl(fd, DRM_IOCTL_MODE_CREATE_DUMB, &creq); if (ret < 0) { fprintf(stderr, "cannot create dumb buffer (%d): %m\n", errno); return -errno; } dev->stride = creq.pitch; dev->size = creq.size; dev->handle = creq.handle; /* create framebuffer object for the dumb-buffer */ ret = drmModeAddFB(fd, dev->width, dev->height, 8, 8, dev->stride, dev->handle, &dev->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 = dev->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 */ dev->map = mmap(0, dev->size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, mreq.offset); if (dev->map == MAP_FAILED) { fprintf(stderr, "cannot mmap dumb buffer (%d): %m\n", errno); ret = -errno; goto err_fb; } /* clear the framebuffer to 0 */ memset(dev->map, 0, dev->size); return 0; err_fb: drmModeRmFB(fd, dev->fb); err_destroy: memset(&dreq, 0, sizeof(dreq)); dreq.handle = dev->handle; drmIoctl(fd, DRM_IOCTL_MODE_DESTROY_DUMB, &dreq); return ret; } /* * Finally! We have a connector with a suitable CRTC. We know which mode we want * to use and we have a framebuffer of the correct size that we can write to. * There is nothing special left to do. We only have to program the CRTC to * connect each new framebuffer to each selected connector for each combination * that we saved in the global modeset_list. * This is done with a call to drmModeSetCrtc(). * * So we are ready for our main() function. First we check whether the user * specified a DRM device on the command line, otherwise we use the default * /dev/dri/card0. Then we open the device via modeset_open(). modeset_prepare() * prepares all connectors and we can loop over "modeset_list" and call * drmModeSetCrtc() on every CRTC/connector combination. * * But printing empty black pages is boring so we have another helper function * modeset_draw() that draws some colors into the framebuffer for 5 seconds and * then returns. And then we have all the cleanup functions which correctly free * all devices again after we used them. All these functions are described below * the main() function. * * As a side note: drmModeSetCrtc() actually takes a list of connectors that we * want to control with this CRTC. We pass only one connector, though. As * explained earlier, if we used multiple connectors, then all connectors would * have the same controlling framebuffer so the output would be cloned. This is * most often not what you want so we avoid explaining this feature here. * Furthermore, all connectors will have to run with the same mode, which is * also often not guaranteed. So instead, we only use one connector per CRTC. * * Before calling drmModeSetCrtc() we also save the current CRTC configuration. * This is used in modeset_cleanup() to restore the CRTC to the same mode as was * before we changed it. * If we don't do this, the screen will stay blank after we exit until another * application performs modesetting itself. */ int main(int argc, char **argv) { int ret, fd; const char *card; struct modeset_dev *iter; /* 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); ret = drmModeSetCrtc(fd, iter->crtc, iter->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; } /* * 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 crtc_lut(int fd, struct modeset_dev *dev, int p) { struct drm_mode_crtc_lut clut; uint16_t r[256]; uint16_t g[256]; uint16_t b[256]; int ret; int i; /* prepare buffer for memory mapping */ memset(&clut, 0, sizeof(clut)); clut.crtc_id = dev->crtc; clut.gamma_size = 256; clut.red = (uint64_t)r; clut.green = (uint64_t)g; clut.blue = (uint64_t)b; for (i = 0; i < 256; ++i) { r[i] = ((p + 2 * i) & 255) * 257; g[i] = ((p + 3 * i) & 255) * 257; b[i] = ((p + 5 * i) & 255) * 257; } ret = drmIoctl(fd, DRM_IOCTL_MODE_SETGAMMA, &clut); if (ret) fprintf(stderr, "cannot set gamma lut (%d): %m\n", errno); } /* * modeset_draw(): This draws a solid color into all configured framebuffers. * Every 100ms the color changes to a slightly different color so we get some * kind of smoothly changing color-gradient. * * The color calculation can be ignored as it is pretty boring. So the * interesting stuff is iterating over "modeset_list" and then through all lines * and width. We then set each pixel individually to the current color. * * We do this 50 times as we sleep 100ms after each redraw round. This makes * 50*100ms = 5000ms = 5s so it takes about 5seconds to finish this loop. * * Please note that we draw directly into the framebuffer. This means that you * will see flickering as the monitor might refresh while we redraw the screen. * To avoid this you would need to use two framebuffers and a call to * drmModeSetCrtc() to switch between both buffers. * You can also use drmModePageFlip() to do a vsync'ed pageflip. But this is * beyond the scope of this document. */ static void modeset_draw(int fd) { uint8_t p = 0; unsigned int i, j, k; struct modeset_dev *iter; for (iter = modeset_list; iter; iter = iter->next) { for (k = 0; k < iter->width; ++k) { for (j = 0; j < iter->height / 3; ++j) { iter->map[iter->stride * j + k] = k * 256 / iter->width; } for (; j < iter->height; ++j) iter->map[iter->stride * j + k] = 26; } } for (i = 0; i < 50; ++i, ++p) { for (iter = modeset_list; iter; iter = iter->next) crtc_lut(fd, iter, p); usleep(100000); } } /* * modeset_cleanup(fd): This cleans up all the devices we created during * modeset_prepare(). It resets the CRTCs to their saved states and deallocates * all memory. * It should be pretty obvious how all of this works. */ static void modeset_cleanup(int fd) { struct modeset_dev *iter; struct drm_mode_destroy_dumb dreq; while (modeset_list) { /* remove from global list */ iter = modeset_list; modeset_list = iter->next; /* restore saved CRTC configuration */ 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); /* unmap buffer */ munmap(iter->map, iter->size); /* delete framebuffer */ drmModeRmFB(fd, iter->fb); /* delete dumb buffer */ memset(&dreq, 0, sizeof(dreq)); dreq.handle = iter->handle; drmIoctl(fd, DRM_IOCTL_MODE_DESTROY_DUMB, &dreq); /* free allocated memory */ free(iter); } } /* * I hope this was a short but easy overview of the DRM modesetting API. The DRM * API offers much more capabilities including: * - double-buffering or tripple-buffering (or whatever you want) * - vsync'ed page-flips * - hardware-accelerated rendering (for example via OpenGL) * - output cloning * - graphics-clients plus authentication * - DRM planes/overlays/sprites * - ... * If you are interested in these topics, I can currently only redirect you to * existing implementations, including: * - plymouth (which uses dumb-buffers like this example; very easy to understand) * - kmscon (which uses libuterm to do this) * - wayland (very sophisticated DRM renderer; hard to understand fully as it * uses more complicated techniques like DRM planes) * - xserver (very hard to understand as it is split across many files/projects) * * But understanding how modesetting (as described in this document) works, is * essential to understand all further DRM topics. * * Any feedback is welcome. Feel free to use this code freely for your own * documentation or projects. * * - Hosted on http://github.com/dvdhrm/docs * - Written by David Herrmann <dh.herrmann@xxxxxxxxxxxxxx> */ ----------------8<--------------- Peter Rosin (3): drm: atmel-hlcdc: add support for 8-bit color lookup table mode drm/fb-cma-helper: expose more of fb cma guts drm: atmel-hlcdc: add clut support for legacy fbdev drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_crtc.c | 58 +++++++++++++++++++++++++ drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_dc.c | 25 ++++++++++- drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_dc.h | 20 +++++++++ drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_plane.c | 29 +++++++++++++ drivers/gpu/drm/drm_fb_cma_helper.c | 55 ++++++++++++++++++----- include/drm/drm_fb_cma_helper.h | 8 +++- 6 files changed, 182 insertions(+), 13 deletions(-) -- 2.1.4 _______________________________________________ dri-devel mailing list dri-devel@xxxxxxxxxxxxxxxxxxxxx https://lists.freedesktop.org/mailman/listinfo/dri-devel
