Index: GIDs =================================================================== --- GIDs +++ GIDs @@ -800,7 +800,7 @@ # free: 857 # free: 858 # free: 859 -# free: 860 +weston-launch:*:860: # free: 861 # free: 862 # free: 863 Index: x11-wm/Makefile =================================================================== --- x11-wm/Makefile +++ x11-wm/Makefile @@ -120,6 +121,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,112 @@ +# Created by: Johannes Lundberg +# $FreeBSD$ + +PORTNAME= weston +PORTVERSION= 3.0.0 +CATEGORIES= x11-wm wayland +MASTER_SITES= http://wayland.freedesktop.org/releases/ + +MAINTAINER= johalun0@gmail.com +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 \ + libevent.so:devel/libevent \ + 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 \ + liblcms2.so:graphics/lcms2 + +USES= autoreconf alias gmake pathfix jpeg libtool pkgconfig tar:xz localbase:ldflags + +USE_XORG= x11 xcb xcursor +USE_GL= egl gbm glesv2 +USE_LDCONFIG= yes + +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" + +INSTALL_TARGET= install-strip + +.include + +.if !empty(PORT_OPTIONS:MCLIENTS_INSTALL) +USE_GNOME+=glib20 +.endif + +# 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/ + @if ! pkg-config --exists wayland-egl; then \ + ${ECHO_MSG} "${PKGNAME}: Needs mesa-libs with wayland support enabled."; \ + ${FALSE}; \ + fi + +.include Index: x11-wm/weston/distinfo =================================================================== --- /dev/null +++ x11-wm/weston/distinfo @@ -0,0 +1,3 @@ +TIMESTAMP = 1507883343 +SHA256 (weston-3.0.0.tar.xz) = cde1d55e8dd70c3cbb3d1ec72f60e60000041579caa1d6a262bd9c35e93723a5 +SIZE (weston-3.0.0.tar.xz) = 1300340 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-10-13 15:26:13 UTC ++++ Makefile.am +@@ -85,6 +85,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 \ +@@ -295,6 +296,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 \ +@@ -459,6 +461,28 @@ fbdev_backend_la_CFLAGS = \ + fbdev_backend_la_SOURCES = \ + libweston/compositor-fbdev.c \ + libweston/compositor-fbdev.h \ ++ shared/helpers.h \ ++ $(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 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-08-08 18:57:02 UTC ++++ clients/desktop-shell.c +@@ -41,6 +41,7 @@ + #include + #include + #include ++#include + + #include + #include "window.h" +@@ -49,6 +50,8 @@ + #include "shared/helpers.h" + #include "shared/xalloc.h" + #include "shared/zalloc.h" ++ ++#define program_invocation_short_name getprogname() + + #include "weston-desktop-shell-client-protocol.h" + Index: x11-wm/weston/files/patch-clients_ivi-shell-user-interface.c =================================================================== --- /dev/null +++ x11-wm/weston/files/patch-clients_ivi-shell-user-interface.c @@ -0,0 +1,161 @@ +--- clients/ivi-shell-user-interface.c.orig 2017-10-13 16:13:46 UTC ++++ clients/ivi-shell-user-interface.c +@@ -218,7 +218,7 @@ set_pointer_image(struct wlContextCommon *pCtx, uint32 + return; + + if (cursor->image_count <= index) { +- fprintf(stderr, "cursor index out of range\n"); ++ fprintf(stderr, "cursor index out of range\r\n"); + return; + } + +@@ -250,7 +250,7 @@ PointerHandleEnter(void *data, struct wl_pointer *wlPo + pCtx->enterSurface = wlSurface; + set_pointer_image(pCtx, 0); + #ifdef _DEBUG +- printf("ENTER PointerHandleEnter: x(%d), y(%d)\n", sx, sy); ++ printf("ENTER PointerHandleEnter: x(%d), y(%d)\r\n", sx, sy); + #endif + } + +@@ -263,7 +263,7 @@ PointerHandleLeave(void *data, struct wl_pointer *wlPo + pCtx->enterSurface = NULL; + + #ifdef _DEBUG +- printf("ENTER PointerHandleLeave: serial(%d)\n", serial); ++ printf("ENTER PointerHandleLeave: serial(%d)\r\n", serial); + #endif + } + +@@ -272,7 +272,7 @@ PointerHandleMotion(void *data, struct wl_pointer *wlP + wl_fixed_t sx, wl_fixed_t sy) + { + #ifdef _DEBUG +- printf("ENTER PointerHandleMotion: x(%d), y(%d)\n", sx, sy); ++ printf("ENTER PointerHandleMotion: x(%d), y(%d)\r\n", sx, sy); + #endif + } + +@@ -287,13 +287,13 @@ execute_process(char *path, char *argv[]) + { + pid_t pid = fork(); + if (pid < 0) +- fprintf(stderr, "Failed to fork\n"); ++ fprintf(stderr, "Failed to fork\r\n"); + + if (pid) + return pid; + + if (-1 == execve(path, argv, environ)) { +- fprintf(stderr, "Failed to execve %s\n", path); ++ fprintf(stderr, "Failed to execve %s\r\n", path); + exit(1); + } + +@@ -408,7 +408,7 @@ PointerHandleButton(void *data, struct wl_pointer *wlP + break; + } + #ifdef _DEBUG +- printf("ENTER PointerHandleButton: button(%d), state(%d)\n", ++ printf("ENTER PointerHandleButton: button(%d), state(%d)\r\n", + button, state); + #endif + } +@@ -418,7 +418,7 @@ PointerHandleAxis(void *data, struct wl_pointer *wlPoi + uint32_t axis, wl_fixed_t value) + { + #ifdef _DEBUG +- printf("ENTER PointerHandleAxis: axis(%d), value(%d)\n", axis, value); ++ printf("ENTER PointerHandleAxis: axis(%d), value(%d)\r\n", axis, value); + #endif + } + +@@ -766,7 +766,7 @@ create_cursors(struct wlContextCommon *cmm) + } + + if (!cursor) { +- fprintf(stderr, "could not load cursor '%s'\n", ++ fprintf(stderr, "could not load cursor '%s'\r\n", + cursors[i].names[0]); + } + +@@ -805,7 +805,7 @@ createShmBuffer(struct wlContextStruct *p_wlCtx) + + fd = os_create_anonymous_file(size); + if (fd < 0) { +- fprintf(stderr, "creating a buffer file for %d B failed: %m\n", ++ fprintf(stderr, "creating a buffer file for %d B failed: %m\r\n", + size); + return ; + } +@@ -814,7 +814,7 @@ createShmBuffer(struct wlContextStruct *p_wlCtx) + mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); + + if (MAP_FAILED == p_wlCtx->data) { +- fprintf(stderr, "mmap failed: %m\n"); ++ fprintf(stderr, "mmap failed: %m\r\n"); + close(fd); + return; + } +@@ -827,7 +827,7 @@ createShmBuffer(struct wlContextStruct *p_wlCtx) + WL_SHM_FORMAT_ARGB8888); + + if (NULL == p_wlCtx->wlBuffer) { +- fprintf(stderr, "wl_shm_create_buffer failed: %m\n"); ++ fprintf(stderr, "wl_shm_create_buffer failed: %m\r\n"); + close(fd); + return; + } +@@ -866,7 +866,7 @@ createSurface(struct wlContextStruct *p_wlCtx) + p_wlCtx->wlSurface = + wl_compositor_create_surface(p_wlCtx->cmm->wlCompositor); + if (NULL == p_wlCtx->wlSurface) { +- printf("Error: wl_compositor_create_surface failed.\n"); ++ printf("Error: wl_compositor_create_surface failed.\r\n"); + destroyWLContextCommon(p_wlCtx->cmm); + abort(); + } +@@ -920,7 +920,7 @@ create_ivisurface(struct wlContextStruct *p_wlCtx, + id_surface, + p_wlCtx->wlSurface); + if (ivisurf == NULL) { +- fprintf(stderr, "Failed to create ivi_client_surface\n"); ++ fprintf(stderr, "Failed to create ivi_client_surface\r\n"); + return; + } + +@@ -935,7 +935,7 @@ create_ivisurfaceFromFile(struct wlContextStruct *p_wl + cairo_surface_t *surface = load_cairo_surface(imageFile); + + if (NULL == surface) { +- fprintf(stderr, "Failed to load_cairo_surface %s\n", imageFile); ++ fprintf(stderr, "Failed to load_cairo_surface %s\r\n", imageFile); + return; + } + +@@ -1226,7 +1226,7 @@ int main(int argc, char **argv) + + wlCtxCommon.wlDisplay = wl_display_connect(NULL); + if (NULL == wlCtxCommon.wlDisplay) { +- printf("Error: wl_display_connect failed.\n"); ++ printf("Error: wl_display_connect failed.\r\n"); + return -1; + } + +@@ -1238,14 +1238,14 @@ int main(int argc, char **argv) + wl_display_roundtrip(wlCtxCommon.wlDisplay); + + if (wlCtxCommon.wlShm == NULL) { +- fprintf(stderr, "No wl_shm global\n"); ++ fprintf(stderr, "No wl_shm global\r\n"); + exit(1); + } + + wl_display_roundtrip(wlCtxCommon.wlDisplay); + + if (!(wlCtxCommon.formats & (1 << WL_SHM_FORMAT_XRGB8888))) { +- fprintf(stderr, "WL_SHM_FORMAT_XRGB32 not available\n"); ++ fprintf(stderr, "WL_SHM_FORMAT_XRGB32 not available\r\n"); + exit(1); + } + 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 2017-08-08 18:57:02 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 2017-08-08 18:57:02 UTC ++++ clients/terminal.c +@@ -32,7 +32,11 @@ + #include + #include + #include +-#include ++/* #include */ ++#include ++#include ++#include ++#include + #include + #include + #include +@@ -3112,7 +3116,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 2017-08-08 18:57:02 UTC ++++ clients/weston-info.c +@@ -605,9 +605,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-clients_window.c =================================================================== --- /dev/null +++ x11-wm/weston/files/patch-clients_window.c @@ -0,0 +1,450 @@ +--- clients/window.c.orig 2017-10-13 16:21:15 UTC ++++ clients/window.c +@@ -616,7 +616,7 @@ egl_window_surface_acquire(struct toysurface *base, EG + cairo_device_acquire(device); + if (!eglMakeCurrent(surface->display->dpy, surface->egl_surface, + surface->egl_surface, ctx)) +- fprintf(stderr, "failed to make surface current\n"); ++ fprintf(stderr, "failed to make surface current\r\n"); + + return 0; + } +@@ -633,7 +633,7 @@ egl_window_surface_release(struct toysurface *base) + + if (!eglMakeCurrent(surface->display->dpy, + EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)) +- fprintf(stderr, "failed to make context current\n"); ++ fprintf(stderr, "failed to make context current\r\n"); + + cairo_device_release(device); + } +@@ -746,14 +746,14 @@ make_shm_pool(struct display *display, int size, void + + fd = os_create_anonymous_file(size); + if (fd < 0) { +- fprintf(stderr, "creating a buffer file for %d B failed: %m\n", ++ fprintf(stderr, "creating a buffer file for %d B failed: %m\r\n", + size); + return NULL; + } + + *data = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); + if (*data == MAP_FAILED) { +- fprintf(stderr, "mmap failed: %m\n"); ++ fprintf(stderr, "mmap failed: %m\r\n"); + close(fd); + return NULL; + } +@@ -935,7 +935,7 @@ check_size(struct rectangle *rect) + return 0; + + fprintf(stderr, "tried to create surface of " +- "width: %d, height: %d\n", rect->width, rect->height); ++ "width: %d, height: %d\r\n", rect->width, rect->height); + return -1; + } + +@@ -1014,7 +1014,7 @@ shm_surface_buffer_state_debug(struct shm_surface *sur + } + + bufs[MAX_LEAVES] = '\0'; +- DBG_OBJ(surface->surface, "%s, leaves [%s]\n", msg, bufs); ++ DBG_OBJ(surface->surface, "%s, leaves [%s]\r\n", msg, bufs); + #endif + } + +@@ -1080,11 +1080,11 @@ shm_surface_prepare(struct toysurface *base, int dx, i + if (!leaf || surface->leaf[i].cairo_surface) + leaf = &surface->leaf[i]; + } +- DBG_OBJ(surface->surface, "pick leaf %d\n", ++ DBG_OBJ(surface->surface, "pick leaf %d\r\n", + (int)(leaf - &surface->leaf[0])); + + if (!leaf) { +- fprintf(stderr, "%s: all buffers are held by the server.\n", ++ fprintf(stderr, "%s: all buffers are held by the server.\r\n", + __func__); + exit(1); + return NULL; +@@ -1163,7 +1163,7 @@ shm_surface_swap(struct toysurface *base, + server_allocation->width, server_allocation->height); + wl_surface_commit(surface->surface); + +- DBG_OBJ(surface->surface, "leaf %d busy\n", ++ DBG_OBJ(surface->surface, "leaf %d busy\r\n", + (int)(leaf - &surface->leaf[0])); + + leaf->busy = 1; +@@ -1198,7 +1198,7 @@ shm_surface_create(struct display *display, struct wl_ + uint32_t flags, struct rectangle *rectangle) + { + struct shm_surface *surface; +- DBG_OBJ(wl_surface, "\n"); ++ DBG_OBJ(wl_surface, "\r\n"); + + surface = xzalloc(sizeof *surface); + surface->base.prepare = shm_surface_prepare; +@@ -1356,7 +1356,7 @@ create_cursors(struct display *display) + + display->cursor_theme = wl_cursor_theme_load(theme, size, display->shm); + if (!display->cursor_theme) { +- fprintf(stderr, "could not load theme '%s'\n", theme); ++ fprintf(stderr, "could not load theme '%s'\r\n", theme); + return; + } + free(theme); +@@ -1370,7 +1370,7 @@ create_cursors(struct display *display) + display->cursor_theme, cursors[i].names[j]); + + if (!cursor) +- fprintf(stderr, "could not load cursor '%s'\n", ++ fprintf(stderr, "could not load cursor '%s'\r\n", + cursors[i].names[0]); + + display->cursors[i] = cursor; +@@ -2012,7 +2012,7 @@ window_schedule_redraw_task(struct window *window); + void + widget_schedule_redraw(struct widget *widget) + { +- DBG_OBJ(widget->surface->surface, "widget %p\n", widget); ++ DBG_OBJ(widget->surface->surface, "widget %p\r\n", widget); + widget->surface->redraw_needed = 1; + window_schedule_redraw_task(widget->window); + } +@@ -2151,7 +2151,7 @@ tooltip_timer_reset(struct tooltip *tooltip) + its.it_value.tv_sec = TOOLTIP_TIMEOUT / 1000; + its.it_value.tv_nsec = (TOOLTIP_TIMEOUT % 1000) * 1000 * 1000; + if (timerfd_settime(tooltip->tooltip_fd, 0, &its, NULL) < 0) { +- fprintf(stderr, "could not set timerfd\n: %m"); ++ fprintf(stderr, "could not set timerfd\r\n: %m"); + return -1; + } + +@@ -2188,7 +2188,7 @@ widget_set_tooltip(struct widget *parent, char *entry, + tooltip->entry = strdup(entry); + tooltip->tooltip_fd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC); + if (tooltip->tooltip_fd < 0) { +- fprintf(stderr, "could not create timerfd\n: %m"); ++ fprintf(stderr, "could not create timerfd\r\n: %m"); + return -1; + } + +@@ -2697,7 +2697,7 @@ cursor_delay_timer_reset(struct input *input, uint32_t + its.it_value.tv_sec = duration / 1000; + its.it_value.tv_nsec = (duration % 1000) * 1000 * 1000; + if (timerfd_settime(input->cursor_delay_fd, 0, &its, NULL) < 0) +- fprintf(stderr, "could not set cursor timerfd\n: %m"); ++ fprintf(stderr, "could not set cursor timerfd\r\n: %m"); + } + + static void cancel_pointer_image_update(struct input *input) +@@ -2739,7 +2739,7 @@ pointer_handle_enter(void *data, struct wl_pointer *po + + window = wl_surface_get_user_data(surface); + if (surface != window->main_surface->surface) { +- DBG("Ignoring input event from subsurface %p\n", surface); ++ DBG("Ignoring input event from subsurface %p\r\n", surface); + return; + } + +@@ -3018,14 +3018,14 @@ keyboard_handle_keymap(void *data, struct wl_keyboard + close(fd); + + if (!keymap) { +- fprintf(stderr, "failed to compile keymap\n"); ++ fprintf(stderr, "failed to compile keymap\r\n"); + return; + } + + /* Set up XKB state */ + state = xkb_state_new(keymap); + if (!state) { +- fprintf(stderr, "failed to create XKB state\n"); ++ fprintf(stderr, "failed to create XKB state\r\n"); + xkb_keymap_unref(keymap); + return; + } +@@ -3053,13 +3053,13 @@ keyboard_handle_keymap(void *data, struct wl_keyboard + input->xkb.compose_table = compose_table; + } else { + fprintf(stderr, "could not create XKB compose state. " +- "Disabiling compose.\n"); ++ "Disabiling compose.\r\n"); + xkb_compose_table_unref(compose_table); + compose_table = NULL; + } + } else { + fprintf(stderr, "could not create XKB compose table for locale '%s'. " +- "Disabiling compose\n", locale); ++ "Disabiling compose\r\n", locale); + } + #endif + +@@ -3290,12 +3290,12 @@ touch_handle_down(void *data, struct wl_touch *wl_touc + input->display->serial = serial; + input->touch_focus = wl_surface_get_user_data(surface); + if (!input->touch_focus) { +- DBG("Failed to find to touch focus for surface %p\n", surface); ++ DBG("Failed to find to touch focus for surface %p\r\n", surface); + return; + } + + if (surface != input->touch_focus->main_surface->surface) { +- DBG("Ignoring input event from subsurface %p\n", surface); ++ DBG("Ignoring input event from subsurface %p\r\n", surface); + input->touch_focus = NULL; + return; + } +@@ -3332,7 +3332,7 @@ touch_handle_up(void *data, struct wl_touch *wl_touch, + struct touch_point *tp, *tmp; + + if (!input->touch_focus) { +- DBG("No touch focus found for touch up event!\n"); ++ DBG("No touch focus found for touch up event!\r\n"); + return; + } + +@@ -3361,10 +3361,10 @@ touch_handle_motion(void *data, struct wl_touch *wl_to + float sx = wl_fixed_to_double(x_w); + float sy = wl_fixed_to_double(y_w); + +- DBG("touch_handle_motion: %i %i\n", id, wl_list_length(&input->touch_point_list)); ++ DBG("touch_handle_motion: %i %i\r\n", id, wl_list_length(&input->touch_point_list)); + + if (!input->touch_focus) { +- DBG("No touch focus found for touch motion event!\n"); ++ DBG("No touch focus found for touch motion event!\r\n"); + return; + } + +@@ -3388,10 +3388,10 @@ touch_handle_frame(void *data, struct wl_touch *wl_tou + struct input *input = data; + struct touch_point *tp, *tmp; + +- DBG("touch_handle_frame\n"); ++ DBG("touch_handle_frame\r\n"); + + if (!input->touch_focus) { +- DBG("No touch focus found for touch frame event!\n"); ++ DBG("No touch focus found for touch frame event!\r\n"); + return; + } + +@@ -3408,10 +3408,10 @@ touch_handle_cancel(void *data, struct wl_touch *wl_to + struct input *input = data; + struct touch_point *tp, *tmp; + +- DBG("touch_handle_cancel\n"); ++ DBG("touch_handle_cancel\r\n"); + + if (!input->touch_focus) { +- DBG("No touch focus found for touch cancel event!\n"); ++ DBG("No touch focus found for touch cancel event!\r\n"); + return; + } + +@@ -3760,7 +3760,7 @@ input_set_pointer_image_index(struct input *input, int + return; + + if (index >= (int) cursor->image_count) { +- fprintf(stderr, "cursor index out of range\n"); ++ fprintf(stderr, "cursor index out of range\r\n"); + return; + } + +@@ -4192,7 +4192,7 @@ idle_resize(struct window *window) + window->resize_needed = 0; + window->redraw_needed = 1; + +- DBG("from %dx%d to %dx%d\n", ++ DBG("from %dx%d to %dx%d\r\n", + window->main_surface->server_allocation.width, + window->main_surface->server_allocation.height, + window->pending_allocation.width, +@@ -4209,7 +4209,7 @@ undo_resize(struct window *window) + window->pending_allocation.height = + window->main_surface->server_allocation.height; + +- DBG("back to %dx%d\n", ++ DBG("back to %dx%d\r\n", + window->main_surface->server_allocation.width, + window->main_surface->server_allocation.height); + +@@ -4219,7 +4219,7 @@ undo_resize(struct window *window) + window->pending_allocation.height == 0) { + fprintf(stderr, "Error: Could not draw a surface, " + "most likely due to insufficient disk space in " +- "%s (XDG_RUNTIME_DIR).\n", getenv("XDG_RUNTIME_DIR")); ++ "%s (XDG_RUNTIME_DIR).\r\n", getenv("XDG_RUNTIME_DIR")); + exit(EXIT_FAILURE); + } + } +@@ -4496,14 +4496,14 @@ frame_callback(void *data, struct wl_callback *callbac + struct surface *surface = data; + + assert(callback == surface->frame_cb); +- DBG_OBJ(callback, "done\n"); ++ DBG_OBJ(callback, "done\r\n"); + wl_callback_destroy(callback); + surface->frame_cb = NULL; + + surface->last_time = time; + + if (surface->redraw_needed || surface->window->redraw_needed) { +- DBG_OBJ(surface->surface, "window_schedule_redraw_task\n"); ++ DBG_OBJ(surface->surface, "window_schedule_redraw_task\r\n"); + window_schedule_redraw_task(surface->window); + } + } +@@ -4515,7 +4515,7 @@ static const struct wl_callback_listener listener = { + static int + surface_redraw(struct surface *surface) + { +- DBG_OBJ(surface->surface, "begin\n"); ++ DBG_OBJ(surface->surface, "begin\r\n"); + + if (!surface->window->redraw_needed && !surface->redraw_needed) + return 0; +@@ -4527,24 +4527,24 @@ surface_redraw(struct surface *surface) + if (!surface->window->redraw_needed) + return 0; + +- DBG_OBJ(surface->frame_cb, "cancelled\n"); ++ DBG_OBJ(surface->frame_cb, "cancelled\r\n"); + wl_callback_destroy(surface->frame_cb); + } + + if (surface->widget->use_cairo && + !widget_get_cairo_surface(surface->widget)) { +- DBG_OBJ(surface->surface, "cancelled due to buffer failure\n"); ++ DBG_OBJ(surface->surface, "cancelled due to buffer failure\r\n"); + return -1; + } + + surface->frame_cb = wl_surface_frame(surface->surface); + wl_callback_add_listener(surface->frame_cb, &listener, surface); +- DBG_OBJ(surface->frame_cb, "new\n"); ++ DBG_OBJ(surface->frame_cb, "new\r\n"); + + surface->redraw_needed = 0; +- DBG_OBJ(surface->surface, "-> widget_redraw\n"); ++ DBG_OBJ(surface->surface, "-> widget_redraw\r\n"); + widget_redraw(surface->widget); +- DBG_OBJ(surface->surface, "done\n"); ++ DBG_OBJ(surface->surface, "done\r\n"); + return 0; + } + +@@ -4556,7 +4556,7 @@ idle_redraw(struct task *task, uint32_t events) + int failed = 0; + int resized = 0; + +- DBG(" --------- \n"); ++ DBG(" --------- \r\n"); + + wl_list_init(&window->redraw_task.link); + window->redraw_task_scheduled = 0; +@@ -4564,7 +4564,7 @@ idle_redraw(struct task *task, uint32_t events) + if (window->resize_needed) { + /* throttle resizing to the main surface display */ + if (window->main_surface->frame_cb) { +- DBG_OBJ(window->main_surface->frame_cb, "pending\n"); ++ DBG_OBJ(window->main_surface->frame_cb, "pending\r\n"); + return; + } + +@@ -4618,7 +4618,7 @@ window_schedule_redraw(struct window *window) + { + struct surface *surface; + +- DBG_OBJ(window->main_surface->surface, "window %p\n", window); ++ DBG_OBJ(window->main_surface->surface, "window %p\r\n", window); + + wl_list_for_each(surface, &window->subsurface_list, link) + surface->redraw_needed = 1; +@@ -6102,31 +6102,31 @@ init_egl(struct display *d) + d->display, NULL); + + if (!eglInitialize(d->dpy, &major, &minor)) { +- fprintf(stderr, "failed to initialize EGL\n"); ++ fprintf(stderr, "failed to initialize EGL\r\n"); + return -1; + } + + if (!eglBindAPI(api)) { +- fprintf(stderr, "failed to bind EGL client API\n"); ++ fprintf(stderr, "failed to bind EGL client API\r\n"); + return -1; + } + + if (!eglChooseConfig(d->dpy, argb_cfg_attribs, + &d->argb_config, 1, &n) || n != 1) { +- fprintf(stderr, "failed to choose argb EGL config\n"); ++ fprintf(stderr, "failed to choose argb EGL config\r\n"); + return -1; + } + + d->argb_ctx = eglCreateContext(d->dpy, d->argb_config, + EGL_NO_CONTEXT, context_attribs); + if (d->argb_ctx == NULL) { +- fprintf(stderr, "failed to create EGL context\n"); ++ fprintf(stderr, "failed to create EGL context\r\n"); + return -1; + } + + d->argb_device = cairo_egl_device_create(d->dpy, d->argb_ctx); + if (cairo_device_status(d->argb_device) != CAIRO_STATUS_SUCCESS) { +- fprintf(stderr, "failed to get cairo EGL argb device\n"); ++ fprintf(stderr, "failed to get cairo EGL argb device\r\n"); + return -1; + } + +@@ -6216,14 +6216,14 @@ display_create(int *argc, char *argv[]) + + d->display = wl_display_connect(NULL); + if (d->display == NULL) { +- fprintf(stderr, "failed to connect to Wayland display: %m\n"); ++ fprintf(stderr, "failed to connect to Wayland display: %m\r\n"); + free(d); + return NULL; + } + + d->xkb_context = xkb_context_new(0); + if (d->xkb_context == NULL) { +- fprintf(stderr, "Failed to create XKB context\n"); ++ fprintf(stderr, "Failed to create XKB context\r\n"); + free(d); + return NULL; + } +@@ -6243,14 +6243,14 @@ display_create(int *argc, char *argv[]) + wl_registry_add_listener(d->registry, ®istry_listener, d); + + if (wl_display_roundtrip(d->display) < 0) { +- fprintf(stderr, "Failed to process Wayland connection: %m\n"); ++ fprintf(stderr, "Failed to process Wayland connection: %m\r\n"); + return NULL; + } + + #ifdef HAVE_CAIRO_EGL + if (init_egl(d) < 0) + fprintf(stderr, "EGL does not seem to work, " +- "falling back to software rendering and wl_shm.\n"); ++ "falling back to software rendering and wl_shm.\r\n"); + #endif + + create_cursors(d); +@@ -6288,11 +6288,11 @@ void + display_destroy(struct display *display) + { + if (!wl_list_empty(&display->window_list)) +- fprintf(stderr, "toytoolkit warning: %d windows exist.\n", ++ fprintf(stderr, "toytoolkit warning: %d windows exist.\r\n", + wl_list_length(&display->window_list)); + + if (!wl_list_empty(&display->deferred_list)) +- fprintf(stderr, "toytoolkit warning: deferred tasks exist.\n"); ++ fprintf(stderr, "toytoolkit warning: deferred tasks exist.\r\n"); + + cairo_surface_destroy(display->dummy_surface); + free(display->dummy_surface_data); Index: x11-wm/weston/files/patch-compositor_main.c =================================================================== --- /dev/null +++ x11-wm/weston/files/patch-compositor_main.c @@ -0,0 +1,164 @@ +--- compositor/main.c.orig 2017-08-08 18:57:02 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" +@@ -99,7 +102,7 @@ static int weston_log_timestamp(void) + + if (brokendown_time->tm_mday != cached_tm_mday) { + strftime(string, sizeof string, "%Y-%m-%d %Z", brokendown_time); +- fprintf(weston_logfile, "Date: %s\n", string); ++ fprintf(weston_logfile, "Date: %s\r\n", string); + + cached_tm_mday = brokendown_time->tm_mday; + } +@@ -115,6 +118,7 @@ custom_handler(const char *fmt, va_list arg) + weston_log_timestamp(); + fprintf(weston_logfile, "libwayland: "); + vfprintf(weston_logfile, fmt, arg); ++ fprintf(weston_logfile, "\r"); + } + + static void +@@ -149,6 +153,7 @@ vlog(const char *fmt, va_list ap) + + l = weston_log_timestamp(); + l += vfprintf(weston_logfile, fmt, ap); ++ l += fprintf(weston_logfile, "\r"); + + return l; + } +@@ -538,6 +543,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 +585,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 +696,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 +@@ -1579,6 +1595,57 @@ load_x11_backend(struct weston_compositor *c, + } + + 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; +@@ -1724,6 +1791,8 @@ load_backend(struct weston_compositor *compositor, con + 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")) +@@ -1823,9 +1892,9 @@ int main(int argc, char *argv[]) + weston_log_set_handler(vlog, vlog_continue); + weston_log_file_open(log); + +- weston_log("%s\n" +- STAMP_SPACE "%s\n" +- STAMP_SPACE "Bug reports to: %s\n" ++ weston_log("%s\r\n" ++ STAMP_SPACE "%s\r\n" ++ STAMP_SPACE "Bug reports to: %s\r\n" + STAMP_SPACE "Build: %s\n", + PACKAGE_STRING, PACKAGE_URL, PACKAGE_BUGREPORT, + BUILD_ID); 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-08-08 18:57:02 UTC ++++ configure.ac +@@ -244,6 +244,17 @@ AS_IF([test x$enable_fbdev_compositor = xyes], [ + 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], +@@ -708,6 +719,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,45 @@ +--- libweston/compositor-drm.c.orig 2017-08-08 18:57:03 UTC ++++ libweston/compositor-drm.c +@@ -34,7 +34,7 @@ + #include + #include + #include +-#include ++//#include + #include + #include + #include +@@ -3189,6 +3189,8 @@ drm_device_is_kms(struct drm_backend *b, struct udev_d + drmModeRes *res; + int id, fd; + ++ printf("%s] Got filename %s and sysnum %s\r\n", __func__, filename, sysnum); ++ + if (!filename) + return false; + +@@ -3251,6 +3253,16 @@ find_primary_gpu(struct drm_backend *b, const char *se + struct udev_device *device, *drm_device, *pci; + + e = udev_enumerate_new(b->udev); ++ ++#ifdef __FreeBSD__ ++ // libudev-devd don't support matching properly yet ++ device = udev_device_new_from_syspath(e, "/dev/dri/card0"); ++ if (drm_device_is_kms(b, device)) { ++ udev_enumerate_unref(e); ++ return device; ++ } ++#endif ++ + udev_enumerate_add_match_subsystem(e, "drm"); + udev_enumerate_add_match_sysname(e, "card[0-9]*"); + +@@ -3314,7 +3326,6 @@ find_primary_gpu(struct drm_backend *b, const char *se + /* If we're returning a device to use, we must have an open FD for + * it. */ + assert(!!drm_device == (b->drm.fd >= 0)); +- + udev_enumerate_unref(e); + return drm_device; + } 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-10-13 15:26:13 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-10-13 15:26:13 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-wayland.c =================================================================== --- /dev/null +++ x11-wm/weston/files/patch-libweston_compositor-wayland.c @@ -0,0 +1,47 @@ +--- libweston/compositor-wayland.c.orig 2017-10-13 16:26:11 UTC ++++ libweston/compositor-wayland.c +@@ -940,7 +940,7 @@ mode_feedback_successful(void *data, + { + enum mode_status *value = data; + +- printf("Mode switch successful\n"); ++ printf("Mode switch successful\r\n"); + + *value = MODE_STATUS_SUCCESS; + } +@@ -950,7 +950,7 @@ mode_feedback_failed(void *data, struct zwp_fullscreen + { + enum mode_status *value = data; + +- printf("Mode switch failed\n"); ++ printf("Mode switch failed\r\n"); + + *value = MODE_STATUS_FAIL; + } +@@ -960,7 +960,7 @@ mode_feedback_cancelled(void *data, struct zwp_fullscr + { + enum mode_status *value = data; + +- printf("Mode switch cancelled\n"); ++ printf("Mode switch cancelled\r\n"); + + *value = MODE_STATUS_CANCEL; + } +@@ -2447,7 +2447,7 @@ create_cursor(struct wayland_backend *b, + config->cursor_size, + b->parent.shm); + if (!b->cursor_theme) { +- fprintf(stderr, "could not load cursor theme\n"); ++ fprintf(stderr, "could not load cursor theme\r\n"); + return; + } + +@@ -2456,7 +2456,7 @@ create_cursor(struct wayland_backend *b, + b->cursor = wl_cursor_theme_get_cursor(b->cursor_theme, + left_ptrs[i]); + if (!b->cursor) { +- fprintf(stderr, "could not load left cursor\n"); ++ fprintf(stderr, "could not load left cursor\r\n"); + return; + } + } 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-08-08 18:57:03 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-08-08 18:57:03 UTC ++++ libweston/compositor.h +@@ -1672,6 +1672,7 @@ weston_compositor_create(struct wl_display *display, v + 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-08-08 18:57:03 UTC ++++ libweston/compositor.c +@@ -5406,10 +5406,10 @@ weston_compositor_set_presentation_clock_software( + { + /* 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; +@@ -5598,6 +5598,7 @@ weston_compositor_get_user_data(struct weston_composit + 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 2017-08-08 18:57:03 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,177 @@ +--- libweston/launcher-direct.c.orig 2017-08-08 18:57:03 UTC ++++ libweston/launcher-direct.c +@@ -33,19 +33,27 @@ + #include + #include + #include +-#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 BUILD_DRM_COMPOSITOR + +@@ -117,7 +125,7 @@ setup_tty(struct launcher_direct *launcher, int tty) + 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); +@@ -126,7 +134,7 @@ setup_tty(struct launcher_direct *launcher, int tty) + 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); +@@ -134,14 +142,20 @@ setup_tty(struct launcher_direct *launcher, int tty) + } + } + +- 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"); +@@ -153,20 +167,31 @@ setup_tty(struct launcher_direct *launcher, int tty) + 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; ++ } ++ + ret = ioctl(launcher->tty, KDSETMODE, KD_GRAPHICS); + if (ret) { + weston_log("failed to set KD_GRAPHICS mode on tty: %m\n"); +@@ -184,10 +209,10 @@ setup_tty(struct launcher_direct *launcher, int tty) + 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; +@@ -222,13 +247,11 @@ launcher_direct_open(struct weston_launcher *launcher_ + 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; +@@ -246,13 +269,22 @@ launcher_direct_restore(struct weston_launcher *launch + 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,84 @@ +--- libweston/launcher-weston-launch.c.orig 2017-08-08 18:57:03 UTC ++++ libweston/launcher-weston-launch.c +@@ -34,26 +34,36 @@ + #include + #include + #include +-#include ++/* #include */ + #include + #include + #include + #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 BUILD_DRM_COMPOSITOR + +@@ -161,13 +171,24 @@ launcher_weston_launch_restore(struct weston_launcher + 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. */ +@@ -244,7 +265,9 @@ launcher_weston_launch_connect(struct weston_launcher + /* 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 2017-08-08 18:57:03 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_pixel-formats.c =================================================================== --- /dev/null +++ x11-wm/weston/files/patch-libweston_pixel-formats.c @@ -0,0 +1,11 @@ +--- libweston/pixel-formats.c.orig 2017-08-08 18:57:03 UTC ++++ libweston/pixel-formats.c +@@ -25,7 +25,7 @@ + + #include "config.h" + +-#include ++#include + #include + #include + #include Index: x11-wm/weston/files/patch-libweston_timeline.c =================================================================== --- /dev/null +++ x11-wm/weston/files/patch-libweston_timeline.c @@ -0,0 +1,11 @@ +--- libweston/timeline.c.orig 2017-08-08 18:57:03 UTC ++++ libweston/timeline.c +@@ -36,6 +36,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,432 @@ +--- libweston/weston-launch.c.orig 2017-08-08 18:57:03 UTC ++++ libweston/weston-launch.c +@@ -33,7 +33,6 @@ + #include + #include + +-#include + #include + + #include +@@ -42,15 +41,40 @@ + #include + #include + #include +-#include ++/* #include */ + #include + #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\r\n",strerror(e)); \ ++ fprintf(stderr, __VA_ARGS__); \ ++ fprintf(stderr, "\r\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 + #include +@@ -61,12 +85,13 @@ + + #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) + #endif +@@ -122,7 +147,7 @@ read_groups(void) + n = getgroups(0, NULL); + + if (n < 0) { +- fprintf(stderr, "Unable to retrieve groups: %m\n"); ++ fprintf(stderr, "Unable to retrieve groups: %m\r\n"); + return NULL; + } + +@@ -131,7 +156,7 @@ read_groups(void) + return NULL; + + if (getgroups(n, groups) < 0) { +- fprintf(stderr, "Unable to retrieve groups: %m\n"); ++ fprintf(stderr, "Unable to retrieve groups: %m\r\n"); + free(groups); + return NULL; + } +@@ -143,7 +168,7 @@ weston_launch_allowed(struct weston_launch *wl) + { + struct group *gr; + gid_t *groups; +- int i; ++ int i,n; + #ifdef HAVE_SYSTEMD_LOGIN + char *session, *seat; + int err; +@@ -156,7 +181,8 @@ weston_launch_allowed(struct weston_launch *wl) + 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; +@@ -201,21 +227,21 @@ setup_pam(struct weston_launch *wl) + + err = pam_start("login", wl->pw->pw_name, &wl->pc, &wl->ph); + if (err != PAM_SUCCESS) { +- fprintf(stderr, "failed to start pam transaction: %d: %s\n", ++ fprintf(stderr, "failed to start pam transaction: %d: %s\r\n", + err, pam_strerror(wl->ph, err)); + return -1; + } + + err = pam_set_item(wl->ph, PAM_TTY, ttyname(wl->tty)); + if (err != PAM_SUCCESS) { +- fprintf(stderr, "failed to set PAM_TTY item: %d: %s\n", ++ fprintf(stderr, "failed to set PAM_TTY item: %d: %s\r\n", + err, pam_strerror(wl->ph, err)); + return -1; + } + + err = pam_open_session(wl->ph, 0); + if (err != PAM_SUCCESS) { +- fprintf(stderr, "failed to open pam session: %d: %s\n", ++ fprintf(stderr, "failed to open pam session: %d: %s\r\n", + err, pam_strerror(wl->ph, err)); + return -1; + } +@@ -311,7 +337,7 @@ handle_open(struct weston_launch *wl, struct msghdr *m + + fd = open(message->path, message->flags); + if (fd < 0) { +- fprintf(stderr, "Error opening device %s: %m\n", ++ fprintf(stderr, "Error opening device %s: %m\r\n", + message->path); + goto err0; + } +@@ -319,18 +345,18 @@ handle_open(struct weston_launch *wl, struct msghdr *m + if (fstat(fd, &s) < 0) { + close(fd); + fd = -1; +- fprintf(stderr, "Failed to stat %s\n", message->path); ++ fprintf(stderr, "Failed to stat %s\r\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; +- } ++ /* 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\r\n", */ ++ /* message->path); */ ++ /* goto err0; */ ++ /* } */ + + err0: + memset(&nmsg, 0, sizeof nmsg); +@@ -351,8 +377,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\r\n", + message->path, ret, fd); + do { + len = sendmsg(wl->sock[0], &nmsg, 0); +@@ -361,10 +387,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; +@@ -418,17 +443,26 @@ quit(struct weston_launch *wl, int status) + if (wl->new_user) { + err = pam_close_session(wl->ph, 0); + if (err) +- fprintf(stderr, "pam_close_session failed: %d: %s\n", ++ fprintf(stderr, "pam_close_session failed: %d: %s\r\n", + err, pam_strerror(wl->ph, err)); + 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\r\n"); + ++ struct termios tios; ++ if (tcgetattr(wl->tty, &tios)) { ++ fprintf(stderr, "Failed to get terminal attribute\r\n"); ++ } else { ++ cfmakesane(&tios); ++ if (tcsetattr(wl->tty , TCSAFLUSH, &tios)) ++ fprintf(stderr, "Failed to set terminal attribute\r\n"); ++ } ++ + if (ioctl(wl->tty, KDSETMODE, KD_TEXT)) +- fprintf(stderr, "failed to set KD_TEXT mode on tty: %m\n"); ++ fprintf(stderr, "failed to set KD_TEXT mode on tty: %m\r\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 +@@ -436,8 +470,9 @@ quit(struct weston_launch *wl, int status) + 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"); ++ fprintf(stderr, "could not reset vt handling\r\n"); + + exit(status); + } +@@ -445,15 +480,24 @@ quit(struct weston_launch *wl, int status) + 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. */ + ioctl(fd, EVIOCREVOKE, 0); + close(fd); ++ } else { ++ fprintf(stderr,"%s: stat failed on fd %d\r\n",__func__,fd); + } + } + } +@@ -464,13 +508,17 @@ handle_signal(struct weston_launch *wl) + 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\r\n",__func__); + pid = waitpid(-1, &status, 0); + if (pid == wl->child) { + wl->child = 0; +@@ -490,22 +538,32 @@ handle_signal(struct weston_launch *wl) + } + break; + case SIGTERM: ++ printf("%s: SIGTERM - killing\r\n",__func__); + case SIGINT: ++ printf("%s: SIGINT - killing\r\n",__func__); + if (wl->child) + kill(wl->child, sig.ssi_signo); + break; + case SIGUSR1: ++ printf("%s: SIGUSR1 - deactivating\r\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\r\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\r\n",__func__); + return -1; + } + +@@ -528,7 +586,7 @@ setup_tty(struct weston_launch *wl, const char *tty) + 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) +@@ -537,7 +595,7 @@ setup_tty(struct weston_launch *wl, const char *tty) + 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); + } +@@ -545,35 +603,36 @@ setup_tty(struct weston_launch *wl, const char *tty) + 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"); ++ error(1, errno, "failed to get current keyboard mode: %m\r\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\r\n"); + ++ struct termios tios; ++ if (tcgetattr(wl->tty, &tios)) ++ error(1, errno, "Failed to get terminal attribute %m\r\n"); ++ cfmakeraw(&tios); ++ if (tcsetattr(wl->tty , TCSAFLUSH, &tios)) ++ error(1, errno, "Failed to set terminal attribute %m\r\n"); ++ + if (ioctl(wl->tty, KDSETMODE, KD_GRAPHICS)) +- error(1, errno, "failed to set KD_GRAPHICS mode on tty: %m\n"); ++ error(1, errno, "failed to set KD_GRAPHICS mode on tty: %m\r\n"); + + 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"); ++ error(1, errno, "failed to take control of vt handling\r\n"); + + return 0; + } +@@ -641,7 +700,7 @@ launch_compositor(struct weston_launch *wl, int argc, + int o, i; + + if (wl->verbose) +- printf("weston-launch: spawned weston with pid: %d\n", getpid()); ++ printf("weston-launch: spawned weston with pid: %d\r\n", getpid()); + if (wl->new_user) { + o = setup_session(wl, child_argv); + } else { +@@ -675,11 +734,11 @@ launch_compositor(struct weston_launch *wl, int argc, + static void + help(const char *name) + { +- fprintf(stderr, "Usage: %s [args...] [-- [weston args..]]\n", name); +- fprintf(stderr, " -u, --user Start session as specified username\n"); +- fprintf(stderr, " -t, --tty Start session on alternative tty\n"); +- fprintf(stderr, " -v, --verbose Be verbose\n"); +- fprintf(stderr, " -h, --help Display this help message\n"); ++ fprintf(stderr, "Usage: %s [args...] [-- [weston args..]]\r\n", name); ++ fprintf(stderr, " -u, --user Start session as specified username\r\n"); ++ fprintf(stderr, " -t, --tty Start session on alternative tty\r\n"); ++ fprintf(stderr, " -v, --verbose Be verbose\r\n"); ++ fprintf(stderr, " -h, --help Display this help message\r\n"); + } + + int +@@ -730,13 +789,13 @@ main(int argc, char *argv[]) + error(1, errno, "failed to get username"); + + if (!weston_launch_allowed(&wl)) +- error(1, 0, "Permission denied. You should either:\n" ++ error(1, 0, "Permission denied. You should either:\r\n" + #ifdef HAVE_SYSTEMD_LOGIN +- " - run from an active and local (systemd) session.\n" ++ " - run from an active and local (systemd) session.\r\n" + #else +- " - enable systemd session support for weston-launch.\n" ++ " - enable systemd session support for weston-launch.\r\n" + #endif +- " - or add yourself to the 'weston-launch' group."); ++ " - or add yourself to the 'weston-launch' group.\r\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 2017-08-08 18:57:03 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_os-compatibility.c =================================================================== --- /dev/null +++ x11-wm/weston/files/patch-shared_os-compatibility.c @@ -0,0 +1,91 @@ +--- shared/os-compatibility.c.orig 2018-01-25 11:12:19 UTC ++++ shared/os-compatibility.c +@@ -25,6 +25,7 @@ + + #include "config.h" + ++#include + #include + #include + #include +@@ -107,26 +108,6 @@ os_epoll_create_cloexec(void) + return set_cloexec_or_close(fd); + } + +-static int +-create_tmpfile_cloexec(char *tmpname) +-{ +- int fd; +- +-#ifdef HAVE_MKOSTEMP +- fd = mkostemp(tmpname, O_CLOEXEC); +- if (fd >= 0) +- unlink(tmpname); +-#else +- fd = mkstemp(tmpname); +- if (fd >= 0) { +- fd = set_cloexec_or_close(fd); +- unlink(tmpname); +- } +-#endif +- +- return fd; +-} +- + /* + * Create a new, unique, anonymous file of the given size, and + * return the file descriptor for it. The file descriptor is set +@@ -151,50 +132,20 @@ create_tmpfile_cloexec(char *tmpname) + int + os_create_anonymous_file(off_t size) + { +- static const char template[] = "/weston-shared-XXXXXX"; +- const char *path; +- char *name; +- int fd; +- int ret; ++ int fd, ret; + +- path = getenv("XDG_RUNTIME_DIR"); +- if (!path) { +- errno = ENOENT; +- return -1; +- } +- +- name = malloc(strlen(path) + sizeof(template)); +- if (!name) +- return -1; +- +- strcpy(name, path); +- strcat(name, template); +- +- fd = create_tmpfile_cloexec(name); +- +- free(name); +- ++ // shm_open is always CLOEXEC ++ fd = shm_open(SHM_ANON, O_CREAT | O_RDWR, 0600); + if (fd < 0) + return -1; + +-#ifdef HAVE_POSIX_FALLOCATE + do { +- ret = posix_fallocate(fd, 0, size); +- } while (ret == EINTR); +- if (ret != 0) { +- close(fd); +- errno = ret; +- return -1; +- } +-#else +- do { + ret = ftruncate(fd, size); + } while (ret < 0 && errno == EINTR); + if (ret < 0) { + close(fd); + return -1; + } +-#endif + + return fd; + } 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 2017-08-08 18:57:03 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 2017-08-08 18:57:03 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-08-08 18:57:03 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-08-08 18:57:03 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 2017-08-08 18:57:03 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,59 @@ +--- xwayland/launcher.c.orig 2017-08-08 18:57:03 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,10 +72,12 @@ weston_xserver_shutdown(struct weston_xserver *wxs) + { + 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); + wl_event_source_remove(wxs->unix_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 *lockfile, size_t ls + 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-drm +%%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-3/compositor-drm.h +include/libweston-3/compositor-fbdev.h +include/libweston-3/compositor-headless.h +include/libweston-3/compositor-rdp.h +%%SCFB%%include/libweston-3/compositor-scfb.h +%%WAYLAND%%include/libweston-3/compositor-wayland.h +%%X11%%include/libweston-3/compositor-x11.h +include/libweston-3/compositor.h +include/libweston-3/config-parser.h +include/libweston-3/libweston-desktop.h +include/libweston-3/matrix.h +include/libweston-3/plugin-registry.h +include/libweston-3/timeline-object.h +include/libweston-3/version.h +include/libweston-3/windowed-output-api.h +%%XWAYLAND%%include/libweston-3/xwayland-api.h +include/libweston-3/zalloc.h +include/weston/ivi-layout-export.h +include/weston/weston.h +lib/libweston-3.so +lib/libweston-3.so.0 +lib/libweston-3.so.0.0.0 +%%DRM%%lib/libweston-3/drm-backend.so +lib/libweston-3/gl-renderer.so +lib/libweston-3/headless-backend.so +%%SCFB%%lib/libweston-3/scfb-backend.so +%%WAYLAND%%lib/libweston-3/wayland-backend.so +%%X11%%lib/libweston-3/x11-backend.so +%%XWAYLAND%%lib/libweston-3/xwayland.so +lib/libweston-desktop-3.so +lib/libweston-desktop-3.so.0 +lib/libweston-desktop-3.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-3.pc +libdata/pkgconfig/libweston-desktop-3.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