diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..de93a21 --- /dev/null +++ b/.gitignore @@ -0,0 +1,6 @@ +*.o +wlr-output-power-management-unstable-v1.c +wlr-output-power-management-unstable-v1.h +xdg-output-unstable-v1.c +xdg-output-unstable-v1.h +wlopm diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..6eaf8c8 --- /dev/null +++ b/Makefile @@ -0,0 +1,35 @@ +SCANNER := wayland-scanner + +PREFIX=/usr/local +BINDIR=$(PREFIX)/bin +MANDIR=$(PREFIX)/share/man + +CFLAGS=-Wall -Werror -Wextra -Wpedantic -Wno-unused-parameter -Wconversion +LIBS=-lwayland-client +OBJ=wlopm.o wlr-output-power-management-unstable-v1.o xdg-output-unstable-v1.o +GEN=wlr-output-power-management-unstable-v1.c wlr-output-power-management-unstable-v1.h xdg-output-unstable-v1.c xdg-output-unstable-v1.h + +wlopm: $(OBJ) + $(CC)$ $(LDFLAGS) -o $@ $(OBJ) $(LIBS) + +$(OBJ): $(GEN) + +%.c: %.xml + $(SCANNER) private-code < $< > $@ + +%.h: %.xml + $(SCANNER) client-header < $< > $@ + +install: wlopm + install -D wlopm $(DESTDIR)$(BINDIR)/wlopm + install -D wlopm.1 $(DESTDIR)$(MANDIR)/man1/wlopm.1 + +uninstall: + $(RM) $(DESTDIR)$(BINDIR)/wlopm + $(RM) $(DESTDIR)$(MANDIR)/man1/wlopm.1 + +clean: + $(RM) wlopm $(GEN) $(OBJ) + +.PHONY: clean install + diff --git a/wlopm.1 b/wlopm.1 new file mode 100644 index 0000000..3f6aff8 --- /dev/null +++ b/wlopm.1 @@ -0,0 +1,31 @@ +.TH wlopm 1 2021-03-14 wlopm-0.0.1 + +.SH NAME +wlopm - Wayland output power management + +.SH DESCRIPTION +wlopm is a simple client implementing zwlr-output-power-management-v1. It can be +used to query and set the output power mode of Wayland outputs. + +.SH USAGE +\fBwlopm\fR +.RS 4 +List outputs and their power modes. +.P +.RE + +\fBwlopm on \fR +.RS 4 +Set output power mode to on. +.P +.RE + +\fBwlopm off \fR +.RS 4 +Set output power mode to off. +.P +.RE + +.SH AUTHOR +Leon Henrik Plickat + diff --git a/wlopm.c b/wlopm.c new file mode 100644 index 0000000..994328f --- /dev/null +++ b/wlopm.c @@ -0,0 +1,307 @@ +/* + * wlopm - Wayland output power manager + * + * Copyright (C) 2021 Leon Henrik Plickat + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include +#include +#include +#include +#include + +#include + +#include "xdg-output-unstable-v1.h" +#include "wlr-output-power-management-unstable-v1.h" + +#define VERSION "0.0.1" + +const char usage[] = + "Usage:\n" + "\twlopm List outputs and their power modes.\n" + "\twlopm on Set output power mode to on.\n" + "\twlopm off Set output power mode to off.\n" + "\n"; + +enum Action +{ + LIST, + ON, + OFF, +}; + +enum Action action = LIST; +char *name = NULL; + +struct Output +{ + struct wl_list link; + struct wl_output *wl_output; + struct zxdg_output_v1 *xdg_output; + struct zwlr_output_power_v1 *wlr_output_power; + enum zwlr_output_power_v1_mode mode; + char *name; + uint32_t global_name; +}; + +struct wl_display *wl_display = NULL; +struct wl_registry *wl_registry = NULL; +struct wl_callback *sync_callback = NULL; + +struct wl_list outputs; + +struct zxdg_output_manager_v1 *xdg_output_manager = NULL; +struct zwlr_output_power_manager_v1 *wlr_output_power_manager = NULL; + +int ret = EXIT_SUCCESS; +bool loop = true; + +static void noop () {} + +static void wlr_output_power_handle_mode (void *data, struct zwlr_output_power_v1 *wlr_output_power, + enum zwlr_output_power_v1_mode mode) +{ + struct Output *output = (struct Output *)data; + output->mode = mode; +} + +static void wlr_output_power_handle_failed (void *data, struct zwlr_output_power_v1 *wlr_output_power) +{ + struct Output *output = (struct Output *)data; + fprintf(stderr, "ERROR: Setting mode for output \"%s\" failed.\n", output->name); + loop = false; + ret = EXIT_FAILURE; +} + +static const struct zwlr_output_power_v1_listener wlr_output_power_listener = { + .mode = wlr_output_power_handle_mode, + .failed = wlr_output_power_handle_failed, +}; + +static void xdg_output_handle_name (void *data, struct zxdg_output_v1 *xdg_output, + const char *name) +{ + struct Output *output = (struct Output *)data; + if ( output->name != NULL ) + free(output->name); + output->name = strdup(name); +} + +static const struct zxdg_output_v1_listener xdg_output_listener = { + .logical_size = noop, + .name = xdg_output_handle_name, + .logical_position = noop, + .description = noop, + .done = noop, /* Deprecated since version 3. */ +}; + +static void registry_handle_global (void *data, struct wl_registry *registry, + uint32_t name, const char *interface, uint32_t version) +{ + if ( strcmp(interface, wl_output_interface.name) == 0 ) + { + struct Output *output = calloc(1, sizeof(struct Output)); + if ( output == NULL ) + { + fputs("ERROR: Failed to allocate.\n", stderr); + return; + } + + output->wl_output = wl_registry_bind(registry, name, + &wl_output_interface, version); + output->xdg_output = NULL; + output->name = NULL; + output->global_name = name; + + wl_list_insert(&outputs, &output->link); + } + else if ( strcmp(interface, zxdg_output_manager_v1_interface.name) == 0 ) + xdg_output_manager = wl_registry_bind(registry, name, + &zxdg_output_manager_v1_interface, version); + else if ( strcmp(interface, zwlr_output_power_manager_v1_interface.name) == 0 ) + wlr_output_power_manager = wl_registry_bind(registry, name, + &zwlr_output_power_manager_v1_interface, version); +} + +static const struct wl_registry_listener registry_listener = { + .global = registry_handle_global, + .global_remove = noop, /* We don't run long enough to care. */ +}; + +static void sync_handle_done (void *data, struct wl_callback *wl_callback, uint32_t other_data); +static const struct wl_callback_listener sync_callback_listener = { + .done = sync_handle_done, +}; + +static void sync_handle_done (void *data, struct wl_callback *wl_callback, uint32_t other_data) +{ + wl_callback_destroy(wl_callback); + sync_callback = NULL; + + static int sync = 0; + if ( sync == 0 ) + { + if ( wlr_output_power_manager == NULL ) + { + fputs("ERROR: Wayland server does not support wlr-output-power-management-v1.\n", stderr); + loop = false; + ret = EXIT_FAILURE; + return; + } + + if ( xdg_output_manager == NULL ) + { + fputs("ERROR: Wayland server does not support xdg-output.\n", stderr); + loop = false; + ret = EXIT_FAILURE; + return; + } + + struct Output *output; + wl_list_for_each(output, &outputs, link) + { + output->xdg_output = zxdg_output_manager_v1_get_xdg_output( + xdg_output_manager, output->wl_output); + zxdg_output_v1_add_listener(output->xdg_output, + &xdg_output_listener, output); + + output->wlr_output_power = zwlr_output_power_manager_v1_get_output_power( + wlr_output_power_manager, output->wl_output); + zwlr_output_power_v1_add_listener(output->wlr_output_power, + &wlr_output_power_listener, output); + } + + sync_callback = wl_display_sync(wl_display); + wl_callback_add_listener(sync_callback, &sync_callback_listener, NULL); + } + else if ( sync == 1 ) + { + if ( action == LIST ) + { + struct Output *output; + wl_list_for_each(output, &outputs, link) + fprintf(stdout, "%s %s\n", output->name, + output->mode == ZWLR_OUTPUT_POWER_V1_MODE_ON ? "on" : "off"); + loop = false; + } + else + { + struct Output *output; + wl_list_for_each(output, &outputs, link) + if ( strcmp(output->name, name) == 0 ) + goto found; + fprintf(stdout, "ERROR: No output with name \"%s\".\n", name); + ret = EXIT_FAILURE; + loop = false; + return; +found: + zwlr_output_power_v1_set_mode(output->wlr_output_power, + action == ON ? ZWLR_OUTPUT_POWER_V1_MODE_ON : ZWLR_OUTPUT_POWER_V1_MODE_OFF); + + /* We need to sync yet another time because setting the + * power mode might fail. + */ + sync_callback = wl_display_sync(wl_display); + wl_callback_add_listener(sync_callback, &sync_callback_listener, NULL); + } + } + else + loop = false; + sync++; +} + +int main(int argc, char *argv[]) +{ + if ( argc == 3 ) + { + if ( strcmp(argv[1], "on") == 0 ) + action = ON; + else if ( strcmp(argv[1], "off") == 0 ) + action = OFF; + else + { + fputs(usage, stderr); + return EXIT_FAILURE; + } + + name = strdup(argv[2]); + } + else if ( argc != 1 ) + { + fputs(usage, stderr); + return EXIT_FAILURE; + } + + /* We query the display name here instead of letting wl_display_connect() + * figure it out itself, because libwayland (for legacy reasons) falls + * back to using "wayland-0" when $WAYLAND_DISPLAY is not set, which is + * generally not desirable. + */ + const char *display_name = getenv("WAYLAND_DISPLAY"); + if ( display_name == NULL ) + { + fputs("ERROR: WAYLAND_DISPLAY is not set.\n", stderr); + if ( name != NULL ) + free(name); + return EXIT_FAILURE; + } + + wl_display = wl_display_connect(display_name); + if ( wl_display == NULL ) + { + fputs("ERROR: Can not connect to wayland display.\n", stderr); + if ( name != NULL ) + free(name); + return EXIT_FAILURE; + } + + wl_list_init(&outputs); + + wl_registry = wl_display_get_registry(wl_display); + wl_registry_add_listener(wl_registry, ®istry_listener, NULL); + + sync_callback = wl_display_sync(wl_display); + wl_callback_add_listener(sync_callback, &sync_callback_listener, NULL); + + while ( loop && wl_display_dispatch(wl_display) > 0 ); + + struct Output *output, *tmp; + wl_list_for_each_safe(output, tmp, &outputs, link) + { + zwlr_output_power_v1_destroy(output->wlr_output_power); + zxdg_output_v1_destroy(output->xdg_output); + wl_output_destroy(output->wl_output); + wl_list_remove(&output->link); + free(output->name); + free(output); + } + + if ( name != NULL ) + free(name); + if ( sync_callback != NULL ) + wl_callback_destroy(sync_callback); + if ( wlr_output_power_manager != NULL ) + zwlr_output_power_manager_v1_destroy(wlr_output_power_manager); + if ( xdg_output_manager != NULL ) + zxdg_output_manager_v1_destroy(xdg_output_manager); + if ( wl_registry != NULL ) + wl_registry_destroy(wl_registry); + wl_display_disconnect(wl_display); + + return ret; +} + diff --git a/wlr-output-power-management-unstable-v1.xml b/wlr-output-power-management-unstable-v1.xml new file mode 100644 index 0000000..a977839 --- /dev/null +++ b/wlr-output-power-management-unstable-v1.xml @@ -0,0 +1,128 @@ + + + + Copyright © 2019 Purism SPC + + 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. + + + + This protocol allows clients to control power management modes + of outputs that are currently part of the compositor space. The + intent is to allow special clients like desktop shells to power + down outputs when the system is idle. + + To modify outputs not currently part of the compositor space see + wlr-output-management. + + Warning! The protocol described in this file is experimental and + backward incompatible changes may be made. Backward compatible changes + may be added together with the corresponding interface version bump. + Backward incompatible changes are done by bumping the version number in + the protocol and interface names and resetting the interface version. + Once the protocol is to be declared stable, the 'z' prefix and the + version number in the protocol and interface names are removed and the + interface version number is reset. + + + + + This interface is a manager that allows creating per-output power + management mode controls. + + + + + Create a output power management mode control that can be used to + adjust the power management mode for a given output. + + + + + + + + All objects created by the manager will still remain valid, until their + appropriate destroy request has been called. + + + + + + + This object offers requests to set the power management mode of + an output. + + + + + + + + + + + + + + Set an output's power save mode to the given mode. The mode change + is effective immediately. If the output does not support the given + mode a failed event is sent. + + + + + + + Report the power management mode change of an output. + + The mode event is sent after an output changed its power + management mode. The reason can be a client using set_mode or the + compositor deciding to change an output's mode. + This event is also sent immediately when the object is created + so the client is informed about the current power management mode. + + + + + + + This event indicates that the output power management mode control + is no longer valid. This can happen for a number of reasons, + including: + - The output doesn't support power management + - Another client already has exclusive power management mode control + for this output + - The output disappeared + + Upon receiving this event, the client should destroy this object. + + + + + + Destroys the output power management mode control object. + + + + diff --git a/xdg-output-unstable-v1.xml b/xdg-output-unstable-v1.xml new file mode 100644 index 0000000..fe3a70a --- /dev/null +++ b/xdg-output-unstable-v1.xml @@ -0,0 +1,220 @@ + + + + + Copyright © 2017 Red Hat Inc. + + 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. + + + + This protocol aims at describing outputs in a way which is more in line + with the concept of an output on desktop oriented systems. + + Some information are more specific to the concept of an output for + a desktop oriented system and may not make sense in other applications, + such as IVI systems for example. + + Typically, the global compositor space on a desktop system is made of + a contiguous or overlapping set of rectangular regions. + + Some of the information provided in this protocol might be identical + to their counterparts already available from wl_output, in which case + the information provided by this protocol should be preferred to their + equivalent in wl_output. The goal is to move the desktop specific + concepts (such as output location within the global compositor space, + the connector name and types, etc.) out of the core wl_output protocol. + + Warning! The protocol described in this file is experimental and + backward incompatible changes may be made. Backward compatible + changes may be added together with the corresponding interface + version bump. + Backward incompatible changes are done by bumping the version + number in the protocol and interface names and resetting the + interface version. Once the protocol is to be declared stable, + the 'z' prefix and the version number in the protocol and + interface names are removed and the interface version number is + reset. + + + + + A global factory interface for xdg_output objects. + + + + + Using this request a client can tell the server that it is not + going to use the xdg_output_manager object anymore. + + Any objects already created through this instance are not affected. + + + + + + This creates a new xdg_output object for the given wl_output. + + + + + + + + + An xdg_output describes part of the compositor geometry. + + This typically corresponds to a monitor that displays part of the + compositor space. + + For objects version 3 onwards, after all xdg_output properties have been + sent (when the object is created and when properties are updated), a + wl_output.done event is sent. This allows changes to the output + properties to be seen as atomic, even if they happen via multiple events. + + + + + Using this request a client can tell the server that it is not + going to use the xdg_output object anymore. + + + + + + The position event describes the location of the wl_output within + the global compositor space. + + The logical_position event is sent after creating an xdg_output + (see xdg_output_manager.get_xdg_output) and whenever the location + of the output changes within the global compositor space. + + + + + + + + The logical_size event describes the size of the output in the + global compositor space. + + For example, a surface without any buffer scale, transformation + nor rotation set, with the size matching the logical_size will + have the same size as the corresponding output when displayed. + + Most regular Wayland clients should not pay attention to the + logical size and would rather rely on xdg_shell interfaces. + + Some clients such as Xwayland, however, need this to configure + their surfaces in the global compositor space as the compositor + may apply a different scale from what is advertised by the output + scaling property (to achieve fractional scaling, for example). + + For example, for a wl_output mode 3840×2160 and a scale factor 2: + + - A compositor not scaling the surface buffers will advertise a + logical size of 3840×2160, + + - A compositor automatically scaling the surface buffers will + advertise a logical size of 1920×1080, + + - A compositor using a fractional scale of 1.5 will advertise a + logical size to 2560×1620. + + For example, for a wl_output mode 1920×1080 and a 90 degree rotation, + the compositor will advertise a logical size of 1080x1920. + + The logical_size event is sent after creating an xdg_output + (see xdg_output_manager.get_xdg_output) and whenever the logical + size of the output changes, either as a result of a change in the + applied scale or because of a change in the corresponding output + mode(see wl_output.mode) or transform (see wl_output.transform). + + + + + + + + This event is sent after all other properties of an xdg_output + have been sent. + + This allows changes to the xdg_output properties to be seen as + atomic, even if they happen via multiple events. + + For objects version 3 onwards, this event is deprecated. Compositors + are not required to send it anymore and must send wl_output.done + instead. + + + + + + + + Many compositors will assign names to their outputs, show them to the + user, allow them to be configured by name, etc. The client may wish to + know this name as well to offer the user similar behaviors. + + The naming convention is compositor defined, but limited to + alphanumeric characters and dashes (-). Each name is unique among all + wl_output globals, but if a wl_output global is destroyed the same name + may be reused later. The names will also remain consistent across + sessions with the same hardware and software configuration. + + Examples of names include 'HDMI-A-1', 'WL-1', 'X11-1', etc. However, do + not assume that the name is a reflection of an underlying DRM + connector, X11 connection, etc. + + The name event is sent after creating an xdg_output (see + xdg_output_manager.get_xdg_output). This event is only sent once per + xdg_output, and the name does not change over the lifetime of the + wl_output global. + + + + + + + Many compositors can produce human-readable descriptions of their + outputs. The client may wish to know this description as well, to + communicate the user for various purposes. + + The description is a UTF-8 string with no convention defined for its + contents. Examples might include 'Foocorp 11" Display' or 'Virtual X11 + output via :1'. + + The description event is sent after creating an xdg_output (see + xdg_output_manager.get_xdg_output) and whenever the description + changes. The description is optional, and may not be sent at all. + + For objects of version 2 and lower, this event is only sent once per + xdg_output, and the description does not change over the lifetime of + the wl_output global. + + + + + +