wlroots/backend/backend.c

180 lines
4.2 KiB
C
Raw Normal View History

#include <assert.h>
2018-02-12 20:29:23 +00:00
#include <errno.h>
2017-06-10 16:21:54 +00:00
#include <libinput.h>
2018-02-12 20:29:23 +00:00
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <wayland-server.h>
2017-08-12 23:55:40 +00:00
#include <wlr/backend/drm.h>
2018-02-12 20:29:23 +00:00
#include <wlr/backend/interface.h>
2017-08-12 23:55:40 +00:00
#include <wlr/backend/libinput.h>
2018-02-12 20:29:23 +00:00
#include <wlr/backend/multi.h>
#include <wlr/backend/session.h>
2017-06-19 17:40:58 +00:00
#include <wlr/backend/wayland.h>
#include <wlr/config.h>
#include <wlr/util/log.h>
/* WLR_HAS_X11_BACKEND needs to be after wlr/config.h */
2018-03-23 09:28:36 +00:00
#ifdef WLR_HAS_X11_BACKEND
2018-03-27 03:15:21 +00:00
#include <wlr/backend/x11.h>
2018-03-23 09:28:36 +00:00
#endif
2017-05-07 14:00:23 +00:00
void wlr_backend_init(struct wlr_backend *backend,
const struct wlr_backend_impl *impl) {
assert(backend);
2017-05-07 14:00:23 +00:00
backend->impl = impl;
2017-12-19 23:14:47 +00:00
wl_signal_init(&backend->events.destroy);
wl_signal_init(&backend->events.new_input);
wl_signal_init(&backend->events.new_output);
2017-05-07 14:00:23 +00:00
}
bool wlr_backend_start(struct wlr_backend *backend) {
if (backend->impl->start) {
return backend->impl->start(backend);
}
return true;
2017-05-07 14:00:23 +00:00
}
void wlr_backend_destroy(struct wlr_backend *backend) {
if (!backend) {
return;
}
if (backend->impl && backend->impl->destroy) {
backend->impl->destroy(backend);
} else {
free(backend);
}
2017-05-07 14:00:23 +00:00
}
struct wlr_renderer *wlr_backend_get_renderer(struct wlr_backend *backend) {
if (backend->impl->get_renderer) {
return backend->impl->get_renderer(backend);
}
return NULL;
}
2018-03-31 03:36:05 +00:00
static size_t parse_outputs_env(const char *name) {
const char *outputs_str = getenv(name);
if (outputs_str == NULL) {
return 1;
}
char *end;
int outputs = (int)strtol(outputs_str, &end, 10);
if (*end || outputs < 0) {
wlr_log(L_ERROR, "%s specified with invalid integer, ignoring", name);
return 1;
}
return outputs;
}
2017-06-20 22:22:21 +00:00
static struct wlr_backend *attempt_wl_backend(struct wl_display *display) {
struct wlr_backend *backend = wlr_wl_backend_create(display, NULL);
if (backend == NULL) {
return NULL;
}
2018-03-31 03:36:05 +00:00
size_t outputs = parse_outputs_env("WLR_WL_OUTPUTS");
for (size_t i = 0; i < outputs; ++i) {
wlr_wl_output_create(backend);
2017-06-20 22:22:21 +00:00
}
return backend;
}
2018-04-04 17:59:47 +00:00
#ifdef WLR_HAS_X11_BACKEND
static struct wlr_backend *attempt_x11_backend(struct wl_display *display,
const char *x11_display) {
struct wlr_backend *backend = wlr_x11_backend_create(display, x11_display);
if (backend == NULL) {
return NULL;
}
2018-03-31 03:36:05 +00:00
size_t outputs = parse_outputs_env("WLR_X11_OUTPUTS");
for (size_t i = 0; i < outputs; ++i) {
wlr_x11_output_create(backend);
}
2017-06-20 22:22:21 +00:00
return backend;
}
2018-04-04 17:59:47 +00:00
#endif
2017-06-20 22:22:21 +00:00
struct wlr_backend *wlr_backend_autocreate(struct wl_display *display) {
struct wlr_backend *backend = wlr_multi_backend_create(display);
if (!backend) {
wlr_log(L_ERROR, "could not allocate multibackend");
return NULL;
}
if (getenv("WAYLAND_DISPLAY") || getenv("_WAYLAND_DISPLAY") ||
getenv("WAYLAND_SOCKET")) {
struct wlr_backend *wl_backend = attempt_wl_backend(display);
if (wl_backend) {
wlr_multi_backend_add(backend, wl_backend);
return backend;
2017-06-20 22:22:21 +00:00
}
2017-06-19 17:40:58 +00:00
}
2017-06-10 16:21:54 +00:00
#ifdef WLR_HAS_X11_BACKEND
2017-09-22 02:58:41 +00:00
const char *x11_display = getenv("DISPLAY");
if (x11_display) {
struct wlr_backend *x11_backend =
attempt_x11_backend(display, x11_display);
if (x11_backend) {
wlr_multi_backend_add(backend, x11_backend);
return backend;
}
2017-08-12 23:55:40 +00:00
}
#endif
2017-08-12 23:55:40 +00:00
// Attempt DRM+libinput
struct wlr_session *session = wlr_session_create(display);
2017-08-12 23:55:40 +00:00
if (!session) {
wlr_log(L_ERROR, "Failed to start a DRM session");
wlr_backend_destroy(backend);
return NULL;
2017-08-12 23:55:40 +00:00
}
2017-08-26 02:02:04 +00:00
struct wlr_backend *libinput = wlr_libinput_backend_create(display, session);
if (libinput) {
wlr_multi_backend_add(backend, libinput);
} else {
wlr_log(L_ERROR, "Failed to start libinput backend");
wlr_backend_destroy(backend);
wlr_session_destroy(session);
return NULL;
2017-08-12 23:55:40 +00:00
}
2017-10-01 03:47:05 +00:00
int gpus[8];
size_t num_gpus = wlr_session_find_gpus(session, 8, gpus);
struct wlr_backend *primary_drm = NULL;
wlr_log(L_INFO, "Found %zu GPUs", num_gpus);
for (size_t i = 0; i < num_gpus; ++i) {
2017-10-01 06:22:47 +00:00
struct wlr_backend *drm = wlr_drm_backend_create(display, session,
gpus[i], primary_drm);
2017-10-01 03:47:05 +00:00
if (!drm) {
wlr_log(L_ERROR, "Failed to open DRM device");
continue;
}
if (!primary_drm) {
primary_drm = drm;
}
wlr_multi_backend_add(backend, drm);
}
if (!primary_drm) {
wlr_log(L_ERROR, "Failed to open any DRM device");
wlr_backend_destroy(libinput);
wlr_session_destroy(session);
wlr_backend_destroy(backend);
return NULL;
}
2017-08-12 23:55:40 +00:00
return backend;
2017-08-12 23:55:40 +00:00
}