blob: b70339cc01a9d5e5e377c698118f9484d20072d4 [file] [log] [blame]
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001/*
Kristian Høgsberg96aa7da2011-09-15 15:43:14 -04002 * Copyright © 2008-2011 Kristian Høgsberg
3 * Copyright © 2011 Intel Corporation
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04004 *
Bryce Harringtona0bbfea2015-06-11 15:35:43 -07005 * Permission is hereby granted, free of charge, to any person obtaining
6 * a copy of this software and associated documentation files (the
7 * "Software"), to deal in the Software without restriction, including
8 * without limitation the rights to use, copy, modify, merge, publish,
9 * distribute, sublicense, and/or sell copies of the Software, and to
10 * permit persons to whom the Software is furnished to do so, subject to
11 * the following conditions:
Kristian Høgsbergfc783d42010-06-11 12:56:24 -040012 *
Bryce Harringtona0bbfea2015-06-11 15:35:43 -070013 * The above copyright notice and this permission notice (including the
14 * next paragraph) shall be included in all copies or substantial
15 * portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
18 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
20 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
21 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
22 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
23 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
24 * SOFTWARE.
Kristian Høgsbergfc783d42010-06-11 12:56:24 -040025 */
26
Daniel Stonec228e232013-05-22 18:03:19 +030027#include "config.h"
Kristian Høgsberg0b9334a2011-04-12 11:34:32 -040028
Jesse Barnes58ef3792012-02-23 09:45:49 -050029#include <errno.h>
Jussi Kukkonen649bbce2016-07-19 14:16:27 +030030#include <stdint.h>
Kristian Høgsbergfc783d42010-06-11 12:56:24 -040031#include <stdlib.h>
Richard Hughes2b2092a2013-04-24 14:58:02 +010032#include <ctype.h>
Kristian Høgsbergfc783d42010-06-11 12:56:24 -040033#include <string.h>
34#include <fcntl.h>
35#include <unistd.h>
Kristian Høgsberg5d1c0c52012-04-10 00:11:50 -040036#include <linux/input.h>
Kristian Høgsberg3f495872013-09-18 23:00:17 -070037#include <linux/vt.h>
Ander Conselvan de Oliveirafd1f4c62012-06-26 17:09:14 +030038#include <assert.h>
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +020039#include <sys/mman.h>
Ander Conselvan de Oliveira97f29522013-10-14 15:57:11 +030040#include <dlfcn.h>
Ander Conselvan de Oliveira95eb3a22013-05-07 14:16:59 +030041#include <time.h>
Kristian Høgsbergfc783d42010-06-11 12:56:24 -040042
Benjamin Franzkec649a922011-03-02 11:56:04 +010043#include <xf86drm.h>
44#include <xf86drmMode.h>
Jesse Barnes58ef3792012-02-23 09:45:49 -050045#include <drm_fourcc.h>
Benjamin Franzkec649a922011-03-02 11:56:04 +010046
Benjamin Franzke060cf802011-04-30 09:32:11 +020047#include <gbm.h>
Pekka Paalanen33156972012-08-03 13:30:30 -040048#include <libudev.h>
Benjamin Franzke060cf802011-04-30 09:32:11 +020049
Giulio Camuffo1c0e40d2016-04-29 15:40:34 -070050#include "compositor.h"
51#include "compositor-drm.h"
Jon Cruz35b2eaa2015-06-15 15:37:08 -070052#include "shared/helpers.h"
Mario Kleinerf507ec32015-06-21 21:25:14 +020053#include "shared/timespec-util.h"
John Kåre Alsaker30d2b1f2012-11-13 19:10:28 +010054#include "gl-renderer.h"
Vincent Abriouc9506672016-10-05 16:14:07 +020055#include "weston-egl-ext.h"
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +020056#include "pixman-renderer.h"
Giulio Camuffo1c0e40d2016-04-29 15:40:34 -070057#include "libbacklight.h"
Peter Hutterer823ad332014-11-26 07:06:31 +100058#include "libinput-seat.h"
Benjamin Franzkebfeda132012-01-30 14:04:04 +010059#include "launcher-util.h"
Ander Conselvan de Oliveira6aae4d32013-08-23 17:15:48 +030060#include "vaapi-recorder.h"
Pekka Paalanenb00c79b2016-02-18 16:53:27 +020061#include "presentation-time-server-protocol.h"
Pekka Paalanene4d231e2014-06-12 15:12:48 +030062#include "linux-dmabuf.h"
Micah Fedkec8890122017-02-01 15:28:23 -050063#include "linux-dmabuf-unstable-v1-server-protocol.h"
Kristian Høgsbergfc783d42010-06-11 12:56:24 -040064
Ander Conselvan de Oliveira95eb3a22013-05-07 14:16:59 +030065#ifndef DRM_CAP_TIMESTAMP_MONOTONIC
66#define DRM_CAP_TIMESTAMP_MONOTONIC 0x6
67#endif
68
Alvaro Fernando Garcíadce7c6e2014-07-28 18:30:17 -030069#ifndef DRM_CAP_CURSOR_WIDTH
70#define DRM_CAP_CURSOR_WIDTH 0x8
71#endif
72
73#ifndef DRM_CAP_CURSOR_HEIGHT
74#define DRM_CAP_CURSOR_HEIGHT 0x9
75#endif
76
77#ifndef GBM_BO_USE_CURSOR
78#define GBM_BO_USE_CURSOR GBM_BO_USE_CURSOR_64X64
79#endif
80
Giulio Camuffo954f1832014-10-11 18:27:30 +030081struct drm_backend {
82 struct weston_backend base;
83 struct weston_compositor *compositor;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -040084
85 struct udev *udev;
86 struct wl_event_source *drm_source;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -040087
Benjamin Franzke9c26ff32011-03-15 15:08:41 +010088 struct udev_monitor *udev_monitor;
89 struct wl_event_source *udev_drm_source;
90
Benjamin Franzke2af7f102011-03-02 11:14:59 +010091 struct {
David Herrmannd7488c22012-03-11 20:05:21 +010092 int id;
Benjamin Franzke2af7f102011-03-02 11:14:59 +010093 int fd;
Ander Conselvan de Oliveira6aae4d32013-08-23 17:15:48 +030094 char *filename;
Benjamin Franzke2af7f102011-03-02 11:14:59 +010095 } drm;
Benjamin Franzke060cf802011-04-30 09:32:11 +020096 struct gbm_device *gbm;
Kristian Høgsberg61741a22013-09-17 16:02:57 -070097 struct wl_listener session_listener;
Miguel A. Vicofcf4b6c2016-03-21 17:41:03 +010098 uint32_t gbm_format;
Pekka Paalanenbce2d3f2011-12-02 13:07:27 +020099
Rob Clark4339add2012-08-09 14:18:28 -0500100 /* we need these parameters in order to not fail drmModeAddFB2()
101 * due to out of bounds dimensions, and then mistakenly set
102 * sprites_are_broken:
103 */
Daniel Stonef214fdc2016-11-14 17:43:57 +0000104 int min_width, max_width;
105 int min_height, max_height;
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200106 int no_addfb2;
Rob Clark4339add2012-08-09 14:18:28 -0500107
Jesse Barnes58ef3792012-02-23 09:45:49 -0500108 struct wl_list sprite_list;
Kristian Høgsberg65bec242012-03-05 19:57:35 -0500109 int sprites_are_broken;
Ander Conselvan de Oliveirada1c9082012-10-31 17:55:46 +0200110 int sprites_hidden;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500111
Rob Clarkab5b1e32012-08-09 13:24:45 -0500112 int cursors_are_broken;
113
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +0200114 int use_pixman;
115
Rob Bradfordd355b802013-05-31 18:09:55 +0100116 struct udev_input input;
Alvaro Fernando Garcíadce7c6e2014-07-28 18:30:17 -0300117
Daniel Stone70d337d2015-06-16 18:42:23 +0100118 int32_t cursor_width;
119 int32_t cursor_height;
Ucan, Emre (ADITG/SW1)21e49442017-02-02 14:06:55 +0000120
121 uint32_t connector;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400122};
123
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -0400124struct drm_mode {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500125 struct weston_mode base;
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -0400126 drmModeModeInfo mode_info;
127};
128
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300129struct drm_fb {
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +0200130 uint32_t fb_id, stride, handle, size;
Daniel Stonec8c917c2016-11-14 17:45:58 +0000131 int width, height;
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +0200132 int fd;
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300133 int is_client_buffer;
Pekka Paalanende685b82012-12-04 15:58:12 +0200134 struct weston_buffer_reference buffer_ref;
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +0200135
136 /* Used by gbm fbs */
137 struct gbm_bo *bo;
138
139 /* Used by dumb fbs */
140 void *map;
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300141};
142
Richard Hughes2b2092a2013-04-24 14:58:02 +0100143struct drm_edid {
144 char eisa_id[13];
145 char monitor_name[13];
146 char pnp_id[5];
147 char serial_number[13];
148};
149
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400150struct drm_output {
Armin Krezović08368132016-09-30 14:11:05 +0200151 struct weston_output base;
152 drmModeConnector *connector;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400153
Daniel Stone17339232015-11-28 12:09:47 +0000154 uint32_t crtc_id; /* object ID to pass to DRM functions */
155 int pipe; /* index of CRTC in resource array / bitmasks */
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400156 uint32_t connector_id;
Matt Roper361d2ad2011-08-29 13:52:23 -0700157 drmModeCrtcPtr original_crtc;
Richard Hughes2b2092a2013-04-24 14:58:02 +0100158 struct drm_edid edid;
Ander Conselvan de Oliveiraa0a433a2013-06-04 16:24:04 +0300159 drmModePropertyPtr dpms_prop;
Miguel A. Vicofcf4b6c2016-03-21 17:41:03 +0100160 uint32_t gbm_format;
Benjamin Franzke1178a3c2011-04-10 16:49:52 +0200161
Daniel Stone36609c72015-06-18 07:49:02 +0100162 enum dpms_enum dpms;
163
Ander Conselvan de Oliveiraa7326962012-06-26 17:09:13 +0300164 int vblank_pending;
165 int page_flip_pending;
Xiong Zhangabd5d472013-10-11 14:43:07 +0800166 int destroy_pending;
Armin Krezović08368132016-09-30 14:11:05 +0200167 int disable_pending;
Ander Conselvan de Oliveiraa7326962012-06-26 17:09:13 +0300168
Miguel A. Vicofcf4b6c2016-03-21 17:41:03 +0100169 struct gbm_surface *gbm_surface;
170 struct gbm_bo *gbm_cursor_bo[2];
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400171 struct weston_plane cursor_plane;
172 struct weston_plane fb_plane;
Jason Ekstranda7af7042013-10-12 22:38:11 -0500173 struct weston_view *cursor_view;
Kristian Høgsberg5626d342012-08-03 11:50:05 -0400174 int current_cursor;
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300175 struct drm_fb *current, *next;
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +0200176 struct backlight *backlight;
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +0200177
178 struct drm_fb *dumb[2];
179 pixman_image_t *image[2];
180 int current_image;
181 pixman_region32_t previous_damage;
Ander Conselvan de Oliveira6aae4d32013-08-23 17:15:48 +0300182
183 struct vaapi_recorder *recorder;
184 struct wl_listener recorder_frame_listener;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400185};
186
Jesse Barnes58ef3792012-02-23 09:45:49 -0500187/*
188 * An output has a primary display plane plus zero or more sprites for
189 * blending display contents.
190 */
191struct drm_sprite {
192 struct wl_list link;
193
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400194 struct weston_plane plane;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500195
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200196 struct drm_fb *current, *next;
Ander Conselvan de Oliveiraa7326962012-06-26 17:09:13 +0300197 struct drm_output *output;
Giulio Camuffo954f1832014-10-11 18:27:30 +0300198 struct drm_backend *backend;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500199
Jesse Barnes58ef3792012-02-23 09:45:49 -0500200 uint32_t possible_crtcs;
201 uint32_t plane_id;
202 uint32_t count_formats;
203
204 int32_t src_x, src_y;
205 uint32_t src_w, src_h;
206 uint32_t dest_x, dest_y;
207 uint32_t dest_w, dest_h;
208
209 uint32_t formats[];
210};
211
Ander Conselvan de Oliveira97f29522013-10-14 15:57:11 +0300212static struct gl_renderer_interface *gl_renderer;
213
Kristian Høgsberg98cfea62013-02-18 16:15:53 -0500214static const char default_seat[] = "seat0";
Pekka Paalanen33156972012-08-03 13:30:30 -0400215
Armin Krezović545dba62016-08-05 15:54:18 +0200216static inline struct drm_output *
217to_drm_output(struct weston_output *base)
218{
219 return container_of(base, struct drm_output, base);
220}
221
222static inline struct drm_backend *
223to_drm_backend(struct weston_compositor *base)
224{
225 return container_of(base->backend, struct drm_backend, base);
226}
227
Kristian Høgsberg5626d342012-08-03 11:50:05 -0400228static void
229drm_output_set_cursor(struct drm_output *output);
Kristian Høgsberg5626d342012-08-03 11:50:05 -0400230
Mario Kleinerf507ec32015-06-21 21:25:14 +0200231static void
232drm_output_update_msc(struct drm_output *output, unsigned int seq);
233
Jesse Barnes58ef3792012-02-23 09:45:49 -0500234static int
Daniel Stonea3ae4762015-11-28 12:07:36 +0000235drm_sprite_crtc_supported(struct drm_output *output, struct drm_sprite *sprite)
Jesse Barnes58ef3792012-02-23 09:45:49 -0500236{
Daniel Stonea3ae4762015-11-28 12:07:36 +0000237 return !!(sprite->possible_crtcs & (1 << output->pipe));
Jesse Barnes58ef3792012-02-23 09:45:49 -0500238}
239
Daniel Stone72c0e1b2017-02-09 13:49:15 +0000240static struct drm_output *
241drm_output_find_by_crtc(struct drm_backend *b, uint32_t crtc_id)
242{
243 struct drm_output *output;
244
245 wl_list_for_each(output, &b->compositor->output_list, base.link) {
246 if (output->crtc_id == crtc_id)
247 return output;
248 }
249
250 wl_list_for_each(output, &b->compositor->pending_output_list,
251 base.link) {
252 if (output->crtc_id == crtc_id)
253 return output;
254 }
255
256 return NULL;
257}
258
Daniel Stonec0ec7592017-02-09 13:58:35 +0000259static struct drm_output *
260drm_output_find_by_connector(struct drm_backend *b, uint32_t connector_id)
261{
262 struct drm_output *output;
263
264 wl_list_for_each(output, &b->compositor->output_list, base.link) {
265 if (output->connector_id == connector_id)
266 return output;
267 }
268
269 wl_list_for_each(output, &b->compositor->pending_output_list,
270 base.link) {
271 if (output->connector_id == connector_id)
272 return output;
273 }
274
275 return NULL;
276}
277
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300278static void
279drm_fb_destroy_callback(struct gbm_bo *bo, void *data)
280{
281 struct drm_fb *fb = data;
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300282
283 if (fb->fb_id)
Daniel Stone4e5eceb2015-11-30 16:07:19 +0000284 drmModeRmFB(fb->fd, fb->fb_id);
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300285
Pekka Paalanende685b82012-12-04 15:58:12 +0200286 weston_buffer_reference(&fb->buffer_ref, NULL);
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300287
288 free(data);
289}
290
291static struct drm_fb *
Daniel Stonef214fdc2016-11-14 17:43:57 +0000292drm_fb_create_dumb(struct drm_backend *b, int width, int height,
Tomi Valkeinenf8da0c22016-06-20 14:18:45 +0300293 uint32_t format)
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +0200294{
295 struct drm_fb *fb;
296 int ret;
Tomi Valkeinenf8da0c22016-06-20 14:18:45 +0300297 uint32_t bpp, depth;
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +0200298
299 struct drm_mode_create_dumb create_arg;
300 struct drm_mode_destroy_dumb destroy_arg;
301 struct drm_mode_map_dumb map_arg;
302
Peter Huttererf3d62272013-08-08 11:57:05 +1000303 fb = zalloc(sizeof *fb);
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +0200304 if (!fb)
305 return NULL;
306
Tomi Valkeinenf8da0c22016-06-20 14:18:45 +0300307 switch (format) {
308 case GBM_FORMAT_XRGB8888:
309 bpp = 32;
310 depth = 24;
311 break;
312 case GBM_FORMAT_RGB565:
313 bpp = depth = 16;
314 break;
315 default:
316 return NULL;
317 }
318
Kristian Høgsbergac6104e2013-08-21 22:14:14 -0700319 memset(&create_arg, 0, sizeof create_arg);
Tomi Valkeinenf8da0c22016-06-20 14:18:45 +0300320 create_arg.bpp = bpp;
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +0200321 create_arg.width = width;
322 create_arg.height = height;
323
Giulio Camuffo954f1832014-10-11 18:27:30 +0300324 ret = drmIoctl(b->drm.fd, DRM_IOCTL_MODE_CREATE_DUMB, &create_arg);
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +0200325 if (ret)
326 goto err_fb;
327
328 fb->handle = create_arg.handle;
329 fb->stride = create_arg.pitch;
330 fb->size = create_arg.size;
Daniel Stonec8c917c2016-11-14 17:45:58 +0000331 fb->width = width;
332 fb->height = height;
Giulio Camuffo954f1832014-10-11 18:27:30 +0300333 fb->fd = b->drm.fd;
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +0200334
Tomi Valkeinenf8da0c22016-06-20 14:18:45 +0300335 ret = -1;
336
337 if (!b->no_addfb2) {
Yong Bakos4b6321f2016-08-17 17:37:55 -0700338 uint32_t handles[4] = { 0 }, pitches[4] = { 0 }, offsets[4] = { 0 };
Tomi Valkeinenf8da0c22016-06-20 14:18:45 +0300339
340 handles[0] = fb->handle;
341 pitches[0] = fb->stride;
342 offsets[0] = 0;
343
344 ret = drmModeAddFB2(b->drm.fd, width, height,
345 format, handles, pitches, offsets,
346 &fb->fb_id, 0);
347 if (ret) {
348 weston_log("addfb2 failed: %m\n");
349 b->no_addfb2 = 1;
350 }
351 }
352
353 if (ret) {
354 ret = drmModeAddFB(b->drm.fd, width, height, depth, bpp,
355 fb->stride, fb->handle, &fb->fb_id);
356 }
357
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +0200358 if (ret)
359 goto err_bo;
360
Kristian Høgsbergac6104e2013-08-21 22:14:14 -0700361 memset(&map_arg, 0, sizeof map_arg);
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +0200362 map_arg.handle = fb->handle;
Chris Michaeleb2074a2013-05-01 21:26:02 -0400363 ret = drmIoctl(fb->fd, DRM_IOCTL_MODE_MAP_DUMB, &map_arg);
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +0200364 if (ret)
365 goto err_add_fb;
366
Chris Michael4a7ce1f2015-11-10 10:40:37 -0500367 fb->map = mmap(NULL, fb->size, PROT_WRITE,
Giulio Camuffo954f1832014-10-11 18:27:30 +0300368 MAP_SHARED, b->drm.fd, map_arg.offset);
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +0200369 if (fb->map == MAP_FAILED)
370 goto err_add_fb;
371
372 return fb;
373
374err_add_fb:
Giulio Camuffo954f1832014-10-11 18:27:30 +0300375 drmModeRmFB(b->drm.fd, fb->fb_id);
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +0200376err_bo:
377 memset(&destroy_arg, 0, sizeof(destroy_arg));
378 destroy_arg.handle = create_arg.handle;
Giulio Camuffo954f1832014-10-11 18:27:30 +0300379 drmIoctl(b->drm.fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy_arg);
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +0200380err_fb:
381 free(fb);
382 return NULL;
383}
384
385static void
386drm_fb_destroy_dumb(struct drm_fb *fb)
387{
388 struct drm_mode_destroy_dumb destroy_arg;
389
390 if (!fb->map)
391 return;
392
393 if (fb->fb_id)
394 drmModeRmFB(fb->fd, fb->fb_id);
395
396 weston_buffer_reference(&fb->buffer_ref, NULL);
397
398 munmap(fb->map, fb->size);
399
400 memset(&destroy_arg, 0, sizeof(destroy_arg));
401 destroy_arg.handle = fb->handle;
402 drmIoctl(fb->fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy_arg);
403
404 free(fb);
405}
406
407static struct drm_fb *
Kristian Høgsberga2f84cc2012-12-07 12:37:58 -0500408drm_fb_get_from_bo(struct gbm_bo *bo,
Giulio Camuffo954f1832014-10-11 18:27:30 +0300409 struct drm_backend *backend, uint32_t format)
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300410{
411 struct drm_fb *fb = gbm_bo_get_user_data(bo);
Derek Foreman482ffdf2016-07-08 12:50:57 -0500412 uint32_t handles[4] = { 0 }, pitches[4] = { 0 }, offsets[4] = { 0 };
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300413 int ret;
414
415 if (fb)
416 return fb;
417
Bryce Harringtonde16d892014-11-20 22:21:57 -0800418 fb = zalloc(sizeof *fb);
419 if (fb == NULL)
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +0200420 return NULL;
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300421
422 fb->bo = bo;
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300423
Daniel Stonec8c917c2016-11-14 17:45:58 +0000424 fb->width = gbm_bo_get_width(bo);
425 fb->height = gbm_bo_get_height(bo);
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +0200426 fb->stride = gbm_bo_get_stride(bo);
427 fb->handle = gbm_bo_get_handle(bo).u32;
Daniel Stonec8c917c2016-11-14 17:45:58 +0000428 fb->size = fb->stride * fb->height;
Giulio Camuffo954f1832014-10-11 18:27:30 +0300429 fb->fd = backend->drm.fd;
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300430
Daniel Stonec8c917c2016-11-14 17:45:58 +0000431 if (backend->min_width > fb->width ||
432 fb->width > backend->max_width ||
433 backend->min_height > fb->height ||
434 fb->height > backend->max_height) {
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200435 weston_log("bo geometry out of bounds\n");
436 goto err_free;
437 }
438
439 ret = -1;
440
Giulio Camuffo954f1832014-10-11 18:27:30 +0300441 if (format && !backend->no_addfb2) {
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +0200442 handles[0] = fb->handle;
443 pitches[0] = fb->stride;
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200444 offsets[0] = 0;
445
Daniel Stonec8c917c2016-11-14 17:45:58 +0000446 ret = drmModeAddFB2(backend->drm.fd, fb->width, fb->height,
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200447 format, handles, pitches, offsets,
448 &fb->fb_id, 0);
449 if (ret) {
450 weston_log("addfb2 failed: %m\n");
Giulio Camuffo954f1832014-10-11 18:27:30 +0300451 backend->no_addfb2 = 1;
452 backend->sprites_are_broken = 1;
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200453 }
454 }
455
456 if (ret)
Daniel Stonec8c917c2016-11-14 17:45:58 +0000457 ret = drmModeAddFB(backend->drm.fd, fb->width, fb->height,
458 24, 32, fb->stride, fb->handle, &fb->fb_id);
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200459
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300460 if (ret) {
Martin Minarik6d118362012-06-07 18:01:59 +0200461 weston_log("failed to create kms fb: %m\n");
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200462 goto err_free;
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300463 }
464
465 gbm_bo_set_user_data(bo, fb, drm_fb_destroy_callback);
466
467 return fb;
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200468
469err_free:
470 free(fb);
471 return NULL;
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300472}
473
474static void
Jason Ekstrand6bd62942013-06-20 20:38:23 -0500475drm_fb_set_buffer(struct drm_fb *fb, struct weston_buffer *buffer)
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200476{
Pekka Paalanende685b82012-12-04 15:58:12 +0200477 assert(fb->buffer_ref.buffer == NULL);
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200478
479 fb->is_client_buffer = 1;
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200480
Pekka Paalanende685b82012-12-04 15:58:12 +0200481 weston_buffer_reference(&fb->buffer_ref, buffer);
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200482}
483
Ander Conselvan de Oliveira526d4612013-01-25 15:13:03 +0200484static void
485drm_output_release_fb(struct drm_output *output, struct drm_fb *fb)
486{
487 if (!fb)
488 return;
489
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +0200490 if (fb->map &&
491 (fb != output->dumb[0] && fb != output->dumb[1])) {
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +0200492 drm_fb_destroy_dumb(fb);
493 } else if (fb->bo) {
Ander Conselvan de Oliveira526d4612013-01-25 15:13:03 +0200494 if (fb->is_client_buffer)
495 gbm_bo_destroy(fb->bo);
496 else
Miguel A. Vicofcf4b6c2016-03-21 17:41:03 +0100497 gbm_surface_release_buffer(output->gbm_surface,
Jason Ekstrand3ec57f52013-11-14 20:52:35 -0600498 fb->bo);
Ander Conselvan de Oliveira526d4612013-01-25 15:13:03 +0200499 }
500}
501
Kristian Høgsberga2f84cc2012-12-07 12:37:58 -0500502static uint32_t
Ander Conselvan de Oliveirae9209412012-11-30 17:34:22 +0200503drm_output_check_scanout_format(struct drm_output *output,
504 struct weston_surface *es, struct gbm_bo *bo)
505{
Ander Conselvan de Oliveirae9209412012-11-30 17:34:22 +0200506 uint32_t format;
507 pixman_region32_t r;
508
509 format = gbm_bo_get_format(bo);
510
Kristian Høgsberg3f97b342013-10-16 16:08:57 -0700511 if (format == GBM_FORMAT_ARGB8888) {
512 /* We can scanout an ARGB buffer if the surface's
513 * opaque region covers the whole output, but we have
514 * to use XRGB as the KMS format code. */
Kristian Høgsberg1be87e32014-01-17 14:22:41 -0800515 pixman_region32_init_rect(&r, 0, 0,
516 output->base.width,
517 output->base.height);
518 pixman_region32_subtract(&r, &r, &es->opaque);
Ander Conselvan de Oliveirae9209412012-11-30 17:34:22 +0200519
520 if (!pixman_region32_not_empty(&r))
Kristian Høgsberga2f84cc2012-12-07 12:37:58 -0500521 format = GBM_FORMAT_XRGB8888;
Ander Conselvan de Oliveirae9209412012-11-30 17:34:22 +0200522
523 pixman_region32_fini(&r);
Kristian Høgsberga2f84cc2012-12-07 12:37:58 -0500524 }
Kristian Høgsberg3f97b342013-10-16 16:08:57 -0700525
Miguel A. Vicofcf4b6c2016-03-21 17:41:03 +0100526 if (output->gbm_format == format)
Kristian Høgsberg3f97b342013-10-16 16:08:57 -0700527 return format;
528
529 return 0;
Ander Conselvan de Oliveirae9209412012-11-30 17:34:22 +0200530}
531
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400532static struct weston_plane *
Pekka Paalanen050c1ba2014-12-17 16:20:38 +0200533drm_output_prepare_scanout_view(struct drm_output *output,
Jason Ekstranda7af7042013-10-12 22:38:11 -0500534 struct weston_view *ev)
Kristian Høgsberg5f5e42e2012-01-25 23:59:42 -0500535{
Armin Krezović545dba62016-08-05 15:54:18 +0200536 struct drm_backend *b = to_drm_backend(output->base.compositor);
Jason Ekstranda7af7042013-10-12 22:38:11 -0500537 struct weston_buffer *buffer = ev->surface->buffer_ref.buffer;
Pekka Paalanen952b6c82014-03-14 14:38:15 +0200538 struct weston_buffer_viewport *viewport = &ev->surface->buffer_viewport;
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300539 struct gbm_bo *bo;
Kristian Høgsberga2f84cc2012-12-07 12:37:58 -0500540 uint32_t format;
Kristian Høgsberg5f5e42e2012-01-25 23:59:42 -0500541
Daniel Stone296d7a92016-10-21 18:05:37 +0100542 /* We use GBM to import buffers. */
543 if (b->gbm == NULL)
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400544 return NULL;
Kristian Høgsberg5f5e42e2012-01-25 23:59:42 -0500545
Daniel Stone296d7a92016-10-21 18:05:37 +0100546 if (buffer == NULL)
547 return NULL;
548
549 /* Make sure our view is exactly compatible with the output. */
550 if (ev->geometry.x != output->base.x ||
551 ev->geometry.y != output->base.y)
552 return NULL;
553 if (ev->transform.enabled)
554 return NULL;
Pekka Paalanen5580f222015-02-17 16:33:18 +0200555 if (ev->geometry.scissor_enabled)
556 return NULL;
557
Daniel Stone296d7a92016-10-21 18:05:37 +0100558 if (buffer->width != output->base.current_mode->width ||
559 buffer->height != output->base.current_mode->height)
560 return NULL;
561 if (viewport->buffer.transform != output->base.transform)
562 return NULL;
563
Giulio Camuffo954f1832014-10-11 18:27:30 +0300564 bo = gbm_bo_import(b->gbm, GBM_BO_IMPORT_WL_BUFFER,
Kristian Høgsberg63996462013-09-03 22:27:08 -0700565 buffer->resource, GBM_BO_USE_SCANOUT);
Kristian Høgsberg5f5e42e2012-01-25 23:59:42 -0500566
Rob Bradford9b101872012-09-14 23:25:41 +0100567 /* Unable to use the buffer for scanout */
568 if (!bo)
569 return NULL;
570
Jason Ekstranda7af7042013-10-12 22:38:11 -0500571 format = drm_output_check_scanout_format(output, ev->surface, bo);
Kristian Høgsberga2f84cc2012-12-07 12:37:58 -0500572 if (format == 0) {
Ander Conselvan de Oliveiraa64b15d2012-05-02 16:42:22 +0300573 gbm_bo_destroy(bo);
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400574 return NULL;
Ander Conselvan de Oliveiraa64b15d2012-05-02 16:42:22 +0300575 }
576
Giulio Camuffo954f1832014-10-11 18:27:30 +0300577 output->next = drm_fb_get_from_bo(bo, b, format);
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300578 if (!output->next) {
579 gbm_bo_destroy(bo);
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400580 return NULL;
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300581 }
Kristian Høgsberg5f5e42e2012-01-25 23:59:42 -0500582
Pekka Paalanende685b82012-12-04 15:58:12 +0200583 drm_fb_set_buffer(output->next, buffer);
Kristian Høgsberg5f5e42e2012-01-25 23:59:42 -0500584
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400585 return &output->fb_plane;
Kristian Høgsberg5f5e42e2012-01-25 23:59:42 -0500586}
587
Kristian Høgsberg06cf6b02012-01-25 23:47:45 -0500588static void
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +0200589drm_output_render_gl(struct drm_output *output, pixman_region32_t *damage)
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -0400590{
Armin Krezović545dba62016-08-05 15:54:18 +0200591 struct drm_backend *b = to_drm_backend(output->base.compositor);
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300592 struct gbm_bo *bo;
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -0400593
Giulio Camuffo954f1832014-10-11 18:27:30 +0300594 output->base.compositor->renderer->repaint_output(&output->base,
595 damage);
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -0400596
Miguel A. Vicofcf4b6c2016-03-21 17:41:03 +0100597 bo = gbm_surface_lock_front_buffer(output->gbm_surface);
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300598 if (!bo) {
Martin Minarik6d118362012-06-07 18:01:59 +0200599 weston_log("failed to lock front buffer: %m\n");
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -0400600 return;
601 }
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300602
Miguel A. Vicofcf4b6c2016-03-21 17:41:03 +0100603 output->next = drm_fb_get_from_bo(bo, b, output->gbm_format);
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300604 if (!output->next) {
Martin Minarik6d118362012-06-07 18:01:59 +0200605 weston_log("failed to get drm_fb for bo\n");
Miguel A. Vicofcf4b6c2016-03-21 17:41:03 +0100606 gbm_surface_release_buffer(output->gbm_surface, bo);
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300607 return;
608 }
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -0400609}
610
611static void
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +0200612drm_output_render_pixman(struct drm_output *output, pixman_region32_t *damage)
613{
614 struct weston_compositor *ec = output->base.compositor;
615 pixman_region32_t total_damage, previous_damage;
616
617 pixman_region32_init(&total_damage);
618 pixman_region32_init(&previous_damage);
619
620 pixman_region32_copy(&previous_damage, damage);
621
622 pixman_region32_union(&total_damage, damage, &output->previous_damage);
623 pixman_region32_copy(&output->previous_damage, &previous_damage);
624
625 output->current_image ^= 1;
626
627 output->next = output->dumb[output->current_image];
628 pixman_renderer_output_set_buffer(&output->base,
629 output->image[output->current_image]);
630
631 ec->renderer->repaint_output(&output->base, &total_damage);
632
633 pixman_region32_fini(&total_damage);
634 pixman_region32_fini(&previous_damage);
635}
636
637static void
638drm_output_render(struct drm_output *output, pixman_region32_t *damage)
639{
Giulio Camuffo954f1832014-10-11 18:27:30 +0300640 struct weston_compositor *c = output->base.compositor;
Armin Krezović545dba62016-08-05 15:54:18 +0200641 struct drm_backend *b = to_drm_backend(c);
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +0200642
Giulio Camuffo954f1832014-10-11 18:27:30 +0300643 if (b->use_pixman)
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +0200644 drm_output_render_pixman(output, damage);
645 else
646 drm_output_render_gl(output, damage);
647
Giulio Camuffo954f1832014-10-11 18:27:30 +0300648 pixman_region32_subtract(&c->primary_plane.damage,
649 &c->primary_plane.damage, damage);
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +0200650}
651
652static void
Richard Hughese7299962013-05-01 21:52:12 +0100653drm_output_set_gamma(struct weston_output *output_base,
654 uint16_t size, uint16_t *r, uint16_t *g, uint16_t *b)
655{
656 int rc;
Armin Krezović545dba62016-08-05 15:54:18 +0200657 struct drm_output *output = to_drm_output(output_base);
Giulio Camuffo954f1832014-10-11 18:27:30 +0300658 struct drm_backend *backend =
Armin Krezović545dba62016-08-05 15:54:18 +0200659 to_drm_backend(output->base.compositor);
Richard Hughese7299962013-05-01 21:52:12 +0100660
661 /* check */
662 if (output_base->gamma_size != size)
663 return;
664 if (!output->original_crtc)
665 return;
666
Giulio Camuffo954f1832014-10-11 18:27:30 +0300667 rc = drmModeCrtcSetGamma(backend->drm.fd,
Richard Hughese7299962013-05-01 21:52:12 +0100668 output->crtc_id,
669 size, r, g, b);
670 if (rc)
671 weston_log("set gamma failed: %m\n");
672}
673
Bryce Harringtonada4f072015-06-30 13:25:46 -0700674/* Determine the type of vblank synchronization to use for the output.
Pekka Paalanenb00c79b2016-02-18 16:53:27 +0200675 *
Bryce Harringtonada4f072015-06-30 13:25:46 -0700676 * The pipe parameter indicates which CRTC is in use. Knowing this, we
677 * can determine which vblank sequence type to use for it. Traditional
678 * cards had only two CRTCs, with CRTC 0 using no special flags, and
679 * CRTC 1 using DRM_VBLANK_SECONDARY. The first bit of the pipe
680 * parameter indicates this.
Pekka Paalanenb00c79b2016-02-18 16:53:27 +0200681 *
Bryce Harringtonada4f072015-06-30 13:25:46 -0700682 * Bits 1-5 of the pipe parameter are 5 bit wide pipe number between
683 * 0-31. If this is non-zero it indicates we're dealing with a
684 * multi-gpu situation and we need to calculate the vblank sync
685 * using DRM_BLANK_HIGH_CRTC_MASK.
686 */
Pekka Paalanenc8a1ff02015-07-02 15:06:08 +0300687static unsigned int
688drm_waitvblank_pipe(struct drm_output *output)
Mario Kleiner2ab4f4e2015-06-21 21:25:13 +0200689{
690 if (output->pipe > 1)
691 return (output->pipe << DRM_VBLANK_HIGH_CRTC_SHIFT) &
692 DRM_VBLANK_HIGH_CRTC_MASK;
693 else if (output->pipe > 0)
694 return DRM_VBLANK_SECONDARY;
695 else
696 return 0;
697}
698
David Herrmann1edf44c2013-10-22 17:11:26 +0200699static int
Kristian Høgsberg6ddcdae2012-02-28 22:31:58 -0500700drm_output_repaint(struct weston_output *output_base,
Kristian Høgsbergd7c17262012-09-05 21:54:15 -0400701 pixman_region32_t *damage)
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +0100702{
Armin Krezović545dba62016-08-05 15:54:18 +0200703 struct drm_output *output = to_drm_output(output_base);
Giulio Camuffo954f1832014-10-11 18:27:30 +0300704 struct drm_backend *backend =
Armin Krezović545dba62016-08-05 15:54:18 +0200705 to_drm_backend(output->base.compositor);
Jesse Barnes58ef3792012-02-23 09:45:49 -0500706 struct drm_sprite *s;
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -0400707 struct drm_mode *mode;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500708 int ret = 0;
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +0100709
Armin Krezović08368132016-09-30 14:11:05 +0200710 if (output->disable_pending || output->destroy_pending)
David Herrmann1edf44c2013-10-22 17:11:26 +0200711 return -1;
Xiong Zhangabd5d472013-10-11 14:43:07 +0800712
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300713 if (!output->next)
Kristian Høgsbergd7c17262012-09-05 21:54:15 -0400714 drm_output_render(output, damage);
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300715 if (!output->next)
David Herrmann1edf44c2013-10-22 17:11:26 +0200716 return -1;
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +0100717
Hardeningff39efa2013-09-18 23:56:35 +0200718 mode = container_of(output->base.current_mode, struct drm_mode, base);
Ander Conselvan de Oliveira65796812013-11-19 15:22:04 +0200719 if (!output->current ||
720 output->current->stride != output->next->stride) {
Giulio Camuffo954f1832014-10-11 18:27:30 +0300721 ret = drmModeSetCrtc(backend->drm.fd, output->crtc_id,
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300722 output->next->fb_id, 0, 0,
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -0400723 &output->connector_id, 1,
724 &mode->mode_info);
725 if (ret) {
Martin Minarik6d118362012-06-07 18:01:59 +0200726 weston_log("set mode failed: %m\n");
David Herrmann1edf44c2013-10-22 17:11:26 +0200727 goto err_pageflip;
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -0400728 }
Ander Conselvan de Oliveira722a2d52013-06-04 16:24:05 +0300729 output_base->set_dpms(output_base, WESTON_DPMS_ON);
Benjamin Franzke1178a3c2011-04-10 16:49:52 +0200730 }
731
Giulio Camuffo954f1832014-10-11 18:27:30 +0300732 if (drmModePageFlip(backend->drm.fd, output->crtc_id,
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300733 output->next->fb_id,
Kristian Høgsberg54f14c32012-01-18 11:47:41 -0500734 DRM_MODE_PAGE_FLIP_EVENT, output) < 0) {
Martin Minarik6d118362012-06-07 18:01:59 +0200735 weston_log("queueing pageflip failed: %m\n");
David Herrmann1edf44c2013-10-22 17:11:26 +0200736 goto err_pageflip;
Kristian Høgsberg54f14c32012-01-18 11:47:41 -0500737 }
Benjamin Franzkeec4d3422011-03-14 12:07:26 +0100738
Ander Conselvan de Oliveiraa7326962012-06-26 17:09:13 +0300739 output->page_flip_pending = 1;
740
Kristian Høgsberg5626d342012-08-03 11:50:05 -0400741 drm_output_set_cursor(output);
742
Jesse Barnes58ef3792012-02-23 09:45:49 -0500743 /*
744 * Now, update all the sprite surfaces
745 */
Giulio Camuffo954f1832014-10-11 18:27:30 +0300746 wl_list_for_each(s, &backend->sprite_list, link) {
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200747 uint32_t flags = 0, fb_id = 0;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500748 drmVBlank vbl = {
749 .request.type = DRM_VBLANK_RELATIVE | DRM_VBLANK_EVENT,
750 .request.sequence = 1,
751 };
752
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200753 if ((!s->current && !s->next) ||
Daniel Stonea3ae4762015-11-28 12:07:36 +0000754 !drm_sprite_crtc_supported(output, s))
Jesse Barnes58ef3792012-02-23 09:45:49 -0500755 continue;
756
Giulio Camuffo954f1832014-10-11 18:27:30 +0300757 if (s->next && !backend->sprites_hidden)
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200758 fb_id = s->next->fb_id;
759
Giulio Camuffo954f1832014-10-11 18:27:30 +0300760 ret = drmModeSetPlane(backend->drm.fd, s->plane_id,
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200761 output->crtc_id, fb_id, flags,
Jesse Barnes58ef3792012-02-23 09:45:49 -0500762 s->dest_x, s->dest_y,
763 s->dest_w, s->dest_h,
764 s->src_x, s->src_y,
765 s->src_w, s->src_h);
766 if (ret)
Martin Minarik6d118362012-06-07 18:01:59 +0200767 weston_log("setplane failed: %d: %s\n",
Jesse Barnes58ef3792012-02-23 09:45:49 -0500768 ret, strerror(errno));
769
Mario Kleiner2ab4f4e2015-06-21 21:25:13 +0200770 vbl.request.type |= drm_waitvblank_pipe(output);
Rob Clark5ca1a472012-08-08 20:27:37 -0500771
Jesse Barnes58ef3792012-02-23 09:45:49 -0500772 /*
773 * Queue a vblank signal so we know when the surface
774 * becomes active on the display or has been replaced.
775 */
776 vbl.request.signal = (unsigned long)s;
Giulio Camuffo954f1832014-10-11 18:27:30 +0300777 ret = drmWaitVBlank(backend->drm.fd, &vbl);
Jesse Barnes58ef3792012-02-23 09:45:49 -0500778 if (ret) {
Martin Minarik6d118362012-06-07 18:01:59 +0200779 weston_log("vblank event request failed: %d: %s\n",
Jesse Barnes58ef3792012-02-23 09:45:49 -0500780 ret, strerror(errno));
781 }
Ander Conselvan de Oliveiraa7326962012-06-26 17:09:13 +0300782
783 s->output = output;
784 output->vblank_pending = 1;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500785 }
786
David Herrmann1edf44c2013-10-22 17:11:26 +0200787 return 0;
788
789err_pageflip:
Kristian Høgsbergb3955b02014-01-23 16:25:06 -0800790 output->cursor_view = NULL;
David Herrmann1edf44c2013-10-22 17:11:26 +0200791 if (output->next) {
792 drm_output_release_fb(output, output->next);
793 output->next = NULL;
794 }
795
796 return -1;
Kristian Høgsbergfc783d42010-06-11 12:56:24 -0400797}
798
799static void
Jonas Ådahle5a12252013-04-05 23:07:11 +0200800drm_output_start_repaint_loop(struct weston_output *output_base)
801{
Armin Krezović545dba62016-08-05 15:54:18 +0200802 struct drm_output *output = to_drm_output(output_base);
803 struct drm_backend *backend =
804 to_drm_backend(output_base->compositor);
Jonas Ådahle5a12252013-04-05 23:07:11 +0200805 uint32_t fb_id;
Mario Kleinerf507ec32015-06-21 21:25:14 +0200806 struct timespec ts, tnow;
807 struct timespec vbl2now;
808 int64_t refresh_nsec;
809 int ret;
810 drmVBlank vbl = {
811 .request.type = DRM_VBLANK_RELATIVE,
812 .request.sequence = 0,
813 .request.signal = 0,
814 };
Ander Conselvan de Oliveira95eb3a22013-05-07 14:16:59 +0300815
Armin Krezović08368132016-09-30 14:11:05 +0200816 if (output->disable_pending || output->destroy_pending)
Xiong Zhangabd5d472013-10-11 14:43:07 +0800817 return;
818
Ander Conselvan de Oliveira95eb3a22013-05-07 14:16:59 +0300819 if (!output->current) {
820 /* We can't page flip if there's no mode set */
David Herrmann3c688c52013-10-22 17:11:25 +0200821 goto finish_frame;
Ander Conselvan de Oliveira95eb3a22013-05-07 14:16:59 +0300822 }
823
Mario Kleinerf507ec32015-06-21 21:25:14 +0200824 /* Try to get current msc and timestamp via instant query */
825 vbl.request.type |= drm_waitvblank_pipe(output);
826 ret = drmWaitVBlank(backend->drm.fd, &vbl);
827
828 /* Error ret or zero timestamp means failure to get valid timestamp */
829 if ((ret == 0) && (vbl.reply.tval_sec > 0 || vbl.reply.tval_usec > 0)) {
830 ts.tv_sec = vbl.reply.tval_sec;
831 ts.tv_nsec = vbl.reply.tval_usec * 1000;
832
833 /* Valid timestamp for most recent vblank - not stale?
834 * Stale ts could happen on Linux 3.17+, so make sure it
835 * is not older than 1 refresh duration since now.
836 */
837 weston_compositor_read_presentation_clock(backend->compositor,
838 &tnow);
839 timespec_sub(&vbl2now, &tnow, &ts);
840 refresh_nsec =
841 millihz_to_nsec(output->base.current_mode->refresh);
842 if (timespec_to_nsec(&vbl2now) < refresh_nsec) {
843 drm_output_update_msc(output, vbl.reply.sequence);
844 weston_output_finish_frame(output_base, &ts,
Pekka Paalanenb00c79b2016-02-18 16:53:27 +0200845 WP_PRESENTATION_FEEDBACK_INVALID);
Mario Kleinerf507ec32015-06-21 21:25:14 +0200846 return;
847 }
848 }
849
850 /* Immediate query didn't provide valid timestamp.
851 * Use pageflip fallback.
852 */
Ander Conselvan de Oliveira95eb3a22013-05-07 14:16:59 +0300853 fb_id = output->current->fb_id;
Jonas Ådahle5a12252013-04-05 23:07:11 +0200854
Giulio Camuffo954f1832014-10-11 18:27:30 +0300855 if (drmModePageFlip(backend->drm.fd, output->crtc_id, fb_id,
Jonas Ådahle5a12252013-04-05 23:07:11 +0200856 DRM_MODE_PAGE_FLIP_EVENT, output) < 0) {
857 weston_log("queueing pageflip failed: %m\n");
David Herrmann3c688c52013-10-22 17:11:25 +0200858 goto finish_frame;
Jonas Ådahle5a12252013-04-05 23:07:11 +0200859 }
David Herrmann3c688c52013-10-22 17:11:25 +0200860
861 return;
862
863finish_frame:
864 /* if we cannot page-flip, immediately finish frame */
Giulio Camuffo954f1832014-10-11 18:27:30 +0300865 weston_compositor_read_presentation_clock(output_base->compositor, &ts);
Pekka Paalanen363aa7b2014-12-17 16:20:40 +0200866 weston_output_finish_frame(output_base, &ts,
Pekka Paalanenb00c79b2016-02-18 16:53:27 +0200867 WP_PRESENTATION_FEEDBACK_INVALID);
Jonas Ådahle5a12252013-04-05 23:07:11 +0200868}
869
870static void
Pekka Paalanen641307c2014-09-23 22:08:47 -0400871drm_output_update_msc(struct drm_output *output, unsigned int seq)
872{
873 uint64_t msc_hi = output->base.msc >> 32;
874
875 if (seq < (output->base.msc & 0xffffffff))
876 msc_hi++;
877
878 output->base.msc = (msc_hi << 32) + seq;
879}
880
881static void
Jesse Barnes58ef3792012-02-23 09:45:49 -0500882vblank_handler(int fd, unsigned int frame, unsigned int sec, unsigned int usec,
883 void *data)
884{
885 struct drm_sprite *s = (struct drm_sprite *)data;
Ander Conselvan de Oliveiraa7326962012-06-26 17:09:13 +0300886 struct drm_output *output = s->output;
Pekka Paalanenb5eedad2014-09-23 22:08:45 -0400887 struct timespec ts;
Pekka Paalanenb00c79b2016-02-18 16:53:27 +0200888 uint32_t flags = WP_PRESENTATION_FEEDBACK_KIND_HW_COMPLETION |
889 WP_PRESENTATION_FEEDBACK_KIND_HW_CLOCK;
Ander Conselvan de Oliveiraa7326962012-06-26 17:09:13 +0300890
Pekka Paalanen641307c2014-09-23 22:08:47 -0400891 drm_output_update_msc(output, frame);
Ander Conselvan de Oliveiraa7326962012-06-26 17:09:13 +0300892 output->vblank_pending = 0;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500893
Ander Conselvan de Oliveira526d4612013-01-25 15:13:03 +0200894 drm_output_release_fb(output, s->current);
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200895 s->current = s->next;
896 s->next = NULL;
Ander Conselvan de Oliveiraa7326962012-06-26 17:09:13 +0300897
898 if (!output->page_flip_pending) {
Pekka Paalanenb5eedad2014-09-23 22:08:45 -0400899 ts.tv_sec = sec;
900 ts.tv_nsec = usec * 1000;
Pekka Paalanen363aa7b2014-12-17 16:20:40 +0200901 weston_output_finish_frame(&output->base, &ts, flags);
Ander Conselvan de Oliveiraa7326962012-06-26 17:09:13 +0300902 }
Jesse Barnes58ef3792012-02-23 09:45:49 -0500903}
904
905static void
Armin Krezović08368132016-09-30 14:11:05 +0200906drm_output_destroy(struct weston_output *base);
Xiong Zhangabd5d472013-10-11 14:43:07 +0800907
908static void
Kristian Høgsbergfc783d42010-06-11 12:56:24 -0400909page_flip_handler(int fd, unsigned int frame,
910 unsigned int sec, unsigned int usec, void *data)
911{
Armin Krezović545dba62016-08-05 15:54:18 +0200912 struct drm_output *output = data;
Pekka Paalanenb5eedad2014-09-23 22:08:45 -0400913 struct timespec ts;
Pekka Paalanenb00c79b2016-02-18 16:53:27 +0200914 uint32_t flags = WP_PRESENTATION_FEEDBACK_KIND_VSYNC |
915 WP_PRESENTATION_FEEDBACK_KIND_HW_COMPLETION |
916 WP_PRESENTATION_FEEDBACK_KIND_HW_CLOCK;
Kristian Høgsbergfc783d42010-06-11 12:56:24 -0400917
Pekka Paalanen641307c2014-09-23 22:08:47 -0400918 drm_output_update_msc(output, frame);
919
Jonas Ådahle5a12252013-04-05 23:07:11 +0200920 /* We don't set page_flip_pending on start_repaint_loop, in that case
921 * we just want to page flip to the current buffer to get an accurate
922 * timestamp */
923 if (output->page_flip_pending) {
924 drm_output_release_fb(output, output->current);
925 output->current = output->next;
926 output->next = NULL;
927 }
Ander Conselvan de Oliveiraa7326962012-06-26 17:09:13 +0300928
Jonas Ådahle5a12252013-04-05 23:07:11 +0200929 output->page_flip_pending = 0;
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -0400930
Xiong Zhangabd5d472013-10-11 14:43:07 +0800931 if (output->destroy_pending)
932 drm_output_destroy(&output->base);
Armin Krezović08368132016-09-30 14:11:05 +0200933 else if (output->disable_pending)
934 weston_output_disable(&output->base);
Xiong Zhangabd5d472013-10-11 14:43:07 +0800935 else if (!output->vblank_pending) {
Pekka Paalanenb5eedad2014-09-23 22:08:45 -0400936 ts.tv_sec = sec;
937 ts.tv_nsec = usec * 1000;
Pekka Paalanen363aa7b2014-12-17 16:20:40 +0200938 weston_output_finish_frame(&output->base, &ts, flags);
Ander Conselvan de Oliveira6aae4d32013-08-23 17:15:48 +0300939
940 /* We can't call this from frame_notify, because the output's
941 * repaint needed flag is cleared just after that */
942 if (output->recorder)
943 weston_output_schedule_repaint(&output->base);
Ander Conselvan de Oliveiraa7326962012-06-26 17:09:13 +0300944 }
Benjamin Franzke1178a3c2011-04-10 16:49:52 +0200945}
946
Kristian Høgsberga2f84cc2012-12-07 12:37:58 -0500947static uint32_t
948drm_output_check_sprite_format(struct drm_sprite *s,
Jason Ekstranda7af7042013-10-12 22:38:11 -0500949 struct weston_view *ev, struct gbm_bo *bo)
Jesse Barnes58ef3792012-02-23 09:45:49 -0500950{
Kristian Høgsberga2f84cc2012-12-07 12:37:58 -0500951 uint32_t i, format;
952
953 format = gbm_bo_get_format(bo);
954
955 if (format == GBM_FORMAT_ARGB8888) {
956 pixman_region32_t r;
957
Kristian Høgsberg63093a32013-03-01 14:29:16 -0500958 pixman_region32_init_rect(&r, 0, 0,
Jason Ekstrand918f2dd2013-12-02 21:01:53 -0600959 ev->surface->width,
960 ev->surface->height);
Jason Ekstranda7af7042013-10-12 22:38:11 -0500961 pixman_region32_subtract(&r, &r, &ev->surface->opaque);
Kristian Høgsberga2f84cc2012-12-07 12:37:58 -0500962
963 if (!pixman_region32_not_empty(&r))
964 format = GBM_FORMAT_XRGB8888;
965
966 pixman_region32_fini(&r);
967 }
Jesse Barnes58ef3792012-02-23 09:45:49 -0500968
969 for (i = 0; i < s->count_formats; i++)
970 if (s->formats[i] == format)
Kristian Høgsberga2f84cc2012-12-07 12:37:58 -0500971 return format;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500972
973 return 0;
974}
975
976static int
Jason Ekstranda7af7042013-10-12 22:38:11 -0500977drm_view_transform_supported(struct weston_view *ev)
Jesse Barnes58ef3792012-02-23 09:45:49 -0500978{
Jason Ekstranda7af7042013-10-12 22:38:11 -0500979 return !ev->transform.enabled ||
980 (ev->transform.matrix.type < WESTON_MATRIX_TRANSFORM_ROTATE);
Jesse Barnes58ef3792012-02-23 09:45:49 -0500981}
982
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400983static struct weston_plane *
Pekka Paalanen050c1ba2014-12-17 16:20:38 +0200984drm_output_prepare_overlay_view(struct drm_output *output,
Jason Ekstranda7af7042013-10-12 22:38:11 -0500985 struct weston_view *ev)
Jesse Barnes58ef3792012-02-23 09:45:49 -0500986{
Pekka Paalanen050c1ba2014-12-17 16:20:38 +0200987 struct weston_compositor *ec = output->base.compositor;
Armin Krezović545dba62016-08-05 15:54:18 +0200988 struct drm_backend *b = to_drm_backend(ec);
Pekka Paalanen952b6c82014-03-14 14:38:15 +0200989 struct weston_buffer_viewport *viewport = &ev->surface->buffer_viewport;
Pekka Paalanenbf8cc6f2014-06-12 17:12:12 +0300990 struct wl_resource *buffer_resource;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500991 struct drm_sprite *s;
Pekka Paalanenbf8cc6f2014-06-12 17:12:12 +0300992 struct linux_dmabuf_buffer *dmabuf;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500993 int found = 0;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500994 struct gbm_bo *bo;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500995 pixman_region32_t dest_rect, src_rect;
Ander Conselvan de Oliveira409eebf2012-12-05 15:14:04 +0200996 pixman_box32_t *box, tbox;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500997 uint32_t format;
Kristian Høgsberg3b00bae2012-07-13 15:25:07 -0400998 wl_fixed_t sx1, sy1, sx2, sy2;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500999
Giulio Camuffo954f1832014-10-11 18:27:30 +03001000 if (b->sprites_are_broken)
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04001001 return NULL;
Kristian Høgsberg65bec242012-03-05 19:57:35 -05001002
Daniel Stone296d7a92016-10-21 18:05:37 +01001003 /* Don't import buffers which span multiple outputs. */
Pekka Paalanen050c1ba2014-12-17 16:20:38 +02001004 if (ev->output_mask != (1u << output->base.id))
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04001005 return NULL;
Ander Conselvan de Oliveirad450b192012-06-26 17:09:12 +03001006
Daniel Stone296d7a92016-10-21 18:05:37 +01001007 /* We can only import GBM buffers. */
1008 if (b->gbm == NULL)
1009 return NULL;
1010
Jason Ekstranda7af7042013-10-12 22:38:11 -05001011 if (ev->surface->buffer_ref.buffer == NULL)
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04001012 return NULL;
Pekka Paalanenbf8cc6f2014-06-12 17:12:12 +03001013 buffer_resource = ev->surface->buffer_ref.buffer->resource;
Pekka Paalanenbf8cc6f2014-06-12 17:12:12 +03001014 if (wl_shm_buffer_get(buffer_resource))
Rob Clark702ffae2012-08-09 14:18:27 -05001015 return NULL;
1016
Daniel Stone296d7a92016-10-21 18:05:37 +01001017 if (viewport->buffer.transform != output->base.transform)
1018 return NULL;
1019 if (viewport->buffer.scale != output->base.current_scale)
1020 return NULL;
Jason Ekstranda7af7042013-10-12 22:38:11 -05001021 if (!drm_view_transform_supported(ev))
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04001022 return NULL;
Jesse Barnes58ef3792012-02-23 09:45:49 -05001023
Daniel Stone296d7a92016-10-21 18:05:37 +01001024 if (ev->alpha != 1.0f)
1025 return NULL;
1026
Giulio Camuffo954f1832014-10-11 18:27:30 +03001027 wl_list_for_each(s, &b->sprite_list, link) {
Daniel Stonea3ae4762015-11-28 12:07:36 +00001028 if (!drm_sprite_crtc_supported(output, s))
Jesse Barnes58ef3792012-02-23 09:45:49 -05001029 continue;
1030
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +02001031 if (!s->next) {
Jesse Barnes58ef3792012-02-23 09:45:49 -05001032 found = 1;
1033 break;
1034 }
1035 }
1036
1037 /* No sprites available */
1038 if (!found)
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04001039 return NULL;
Jesse Barnes58ef3792012-02-23 09:45:49 -05001040
Pekka Paalanenbf8cc6f2014-06-12 17:12:12 +03001041 if ((dmabuf = linux_dmabuf_buffer_get(buffer_resource))) {
Bryce Harringtona3582072015-08-14 12:23:13 -07001042#ifdef HAVE_GBM_FD_IMPORT
Pekka Paalanenbf8cc6f2014-06-12 17:12:12 +03001043 /* XXX: TODO:
1044 *
1045 * Use AddFB2 directly, do not go via GBM.
1046 * Add support for multiplanar formats.
1047 * Both require refactoring in the DRM-backend to
1048 * support a mix of gbm_bos and drmfbs.
1049 */
1050 struct gbm_import_fd_data gbm_dmabuf = {
Emmanuel Gil Peyrotc3996922015-11-24 19:28:24 +00001051 .fd = dmabuf->attributes.fd[0],
1052 .width = dmabuf->attributes.width,
1053 .height = dmabuf->attributes.height,
1054 .stride = dmabuf->attributes.stride[0],
1055 .format = dmabuf->attributes.format
Pekka Paalanenbf8cc6f2014-06-12 17:12:12 +03001056 };
1057
Micah Fedkec8890122017-02-01 15:28:23 -05001058 /* XXX: TODO:
1059 *
1060 * Currently the buffer is rejected if any dmabuf attribute
1061 * flag is set. This keeps us from passing an inverted /
1062 * interlaced / bottom-first buffer (or any other type that may
1063 * be added in the future) through to an overlay. Ultimately,
1064 * these types of buffers should be handled through buffer
1065 * transforms and not as spot-checks requiring specific
1066 * knowledge. */
1067 if (dmabuf->attributes.n_planes != 1 ||
1068 dmabuf->attributes.offset[0] != 0 ||
1069 dmabuf->attributes.flags)
Pekka Paalanenbf8cc6f2014-06-12 17:12:12 +03001070 return NULL;
1071
1072 bo = gbm_bo_import(b->gbm, GBM_BO_IMPORT_FD, &gbm_dmabuf,
1073 GBM_BO_USE_SCANOUT);
Bryce Harringtona3582072015-08-14 12:23:13 -07001074#else
1075 return NULL;
1076#endif
Pekka Paalanenbf8cc6f2014-06-12 17:12:12 +03001077 } else {
1078 bo = gbm_bo_import(b->gbm, GBM_BO_IMPORT_WL_BUFFER,
1079 buffer_resource, GBM_BO_USE_SCANOUT);
1080 }
Kristian Høgsberg2763a2e2012-07-13 22:54:43 -04001081 if (!bo)
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04001082 return NULL;
Kristian Høgsberg2763a2e2012-07-13 22:54:43 -04001083
Jason Ekstranda7af7042013-10-12 22:38:11 -05001084 format = drm_output_check_sprite_format(s, ev, bo);
Kristian Høgsberga2f84cc2012-12-07 12:37:58 -05001085 if (format == 0) {
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +02001086 gbm_bo_destroy(bo);
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04001087 return NULL;
Jesse Barnes58ef3792012-02-23 09:45:49 -05001088 }
1089
Giulio Camuffo954f1832014-10-11 18:27:30 +03001090 s->next = drm_fb_get_from_bo(bo, b, format);
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +02001091 if (!s->next) {
1092 gbm_bo_destroy(bo);
1093 return NULL;
1094 }
1095
Jason Ekstranda7af7042013-10-12 22:38:11 -05001096 drm_fb_set_buffer(s->next, ev->surface->buffer_ref.buffer);
Jesse Barnes58ef3792012-02-23 09:45:49 -05001097
Jason Ekstranda7af7042013-10-12 22:38:11 -05001098 box = pixman_region32_extents(&ev->transform.boundingbox);
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04001099 s->plane.x = box->x1;
1100 s->plane.y = box->y1;
1101
Jesse Barnes58ef3792012-02-23 09:45:49 -05001102 /*
1103 * Calculate the source & dest rects properly based on actual
Derek Foreman4b1a0a12014-09-10 15:37:33 -05001104 * position (note the caller has called weston_view_update_transform()
Jesse Barnes58ef3792012-02-23 09:45:49 -05001105 * for us already).
1106 */
1107 pixman_region32_init(&dest_rect);
Jason Ekstranda7af7042013-10-12 22:38:11 -05001108 pixman_region32_intersect(&dest_rect, &ev->transform.boundingbox,
Pekka Paalanen050c1ba2014-12-17 16:20:38 +02001109 &output->base.region);
1110 pixman_region32_translate(&dest_rect, -output->base.x, -output->base.y);
Jesse Barnes58ef3792012-02-23 09:45:49 -05001111 box = pixman_region32_extents(&dest_rect);
Pekka Paalanen050c1ba2014-12-17 16:20:38 +02001112 tbox = weston_transformed_rect(output->base.width,
1113 output->base.height,
1114 output->base.transform,
1115 output->base.current_scale,
Alexander Larssond9a7bb72013-05-22 14:41:39 +02001116 *box);
Ander Conselvan de Oliveira409eebf2012-12-05 15:14:04 +02001117 s->dest_x = tbox.x1;
1118 s->dest_y = tbox.y1;
1119 s->dest_w = tbox.x2 - tbox.x1;
1120 s->dest_h = tbox.y2 - tbox.y1;
Jesse Barnes58ef3792012-02-23 09:45:49 -05001121 pixman_region32_fini(&dest_rect);
1122
1123 pixman_region32_init(&src_rect);
Jason Ekstranda7af7042013-10-12 22:38:11 -05001124 pixman_region32_intersect(&src_rect, &ev->transform.boundingbox,
Pekka Paalanen050c1ba2014-12-17 16:20:38 +02001125 &output->base.region);
Jesse Barnes58ef3792012-02-23 09:45:49 -05001126 box = pixman_region32_extents(&src_rect);
Kristian Høgsberg3b00bae2012-07-13 15:25:07 -04001127
Jason Ekstranda7af7042013-10-12 22:38:11 -05001128 weston_view_from_global_fixed(ev,
1129 wl_fixed_from_int(box->x1),
1130 wl_fixed_from_int(box->y1),
1131 &sx1, &sy1);
1132 weston_view_from_global_fixed(ev,
1133 wl_fixed_from_int(box->x2),
1134 wl_fixed_from_int(box->y2),
1135 &sx2, &sy2);
Kristian Høgsberg3b00bae2012-07-13 15:25:07 -04001136
1137 if (sx1 < 0)
1138 sx1 = 0;
1139 if (sy1 < 0)
1140 sy1 = 0;
Jason Ekstrand918f2dd2013-12-02 21:01:53 -06001141 if (sx2 > wl_fixed_from_int(ev->surface->width))
1142 sx2 = wl_fixed_from_int(ev->surface->width);
1143 if (sy2 > wl_fixed_from_int(ev->surface->height))
1144 sy2 = wl_fixed_from_int(ev->surface->height);
Kristian Høgsberg3b00bae2012-07-13 15:25:07 -04001145
Ander Conselvan de Oliveira409eebf2012-12-05 15:14:04 +02001146 tbox.x1 = sx1;
1147 tbox.y1 = sy1;
1148 tbox.x2 = sx2;
1149 tbox.y2 = sy2;
1150
Jason Ekstrand918f2dd2013-12-02 21:01:53 -06001151 tbox = weston_transformed_rect(wl_fixed_from_int(ev->surface->width),
1152 wl_fixed_from_int(ev->surface->height),
Pekka Paalanen952b6c82014-03-14 14:38:15 +02001153 viewport->buffer.transform,
1154 viewport->buffer.scale,
Pekka Paalanen1fd9c0f2013-11-26 18:19:41 +01001155 tbox);
Ander Conselvan de Oliveira409eebf2012-12-05 15:14:04 +02001156
1157 s->src_x = tbox.x1 << 8;
1158 s->src_y = tbox.y1 << 8;
1159 s->src_w = (tbox.x2 - tbox.x1) << 8;
1160 s->src_h = (tbox.y2 - tbox.y1) << 8;
Jesse Barnes58ef3792012-02-23 09:45:49 -05001161 pixman_region32_fini(&src_rect);
1162
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04001163 return &s->plane;
Jesse Barnes58ef3792012-02-23 09:45:49 -05001164}
1165
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04001166static struct weston_plane *
Pekka Paalanen050c1ba2014-12-17 16:20:38 +02001167drm_output_prepare_cursor_view(struct drm_output *output,
Jason Ekstranda7af7042013-10-12 22:38:11 -05001168 struct weston_view *ev)
Kristian Høgsbergd8bf90c2012-02-23 23:03:14 -05001169{
Armin Krezović545dba62016-08-05 15:54:18 +02001170 struct drm_backend *b = to_drm_backend(output->base.compositor);
Neil Robertsf37f82c2014-05-01 18:00:41 +01001171 struct weston_buffer_viewport *viewport = &ev->surface->buffer_viewport;
Derek Foreman6c19b692015-12-03 14:07:12 -06001172 struct wl_shm_buffer *shmbuf;
Kristian Høgsberg5626d342012-08-03 11:50:05 -04001173
Giulio Camuffo954f1832014-10-11 18:27:30 +03001174 if (b->cursors_are_broken)
Kristian Høgsberg8a015802012-08-09 17:19:23 -04001175 return NULL;
Daniel Stone296d7a92016-10-21 18:05:37 +01001176
1177 if (output->cursor_view)
Pekka Paalanen5580f222015-02-17 16:33:18 +02001178 return NULL;
Daniel Stone296d7a92016-10-21 18:05:37 +01001179
1180 /* Don't import buffers which span multiple outputs. */
1181 if (ev->output_mask != (1u << output->base.id))
1182 return NULL;
1183
1184 /* We use GBM to import SHM buffers. */
1185 if (b->gbm == NULL)
1186 return NULL;
1187
Derek Foreman6c19b692015-12-03 14:07:12 -06001188 if (ev->surface->buffer_ref.buffer == NULL)
1189 return NULL;
1190 shmbuf = wl_shm_buffer_get(ev->surface->buffer_ref.buffer->resource);
1191 if (!shmbuf)
1192 return NULL;
1193 if (wl_shm_buffer_get_format(shmbuf) != WL_SHM_FORMAT_ARGB8888)
1194 return NULL;
Daniel Stone296d7a92016-10-21 18:05:37 +01001195
1196 if (output->base.transform != WL_OUTPUT_TRANSFORM_NORMAL)
1197 return NULL;
1198 if (ev->transform.enabled &&
1199 (ev->transform.matrix.type > WESTON_MATRIX_TRANSFORM_TRANSLATE))
1200 return NULL;
1201 if (viewport->buffer.scale != output->base.current_scale)
1202 return NULL;
1203 if (ev->geometry.scissor_enabled)
1204 return NULL;
1205
Derek Foreman6c19b692015-12-03 14:07:12 -06001206 if (ev->surface->width > b->cursor_width ||
Daniel Stone70d337d2015-06-16 18:42:23 +01001207 ev->surface->height > b->cursor_height)
Kristian Høgsberg5626d342012-08-03 11:50:05 -04001208 return NULL;
1209
Jason Ekstranda7af7042013-10-12 22:38:11 -05001210 output->cursor_view = ev;
Kristian Høgsberg5626d342012-08-03 11:50:05 -04001211
1212 return &output->cursor_plane;
1213}
1214
Pekka Paalanend0ead482014-06-16 12:05:40 +03001215/**
1216 * Update the image for the current cursor surface
1217 *
1218 * @param b DRM backend structure
1219 * @param bo GBM buffer object to write into
1220 * @param ev View to use for cursor image
1221 */
1222static void
1223cursor_bo_update(struct drm_backend *b, struct gbm_bo *bo,
1224 struct weston_view *ev)
1225{
1226 struct weston_buffer *buffer = ev->surface->buffer_ref.buffer;
1227 uint32_t buf[b->cursor_width * b->cursor_height];
1228 int32_t stride;
1229 uint8_t *s;
1230 int i;
1231
1232 assert(buffer && buffer->shm_buffer);
1233 assert(buffer->shm_buffer == wl_shm_buffer_get(buffer->resource));
1234 assert(ev->surface->width <= b->cursor_width);
1235 assert(ev->surface->height <= b->cursor_height);
1236
1237 memset(buf, 0, sizeof buf);
1238 stride = wl_shm_buffer_get_stride(buffer->shm_buffer);
1239 s = wl_shm_buffer_get_data(buffer->shm_buffer);
1240
1241 wl_shm_buffer_begin_access(buffer->shm_buffer);
1242 for (i = 0; i < ev->surface->height; i++)
1243 memcpy(buf + i * b->cursor_width,
1244 s + i * stride,
1245 ev->surface->width * 4);
1246 wl_shm_buffer_end_access(buffer->shm_buffer);
1247
1248 if (gbm_bo_write(bo, buf, sizeof buf) < 0)
1249 weston_log("failed update cursor: %m\n");
1250}
1251
Kristian Høgsberg5626d342012-08-03 11:50:05 -04001252static void
1253drm_output_set_cursor(struct drm_output *output)
1254{
Jason Ekstranda7af7042013-10-12 22:38:11 -05001255 struct weston_view *ev = output->cursor_view;
Neil Robertse5051712013-11-13 15:44:06 +00001256 struct weston_buffer *buffer;
Armin Krezović545dba62016-08-05 15:54:18 +02001257 struct drm_backend *b = to_drm_backend(output->base.compositor);
Pekka Paalanend0ead482014-06-16 12:05:40 +03001258 EGLint handle;
Kristian Høgsberga6edab32012-07-14 01:06:28 -04001259 struct gbm_bo *bo;
Derek Foremanbe428b32015-11-24 11:39:38 -06001260 float x, y;
Kristian Høgsbergd8bf90c2012-02-23 23:03:14 -05001261
Jason Ekstranda7af7042013-10-12 22:38:11 -05001262 output->cursor_view = NULL;
1263 if (ev == NULL) {
Giulio Camuffo954f1832014-10-11 18:27:30 +03001264 drmModeSetCursor(b->drm.fd, output->crtc_id, 0, 0, 0);
Derek Foremanb0427562016-02-05 15:55:20 -06001265 output->cursor_plane.x = INT32_MIN;
1266 output->cursor_plane.y = INT32_MIN;
Kristian Høgsberg5626d342012-08-03 11:50:05 -04001267 return;
1268 }
Kristian Høgsbergd8bf90c2012-02-23 23:03:14 -05001269
Neil Robertse5051712013-11-13 15:44:06 +00001270 buffer = ev->surface->buffer_ref.buffer;
1271
1272 if (buffer &&
Pekka Paalanende685b82012-12-04 15:58:12 +02001273 pixman_region32_not_empty(&output->cursor_plane.damage)) {
Kristian Høgsberg5626d342012-08-03 11:50:05 -04001274 pixman_region32_fini(&output->cursor_plane.damage);
1275 pixman_region32_init(&output->cursor_plane.damage);
Kristian Høgsberg1f5de352012-07-18 12:09:58 -04001276 output->current_cursor ^= 1;
Miguel A. Vicofcf4b6c2016-03-21 17:41:03 +01001277 bo = output->gbm_cursor_bo[output->current_cursor];
Kristian Høgsbergd8bf90c2012-02-23 23:03:14 -05001278
Pekka Paalanend0ead482014-06-16 12:05:40 +03001279 cursor_bo_update(b, bo, ev);
Kristian Høgsberg1f5de352012-07-18 12:09:58 -04001280 handle = gbm_bo_get_handle(bo).s32;
Giulio Camuffo954f1832014-10-11 18:27:30 +03001281 if (drmModeSetCursor(b->drm.fd, output->crtc_id, handle,
1282 b->cursor_width, b->cursor_height)) {
Pekka Paalanenae29da22012-08-06 14:57:05 +03001283 weston_log("failed to set cursor: %m\n");
Giulio Camuffo954f1832014-10-11 18:27:30 +03001284 b->cursors_are_broken = 1;
Rob Clarkab5b1e32012-08-09 13:24:45 -05001285 }
Kristian Høgsberga6edab32012-07-14 01:06:28 -04001286 }
1287
Derek Foremanbe428b32015-11-24 11:39:38 -06001288 weston_view_to_global_float(ev, 0, 0, &x, &y);
Pekka Paalanen7eaed402015-11-27 14:20:58 +02001289
1290 /* From global to output space, output transform is guaranteed to be
1291 * NORMAL by drm_output_prepare_cursor_view().
1292 */
1293 x = (x - output->base.x) * output->base.current_scale;
1294 y = (y - output->base.y) * output->base.current_scale;
1295
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04001296 if (output->cursor_plane.x != x || output->cursor_plane.y != y) {
Giulio Camuffo954f1832014-10-11 18:27:30 +03001297 if (drmModeMoveCursor(b->drm.fd, output->crtc_id, x, y)) {
Kristian Høgsberg24e42752012-07-18 12:08:37 -04001298 weston_log("failed to move cursor: %m\n");
Giulio Camuffo954f1832014-10-11 18:27:30 +03001299 b->cursors_are_broken = 1;
Rob Clarkab5b1e32012-08-09 13:24:45 -05001300 }
1301
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04001302 output->cursor_plane.x = x;
1303 output->cursor_plane.y = y;
Kristian Høgsberga6edab32012-07-14 01:06:28 -04001304 }
Kristian Høgsbergd8bf90c2012-02-23 23:03:14 -05001305}
1306
Jesse Barnes58ef3792012-02-23 09:45:49 -05001307static void
Pekka Paalanen050c1ba2014-12-17 16:20:38 +02001308drm_assign_planes(struct weston_output *output_base)
Jesse Barnes58ef3792012-02-23 09:45:49 -05001309{
Armin Krezović545dba62016-08-05 15:54:18 +02001310 struct drm_backend *b = to_drm_backend(output_base->compositor);
1311 struct drm_output *output = to_drm_output(output_base);
Jason Ekstranda7af7042013-10-12 22:38:11 -05001312 struct weston_view *ev, *next;
Jesse Barnes58ef3792012-02-23 09:45:49 -05001313 pixman_region32_t overlap, surface_overlap;
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04001314 struct weston_plane *primary, *next_plane;
Jesse Barnes58ef3792012-02-23 09:45:49 -05001315
1316 /*
1317 * Find a surface for each sprite in the output using some heuristics:
1318 * 1) size
1319 * 2) frequency of update
1320 * 3) opacity (though some hw might support alpha blending)
1321 * 4) clipping (this can be fixed with color keys)
1322 *
1323 * The idea is to save on blitting since this should save power.
1324 * If we can get a large video surface on the sprite for example,
1325 * the main display surface may not need to update at all, and
1326 * the client buffer can be used directly for the sprite surface
1327 * as we do for flipping full screen surfaces.
1328 */
1329 pixman_region32_init(&overlap);
Giulio Camuffo954f1832014-10-11 18:27:30 +03001330 primary = &output_base->compositor->primary_plane;
Jason Ekstranda7af7042013-10-12 22:38:11 -05001331
Giulio Camuffo954f1832014-10-11 18:27:30 +03001332 wl_list_for_each_safe(ev, next, &output_base->compositor->view_list, link) {
Ander Conselvan de Oliveira895b1fd2013-11-19 15:22:05 +02001333 struct weston_surface *es = ev->surface;
1334
1335 /* Test whether this buffer can ever go into a plane:
1336 * non-shm, or small enough to be a cursor.
1337 *
1338 * Also, keep a reference when using the pixman renderer.
1339 * That makes it possible to do a seamless switch to the GL
1340 * renderer and since the pixman renderer keeps a reference
1341 * to the buffer anyway, there is no side effects.
Pekka Paalanenccfeae22012-12-04 15:58:14 +02001342 */
Giulio Camuffo954f1832014-10-11 18:27:30 +03001343 if (b->use_pixman ||
Ander Conselvan de Oliveira895b1fd2013-11-19 15:22:05 +02001344 (es->buffer_ref.buffer &&
1345 (!wl_shm_buffer_get(es->buffer_ref.buffer->resource) ||
Derek Foreman87430472015-10-15 10:24:48 -05001346 (ev->surface->width <= b->cursor_width &&
1347 ev->surface->height <= b->cursor_height))))
Derek Foreman0fd6d4e2014-10-10 09:36:45 -05001348 es->keep_buffer = true;
Ander Conselvan de Oliveira895b1fd2013-11-19 15:22:05 +02001349 else
Derek Foreman0fd6d4e2014-10-10 09:36:45 -05001350 es->keep_buffer = false;
Pekka Paalanenccfeae22012-12-04 15:58:14 +02001351
Jesse Barnes58ef3792012-02-23 09:45:49 -05001352 pixman_region32_init(&surface_overlap);
1353 pixman_region32_intersect(&surface_overlap, &overlap,
Jason Ekstranda7af7042013-10-12 22:38:11 -05001354 &ev->transform.boundingbox);
Jesse Barnes58ef3792012-02-23 09:45:49 -05001355
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04001356 next_plane = NULL;
Kristian Høgsberg6143f7d2012-07-14 00:31:32 -04001357 if (pixman_region32_not_empty(&surface_overlap))
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04001358 next_plane = primary;
1359 if (next_plane == NULL)
Jason Ekstranda7af7042013-10-12 22:38:11 -05001360 next_plane = drm_output_prepare_cursor_view(output, ev);
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04001361 if (next_plane == NULL)
Jason Ekstranda7af7042013-10-12 22:38:11 -05001362 next_plane = drm_output_prepare_scanout_view(output, ev);
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04001363 if (next_plane == NULL)
Jason Ekstranda7af7042013-10-12 22:38:11 -05001364 next_plane = drm_output_prepare_overlay_view(output, ev);
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04001365 if (next_plane == NULL)
1366 next_plane = primary;
Pekka Paalanenbf0e0312014-12-17 16:20:41 +02001367
Jason Ekstranda7af7042013-10-12 22:38:11 -05001368 weston_view_move_to_plane(ev, next_plane);
Pekka Paalanenbf0e0312014-12-17 16:20:41 +02001369
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04001370 if (next_plane == primary)
Jesse Barnes58ef3792012-02-23 09:45:49 -05001371 pixman_region32_union(&overlap, &overlap,
Jason Ekstranda7af7042013-10-12 22:38:11 -05001372 &ev->transform.boundingbox);
Kristian Høgsberg6143f7d2012-07-14 00:31:32 -04001373
Pekka Paalanenbf0e0312014-12-17 16:20:41 +02001374 if (next_plane == primary ||
1375 next_plane == &output->cursor_plane) {
1376 /* cursor plane involves a copy */
1377 ev->psf_flags = 0;
1378 } else {
1379 /* All other planes are a direct scanout of a
1380 * single client buffer.
1381 */
Pekka Paalanenb00c79b2016-02-18 16:53:27 +02001382 ev->psf_flags = WP_PRESENTATION_FEEDBACK_KIND_ZERO_COPY;
Pekka Paalanenbf0e0312014-12-17 16:20:41 +02001383 }
1384
Jesse Barnes58ef3792012-02-23 09:45:49 -05001385 pixman_region32_fini(&surface_overlap);
1386 }
1387 pixman_region32_fini(&overlap);
Jesse Barnes58ef3792012-02-23 09:45:49 -05001388}
1389
Pekka Paalanen7b36b422014-06-04 14:00:53 +03001390/**
1391 * Find the closest-matching mode for a given target
1392 *
1393 * Given a target mode, find the most suitable mode amongst the output's
1394 * current mode list to use, preferring the current mode if possible, to
1395 * avoid an expensive mode switch.
1396 *
1397 * @param output DRM output
1398 * @param target_mode Mode to attempt to match
1399 * @returns Pointer to a mode from the output's mode list
1400 */
Alex Wub7b8bda2012-04-17 17:20:48 +08001401static struct drm_mode *
1402choose_mode (struct drm_output *output, struct weston_mode *target_mode)
1403{
1404 struct drm_mode *tmp_mode = NULL, *mode;
1405
Hardeningff39efa2013-09-18 23:56:35 +02001406 if (output->base.current_mode->width == target_mode->width &&
1407 output->base.current_mode->height == target_mode->height &&
1408 (output->base.current_mode->refresh == target_mode->refresh ||
Alex Wub7b8bda2012-04-17 17:20:48 +08001409 target_mode->refresh == 0))
Hardeningff39efa2013-09-18 23:56:35 +02001410 return (struct drm_mode *)output->base.current_mode;
Alex Wub7b8bda2012-04-17 17:20:48 +08001411
1412 wl_list_for_each(mode, &output->base.mode_list, base.link) {
1413 if (mode->mode_info.hdisplay == target_mode->width &&
1414 mode->mode_info.vdisplay == target_mode->height) {
Mario Kleiner872797c2015-06-21 21:25:09 +02001415 if (mode->base.refresh == target_mode->refresh ||
1416 target_mode->refresh == 0) {
Alex Wub7b8bda2012-04-17 17:20:48 +08001417 return mode;
Daniel Stonef556ebe2015-05-21 08:28:58 +01001418 } else if (!tmp_mode)
Alex Wub7b8bda2012-04-17 17:20:48 +08001419 tmp_mode = mode;
1420 }
1421 }
1422
1423 return tmp_mode;
1424}
1425
1426static int
Giulio Camuffo954f1832014-10-11 18:27:30 +03001427drm_output_init_egl(struct drm_output *output, struct drm_backend *b);
Daniel Stone3e661f72016-11-04 17:24:06 +00001428static void
1429drm_output_fini_egl(struct drm_output *output);
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02001430static int
Giulio Camuffo954f1832014-10-11 18:27:30 +03001431drm_output_init_pixman(struct drm_output *output, struct drm_backend *b);
Daniel Stone3e661f72016-11-04 17:24:06 +00001432static void
1433drm_output_fini_pixman(struct drm_output *output);
Ander Conselvan de Oliveira6c01c9c2012-12-14 13:37:30 -02001434
1435static int
Alex Wub7b8bda2012-04-17 17:20:48 +08001436drm_output_switch_mode(struct weston_output *output_base, struct weston_mode *mode)
1437{
1438 struct drm_output *output;
1439 struct drm_mode *drm_mode;
Giulio Camuffo954f1832014-10-11 18:27:30 +03001440 struct drm_backend *b;
Alex Wub7b8bda2012-04-17 17:20:48 +08001441
1442 if (output_base == NULL) {
Martin Minarik6d118362012-06-07 18:01:59 +02001443 weston_log("output is NULL.\n");
Alex Wub7b8bda2012-04-17 17:20:48 +08001444 return -1;
1445 }
1446
1447 if (mode == NULL) {
Martin Minarik6d118362012-06-07 18:01:59 +02001448 weston_log("mode is NULL.\n");
Alex Wub7b8bda2012-04-17 17:20:48 +08001449 return -1;
1450 }
1451
Armin Krezović545dba62016-08-05 15:54:18 +02001452 b = to_drm_backend(output_base->compositor);
1453 output = to_drm_output(output_base);
Alex Wub7b8bda2012-04-17 17:20:48 +08001454 drm_mode = choose_mode (output, mode);
1455
1456 if (!drm_mode) {
Martin Minarik6d118362012-06-07 18:01:59 +02001457 weston_log("%s, invalid resolution:%dx%d\n", __func__, mode->width, mode->height);
Alex Wub7b8bda2012-04-17 17:20:48 +08001458 return -1;
Ander Conselvan de Oliveira6c01c9c2012-12-14 13:37:30 -02001459 }
1460
Hardeningff39efa2013-09-18 23:56:35 +02001461 if (&drm_mode->base == output->base.current_mode)
Alex Wub7b8bda2012-04-17 17:20:48 +08001462 return 0;
Alex Wub7b8bda2012-04-17 17:20:48 +08001463
Hardeningff39efa2013-09-18 23:56:35 +02001464 output->base.current_mode->flags = 0;
Alex Wub7b8bda2012-04-17 17:20:48 +08001465
Hardeningff39efa2013-09-18 23:56:35 +02001466 output->base.current_mode = &drm_mode->base;
1467 output->base.current_mode->flags =
Alex Wub7b8bda2012-04-17 17:20:48 +08001468 WL_OUTPUT_MODE_CURRENT | WL_OUTPUT_MODE_PREFERRED;
1469
Alex Wub7b8bda2012-04-17 17:20:48 +08001470 /* reset rendering stuff. */
Ander Conselvan de Oliveira526d4612013-01-25 15:13:03 +02001471 drm_output_release_fb(output, output->current);
1472 drm_output_release_fb(output, output->next);
1473 output->current = output->next = NULL;
Alex Wub7b8bda2012-04-17 17:20:48 +08001474
Giulio Camuffo954f1832014-10-11 18:27:30 +03001475 if (b->use_pixman) {
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02001476 drm_output_fini_pixman(output);
Giulio Camuffo954f1832014-10-11 18:27:30 +03001477 if (drm_output_init_pixman(output, b) < 0) {
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02001478 weston_log("failed to init output pixman state with "
1479 "new mode\n");
1480 return -1;
1481 }
1482 } else {
Daniel Stone3e661f72016-11-04 17:24:06 +00001483 drm_output_fini_egl(output);
Giulio Camuffo954f1832014-10-11 18:27:30 +03001484 if (drm_output_init_egl(output, b) < 0) {
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02001485 weston_log("failed to init output egl state with "
1486 "new mode");
1487 return -1;
1488 }
Ander Conselvan de Oliveira6c01c9c2012-12-14 13:37:30 -02001489 }
1490
Alex Wub7b8bda2012-04-17 17:20:48 +08001491 return 0;
Alex Wub7b8bda2012-04-17 17:20:48 +08001492}
1493
Kristian Høgsbergb1868472011-04-22 12:27:57 -04001494static int
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001495on_drm_input(int fd, uint32_t mask, void *data)
1496{
1497 drmEventContext evctx;
1498
1499 memset(&evctx, 0, sizeof evctx);
1500 evctx.version = DRM_EVENT_CONTEXT_VERSION;
1501 evctx.page_flip_handler = page_flip_handler;
Jesse Barnes58ef3792012-02-23 09:45:49 -05001502 evctx.vblank_handler = vblank_handler;
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001503 drmHandleEvent(fd, &evctx);
Kristian Høgsbergb1868472011-04-22 12:27:57 -04001504
1505 return 1;
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001506}
1507
1508static int
Daniel Stoneefa504f2016-12-19 16:48:20 +00001509init_kms_caps(struct drm_backend *b)
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001510{
Ander Conselvan de Oliveira95eb3a22013-05-07 14:16:59 +03001511 uint64_t cap;
Daniel Stoneefa504f2016-12-19 16:48:20 +00001512 int ret;
Pekka Paalanenb5eedad2014-09-23 22:08:45 -04001513 clockid_t clk_id;
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -04001514
Daniel Stoneefa504f2016-12-19 16:48:20 +00001515 weston_log("using %s\n", b->drm.filename);
Kristian Høgsbergb71302e2012-05-10 12:28:35 -04001516
Daniel Stoneefa504f2016-12-19 16:48:20 +00001517 ret = drmGetCap(b->drm.fd, DRM_CAP_TIMESTAMP_MONOTONIC, &cap);
Ander Conselvan de Oliveira95eb3a22013-05-07 14:16:59 +03001518 if (ret == 0 && cap == 1)
Pekka Paalanenb5eedad2014-09-23 22:08:45 -04001519 clk_id = CLOCK_MONOTONIC;
Ander Conselvan de Oliveira95eb3a22013-05-07 14:16:59 +03001520 else
Pekka Paalanenb5eedad2014-09-23 22:08:45 -04001521 clk_id = CLOCK_REALTIME;
1522
Giulio Camuffo954f1832014-10-11 18:27:30 +03001523 if (weston_compositor_set_presentation_clock(b->compositor, clk_id) < 0) {
Pekka Paalanenb5eedad2014-09-23 22:08:45 -04001524 weston_log("Error: failed to set presentation clock %d.\n",
1525 clk_id);
1526 return -1;
1527 }
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +02001528
Daniel Stoneefa504f2016-12-19 16:48:20 +00001529 ret = drmGetCap(b->drm.fd, DRM_CAP_CURSOR_WIDTH, &cap);
Alvaro Fernando Garcíadce7c6e2014-07-28 18:30:17 -03001530 if (ret == 0)
Giulio Camuffo954f1832014-10-11 18:27:30 +03001531 b->cursor_width = cap;
Alvaro Fernando Garcíadce7c6e2014-07-28 18:30:17 -03001532 else
Giulio Camuffo954f1832014-10-11 18:27:30 +03001533 b->cursor_width = 64;
Alvaro Fernando Garcíadce7c6e2014-07-28 18:30:17 -03001534
Daniel Stoneefa504f2016-12-19 16:48:20 +00001535 ret = drmGetCap(b->drm.fd, DRM_CAP_CURSOR_HEIGHT, &cap);
Alvaro Fernando Garcíadce7c6e2014-07-28 18:30:17 -03001536 if (ret == 0)
Giulio Camuffo954f1832014-10-11 18:27:30 +03001537 b->cursor_height = cap;
Alvaro Fernando Garcíadce7c6e2014-07-28 18:30:17 -03001538 else
Giulio Camuffo954f1832014-10-11 18:27:30 +03001539 b->cursor_height = 64;
Alvaro Fernando Garcíadce7c6e2014-07-28 18:30:17 -03001540
Ander Conselvan de Oliveira22929172013-01-25 15:13:02 +02001541 return 0;
1542}
1543
Ander Conselvan de Oliveira65796812013-11-19 15:22:04 +02001544static struct gbm_device *
1545create_gbm_device(int fd)
Ander Conselvan de Oliveira22929172013-01-25 15:13:02 +02001546{
Ander Conselvan de Oliveira65796812013-11-19 15:22:04 +02001547 struct gbm_device *gbm;
Alexandru DAMIANbe0ac5b2013-10-02 17:51:05 +01001548
Ander Conselvan de Oliveira97f29522013-10-14 15:57:11 +03001549 gl_renderer = weston_load_module("gl-renderer.so",
1550 "gl_renderer_interface");
1551 if (!gl_renderer)
Ander Conselvan de Oliveira65796812013-11-19 15:22:04 +02001552 return NULL;
Ander Conselvan de Oliveira97f29522013-10-14 15:57:11 +03001553
1554 /* GBM will load a dri driver, but even though they need symbols from
1555 * libglapi, in some version of Mesa they are not linked to it. Since
1556 * only the gl-renderer module links to it, the call above won't make
1557 * these symbols globally available, and loading the DRI driver fails.
1558 * Workaround this by dlopen()'ing libglapi with RTLD_GLOBAL. */
1559 dlopen("libglapi.so.0", RTLD_LAZY | RTLD_GLOBAL);
1560
Ander Conselvan de Oliveira65796812013-11-19 15:22:04 +02001561 gbm = gbm_create_device(fd);
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001562
Ander Conselvan de Oliveira65796812013-11-19 15:22:04 +02001563 return gbm;
1564}
1565
Bryce Harringtonc056a982015-05-19 15:25:18 -07001566/* When initializing EGL, if the preferred buffer format isn't available
Bryce Harringtonb9939982016-04-15 20:28:26 -07001567 * we may be able to substitute an ARGB format for an XRGB one.
Derek Foremanc4cfe852015-05-15 12:12:40 -05001568 *
1569 * This returns 0 if substitution isn't possible, but 0 might be a
1570 * legitimate format for other EGL platforms, so the caller is
1571 * responsible for checking for 0 before calling gl_renderer->create().
1572 *
1573 * This works around https://bugs.freedesktop.org/show_bug.cgi?id=89689
1574 * but it's entirely possible we'll see this again on other implementations.
1575 */
1576static int
1577fallback_format_for(uint32_t format)
1578{
1579 switch (format) {
1580 case GBM_FORMAT_XRGB8888:
1581 return GBM_FORMAT_ARGB8888;
1582 case GBM_FORMAT_XRGB2101010:
1583 return GBM_FORMAT_ARGB2101010;
1584 default:
1585 return 0;
1586 }
1587}
1588
Ander Conselvan de Oliveira65796812013-11-19 15:22:04 +02001589static int
Giulio Camuffo954f1832014-10-11 18:27:30 +03001590drm_backend_create_gl_renderer(struct drm_backend *b)
Ander Conselvan de Oliveira65796812013-11-19 15:22:04 +02001591{
Derek Foreman6d556372015-11-04 14:47:33 -06001592 EGLint format[3] = {
Miguel A. Vicofcf4b6c2016-03-21 17:41:03 +01001593 b->gbm_format,
1594 fallback_format_for(b->gbm_format),
Derek Foreman6d556372015-11-04 14:47:33 -06001595 0,
Derek Foremanc4cfe852015-05-15 12:12:40 -05001596 };
Derek Foreman6d556372015-11-04 14:47:33 -06001597 int n_formats = 2;
John Kåre Alsakeref591aa2013-03-02 12:27:39 +01001598
Derek Foremanc4cfe852015-05-15 12:12:40 -05001599 if (format[1])
Derek Foreman6d556372015-11-04 14:47:33 -06001600 n_formats = 3;
Miguel A. Vicodddc6702016-05-18 17:41:07 +02001601 if (gl_renderer->display_create(b->compositor,
1602 EGL_PLATFORM_GBM_KHR,
1603 (void *)b->gbm,
Miguel A. Vico41700e32016-05-18 17:47:59 +02001604 NULL,
Miguel A. Vicodddc6702016-05-18 17:41:07 +02001605 gl_renderer->opaque_attribs,
1606 format,
1607 n_formats) < 0) {
Ander Conselvan de Oliveira65796812013-11-19 15:22:04 +02001608 return -1;
1609 }
1610
1611 return 0;
1612}
1613
1614static int
Giulio Camuffo954f1832014-10-11 18:27:30 +03001615init_egl(struct drm_backend *b)
Ander Conselvan de Oliveira65796812013-11-19 15:22:04 +02001616{
Giulio Camuffo954f1832014-10-11 18:27:30 +03001617 b->gbm = create_gbm_device(b->drm.fd);
Ander Conselvan de Oliveira65796812013-11-19 15:22:04 +02001618
Giulio Camuffo954f1832014-10-11 18:27:30 +03001619 if (!b->gbm)
Ander Conselvan de Oliveira65796812013-11-19 15:22:04 +02001620 return -1;
1621
Giulio Camuffo954f1832014-10-11 18:27:30 +03001622 if (drm_backend_create_gl_renderer(b) < 0) {
1623 gbm_device_destroy(b->gbm);
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -04001624 return -1;
1625 }
1626
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001627 return 0;
1628}
1629
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02001630static int
Giulio Camuffo954f1832014-10-11 18:27:30 +03001631init_pixman(struct drm_backend *b)
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02001632{
Giulio Camuffo954f1832014-10-11 18:27:30 +03001633 return pixman_renderer_init(b->compositor);
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02001634}
1635
Pekka Paalanen7b36b422014-06-04 14:00:53 +03001636/**
1637 * Add a mode to output's mode list
1638 *
1639 * Copy the supplied DRM mode into a Weston mode structure, and add it to the
1640 * output's mode list.
1641 *
1642 * @param output DRM output to add mode to
1643 * @param info DRM mode structure to add
1644 * @returns Newly-allocated Weston/DRM mode structure
1645 */
Ander Conselvan de Oliveira42c46462012-08-09 16:45:00 +03001646static struct drm_mode *
Pekka Paalanen7b36b422014-06-04 14:00:53 +03001647drm_output_add_mode(struct drm_output *output, const drmModeModeInfo *info)
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001648{
1649 struct drm_mode *mode;
Kristian Høgsbergc4621b02012-05-10 12:23:53 -04001650 uint64_t refresh;
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001651
1652 mode = malloc(sizeof *mode);
1653 if (mode == NULL)
Ander Conselvan de Oliveira42c46462012-08-09 16:45:00 +03001654 return NULL;
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001655
1656 mode->base.flags = 0;
Alexander Larsson0b135062013-05-28 16:23:36 +02001657 mode->base.width = info->hdisplay;
1658 mode->base.height = info->vdisplay;
Kristian Høgsbergc4621b02012-05-10 12:23:53 -04001659
1660 /* Calculate higher precision (mHz) refresh rate */
1661 refresh = (info->clock * 1000000LL / info->htotal +
1662 info->vtotal / 2) / info->vtotal;
1663
1664 if (info->flags & DRM_MODE_FLAG_INTERLACE)
1665 refresh *= 2;
1666 if (info->flags & DRM_MODE_FLAG_DBLSCAN)
1667 refresh /= 2;
1668 if (info->vscan > 1)
1669 refresh /= info->vscan;
1670
1671 mode->base.refresh = refresh;
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001672 mode->mode_info = *info;
Kristian Høgsberg061c4252012-06-28 11:28:15 -04001673
1674 if (info->type & DRM_MODE_TYPE_PREFERRED)
1675 mode->base.flags |= WL_OUTPUT_MODE_PREFERRED;
1676
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001677 wl_list_insert(output->base.mode_list.prev, &mode->base.link);
1678
Ander Conselvan de Oliveira42c46462012-08-09 16:45:00 +03001679 return mode;
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001680}
1681
1682static int
1683drm_subpixel_to_wayland(int drm_value)
1684{
1685 switch (drm_value) {
1686 default:
1687 case DRM_MODE_SUBPIXEL_UNKNOWN:
1688 return WL_OUTPUT_SUBPIXEL_UNKNOWN;
1689 case DRM_MODE_SUBPIXEL_NONE:
1690 return WL_OUTPUT_SUBPIXEL_NONE;
1691 case DRM_MODE_SUBPIXEL_HORIZONTAL_RGB:
1692 return WL_OUTPUT_SUBPIXEL_HORIZONTAL_RGB;
1693 case DRM_MODE_SUBPIXEL_HORIZONTAL_BGR:
1694 return WL_OUTPUT_SUBPIXEL_HORIZONTAL_BGR;
1695 case DRM_MODE_SUBPIXEL_VERTICAL_RGB:
1696 return WL_OUTPUT_SUBPIXEL_VERTICAL_RGB;
1697 case DRM_MODE_SUBPIXEL_VERTICAL_BGR:
1698 return WL_OUTPUT_SUBPIXEL_VERTICAL_BGR;
1699 }
1700}
1701
Tiago Vignatti5ab91ad2012-03-12 19:40:09 -03001702/* returns a value between 0-255 range, where higher is brighter */
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02001703static uint32_t
1704drm_get_backlight(struct drm_output *output)
1705{
1706 long brightness, max_brightness, norm;
1707
1708 brightness = backlight_get_brightness(output->backlight);
1709 max_brightness = backlight_get_max_brightness(output->backlight);
1710
Tiago Vignatti5ab91ad2012-03-12 19:40:09 -03001711 /* convert it on a scale of 0 to 255 */
1712 norm = (brightness * 255)/(max_brightness);
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02001713
1714 return (uint32_t) norm;
1715}
1716
Tiago Vignatti5ab91ad2012-03-12 19:40:09 -03001717/* values accepted are between 0-255 range */
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02001718static void
1719drm_set_backlight(struct weston_output *output_base, uint32_t value)
1720{
Armin Krezović545dba62016-08-05 15:54:18 +02001721 struct drm_output *output = to_drm_output(output_base);
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02001722 long max_brightness, new_brightness;
1723
1724 if (!output->backlight)
1725 return;
1726
Kristian Høgsberg875ab9e2012-03-30 11:52:39 -04001727 if (value > 255)
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02001728 return;
1729
1730 max_brightness = backlight_get_max_brightness(output->backlight);
1731
1732 /* get denormalized value */
Tiago Vignatti5ab91ad2012-03-12 19:40:09 -03001733 new_brightness = (value * max_brightness) / 255;
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02001734
1735 backlight_set_brightness(output->backlight, new_brightness);
1736}
1737
1738static drmModePropertyPtr
1739drm_get_prop(int fd, drmModeConnectorPtr connector, const char *name)
1740{
1741 drmModePropertyPtr props;
1742 int i;
1743
1744 for (i = 0; i < connector->count_props; i++) {
1745 props = drmModeGetProperty(fd, connector->props[i]);
1746 if (!props)
1747 continue;
1748
1749 if (!strcmp(props->name, name))
1750 return props;
1751
1752 drmModeFreeProperty(props);
1753 }
1754
1755 return NULL;
1756}
1757
1758static void
1759drm_set_dpms(struct weston_output *output_base, enum dpms_enum level)
1760{
Armin Krezović545dba62016-08-05 15:54:18 +02001761 struct drm_output *output = to_drm_output(output_base);
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02001762 struct weston_compositor *ec = output_base->compositor;
Armin Krezović545dba62016-08-05 15:54:18 +02001763 struct drm_backend *b = to_drm_backend(ec);
Daniel Stone36609c72015-06-18 07:49:02 +01001764 int ret;
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02001765
Ander Conselvan de Oliveiraa0a433a2013-06-04 16:24:04 +03001766 if (!output->dpms_prop)
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02001767 return;
1768
Daniel Stone36609c72015-06-18 07:49:02 +01001769 ret = drmModeConnectorSetProperty(b->drm.fd, output->connector_id,
1770 output->dpms_prop->prop_id, level);
1771 if (ret) {
1772 weston_log("DRM: DPMS: failed property set for %s\n",
1773 output->base.name);
1774 return;
1775 }
1776
1777 output->dpms = level;
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02001778}
1779
Pekka Paalanen3ce63622014-06-04 16:29:49 +03001780static const char * const connector_type_names[] = {
Pekka Paalanen89c49b32015-08-19 15:25:57 +03001781 [DRM_MODE_CONNECTOR_Unknown] = "Unknown",
1782 [DRM_MODE_CONNECTOR_VGA] = "VGA",
1783 [DRM_MODE_CONNECTOR_DVII] = "DVI-I",
1784 [DRM_MODE_CONNECTOR_DVID] = "DVI-D",
1785 [DRM_MODE_CONNECTOR_DVIA] = "DVI-A",
1786 [DRM_MODE_CONNECTOR_Composite] = "Composite",
1787 [DRM_MODE_CONNECTOR_SVIDEO] = "SVIDEO",
1788 [DRM_MODE_CONNECTOR_LVDS] = "LVDS",
1789 [DRM_MODE_CONNECTOR_Component] = "Component",
1790 [DRM_MODE_CONNECTOR_9PinDIN] = "DIN",
1791 [DRM_MODE_CONNECTOR_DisplayPort] = "DP",
1792 [DRM_MODE_CONNECTOR_HDMIA] = "HDMI-A",
1793 [DRM_MODE_CONNECTOR_HDMIB] = "HDMI-B",
1794 [DRM_MODE_CONNECTOR_TV] = "TV",
1795 [DRM_MODE_CONNECTOR_eDP] = "eDP",
Pekka Paalanenab81f152015-08-24 14:27:07 +03001796#ifdef DRM_MODE_CONNECTOR_DSI
Pekka Paalanen89c49b32015-08-19 15:25:57 +03001797 [DRM_MODE_CONNECTOR_VIRTUAL] = "Virtual",
1798 [DRM_MODE_CONNECTOR_DSI] = "DSI",
Pekka Paalanenab81f152015-08-24 14:27:07 +03001799#endif
Kristian Høgsberg2f9ed712012-07-26 17:57:15 -04001800};
1801
Pekka Paalanen3ce63622014-06-04 16:29:49 +03001802static char *
1803make_connector_name(const drmModeConnector *con)
1804{
1805 char name[32];
Pekka Paalanen89c49b32015-08-19 15:25:57 +03001806 const char *type_name = NULL;
Pekka Paalanen3ce63622014-06-04 16:29:49 +03001807
1808 if (con->connector_type < ARRAY_LENGTH(connector_type_names))
1809 type_name = connector_type_names[con->connector_type];
Pekka Paalanen89c49b32015-08-19 15:25:57 +03001810
1811 if (!type_name)
1812 type_name = "UNNAMED";
1813
1814 snprintf(name, sizeof name, "%s-%d", type_name, con->connector_type_id);
Pekka Paalanen3ce63622014-06-04 16:29:49 +03001815
1816 return strdup(name);
1817}
1818
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001819static int
Giulio Camuffo954f1832014-10-11 18:27:30 +03001820find_crtc_for_connector(struct drm_backend *b,
Kristian Høgsberg9ca38462012-07-26 22:44:55 -04001821 drmModeRes *resources, drmModeConnector *connector)
1822{
1823 drmModeEncoder *encoder;
Kristian Høgsberg9ca38462012-07-26 22:44:55 -04001824 int i, j;
Daniel Stone75487c22017-01-16 14:33:38 +00001825 int ret = -1;
Kristian Høgsberg9ca38462012-07-26 22:44:55 -04001826
1827 for (j = 0; j < connector->count_encoders; j++) {
Daniel Stone75487c22017-01-16 14:33:38 +00001828 uint32_t possible_crtcs, encoder_id, crtc_id;
1829
Giulio Camuffo954f1832014-10-11 18:27:30 +03001830 encoder = drmModeGetEncoder(b->drm.fd, connector->encoders[j]);
Kristian Høgsberg9ca38462012-07-26 22:44:55 -04001831 if (encoder == NULL) {
1832 weston_log("Failed to get encoder.\n");
Daniel Stone75487c22017-01-16 14:33:38 +00001833 continue;
Kristian Høgsberg9ca38462012-07-26 22:44:55 -04001834 }
Daniel Stone75487c22017-01-16 14:33:38 +00001835 encoder_id = encoder->encoder_id;
Kristian Høgsberg9ca38462012-07-26 22:44:55 -04001836 possible_crtcs = encoder->possible_crtcs;
Daniel Stone75487c22017-01-16 14:33:38 +00001837 crtc_id = encoder->crtc_id;
Kristian Høgsberg9ca38462012-07-26 22:44:55 -04001838 drmModeFreeEncoder(encoder);
1839
1840 for (i = 0; i < resources->count_crtcs; i++) {
Daniel Stone72c0e1b2017-02-09 13:49:15 +00001841 if (!(possible_crtcs & (1 << i)))
1842 continue;
1843
1844 if (drm_output_find_by_crtc(b, resources->crtcs[i]))
1845 continue;
1846
Daniel Stone75487c22017-01-16 14:33:38 +00001847 /* Try to preserve the existing
1848 * CRTC -> encoder -> connector routing; it makes
1849 * initialisation faster, and also since we have a
1850 * very dumb picking algorithm, may preserve a better
1851 * choice. */
1852 if (!connector->encoder_id ||
1853 (encoder_id == connector->encoder_id &&
1854 crtc_id == resources->crtcs[i]))
1855 return i;
1856
1857 ret = i;
Kristian Høgsberg9ca38462012-07-26 22:44:55 -04001858 }
1859 }
1860
Daniel Stone75487c22017-01-16 14:33:38 +00001861 return ret;
Kristian Høgsberg9ca38462012-07-26 22:44:55 -04001862}
1863
Ander Conselvan de Oliveira475cf152012-12-14 13:37:29 -02001864/* Init output state that depends on gl or gbm */
1865static int
Giulio Camuffo954f1832014-10-11 18:27:30 +03001866drm_output_init_egl(struct drm_output *output, struct drm_backend *b)
Ander Conselvan de Oliveira475cf152012-12-14 13:37:29 -02001867{
Derek Foremanc4cfe852015-05-15 12:12:40 -05001868 EGLint format[2] = {
Miguel A. Vicofcf4b6c2016-03-21 17:41:03 +01001869 output->gbm_format,
1870 fallback_format_for(output->gbm_format),
Derek Foremanc4cfe852015-05-15 12:12:40 -05001871 };
1872 int i, flags, n_formats = 1;
Ander Conselvan de Oliveira6c01c9c2012-12-14 13:37:30 -02001873
Miguel A. Vicofcf4b6c2016-03-21 17:41:03 +01001874 output->gbm_surface = gbm_surface_create(b->gbm,
Hardeningff39efa2013-09-18 23:56:35 +02001875 output->base.current_mode->width,
1876 output->base.current_mode->height,
Derek Foremanc4cfe852015-05-15 12:12:40 -05001877 format[0],
Ander Conselvan de Oliveira475cf152012-12-14 13:37:29 -02001878 GBM_BO_USE_SCANOUT |
1879 GBM_BO_USE_RENDERING);
Miguel A. Vicofcf4b6c2016-03-21 17:41:03 +01001880 if (!output->gbm_surface) {
Ander Conselvan de Oliveira475cf152012-12-14 13:37:29 -02001881 weston_log("failed to create gbm surface\n");
1882 return -1;
1883 }
1884
Derek Foremanc4cfe852015-05-15 12:12:40 -05001885 if (format[1])
1886 n_formats = 2;
Miguel A. Vicoc095cde2016-05-18 17:43:00 +02001887 if (gl_renderer->output_window_create(&output->base,
1888 (EGLNativeWindowType)output->gbm_surface,
1889 output->gbm_surface,
1890 gl_renderer->opaque_attribs,
1891 format,
1892 n_formats) < 0) {
Ander Conselvan de Oliveira6c01c9c2012-12-14 13:37:30 -02001893 weston_log("failed to create gl renderer output state\n");
Miguel A. Vicofcf4b6c2016-03-21 17:41:03 +01001894 gbm_surface_destroy(output->gbm_surface);
Ander Conselvan de Oliveira475cf152012-12-14 13:37:29 -02001895 return -1;
1896 }
1897
Alvaro Fernando Garcíadce7c6e2014-07-28 18:30:17 -03001898 flags = GBM_BO_USE_CURSOR | GBM_BO_USE_WRITE;
Ander Conselvan de Oliveira6c01c9c2012-12-14 13:37:30 -02001899
1900 for (i = 0; i < 2; i++) {
Miguel A. Vicofcf4b6c2016-03-21 17:41:03 +01001901 if (output->gbm_cursor_bo[i])
Ander Conselvan de Oliveira6c01c9c2012-12-14 13:37:30 -02001902 continue;
1903
Miguel A. Vicofcf4b6c2016-03-21 17:41:03 +01001904 output->gbm_cursor_bo[i] =
Giulio Camuffo954f1832014-10-11 18:27:30 +03001905 gbm_bo_create(b->gbm, b->cursor_width, b->cursor_height,
Alvaro Fernando Garcíadce7c6e2014-07-28 18:30:17 -03001906 GBM_FORMAT_ARGB8888, flags);
Ander Conselvan de Oliveira6c01c9c2012-12-14 13:37:30 -02001907 }
1908
Miguel A. Vicofcf4b6c2016-03-21 17:41:03 +01001909 if (output->gbm_cursor_bo[0] == NULL || output->gbm_cursor_bo[1] == NULL) {
Ander Conselvan de Oliveira475cf152012-12-14 13:37:29 -02001910 weston_log("cursor buffers unavailable, using gl cursors\n");
Giulio Camuffo954f1832014-10-11 18:27:30 +03001911 b->cursors_are_broken = 1;
Ander Conselvan de Oliveira475cf152012-12-14 13:37:29 -02001912 }
1913
1914 return 0;
1915}
1916
Daniel Stone3e661f72016-11-04 17:24:06 +00001917static void
1918drm_output_fini_egl(struct drm_output *output)
1919{
1920 gl_renderer->output_destroy(&output->base);
1921 gbm_surface_destroy(output->gbm_surface);
1922}
1923
Kristian Høgsberg9ca38462012-07-26 22:44:55 -04001924static int
Giulio Camuffo954f1832014-10-11 18:27:30 +03001925drm_output_init_pixman(struct drm_output *output, struct drm_backend *b)
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02001926{
Hardeningff39efa2013-09-18 23:56:35 +02001927 int w = output->base.current_mode->width;
1928 int h = output->base.current_mode->height;
Tomi Valkeinenf8da0c22016-06-20 14:18:45 +03001929 uint32_t format = output->gbm_format;
1930 uint32_t pixman_format;
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02001931 unsigned int i;
1932
Tomi Valkeinenf8da0c22016-06-20 14:18:45 +03001933 switch (format) {
1934 case GBM_FORMAT_XRGB8888:
1935 pixman_format = PIXMAN_x8r8g8b8;
1936 break;
1937 case GBM_FORMAT_RGB565:
1938 pixman_format = PIXMAN_r5g6b5;
1939 break;
1940 default:
1941 weston_log("Unsupported pixman format 0x%x\n", format);
1942 return -1;
1943 }
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02001944
Tomi Valkeinenf8da0c22016-06-20 14:18:45 +03001945 /* FIXME error checking */
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02001946 for (i = 0; i < ARRAY_LENGTH(output->dumb); i++) {
Tomi Valkeinenf8da0c22016-06-20 14:18:45 +03001947 output->dumb[i] = drm_fb_create_dumb(b, w, h, format);
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02001948 if (!output->dumb[i])
1949 goto err;
1950
1951 output->image[i] =
Tomi Valkeinenf8da0c22016-06-20 14:18:45 +03001952 pixman_image_create_bits(pixman_format, w, h,
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02001953 output->dumb[i]->map,
1954 output->dumb[i]->stride);
1955 if (!output->image[i])
1956 goto err;
1957 }
1958
1959 if (pixman_renderer_output_create(&output->base) < 0)
1960 goto err;
1961
1962 pixman_region32_init_rect(&output->previous_damage,
Alexander Larsson0b135062013-05-28 16:23:36 +02001963 output->base.x, output->base.y, output->base.width, output->base.height);
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02001964
1965 return 0;
1966
1967err:
1968 for (i = 0; i < ARRAY_LENGTH(output->dumb); i++) {
1969 if (output->dumb[i])
1970 drm_fb_destroy_dumb(output->dumb[i]);
1971 if (output->image[i])
1972 pixman_image_unref(output->image[i]);
1973
1974 output->dumb[i] = NULL;
1975 output->image[i] = NULL;
1976 }
1977
1978 return -1;
1979}
1980
1981static void
1982drm_output_fini_pixman(struct drm_output *output)
1983{
1984 unsigned int i;
1985
1986 pixman_renderer_output_destroy(&output->base);
1987 pixman_region32_fini(&output->previous_damage);
1988
1989 for (i = 0; i < ARRAY_LENGTH(output->dumb); i++) {
1990 drm_fb_destroy_dumb(output->dumb[i]);
1991 pixman_image_unref(output->image[i]);
1992 output->dumb[i] = NULL;
1993 output->image[i] = NULL;
1994 }
1995}
1996
Richard Hughes2b2092a2013-04-24 14:58:02 +01001997static void
1998edid_parse_string(const uint8_t *data, char text[])
1999{
2000 int i;
2001 int replaced = 0;
2002
2003 /* this is always 12 bytes, but we can't guarantee it's null
2004 * terminated or not junk. */
2005 strncpy(text, (const char *) data, 12);
2006
Bryce Harrington9c7de162015-08-28 13:04:26 -07002007 /* guarantee our new string is null-terminated */
2008 text[12] = '\0';
2009
Richard Hughes2b2092a2013-04-24 14:58:02 +01002010 /* remove insane chars */
2011 for (i = 0; text[i] != '\0'; i++) {
2012 if (text[i] == '\n' ||
2013 text[i] == '\r') {
2014 text[i] = '\0';
2015 break;
2016 }
2017 }
2018
2019 /* ensure string is printable */
2020 for (i = 0; text[i] != '\0'; i++) {
2021 if (!isprint(text[i])) {
2022 text[i] = '-';
2023 replaced++;
2024 }
2025 }
2026
2027 /* if the string is random junk, ignore the string */
2028 if (replaced > 4)
2029 text[0] = '\0';
2030}
2031
2032#define EDID_DESCRIPTOR_ALPHANUMERIC_DATA_STRING 0xfe
2033#define EDID_DESCRIPTOR_DISPLAY_PRODUCT_NAME 0xfc
2034#define EDID_DESCRIPTOR_DISPLAY_PRODUCT_SERIAL_NUMBER 0xff
2035#define EDID_OFFSET_DATA_BLOCKS 0x36
2036#define EDID_OFFSET_LAST_BLOCK 0x6c
2037#define EDID_OFFSET_PNPID 0x08
2038#define EDID_OFFSET_SERIAL 0x0c
2039
2040static int
2041edid_parse(struct drm_edid *edid, const uint8_t *data, size_t length)
2042{
2043 int i;
2044 uint32_t serial_number;
2045
2046 /* check header */
2047 if (length < 128)
2048 return -1;
2049 if (data[0] != 0x00 || data[1] != 0xff)
2050 return -1;
2051
2052 /* decode the PNP ID from three 5 bit words packed into 2 bytes
2053 * /--08--\/--09--\
2054 * 7654321076543210
2055 * |\---/\---/\---/
2056 * R C1 C2 C3 */
2057 edid->pnp_id[0] = 'A' + ((data[EDID_OFFSET_PNPID + 0] & 0x7c) / 4) - 1;
2058 edid->pnp_id[1] = 'A' + ((data[EDID_OFFSET_PNPID + 0] & 0x3) * 8) + ((data[EDID_OFFSET_PNPID + 1] & 0xe0) / 32) - 1;
2059 edid->pnp_id[2] = 'A' + (data[EDID_OFFSET_PNPID + 1] & 0x1f) - 1;
2060 edid->pnp_id[3] = '\0';
2061
2062 /* maybe there isn't a ASCII serial number descriptor, so use this instead */
2063 serial_number = (uint32_t) data[EDID_OFFSET_SERIAL + 0];
2064 serial_number += (uint32_t) data[EDID_OFFSET_SERIAL + 1] * 0x100;
2065 serial_number += (uint32_t) data[EDID_OFFSET_SERIAL + 2] * 0x10000;
2066 serial_number += (uint32_t) data[EDID_OFFSET_SERIAL + 3] * 0x1000000;
2067 if (serial_number > 0)
2068 sprintf(edid->serial_number, "%lu", (unsigned long) serial_number);
2069
2070 /* parse EDID data */
2071 for (i = EDID_OFFSET_DATA_BLOCKS;
2072 i <= EDID_OFFSET_LAST_BLOCK;
2073 i += 18) {
2074 /* ignore pixel clock data */
2075 if (data[i] != 0)
2076 continue;
2077 if (data[i+2] != 0)
2078 continue;
2079
2080 /* any useful blocks? */
2081 if (data[i+3] == EDID_DESCRIPTOR_DISPLAY_PRODUCT_NAME) {
2082 edid_parse_string(&data[i+5],
2083 edid->monitor_name);
2084 } else if (data[i+3] == EDID_DESCRIPTOR_DISPLAY_PRODUCT_SERIAL_NUMBER) {
2085 edid_parse_string(&data[i+5],
2086 edid->serial_number);
2087 } else if (data[i+3] == EDID_DESCRIPTOR_ALPHANUMERIC_DATA_STRING) {
2088 edid_parse_string(&data[i+5],
2089 edid->eisa_id);
2090 }
2091 }
2092 return 0;
2093}
2094
2095static void
Giulio Camuffo954f1832014-10-11 18:27:30 +03002096find_and_parse_output_edid(struct drm_backend *b,
Richard Hughes2b2092a2013-04-24 14:58:02 +01002097 struct drm_output *output,
2098 drmModeConnector *connector)
2099{
2100 drmModePropertyBlobPtr edid_blob = NULL;
2101 drmModePropertyPtr property;
2102 int i;
2103 int rc;
2104
2105 for (i = 0; i < connector->count_props && !edid_blob; i++) {
Giulio Camuffo954f1832014-10-11 18:27:30 +03002106 property = drmModeGetProperty(b->drm.fd, connector->props[i]);
Richard Hughes2b2092a2013-04-24 14:58:02 +01002107 if (!property)
2108 continue;
2109 if ((property->flags & DRM_MODE_PROP_BLOB) &&
2110 !strcmp(property->name, "EDID")) {
Giulio Camuffo954f1832014-10-11 18:27:30 +03002111 edid_blob = drmModeGetPropertyBlob(b->drm.fd,
Richard Hughes2b2092a2013-04-24 14:58:02 +01002112 connector->prop_values[i]);
2113 }
2114 drmModeFreeProperty(property);
2115 }
2116 if (!edid_blob)
2117 return;
2118
2119 rc = edid_parse(&output->edid,
2120 edid_blob->data,
2121 edid_blob->length);
2122 if (!rc) {
2123 weston_log("EDID data '%s', '%s', '%s'\n",
2124 output->edid.pnp_id,
2125 output->edid.monitor_name,
2126 output->edid.serial_number);
2127 if (output->edid.pnp_id[0] != '\0')
2128 output->base.make = output->edid.pnp_id;
2129 if (output->edid.monitor_name[0] != '\0')
2130 output->base.model = output->edid.monitor_name;
2131 if (output->edid.serial_number[0] != '\0')
2132 output->base.serial_number = output->edid.serial_number;
2133 }
2134 drmModeFreePropertyBlob(edid_blob);
2135}
2136
Kristian Høgsberga30989a2013-05-23 17:23:15 -04002137
2138
2139static int
2140parse_modeline(const char *s, drmModeModeInfo *mode)
2141{
2142 char hsync[16];
2143 char vsync[16];
2144 float fclock;
2145
2146 mode->type = DRM_MODE_TYPE_USERDEF;
2147 mode->hskew = 0;
2148 mode->vscan = 0;
2149 mode->vrefresh = 0;
2150 mode->flags = 0;
2151
Rob Bradford307e09e2013-07-26 16:29:40 +01002152 if (sscanf(s, "%f %hd %hd %hd %hd %hd %hd %hd %hd %15s %15s",
Kristian Høgsberga30989a2013-05-23 17:23:15 -04002153 &fclock,
2154 &mode->hdisplay,
2155 &mode->hsync_start,
2156 &mode->hsync_end,
2157 &mode->htotal,
2158 &mode->vdisplay,
2159 &mode->vsync_start,
2160 &mode->vsync_end,
2161 &mode->vtotal, hsync, vsync) != 11)
2162 return -1;
2163
2164 mode->clock = fclock * 1000;
2165 if (strcmp(hsync, "+hsync") == 0)
2166 mode->flags |= DRM_MODE_FLAG_PHSYNC;
2167 else if (strcmp(hsync, "-hsync") == 0)
2168 mode->flags |= DRM_MODE_FLAG_NHSYNC;
2169 else
2170 return -1;
2171
2172 if (strcmp(vsync, "+vsync") == 0)
2173 mode->flags |= DRM_MODE_FLAG_PVSYNC;
2174 else if (strcmp(vsync, "-vsync") == 0)
2175 mode->flags |= DRM_MODE_FLAG_NVSYNC;
2176 else
2177 return -1;
2178
Emmanuel Gil Peyrota62138b2016-05-02 22:40:11 +01002179 snprintf(mode->name, sizeof mode->name, "%dx%d@%.3f",
2180 mode->hdisplay, mode->vdisplay, fclock);
2181
Kristian Høgsberga30989a2013-05-23 17:23:15 -04002182 return 0;
2183}
2184
Rob Bradford66bd9f52013-06-25 18:56:42 +01002185static void
Giulio Camuffo954f1832014-10-11 18:27:30 +03002186setup_output_seat_constraint(struct drm_backend *b,
Rob Bradford66bd9f52013-06-25 18:56:42 +01002187 struct weston_output *output,
2188 const char *s)
2189{
2190 if (strcmp(s, "") != 0) {
Derek Foreman1281a362015-07-31 16:55:32 -05002191 struct weston_pointer *pointer;
Rob Bradford66bd9f52013-06-25 18:56:42 +01002192 struct udev_seat *seat;
2193
Giulio Camuffo954f1832014-10-11 18:27:30 +03002194 seat = udev_seat_get_named(&b->input, s);
Derek Foreman0720ea32015-07-15 13:00:35 -05002195 if (!seat)
2196 return;
Rob Bradford66bd9f52013-06-25 18:56:42 +01002197
Derek Foreman0720ea32015-07-15 13:00:35 -05002198 seat->base.output = output;
2199
Derek Foreman1281a362015-07-31 16:55:32 -05002200 pointer = weston_seat_get_pointer(&seat->base);
2201 if (pointer)
2202 weston_pointer_clamp(pointer,
2203 &pointer->x,
2204 &pointer->y);
Rob Bradford66bd9f52013-06-25 18:56:42 +01002205 }
2206}
2207
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02002208static int
Giulio Camuffo1c0e40d2016-04-29 15:40:34 -07002209parse_gbm_format(const char *s, uint32_t default_value, uint32_t *gbm_format)
Neil Roberts77c1a5b2014-03-07 18:05:50 +00002210{
Neil Roberts77c1a5b2014-03-07 18:05:50 +00002211 int ret = 0;
2212
Neil Roberts77c1a5b2014-03-07 18:05:50 +00002213 if (s == NULL)
Giulio Camuffo1c0e40d2016-04-29 15:40:34 -07002214 *gbm_format = default_value;
Neil Roberts77c1a5b2014-03-07 18:05:50 +00002215 else if (strcmp(s, "xrgb8888") == 0)
Giulio Camuffo1c0e40d2016-04-29 15:40:34 -07002216 *gbm_format = GBM_FORMAT_XRGB8888;
Neil Roberts77c1a5b2014-03-07 18:05:50 +00002217 else if (strcmp(s, "rgb565") == 0)
Giulio Camuffo1c0e40d2016-04-29 15:40:34 -07002218 *gbm_format = GBM_FORMAT_RGB565;
Neil Roberts77c1a5b2014-03-07 18:05:50 +00002219 else if (strcmp(s, "xrgb2101010") == 0)
Giulio Camuffo1c0e40d2016-04-29 15:40:34 -07002220 *gbm_format = GBM_FORMAT_XRGB2101010;
Neil Roberts77c1a5b2014-03-07 18:05:50 +00002221 else {
2222 weston_log("fatal: unrecognized pixel format: %s\n", s);
2223 ret = -1;
2224 }
2225
Neil Roberts77c1a5b2014-03-07 18:05:50 +00002226 return ret;
2227}
2228
Pekka Paalanen7b36b422014-06-04 14:00:53 +03002229/**
2230 * Choose suitable mode for an output
2231 *
2232 * Find the most suitable mode to use for initial setup (or reconfiguration on
2233 * hotplug etc) for a DRM output.
2234 *
2235 * @param output DRM output to choose mode for
2236 * @param kind Strategy and preference to use when choosing mode
2237 * @param width Desired width for this output
2238 * @param height Desired height for this output
2239 * @param current_mode Mode currently being displayed on this output
2240 * @param modeline Manually-entered mode (may be NULL)
2241 * @returns A mode from the output's mode list, or NULL if none available
2242 */
2243static struct drm_mode *
Giulio Camuffo1c0e40d2016-04-29 15:40:34 -07002244drm_output_choose_initial_mode(struct drm_backend *backend,
2245 struct drm_output *output,
2246 enum weston_drm_backend_output_mode mode,
Armin Krezović08368132016-09-30 14:11:05 +02002247 const char *modeline,
Giulio Camuffo1c0e40d2016-04-29 15:40:34 -07002248 const drmModeModeInfo *current_mode)
Pekka Paalanen7b36b422014-06-04 14:00:53 +03002249{
2250 struct drm_mode *preferred = NULL;
2251 struct drm_mode *current = NULL;
2252 struct drm_mode *configured = NULL;
2253 struct drm_mode *best = NULL;
2254 struct drm_mode *drm_mode;
Armin Krezović08368132016-09-30 14:11:05 +02002255 drmModeModeInfo drm_modeline;
Giulio Camuffo1c0e40d2016-04-29 15:40:34 -07002256 int32_t width = 0;
2257 int32_t height = 0;
Fabien Dessenne2d66a7d2017-01-17 17:17:21 +01002258 uint32_t refresh = 0;
2259 int n;
Giulio Camuffo1c0e40d2016-04-29 15:40:34 -07002260
Armin Krezović08368132016-09-30 14:11:05 +02002261 if (mode == WESTON_DRM_BACKEND_OUTPUT_PREFERRED && modeline) {
Fabien Dessenne2d66a7d2017-01-17 17:17:21 +01002262 n = sscanf(modeline, "%dx%d@%d", &width, &height, &refresh);
2263 if (n != 2 && n != 3) {
Giulio Camuffo1c0e40d2016-04-29 15:40:34 -07002264 width = -1;
2265
Armin Krezović08368132016-09-30 14:11:05 +02002266 if (parse_modeline(modeline, &drm_modeline) == 0) {
2267 configured = drm_output_add_mode(output, &drm_modeline);
Giulio Camuffo1c0e40d2016-04-29 15:40:34 -07002268 if (!configured)
2269 return NULL;
2270 } else {
2271 weston_log("Invalid modeline \"%s\" for output %s\n",
Armin Krezović08368132016-09-30 14:11:05 +02002272 modeline, output->base.name);
Giulio Camuffo1c0e40d2016-04-29 15:40:34 -07002273 }
2274 }
2275 }
Pekka Paalanen7b36b422014-06-04 14:00:53 +03002276
2277 wl_list_for_each_reverse(drm_mode, &output->base.mode_list, base.link) {
Giulio Camuffo1c0e40d2016-04-29 15:40:34 -07002278 if (width == drm_mode->base.width &&
Fabien Dessenne2d66a7d2017-01-17 17:17:21 +01002279 height == drm_mode->base.height &&
2280 (refresh == 0 || refresh == drm_mode->mode_info.vrefresh))
Pekka Paalanen7b36b422014-06-04 14:00:53 +03002281 configured = drm_mode;
2282
comic fans7a5c5622016-03-17 14:29:27 +02002283 if (memcmp(current_mode, &drm_mode->mode_info,
Pekka Paalanen7b36b422014-06-04 14:00:53 +03002284 sizeof *current_mode) == 0)
2285 current = drm_mode;
2286
2287 if (drm_mode->base.flags & WL_OUTPUT_MODE_PREFERRED)
2288 preferred = drm_mode;
2289
2290 best = drm_mode;
2291 }
2292
Pekka Paalanen7b36b422014-06-04 14:00:53 +03002293 if (current == NULL && current_mode->clock != 0) {
2294 current = drm_output_add_mode(output, current_mode);
2295 if (!current)
2296 return NULL;
2297 }
2298
Giulio Camuffo1c0e40d2016-04-29 15:40:34 -07002299 if (mode == WESTON_DRM_BACKEND_OUTPUT_CURRENT)
Pekka Paalanen7b36b422014-06-04 14:00:53 +03002300 configured = current;
2301
Pekka Paalanen7b36b422014-06-04 14:00:53 +03002302 if (configured)
2303 return configured;
2304
2305 if (preferred)
2306 return preferred;
2307
2308 if (current)
2309 return current;
2310
2311 if (best)
2312 return best;
2313
2314 weston_log("no available modes for %s\n", output->base.name);
2315 return NULL;
2316}
2317
Pekka Paalaneneee580b2014-06-04 16:43:06 +03002318static int
2319connector_get_current_mode(drmModeConnector *connector, int drm_fd,
2320 drmModeModeInfo *mode)
2321{
2322 drmModeEncoder *encoder;
2323 drmModeCrtc *crtc;
2324
2325 /* Get the current mode on the crtc that's currently driving
2326 * this connector. */
2327 encoder = drmModeGetEncoder(drm_fd, connector->encoder_id);
2328 memset(mode, 0, sizeof *mode);
2329 if (encoder != NULL) {
2330 crtc = drmModeGetCrtc(drm_fd, encoder->crtc_id);
2331 drmModeFreeEncoder(encoder);
2332 if (crtc == NULL)
2333 return -1;
2334 if (crtc->mode_valid)
2335 *mode = crtc->mode;
2336 drmModeFreeCrtc(crtc);
2337 }
2338
2339 return 0;
2340}
2341
Neil Roberts77c1a5b2014-03-07 18:05:50 +00002342static int
Armin Krezović08368132016-09-30 14:11:05 +02002343drm_output_set_mode(struct weston_output *base,
2344 enum weston_drm_backend_output_mode mode,
2345 const char *modeline)
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002346{
Armin Krezović08368132016-09-30 14:11:05 +02002347 struct drm_output *output = to_drm_output(base);
2348 struct drm_backend *b = to_drm_backend(base->compositor);
Giulio Camuffo1c0e40d2016-04-29 15:40:34 -07002349
Armin Krezović445b41b2016-10-09 23:48:16 +02002350 struct drm_mode *current;
Giulio Camuffo1c0e40d2016-04-29 15:40:34 -07002351 drmModeModeInfo crtc_mode;
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002352
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04002353 output->base.make = "unknown";
2354 output->base.model = "unknown";
Richard Hughes2b2092a2013-04-24 14:58:02 +01002355 output->base.serial_number = "unknown";
Matt Roper361d2ad2011-08-29 13:52:23 -07002356
Armin Krezović08368132016-09-30 14:11:05 +02002357 if (connector_get_current_mode(output->connector, b->drm.fd, &crtc_mode) < 0)
Armin Krezović445b41b2016-10-09 23:48:16 +02002358 return -1;
David Herrmann0f0d54e2011-12-08 17:05:45 +01002359
Armin Krezović08368132016-09-30 14:11:05 +02002360 current = drm_output_choose_initial_mode(b, output, mode, modeline, &crtc_mode);
Pekka Paalanen7b36b422014-06-04 14:00:53 +03002361 if (!current)
Armin Krezović445b41b2016-10-09 23:48:16 +02002362 return -1;
Armin Krezović08368132016-09-30 14:11:05 +02002363
Pekka Paalanen7b36b422014-06-04 14:00:53 +03002364 output->base.current_mode = &current->base;
Hardeningff39efa2013-09-18 23:56:35 +02002365 output->base.current_mode->flags |= WL_OUTPUT_MODE_CURRENT;
Wang Quanxianacb805a2012-07-30 18:09:46 -04002366
Armin Krezović08368132016-09-30 14:11:05 +02002367 /* Set native_ fields, so weston_output_mode_switch_to_native() works */
2368 output->base.native_mode = output->base.current_mode;
2369 output->base.native_scale = output->base.current_scale;
2370
2371 output->base.mm_width = output->connector->mmWidth;
2372 output->base.mm_height = output->connector->mmHeight;
2373
2374 return 0;
Armin Krezović08368132016-09-30 14:11:05 +02002375}
2376
2377static void
2378drm_output_set_gbm_format(struct weston_output *base,
2379 const char *gbm_format)
2380{
2381 struct drm_output *output = to_drm_output(base);
2382 struct drm_backend *b = to_drm_backend(base->compositor);
2383
2384 if (parse_gbm_format(gbm_format, b->gbm_format, &output->gbm_format) == -1)
2385 output->gbm_format = b->gbm_format;
2386}
2387
2388static void
2389drm_output_set_seat(struct weston_output *base,
2390 const char *seat)
2391{
2392 struct drm_output *output = to_drm_output(base);
2393 struct drm_backend *b = to_drm_backend(base->compositor);
2394
2395 setup_output_seat_constraint(b, &output->base,
2396 seat ? seat : "");
2397}
2398
2399static int
2400drm_output_enable(struct weston_output *base)
2401{
2402 struct drm_output *output = to_drm_output(base);
2403 struct drm_backend *b = to_drm_backend(base->compositor);
2404 struct weston_mode *m;
2405
2406 output->dpms_prop = drm_get_prop(b->drm.fd, output->connector, "DPMS");
John Kåre Alsaker94659272012-11-13 19:10:18 +01002407
Giulio Camuffo954f1832014-10-11 18:27:30 +03002408 if (b->use_pixman) {
2409 if (drm_output_init_pixman(output, b) < 0) {
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02002410 weston_log("Failed to init output pixman state\n");
Armin Krezović08368132016-09-30 14:11:05 +02002411 goto err_free;
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02002412 }
Giulio Camuffo954f1832014-10-11 18:27:30 +03002413 } else if (drm_output_init_egl(output, b) < 0) {
Ander Conselvan de Oliveira475cf152012-12-14 13:37:29 -02002414 weston_log("Failed to init output gl state\n");
Armin Krezović08368132016-09-30 14:11:05 +02002415 goto err_free;
Kristian Høgsberg1d1e0a52012-10-21 13:29:26 -04002416 }
Kristian Høgsberg8e1f77f2012-05-03 11:39:35 -04002417
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02002418 if (output->backlight) {
Kristian Høgsberg220819f2013-05-23 20:29:40 -04002419 weston_log("Initialized backlight, device %s\n",
2420 output->backlight->path);
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02002421 output->base.set_backlight = drm_set_backlight;
2422 output->base.backlight_current = drm_get_backlight(output);
Kristian Høgsberg220819f2013-05-23 20:29:40 -04002423 } else {
2424 weston_log("Failed to initialize backlight\n");
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02002425 }
2426
Jonas Ådahle5a12252013-04-05 23:07:11 +02002427 output->base.start_repaint_loop = drm_output_start_repaint_loop;
Kristian Høgsberg68c479a2012-01-25 23:32:28 -05002428 output->base.repaint = drm_output_repaint;
Jesse Barnes58ef3792012-02-23 09:45:49 -05002429 output->base.assign_planes = drm_assign_planes;
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02002430 output->base.set_dpms = drm_set_dpms;
Alex Wub7b8bda2012-04-17 17:20:48 +08002431 output->base.switch_mode = drm_output_switch_mode;
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +01002432
Richard Hughese7299962013-05-01 21:52:12 +01002433 output->base.gamma_size = output->original_crtc->gamma_size;
2434 output->base.set_gamma = drm_output_set_gamma;
2435
Armin Krezović08368132016-09-30 14:11:05 +02002436 output->base.subpixel = drm_subpixel_to_wayland(output->connector->subpixel);
2437
2438 find_and_parse_output_edid(b, output, output->connector);
Armin Krezović9bcf4c52017-02-08 13:55:26 +01002439 if (output->connector->connector_type == DRM_MODE_CONNECTOR_LVDS ||
2440 output->connector->connector_type == DRM_MODE_CONNECTOR_eDP)
Armin Krezović08368132016-09-30 14:11:05 +02002441 output->base.connection_internal = 1;
2442
Derek Foremanb0427562016-02-05 15:55:20 -06002443 weston_plane_init(&output->cursor_plane, b->compositor,
2444 INT32_MIN, INT32_MIN);
Giulio Camuffo954f1832014-10-11 18:27:30 +03002445 weston_plane_init(&output->fb_plane, b->compositor, 0, 0);
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04002446
Giulio Camuffo954f1832014-10-11 18:27:30 +03002447 weston_compositor_stack_plane(b->compositor, &output->cursor_plane, NULL);
2448 weston_compositor_stack_plane(b->compositor, &output->fb_plane,
2449 &b->compositor->primary_plane);
Ander Conselvan de Oliveira8ad19822013-03-05 17:30:27 +02002450
Kristian Høgsberg2f9ed712012-07-26 17:57:15 -04002451 weston_log("Output %s, (connector %d, crtc %d)\n",
Richard Hughesafe690c2013-05-02 10:10:04 +01002452 output->base.name, output->connector_id, output->crtc_id);
Kristian Høgsberg061c4252012-06-28 11:28:15 -04002453 wl_list_for_each(m, &output->base.mode_list, link)
U. Artie Eoffd3ed6cb2014-01-10 10:15:17 -08002454 weston_log_continue(STAMP_SPACE "mode %dx%d@%.1f%s%s%s\n",
Kristian Høgsberg061c4252012-06-28 11:28:15 -04002455 m->width, m->height, m->refresh / 1000.0,
2456 m->flags & WL_OUTPUT_MODE_PREFERRED ?
2457 ", preferred" : "",
2458 m->flags & WL_OUTPUT_MODE_CURRENT ?
2459 ", current" : "",
Armin Krezović08368132016-09-30 14:11:05 +02002460 output->connector->count_modes == 0 ?
Kristian Høgsberg061c4252012-06-28 11:28:15 -04002461 ", built-in" : "");
Kristian Høgsbergfc9c5e02012-06-08 16:45:33 -04002462
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002463 return 0;
David Herrmann0f0d54e2011-12-08 17:05:45 +01002464
2465err_free:
Armin Krezović08368132016-09-30 14:11:05 +02002466 drmModeFreeProperty(output->dpms_prop);
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -04002467
David Herrmann0f0d54e2011-12-08 17:05:45 +01002468 return -1;
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002469}
2470
Jesse Barnes58ef3792012-02-23 09:45:49 -05002471static void
Armin Krezović08368132016-09-30 14:11:05 +02002472drm_output_deinit(struct weston_output *base)
2473{
2474 struct drm_output *output = to_drm_output(base);
2475 struct drm_backend *b = to_drm_backend(base->compositor);
2476
Daniel Stone3e661f72016-11-04 17:24:06 +00002477 if (b->use_pixman)
Armin Krezović08368132016-09-30 14:11:05 +02002478 drm_output_fini_pixman(output);
Daniel Stone3e661f72016-11-04 17:24:06 +00002479 else
2480 drm_output_fini_egl(output);
Armin Krezović08368132016-09-30 14:11:05 +02002481
2482 weston_plane_release(&output->fb_plane);
2483 weston_plane_release(&output->cursor_plane);
2484
2485 drmModeFreeProperty(output->dpms_prop);
2486
2487 /* Turn off hardware cursor */
2488 drmModeSetCursor(b->drm.fd, output->crtc_id, 0, 0, 0);
2489}
2490
2491static void
2492drm_output_destroy(struct weston_output *base)
2493{
2494 struct drm_output *output = to_drm_output(base);
2495 struct drm_backend *b = to_drm_backend(base->compositor);
Armin Krezović445b41b2016-10-09 23:48:16 +02002496 struct drm_mode *drm_mode, *next;
Armin Krezović08368132016-09-30 14:11:05 +02002497 drmModeCrtcPtr origcrtc = output->original_crtc;
2498
2499 if (output->page_flip_pending) {
2500 output->destroy_pending = 1;
2501 weston_log("destroy output while page flip pending\n");
2502 return;
2503 }
2504
2505 if (output->base.enabled)
2506 drm_output_deinit(&output->base);
2507
Armin Krezović445b41b2016-10-09 23:48:16 +02002508 wl_list_for_each_safe(drm_mode, next, &output->base.mode_list,
2509 base.link) {
2510 wl_list_remove(&drm_mode->base.link);
2511 free(drm_mode);
2512 }
2513
Armin Krezović08368132016-09-30 14:11:05 +02002514 if (origcrtc) {
2515 /* Restore original CRTC state */
2516 drmModeSetCrtc(b->drm.fd, origcrtc->crtc_id, origcrtc->buffer_id,
2517 origcrtc->x, origcrtc->y,
2518 &output->connector_id, 1, &origcrtc->mode);
2519 drmModeFreeCrtc(origcrtc);
2520 }
2521
2522 weston_output_destroy(&output->base);
2523
2524 drmModeFreeConnector(output->connector);
2525
2526 if (output->backlight)
2527 backlight_destroy(output->backlight);
2528
Armin Krezović08368132016-09-30 14:11:05 +02002529 free(output);
2530}
2531
2532static int
2533drm_output_disable(struct weston_output *base)
2534{
2535 struct drm_output *output = to_drm_output(base);
2536 struct drm_backend *b = to_drm_backend(base->compositor);
2537
2538 if (output->page_flip_pending) {
2539 output->disable_pending = 1;
2540 return -1;
2541 }
2542
2543 if (output->base.enabled)
2544 drm_output_deinit(&output->base);
2545
2546 output->disable_pending = 0;
2547
2548 weston_log("Disabling output %s\n", output->base.name);
2549 drmModeSetCrtc(b->drm.fd, output->crtc_id,
2550 0, 0, 0, 0, 0, NULL);
2551
2552 return 0;
2553}
2554
2555/**
2556 * Create a Weston output structure
2557 *
2558 * Given a DRM connector, create a matching drm_output structure and add it
2559 * to Weston's output list. It also takes ownership of the connector, which
2560 * is released when output is destroyed.
2561 *
2562 * @param b Weston backend structure
2563 * @param resources DRM resources for this device
2564 * @param connector DRM connector to use for this new output
2565 * @param drm_device udev device pointer
2566 * @returns 0 on success, or -1 on failure
2567 */
2568static int
2569create_output_for_connector(struct drm_backend *b,
2570 drmModeRes *resources,
2571 drmModeConnector *connector,
2572 struct udev_device *drm_device)
2573{
2574 struct drm_output *output;
Armin Krezović445b41b2016-10-09 23:48:16 +02002575 struct drm_mode *drm_mode;
Armin Krezović08368132016-09-30 14:11:05 +02002576 int i;
2577
2578 i = find_crtc_for_connector(b, resources, connector);
2579 if (i < 0) {
2580 weston_log("No usable crtc/encoder pair for connector.\n");
Armin Krezović445b41b2016-10-09 23:48:16 +02002581 goto err;
Armin Krezović08368132016-09-30 14:11:05 +02002582 }
2583
2584 output = zalloc(sizeof *output);
2585 if (output == NULL)
Armin Krezović445b41b2016-10-09 23:48:16 +02002586 goto err;
Armin Krezović08368132016-09-30 14:11:05 +02002587
2588 output->connector = connector;
2589 output->crtc_id = resources->crtcs[i];
2590 output->pipe = i;
2591 output->connector_id = connector->connector_id;
2592
2593 output->backlight = backlight_init(drm_device,
2594 connector->connector_type);
2595
Armin Krezović445b41b2016-10-09 23:48:16 +02002596 output->original_crtc = drmModeGetCrtc(b->drm.fd, output->crtc_id);
2597
Armin Krezović08368132016-09-30 14:11:05 +02002598 output->base.enable = drm_output_enable;
2599 output->base.destroy = drm_output_destroy;
2600 output->base.disable = drm_output_disable;
2601 output->base.name = make_connector_name(connector);
2602
2603 output->destroy_pending = 0;
2604 output->disable_pending = 0;
Armin Krezović08368132016-09-30 14:11:05 +02002605
Armin Krezović40087402016-09-30 14:11:12 +02002606 weston_output_init(&output->base, b->compositor);
Armin Krezović445b41b2016-10-09 23:48:16 +02002607
2608 wl_list_init(&output->base.mode_list);
2609
2610 for (i = 0; i < output->connector->count_modes; i++) {
2611 drm_mode = drm_output_add_mode(output, &output->connector->modes[i]);
2612 if (!drm_mode) {
2613 drm_output_destroy(&output->base);
2614 return -1;
2615 }
2616 }
2617
Armin Krezović08368132016-09-30 14:11:05 +02002618 weston_compositor_add_pending_output(&output->base, b->compositor);
2619
2620 return 0;
Armin Krezović445b41b2016-10-09 23:48:16 +02002621
2622err:
2623 drmModeFreeConnector(connector);
2624
2625 return -1;
Armin Krezović08368132016-09-30 14:11:05 +02002626}
2627
2628static void
Giulio Camuffo954f1832014-10-11 18:27:30 +03002629create_sprites(struct drm_backend *b)
Jesse Barnes58ef3792012-02-23 09:45:49 -05002630{
2631 struct drm_sprite *sprite;
2632 drmModePlaneRes *plane_res;
2633 drmModePlane *plane;
Kristian Høgsberg875ab9e2012-03-30 11:52:39 -04002634 uint32_t i;
Jesse Barnes58ef3792012-02-23 09:45:49 -05002635
Giulio Camuffo954f1832014-10-11 18:27:30 +03002636 plane_res = drmModeGetPlaneResources(b->drm.fd);
Jesse Barnes58ef3792012-02-23 09:45:49 -05002637 if (!plane_res) {
Martin Minarik6d118362012-06-07 18:01:59 +02002638 weston_log("failed to get plane resources: %s\n",
Jesse Barnes58ef3792012-02-23 09:45:49 -05002639 strerror(errno));
2640 return;
2641 }
2642
2643 for (i = 0; i < plane_res->count_planes; i++) {
Giulio Camuffo954f1832014-10-11 18:27:30 +03002644 plane = drmModeGetPlane(b->drm.fd, plane_res->planes[i]);
Jesse Barnes58ef3792012-02-23 09:45:49 -05002645 if (!plane)
2646 continue;
2647
Peter Huttererf3d62272013-08-08 11:57:05 +10002648 sprite = zalloc(sizeof(*sprite) + ((sizeof(uint32_t)) *
Jesse Barnes58ef3792012-02-23 09:45:49 -05002649 plane->count_formats));
2650 if (!sprite) {
Martin Minarik6d118362012-06-07 18:01:59 +02002651 weston_log("%s: out of memory\n",
Jesse Barnes58ef3792012-02-23 09:45:49 -05002652 __func__);
Chris Michael8b376872014-01-02 11:39:40 +00002653 drmModeFreePlane(plane);
Jesse Barnes58ef3792012-02-23 09:45:49 -05002654 continue;
2655 }
2656
Jesse Barnes58ef3792012-02-23 09:45:49 -05002657 sprite->possible_crtcs = plane->possible_crtcs;
2658 sprite->plane_id = plane->plane_id;
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +02002659 sprite->current = NULL;
2660 sprite->next = NULL;
Giulio Camuffo954f1832014-10-11 18:27:30 +03002661 sprite->backend = b;
Jesse Barnes58ef3792012-02-23 09:45:49 -05002662 sprite->count_formats = plane->count_formats;
2663 memcpy(sprite->formats, plane->formats,
Rob Clark8efbc8e2012-03-11 19:48:44 -05002664 plane->count_formats * sizeof(plane->formats[0]));
Jesse Barnes58ef3792012-02-23 09:45:49 -05002665 drmModeFreePlane(plane);
Giulio Camuffo954f1832014-10-11 18:27:30 +03002666 weston_plane_init(&sprite->plane, b->compositor, 0, 0);
2667 weston_compositor_stack_plane(b->compositor, &sprite->plane,
2668 &b->compositor->primary_plane);
Jesse Barnes58ef3792012-02-23 09:45:49 -05002669
Giulio Camuffo954f1832014-10-11 18:27:30 +03002670 wl_list_insert(&b->sprite_list, &sprite->link);
Jesse Barnes58ef3792012-02-23 09:45:49 -05002671 }
2672
Samuel Iglesias Gonsalvezde466732013-06-13 10:03:33 +02002673 drmModeFreePlaneResources(plane_res);
Jesse Barnes58ef3792012-02-23 09:45:49 -05002674}
2675
Kristian Høgsberg85fd3272012-02-23 21:45:32 -05002676static void
Giulio Camuffo954f1832014-10-11 18:27:30 +03002677destroy_sprites(struct drm_backend *backend)
Kristian Høgsberg85fd3272012-02-23 21:45:32 -05002678{
2679 struct drm_sprite *sprite, *next;
2680 struct drm_output *output;
2681
Giulio Camuffo954f1832014-10-11 18:27:30 +03002682 output = container_of(backend->compositor->output_list.next,
Kristian Høgsberg85fd3272012-02-23 21:45:32 -05002683 struct drm_output, base.link);
2684
Giulio Camuffo954f1832014-10-11 18:27:30 +03002685 wl_list_for_each_safe(sprite, next, &backend->sprite_list, link) {
2686 drmModeSetPlane(backend->drm.fd,
Kristian Høgsberg85fd3272012-02-23 21:45:32 -05002687 sprite->plane_id,
2688 output->crtc_id, 0, 0,
2689 0, 0, 0, 0, 0, 0, 0, 0);
Ander Conselvan de Oliveira526d4612013-01-25 15:13:03 +02002690 drm_output_release_fb(output, sprite->current);
2691 drm_output_release_fb(output, sprite->next);
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04002692 weston_plane_release(&sprite->plane);
Kristian Høgsberg85fd3272012-02-23 21:45:32 -05002693 free(sprite);
2694 }
2695}
Jesse Barnes58ef3792012-02-23 09:45:49 -05002696
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002697static int
Ucan, Emre (ADITG/SW1)9a200d72017-02-02 14:06:56 +00002698create_outputs(struct drm_backend *b, struct udev_device *drm_device)
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002699{
2700 drmModeConnector *connector;
2701 drmModeRes *resources;
2702 int i;
2703
Giulio Camuffo954f1832014-10-11 18:27:30 +03002704 resources = drmModeGetResources(b->drm.fd);
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002705 if (!resources) {
Martin Minarik6d118362012-06-07 18:01:59 +02002706 weston_log("drmModeGetResources failed\n");
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002707 return -1;
2708 }
2709
Giulio Camuffo954f1832014-10-11 18:27:30 +03002710 b->min_width = resources->min_width;
2711 b->max_width = resources->max_width;
2712 b->min_height = resources->min_height;
2713 b->max_height = resources->max_height;
Rob Clark4339add2012-08-09 14:18:28 -05002714
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002715 for (i = 0; i < resources->count_connectors; i++) {
Giulio Camuffo954f1832014-10-11 18:27:30 +03002716 connector = drmModeGetConnector(b->drm.fd,
Benjamin Franzke117483d2011-08-30 11:38:26 +02002717 resources->connectors[i]);
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002718 if (connector == NULL)
2719 continue;
2720
2721 if (connector->connection == DRM_MODE_CONNECTED &&
Ucan, Emre (ADITG/SW1)9a200d72017-02-02 14:06:56 +00002722 (b->connector == 0 ||
2723 connector->connector_id == b->connector)) {
Giulio Camuffo954f1832014-10-11 18:27:30 +03002724 if (create_output_for_connector(b, resources,
Armin Krezović445b41b2016-10-09 23:48:16 +02002725 connector, drm_device) < 0)
Benjamin Franzke439d9862011-10-07 08:20:53 +02002726 continue;
Armin Krezović08368132016-09-30 14:11:05 +02002727 } else {
2728 drmModeFreeConnector(connector);
Benjamin Franzke9eaee352011-08-02 13:03:54 +02002729 }
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002730 }
2731
Armin Krezović08368132016-09-30 14:11:05 +02002732 if (wl_list_empty(&b->compositor->output_list) &&
2733 wl_list_empty(&b->compositor->pending_output_list))
Martin Minarik6d118362012-06-07 18:01:59 +02002734 weston_log("No currently active connector found.\n");
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002735
2736 drmModeFreeResources(resources);
2737
2738 return 0;
2739}
2740
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002741static void
Giulio Camuffo954f1832014-10-11 18:27:30 +03002742update_outputs(struct drm_backend *b, struct udev_device *drm_device)
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002743{
2744 drmModeConnector *connector;
2745 drmModeRes *resources;
2746 struct drm_output *output, *next;
Daniel Stoneefc2b1d2017-02-09 14:06:31 +00002747 uint32_t *connected;
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002748 int i;
2749
Giulio Camuffo954f1832014-10-11 18:27:30 +03002750 resources = drmModeGetResources(b->drm.fd);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002751 if (!resources) {
Martin Minarik6d118362012-06-07 18:01:59 +02002752 weston_log("drmModeGetResources failed\n");
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002753 return;
2754 }
2755
Daniel Stoneefc2b1d2017-02-09 14:06:31 +00002756 connected = calloc(resources->count_connectors, sizeof(uint32_t));
2757 if (!connected) {
2758 drmModeFreeResources(resources);
2759 return;
2760 }
2761
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002762 /* collect new connects */
2763 for (i = 0; i < resources->count_connectors; i++) {
Ucan, Emre (ADITG/SW1)21e49442017-02-02 14:06:55 +00002764 uint32_t connector_id = resources->connectors[i];
Benjamin Franzke117483d2011-08-30 11:38:26 +02002765
Giulio Camuffo954f1832014-10-11 18:27:30 +03002766 connector = drmModeGetConnector(b->drm.fd, connector_id);
David Herrmann7551cff2011-12-08 17:05:43 +01002767 if (connector == NULL)
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002768 continue;
2769
David Herrmann7551cff2011-12-08 17:05:43 +01002770 if (connector->connection != DRM_MODE_CONNECTED) {
2771 drmModeFreeConnector(connector);
2772 continue;
2773 }
2774
Ucan, Emre (ADITG/SW1)21e49442017-02-02 14:06:55 +00002775 if (b->connector && (b->connector != connector_id)) {
2776 drmModeFreeConnector(connector);
2777 continue;
2778 }
2779
Daniel Stoneefc2b1d2017-02-09 14:06:31 +00002780 connected[i] = connector_id;
Benjamin Franzke117483d2011-08-30 11:38:26 +02002781
Daniel Stonec0ec7592017-02-09 13:58:35 +00002782 if (drm_output_find_by_connector(b, connector_id)) {
Armin Krezović08368132016-09-30 14:11:05 +02002783 drmModeFreeConnector(connector);
Daniel Stonec0ec7592017-02-09 13:58:35 +00002784 continue;
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002785 }
Daniel Stonec0ec7592017-02-09 13:58:35 +00002786
2787 create_output_for_connector(b, resources,
2788 connector, drm_device);
2789 weston_log("connector %d connected\n", connector_id);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002790 }
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002791
Daniel Stoneefc2b1d2017-02-09 14:06:31 +00002792 wl_list_for_each_safe(output, next, &b->compositor->output_list,
2793 base.link) {
2794 bool disconnected = true;
2795
2796 for (i = 0; i < resources->count_connectors; i++) {
2797 if (connected[i] == output->connector_id) {
2798 disconnected = false;
2799 break;
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002800 }
2801 }
Armin Krezović08368132016-09-30 14:11:05 +02002802
Daniel Stoneefc2b1d2017-02-09 14:06:31 +00002803 if (!disconnected)
2804 continue;
2805
2806 weston_log("connector %d disconnected\n", output->connector_id);
2807 drm_output_destroy(&output->base);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002808 }
Daniel Stoneefc2b1d2017-02-09 14:06:31 +00002809
2810 wl_list_for_each_safe(output, next, &b->compositor->pending_output_list,
2811 base.link) {
2812 bool disconnected = true;
2813
2814 for (i = 0; i < resources->count_connectors; i++) {
2815 if (connected[i] == output->connector_id) {
2816 disconnected = false;
2817 break;
2818 }
2819 }
2820
2821 if (!disconnected)
2822 continue;
2823
2824 weston_log("connector %d disconnected\n", output->connector_id);
2825 drm_output_destroy(&output->base);
2826 }
2827
2828 free(connected);
2829 drmModeFreeResources(resources);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002830}
2831
2832static int
Giulio Camuffo954f1832014-10-11 18:27:30 +03002833udev_event_is_hotplug(struct drm_backend *b, struct udev_device *device)
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002834{
David Herrmannd7488c22012-03-11 20:05:21 +01002835 const char *sysnum;
David Herrmann6ac52db2012-03-11 20:05:22 +01002836 const char *val;
David Herrmannd7488c22012-03-11 20:05:21 +01002837
2838 sysnum = udev_device_get_sysnum(device);
Giulio Camuffo954f1832014-10-11 18:27:30 +03002839 if (!sysnum || atoi(sysnum) != b->drm.id)
David Herrmannd7488c22012-03-11 20:05:21 +01002840 return 0;
Benjamin Franzke117483d2011-08-30 11:38:26 +02002841
David Herrmann6ac52db2012-03-11 20:05:22 +01002842 val = udev_device_get_property_value(device, "HOTPLUG");
2843 if (!val)
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002844 return 0;
2845
David Herrmann6ac52db2012-03-11 20:05:22 +01002846 return strcmp(val, "1") == 0;
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002847}
2848
Kristian Høgsbergb1868472011-04-22 12:27:57 -04002849static int
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002850udev_drm_event(int fd, uint32_t mask, void *data)
2851{
Giulio Camuffo954f1832014-10-11 18:27:30 +03002852 struct drm_backend *b = data;
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002853 struct udev_device *event;
2854
Giulio Camuffo954f1832014-10-11 18:27:30 +03002855 event = udev_monitor_receive_device(b->udev_monitor);
Benjamin Franzke117483d2011-08-30 11:38:26 +02002856
Giulio Camuffo954f1832014-10-11 18:27:30 +03002857 if (udev_event_is_hotplug(b, event))
2858 update_outputs(b, event);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002859
2860 udev_device_unref(event);
Kristian Høgsbergb1868472011-04-22 12:27:57 -04002861
2862 return 1;
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002863}
2864
Kristian Høgsbergcaa64422010-12-01 16:52:15 -05002865static void
Kristian Høgsberg7b884bc2012-07-31 14:32:01 -04002866drm_restore(struct weston_compositor *ec)
2867{
Kristian Høgsberg3f495872013-09-18 23:00:17 -07002868 weston_launcher_restore(ec->launcher);
Kristian Høgsberg7b884bc2012-07-31 14:32:01 -04002869}
2870
2871static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002872drm_destroy(struct weston_compositor *ec)
Kristian Høgsbergcaa64422010-12-01 16:52:15 -05002873{
Armin Krezović545dba62016-08-05 15:54:18 +02002874 struct drm_backend *b = to_drm_backend(ec);
Kristian Høgsbergcaa64422010-12-01 16:52:15 -05002875
Giulio Camuffo954f1832014-10-11 18:27:30 +03002876 udev_input_destroy(&b->input);
Jonas Ådahlc97af922012-03-28 22:36:09 +02002877
Giulio Camuffo954f1832014-10-11 18:27:30 +03002878 wl_event_source_remove(b->udev_drm_source);
2879 wl_event_source_remove(b->drm_source);
Jonas Ådahlc97af922012-03-28 22:36:09 +02002880
Giulio Camuffo954f1832014-10-11 18:27:30 +03002881 destroy_sprites(b);
Kristian Høgsberg3d64a3e2013-05-10 12:36:04 -04002882
Ander Conselvan de Oliveira6b162142013-10-25 16:26:32 +03002883 weston_compositor_shutdown(ec);
2884
Giulio Camuffo954f1832014-10-11 18:27:30 +03002885 if (b->gbm)
2886 gbm_device_destroy(b->gbm);
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02002887
Giulio Camuffo954f1832014-10-11 18:27:30 +03002888 weston_launcher_destroy(ec->launcher);
Kristian Høgsbergcaa64422010-12-01 16:52:15 -05002889
Giulio Camuffo954f1832014-10-11 18:27:30 +03002890 close(b->drm.fd);
Giulio Camuffo954f1832014-10-11 18:27:30 +03002891 free(b);
Kristian Høgsbergcaa64422010-12-01 16:52:15 -05002892}
2893
Kristian Høgsberg9396fc52011-05-06 15:15:37 -04002894static void
Kristian Høgsberg61741a22013-09-17 16:02:57 -07002895session_notify(struct wl_listener *listener, void *data)
Kristian Høgsberg9396fc52011-05-06 15:15:37 -04002896{
Kristian Høgsberg61741a22013-09-17 16:02:57 -07002897 struct weston_compositor *compositor = data;
Armin Krezović545dba62016-08-05 15:54:18 +02002898 struct drm_backend *b = to_drm_backend(compositor);
Kristian Høgsberg85fd3272012-02-23 21:45:32 -05002899 struct drm_sprite *sprite;
Kristian Høgsberga6edab32012-07-14 01:06:28 -04002900 struct drm_output *output;
Kristian Høgsberg9396fc52011-05-06 15:15:37 -04002901
Giulio Camuffo954f1832014-10-11 18:27:30 +03002902 if (compositor->session_active) {
Kristian Høgsberg61741a22013-09-17 16:02:57 -07002903 weston_log("activating session\n");
Daniel Stonef33e1042016-11-05 08:10:13 +00002904 weston_compositor_wake(compositor);
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002905 weston_compositor_damage_all(compositor);
Giulio Camuffo954f1832014-10-11 18:27:30 +03002906 udev_input_enable(&b->input);
Kristian Høgsberg61741a22013-09-17 16:02:57 -07002907 } else {
2908 weston_log("deactivating session\n");
Giulio Camuffo954f1832014-10-11 18:27:30 +03002909 udev_input_disable(&b->input);
Kristian Høgsberg4014a6b2012-04-10 00:08:45 -04002910
Philipp Brüschweiler57edf7f2013-03-29 13:01:56 +01002911 weston_compositor_offscreen(compositor);
Kristian Høgsbergd8e181b2011-05-06 15:38:28 -04002912
Kristian Høgsberg34f80ff2012-01-18 11:50:31 -05002913 /* If we have a repaint scheduled (either from a
2914 * pending pageflip or the idle handler), make sure we
2915 * cancel that so we don't try to pageflip when we're
Philipp Brüschweiler57edf7f2013-03-29 13:01:56 +01002916 * vt switched away. The OFFSCREEN state will prevent
Abdur Rehman4dca0e12017-01-01 19:46:35 +05002917 * further attempts at repainting. When we switch
Kristian Høgsberg34f80ff2012-01-18 11:50:31 -05002918 * back, we schedule a repaint, which will process
2919 * pending frame callbacks. */
2920
Giulio Camuffo954f1832014-10-11 18:27:30 +03002921 wl_list_for_each(output, &compositor->output_list, base.link) {
Kristian Høgsberga6edab32012-07-14 01:06:28 -04002922 output->base.repaint_needed = 0;
Giulio Camuffo954f1832014-10-11 18:27:30 +03002923 drmModeSetCursor(b->drm.fd, output->crtc_id, 0, 0, 0);
Kristian Høgsberg34f80ff2012-01-18 11:50:31 -05002924 }
2925
Giulio Camuffo954f1832014-10-11 18:27:30 +03002926 output = container_of(compositor->output_list.next,
Kristian Høgsberga6edab32012-07-14 01:06:28 -04002927 struct drm_output, base.link);
Kristian Høgsberg85fd3272012-02-23 21:45:32 -05002928
Giulio Camuffo954f1832014-10-11 18:27:30 +03002929 wl_list_for_each(sprite, &b->sprite_list, link)
2930 drmModeSetPlane(b->drm.fd,
Kristian Høgsberg85fd3272012-02-23 21:45:32 -05002931 sprite->plane_id,
Kristian Høgsberga6edab32012-07-14 01:06:28 -04002932 output->crtc_id, 0, 0,
Kristian Høgsberg85fd3272012-02-23 21:45:32 -05002933 0, 0, 0, 0, 0, 0, 0, 0);
Kristian Høgsberg9396fc52011-05-06 15:15:37 -04002934 };
2935}
2936
Daniel Stoneefa504f2016-12-19 16:48:20 +00002937/**
2938 * Determines whether or not a device is capable of modesetting. If successful,
2939 * sets b->drm.fd and b->drm.filename to the opened device.
2940 */
2941static bool
2942drm_device_is_kms(struct drm_backend *b, struct udev_device *device)
2943{
2944 const char *filename = udev_device_get_devnode(device);
2945 const char *sysnum = udev_device_get_sysnum(device);
2946 drmModeRes *res;
2947 int id, fd;
2948
2949 if (!filename)
2950 return false;
2951
2952 fd = weston_launcher_open(b->compositor->launcher, filename, O_RDWR);
2953 if (fd < 0)
2954 return false;
2955
2956 res = drmModeGetResources(fd);
2957 if (!res)
2958 goto out_fd;
2959
2960 if (res->count_crtcs <= 0 || res->count_connectors <= 0 ||
2961 res->count_encoders <= 0)
2962 goto out_res;
2963
2964 if (sysnum)
2965 id = atoi(sysnum);
2966 if (!sysnum || id < 0) {
2967 weston_log("couldn't get sysnum for device %s\n", filename);
2968 goto out_res;
2969 }
2970
2971 /* We can be called successfully on multiple devices; if we have,
2972 * clean up old entries. */
2973 if (b->drm.fd >= 0)
2974 weston_launcher_close(b->compositor->launcher, b->drm.fd);
2975 free(b->drm.filename);
2976
2977 b->drm.fd = fd;
2978 b->drm.id = id;
2979 b->drm.filename = strdup(filename);
2980
2981 return true;
2982
2983out_res:
2984 drmModeFreeResources(res);
2985out_fd:
2986 weston_launcher_close(b->compositor->launcher, fd);
2987 return false;
2988}
2989
David Herrmann0af066f2012-10-29 19:21:16 +01002990/*
2991 * Find primary GPU
2992 * Some systems may have multiple DRM devices attached to a single seat. This
2993 * function loops over all devices and tries to find a PCI device with the
2994 * boot_vga sysfs attribute set to 1.
2995 * If no such device is found, the first DRM device reported by udev is used.
Daniel Stoneefa504f2016-12-19 16:48:20 +00002996 * Devices are also vetted to make sure they are are capable of modesetting,
2997 * rather than pure render nodes (GPU with no display), or pure
2998 * memory-allocation devices (VGEM).
David Herrmann0af066f2012-10-29 19:21:16 +01002999 */
3000static struct udev_device*
Giulio Camuffo954f1832014-10-11 18:27:30 +03003001find_primary_gpu(struct drm_backend *b, const char *seat)
David Herrmann0af066f2012-10-29 19:21:16 +01003002{
3003 struct udev_enumerate *e;
3004 struct udev_list_entry *entry;
3005 const char *path, *device_seat, *id;
3006 struct udev_device *device, *drm_device, *pci;
3007
Giulio Camuffo954f1832014-10-11 18:27:30 +03003008 e = udev_enumerate_new(b->udev);
David Herrmann0af066f2012-10-29 19:21:16 +01003009 udev_enumerate_add_match_subsystem(e, "drm");
3010 udev_enumerate_add_match_sysname(e, "card[0-9]*");
3011
3012 udev_enumerate_scan_devices(e);
3013 drm_device = NULL;
3014 udev_list_entry_foreach(entry, udev_enumerate_get_list_entry(e)) {
Daniel Stoneefa504f2016-12-19 16:48:20 +00003015 bool is_boot_vga = false;
3016
David Herrmann0af066f2012-10-29 19:21:16 +01003017 path = udev_list_entry_get_name(entry);
Giulio Camuffo954f1832014-10-11 18:27:30 +03003018 device = udev_device_new_from_syspath(b->udev, path);
David Herrmann0af066f2012-10-29 19:21:16 +01003019 if (!device)
3020 continue;
3021 device_seat = udev_device_get_property_value(device, "ID_SEAT");
3022 if (!device_seat)
3023 device_seat = default_seat;
3024 if (strcmp(device_seat, seat)) {
3025 udev_device_unref(device);
3026 continue;
3027 }
3028
3029 pci = udev_device_get_parent_with_subsystem_devtype(device,
3030 "pci", NULL);
3031 if (pci) {
3032 id = udev_device_get_sysattr_value(pci, "boot_vga");
Daniel Stoneefa504f2016-12-19 16:48:20 +00003033 if (id && !strcmp(id, "1"))
3034 is_boot_vga = true;
David Herrmann0af066f2012-10-29 19:21:16 +01003035 }
3036
Daniel Stoneefa504f2016-12-19 16:48:20 +00003037 /* If we already have a modesetting-capable device, and this
3038 * device isn't our boot-VGA device, we aren't going to use
3039 * it. */
3040 if (!is_boot_vga && drm_device) {
David Herrmann0af066f2012-10-29 19:21:16 +01003041 udev_device_unref(device);
Daniel Stoneefa504f2016-12-19 16:48:20 +00003042 continue;
3043 }
3044
3045 /* Make sure this device is actually capable of modesetting;
3046 * if this call succeeds, b->drm.{fd,filename} will be set,
3047 * and any old values freed. */
3048 if (!drm_device_is_kms(b, device)) {
3049 udev_device_unref(device);
3050 continue;
3051 }
3052
3053 /* There can only be one boot_vga device, and we try to use it
3054 * at all costs. */
3055 if (is_boot_vga) {
3056 if (drm_device)
3057 udev_device_unref(drm_device);
3058 drm_device = device;
3059 break;
3060 }
3061
3062 /* Per the (!is_boot_vga && drm_device) test above, we only
3063 * trump existing saved devices with boot-VGA devices, so if
3064 * we end up here, this must be the first device we've seen. */
3065 assert(!drm_device);
3066 drm_device = device;
David Herrmann0af066f2012-10-29 19:21:16 +01003067 }
3068
Daniel Stoneefa504f2016-12-19 16:48:20 +00003069 /* If we're returning a device to use, we must have an open FD for
3070 * it. */
3071 assert(!!drm_device == (b->drm.fd >= 0));
3072
David Herrmann0af066f2012-10-29 19:21:16 +01003073 udev_enumerate_unref(e);
3074 return drm_device;
3075}
3076
Ander Conselvan de Oliveirada1c9082012-10-31 17:55:46 +02003077static void
Derek Foreman8ae2db52015-07-15 13:00:36 -05003078planes_binding(struct weston_keyboard *keyboard, uint32_t time, uint32_t key,
3079 void *data)
Ander Conselvan de Oliveirada1c9082012-10-31 17:55:46 +02003080{
Giulio Camuffo954f1832014-10-11 18:27:30 +03003081 struct drm_backend *b = data;
Ander Conselvan de Oliveirada1c9082012-10-31 17:55:46 +02003082
Ander Conselvan de Oliveira7e918da2012-11-22 15:56:59 +02003083 switch (key) {
3084 case KEY_C:
Giulio Camuffo954f1832014-10-11 18:27:30 +03003085 b->cursors_are_broken ^= 1;
Ander Conselvan de Oliveira7e918da2012-11-22 15:56:59 +02003086 break;
3087 case KEY_V:
Giulio Camuffo954f1832014-10-11 18:27:30 +03003088 b->sprites_are_broken ^= 1;
Ander Conselvan de Oliveira7e918da2012-11-22 15:56:59 +02003089 break;
3090 case KEY_O:
Giulio Camuffo954f1832014-10-11 18:27:30 +03003091 b->sprites_hidden ^= 1;
Ander Conselvan de Oliveira7e918da2012-11-22 15:56:59 +02003092 break;
3093 default:
3094 break;
3095 }
Ander Conselvan de Oliveira180f42a2012-11-21 15:11:37 +02003096}
3097
Kristian Høgsberg0eac34a2013-08-30 14:28:22 -07003098#ifdef BUILD_VAAPI_RECORDER
Ander Conselvan de Oliveira6aae4d32013-08-23 17:15:48 +03003099static void
Ander Conselvan de Oliveira2d13fde2014-05-09 15:57:38 +03003100recorder_destroy(struct drm_output *output)
3101{
3102 vaapi_recorder_destroy(output->recorder);
3103 output->recorder = NULL;
3104
3105 output->base.disable_planes--;
3106
3107 wl_list_remove(&output->recorder_frame_listener.link);
3108 weston_log("[libva recorder] done\n");
3109}
3110
3111static void
Ander Conselvan de Oliveira6aae4d32013-08-23 17:15:48 +03003112recorder_frame_notify(struct wl_listener *listener, void *data)
3113{
3114 struct drm_output *output;
Giulio Camuffo954f1832014-10-11 18:27:30 +03003115 struct drm_backend *b;
Ander Conselvan de Oliveira6aae4d32013-08-23 17:15:48 +03003116 int fd, ret;
3117
3118 output = container_of(listener, struct drm_output,
3119 recorder_frame_listener);
Armin Krezović545dba62016-08-05 15:54:18 +02003120 b = to_drm_backend(output->base.compositor);
Ander Conselvan de Oliveira6aae4d32013-08-23 17:15:48 +03003121
3122 if (!output->recorder)
3123 return;
3124
Giulio Camuffo954f1832014-10-11 18:27:30 +03003125 ret = drmPrimeHandleToFD(b->drm.fd, output->current->handle,
Ander Conselvan de Oliveira6aae4d32013-08-23 17:15:48 +03003126 DRM_CLOEXEC, &fd);
3127 if (ret) {
3128 weston_log("[libva recorder] "
3129 "failed to create prime fd for front buffer\n");
3130 return;
3131 }
3132
Ander Conselvan de Oliveira2d13fde2014-05-09 15:57:38 +03003133 ret = vaapi_recorder_frame(output->recorder, fd,
3134 output->current->stride);
3135 if (ret < 0) {
3136 weston_log("[libva recorder] aborted: %m\n");
3137 recorder_destroy(output);
3138 }
Ander Conselvan de Oliveira6aae4d32013-08-23 17:15:48 +03003139}
3140
3141static void *
Giulio Camuffo954f1832014-10-11 18:27:30 +03003142create_recorder(struct drm_backend *b, int width, int height,
Ander Conselvan de Oliveira6aae4d32013-08-23 17:15:48 +03003143 const char *filename)
3144{
3145 int fd;
3146 drm_magic_t magic;
3147
Giulio Camuffo954f1832014-10-11 18:27:30 +03003148 fd = open(b->drm.filename, O_RDWR | O_CLOEXEC);
Ander Conselvan de Oliveira6aae4d32013-08-23 17:15:48 +03003149 if (fd < 0)
3150 return NULL;
3151
3152 drmGetMagic(fd, &magic);
Giulio Camuffo954f1832014-10-11 18:27:30 +03003153 drmAuthMagic(b->drm.fd, magic);
Ander Conselvan de Oliveira6aae4d32013-08-23 17:15:48 +03003154
3155 return vaapi_recorder_create(fd, width, height, filename);
3156}
3157
3158static void
Derek Foreman8ae2db52015-07-15 13:00:36 -05003159recorder_binding(struct weston_keyboard *keyboard, uint32_t time, uint32_t key,
Ander Conselvan de Oliveira6aae4d32013-08-23 17:15:48 +03003160 void *data)
3161{
Giulio Camuffo954f1832014-10-11 18:27:30 +03003162 struct drm_backend *b = data;
Ander Conselvan de Oliveira6aae4d32013-08-23 17:15:48 +03003163 struct drm_output *output;
3164 int width, height;
3165
Giulio Camuffo954f1832014-10-11 18:27:30 +03003166 output = container_of(b->compositor->output_list.next,
Ander Conselvan de Oliveira6aae4d32013-08-23 17:15:48 +03003167 struct drm_output, base.link);
3168
3169 if (!output->recorder) {
Miguel A. Vicofcf4b6c2016-03-21 17:41:03 +01003170 if (output->gbm_format != GBM_FORMAT_XRGB8888) {
Ander Conselvan de Oliveira2ef1cd12014-05-06 16:49:06 +03003171 weston_log("failed to start vaapi recorder: "
3172 "output format not supported\n");
3173 return;
3174 }
3175
Hardeningff39efa2013-09-18 23:56:35 +02003176 width = output->base.current_mode->width;
3177 height = output->base.current_mode->height;
Ander Conselvan de Oliveira6aae4d32013-08-23 17:15:48 +03003178
3179 output->recorder =
Giulio Camuffo954f1832014-10-11 18:27:30 +03003180 create_recorder(b, width, height, "capture.h264");
Ander Conselvan de Oliveira6aae4d32013-08-23 17:15:48 +03003181 if (!output->recorder) {
3182 weston_log("failed to create vaapi recorder\n");
3183 return;
3184 }
3185
3186 output->base.disable_planes++;
3187
3188 output->recorder_frame_listener.notify = recorder_frame_notify;
3189 wl_signal_add(&output->base.frame_signal,
3190 &output->recorder_frame_listener);
3191
3192 weston_output_schedule_repaint(&output->base);
3193
3194 weston_log("[libva recorder] initialized\n");
3195 } else {
Ander Conselvan de Oliveira2d13fde2014-05-09 15:57:38 +03003196 recorder_destroy(output);
Ander Conselvan de Oliveira6aae4d32013-08-23 17:15:48 +03003197 }
3198}
3199#else
3200static void
Bryce Harrington4a8a3a12015-07-16 19:12:26 -07003201recorder_binding(struct weston_keyboard *keyboard, uint32_t time, uint32_t key,
Ander Conselvan de Oliveira6aae4d32013-08-23 17:15:48 +03003202 void *data)
3203{
3204 weston_log("Compiled without libva support\n");
3205}
3206#endif
3207
Ander Conselvan de Oliveira65796812013-11-19 15:22:04 +02003208static void
Giulio Camuffo954f1832014-10-11 18:27:30 +03003209switch_to_gl_renderer(struct drm_backend *b)
Ander Conselvan de Oliveira65796812013-11-19 15:22:04 +02003210{
3211 struct drm_output *output;
Pekka Paalanene4d231e2014-06-12 15:12:48 +03003212 bool dmabuf_support_inited;
Ander Conselvan de Oliveira65796812013-11-19 15:22:04 +02003213
Giulio Camuffo954f1832014-10-11 18:27:30 +03003214 if (!b->use_pixman)
Ander Conselvan de Oliveira65796812013-11-19 15:22:04 +02003215 return;
3216
Pekka Paalanene4d231e2014-06-12 15:12:48 +03003217 dmabuf_support_inited = !!b->compositor->renderer->import_dmabuf;
3218
Ander Conselvan de Oliveira65796812013-11-19 15:22:04 +02003219 weston_log("Switching to GL renderer\n");
3220
Giulio Camuffo954f1832014-10-11 18:27:30 +03003221 b->gbm = create_gbm_device(b->drm.fd);
3222 if (!b->gbm) {
Ander Conselvan de Oliveira65796812013-11-19 15:22:04 +02003223 weston_log("Failed to create gbm device. "
3224 "Aborting renderer switch\n");
3225 return;
3226 }
3227
Giulio Camuffo954f1832014-10-11 18:27:30 +03003228 wl_list_for_each(output, &b->compositor->output_list, base.link)
Ander Conselvan de Oliveira65796812013-11-19 15:22:04 +02003229 pixman_renderer_output_destroy(&output->base);
3230
Giulio Camuffo954f1832014-10-11 18:27:30 +03003231 b->compositor->renderer->destroy(b->compositor);
Ander Conselvan de Oliveira65796812013-11-19 15:22:04 +02003232
Giulio Camuffo954f1832014-10-11 18:27:30 +03003233 if (drm_backend_create_gl_renderer(b) < 0) {
3234 gbm_device_destroy(b->gbm);
Ander Conselvan de Oliveira65796812013-11-19 15:22:04 +02003235 weston_log("Failed to create GL renderer. Quitting.\n");
3236 /* FIXME: we need a function to shutdown cleanly */
3237 assert(0);
3238 }
3239
Giulio Camuffo954f1832014-10-11 18:27:30 +03003240 wl_list_for_each(output, &b->compositor->output_list, base.link)
3241 drm_output_init_egl(output, b);
Ander Conselvan de Oliveira65796812013-11-19 15:22:04 +02003242
Giulio Camuffo954f1832014-10-11 18:27:30 +03003243 b->use_pixman = 0;
Pekka Paalanene4d231e2014-06-12 15:12:48 +03003244
3245 if (!dmabuf_support_inited && b->compositor->renderer->import_dmabuf) {
3246 if (linux_dmabuf_setup(b->compositor) < 0)
3247 weston_log("Error: initializing dmabuf "
3248 "support failed.\n");
3249 }
Ander Conselvan de Oliveira65796812013-11-19 15:22:04 +02003250}
3251
3252static void
Derek Foreman8ae2db52015-07-15 13:00:36 -05003253renderer_switch_binding(struct weston_keyboard *keyboard, uint32_t time,
3254 uint32_t key, void *data)
Ander Conselvan de Oliveira65796812013-11-19 15:22:04 +02003255{
Derek Foreman8ae2db52015-07-15 13:00:36 -05003256 struct drm_backend *b =
Armin Krezović545dba62016-08-05 15:54:18 +02003257 to_drm_backend(keyboard->seat->compositor);
Ander Conselvan de Oliveira65796812013-11-19 15:22:04 +02003258
Giulio Camuffo954f1832014-10-11 18:27:30 +03003259 switch_to_gl_renderer(b);
Ander Conselvan de Oliveira65796812013-11-19 15:22:04 +02003260}
3261
Armin Krezović08368132016-09-30 14:11:05 +02003262static const struct weston_drm_output_api api = {
3263 drm_output_set_mode,
3264 drm_output_set_gbm_format,
3265 drm_output_set_seat,
3266};
3267
Giulio Camuffo954f1832014-10-11 18:27:30 +03003268static struct drm_backend *
3269drm_backend_create(struct weston_compositor *compositor,
Giulio Camuffo1c0e40d2016-04-29 15:40:34 -07003270 struct weston_drm_backend_config *config)
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04003271{
Giulio Camuffo954f1832014-10-11 18:27:30 +03003272 struct drm_backend *b;
David Herrmann0af066f2012-10-29 19:21:16 +01003273 struct udev_device *drm_device;
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04003274 struct wl_event_loop *loop;
Giulio Camuffo1c0e40d2016-04-29 15:40:34 -07003275 const char *seat_id = default_seat;
Armin Krezović08368132016-09-30 14:11:05 +02003276 int ret;
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04003277
Kristian Høgsbergfc9c5e02012-06-08 16:45:33 -04003278 weston_log("initializing drm backend\n");
3279
Giulio Camuffo954f1832014-10-11 18:27:30 +03003280 b = zalloc(sizeof *b);
3281 if (b == NULL)
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04003282 return NULL;
Daniel Stone725c2c32012-06-22 14:04:36 +01003283
Daniel Stoneefa504f2016-12-19 16:48:20 +00003284 b->drm.fd = -1;
3285
Pekka Paalanen68583832015-05-19 09:53:16 +03003286 /*
3287 * KMS support for hardware planes cannot properly synchronize
3288 * without nuclear page flip. Without nuclear/atomic, hw plane
3289 * and cursor plane updates would either tear or cause extra
3290 * waits for vblanks which means dropping the compositor framerate
Pekka Paalanen3f32a132015-09-07 15:38:43 +03003291 * to a fraction. For cursors, it's not so bad, so they are
3292 * enabled.
Pekka Paalanen68583832015-05-19 09:53:16 +03003293 *
3294 * These can be enabled again when nuclear/atomic support lands.
3295 */
Giulio Camuffo954f1832014-10-11 18:27:30 +03003296 b->sprites_are_broken = 1;
Giulio Camuffo954f1832014-10-11 18:27:30 +03003297 b->compositor = compositor;
Giulio Camuffo1c0e40d2016-04-29 15:40:34 -07003298 b->use_pixman = config->use_pixman;
Kristian Høgsberg8e6f3762013-10-16 16:31:42 -07003299
Giulio Camuffo1c0e40d2016-04-29 15:40:34 -07003300 if (parse_gbm_format(config->gbm_format, GBM_FORMAT_XRGB8888, &b->gbm_format) < 0)
3301 goto err_compositor;
Kristian Høgsberg8e6f3762013-10-16 16:31:42 -07003302
Giulio Camuffo1c0e40d2016-04-29 15:40:34 -07003303 if (config->seat_id)
3304 seat_id = config->seat_id;
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02003305
Rafal Mielniczuk32069c02013-03-27 18:39:28 +01003306 /* Check if we run drm-backend using weston-launch */
Giulio Camuffo1c0e40d2016-04-29 15:40:34 -07003307 compositor->launcher = weston_launcher_connect(compositor, config->tty,
3308 seat_id, true);
Giulio Camuffo954f1832014-10-11 18:27:30 +03003309 if (compositor->launcher == NULL) {
Rafal Mielniczuk32069c02013-03-27 18:39:28 +01003310 weston_log("fatal: drm backend should be run "
Kristian Høgsbergb76237e2013-04-04 21:36:20 -04003311 "using weston-launch binary or as root\n");
Rafal Mielniczuk32069c02013-03-27 18:39:28 +01003312 goto err_compositor;
3313 }
3314
Giulio Camuffo954f1832014-10-11 18:27:30 +03003315 b->udev = udev_new();
3316 if (b->udev == NULL) {
Martin Minarik6d118362012-06-07 18:01:59 +02003317 weston_log("failed to initialize udev context\n");
Kristian Høgsberg3f495872013-09-18 23:00:17 -07003318 goto err_launcher;
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04003319 }
3320
Giulio Camuffo954f1832014-10-11 18:27:30 +03003321 b->session_listener.notify = session_notify;
3322 wl_signal_add(&compositor->session_signal, &b->session_listener);
Kristian Høgsbergc5b9ddb2012-01-15 14:29:09 -05003323
Giulio Camuffo1c0e40d2016-04-29 15:40:34 -07003324 drm_device = find_primary_gpu(b, seat_id);
Kristian Høgsberg8d51f142011-07-15 21:28:38 -04003325 if (drm_device == NULL) {
Martin Minarik6d118362012-06-07 18:01:59 +02003326 weston_log("no drm device found\n");
Kristian Høgsberg3f495872013-09-18 23:00:17 -07003327 goto err_udev;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04003328 }
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04003329
Daniel Stoneefa504f2016-12-19 16:48:20 +00003330 if (init_kms_caps(b) < 0) {
Ander Conselvan de Oliveira22929172013-01-25 15:13:02 +02003331 weston_log("failed to initialize kms\n");
3332 goto err_udev_dev;
3333 }
3334
Giulio Camuffo954f1832014-10-11 18:27:30 +03003335 if (b->use_pixman) {
3336 if (init_pixman(b) < 0) {
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02003337 weston_log("failed to initialize pixman renderer\n");
3338 goto err_udev_dev;
3339 }
3340 } else {
Giulio Camuffo954f1832014-10-11 18:27:30 +03003341 if (init_egl(b) < 0) {
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02003342 weston_log("failed to initialize egl\n");
3343 goto err_udev_dev;
3344 }
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04003345 }
Kristian Høgsberg8525a502011-01-14 16:20:21 -05003346
Giulio Camuffo954f1832014-10-11 18:27:30 +03003347 b->base.destroy = drm_destroy;
3348 b->base.restore = drm_restore;
Benjamin Franzke431da9a2011-04-20 11:02:58 +02003349
Bob Ham91880f12016-01-12 10:21:47 +00003350 weston_setup_vt_switch_bindings(compositor);
Kristian Høgsberg5d1c0c52012-04-10 00:11:50 -04003351
Giulio Camuffo954f1832014-10-11 18:27:30 +03003352 wl_list_init(&b->sprite_list);
3353 create_sprites(b);
Jesse Barnes58ef3792012-02-23 09:45:49 -05003354
Giulio Camuffo954f1832014-10-11 18:27:30 +03003355 if (udev_input_init(&b->input,
Giulio Camuffo8aedf7b2016-06-02 21:48:12 +03003356 compositor, b->udev, seat_id,
3357 config->configure_device) < 0) {
Ander Conselvan de Oliveira4ade0e42014-04-17 13:08:45 +03003358 weston_log("failed to create input devices\n");
3359 goto err_sprite;
3360 }
3361
Ucan, Emre (ADITG/SW1)21e49442017-02-02 14:06:55 +00003362 b->connector = config->connector;
3363
Ucan, Emre (ADITG/SW1)9a200d72017-02-02 14:06:56 +00003364 if (create_outputs(b, drm_device) < 0) {
Daniel Stoneefa504f2016-12-19 16:48:20 +00003365 weston_log("failed to create output for %s\n", b->drm.filename);
Ander Conselvan de Oliveira4ade0e42014-04-17 13:08:45 +03003366 goto err_udev_input;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04003367 }
3368
Jason Ekstrand9fc71512014-04-02 19:53:46 -05003369 /* A this point we have some idea of whether or not we have a working
3370 * cursor plane. */
Giulio Camuffo954f1832014-10-11 18:27:30 +03003371 if (!b->cursors_are_broken)
3372 compositor->capabilities |= WESTON_CAP_CURSOR_PLANE;
Jason Ekstrand9fc71512014-04-02 19:53:46 -05003373
Giulio Camuffo954f1832014-10-11 18:27:30 +03003374 loop = wl_display_get_event_loop(compositor->wl_display);
3375 b->drm_source =
3376 wl_event_loop_add_fd(loop, b->drm.fd,
3377 WL_EVENT_READABLE, on_drm_input, b);
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04003378
Giulio Camuffo954f1832014-10-11 18:27:30 +03003379 b->udev_monitor = udev_monitor_new_from_netlink(b->udev, "udev");
3380 if (b->udev_monitor == NULL) {
Abdur Rehman4dca0e12017-01-01 19:46:35 +05003381 weston_log("failed to initialize udev monitor\n");
Daniel Stonea96b93c2012-06-22 14:04:37 +01003382 goto err_drm_source;
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01003383 }
Giulio Camuffo954f1832014-10-11 18:27:30 +03003384 udev_monitor_filter_add_match_subsystem_devtype(b->udev_monitor,
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01003385 "drm", NULL);
Giulio Camuffo954f1832014-10-11 18:27:30 +03003386 b->udev_drm_source =
Benjamin Franzke117483d2011-08-30 11:38:26 +02003387 wl_event_loop_add_fd(loop,
Giulio Camuffo954f1832014-10-11 18:27:30 +03003388 udev_monitor_get_fd(b->udev_monitor),
3389 WL_EVENT_READABLE, udev_drm_event, b);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01003390
Giulio Camuffo954f1832014-10-11 18:27:30 +03003391 if (udev_monitor_enable_receiving(b->udev_monitor) < 0) {
Martin Minarik6d118362012-06-07 18:01:59 +02003392 weston_log("failed to enable udev-monitor receiving\n");
Daniel Stonea96b93c2012-06-22 14:04:37 +01003393 goto err_udev_monitor;
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01003394 }
3395
Daniel Stonea96b93c2012-06-22 14:04:37 +01003396 udev_device_unref(drm_device);
Daniel Stonea96b93c2012-06-22 14:04:37 +01003397
Giulio Camuffo954f1832014-10-11 18:27:30 +03003398 weston_compositor_add_debug_binding(compositor, KEY_O,
3399 planes_binding, b);
3400 weston_compositor_add_debug_binding(compositor, KEY_C,
3401 planes_binding, b);
3402 weston_compositor_add_debug_binding(compositor, KEY_V,
3403 planes_binding, b);
3404 weston_compositor_add_debug_binding(compositor, KEY_Q,
3405 recorder_binding, b);
3406 weston_compositor_add_debug_binding(compositor, KEY_W,
3407 renderer_switch_binding, b);
Ander Conselvan de Oliveirada1c9082012-10-31 17:55:46 +02003408
Pekka Paalanene4d231e2014-06-12 15:12:48 +03003409 if (compositor->renderer->import_dmabuf) {
3410 if (linux_dmabuf_setup(compositor) < 0)
3411 weston_log("Error: initializing dmabuf "
3412 "support failed.\n");
3413 }
3414
Giulio Camuffo954f1832014-10-11 18:27:30 +03003415 compositor->backend = &b->base;
Pekka Paalanene4d231e2014-06-12 15:12:48 +03003416
Armin Krezović08368132016-09-30 14:11:05 +02003417 ret = weston_plugin_api_register(compositor, WESTON_DRM_OUTPUT_API_NAME,
3418 &api, sizeof(api));
3419
3420 if (ret < 0) {
3421 weston_log("Failed to register output API.\n");
3422 goto err_udev_monitor;
3423 }
3424
Giulio Camuffo954f1832014-10-11 18:27:30 +03003425 return b;
Daniel Stonea96b93c2012-06-22 14:04:37 +01003426
3427err_udev_monitor:
Giulio Camuffo954f1832014-10-11 18:27:30 +03003428 wl_event_source_remove(b->udev_drm_source);
3429 udev_monitor_unref(b->udev_monitor);
Daniel Stonea96b93c2012-06-22 14:04:37 +01003430err_drm_source:
Giulio Camuffo954f1832014-10-11 18:27:30 +03003431 wl_event_source_remove(b->drm_source);
Ander Conselvan de Oliveira4ade0e42014-04-17 13:08:45 +03003432err_udev_input:
Giulio Camuffo954f1832014-10-11 18:27:30 +03003433 udev_input_destroy(&b->input);
Kristian Høgsberg2bc5e8e2012-09-06 20:51:00 -04003434err_sprite:
Emmanuel Gil Peyrotb8347e32016-05-02 22:40:13 +01003435 if (b->gbm)
3436 gbm_device_destroy(b->gbm);
Giulio Camuffo954f1832014-10-11 18:27:30 +03003437 destroy_sprites(b);
Daniel Stonea96b93c2012-06-22 14:04:37 +01003438err_udev_dev:
3439 udev_device_unref(drm_device);
Kristian Høgsberg3f495872013-09-18 23:00:17 -07003440err_launcher:
Giulio Camuffo954f1832014-10-11 18:27:30 +03003441 weston_launcher_destroy(compositor->launcher);
Daniel Stonea96b93c2012-06-22 14:04:37 +01003442err_udev:
Giulio Camuffo954f1832014-10-11 18:27:30 +03003443 udev_unref(b->udev);
Daniel Stonea96b93c2012-06-22 14:04:37 +01003444err_compositor:
Giulio Camuffo954f1832014-10-11 18:27:30 +03003445 weston_compositor_shutdown(compositor);
Giulio Camuffo954f1832014-10-11 18:27:30 +03003446 free(b);
Daniel Stonea96b93c2012-06-22 14:04:37 +01003447 return NULL;
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04003448}
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003449
Giulio Camuffo1c0e40d2016-04-29 15:40:34 -07003450static void
3451config_init_to_defaults(struct weston_drm_backend_config *config)
3452{
3453}
3454
Giulio Camuffo954f1832014-10-11 18:27:30 +03003455WL_EXPORT int
Quentin Glidic23e1d6f2016-12-02 14:08:44 +01003456weston_backend_init(struct weston_compositor *compositor,
3457 struct weston_backend_config *config_base)
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003458{
Giulio Camuffo954f1832014-10-11 18:27:30 +03003459 struct drm_backend *b;
Giulio Camuffo1c0e40d2016-04-29 15:40:34 -07003460 struct weston_drm_backend_config config = {{ 0, }};
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003461
Giulio Camuffo1c0e40d2016-04-29 15:40:34 -07003462 if (config_base == NULL ||
3463 config_base->struct_version != WESTON_DRM_BACKEND_CONFIG_VERSION ||
3464 config_base->struct_size > sizeof(struct weston_drm_backend_config)) {
3465 weston_log("drm backend config structure is invalid\n");
3466 return -1;
3467 }
Benjamin Franzke117483d2011-08-30 11:38:26 +02003468
Giulio Camuffo1c0e40d2016-04-29 15:40:34 -07003469 config_init_to_defaults(&config);
3470 memcpy(&config, config_base, config_base->struct_size);
Kristian Høgsbergd8e98332013-10-16 16:15:11 -07003471
Giulio Camuffo1c0e40d2016-04-29 15:40:34 -07003472 b = drm_backend_create(compositor, &config);
Giulio Camuffo954f1832014-10-11 18:27:30 +03003473 if (b == NULL)
3474 return -1;
Giulio Camuffo1c0e40d2016-04-29 15:40:34 -07003475
Giulio Camuffo954f1832014-10-11 18:27:30 +03003476 return 0;
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003477}