Index: GIDs =================================================================== --- GIDs +++ GIDs @@ -801,7 +801,7 @@ # free: 857 # free: 858 # free: 859 -# free: 860 +weston-launch:*:860: # free: 861 # free: 862 # free: 863 Index: graphics/wayland/Makefile =================================================================== --- graphics/wayland/Makefile +++ graphics/wayland/Makefile @@ -19,7 +19,7 @@ # and keep diff with upstream minimal. PORTNAME= wayland -PORTVERSION= 1.12.0 +PORTVERSION= 1.13.0 CATEGORIES= graphics wayland MASTER_SITES= http://wayland.freedesktop.org/releases/ Index: graphics/wayland/distinfo =================================================================== --- graphics/wayland/distinfo +++ graphics/wayland/distinfo @@ -1,3 +1,3 @@ -TIMESTAMP = 1481659324 -SHA256 (wayland-1.12.0.tar.xz) = d6b4135cba0188abcb7275513c72dede751d6194f6edc5b82183a3ba8b821ab1 -SIZE (wayland-1.12.0.tar.xz) = 379520 +TIMESTAMP = 1493798580 +SHA256 (wayland-1.13.0.tar.xz) = 69b052c031a61e89af7cc8780893d0da1e301492352aa449dee9345043e6fe51 +SIZE (wayland-1.13.0.tar.xz) = 414508 Index: graphics/wayland/files/patch-Makefile.am =================================================================== --- graphics/wayland/files/patch-Makefile.am +++ graphics/wayland/files/patch-Makefile.am @@ -1,4 +1,4 @@ ---- Makefile.am.orig 2016-02-29 23:30:58 UTC +--- Makefile.am.orig 2017-05-03 08:03:42 UTC +++ Makefile.am @@ -73,7 +73,7 @@ nodist_include_HEADERS = \ protocol/wayland-client-protocol.h @@ -18,7 +18,7 @@ libwayland_client_la_LDFLAGS = -version-info 3:0:3 libwayland_client_la_SOURCES = \ src/wayland-client.c -@@ -186,7 +186,7 @@ libtest_runner_la_LIBADD = \ +@@ -198,7 +198,7 @@ libtest_runner_la_LIBADD = \ libwayland-util.la \ libwayland-client.la \ libwayland-server.la \ Index: graphics/wayland/files/patch-src_wayland-server.c =================================================================== --- graphics/wayland/files/patch-src_wayland-server.c +++ graphics/wayland/files/patch-src_wayland-server.c @@ -1,5 +1,5 @@ ---- src/wayland-server.c.orig 2016-09-20 17:33:11.000000000 +0000 -+++ src/wayland-server.c 2016-12-13 20:07:06.878000000 +0000 +--- src/wayland-server.c.orig 2017-02-07 22:59:06 UTC ++++ src/wayland-server.c @@ -25,6 +25,8 @@ #define _GNU_SOURCE @@ -21,21 +21,22 @@ #include "wayland-util.h" #include "wayland-private.h" #include "wayland-server.h" -@@ -79,7 +86,13 @@ +@@ -79,7 +86,13 @@ struct wl_client { struct wl_list link; struct wl_map objects; - struct wl_signal destroy_signal; + struct wl_priv_signal destroy_signal; +- struct ucred ucred; +#ifdef HAVE_SYS_UCRED_H + /* FreeBSD */ + struct xucred xucred; +#else + /* Linux */ - struct ucred ucred; ++ struct ucred ucred; +#endif int error; - struct wl_signal resource_created_signal; + struct wl_priv_signal resource_created_signal; }; -@@ -466,10 +479,20 @@ +@@ -503,10 +516,20 @@ wl_client_create(struct wl_display *disp if (!client->source) goto err_client; @@ -56,7 +57,7 @@ client->connection = wl_connection_create(fd); if (client->connection == NULL) -@@ -523,12 +546,23 @@ +@@ -560,12 +583,23 @@ WL_EXPORT void wl_client_get_credentials(struct wl_client *client, pid_t *pid, uid_t *uid, gid_t *gid) { Index: x11-wm/Makefile =================================================================== --- x11-wm/Makefile +++ x11-wm/Makefile @@ -120,6 +120,7 @@ SUBDIR += vtwm SUBDIR += w9wm SUBDIR += weewm + SUBDIR += weston SUBDIR += windowlab SUBDIR += windowmaker SUBDIR += wm2 Index: x11-wm/weston/Makefile =================================================================== --- /dev/null +++ x11-wm/weston/Makefile @@ -0,0 +1,100 @@ +# Created by: Johannes Lundberg +# $FreeBSD$ + +PORTNAME= weston +PORTVERSION= 2.0.0 +CATEGORIES= x11-wm wayland +MASTER_SITES= http://wayland.freedesktop.org/releases/ + +MAINTAINER= x11@freebsd.org +COMMENT= Wayland Reference Compositor + +LICENSE= MIT + +BUILD_DEPENDS= wayland-protocols>=1.7:graphics/wayland-protocols +LIB_DEPENDS= \ + libxkbcommon.so:x11/libxkbcommon \ + libpixman-1.so:x11/pixman \ + libcairo.so:graphics/cairo \ + libpango-1.0.so:x11-toolkits/pango \ + libcolord.so:graphics/colord \ + libfontconfig.so:x11-fonts/fontconfig \ + libfreetype.so:print/freetype2 \ + libwayland-server.so:graphics/wayland \ + libwayland-egl.so:graphics/mesa-libs \ + libevent.so:devel/libevent2 \ + libpng.so:graphics/png \ + libwebp.so:graphics/webp \ + libffi.so:devel/libffi \ + libepoll-shim.so:devel/libepoll-shim \ + libudev.so:devel/libudev-devd \ + libunwind.so:devel/libunwind \ + libevdev.so:devel/libevdev \ + libinput.so:x11/libinput \ + libmtdev.so:devel/libmtdev + +USES= autoreconf alias execinfo gmake pathfix jpeg libtool pkgconfig tar:xz localbase:ldflags + +USE_XORG= x11 xcb xcursor +USE_GL= egl gbm glesv2 + +OPTIONS_SUB= yes +OPTIONS_DEFINE= SUID CLIENTS CLIENTS_INSTALL XWAYLAND +OPTIONS_MULTI= COMPOSITORS +OPTIONS_MULTI_COMPOSITORS= X11 DRM WAYLAND SCFB +OPTIONS_SINGLE= CAIRO +OPTIONS_SINGLE_CAIRO= CAIROIMAGE CAIROGL CAIROGLESV2 + +OPTIONS_DEFAULT= SUID CAIROIMAGE CLIENTS CLIENTS_INSTALL XWAYLAND X11 DRM WAYLAND SCFB + +CAIRO_DESC= Cairo backend +CAIROGL_DESC= GL (enabled in cairo by default) +CAIROGLESV2_DESC= GLESv2 (requires cairo built with --enable-glesv2) +CAIROIMAGE_DESC= Image (Recommended) +CLIENTS_DESC= Build Weston clients +CLIENTS_INSTALL_DESC= Install Weston clients +DRM_DESC= Hardware accelerated compositor backend +SCFB_DESC= Software rendered compositor backend +SUID_DESC= Install weston-launch binary with setuid bit set +WAYLAND_DESC= Nested Weston compositors +X11_DESC= Run Weston as X11 client (good for testing) +XWAYLAND_DESC= Support running X clients in Weston + +CAIROIMAGE_CONFIGURE_ON= --with-cairo=image +CAIROGL_CONFIGURE_ON= --with-cairo=gl +CAIROGLESV2_CONFIGURE_ON= --with-cairo=glesv2 --with-cairo-glesv2 +CLIENTS_CONFIGURE_ENABLE= clients +CLIENTS_INSTALL_CONFIGURE_ENABLE= demo-clients-install +DRM_CONFIGURE_ENABLE= drm-compositor +DRM_LIB_DEPENDS= libdrm.so:graphics/libdrm +SCFB_CONFIGURE_ENABLE= scfb-compositor +WAYLAND_CONFIGURE_ENABLE= wayland-compositor +X11_CONFIGURE_ENABLE= x11-compositor +XWAYLAND_CONFIGURE_ENABLE= xwayland + +CPPFLAGS+= -I${LOCALBASE}/include/libepoll-shim + +GROUPS= weston-launch + +GNU_CONFIGURE= YES + +CONFIGURE_ARGS= --enable-weston-launch +CONFIGURE_ARGS+= --disable-fbdev-compositor +CONFIGURE_ARGS+= --disable-vaapi-recorder +CONFIGURE_ARGS+= --disable-xwayland-test + +# We handle setuid in the plist. This allows to build as a user. +CONFIGURE_ARGS+= --disable-setuid-install + +CONFIGURE_ENV+= LIBS="-lepoll-shim -lrt -lEGL" +CONFIGURE_ENV+= EGL_TESTS_LIBS="-lwayland-client -lGLESv2 -lwayland-egl -lwayland-client" +CONFIGURE_ENV+= EGL_TESTS_CFLAGS="-L${STAGEDIR}${PREFIX}/lib -I${STAGEDIR}${PREFIX}/include" + +# Should not have to do this. "make" should find them in $WAYLAND_PROTOCOLS_DATADIR set by automake... +WAYLAND_PROTOCOLS_DATADIR=`pkg-config --variable=pkgdatadir wayland-protocols` +pre-configure: + @cp ${WAYLAND_PROTOCOLS_DATADIR}/stable/*/* ${WRKSRC}/protocol/ + @cp ${WAYLAND_PROTOCOLS_DATADIR}/unstable/*/* ${WRKSRC}/protocol/ + + +.include Index: x11-wm/weston/distinfo =================================================================== --- /dev/null +++ x11-wm/weston/distinfo @@ -0,0 +1,3 @@ +TIMESTAMP = 1493801292 +SHA256 (weston-2.0.0.tar.xz) = b4e446ac27f118196f1609dab89bb3cb3e81652d981414ad860e733b355365d8 +SIZE (weston-2.0.0.tar.xz) = 1272628 Index: x11-wm/weston/files/patch-Makefile.am =================================================================== --- /dev/null +++ x11-wm/weston/files/patch-Makefile.am @@ -0,0 +1,47 @@ +--- Makefile.am.orig 2017-05-03 10:47:21 UTC ++++ Makefile.am +@@ -84,6 +84,7 @@ libweston_@LIBWESTON_MAJOR@_la_SOURCES = + libweston/compositor.h \ + libweston/compositor-drm.h \ + libweston/compositor-fbdev.h \ ++ libweston/compositor-scfb.h \ + libweston/compositor-headless.h \ + libweston/compositor-rdp.h \ + libweston/compositor-wayland.h \ +@@ -284,6 +285,7 @@ libwestoninclude_HEADERS = \ + libweston/compositor.h \ + libweston/compositor-drm.h \ + libweston/compositor-fbdev.h \ ++ libweston/compositor-scfb.h \ + libweston/compositor-headless.h \ + libweston/compositor-rdp.h \ + libweston/compositor-wayland.h \ +@@ -452,6 +454,28 @@ fbdev_backend_la_SOURCES = \ + $(INPUT_BACKEND_SOURCES) + endif + ++if ENABLE_SCFB_COMPOSITOR ++libweston_module_LTLIBRARIES += scfb-backend.la ++scfb_backend_la_LDFLAGS = -module -avoid-version ++scfb_backend_la_LIBADD = \ ++ $(COMPOSITOR_LIBS) \ ++ $(SCFB_COMPOSITOR_LIBS) \ ++ $(INPUT_BACKEND_LIBS) \ ++ libsession-helper.la \ ++ libshared.la ++scfb_backend_la_CFLAGS = \ ++ $(COMPOSITOR_CFLAGS) \ ++ $(EGL_CFLAGS) \ ++ $(SCFB_COMPOSITOR_CFLAGS) \ ++ $(PIXMAN_CFLAGS) \ ++ $(AM_CFLAGS) ++scfb_backend_la_SOURCES = \ ++ libweston/compositor-scfb.c \ ++ libweston/compositor-scfb.h \ ++ shared/helpers.h \ ++ $(INPUT_BACKEND_SOURCES) ++endif ++ + if ENABLE_RDP_COMPOSITOR + libweston_module_LTLIBRARIES += rdp-backend.la + rdp_backend_la_LDFLAGS = -module -avoid-version Index: x11-wm/weston/files/patch-clients_desktop-shell.c =================================================================== --- /dev/null +++ x11-wm/weston/files/patch-clients_desktop-shell.c @@ -0,0 +1,19 @@ +--- clients/desktop-shell.c.orig 2017-01-19 01:41:20 UTC ++++ clients/desktop-shell.c +@@ -41,6 +41,7 @@ + #include + #include + #include ++#include + + #include + #include "window.h" +@@ -50,6 +51,8 @@ + #include "shared/xalloc.h" + #include "shared/zalloc.h" + ++#define program_invocation_short_name getprogname() ++ + #include "weston-desktop-shell-client-protocol.h" + + #define DEFAULT_CLOCK_FORMAT CLOCK_FORMAT_MINUTES Index: x11-wm/weston/files/patch-clients_screenshot.c =================================================================== --- /dev/null +++ x11-wm/weston/files/patch-clients_screenshot.c @@ -0,0 +1,11 @@ +--- clients/screenshot.c.orig 2016-08-10 22:56:50 UTC ++++ clients/screenshot.c +@@ -40,6 +40,8 @@ + #include "shared/os-compatibility.h" + #include "shared/xalloc.h" + ++#define program_invocation_short_name getprogname() ++ + /* The screenshooter is a good example of a custom object exposed by + * the compositor and serves as a test bed for implementing client + * side marshalling outside libwayland.so */ Index: x11-wm/weston/files/patch-clients_terminal.c =================================================================== --- /dev/null +++ x11-wm/weston/files/patch-clients_terminal.c @@ -0,0 +1,24 @@ +--- clients/terminal.c.orig 2016-11-21 17:00:30 UTC ++++ clients/terminal.c +@@ -32,7 +32,11 @@ + #include + #include + #include +-#include ++/* #include */ ++#include ++#include ++#include ++#include + #include + #include + #include +@@ -3075,7 +3079,7 @@ int main(int argc, char *argv[]) + + option_shell = getenv("SHELL"); + if (!option_shell) +- option_shell = "/bin/bash"; ++ option_shell = "/bin/sh"; + + config_file = weston_config_get_name_from_env(); + config = weston_config_parse(config_file); Index: x11-wm/weston/files/patch-clients_weston-info.c =================================================================== --- /dev/null +++ x11-wm/weston/files/patch-clients_weston-info.c @@ -0,0 +1,15 @@ +--- clients/weston-info.c.orig 2016-10-22 16:23:57 UTC ++++ clients/weston-info.c +@@ -578,9 +578,9 @@ clock_name(clockid_t clk_id) + static const char *names[] = { + [CLOCK_REALTIME] = "CLOCK_REALTIME", + [CLOCK_MONOTONIC] = "CLOCK_MONOTONIC", +- [CLOCK_MONOTONIC_RAW] = "CLOCK_MONOTONIC_RAW", +- [CLOCK_REALTIME_COARSE] = "CLOCK_REALTIME_COARSE", +- [CLOCK_MONOTONIC_COARSE] = "CLOCK_MONOTONIC_COARSE", ++ /* [CLOCK_MONOTONIC_RAW] = "CLOCK_MONOTONIC_RAW", */ ++ /* [CLOCK_REALTIME_COARSE] = "CLOCK_REALTIME_COARSE", */ ++ /* [CLOCK_MONOTONIC_COARSE] = "CLOCK_MONOTONIC_COARSE", */ + #ifdef CLOCK_BOOTTIME + [CLOCK_BOOTTIME] = "CLOCK_BOOTTIME", + #endif Index: x11-wm/weston/files/patch-compositor_main.c =================================================================== --- /dev/null +++ x11-wm/weston/files/patch-compositor_main.c @@ -0,0 +1,126 @@ +--- compositor/main.c.orig 2017-02-14 20:59:07 UTC ++++ compositor/main.c +@@ -41,7 +41,9 @@ + #include + #include + #include +-#include ++/* #include */ ++#include ++#define PATH_MAX _POSIX_PATH_MAX + + #ifdef HAVE_LIBUNWIND + #define UNW_LOCAL_ONLY +@@ -61,6 +63,7 @@ + #include "compositor-headless.h" + #include "compositor-rdp.h" + #include "compositor-fbdev.h" ++#include "compositor-scfb.h" + #include "compositor-x11.h" + #include "compositor-wayland.h" + #include "windowed-output-api.h" +@@ -538,6 +541,9 @@ usage(int error_code) + #if defined(BUILD_FBDEV_COMPOSITOR) + "\t\t\t\tfbdev-backend.so\n" + #endif ++#if defined(BUILD_SCFB_COMPOSITOR) ++ "\t\t\t\tscfb-backend.so\n" ++#endif + #if defined(BUILD_HEADLESS_COMPOSITOR) + "\t\t\t\theadless-backend.so\n" + #endif +@@ -577,6 +583,14 @@ usage(int error_code) + "\n"); + #endif + ++#if defined(BUILD_SCFB_COMPOSITOR) ++ fprintf(stderr, ++ "Options for scfb-backend.so:\n\n" ++ " --tty=TTY\t\tThe tty to use\n" ++ " --device=DEVICE\tThe framebuffer device to use\n" ++ "\n"); ++#endif ++ + #if defined(BUILD_HEADLESS_COMPOSITOR) + fprintf(stderr, + "Options for headless-backend.so:\n\n" +@@ -680,9 +694,9 @@ clock_name(clockid_t clk_id) + static const char *names[] = { + [CLOCK_REALTIME] = "CLOCK_REALTIME", + [CLOCK_MONOTONIC] = "CLOCK_MONOTONIC", +- [CLOCK_MONOTONIC_RAW] = "CLOCK_MONOTONIC_RAW", +- [CLOCK_REALTIME_COARSE] = "CLOCK_REALTIME_COARSE", +- [CLOCK_MONOTONIC_COARSE] = "CLOCK_MONOTONIC_COARSE", ++ /* [CLOCK_MONOTONIC_RAW] = "CLOCK_MONOTONIC_RAW", */ ++ /* [CLOCK_REALTIME_COARSE] = "CLOCK_REALTIME_COARSE", */ ++ /* [CLOCK_MONOTONIC_COARSE] = "CLOCK_MONOTONIC_COARSE", */ + #ifdef CLOCK_BOOTTIME + [CLOCK_BOOTTIME] = "CLOCK_BOOTTIME", + #endif +@@ -1577,6 +1591,57 @@ load_x11_backend(struct weston_composito + } + + static void ++scfb_backend_output_configure(struct wl_listener *listener, void *data) ++{ ++ struct weston_output *output = data; ++ struct weston_config *wc = wet_get_config(output->compositor); ++ struct weston_config_section *section; ++ ++ section = weston_config_get_section(wc, "output", "name", "scfb"); ++ ++ wet_output_set_transform(output, section, WL_OUTPUT_TRANSFORM_NORMAL, UINT32_MAX); ++ weston_output_set_scale(output, 1); ++ ++ weston_output_enable(output); ++} ++ ++static int ++load_scfb_backend(struct weston_compositor *c, ++ int *argc, char **argv, struct weston_config *wc) ++{ ++ struct weston_scfb_backend_config config = {{ 0, }}; ++ int ret = 0; ++ ++ const struct weston_option scfb_options[] = { ++ { WESTON_OPTION_INTEGER, "tty", 0, &config.tty }, ++ { WESTON_OPTION_STRING, "device", 0, &config.device }, ++ }; ++ ++ parse_options(scfb_options, ARRAY_LENGTH(scfb_options), argc, argv); ++ ++ if (!config.device) ++ config.device = strdup("/dev/ttyv1"); ++ ++ config.base.struct_version = WESTON_SCFB_BACKEND_CONFIG_VERSION; ++ config.base.struct_size = sizeof(struct weston_scfb_backend_config); ++ config.configure_device = configure_input_device; ++ ++ /* load the actual wayland backend and configure it */ ++ ret = weston_compositor_load_backend(c, WESTON_BACKEND_SCFB, ++ &config.base); ++ ++ if (ret < 0) ++ goto out; ++ ++ wet_set_pending_output_handler(c, scfb_backend_output_configure); ++ ++out: ++ free(config.device); ++ return ret; ++ ++} ++ ++static void + wayland_backend_output_configure_hotplug(struct wl_listener *listener, void *data) + { + struct weston_output *output = data; +@@ -1722,6 +1787,8 @@ load_backend(struct weston_compositor *c + return load_rdp_backend(compositor, argc, argv, config); + else if (strstr(backend, "fbdev-backend.so")) + return load_fbdev_backend(compositor, argc, argv, config); ++ else if (strstr(backend, "scfb-backend.so")) ++ return load_scfb_backend(compositor, argc, argv, config); + else if (strstr(backend, "drm-backend.so")) + return load_drm_backend(compositor, argc, argv, config); + else if (strstr(backend, "x11-backend.so")) Index: x11-wm/weston/files/patch-configure.ac =================================================================== --- /dev/null +++ x11-wm/weston/files/patch-configure.ac @@ -0,0 +1,28 @@ +--- configure.ac.orig 2017-02-24 23:44:18 UTC ++++ configure.ac +@@ -251,6 +251,17 @@ AS_IF([test x$enable_fbdev_compositor = + PKG_CHECK_MODULES([FBDEV_COMPOSITOR], [libudev >= 136 mtdev >= 1.1.0]) + ]) + ++ ++AC_ARG_ENABLE([scfb-compositor], [ --enable-scfb-compositor],, ++ enable_scfb_compositor=yes) ++AM_CONDITIONAL([ENABLE_SCFB_COMPOSITOR], ++ [test x$enable_scfb_compositor = xyes]) ++AS_IF([test x$enable_scfb_compositor = xyes], [ ++ AC_DEFINE([BUILD_SCFB_COMPOSITOR], [1], [Build the scfb compositor]) ++ PKG_CHECK_MODULES([SCFB_COMPOSITOR], [libudev >= 136 mtdev >= 1.1.0]) ++]) ++ ++ + AC_ARG_ENABLE([rdp-compositor], [ --enable-rdp-compositor],, + enable_rdp_compositor=no) + AM_CONDITIONAL([ENABLE_RDP_COMPOSITOR], +@@ -707,6 +718,7 @@ AC_MSG_RESULT([ + Wayland Compositor ${enable_wayland_compositor} + Headless Compositor ${enable_headless_compositor} + FBDEV Compositor ${enable_fbdev_compositor} ++ SCFB Compositor ${enable_scfb_compositor} + RDP Compositor ${enable_rdp_compositor} + Screen Sharing ${enable_screen_sharing} + JUnit XML output ${enable_junit_xml} Index: x11-wm/weston/files/patch-libweston_compositor-drm.c =================================================================== --- /dev/null +++ x11-wm/weston/files/patch-libweston_compositor-drm.c @@ -0,0 +1,96 @@ +--- libweston/compositor-drm.c.orig 2017-02-14 20:59:07 UTC ++++ libweston/compositor-drm.c +@@ -34,7 +34,7 @@ + #include + #include + #include +-#include ++//#include + #include + #include + #include +@@ -2956,44 +2956,50 @@ find_primary_gpu(struct drm_backend *b, + struct udev_device *device, *drm_device, *pci; + + e = udev_enumerate_new(b->udev); +- udev_enumerate_add_match_subsystem(e, "drm"); +- udev_enumerate_add_match_sysname(e, "card[0-9]*"); + +- udev_enumerate_scan_devices(e); +- drm_device = NULL; +- udev_list_entry_foreach(entry, udev_enumerate_get_list_entry(e)) { +- path = udev_list_entry_get_name(entry); +- device = udev_device_new_from_syspath(b->udev, path); +- if (!device) +- continue; +- device_seat = udev_device_get_property_value(device, "ID_SEAT"); +- if (!device_seat) +- device_seat = default_seat; +- if (strcmp(device_seat, seat)) { +- udev_device_unref(device); +- continue; +- } ++ // libudev-devd don't support matching properly yet ++ device = udev_device_new_from_syspath(e, "/dev/dri/card0"); ++ return device; + +- pci = udev_device_get_parent_with_subsystem_devtype(device, +- "pci", NULL); +- if (pci) { +- id = udev_device_get_sysattr_value(pci, "boot_vga"); +- if (id && !strcmp(id, "1")) { +- if (drm_device) +- udev_device_unref(drm_device); +- drm_device = device; +- break; +- } +- } ++ /* udev_enumerate_add_match_subsystem(e, "drm"); */ ++ /* udev_enumerate_add_match_sysname(e, "card0"); */ + +- if (!drm_device) +- drm_device = device; +- else +- udev_device_unref(device); +- } ++ /* udev_enumerate_scan_devices(e); */ ++ /* drm_device = NULL; */ ++ /* udev_list_entry_foreach(entry, udev_enumerate_get_list_entry(e)) { */ ++ /* path = udev_list_entry_get_name(entry); */ ++ /* printf("udev iterate got path %s\n",path); */ ++ /* device = udev_device_new_from_syspath(b->udev, path); */ ++ /* if (!device) */ ++ /* continue; */ ++ /* device_seat = udev_device_get_property_value(device, "ID_SEAT"); */ ++ /* if (!device_seat) */ ++ /* device_seat = default_seat; */ ++ /* if (strcmp(device_seat, seat)) { */ ++ /* udev_device_unref(device); */ ++ /* continue; */ ++ /* } */ + +- udev_enumerate_unref(e); +- return drm_device; ++ /* pci = udev_device_get_parent_with_subsystem_devtype(device, */ ++ /* "pci", NULL); */ ++ /* if (pci) { */ ++ /* id = udev_device_get_sysattr_value(pci, "boot_vga"); */ ++ /* if (id && !strcmp(id, "1")) { */ ++ /* if (drm_device) */ ++ /* udev_device_unref(drm_device); */ ++ /* drm_device = device; */ ++ /* break; */ ++ /* } */ ++ /* } */ ++ ++ /* if (!drm_device) */ ++ /* drm_device = device; */ ++ /* else */ ++ /* udev_device_unref(device); */ ++ /* } */ ++ ++ /* udev_enumerate_unref(e); */ ++ /* return drm_device; */ + } + + static void Index: x11-wm/weston/files/patch-libweston_compositor-scfb.h =================================================================== --- /dev/null +++ x11-wm/weston/files/patch-libweston_compositor-scfb.h @@ -0,0 +1,64 @@ +--- libweston/compositor-scfb.h.orig 2017-05-03 10:47:21 UTC ++++ libweston/compositor-scfb.h +@@ -0,0 +1,61 @@ ++/* ++ * Copyright © 2016 Benoit Gschwind ++ * ++ * 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 (including the ++ * next paragraph) 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. ++ */ ++ ++#ifndef WESTON_COMPOSITOR_SCFB_H ++#define WESTON_COMPOSITOR_SCFB_H ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++#include ++ ++#include "compositor.h" ++ ++#define WESTON_SCFB_BACKEND_CONFIG_VERSION 2 ++ ++struct libinput_device; ++ ++struct weston_scfb_backend_config { ++ struct weston_backend_config base; ++ ++ int tty; ++ char *device; ++ ++ /** Callback used to configure input devices. ++ * ++ * This function will be called by the backend when a new input device ++ * needs to be configured. ++ * If NULL the device will use the default configuration. ++ */ ++ void (*configure_device)(struct weston_compositor *compositor, ++ struct libinput_device *device); ++}; ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif /* WESTON_COMPOSITOR_SCFB_H */ Index: x11-wm/weston/files/patch-libweston_compositor-scfb.c =================================================================== --- /dev/null +++ x11-wm/weston/files/patch-libweston_compositor-scfb.c @@ -0,0 +1,835 @@ +--- libweston/compositor-scfb.c.orig 2017-05-03 10:47:21 UTC ++++ libweston/compositor-scfb.c +@@ -0,0 +1,832 @@ ++/* ++ * Copyright © 2008-2011 Kristian Høgsberg ++ * Copyright © 2011 Intel Corporation ++ * Copyright © 2012 Raspberry Pi Foundation ++ * Copyright © 2013 Philip Withnall ++ * ++ * 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 (including the ++ * next paragraph) 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. ++ */ ++ ++#include "config.h" ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#include ++ ++#include ++ ++#include "shared/helpers.h" ++#include "compositor.h" ++#include "compositor-scfb.h" ++#include "launcher-util.h" ++#include "pixman-renderer.h" ++#include "libinput-seat.h" ++#include "presentation-time-server-protocol.h" ++ ++struct scfb_backend { ++ struct weston_backend base; ++ struct weston_compositor *compositor; ++ uint32_t prev_state; ++ ++ struct udev *udev; ++ struct udev_input input; ++ uint32_t output_transform; ++ struct wl_listener session_listener; ++}; ++ ++struct scfb_screeninfo { ++ unsigned int x_resolution; /* pixels, visible area */ ++ unsigned int y_resolution; /* pixels, visible area */ ++ unsigned int width_mm; /* visible screen width in mm */ ++ unsigned int height_mm; /* visible screen height in mm */ ++ unsigned int bits_per_pixel; ++ ++ size_t buffer_length; /* length of frame buffer memory in bytes */ ++ size_t line_length; /* length of a line in bytes */ ++ char id[16]; /* screen identifier */ ++ ++ pixman_format_code_t pixel_format; /* frame buffer pixel format */ ++ unsigned int refresh_rate; /* Hertz */ ++}; ++ ++struct scfb_output { ++ struct scfb_backend *backend; ++ struct weston_output base; ++ ++ struct weston_mode mode; ++ struct wl_event_source *finish_frame_timer; ++ ++ /* Frame buffer details. */ ++ char *device; ++ struct scfb_screeninfo fb_info; ++ void *fb; /* length is fb_info.buffer_length */ ++ ++ /* pixman details. */ ++ pixman_image_t *hw_surface; ++ uint8_t depth; ++}; ++ ++static const char default_seat[] = "seat0"; ++ ++static inline struct scfb_output * ++to_scfb_output(struct weston_output *base) ++{ ++ return container_of(base, struct scfb_output, base); ++} ++ ++static inline struct scfb_backend * ++to_scfb_backend(struct weston_compositor *base) ++{ ++ return container_of(base->backend, struct scfb_backend, base); ++} ++ ++static void ++scfb_output_start_repaint_loop(struct weston_output *output) ++{ ++ struct timespec ts; ++ ++ weston_compositor_read_presentation_clock(output->compositor, &ts); ++ weston_output_finish_frame(output, &ts, WP_PRESENTATION_FEEDBACK_INVALID); ++} ++ ++static int ++scfb_output_repaint(struct weston_output *base, pixman_region32_t *damage) ++{ ++ struct scfb_output *output = to_scfb_output(base); ++ struct weston_compositor *ec = output->base.compositor; ++ ++ /* Repaint the damaged region onto the back buffer. */ ++ pixman_renderer_output_set_buffer(base, output->hw_surface); ++ ec->renderer->repaint_output(base, damage); ++ ++ /* Update the damage region. */ ++ pixman_region32_subtract(&ec->primary_plane.damage, ++ &ec->primary_plane.damage, damage); ++ ++ /* Schedule the end of the frame. We do not sync this to the frame ++ * buffer clock because users who want that should be using the DRM ++ * compositor. FBIO_WAITFORVSYNC blocks and FB_ACTIVATE_VBL requires ++ * panning, which is broken in most kernel drivers. ++ * ++ * Finish the frame synchronised to the specified refresh rate. The ++ * refresh rate is given in mHz and the interval in ms. */ ++ wl_event_source_timer_update(output->finish_frame_timer, ++ 1000000 / output->mode.refresh); ++ ++ return 0; ++} ++ ++static int ++finish_frame_handler(void *data) ++{ ++ struct scfb_output *output = data; ++ struct timespec ts; ++ ++ weston_compositor_read_presentation_clock(output->base.compositor, &ts); ++ weston_output_finish_frame(&output->base, &ts, 0); ++ ++ return 1; ++} ++ ++static pixman_format_code_t ++calculate_pixman_format(struct fbtype *fb) ++{ ++ /* Calculate the pixman format supported by the frame buffer from the ++ * buffer's metadata. Return 0 if no known pixman format is supported ++ * (since this has depth 0 it's guaranteed to not conflict with any ++ * actual pixman format). ++ * ++ * Documentation on the vinfo and finfo structures: ++ * http://www.mjmwired.net/kernel/Documentation/fb/api.txt ++ * ++ * TODO: Try a bit harder to support other formats, including setting ++ * the preferred format in the hardware. */ ++ int type; ++ ++ /* weston_log("Calculating pixman format from:\n" */ ++ /* STAMP_SPACE " - type: %i (aux: %i)\n" */ ++ /* STAMP_SPACE " - visual: %i\n" */ ++ /* STAMP_SPACE " - bpp: %i (grayscale: %i)\n" */ ++ /* STAMP_SPACE " - red: offset: %i, length: %i, MSB: %i\n" */ ++ /* STAMP_SPACE " - green: offset: %i, length: %i, MSB: %i\n" */ ++ /* STAMP_SPACE " - blue: offset: %i, length: %i, MSB: %i\n" */ ++ /* STAMP_SPACE " - transp: offset: %i, length: %i, MSB: %i\n", */ ++ /* finfo->type, finfo->type_aux, finfo->visual, */ ++ /* vinfo->bits_per_pixel, vinfo->grayscale, */ ++ /* vinfo->red.offset, vinfo->red.length, vinfo->red.msb_right, */ ++ /* vinfo->green.offset, vinfo->green.length, */ ++ /* vinfo->green.msb_right, */ ++ /* vinfo->blue.offset, vinfo->blue.length, */ ++ /* vinfo->blue.msb_right, */ ++ /* vinfo->transp.offset, vinfo->transp.length, */ ++ /* vinfo->transp.msb_right); */ ++ ++ /* We only handle packed formats at the moment. */ ++ /* if (vinfo->vi_mem_model != V_INFO_MM_PACKED) { */ ++ /* weston_log("[scfb %s] Error! Only packed format supported\n", */ ++ /* __func__); */ ++ /* return 0; */ ++ /* } */ ++ ++ /* /\* We only handle true-colour frame buffers at the moment. *\/ */ ++ /* switch(finfo->visual) { */ ++ /* case FB_VISUAL_TRUECOLOR: */ ++ /* case FB_VISUAL_DIRECTCOLOR: */ ++ /* if (vinfo->grayscale != 0) */ ++ /* return 0; */ ++ /* break; */ ++ /* default: */ ++ /* return 0; */ ++ /* } */ ++ ++ /* We only support formats with MSBs on the left. */ ++ /* if (vinfo->red.msb_right != 0 || vinfo->green.msb_right != 0 || */ ++ /* vinfo->blue.msb_right != 0) */ ++ /* return 0; */ ++ ++ /* Work out the format type from the offsets. We only support RGBA and ++ * ARGB at the moment. */ ++ /* type = PIXMAN_TYPE_OTHER; */ ++ ++ /* if ((vinfo->transp.offset >= vinfo->red.offset || */ ++ /* vinfo->transp.length == 0) && */ ++ /* vinfo->red.offset >= vinfo->green.offset && */ ++ /* vinfo->green.offset >= vinfo->blue.offset) */ ++ /* type = PIXMAN_TYPE_ARGB; */ ++ /* else if (vinfo->red.offset >= vinfo->green.offset && */ ++ /* vinfo->green.offset >= vinfo->blue.offset && */ ++ /* vinfo->blue.offset >= vinfo->transp.offset) */ ++ ++ type = PIXMAN_TYPE_ARGB; ++ ++ /* if (type == PIXMAN_TYPE_OTHER) */ ++ /* return 0; */ ++ ++ /* Build the format. */ ++ return PIXMAN_FORMAT(fb->fb_depth, type, ++ fb->fb_depth/4, ++ fb->fb_depth/4, ++ fb->fb_depth/4, ++ fb->fb_depth/4); ++} ++ ++ ++static int ++calculate_refresh_rate(struct fbtype *fb) ++{ ++ /* uint64_t quot; */ ++ ++ /* /\* Calculate monitor refresh rate. Default is 60 Hz. Units are mHz. *\/ */ ++ /* quot = (vinfo->upper_margin + vinfo->lower_margin + vinfo->yres); */ ++ /* quot *= (vinfo->left_margin + vinfo->right_margin + vinfo->xres); */ ++ /* quot *= vinfo->pixclock; */ ++ ++ /* if (quot > 0) { */ ++ /* uint64_t refresh_rate; */ ++ ++ /* refresh_rate = 1000000000000000LLU / quot; */ ++ /* if (refresh_rate > 200000) */ ++ /* refresh_rate = 200000; /\* cap at 200 Hz *\/ */ ++ ++ /* return refresh_rate; */ ++ /* } */ ++ ++ return 60 * 1000; /* default to 60 Hz */ ++} ++ ++static int ++scfb_query_screen_info(struct scfb_output *output, int fd, ++ struct scfb_screeninfo *info) ++{ ++ weston_log("[scfb %s] fd %d\n",__func__,fd); ++ ++ struct fbtype fb; ++ /* struct video_info vinfo; */ ++ /* struct video_color_palette vpalette; */ ++ uint32_t linewidth; ++ ++ if (ioctl(fd, FBIOGTYPE, &fb) == -1) { ++ weston_log("Failed to get FBIOTYPE: %s\n", strerror(errno)); ++ return -1; ++ } ++ ++ /* if (ioctl(fd, FBIO_GETPALETTE, &vpalette) == -1) { */ ++ /* weston_log("Failed to get FBIO_GETPALETTE: %s\n", strerror(errno)); */ ++ /* return -1; */ ++ /* } */ ++ ++ /* if (ioctl(fd, FBIO_GETLINEWIDTH, &linewidth) == -1) { */ ++ /* weston_log("Failed to get FBIO_GETLINEWIDTH: %s\n", strerror(errno)); */ ++ /* return -1; */ ++ /* } */ ++ ++ /* if (ioctl(fd, FBIO_MODEINFO, &vinfo) == -1) { */ ++ /* weston_log("Failed to get FBIO_MODEINFO: %s\n", strerror(errno)); */ ++ /* return -1; */ ++ /* } */ ++ ++ linewidth = fb.fb_size / fb.fb_height; ++ ++ weston_log("[scfb %s]: width %d px\n", __func__, fb.fb_width); ++ weston_log("[scfb %s]: height %d px\n", __func__, fb.fb_height); ++ weston_log("[scfb %s]: depth %d bits per pixel\n", __func__, fb.fb_depth); ++ weston_log("[scfb %s]: size %d bytes\n", __func__, fb.fb_size); ++ weston_log("[scfb %s]: linewidth %d bytes\n", __func__, linewidth); ++ /* weston_log("[scfb %s]: palette c %d\n", __func__, vpalette.count); */ ++ /* weston_log("[scfb %s]: palette r %d\n", __func__, *vpalette.red); */ ++ /* weston_log("[scfb %s]: palette g %d\n", __func__, *vpalette.blue); */ ++ /* weston_log("[scfb %s]: palette b %d\n", __func__, *vpalette.green); */ ++ /* weston_log("[scfb %s]: palette a %d\n", __func__, *vpalette.transparent); */ ++ ++ info->x_resolution = fb.fb_width; ++ info->y_resolution = fb.fb_height; ++ info->width_mm = 0; ++ info->height_mm = 0; ++ info->bits_per_pixel = fb.fb_depth; ++ info->buffer_length = fb.fb_size; ++ info->line_length = linewidth; ++ ++ const char *id = "scfb"; ++ strncpy(info->id, id, sizeof(info->id)); ++ info->id[sizeof(info->id)-1] = '\0'; ++ ++ info->pixel_format = calculate_pixman_format(&fb); ++ info->refresh_rate = calculate_refresh_rate(&fb); ++ ++ if (info->pixel_format == 0) { ++ weston_log("Frame buffer uses an unsupported format.\n"); ++ return -1; ++ } ++ ++ return 1; ++} ++ ++static int ++scfb_set_screen_info(struct scfb_output *output, int fd, ++ struct scfb_screeninfo *info) ++{ ++ weston_log("[scfb %s] Changing video info is unsupported\n",__func__); ++ return 1; ++} ++ ++static void scfb_frame_buffer_destroy(struct scfb_output *output); ++ ++/* Returns an FD for the frame buffer device. */ ++static int ++scfb_frame_buffer_open(struct scfb_output *output, const char *fb_dev, ++ struct scfb_screeninfo *screen_info) ++{ ++ weston_log("[scfb %s] fb_dev %s\n",__func__,fb_dev); ++ ++ int fd = -1; ++ ++ /* weston_log("Opening scfb frame buffer.\n"); */ ++ ++ /* Open the frame buffer device. */ ++ fd = open(fb_dev, O_RDWR | O_CLOEXEC); ++ if (fd < 0) { ++ weston_log("Failed to open frame buffer device ‘%s’: %s\n", ++ fb_dev, strerror(errno)); ++ return -1; ++ } ++ ++ /* Grab the screen info. */ ++ if (scfb_query_screen_info(output, fd, screen_info) < 0) { ++ weston_log("Failed to get frame buffer info: %s\n", ++ strerror(errno)); ++ ++ close(fd); ++ return -1; ++ } ++ ++ return fd; ++} ++ ++/* Map the framebuffer's memory. */ ++static void* ++scfb_mmap(size_t len, off_t off, int fd) ++{ ++ int pagemask, mapsize; ++ caddr_t addr; ++ void *mapaddr; ++ ++ pagemask = getpagesize() - 1; ++ mapsize = ((int) len + pagemask) & ~pagemask; ++ addr = 0; ++ /* Make it write only because read is slow (from fbdev backend) */ ++ mapaddr = mmap(addr, mapsize, PROT_WRITE, MAP_SHARED, fd, off); ++ ++ weston_log("[scfb %s] mmap returns: addr %p len 0x%x, fd %d, off %lx\n", ++ __func__, mapaddr, mapsize, fd, off); ++ return mapaddr; ++} ++ ++/* Closes the FD on success or failure. */ ++static int ++scfb_frame_buffer_map(struct scfb_output *output, int fd) ++{ ++ weston_log("[scfb %s] fd %d\n",__func__,fd); ++ ++ int retval = -1; ++ ++ ++ /* Map the frame buffer. Write-only mode, since we don't want to read ++ * anything back (because it's slow). */ ++ output->fb = scfb_mmap(output->fb_info.buffer_length, 0, fd); ++ if (output->fb == MAP_FAILED) { ++ weston_log("Failed to mmap frame buffer: %s\n", ++ strerror(errno)); ++ goto out_close; ++ } ++ ++ /* Create a pixman image to wrap the memory mapped frame buffer. */ ++ output->hw_surface = ++ pixman_image_create_bits(output->fb_info.pixel_format, ++ output->fb_info.x_resolution, ++ output->fb_info.y_resolution, ++ output->fb, ++ output->fb_info.line_length); ++ if (output->hw_surface == NULL) { ++ weston_log("Failed to create surface for frame buffer.\n"); ++ goto out_unmap; ++ } ++ ++ /* Success! */ ++ retval = 0; ++ ++out_unmap: ++ if (retval != 0 && output->fb != NULL) ++ scfb_frame_buffer_destroy(output); ++ ++out_close: ++ if (fd >= 0) ++ close(fd); ++ ++ return retval; ++} ++ ++static void ++scfb_frame_buffer_destroy(struct scfb_output *output) ++{ ++ weston_log("Destroying scfb frame buffer.\n"); ++ ++ if (munmap(output->fb, output->fb_info.buffer_length) < 0) ++ weston_log("Failed to munmap frame buffer: %s\n", ++ strerror(errno)); ++ ++ output->fb = NULL; ++} ++ ++static void scfb_output_destroy(struct weston_output *base); ++static void scfb_output_disable(struct weston_output *base); ++ ++static int ++scfb_output_enable(struct weston_output *base) ++{ ++ struct scfb_output *output = to_scfb_output(base); ++ struct scfb_backend *backend = to_scfb_backend(base->compositor); ++ int fb_fd; ++ struct wl_event_loop *loop; ++ ++ /* Create the frame buffer. */ ++ fb_fd = scfb_frame_buffer_open(output, output->device, &output->fb_info); ++ if (fb_fd < 0) { ++ weston_log("Creating frame buffer failed.\n"); ++ return -1; ++ } ++ ++ if (scfb_frame_buffer_map(output, fb_fd) < 0) { ++ weston_log("Mapping frame buffer failed.\n"); ++ return -1; ++ } ++ ++ output->base.start_repaint_loop = scfb_output_start_repaint_loop; ++ output->base.repaint = scfb_output_repaint; ++ ++ if (pixman_renderer_output_create(&output->base) < 0) ++ goto out_hw_surface; ++ ++ loop = wl_display_get_event_loop(backend->compositor->wl_display); ++ output->finish_frame_timer = ++ wl_event_loop_add_timer(loop, finish_frame_handler, output); ++ ++ weston_log("scfb output %d×%d px\n", ++ output->mode.width, output->mode.height); ++ weston_log_continue(STAMP_SPACE "guessing %d Hz and 96 dpi\n", ++ output->mode.refresh / 1000); ++ ++ return 0; ++ ++out_hw_surface: ++ pixman_image_unref(output->hw_surface); ++ output->hw_surface = NULL; ++ scfb_frame_buffer_destroy(output); ++ ++ return -1; ++} ++ ++static int ++scfb_output_create(struct scfb_backend *backend, ++ const char *device) ++{ ++ weston_log("[scfb %s] device %s\n",__func__,device); ++ ++ struct scfb_output *output; ++ int fb_fd; ++ ++ weston_log("Creating scfb output.\n"); ++ ++ output = zalloc(sizeof *output); ++ if (output == NULL) ++ return -1; ++ ++ output->backend = backend; ++ output->device = strdup(device); ++ ++ /* Create the frame buffer. */ ++ fb_fd = scfb_frame_buffer_open(output, device, &output->fb_info); ++ if (fb_fd < 0) { ++ weston_log("Creating frame buffer failed.\n"); ++ goto out_free; ++ } ++ ++ output->base.name = strdup("scfb"); ++ output->base.destroy = scfb_output_destroy; ++ output->base.disable = NULL; ++ output->base.enable = scfb_output_enable; ++ ++ weston_output_init(&output->base, backend->compositor); ++ ++ /* only one static mode in list */ ++ output->mode.flags = ++ WL_OUTPUT_MODE_CURRENT | WL_OUTPUT_MODE_PREFERRED; ++ output->mode.width = output->fb_info.x_resolution; ++ output->mode.height = output->fb_info.y_resolution; ++ output->mode.refresh = output->fb_info.refresh_rate; ++ wl_list_init(&output->base.mode_list); ++ wl_list_insert(&output->base.mode_list, &output->mode.link); ++ ++ output->base.current_mode = &output->mode; ++ output->base.subpixel = WL_OUTPUT_SUBPIXEL_UNKNOWN; ++ output->base.make = "unknown"; ++ output->base.model = output->fb_info.id; ++ ++ output->base.mm_width = output->fb_info.width_mm; ++ output->base.mm_height = output->fb_info.height_mm; ++ ++ close(fb_fd); ++ ++ weston_compositor_add_pending_output(&output->base, backend->compositor); ++ ++ return 0; ++ ++out_free: ++ free(output->device); ++ free(output); ++ ++ return -1; ++} ++ ++static void ++scfb_output_destroy(struct weston_output *base) ++{ ++ struct scfb_output *output = to_scfb_output(base); ++ ++ weston_log("Destroying scfb output.\n"); ++ ++ /* Close the frame buffer. */ ++ scfb_output_disable(base); ++ ++ if (base->renderer_state != NULL) ++ pixman_renderer_output_destroy(base); ++ ++ /* Remove the output. */ ++ weston_output_destroy(&output->base); ++ ++ free(output->device); ++ free(output); ++} ++ ++/* strcmp()-style return values. */ ++static int ++compare_screen_info (const struct scfb_screeninfo *a, ++ const struct scfb_screeninfo *b) ++{ ++ if (a->x_resolution == b->x_resolution && ++ a->y_resolution == b->y_resolution && ++ a->width_mm == b->width_mm && ++ a->height_mm == b->height_mm && ++ a->bits_per_pixel == b->bits_per_pixel && ++ a->pixel_format == b->pixel_format && ++ a->refresh_rate == b->refresh_rate) ++ return 0; ++ ++ return 1; ++} ++ ++static int ++scfb_output_reenable(struct scfb_backend *backend, ++ struct weston_output *base) ++{ ++ struct scfb_output *output = to_scfb_output(base); ++ struct scfb_screeninfo new_screen_info; ++ int fb_fd; ++ char *device; ++ ++ weston_log("Re-enabling scfb output.\n"); ++ ++ /* Create the frame buffer. */ ++ fb_fd = scfb_frame_buffer_open(output, output->device, ++ &new_screen_info); ++ if (fb_fd < 0) { ++ weston_log("Creating frame buffer failed.\n"); ++ goto err; ++ } ++ ++ /* Check whether the frame buffer details have changed since we were ++ * disabled. */ ++ if (compare_screen_info (&output->fb_info, &new_screen_info) != 0) { ++ /* Perform a mode-set to restore the old mode. */ ++ if (scfb_set_screen_info(output, fb_fd, ++ &output->fb_info) < 0) { ++ weston_log("Failed to restore mode settings. " ++ "Attempting to re-open output anyway.\n"); ++ } ++ ++ close(fb_fd); ++ ++ /* Remove and re-add the output so that resources depending on ++ * the frame buffer X/Y resolution (such as the shadow buffer) ++ * are re-initialised. */ ++ device = strdup(output->device); ++ scfb_output_destroy(&output->base); ++ scfb_output_create(backend, device); ++ free(device); ++ ++ return 0; ++ } ++ ++ /* Map the device if it has the same details as before. */ ++ if (scfb_frame_buffer_map(output, fb_fd) < 0) { ++ weston_log("Mapping frame buffer failed.\n"); ++ goto err; ++ } ++ ++ return 0; ++ ++err: ++ return -1; ++} ++ ++/* NOTE: This leaves output->fb_info populated, caching data so that if ++ * scfb_output_reenable() is called again, it can determine whether a mode-set ++ * is needed. */ ++static void ++scfb_output_disable(struct weston_output *base) ++{ ++ struct scfb_output *output = to_scfb_output(base); ++ ++ weston_log("Disabling scfb output.\n"); ++ ++ if (output->hw_surface != NULL) { ++ pixman_image_unref(output->hw_surface); ++ output->hw_surface = NULL; ++ } ++ ++ scfb_frame_buffer_destroy(output); ++} ++ ++static void ++scfb_backend_destroy(struct weston_compositor *base) ++{ ++ struct scfb_backend *backend = to_scfb_backend(base); ++ ++ udev_input_destroy(&backend->input); ++ ++ /* Destroy the output. */ ++ weston_compositor_shutdown(base); ++ ++ /* Chain up. */ ++ weston_launcher_destroy(base->launcher); ++ ++ free(backend); ++} ++ ++static void ++session_notify(struct wl_listener *listener, void *data) ++{ ++ struct weston_compositor *compositor = data; ++ struct scfb_backend *backend = to_scfb_backend(compositor); ++ struct weston_output *output; ++ ++ if (compositor->session_active) { ++ weston_log("entering VT\n"); ++ compositor->state = backend->prev_state; ++ ++ wl_list_for_each(output, &compositor->output_list, link) { ++ scfb_output_reenable(backend, output); ++ } ++ ++ weston_compositor_damage_all(compositor); ++ ++ udev_input_enable(&backend->input); ++ } else { ++ weston_log("leaving VT\n"); ++ udev_input_disable(&backend->input); ++ ++ wl_list_for_each(output, &compositor->output_list, link) { ++ scfb_output_disable(output); ++ } ++ ++ backend->prev_state = compositor->state; ++ weston_compositor_offscreen(compositor); ++ ++ /* If we have a repaint scheduled (from the idle handler), make ++ * sure we cancel that so we don't try to pageflip when we're ++ * vt switched away. The OFFSCREEN state will prevent ++ * further attempts at repainting. When we switch ++ * back, we schedule a repaint, which will process ++ * pending frame callbacks. */ ++ ++ wl_list_for_each(output, ++ &compositor->output_list, link) { ++ output->repaint_needed = 0; ++ } ++ } ++} ++ ++static void ++scfb_restore(struct weston_compositor *compositor) ++{ ++ weston_launcher_restore(compositor->launcher); ++} ++ ++static struct scfb_backend * ++scfb_backend_create(struct weston_compositor *compositor, ++ struct weston_scfb_backend_config *param) ++{ ++ struct scfb_backend *backend; ++ const char *seat_id = default_seat; ++ ++ weston_log("initializing scfb backend\n"); ++ ++ backend = zalloc(sizeof *backend); ++ if (backend == NULL) ++ return NULL; ++ ++ backend->compositor = compositor; ++ if (weston_compositor_set_presentation_clock_software( ++ compositor) < 0) ++ goto out_compositor; ++ ++ backend->udev = udev_new(); ++ if (backend->udev == NULL) { ++ weston_log("Failed to initialize udev context.\n"); ++ goto out_compositor; ++ } ++ ++ /* Set up the TTY. */ ++ backend->session_listener.notify = session_notify; ++ wl_signal_add(&compositor->session_signal, ++ &backend->session_listener); ++ compositor->launcher = ++ weston_launcher_connect(compositor, param->tty, "seat0", false); ++ if (!compositor->launcher) { ++ weston_log("fatal: scfb backend should be run " ++ "using weston-launch binary or as root\n"); ++ goto out_udev; ++ } ++ ++ backend->base.destroy = scfb_backend_destroy; ++ backend->base.restore = scfb_restore; ++ ++ backend->prev_state = WESTON_COMPOSITOR_ACTIVE; ++ ++ weston_setup_vt_switch_bindings(compositor); ++ ++ if (pixman_renderer_init(compositor) < 0) ++ goto out_launcher; ++ ++ if (scfb_output_create(backend, param->device) < 0) ++ goto out_launcher; ++ ++ udev_input_init(&backend->input, compositor, backend->udev, ++ seat_id, param->configure_device); ++ ++ compositor->backend = &backend->base; ++ return backend; ++ ++out_launcher: ++ weston_launcher_destroy(compositor->launcher); ++ ++out_udev: ++ udev_unref(backend->udev); ++ ++out_compositor: ++ weston_compositor_shutdown(compositor); ++ free(backend); ++ ++ return NULL; ++} ++ ++static void ++config_init_to_defaults(struct weston_scfb_backend_config *config) ++{ ++ /* TODO: Ideally, available frame buffers should be enumerated using ++ * udev, rather than passing a device node in as a parameter. */ ++ config->tty = 0; /* default to current tty */ ++ config->device = "/dev/fb0"; /* default frame buffer */ ++} ++ ++WL_EXPORT int ++weston_backend_init(struct weston_compositor *compositor, ++ struct weston_backend_config *config_base) ++{ ++ struct scfb_backend *b; ++ struct weston_scfb_backend_config config = {{ 0, }}; ++ ++ if (config_base == NULL || ++ config_base->struct_version != WESTON_SCFB_BACKEND_CONFIG_VERSION || ++ config_base->struct_size > sizeof(struct weston_scfb_backend_config)) { ++ weston_log("scfb backend config structure is invalid\n"); ++ return -1; ++ } ++ ++ config_init_to_defaults(&config); ++ memcpy(&config, config_base, config_base->struct_size); ++ ++ b = scfb_backend_create(compositor, &config); ++ if (b == NULL) ++ return -1; ++ return 0; ++} Index: x11-wm/weston/files/patch-libweston_compositor-x11.c =================================================================== --- /dev/null +++ x11-wm/weston/files/patch-libweston_compositor-x11.c @@ -0,0 +1,10 @@ +--- libweston/compositor-x11.c.orig 2017-01-19 01:41:20 UTC ++++ libweston/compositor-x11.c +@@ -37,6 +37,7 @@ + #include + #include + #include ++#include + #include + + #include Index: x11-wm/weston/files/patch-libweston_compositor.h =================================================================== --- /dev/null +++ x11-wm/weston/files/patch-libweston_compositor.h @@ -0,0 +1,10 @@ +--- libweston/compositor.h.orig 2017-02-07 22:58:35 UTC ++++ libweston/compositor.h +@@ -1619,6 +1619,7 @@ weston_compositor_create(struct wl_displ + enum weston_compositor_backend { + WESTON_BACKEND_DRM, + WESTON_BACKEND_FBDEV, ++ WESTON_BACKEND_SCFB, + WESTON_BACKEND_HEADLESS, + WESTON_BACKEND_RDP, + WESTON_BACKEND_WAYLAND, Index: x11-wm/weston/files/patch-libweston_compositor.c =================================================================== --- /dev/null +++ x11-wm/weston/files/patch-libweston_compositor.c @@ -0,0 +1,24 @@ +--- libweston/compositor.c.orig 2017-02-07 22:58:35 UTC ++++ libweston/compositor.c +@@ -5224,10 +5224,10 @@ weston_compositor_set_presentation_clock + { + /* In order of preference */ + static const clockid_t clocks[] = { +- CLOCK_MONOTONIC_RAW, /* no jumps, no crawling */ +- CLOCK_MONOTONIC_COARSE, /* no jumps, may crawl, fast & coarse */ ++ //CLOCK_MONOTONIC_RAW, /* no jumps, no crawling */ ++ //CLOCK_MONOTONIC_COARSE, /* no jumps, may crawl, fast & coarse */ + CLOCK_MONOTONIC, /* no jumps, may crawl */ +- CLOCK_REALTIME_COARSE, /* may jump and crawl, fast & coarse */ ++ //CLOCK_REALTIME_COARSE, /* may jump and crawl, fast & coarse */ + CLOCK_REALTIME /* may jump and crawl */ + }; + unsigned i; +@@ -5416,6 +5416,7 @@ weston_compositor_get_user_data(struct w + static const char * const backend_map[] = { + [WESTON_BACKEND_DRM] = "drm-backend.so", + [WESTON_BACKEND_FBDEV] = "fbdev-backend.so", ++ [WESTON_BACKEND_SCFB] = "scfb-backend.so", + [WESTON_BACKEND_HEADLESS] = "headless-backend.so", + [WESTON_BACKEND_RDP] = "rdp-backend.so", + [WESTON_BACKEND_WAYLAND] = "wayland-backend.so", Index: x11-wm/weston/files/patch-libweston_input.c =================================================================== --- /dev/null +++ x11-wm/weston/files/patch-libweston_input.c @@ -0,0 +1,12 @@ +--- libweston/input.c.orig 2016-12-10 00:45:56 UTC ++++ libweston/input.c +@@ -32,7 +32,8 @@ + #include + #include + #include +-#include ++//#include ++#include + #include + #include + Index: x11-wm/weston/files/patch-libweston_launcher-direct.c =================================================================== --- /dev/null +++ x11-wm/weston/files/patch-libweston_launcher-direct.c @@ -0,0 +1,171 @@ +--- libweston/launcher-direct.c.orig 2017-02-14 20:59:07 UTC ++++ libweston/launcher-direct.c +@@ -34,17 +34,25 @@ + #include + #include + #include +-#include +-#include +-#include ++/* #include */ ++/* #include */ ++/* #include */ ++/* #define TTY_BASENAME "/dev/tty" */ ++/* #define TTY_0 "/dev/tty0" */ ++ ++#include ++#include ++#include ++#define TTY_BASENAME "/dev/ttyv" ++#define TTY_0 "/dev/ttyv0" + + #include "launcher-impl.h" + +-#define DRM_MAJOR 226 ++/* #define DRM_MAJOR 226 */ + +-#ifndef KDSKBMUTE +-#define KDSKBMUTE 0x4B51 +-#endif ++/* #ifndef KDSKBMUTE */ ++/* #define KDSKBMUTE 0x4B51 */ ++/* #endif */ + + #ifdef HAVE_LIBDRM + +@@ -116,7 +124,7 @@ setup_tty(struct launcher_direct *launch + struct vt_mode mode = { 0 }; + struct stat buf; + char tty_device[32] =""; +- int ret, kd_mode; ++ int ret, kd_mode, vt; + + if (tty == 0) { + launcher->tty = dup(tty); +@@ -125,7 +133,7 @@ setup_tty(struct launcher_direct *launch + return -1; + } + } else { +- snprintf(tty_device, sizeof tty_device, "/dev/tty%d", tty); ++ snprintf(tty_device, sizeof tty_device, "%s%d", TTY_BASENAME, tty); + launcher->tty = open(tty_device, O_RDWR | O_CLOEXEC); + if (launcher->tty == -1) { + weston_log("couldn't open tty %s: %m\n", tty_device); +@@ -133,14 +141,20 @@ setup_tty(struct launcher_direct *launch + } + } + +- if (fstat(launcher->tty, &buf) == -1 || +- major(buf.st_rdev) != TTY_MAJOR || minor(buf.st_rdev) == 0) { +- weston_log("%s not a vt\n", tty_device); +- weston_log("if running weston from ssh, " +- "use --tty to specify a tty\n"); +- goto err_close; ++ ret = ioctl(launcher->tty, VT_GETINDEX, &vt); ++ if (ret) { ++ weston_log("failed to get VT index: %m\n"); ++ return -1; + } + ++ /* if (fstat(launcher->tty, &buf) == -1 || */ ++ /* major(buf.st_rdev) != TTY_MAJOR || minor(buf.st_rdev) == 0) { */ ++ /* weston_log("%s not a vt\n", tty_device); */ ++ /* weston_log("if running weston from ssh, " */ ++ /* "use --tty to specify a tty\n"); */ ++ /* goto err_close; */ ++ /* } */ ++ + ret = ioctl(launcher->tty, KDGETMODE, &kd_mode); + if (ret) { + weston_log("failed to get VT mode: %m\n"); +@@ -152,17 +166,28 @@ setup_tty(struct launcher_direct *launch + goto err_close; + } + +- ioctl(launcher->tty, VT_ACTIVATE, minor(buf.st_rdev)); +- ioctl(launcher->tty, VT_WAITACTIVE, minor(buf.st_rdev)); ++ ioctl(launcher->tty, VT_ACTIVATE, vt); ++ ioctl(launcher->tty, VT_WAITACTIVE, vt); + + if (ioctl(launcher->tty, KDGKBMODE, &launcher->kb_mode)) { + weston_log("failed to read keyboard mode: %m\n"); + goto err_close; + } + +- if (ioctl(launcher->tty, KDSKBMUTE, 1) && +- ioctl(launcher->tty, KDSKBMODE, K_OFF)) { +- weston_log("failed to set K_OFF keyboard mode: %m\n"); ++ if (ioctl(launcher->tty, KDSKBMODE, K_RAW) == -1) { ++ weston_log("Could not set keyboard mode to K_RAW"); ++ goto err_close; ++ } ++ ++ /* Put the tty into raw mode */ ++ struct termios tios; ++ if (tcgetattr(launcher->tty, &tios)) { ++ weston_log("Failed to get terminal attribute"); ++ goto err_close; ++ } ++ cfmakeraw(&tios); ++ if (tcsetattr(launcher->tty, TCSAFLUSH, &tios)) { ++ weston_log("Failed to set terminal attribute"); + goto err_close; + } + +@@ -183,10 +208,10 @@ setup_tty(struct launcher_direct *launch + ret = -EINVAL; + goto err_close; + } +- + mode.mode = VT_PROCESS; +- mode.relsig = SIGRTMIN; ++ mode.relsig = SIGRTMAX; + mode.acqsig = SIGRTMIN; ++ mode.frsig = SIGIO; /* not used, but has to be set anyway */ + if (ioctl(launcher->tty, VT_SETMODE, &mode) < 0) { + weston_log("failed to take control of vt handling\n"); + goto err_close; +@@ -221,13 +246,11 @@ launcher_direct_open(struct weston_launc + return -1; + } + +- if (major(s.st_rdev) == DRM_MAJOR) { +- launcher->drm_fd = fd; +- if (!is_drm_master(fd)) { +- weston_log("drm fd not master\n"); +- close(fd); +- return -1; +- } ++ launcher->drm_fd = fd; ++ if (!is_drm_master(fd)) { ++ weston_log("drm fd not master\n"); ++ close(fd); ++ return -1; + } + + return fd; +@@ -245,13 +268,22 @@ launcher_direct_restore(struct weston_la + struct launcher_direct *launcher = wl_container_of(launcher_base, launcher, base); + struct vt_mode mode = { 0 }; + +- if (ioctl(launcher->tty, KDSKBMUTE, 0) && +- ioctl(launcher->tty, KDSKBMODE, launcher->kb_mode)) ++ if (ioctl(launcher->tty, KDSKBMODE, launcher->kb_mode)) + weston_log("failed to restore kb mode: %m\n"); + + if (ioctl(launcher->tty, KDSETMODE, KD_TEXT)) + weston_log("failed to set KD_TEXT mode on tty: %m\n"); + ++ /* Restore sane mode */ ++ struct termios tios; ++ if (tcgetattr(launcher->tty, &tios)) { ++ weston_log("Failed to get terminal attribute"); ++ } else { ++ cfmakesane(&tios); ++ if (tcsetattr(launcher->tty, TCSAFLUSH, &tios)) { ++ weston_log("Failed to set terminal attribute"); ++ } ++ } + /* We have to drop master before we switch the VT back in + * VT_AUTO, so we don't risk switching to a VT with another + * display server, that will then fail to set drm master. */ Index: x11-wm/weston/files/patch-libweston_launcher-weston-launch.c =================================================================== --- /dev/null +++ x11-wm/weston/files/patch-libweston_launcher-weston-launch.c @@ -0,0 +1,87 @@ +--- libweston/launcher-weston-launch.c.orig 2017-02-14 20:59:07 UTC ++++ libweston/launcher-weston-launch.c +@@ -40,19 +40,29 @@ + #include + #include + #include +-#include +-#include +-#include ++ ++#include ++#include ++#include ++#define TTY_BASENAME "/dev/ttyv" ++#define TTY_0 "/dev/ttyv0" ++ ++/* #include */ ++/* #include */ ++/* #include */ ++/* #define TTY_BASENAME "/dev/tty" */ ++/* #define TTY_0 "/dev/tty0" */ ++ + + #include "compositor.h" + #include "weston-launch.h" + #include "launcher-impl.h" + +-#define DRM_MAJOR 226 ++/* #define DRM_MAJOR 226 */ + +-#ifndef KDSKBMUTE +-#define KDSKBMUTE 0x4B51 +-#endif ++/* #ifndef KDSKBMUTE */ ++/* #define KDSKBMUTE 0x4B51 */ ++/* #endif */ + + #ifdef HAVE_LIBDRM + +@@ -151,22 +161,35 @@ launcher_weston_launch_open(struct westo + static void + launcher_weston_launch_close(struct weston_launcher *launcher_base, int fd) + { ++ weston_log("%s: fd %d\n",__func__,fd); + close(fd); + } + + static void + launcher_weston_launch_restore(struct weston_launcher *launcher_base) + { ++ weston_log("%s\n",__func__); + struct launcher_weston_launch *launcher = wl_container_of(launcher_base, launcher, base); + struct vt_mode mode = { 0 }; + +- if (ioctl(launcher->tty, KDSKBMUTE, 0) && ++ if (/*ioctl(launcher->tty, KDSKBMUTE, 0) &&*/ + ioctl(launcher->tty, KDSKBMODE, launcher->kb_mode)) + weston_log("failed to restore kb mode: %m\n"); + + if (ioctl(launcher->tty, KDSETMODE, KD_TEXT)) + weston_log("failed to set KD_TEXT mode on tty: %m\n"); + ++ /* Restore sane mode */ ++ struct termios tios; ++ if (tcgetattr(launcher->tty, &tios)) { ++ weston_log("Failed to get terminal attribute\n"); ++ } else { ++ cfmakesane(&tios); ++ if (tcsetattr(launcher->tty, TCSAFLUSH, &tios)) { ++ weston_log("Failed to set terminal attribute\n"); ++ } ++ } ++ + /* We have to drop master before we switch the VT back in + * VT_AUTO, so we don't risk switching to a VT with another + * display server, that will then fail to set drm master. */ +@@ -243,7 +266,9 @@ launcher_weston_launch_connect(struct we + /* We don't get a chance to read out the original kb + * mode for the tty, so just hard code K_UNICODE here + * in case we have to clean if weston-launch dies. */ +- launcher->kb_mode = K_UNICODE; ++ ++ launcher->kb_mode = K_XLATE; ++ /* launcher->kb_mode = K_UNICODE; */ + + loop = wl_display_get_event_loop(compositor->wl_display); + launcher->source = wl_event_loop_add_fd(loop, launcher->fd, Index: x11-wm/weston/files/patch-libweston_libbacklight.c =================================================================== --- /dev/null +++ x11-wm/weston/files/patch-libweston_libbacklight.c @@ -0,0 +1,16 @@ +--- libweston/libbacklight.c.orig 2016-10-22 16:23:57 UTC ++++ libweston/libbacklight.c +@@ -36,11 +36,11 @@ + #include + #include + #include +-#include ++/* #include */ + #include + #include + #include +-#include ++/* #include */ + #include + #include + Index: x11-wm/weston/files/patch-libweston_libinput-device.c =================================================================== --- /dev/null +++ x11-wm/weston/files/patch-libweston_libinput-device.c @@ -0,0 +1,18 @@ +--- libweston/libinput-device.c.orig 2016-10-22 16:23:57 UTC ++++ libweston/libinput-device.c +@@ -538,6 +538,7 @@ struct evdev_device * + evdev_device_create(struct libinput_device *libinput_device, + struct weston_seat *seat) + { ++ printf("%s\n",__func__); + struct evdev_device *device; + + device = zalloc(sizeof *device); +@@ -573,6 +574,7 @@ evdev_device_create(struct libinput_devi + void + evdev_device_destroy(struct evdev_device *device) + { ++ printf("%s\n",__func__); + if (device->seat_caps & EVDEV_SEAT_POINTER) + weston_seat_release_pointer(device->seat); + if (device->seat_caps & EVDEV_SEAT_KEYBOARD) Index: x11-wm/weston/files/patch-libweston_libinput-seat.c =================================================================== --- /dev/null +++ x11-wm/weston/files/patch-libweston_libinput-seat.c @@ -0,0 +1,58 @@ +--- libweston/libinput-seat.c.orig 2016-11-20 21:46:09 UTC ++++ libweston/libinput-seat.c +@@ -114,6 +114,7 @@ device_removed(struct udev_input *input, + { + struct evdev_device *device; + ++ printf("%s\n",__func__); + device = libinput_device_get_user_data(libinput_device); + evdev_device_destroy(device); + } +@@ -131,9 +132,11 @@ udev_seat_remove_devices(struct udev_sea + void + udev_input_disable(struct udev_input *input) + { ++ printf("%s\n",__func__); + if (input->suspended) + return; + ++ printf("%s\n",__func__); + libinput_suspend(input->libinput); + process_events(input); + input->suspended = 1; +@@ -142,6 +145,7 @@ udev_input_disable(struct udev_input *in + static int + udev_input_process_event(struct libinput_event *event) + { ++ /* printf("%s\n",__func__); */ + struct libinput *libinput = libinput_event_get_context(event); + struct libinput_device *libinput_device = + libinput_event_get_device(event); +@@ -150,9 +154,11 @@ udev_input_process_event(struct libinput + + switch (libinput_event_get_type(event)) { + case LIBINPUT_EVENT_DEVICE_ADDED: ++ printf("%s: Device added\n",__func__); + device_added(input, libinput_device); + break; + case LIBINPUT_EVENT_DEVICE_REMOVED: ++ printf("%s: Device removed\n",__func__); + device_removed(input, libinput_device); + break; + default: +@@ -177,6 +183,7 @@ process_events(struct udev_input *input) + struct libinput_event *event; + + while ((event = libinput_get_event(input->libinput))) { ++ /* printf("%s\n",__func__); */ + process_event(event); + libinput_event_destroy(event); + } +@@ -227,6 +234,7 @@ const struct libinput_interface libinput + int + udev_input_enable(struct udev_input *input) + { ++ printf("%s\n",__func__); + struct wl_event_loop *loop; + struct weston_compositor *c = input->compositor; + int fd; Index: x11-wm/weston/files/patch-libweston_timeline.c =================================================================== --- /dev/null +++ x11-wm/weston/files/patch-libweston_timeline.c @@ -0,0 +1,16 @@ +--- libweston/timeline.c.orig 2016-10-22 16:23:57 UTC ++++ libweston/timeline.c +@@ -1,3 +1,4 @@ ++ + /* + * Copyright © 2014 Pekka Paalanen + * Copyright © 2014 Collabora, Ltd. +@@ -36,6 +37,8 @@ + #include "compositor.h" + #include "file-util.h" + ++#define ETIME ETIMEDOUT ++ + struct timeline_log { + clock_t clk_id; + FILE *file; Index: x11-wm/weston/files/patch-libweston_weston-launch.c =================================================================== --- /dev/null +++ x11-wm/weston/files/patch-libweston_weston-launch.c @@ -0,0 +1,320 @@ +--- libweston/weston-launch.c.orig 2016-10-22 16:23:57 UTC ++++ libweston/weston-launch.c +@@ -33,7 +33,6 @@ + #include + #include + +-#include + #include + + #include +@@ -46,9 +45,34 @@ + #include + #include + +-#include +-#include +-#include ++#include ++#include ++#include ++#define TTY_BASENAME "/dev/ttyv" ++#define TTY_0 "/dev/ttyv0" ++#define error(s,e,...) \ ++ do { \ ++ if(e) \ ++ fprintf(stderr, "errno: %s\n",strerror(e)); \ ++ fprintf(stderr, __VA_ARGS__); \ ++ fprintf(stderr, "\n"); \ ++ if (s != 0) { \ ++ exit(-1); \ ++ } \ ++ } while(false) ++static inline int clearenv(void) { ++ extern char **environ; ++ environ[0] = NULL; ++ return 0; ++} ++ ++/* #include */ ++/* #include */ ++/* #include */ ++/* #include */ ++/* #define TTY_BASENAME "/dev/tty" */ ++/* #define TTY_0 "/dev/tty0" */ ++ + + #include + #include +@@ -60,11 +84,12 @@ + + #include "weston-launch.h" + +-#define DRM_MAJOR 226 + +-#ifndef KDSKBMUTE +-#define KDSKBMUTE 0x4B51 +-#endif ++/* #define DRM_MAJOR 226 */ ++ ++/* #ifndef KDSKBMUTE */ ++/* #define KDSKBMUTE 0x4B51 */ ++/* #endif */ + + #ifndef EVIOCREVOKE + #define EVIOCREVOKE _IOW('E', 0x91, int) +@@ -142,7 +167,7 @@ weston_launch_allowed(struct weston_laun + { + struct group *gr; + gid_t *groups; +- int i; ++ int i,n; + #ifdef HAVE_SYSTEMD_LOGIN + char *session, *seat; + int err; +@@ -155,7 +180,8 @@ weston_launch_allowed(struct weston_laun + if (gr) { + groups = read_groups(); + if (groups) { +- for (i = 0; groups[i]; ++i) { ++ n = getgroups(0, NULL); ++ for (i = 0; igr_gid) { + free(groups); + return true; +@@ -322,14 +348,14 @@ handle_open(struct weston_launch *wl, st + goto err0; + } + +- if (major(s.st_rdev) != INPUT_MAJOR && +- major(s.st_rdev) != DRM_MAJOR) { +- close(fd); +- fd = -1; +- fprintf(stderr, "Device %s is not an input or drm device\n", +- message->path); +- goto err0; +- } ++ /* if (major(s.st_rdev) != INPUT_MAJOR && */ ++ /* major(s.st_rdev) != DRM_MAJOR) { */ ++ /* close(fd); */ ++ /* fd = -1; */ ++ /* fprintf(stderr, "Device %s is not an input or drm device\n", */ ++ /* message->path); */ ++ /* goto err0; */ ++ /* } */ + + err0: + memset(&nmsg, 0, sizeof nmsg); +@@ -350,8 +376,8 @@ err0: + iov.iov_base = &ret; + iov.iov_len = sizeof ret; + +- if (wl->verbose) +- fprintf(stderr, "weston-launch: opened %s: ret: %d, fd: %d\n", ++ /* if (wl->verbose) */ ++ printf("weston-launch: opened %s: ret: %d, fd: %d\n", + message->path, ret, fd); + do { + len = sendmsg(wl->sock[0], &nmsg, 0); +@@ -360,10 +386,9 @@ err0: + if (len < 0) + return -1; + +- if (fd != -1 && major(s.st_rdev) == DRM_MAJOR) ++ if (fd != -1) + wl->drm_fd = fd; +- if (fd != -1 && major(s.st_rdev) == INPUT_MAJOR && +- wl->last_input_fd < fd) ++ if (fd != -1 && wl->last_input_fd < fd) + wl->last_input_fd = fd; + + return 0; +@@ -422,9 +447,18 @@ quit(struct weston_launch *wl, int statu + pam_end(wl->ph, err); + } + +- if (ioctl(wl->tty, KDSKBMUTE, 0) && +- ioctl(wl->tty, KDSKBMODE, wl->kb_mode)) +- fprintf(stderr, "failed to restore keyboard mode: %m\n"); ++ /* if (ioctl(wl->tty, KDSKBMODE, wl->kb_mode)) */ ++ if (ioctl(wl->tty, KDSKBMODE, K_XLATE)) ++ fprintf(stderr, "Could not restore keyboard\n"); ++ ++ struct termios tios; ++ if (tcgetattr(wl->tty, &tios)) { ++ fprintf(stderr, "Failed to get terminal attribute\n"); ++ } else { ++ cfmakesane(&tios); ++ if (tcsetattr(wl->tty , TCSAFLUSH, &tios)) ++ fprintf(stderr, "Failed to set terminal attribute\n"); ++ } + + if (ioctl(wl->tty, KDSETMODE, KD_TEXT)) + fprintf(stderr, "failed to set KD_TEXT mode on tty: %m\n"); +@@ -435,6 +469,7 @@ quit(struct weston_launch *wl, int statu + drmDropMaster(wl->drm_fd); + + mode.mode = VT_AUTO; ++ mode.frsig = SIGIO; /* not used, but has to be set anyway */ + if (ioctl(wl->tty, VT_SETMODE, &mode) < 0) + fprintf(stderr, "could not reset vt handling\n"); + +@@ -444,15 +479,25 @@ quit(struct weston_launch *wl, int statu + static void + close_input_fds(struct weston_launch *wl) + { ++ // Input device are being closed by: launcher_weston_launch_close() ++ // on exit or deactivate. ++ // This function will close the wayland socket fd as well ++ // and crash the program... ++ ++ // Do we need this function? ++ + struct stat s; + int fd; + + for (fd = 3; fd <= wl->last_input_fd; fd++) { +- if (fstat(fd, &s) == 0 && major(s.st_rdev) == INPUT_MAJOR) { ++ if (fstat(fd, &s) == 0) { + /* EVIOCREVOKE may fail if the kernel doesn't + * support it, but all we can do is ignore it. */ ++ printf("%s: Closing fd %d\n",__func__,fd); + ioctl(fd, EVIOCREVOKE, 0); + close(fd); ++ } else { ++ fprintf(stderr,"%s: stat failed on fd %d\n",__func__,fd); + } + } + } +@@ -460,16 +505,22 @@ close_input_fds(struct weston_launch *wl + static int + handle_signal(struct weston_launch *wl) + { ++ printf("%s\n",__func__); ++ + struct signalfd_siginfo sig; + int pid, status, ret; + +- if (read(wl->signalfd, &sig, sizeof sig) != sizeof sig) { +- error(0, errno, "reading signalfd failed"); ++ ret = read(wl->signalfd, &sig, sizeof sig); ++ if (ret != sizeof sig) { ++ error(0, errno, "reading signalfd %d failed", wl->signalfd); ++ // Temporary add delay here so we don't get spammed with error messages ++ usleep(500000); + return -1; + } + + switch (sig.ssi_signo) { + case SIGCHLD: ++ printf("%s: SIGCHLD\n",__func__); + pid = waitpid(-1, &status, 0); + if (pid == wl->child) { + wl->child = 0; +@@ -489,22 +540,32 @@ handle_signal(struct weston_launch *wl) + } + break; + case SIGTERM: ++ printf("%s: SIGTERM - killing\n",__func__); + case SIGINT: ++ printf("%s: SIGINT - killing\n",__func__); + if (wl->child) + kill(wl->child, sig.ssi_signo); + break; + case SIGUSR1: ++ printf("%s: SIGUSR1 - deactivating\n",__func__); + send_reply(wl, WESTON_LAUNCHER_DEACTIVATE); +- close_input_fds(wl); ++ ++ // This is done in launcher-weston-launcher.c, ++ // compositor-drm.c (session-notify) ++ // Double close = crash on vt switch (socket also get closed) ++ /* close_input_fds(wl); */ ++ + drmDropMaster(wl->drm_fd); + ioctl(wl->tty, VT_RELDISP, 1); + break; + case SIGUSR2: ++ printf("%s: SIGUSR2 - activating\n",__func__); + ioctl(wl->tty, VT_RELDISP, VT_ACKACQ); + drmSetMaster(wl->drm_fd); + send_reply(wl, WESTON_LAUNCHER_ACTIVATE); + break; + default: ++ printf("%s: Unknown signal\n",__func__); + return -1; + } + +@@ -527,7 +588,7 @@ setup_tty(struct weston_launch *wl, cons + else + wl->tty = open(tty, O_RDWR | O_NOCTTY); + } else { +- int tty0 = open("/dev/tty0", O_WRONLY | O_CLOEXEC); ++ int tty0 = open(TTY_0, O_WRONLY | O_CLOEXEC); + char filename[16]; + + if (tty0 < 0) +@@ -536,7 +597,7 @@ setup_tty(struct weston_launch *wl, cons + if (ioctl(tty0, VT_OPENQRY, &wl->ttynr) < 0 || wl->ttynr == -1) + error(1, errno, "failed to find non-opened console"); + +- snprintf(filename, sizeof filename, "/dev/tty%d", wl->ttynr); ++ snprintf(filename, sizeof filename, "%s%d", TTY_BASENAME, wl->ttynr); + wl->tty = open(filename, O_RDWR | O_NOCTTY); + close(tty0); + } +@@ -544,26 +605,26 @@ setup_tty(struct weston_launch *wl, cons + if (wl->tty < 0) + error(1, errno, "failed to open tty"); + +- if (fstat(wl->tty, &buf) == -1 || +- major(buf.st_rdev) != TTY_MAJOR || minor(buf.st_rdev) == 0) +- error(1, 0, "weston-launch must be run from a virtual terminal"); +- + if (tty) { + if (fstat(wl->tty, &buf) < 0) + error(1, errno, "stat %s failed", tty); + +- if (major(buf.st_rdev) != TTY_MAJOR) +- error(1, 0, "invalid tty device: %s", tty); +- +- wl->ttynr = minor(buf.st_rdev); ++ if(ioctl(wl->tty, VT_GETINDEX, &wl->ttynr)) ++ error(1, errno, "failed to get vt index for tty %s", tty); + } + + if (ioctl(wl->tty, KDGKBMODE, &wl->kb_mode)) + error(1, errno, "failed to get current keyboard mode: %m\n"); + +- if (ioctl(wl->tty, KDSKBMUTE, 1) && +- ioctl(wl->tty, KDSKBMODE, K_OFF)) +- error(1, errno, "failed to set K_OFF keyboard mode: %m\n"); ++ if (ioctl(wl->tty, KDSKBMODE, K_RAW) == -1) ++ error(1, errno, "Could not set keyboard mode to K_RAW\n"); ++ ++ struct termios tios; ++ if (tcgetattr(wl->tty, &tios)) ++ error(1, errno, "Failed to get terminal attribute %m\n"); ++ cfmakeraw(&tios); ++ if (tcsetattr(wl->tty , TCSAFLUSH, &tios)) ++ error(1, errno, "Failed to set terminal attribute %m\n"); + + if (ioctl(wl->tty, KDSETMODE, KD_GRAPHICS)) + error(1, errno, "failed to set KD_GRAPHICS mode on tty: %m\n"); +@@ -571,6 +632,7 @@ setup_tty(struct weston_launch *wl, cons + mode.mode = VT_PROCESS; + mode.relsig = SIGUSR1; + mode.acqsig = SIGUSR2; ++ mode.frsig = SIGIO; /* not used, but has to be set anyway */ + if (ioctl(wl->tty, VT_SETMODE, &mode) < 0) + error(1, errno, "failed to take control of vt handling\n"); + +@@ -735,7 +797,7 @@ main(int argc, char *argv[]) + #else + " - enable systemd session support for weston-launch.\n" + #endif +- " - or add yourself to the 'weston-launch' group."); ++ " - or add yourself to the 'weston-launch' group.\n"); + + if (setup_tty(&wl, tty) < 0) + exit(EXIT_FAILURE); Index: x11-wm/weston/files/patch-shared_file-util.c =================================================================== --- /dev/null +++ x11-wm/weston/files/patch-shared_file-util.c @@ -0,0 +1,11 @@ +--- shared/file-util.c.orig 2015-10-24 00:02:43 UTC ++++ shared/file-util.c +@@ -34,6 +34,8 @@ + + #include "file-util.h" + ++#define ETIME ETIMEDOUT ++ + static int + current_time_str(char *str, size_t len, const char *fmt) + { Index: x11-wm/weston/files/patch-shared_string-helpers.h =================================================================== --- /dev/null +++ x11-wm/weston/files/patch-shared_string-helpers.h @@ -0,0 +1,10 @@ +--- shared/string-helpers.h.orig 2016-11-20 21:46:09 UTC ++++ shared/string-helpers.h +@@ -31,6 +31,7 @@ + #include + #include + #include ++#include + + /* Convert string to integer + * Index: x11-wm/weston/files/patch-shared_xalloc.c =================================================================== --- /dev/null +++ x11-wm/weston/files/patch-shared_xalloc.c @@ -0,0 +1,11 @@ +--- shared/xalloc.c.orig 2016-10-22 16:23:57 UTC ++++ shared/xalloc.c +@@ -32,6 +32,8 @@ + + #include "xalloc.h" + ++#define program_invocation_short_name getprogname() ++ + void * + fail_on_null(void *p, size_t size, char *file, int32_t line) + { Index: x11-wm/weston/files/patch-tests_surface-screenshot.c =================================================================== --- /dev/null +++ x11-wm/weston/files/patch-tests_surface-screenshot.c @@ -0,0 +1,11 @@ +--- tests/surface-screenshot.c.orig 2017-01-19 01:41:20 UTC ++++ tests/surface-screenshot.c +@@ -37,6 +37,8 @@ + #include "compositor/weston.h" + #include "file-util.h" + ++#define ETIME ETIMEDOUT ++ + static char * + encode_PAM_comment_line(const char *comment) + { Index: x11-wm/weston/files/patch-tests_weston-test-runner.c =================================================================== --- /dev/null +++ x11-wm/weston/files/patch-tests_weston-test-runner.c @@ -0,0 +1,11 @@ +--- tests/weston-test-runner.c.orig 2017-02-07 22:58:35 UTC ++++ tests/weston-test-runner.c +@@ -38,6 +38,8 @@ + + #define SKIP 77 + ++#define program_invocation_short_name getprogname() ++ + char __attribute__((weak)) *server_parameters=""; + + extern const struct weston_test __start_test_section, __stop_test_section; Index: x11-wm/weston/files/patch-tools_zunitc_src_zunitc__impl.c =================================================================== --- /dev/null +++ x11-wm/weston/files/patch-tools_zunitc_src_zunitc__impl.c @@ -0,0 +1,10 @@ +--- tools/zunitc/src/zunitc_impl.c.orig 2016-08-10 22:56:50 UTC ++++ tools/zunitc/src/zunitc_impl.c +@@ -36,6 +36,7 @@ + #include + #include + #include ++#include + + #include "zunitc/zunitc_impl.h" + #include "zunitc/zunitc.h" Index: x11-wm/weston/files/patch-xwayland_launcher.c =================================================================== --- /dev/null +++ x11-wm/weston/files/patch-xwayland_launcher.c @@ -0,0 +1,58 @@ +--- xwayland/launcher.c.orig 2017-01-19 01:41:20 UTC ++++ xwayland/launcher.c +@@ -42,6 +42,10 @@ + #include "shared/string-helpers.h" + #include "compositor/weston.h" + ++#define LOCK_FMT "/tmp/.X%d-lock" ++#define SOCKET_FMT "/tmp/.X11-unix/X%d" ++#define SOCKET2_FMT "/tmp/.X11-unix/X%d_" ++ + static int + weston_xserver_handle_event(int listen_fd, uint32_t mask, void *data) + { +@@ -68,9 +72,11 @@ weston_xserver_shutdown(struct weston_xs + { + char path[256]; + +- snprintf(path, sizeof path, "/tmp/.X%d-lock", wxs->display); ++ snprintf(path, sizeof path, LOCK_FMT, wxs->display); + unlink(path); +- snprintf(path, sizeof path, "/tmp/.X11-unix/X%d", wxs->display); ++ snprintf(path, sizeof path, SOCKET_FMT, wxs->display); ++ unlink(path); ++ snprintf(path, sizeof path, SOCKET2_FMT, wxs->display); + unlink(path); + if (wxs->pid == 0) { + wl_event_source_remove(wxs->abstract_source); +@@ -98,10 +104,10 @@ bind_to_abstract_socket(int display) + + addr.sun_family = AF_LOCAL; + name_size = snprintf(addr.sun_path, sizeof addr.sun_path, +- "%c/tmp/.X11-unix/X%d", 0, display); ++ SOCKET2_FMT, display); + size = offsetof(struct sockaddr_un, sun_path) + name_size; + if (bind(fd, (struct sockaddr *) &addr, size) < 0) { +- weston_log("failed to bind to @%s: %m\n", addr.sun_path + 1); ++ weston_log("failed to bind to '%s'\n", addr.sun_path); + close(fd); + return -1; + } +@@ -127,7 +133,7 @@ bind_to_unix_socket(int display) + + addr.sun_family = AF_LOCAL; + name_size = snprintf(addr.sun_path, sizeof addr.sun_path, +- "/tmp/.X11-unix/X%d", display) + 1; ++ SOCKET_FMT, display); + size = offsetof(struct sockaddr_un, sun_path) + name_size; + unlink(addr.sun_path); + if (bind(fd, (struct sockaddr *) &addr, size) < 0) { +@@ -154,7 +160,7 @@ create_lockfile(int display, char *lockf + int fd, size; + pid_t other; + +- snprintf(lockfile, lsize, "/tmp/.X%d-lock", display); ++ snprintf(lockfile, lsize, LOCK_FMT, display); + fd = open(lockfile, O_WRONLY | O_CLOEXEC | O_CREAT | O_EXCL, 0444); + if (fd < 0 && errno == EEXIST) { + fd = open(lockfile, O_CLOEXEC | O_RDONLY); Index: x11-wm/weston/pkg-descr =================================================================== --- /dev/null +++ x11-wm/weston/pkg-descr @@ -0,0 +1,6 @@ +Weston is a reference implementation of a Wayland compositor. Weston can +run as an X client or under KMS and ships with a few demo clients. The Weston +compositor is a minimal and fast compositor and is suitable for many embedded +and mobile use cases + +www: http://wayland.freedesktop.org Index: x11-wm/weston/pkg-plist =================================================================== --- /dev/null +++ x11-wm/weston/pkg-plist @@ -0,0 +1,104 @@ +%%SUID%%@(,,4755) bin/weston-launch +%%NO_SUID%%bin/weston-launch +bin/weston +bin/wcap-decode +%%CLIENTS_INSTALL%%bin/weston-calibrator +%%CLIENTS_INSTALL%%bin/weston-clickdot +%%CLIENTS_INSTALL%%bin/weston-cliptest +%%CLIENTS_INSTALL%%bin/weston-confine +%%CLIENTS_INSTALL%%bin/weston-dnd +%%CLIENTS_INSTALL%%bin/weston-editor +%%CLIENTS_INSTALL%%bin/weston-eventdemo +%%CLIENTS_INSTALL%%bin/weston-flower +%%CLIENTS_INSTALL%%bin/weston-fullscreen +%%CLIENTS_INSTALL%%bin/weston-image +%%CLIENTS_INSTALL%%bin/weston-info +%%CLIENTS_INSTALL%%bin/weston-multi-resource +%%CLIENTS_INSTALL%%bin/weston-presentation-shm +%%CLIENTS_INSTALL%%bin/weston-resizor +%%CLIENTS_INSTALL%%bin/weston-scaler +%%CLIENTS_INSTALL%%bin/weston-simple-damage +%%CLIENTS_INSTALL%%bin/weston-simple-dmabuf-intel +%%CLIENTS_INSTALL%%bin/weston-simple-dmabuf-v4l +%%CLIENTS_INSTALL%%bin/weston-simple-egl +%%CLIENTS_INSTALL%%bin/weston-simple-shm +%%CLIENTS_INSTALL%%bin/weston-simple-touch +%%CLIENTS_INSTALL%%bin/weston-smoke +%%CLIENTS_INSTALL%%bin/weston-stacking +%%CLIENTS_INSTALL%%bin/weston-subsurfaces +%%CLIENTS_INSTALL%%bin/weston-terminal +%%CLIENTS_INSTALL%%bin/weston-transformed +%%DRM%%include/libweston-2/compositor-drm.h +include/libweston-2/compositor-fbdev.h +include/libweston-2/compositor-headless.h +include/libweston-2/compositor-rdp.h +%%SCFB%%include/libweston-2/compositor-scfb.h +%%WAYLAND%%include/libweston-2/compositor-wayland.h +%%X11%%include/libweston-2/compositor-x11.h +include/libweston-2/compositor.h +include/libweston-2/config-parser.h +include/libweston-2/libweston-desktop.h +include/libweston-2/matrix.h +include/libweston-2/plugin-registry.h +include/libweston-2/timeline-object.h +include/libweston-2/version.h +include/libweston-2/windowed-output-api.h +%%XWAYLAND%%include/libweston-2/xwayland-api.h +include/libweston-2/zalloc.h +include/weston/ivi-layout-export.h +include/weston/weston.h +lib/libweston-2.so +lib/libweston-2.so.0 +lib/libweston-2.so.0.0.0 +%%DRM%%lib/libweston-2/drm-backend.so +lib/libweston-2/gl-renderer.so +lib/libweston-2/headless-backend.so +%%SCFB%%lib/libweston-2/scfb-backend.so +%%WAYLAND%%lib/libweston-2/wayland-backend.so +%%X11%%lib/libweston-2/x11-backend.so +%%XWAYLAND%%lib/libweston-2/xwayland.so +lib/libweston-desktop-2.so +lib/libweston-desktop-2.so.0 +lib/libweston-desktop-2.so.0.0.0 +lib/weston/cms-colord.so +lib/weston/cms-static.so +lib/weston/desktop-shell.so +lib/weston/fullscreen-shell.so +lib/weston/hmi-controller.so +lib/weston/ivi-shell.so +libdata/pkgconfig/libweston-2.pc +libdata/pkgconfig/libweston-desktop-2.pc +libdata/pkgconfig/weston.pc +libexec/weston-desktop-shell +libexec/weston-ivi-shell-user-interface +libexec/weston-keyboard +libexec/weston-screenshooter +libexec/weston-simple-im +man/man1/weston.1.gz +man/man5/weston.ini.5.gz +%%DRM%%man/man7/weston-drm.7.gz +share/wayland-sessions/weston.desktop +%%DATADIR%%/background.png +%%DATADIR%%/border.png +%%DATADIR%%/fullscreen.png +%%DATADIR%%/home.png +%%DATADIR%%/icon_editor.png +%%DATADIR%%/icon_flower.png +%%DATADIR%%/icon_ivi_clickdot.png +%%DATADIR%%/icon_ivi_flower.png +%%DATADIR%%/icon_ivi_simple-egl.png +%%DATADIR%%/icon_ivi_simple-shm.png +%%DATADIR%%/icon_ivi_smoke.png +%%DATADIR%%/icon_terminal.png +%%DATADIR%%/icon_window.png +%%DATADIR%%/panel.png +%%DATADIR%%/pattern.png +%%DATADIR%%/random.png +%%DATADIR%%/sidebyside.png +%%DATADIR%%/sign_close.png +%%DATADIR%%/sign_maximize.png +%%DATADIR%%/sign_minimize.png +%%DATADIR%%/terminal.png +%%DATADIR%%/tiling.png +%%DATADIR%%/wayland.png +%%DATADIR%%/wayland.svg