blob: 136d517e354db7c2ecb35ab9312fdc893544dbd5 [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 *
Kristian Høgsberg96aa7da2011-09-15 15:43:14 -04005 * Permission to use, copy, modify, distribute, and sell this software and
6 * its documentation for any purpose is hereby granted without fee, provided
7 * that the above copyright notice appear in all copies and that both that
8 * copyright notice and this permission notice appear in supporting
9 * documentation, and that the name of the copyright holders not be used in
10 * advertising or publicity pertaining to distribution of the software
11 * without specific, written prior permission. The copyright holders make
12 * no representations about the suitability of this software for any
13 * purpose. It is provided "as is" without express or implied warranty.
Kristian Høgsbergfc783d42010-06-11 12:56:24 -040014 *
Kristian Høgsberg96aa7da2011-09-15 15:43:14 -040015 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
16 * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
17 * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
18 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
19 * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
20 * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
21 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
Kristian Høgsbergfc783d42010-06-11 12:56:24 -040022 */
23
Daniel Stonec228e232013-05-22 18:03:19 +030024#include "config.h"
Kristian Høgsberg0b9334a2011-04-12 11:34:32 -040025
Jesse Barnes58ef3792012-02-23 09:45:49 -050026#include <errno.h>
Kristian Høgsbergfc783d42010-06-11 12:56:24 -040027#include <stdlib.h>
Richard Hughes2b2092a2013-04-24 14:58:02 +010028#include <ctype.h>
Kristian Høgsbergfc783d42010-06-11 12:56:24 -040029#include <string.h>
30#include <fcntl.h>
31#include <unistd.h>
Kristian Høgsberg5d1c0c52012-04-10 00:11:50 -040032#include <linux/input.h>
Kristian Høgsberg3f495872013-09-18 23:00:17 -070033#include <linux/vt.h>
Ander Conselvan de Oliveirafd1f4c62012-06-26 17:09:14 +030034#include <assert.h>
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +020035#include <sys/mman.h>
Ander Conselvan de Oliveira97f29522013-10-14 15:57:11 +030036#include <dlfcn.h>
Ander Conselvan de Oliveira95eb3a22013-05-07 14:16:59 +030037#include <time.h>
Kristian Høgsbergfc783d42010-06-11 12:56:24 -040038
Benjamin Franzkec649a922011-03-02 11:56:04 +010039#include <xf86drm.h>
40#include <xf86drmMode.h>
Jesse Barnes58ef3792012-02-23 09:45:49 -050041#include <drm_fourcc.h>
Benjamin Franzkec649a922011-03-02 11:56:04 +010042
Benjamin Franzke060cf802011-04-30 09:32:11 +020043#include <gbm.h>
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +020044#include <libbacklight.h>
Pekka Paalanen33156972012-08-03 13:30:30 -040045#include <libudev.h>
Benjamin Franzke060cf802011-04-30 09:32:11 +020046
Kristian Høgsbergfc783d42010-06-11 12:56:24 -040047#include "compositor.h"
John Kåre Alsaker30d2b1f2012-11-13 19:10:28 +010048#include "gl-renderer.h"
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +020049#include "pixman-renderer.h"
Kristian Høgsberg98cfea62013-02-18 16:15:53 -050050#include "udev-seat.h"
Benjamin Franzkebfeda132012-01-30 14:04:04 +010051#include "launcher-util.h"
Ander Conselvan de Oliveira6aae4d32013-08-23 17:15:48 +030052#include "vaapi-recorder.h"
Kristian Høgsbergfc783d42010-06-11 12:56:24 -040053
Ander Conselvan de Oliveira95eb3a22013-05-07 14:16:59 +030054#ifndef DRM_CAP_TIMESTAMP_MONOTONIC
55#define DRM_CAP_TIMESTAMP_MONOTONIC 0x6
56#endif
57
Kristian Høgsberg061c4252012-06-28 11:28:15 -040058static int option_current_mode = 0;
Scott Moreau8ab5d452012-07-30 19:51:08 -060059
60enum output_config {
61 OUTPUT_CONFIG_INVALID = 0,
62 OUTPUT_CONFIG_OFF,
63 OUTPUT_CONFIG_PREFERRED,
64 OUTPUT_CONFIG_CURRENT,
Scott Moreau8f37e0b2012-07-31 15:30:41 -060065 OUTPUT_CONFIG_MODE,
66 OUTPUT_CONFIG_MODELINE
Scott Moreau8ab5d452012-07-30 19:51:08 -060067};
68
Kristian Høgsbergce5325d2010-06-14 11:54:00 -040069struct drm_compositor {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -050070 struct weston_compositor base;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -040071
72 struct udev *udev;
73 struct wl_event_source *drm_source;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -040074
Benjamin Franzke9c26ff32011-03-15 15:08:41 +010075 struct udev_monitor *udev_monitor;
76 struct wl_event_source *udev_drm_source;
77
Benjamin Franzke2af7f102011-03-02 11:14:59 +010078 struct {
David Herrmannd7488c22012-03-11 20:05:21 +010079 int id;
Benjamin Franzke2af7f102011-03-02 11:14:59 +010080 int fd;
Ander Conselvan de Oliveira6aae4d32013-08-23 17:15:48 +030081 char *filename;
Benjamin Franzke2af7f102011-03-02 11:14:59 +010082 } drm;
Benjamin Franzke060cf802011-04-30 09:32:11 +020083 struct gbm_device *gbm;
Jesse Barnes58ef3792012-02-23 09:45:49 -050084 uint32_t *crtcs;
85 int num_crtcs;
Marty Jack13d9db22011-02-09 19:01:42 -050086 uint32_t crtc_allocator;
Benjamin Franzke9c26ff32011-03-15 15:08:41 +010087 uint32_t connector_allocator;
Kristian Høgsberg61741a22013-09-17 16:02:57 -070088 struct wl_listener session_listener;
Kristian Høgsbergc3ea26c2013-09-25 15:46:42 -070089 uint32_t format;
Pekka Paalanenbce2d3f2011-12-02 13:07:27 +020090
Rob Clark4339add2012-08-09 14:18:28 -050091 /* we need these parameters in order to not fail drmModeAddFB2()
92 * due to out of bounds dimensions, and then mistakenly set
93 * sprites_are_broken:
94 */
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +020095 uint32_t min_width, max_width;
96 uint32_t min_height, max_height;
97 int no_addfb2;
Rob Clark4339add2012-08-09 14:18:28 -050098
Jesse Barnes58ef3792012-02-23 09:45:49 -050099 struct wl_list sprite_list;
Kristian Høgsberg65bec242012-03-05 19:57:35 -0500100 int sprites_are_broken;
Ander Conselvan de Oliveirada1c9082012-10-31 17:55:46 +0200101 int sprites_hidden;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500102
Rob Clarkab5b1e32012-08-09 13:24:45 -0500103 int cursors_are_broken;
104
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +0200105 int use_pixman;
106
Pekka Paalanenbce2d3f2011-12-02 13:07:27 +0200107 uint32_t prev_state;
Ander Conselvan de Oliveira95eb3a22013-05-07 14:16:59 +0300108
109 clockid_t clock;
Rob Bradfordd355b802013-05-31 18:09:55 +0100110 struct udev_input input;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400111};
112
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -0400113struct drm_mode {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500114 struct weston_mode base;
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -0400115 drmModeModeInfo mode_info;
116};
117
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300118struct drm_output;
119
120struct drm_fb {
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300121 struct drm_output *output;
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +0200122 uint32_t fb_id, stride, handle, size;
123 int fd;
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300124 int is_client_buffer;
Pekka Paalanende685b82012-12-04 15:58:12 +0200125 struct weston_buffer_reference buffer_ref;
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +0200126
127 /* Used by gbm fbs */
128 struct gbm_bo *bo;
129
130 /* Used by dumb fbs */
131 void *map;
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300132};
133
Richard Hughes2b2092a2013-04-24 14:58:02 +0100134struct drm_edid {
135 char eisa_id[13];
136 char monitor_name[13];
137 char pnp_id[5];
138 char serial_number[13];
139};
140
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400141struct drm_output {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500142 struct weston_output base;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400143
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400144 uint32_t crtc_id;
Rob Clark5ca1a472012-08-08 20:27:37 -0500145 int pipe;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400146 uint32_t connector_id;
Matt Roper361d2ad2011-08-29 13:52:23 -0700147 drmModeCrtcPtr original_crtc;
Richard Hughes2b2092a2013-04-24 14:58:02 +0100148 struct drm_edid edid;
Ander Conselvan de Oliveiraa0a433a2013-06-04 16:24:04 +0300149 drmModePropertyPtr dpms_prop;
Benjamin Franzke1178a3c2011-04-10 16:49:52 +0200150
Ander Conselvan de Oliveiraa7326962012-06-26 17:09:13 +0300151 int vblank_pending;
152 int page_flip_pending;
Xiong Zhangabd5d472013-10-11 14:43:07 +0800153 int destroy_pending;
Ander Conselvan de Oliveiraa7326962012-06-26 17:09:13 +0300154
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -0400155 struct gbm_surface *surface;
Kristian Høgsberg8e1f77f2012-05-03 11:39:35 -0400156 struct gbm_bo *cursor_bo[2];
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400157 struct weston_plane cursor_plane;
158 struct weston_plane fb_plane;
Jason Ekstranda7af7042013-10-12 22:38:11 -0500159 struct weston_view *cursor_view;
Kristian Høgsberg5626d342012-08-03 11:50:05 -0400160 int current_cursor;
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300161 struct drm_fb *current, *next;
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +0200162 struct backlight *backlight;
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +0200163
164 struct drm_fb *dumb[2];
165 pixman_image_t *image[2];
166 int current_image;
167 pixman_region32_t previous_damage;
Ander Conselvan de Oliveira6aae4d32013-08-23 17:15:48 +0300168
169 struct vaapi_recorder *recorder;
170 struct wl_listener recorder_frame_listener;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400171};
172
Jesse Barnes58ef3792012-02-23 09:45:49 -0500173/*
174 * An output has a primary display plane plus zero or more sprites for
175 * blending display contents.
176 */
177struct drm_sprite {
178 struct wl_list link;
179
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400180 struct weston_plane plane;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500181
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200182 struct drm_fb *current, *next;
Ander Conselvan de Oliveiraa7326962012-06-26 17:09:13 +0300183 struct drm_output *output;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500184 struct drm_compositor *compositor;
185
Jesse Barnes58ef3792012-02-23 09:45:49 -0500186 uint32_t possible_crtcs;
187 uint32_t plane_id;
188 uint32_t count_formats;
189
190 int32_t src_x, src_y;
191 uint32_t src_w, src_h;
192 uint32_t dest_x, dest_y;
193 uint32_t dest_w, dest_h;
194
195 uint32_t formats[];
196};
197
Kristian Høgsbergd8e98332013-10-16 16:15:11 -0700198struct drm_parameters {
199 int connector;
200 int tty;
201 int use_pixman;
202 const char *seat_id;
203};
204
Ander Conselvan de Oliveira97f29522013-10-14 15:57:11 +0300205static struct gl_renderer_interface *gl_renderer;
206
Kristian Høgsberg98cfea62013-02-18 16:15:53 -0500207static const char default_seat[] = "seat0";
Pekka Paalanen33156972012-08-03 13:30:30 -0400208
Kristian Høgsberg5626d342012-08-03 11:50:05 -0400209static void
210drm_output_set_cursor(struct drm_output *output);
Kristian Høgsberg5626d342012-08-03 11:50:05 -0400211
Jesse Barnes58ef3792012-02-23 09:45:49 -0500212static int
Jesse Barnes58ef3792012-02-23 09:45:49 -0500213drm_sprite_crtc_supported(struct weston_output *output_base, uint32_t supported)
214{
215 struct weston_compositor *ec = output_base->compositor;
216 struct drm_compositor *c =(struct drm_compositor *) ec;
217 struct drm_output *output = (struct drm_output *) output_base;
218 int crtc;
219
220 for (crtc = 0; crtc < c->num_crtcs; crtc++) {
221 if (c->crtcs[crtc] != output->crtc_id)
222 continue;
223
224 if (supported & (1 << crtc))
225 return -1;
226 }
227
228 return 0;
229}
230
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300231static void
232drm_fb_destroy_callback(struct gbm_bo *bo, void *data)
233{
234 struct drm_fb *fb = data;
235 struct gbm_device *gbm = gbm_bo_get_device(bo);
236
237 if (fb->fb_id)
238 drmModeRmFB(gbm_device_get_fd(gbm), fb->fb_id);
239
Pekka Paalanende685b82012-12-04 15:58:12 +0200240 weston_buffer_reference(&fb->buffer_ref, NULL);
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300241
242 free(data);
243}
244
245static struct drm_fb *
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +0200246drm_fb_create_dumb(struct drm_compositor *ec, unsigned width, unsigned height)
247{
248 struct drm_fb *fb;
249 int ret;
250
251 struct drm_mode_create_dumb create_arg;
252 struct drm_mode_destroy_dumb destroy_arg;
253 struct drm_mode_map_dumb map_arg;
254
Peter Huttererf3d62272013-08-08 11:57:05 +1000255 fb = zalloc(sizeof *fb);
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +0200256 if (!fb)
257 return NULL;
258
Kristian Høgsbergac6104e2013-08-21 22:14:14 -0700259 memset(&create_arg, 0, sizeof create_arg);
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +0200260 create_arg.bpp = 32;
261 create_arg.width = width;
262 create_arg.height = height;
263
264 ret = drmIoctl(ec->drm.fd, DRM_IOCTL_MODE_CREATE_DUMB, &create_arg);
265 if (ret)
266 goto err_fb;
267
268 fb->handle = create_arg.handle;
269 fb->stride = create_arg.pitch;
270 fb->size = create_arg.size;
271 fb->fd = ec->drm.fd;
272
273 ret = drmModeAddFB(ec->drm.fd, width, height, 24, 32,
274 fb->stride, fb->handle, &fb->fb_id);
275 if (ret)
276 goto err_bo;
277
Kristian Høgsbergac6104e2013-08-21 22:14:14 -0700278 memset(&map_arg, 0, sizeof map_arg);
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +0200279 map_arg.handle = fb->handle;
Chris Michaeleb2074a2013-05-01 21:26:02 -0400280 ret = drmIoctl(fb->fd, DRM_IOCTL_MODE_MAP_DUMB, &map_arg);
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +0200281 if (ret)
282 goto err_add_fb;
283
284 fb->map = mmap(0, fb->size, PROT_WRITE,
285 MAP_SHARED, ec->drm.fd, map_arg.offset);
286 if (fb->map == MAP_FAILED)
287 goto err_add_fb;
288
289 return fb;
290
291err_add_fb:
292 drmModeRmFB(ec->drm.fd, fb->fb_id);
293err_bo:
294 memset(&destroy_arg, 0, sizeof(destroy_arg));
295 destroy_arg.handle = create_arg.handle;
296 drmIoctl(ec->drm.fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy_arg);
297err_fb:
298 free(fb);
299 return NULL;
300}
301
302static void
303drm_fb_destroy_dumb(struct drm_fb *fb)
304{
305 struct drm_mode_destroy_dumb destroy_arg;
306
307 if (!fb->map)
308 return;
309
310 if (fb->fb_id)
311 drmModeRmFB(fb->fd, fb->fb_id);
312
313 weston_buffer_reference(&fb->buffer_ref, NULL);
314
315 munmap(fb->map, fb->size);
316
317 memset(&destroy_arg, 0, sizeof(destroy_arg));
318 destroy_arg.handle = fb->handle;
319 drmIoctl(fb->fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy_arg);
320
321 free(fb);
322}
323
324static struct drm_fb *
Kristian Høgsberga2f84cc2012-12-07 12:37:58 -0500325drm_fb_get_from_bo(struct gbm_bo *bo,
326 struct drm_compositor *compositor, uint32_t format)
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300327{
328 struct drm_fb *fb = gbm_bo_get_user_data(bo);
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +0200329 uint32_t width, height;
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200330 uint32_t handles[4], pitches[4], offsets[4];
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300331 int ret;
332
333 if (fb)
334 return fb;
335
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +0200336 fb = calloc(1, sizeof *fb);
337 if (!fb)
338 return NULL;
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300339
340 fb->bo = bo;
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300341
342 width = gbm_bo_get_width(bo);
343 height = gbm_bo_get_height(bo);
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +0200344 fb->stride = gbm_bo_get_stride(bo);
345 fb->handle = gbm_bo_get_handle(bo).u32;
346 fb->size = fb->stride * height;
347 fb->fd = compositor->drm.fd;
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300348
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200349 if (compositor->min_width > width || width > compositor->max_width ||
350 compositor->min_height > height ||
351 height > compositor->max_height) {
352 weston_log("bo geometry out of bounds\n");
353 goto err_free;
354 }
355
356 ret = -1;
357
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200358 if (format && !compositor->no_addfb2) {
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +0200359 handles[0] = fb->handle;
360 pitches[0] = fb->stride;
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200361 offsets[0] = 0;
362
363 ret = drmModeAddFB2(compositor->drm.fd, width, height,
364 format, handles, pitches, offsets,
365 &fb->fb_id, 0);
366 if (ret) {
367 weston_log("addfb2 failed: %m\n");
368 compositor->no_addfb2 = 1;
369 compositor->sprites_are_broken = 1;
370 }
371 }
372
373 if (ret)
374 ret = drmModeAddFB(compositor->drm.fd, width, height, 24, 32,
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +0200375 fb->stride, fb->handle, &fb->fb_id);
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200376
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300377 if (ret) {
Martin Minarik6d118362012-06-07 18:01:59 +0200378 weston_log("failed to create kms fb: %m\n");
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200379 goto err_free;
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300380 }
381
382 gbm_bo_set_user_data(bo, fb, drm_fb_destroy_callback);
383
384 return fb;
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200385
386err_free:
387 free(fb);
388 return NULL;
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300389}
390
391static void
Jason Ekstrand6bd62942013-06-20 20:38:23 -0500392drm_fb_set_buffer(struct drm_fb *fb, struct weston_buffer *buffer)
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200393{
Pekka Paalanende685b82012-12-04 15:58:12 +0200394 assert(fb->buffer_ref.buffer == NULL);
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200395
396 fb->is_client_buffer = 1;
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200397
Pekka Paalanende685b82012-12-04 15:58:12 +0200398 weston_buffer_reference(&fb->buffer_ref, buffer);
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200399}
400
Ander Conselvan de Oliveira526d4612013-01-25 15:13:03 +0200401static void
402drm_output_release_fb(struct drm_output *output, struct drm_fb *fb)
403{
404 if (!fb)
405 return;
406
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +0200407 if (fb->map &&
408 (fb != output->dumb[0] && fb != output->dumb[1])) {
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +0200409 drm_fb_destroy_dumb(fb);
410 } else if (fb->bo) {
Ander Conselvan de Oliveira526d4612013-01-25 15:13:03 +0200411 if (fb->is_client_buffer)
412 gbm_bo_destroy(fb->bo);
413 else
414 gbm_surface_release_buffer(output->surface,
Jason Ekstrand3ec57f52013-11-14 20:52:35 -0600415 fb->bo);
Ander Conselvan de Oliveira526d4612013-01-25 15:13:03 +0200416 }
417}
418
Kristian Høgsberga2f84cc2012-12-07 12:37:58 -0500419static uint32_t
Ander Conselvan de Oliveirae9209412012-11-30 17:34:22 +0200420drm_output_check_scanout_format(struct drm_output *output,
421 struct weston_surface *es, struct gbm_bo *bo)
422{
Kristian Høgsberg3f97b342013-10-16 16:08:57 -0700423 struct drm_compositor *c =
424 (struct drm_compositor *) output->base.compositor;
Ander Conselvan de Oliveirae9209412012-11-30 17:34:22 +0200425 uint32_t format;
426 pixman_region32_t r;
427
428 format = gbm_bo_get_format(bo);
429
Kristian Høgsberg3f97b342013-10-16 16:08:57 -0700430 if (format == GBM_FORMAT_ARGB8888) {
431 /* We can scanout an ARGB buffer if the surface's
432 * opaque region covers the whole output, but we have
433 * to use XRGB as the KMS format code. */
Ander Conselvan de Oliveirae9209412012-11-30 17:34:22 +0200434 pixman_region32_init(&r);
435 pixman_region32_subtract(&r, &output->base.region,
436 &es->opaque);
437
438 if (!pixman_region32_not_empty(&r))
Kristian Høgsberga2f84cc2012-12-07 12:37:58 -0500439 format = GBM_FORMAT_XRGB8888;
Ander Conselvan de Oliveirae9209412012-11-30 17:34:22 +0200440
441 pixman_region32_fini(&r);
Kristian Høgsberga2f84cc2012-12-07 12:37:58 -0500442 }
Kristian Høgsberg3f97b342013-10-16 16:08:57 -0700443
444 if (c->format == format)
445 return format;
446
447 return 0;
Ander Conselvan de Oliveirae9209412012-11-30 17:34:22 +0200448}
449
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400450static struct weston_plane *
Jason Ekstranda7af7042013-10-12 22:38:11 -0500451drm_output_prepare_scanout_view(struct weston_output *_output,
452 struct weston_view *ev)
Kristian Høgsberg5f5e42e2012-01-25 23:59:42 -0500453{
Kristian Høgsberg6143f7d2012-07-14 00:31:32 -0400454 struct drm_output *output = (struct drm_output *) _output;
Kristian Høgsberg5f5e42e2012-01-25 23:59:42 -0500455 struct drm_compositor *c =
456 (struct drm_compositor *) output->base.compositor;
Jason Ekstranda7af7042013-10-12 22:38:11 -0500457 struct weston_buffer *buffer = ev->surface->buffer_ref.buffer;
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300458 struct gbm_bo *bo;
Kristian Høgsberga2f84cc2012-12-07 12:37:58 -0500459 uint32_t format;
Kristian Høgsberg5f5e42e2012-01-25 23:59:42 -0500460
Jason Ekstranda7af7042013-10-12 22:38:11 -0500461 if (ev->geometry.x != output->base.x ||
462 ev->geometry.y != output->base.y ||
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +0200463 buffer == NULL || c->gbm == NULL ||
Hardeningff39efa2013-09-18 23:56:35 +0200464 buffer->width != output->base.current_mode->width ||
465 buffer->height != output->base.current_mode->height ||
Pekka Paalanen1fd9c0f2013-11-26 18:19:41 +0100466 output->base.transform != ev->surface->buffer_viewport.transform ||
Jason Ekstranda7af7042013-10-12 22:38:11 -0500467 ev->transform.enabled)
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400468 return NULL;
Kristian Høgsberg5f5e42e2012-01-25 23:59:42 -0500469
Kristian Høgsberg2763a2e2012-07-13 22:54:43 -0400470 bo = gbm_bo_import(c->gbm, GBM_BO_IMPORT_WL_BUFFER,
Kristian Høgsberg63996462013-09-03 22:27:08 -0700471 buffer->resource, GBM_BO_USE_SCANOUT);
Kristian Høgsberg5f5e42e2012-01-25 23:59:42 -0500472
Rob Bradford9b101872012-09-14 23:25:41 +0100473 /* Unable to use the buffer for scanout */
474 if (!bo)
475 return NULL;
476
Jason Ekstranda7af7042013-10-12 22:38:11 -0500477 format = drm_output_check_scanout_format(output, ev->surface, bo);
Kristian Høgsberga2f84cc2012-12-07 12:37:58 -0500478 if (format == 0) {
Ander Conselvan de Oliveiraa64b15d2012-05-02 16:42:22 +0300479 gbm_bo_destroy(bo);
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400480 return NULL;
Ander Conselvan de Oliveiraa64b15d2012-05-02 16:42:22 +0300481 }
482
Kristian Høgsberga2f84cc2012-12-07 12:37:58 -0500483 output->next = drm_fb_get_from_bo(bo, c, format);
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300484 if (!output->next) {
485 gbm_bo_destroy(bo);
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400486 return NULL;
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300487 }
Kristian Høgsberg5f5e42e2012-01-25 23:59:42 -0500488
Pekka Paalanende685b82012-12-04 15:58:12 +0200489 drm_fb_set_buffer(output->next, buffer);
Kristian Høgsberg5f5e42e2012-01-25 23:59:42 -0500490
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400491 return &output->fb_plane;
Kristian Høgsberg5f5e42e2012-01-25 23:59:42 -0500492}
493
Kristian Høgsberg06cf6b02012-01-25 23:47:45 -0500494static void
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +0200495drm_output_render_gl(struct drm_output *output, pixman_region32_t *damage)
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -0400496{
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200497 struct drm_compositor *c =
498 (struct drm_compositor *) output->base.compositor;
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300499 struct gbm_bo *bo;
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -0400500
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200501 c->base.renderer->repaint_output(&output->base, damage);
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -0400502
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300503 bo = gbm_surface_lock_front_buffer(output->surface);
504 if (!bo) {
Martin Minarik6d118362012-06-07 18:01:59 +0200505 weston_log("failed to lock front buffer: %m\n");
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -0400506 return;
507 }
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300508
Kristian Høgsbergc3ea26c2013-09-25 15:46:42 -0700509 output->next = drm_fb_get_from_bo(bo, c, c->format);
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300510 if (!output->next) {
Martin Minarik6d118362012-06-07 18:01:59 +0200511 weston_log("failed to get drm_fb for bo\n");
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300512 gbm_surface_release_buffer(output->surface, bo);
513 return;
514 }
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -0400515}
516
517static void
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +0200518drm_output_render_pixman(struct drm_output *output, pixman_region32_t *damage)
519{
520 struct weston_compositor *ec = output->base.compositor;
521 pixman_region32_t total_damage, previous_damage;
522
523 pixman_region32_init(&total_damage);
524 pixman_region32_init(&previous_damage);
525
526 pixman_region32_copy(&previous_damage, damage);
527
528 pixman_region32_union(&total_damage, damage, &output->previous_damage);
529 pixman_region32_copy(&output->previous_damage, &previous_damage);
530
531 output->current_image ^= 1;
532
533 output->next = output->dumb[output->current_image];
534 pixman_renderer_output_set_buffer(&output->base,
535 output->image[output->current_image]);
536
537 ec->renderer->repaint_output(&output->base, &total_damage);
538
539 pixman_region32_fini(&total_damage);
540 pixman_region32_fini(&previous_damage);
541}
542
543static void
544drm_output_render(struct drm_output *output, pixman_region32_t *damage)
545{
546 struct drm_compositor *c =
547 (struct drm_compositor *) output->base.compositor;
548
549 if (c->use_pixman)
550 drm_output_render_pixman(output, damage);
551 else
552 drm_output_render_gl(output, damage);
553
554 pixman_region32_subtract(&c->base.primary_plane.damage,
555 &c->base.primary_plane.damage, damage);
556}
557
558static void
Richard Hughese7299962013-05-01 21:52:12 +0100559drm_output_set_gamma(struct weston_output *output_base,
560 uint16_t size, uint16_t *r, uint16_t *g, uint16_t *b)
561{
562 int rc;
563 struct drm_output *output = (struct drm_output *) output_base;
564 struct drm_compositor *compositor = (struct drm_compositor *) output->base.compositor;
565
566 /* check */
567 if (output_base->gamma_size != size)
568 return;
569 if (!output->original_crtc)
570 return;
571
572 rc = drmModeCrtcSetGamma(compositor->drm.fd,
573 output->crtc_id,
574 size, r, g, b);
575 if (rc)
576 weston_log("set gamma failed: %m\n");
577}
578
David Herrmann1edf44c2013-10-22 17:11:26 +0200579static int
Kristian Høgsberg6ddcdae2012-02-28 22:31:58 -0500580drm_output_repaint(struct weston_output *output_base,
Kristian Høgsbergd7c17262012-09-05 21:54:15 -0400581 pixman_region32_t *damage)
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +0100582{
583 struct drm_output *output = (struct drm_output *) output_base;
Kristian Høgsberg06cf6b02012-01-25 23:47:45 -0500584 struct drm_compositor *compositor =
585 (struct drm_compositor *) output->base.compositor;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500586 struct drm_sprite *s;
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -0400587 struct drm_mode *mode;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500588 int ret = 0;
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +0100589
Xiong Zhangabd5d472013-10-11 14:43:07 +0800590 if (output->destroy_pending)
David Herrmann1edf44c2013-10-22 17:11:26 +0200591 return -1;
Xiong Zhangabd5d472013-10-11 14:43:07 +0800592
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300593 if (!output->next)
Kristian Høgsbergd7c17262012-09-05 21:54:15 -0400594 drm_output_render(output, damage);
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300595 if (!output->next)
David Herrmann1edf44c2013-10-22 17:11:26 +0200596 return -1;
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +0100597
Hardeningff39efa2013-09-18 23:56:35 +0200598 mode = container_of(output->base.current_mode, struct drm_mode, base);
Ander Conselvan de Oliveira65796812013-11-19 15:22:04 +0200599 if (!output->current ||
600 output->current->stride != output->next->stride) {
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -0400601 ret = drmModeSetCrtc(compositor->drm.fd, output->crtc_id,
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300602 output->next->fb_id, 0, 0,
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -0400603 &output->connector_id, 1,
604 &mode->mode_info);
605 if (ret) {
Martin Minarik6d118362012-06-07 18:01:59 +0200606 weston_log("set mode failed: %m\n");
David Herrmann1edf44c2013-10-22 17:11:26 +0200607 goto err_pageflip;
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -0400608 }
Ander Conselvan de Oliveira722a2d52013-06-04 16:24:05 +0300609 output_base->set_dpms(output_base, WESTON_DPMS_ON);
Benjamin Franzke1178a3c2011-04-10 16:49:52 +0200610 }
611
Kristian Høgsberg06cf6b02012-01-25 23:47:45 -0500612 if (drmModePageFlip(compositor->drm.fd, output->crtc_id,
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300613 output->next->fb_id,
Kristian Høgsberg54f14c32012-01-18 11:47:41 -0500614 DRM_MODE_PAGE_FLIP_EVENT, output) < 0) {
Martin Minarik6d118362012-06-07 18:01:59 +0200615 weston_log("queueing pageflip failed: %m\n");
David Herrmann1edf44c2013-10-22 17:11:26 +0200616 goto err_pageflip;
Kristian Høgsberg54f14c32012-01-18 11:47:41 -0500617 }
Benjamin Franzkeec4d3422011-03-14 12:07:26 +0100618
Ander Conselvan de Oliveiraa7326962012-06-26 17:09:13 +0300619 output->page_flip_pending = 1;
620
Kristian Høgsberg5626d342012-08-03 11:50:05 -0400621 drm_output_set_cursor(output);
622
Jesse Barnes58ef3792012-02-23 09:45:49 -0500623 /*
624 * Now, update all the sprite surfaces
625 */
626 wl_list_for_each(s, &compositor->sprite_list, link) {
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200627 uint32_t flags = 0, fb_id = 0;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500628 drmVBlank vbl = {
629 .request.type = DRM_VBLANK_RELATIVE | DRM_VBLANK_EVENT,
630 .request.sequence = 1,
631 };
632
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200633 if ((!s->current && !s->next) ||
Ander Conselvan de Oliveira2f7a30b2012-11-09 14:19:03 +0200634 !drm_sprite_crtc_supported(output_base, s->possible_crtcs))
Jesse Barnes58ef3792012-02-23 09:45:49 -0500635 continue;
636
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200637 if (s->next && !compositor->sprites_hidden)
638 fb_id = s->next->fb_id;
639
Jesse Barnes58ef3792012-02-23 09:45:49 -0500640 ret = drmModeSetPlane(compositor->drm.fd, s->plane_id,
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200641 output->crtc_id, fb_id, flags,
Jesse Barnes58ef3792012-02-23 09:45:49 -0500642 s->dest_x, s->dest_y,
643 s->dest_w, s->dest_h,
644 s->src_x, s->src_y,
645 s->src_w, s->src_h);
646 if (ret)
Martin Minarik6d118362012-06-07 18:01:59 +0200647 weston_log("setplane failed: %d: %s\n",
Jesse Barnes58ef3792012-02-23 09:45:49 -0500648 ret, strerror(errno));
649
Rob Clark5ca1a472012-08-08 20:27:37 -0500650 if (output->pipe > 0)
651 vbl.request.type |= DRM_VBLANK_SECONDARY;
652
Jesse Barnes58ef3792012-02-23 09:45:49 -0500653 /*
654 * Queue a vblank signal so we know when the surface
655 * becomes active on the display or has been replaced.
656 */
657 vbl.request.signal = (unsigned long)s;
658 ret = drmWaitVBlank(compositor->drm.fd, &vbl);
659 if (ret) {
Martin Minarik6d118362012-06-07 18:01:59 +0200660 weston_log("vblank event request failed: %d: %s\n",
Jesse Barnes58ef3792012-02-23 09:45:49 -0500661 ret, strerror(errno));
662 }
Ander Conselvan de Oliveiraa7326962012-06-26 17:09:13 +0300663
664 s->output = output;
665 output->vblank_pending = 1;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500666 }
667
David Herrmann1edf44c2013-10-22 17:11:26 +0200668 return 0;
669
670err_pageflip:
671 if (output->next) {
672 drm_output_release_fb(output, output->next);
673 output->next = NULL;
674 }
675
676 return -1;
Kristian Høgsbergfc783d42010-06-11 12:56:24 -0400677}
678
679static void
Jonas Ådahle5a12252013-04-05 23:07:11 +0200680drm_output_start_repaint_loop(struct weston_output *output_base)
681{
682 struct drm_output *output = (struct drm_output *) output_base;
683 struct drm_compositor *compositor = (struct drm_compositor *)
684 output_base->compositor;
685 uint32_t fb_id;
David Herrmann3c688c52013-10-22 17:11:25 +0200686 uint32_t msec;
Ander Conselvan de Oliveira95eb3a22013-05-07 14:16:59 +0300687 struct timespec ts;
688
Xiong Zhangabd5d472013-10-11 14:43:07 +0800689 if (output->destroy_pending)
690 return;
691
Ander Conselvan de Oliveira95eb3a22013-05-07 14:16:59 +0300692 if (!output->current) {
693 /* We can't page flip if there's no mode set */
David Herrmann3c688c52013-10-22 17:11:25 +0200694 goto finish_frame;
Ander Conselvan de Oliveira95eb3a22013-05-07 14:16:59 +0300695 }
696
697 fb_id = output->current->fb_id;
Jonas Ådahle5a12252013-04-05 23:07:11 +0200698
699 if (drmModePageFlip(compositor->drm.fd, output->crtc_id, fb_id,
700 DRM_MODE_PAGE_FLIP_EVENT, output) < 0) {
701 weston_log("queueing pageflip failed: %m\n");
David Herrmann3c688c52013-10-22 17:11:25 +0200702 goto finish_frame;
Jonas Ådahle5a12252013-04-05 23:07:11 +0200703 }
David Herrmann3c688c52013-10-22 17:11:25 +0200704
705 return;
706
707finish_frame:
708 /* if we cannot page-flip, immediately finish frame */
709 clock_gettime(compositor->clock, &ts);
710 msec = ts.tv_sec * 1000 + ts.tv_nsec / 1000000;
711 weston_output_finish_frame(output_base, msec);
Jonas Ådahle5a12252013-04-05 23:07:11 +0200712}
713
714static void
Jesse Barnes58ef3792012-02-23 09:45:49 -0500715vblank_handler(int fd, unsigned int frame, unsigned int sec, unsigned int usec,
716 void *data)
717{
718 struct drm_sprite *s = (struct drm_sprite *)data;
Ander Conselvan de Oliveiraa7326962012-06-26 17:09:13 +0300719 struct drm_output *output = s->output;
720 uint32_t msecs;
721
722 output->vblank_pending = 0;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500723
Ander Conselvan de Oliveira526d4612013-01-25 15:13:03 +0200724 drm_output_release_fb(output, s->current);
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200725 s->current = s->next;
726 s->next = NULL;
Ander Conselvan de Oliveiraa7326962012-06-26 17:09:13 +0300727
728 if (!output->page_flip_pending) {
729 msecs = sec * 1000 + usec / 1000;
730 weston_output_finish_frame(&output->base, msecs);
731 }
Jesse Barnes58ef3792012-02-23 09:45:49 -0500732}
733
734static void
Xiong Zhangabd5d472013-10-11 14:43:07 +0800735drm_output_destroy(struct weston_output *output_base);
736
737static void
Kristian Høgsbergfc783d42010-06-11 12:56:24 -0400738page_flip_handler(int fd, unsigned int frame,
739 unsigned int sec, unsigned int usec, void *data)
740{
Benjamin Franzke1178a3c2011-04-10 16:49:52 +0200741 struct drm_output *output = (struct drm_output *) data;
Kristian Høgsbergfc783d42010-06-11 12:56:24 -0400742 uint32_t msecs;
743
Jonas Ådahle5a12252013-04-05 23:07:11 +0200744 /* We don't set page_flip_pending on start_repaint_loop, in that case
745 * we just want to page flip to the current buffer to get an accurate
746 * timestamp */
747 if (output->page_flip_pending) {
748 drm_output_release_fb(output, output->current);
749 output->current = output->next;
750 output->next = NULL;
751 }
Ander Conselvan de Oliveiraa7326962012-06-26 17:09:13 +0300752
Jonas Ådahle5a12252013-04-05 23:07:11 +0200753 output->page_flip_pending = 0;
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -0400754
Xiong Zhangabd5d472013-10-11 14:43:07 +0800755 if (output->destroy_pending)
756 drm_output_destroy(&output->base);
757 else if (!output->vblank_pending) {
Ander Conselvan de Oliveiraa7326962012-06-26 17:09:13 +0300758 msecs = sec * 1000 + usec / 1000;
759 weston_output_finish_frame(&output->base, msecs);
Ander Conselvan de Oliveira6aae4d32013-08-23 17:15:48 +0300760
761 /* We can't call this from frame_notify, because the output's
762 * repaint needed flag is cleared just after that */
763 if (output->recorder)
764 weston_output_schedule_repaint(&output->base);
Ander Conselvan de Oliveiraa7326962012-06-26 17:09:13 +0300765 }
Benjamin Franzke1178a3c2011-04-10 16:49:52 +0200766}
767
Kristian Høgsberga2f84cc2012-12-07 12:37:58 -0500768static uint32_t
769drm_output_check_sprite_format(struct drm_sprite *s,
Jason Ekstranda7af7042013-10-12 22:38:11 -0500770 struct weston_view *ev, struct gbm_bo *bo)
Jesse Barnes58ef3792012-02-23 09:45:49 -0500771{
Kristian Høgsberga2f84cc2012-12-07 12:37:58 -0500772 uint32_t i, format;
773
774 format = gbm_bo_get_format(bo);
775
776 if (format == GBM_FORMAT_ARGB8888) {
777 pixman_region32_t r;
778
Kristian Høgsberg63093a32013-03-01 14:29:16 -0500779 pixman_region32_init_rect(&r, 0, 0,
Jason Ekstrand918f2dd2013-12-02 21:01:53 -0600780 ev->surface->width,
781 ev->surface->height);
Jason Ekstranda7af7042013-10-12 22:38:11 -0500782 pixman_region32_subtract(&r, &r, &ev->surface->opaque);
Kristian Høgsberga2f84cc2012-12-07 12:37:58 -0500783
784 if (!pixman_region32_not_empty(&r))
785 format = GBM_FORMAT_XRGB8888;
786
787 pixman_region32_fini(&r);
788 }
Jesse Barnes58ef3792012-02-23 09:45:49 -0500789
790 for (i = 0; i < s->count_formats; i++)
791 if (s->formats[i] == format)
Kristian Høgsberga2f84cc2012-12-07 12:37:58 -0500792 return format;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500793
794 return 0;
795}
796
797static int
Jason Ekstranda7af7042013-10-12 22:38:11 -0500798drm_view_transform_supported(struct weston_view *ev)
Jesse Barnes58ef3792012-02-23 09:45:49 -0500799{
Jason Ekstranda7af7042013-10-12 22:38:11 -0500800 return !ev->transform.enabled ||
801 (ev->transform.matrix.type < WESTON_MATRIX_TRANSFORM_ROTATE);
Jesse Barnes58ef3792012-02-23 09:45:49 -0500802}
803
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400804static struct weston_plane *
Jason Ekstranda7af7042013-10-12 22:38:11 -0500805drm_output_prepare_overlay_view(struct weston_output *output_base,
806 struct weston_view *ev)
Jesse Barnes58ef3792012-02-23 09:45:49 -0500807{
808 struct weston_compositor *ec = output_base->compositor;
809 struct drm_compositor *c =(struct drm_compositor *) ec;
810 struct drm_sprite *s;
811 int found = 0;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500812 struct gbm_bo *bo;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500813 pixman_region32_t dest_rect, src_rect;
Ander Conselvan de Oliveira409eebf2012-12-05 15:14:04 +0200814 pixman_box32_t *box, tbox;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500815 uint32_t format;
Kristian Høgsberg3b00bae2012-07-13 15:25:07 -0400816 wl_fixed_t sx1, sy1, sx2, sy2;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500817
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +0200818 if (c->gbm == NULL)
819 return NULL;
820
Pekka Paalanen1fd9c0f2013-11-26 18:19:41 +0100821 if (ev->surface->buffer_viewport.transform != output_base->transform)
Ander Conselvan de Oliveira2908a3d2012-11-27 17:03:43 +0200822 return NULL;
823
Pekka Paalanen1fd9c0f2013-11-26 18:19:41 +0100824 if (ev->surface->buffer_viewport.scale != output_base->current_scale)
Alexander Larssond9a7bb72013-05-22 14:41:39 +0200825 return NULL;
826
Kristian Høgsberg65bec242012-03-05 19:57:35 -0500827 if (c->sprites_are_broken)
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400828 return NULL;
Kristian Høgsberg65bec242012-03-05 19:57:35 -0500829
Jason Ekstranda7af7042013-10-12 22:38:11 -0500830 if (ev->output_mask != (1u << output_base->id))
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400831 return NULL;
Ander Conselvan de Oliveirad450b192012-06-26 17:09:12 +0300832
Jason Ekstranda7af7042013-10-12 22:38:11 -0500833 if (ev->surface->buffer_ref.buffer == NULL)
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400834 return NULL;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500835
Jason Ekstranda7af7042013-10-12 22:38:11 -0500836 if (ev->alpha != 1.0f)
Ville Syrjälä5a84f312012-11-16 11:48:46 +0200837 return NULL;
838
Jason Ekstranda7af7042013-10-12 22:38:11 -0500839 if (wl_shm_buffer_get(ev->surface->buffer_ref.buffer->resource))
Rob Clark702ffae2012-08-09 14:18:27 -0500840 return NULL;
841
Jason Ekstranda7af7042013-10-12 22:38:11 -0500842 if (!drm_view_transform_supported(ev))
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400843 return NULL;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500844
Jesse Barnes58ef3792012-02-23 09:45:49 -0500845 wl_list_for_each(s, &c->sprite_list, link) {
846 if (!drm_sprite_crtc_supported(output_base, s->possible_crtcs))
847 continue;
848
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200849 if (!s->next) {
Jesse Barnes58ef3792012-02-23 09:45:49 -0500850 found = 1;
851 break;
852 }
853 }
854
855 /* No sprites available */
856 if (!found)
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400857 return NULL;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500858
Kristian Høgsberg2763a2e2012-07-13 22:54:43 -0400859 bo = gbm_bo_import(c->gbm, GBM_BO_IMPORT_WL_BUFFER,
Jason Ekstranda7af7042013-10-12 22:38:11 -0500860 ev->surface->buffer_ref.buffer->resource,
Kristian Høgsberg63996462013-09-03 22:27:08 -0700861 GBM_BO_USE_SCANOUT);
Kristian Høgsberg2763a2e2012-07-13 22:54:43 -0400862 if (!bo)
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400863 return NULL;
Kristian Høgsberg2763a2e2012-07-13 22:54:43 -0400864
Jason Ekstranda7af7042013-10-12 22:38:11 -0500865 format = drm_output_check_sprite_format(s, ev, bo);
Kristian Høgsberga2f84cc2012-12-07 12:37:58 -0500866 if (format == 0) {
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200867 gbm_bo_destroy(bo);
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400868 return NULL;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500869 }
870
Ander Conselvan de Oliveiraca5c6ae2012-12-07 13:18:11 +0200871 s->next = drm_fb_get_from_bo(bo, c, format);
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200872 if (!s->next) {
873 gbm_bo_destroy(bo);
874 return NULL;
875 }
876
Jason Ekstranda7af7042013-10-12 22:38:11 -0500877 drm_fb_set_buffer(s->next, ev->surface->buffer_ref.buffer);
Jesse Barnes58ef3792012-02-23 09:45:49 -0500878
Jason Ekstranda7af7042013-10-12 22:38:11 -0500879 box = pixman_region32_extents(&ev->transform.boundingbox);
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400880 s->plane.x = box->x1;
881 s->plane.y = box->y1;
882
Jesse Barnes58ef3792012-02-23 09:45:49 -0500883 /*
884 * Calculate the source & dest rects properly based on actual
Martin Olsson3b132e32012-09-29 15:13:56 +0200885 * position (note the caller has called weston_surface_update_transform()
Jesse Barnes58ef3792012-02-23 09:45:49 -0500886 * for us already).
887 */
888 pixman_region32_init(&dest_rect);
Jason Ekstranda7af7042013-10-12 22:38:11 -0500889 pixman_region32_intersect(&dest_rect, &ev->transform.boundingbox,
Jesse Barnes58ef3792012-02-23 09:45:49 -0500890 &output_base->region);
891 pixman_region32_translate(&dest_rect, -output_base->x, -output_base->y);
892 box = pixman_region32_extents(&dest_rect);
Ander Conselvan de Oliveira409eebf2012-12-05 15:14:04 +0200893 tbox = weston_transformed_rect(output_base->width,
894 output_base->height,
Alexander Larsson4ea95522013-05-22 14:41:37 +0200895 output_base->transform,
Hardeningff39efa2013-09-18 23:56:35 +0200896 output_base->current_scale,
Alexander Larssond9a7bb72013-05-22 14:41:39 +0200897 *box);
Ander Conselvan de Oliveira409eebf2012-12-05 15:14:04 +0200898 s->dest_x = tbox.x1;
899 s->dest_y = tbox.y1;
900 s->dest_w = tbox.x2 - tbox.x1;
901 s->dest_h = tbox.y2 - tbox.y1;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500902 pixman_region32_fini(&dest_rect);
903
904 pixman_region32_init(&src_rect);
Jason Ekstranda7af7042013-10-12 22:38:11 -0500905 pixman_region32_intersect(&src_rect, &ev->transform.boundingbox,
Jesse Barnes58ef3792012-02-23 09:45:49 -0500906 &output_base->region);
Jesse Barnes58ef3792012-02-23 09:45:49 -0500907 box = pixman_region32_extents(&src_rect);
Kristian Høgsberg3b00bae2012-07-13 15:25:07 -0400908
Jason Ekstranda7af7042013-10-12 22:38:11 -0500909 weston_view_from_global_fixed(ev,
910 wl_fixed_from_int(box->x1),
911 wl_fixed_from_int(box->y1),
912 &sx1, &sy1);
913 weston_view_from_global_fixed(ev,
914 wl_fixed_from_int(box->x2),
915 wl_fixed_from_int(box->y2),
916 &sx2, &sy2);
Kristian Høgsberg3b00bae2012-07-13 15:25:07 -0400917
918 if (sx1 < 0)
919 sx1 = 0;
920 if (sy1 < 0)
921 sy1 = 0;
Jason Ekstrand918f2dd2013-12-02 21:01:53 -0600922 if (sx2 > wl_fixed_from_int(ev->surface->width))
923 sx2 = wl_fixed_from_int(ev->surface->width);
924 if (sy2 > wl_fixed_from_int(ev->surface->height))
925 sy2 = wl_fixed_from_int(ev->surface->height);
Kristian Høgsberg3b00bae2012-07-13 15:25:07 -0400926
Ander Conselvan de Oliveira409eebf2012-12-05 15:14:04 +0200927 tbox.x1 = sx1;
928 tbox.y1 = sy1;
929 tbox.x2 = sx2;
930 tbox.y2 = sy2;
931
Jason Ekstrand918f2dd2013-12-02 21:01:53 -0600932 tbox = weston_transformed_rect(wl_fixed_from_int(ev->surface->width),
933 wl_fixed_from_int(ev->surface->height),
Pekka Paalanen1fd9c0f2013-11-26 18:19:41 +0100934 ev->surface->buffer_viewport.transform,
935 ev->surface->buffer_viewport.scale,
936 tbox);
Ander Conselvan de Oliveira409eebf2012-12-05 15:14:04 +0200937
938 s->src_x = tbox.x1 << 8;
939 s->src_y = tbox.y1 << 8;
940 s->src_w = (tbox.x2 - tbox.x1) << 8;
941 s->src_h = (tbox.y2 - tbox.y1) << 8;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500942 pixman_region32_fini(&src_rect);
943
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400944 return &s->plane;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500945}
946
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400947static struct weston_plane *
Jason Ekstranda7af7042013-10-12 22:38:11 -0500948drm_output_prepare_cursor_view(struct weston_output *output_base,
949 struct weston_view *ev)
Kristian Høgsbergd8bf90c2012-02-23 23:03:14 -0500950{
Kristian Høgsberg8a015802012-08-09 17:19:23 -0400951 struct drm_compositor *c =
952 (struct drm_compositor *) output_base->compositor;
Kristian Høgsberga6edab32012-07-14 01:06:28 -0400953 struct drm_output *output = (struct drm_output *) output_base;
Kristian Høgsberg5626d342012-08-03 11:50:05 -0400954
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +0200955 if (c->gbm == NULL)
956 return NULL;
Ander Conselvan de Oliveira2908a3d2012-11-27 17:03:43 +0200957 if (output->base.transform != WL_OUTPUT_TRANSFORM_NORMAL)
958 return NULL;
Jason Ekstranda7af7042013-10-12 22:38:11 -0500959 if (output->cursor_view)
Kristian Høgsberg5626d342012-08-03 11:50:05 -0400960 return NULL;
Jason Ekstranda7af7042013-10-12 22:38:11 -0500961 if (ev->output_mask != (1u << output_base->id))
Kristian Høgsberg5626d342012-08-03 11:50:05 -0400962 return NULL;
Rob Clarkab5b1e32012-08-09 13:24:45 -0500963 if (c->cursors_are_broken)
Kristian Høgsberg8a015802012-08-09 17:19:23 -0400964 return NULL;
Jason Ekstranda7af7042013-10-12 22:38:11 -0500965 if (ev->surface->buffer_ref.buffer == NULL ||
966 !wl_shm_buffer_get(ev->surface->buffer_ref.buffer->resource) ||
Jason Ekstrand918f2dd2013-12-02 21:01:53 -0600967 ev->surface->width > 64 || ev->surface->height > 64)
Kristian Høgsberg5626d342012-08-03 11:50:05 -0400968 return NULL;
969
Jason Ekstranda7af7042013-10-12 22:38:11 -0500970 output->cursor_view = ev;
Kristian Høgsberg5626d342012-08-03 11:50:05 -0400971
972 return &output->cursor_plane;
973}
974
975static void
976drm_output_set_cursor(struct drm_output *output)
977{
Jason Ekstranda7af7042013-10-12 22:38:11 -0500978 struct weston_view *ev = output->cursor_view;
Neil Robertse5051712013-11-13 15:44:06 +0000979 struct weston_buffer *buffer;
Kristian Høgsberga6edab32012-07-14 01:06:28 -0400980 struct drm_compositor *c =
981 (struct drm_compositor *) output->base.compositor;
982 EGLint handle, stride;
983 struct gbm_bo *bo;
984 uint32_t buf[64 * 64];
985 unsigned char *s;
Kristian Høgsberg24e42752012-07-18 12:08:37 -0400986 int i, x, y;
Kristian Høgsbergd8bf90c2012-02-23 23:03:14 -0500987
Jason Ekstranda7af7042013-10-12 22:38:11 -0500988 output->cursor_view = NULL;
989 if (ev == NULL) {
Kristian Høgsberg5626d342012-08-03 11:50:05 -0400990 drmModeSetCursor(c->drm.fd, output->crtc_id, 0, 0, 0);
991 return;
992 }
Kristian Høgsbergd8bf90c2012-02-23 23:03:14 -0500993
Neil Robertse5051712013-11-13 15:44:06 +0000994 buffer = ev->surface->buffer_ref.buffer;
995
996 if (buffer &&
Pekka Paalanende685b82012-12-04 15:58:12 +0200997 pixman_region32_not_empty(&output->cursor_plane.damage)) {
Kristian Høgsberg5626d342012-08-03 11:50:05 -0400998 pixman_region32_fini(&output->cursor_plane.damage);
999 pixman_region32_init(&output->cursor_plane.damage);
Kristian Høgsberg1f5de352012-07-18 12:09:58 -04001000 output->current_cursor ^= 1;
1001 bo = output->cursor_bo[output->current_cursor];
1002 memset(buf, 0, sizeof buf);
Neil Robertse5051712013-11-13 15:44:06 +00001003 stride = wl_shm_buffer_get_stride(buffer->shm_buffer);
1004 s = wl_shm_buffer_get_data(buffer->shm_buffer);
1005 wl_shm_buffer_begin_access(buffer->shm_buffer);
Jason Ekstrand918f2dd2013-12-02 21:01:53 -06001006 for (i = 0; i < ev->surface->height; i++)
Kristian Høgsberg1f5de352012-07-18 12:09:58 -04001007 memcpy(buf + i * 64, s + i * stride,
Jason Ekstrand918f2dd2013-12-02 21:01:53 -06001008 ev->surface->width * 4);
Neil Robertse5051712013-11-13 15:44:06 +00001009 wl_shm_buffer_end_access(buffer->shm_buffer);
Kristian Høgsbergd8bf90c2012-02-23 23:03:14 -05001010
Kristian Høgsberg1f5de352012-07-18 12:09:58 -04001011 if (gbm_bo_write(bo, buf, sizeof buf) < 0)
Pekka Paalanenae29da22012-08-06 14:57:05 +03001012 weston_log("failed update cursor: %m\n");
Kristian Høgsberga6edab32012-07-14 01:06:28 -04001013
Kristian Høgsberg1f5de352012-07-18 12:09:58 -04001014 handle = gbm_bo_get_handle(bo).s32;
1015 if (drmModeSetCursor(c->drm.fd,
Rob Clarkab5b1e32012-08-09 13:24:45 -05001016 output->crtc_id, handle, 64, 64)) {
Pekka Paalanenae29da22012-08-06 14:57:05 +03001017 weston_log("failed to set cursor: %m\n");
Rob Clarkab5b1e32012-08-09 13:24:45 -05001018 c->cursors_are_broken = 1;
1019 }
Kristian Høgsberga6edab32012-07-14 01:06:28 -04001020 }
1021
Jason Ekstranda7af7042013-10-12 22:38:11 -05001022 x = (ev->geometry.x - output->base.x) * output->base.current_scale;
1023 y = (ev->geometry.y - output->base.y) * output->base.current_scale;
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04001024 if (output->cursor_plane.x != x || output->cursor_plane.y != y) {
Rob Clarkab5b1e32012-08-09 13:24:45 -05001025 if (drmModeMoveCursor(c->drm.fd, output->crtc_id, x, y)) {
Kristian Høgsberg24e42752012-07-18 12:08:37 -04001026 weston_log("failed to move cursor: %m\n");
Rob Clarkab5b1e32012-08-09 13:24:45 -05001027 c->cursors_are_broken = 1;
1028 }
1029
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04001030 output->cursor_plane.x = x;
1031 output->cursor_plane.y = y;
Kristian Høgsberga6edab32012-07-14 01:06:28 -04001032 }
Kristian Høgsbergd8bf90c2012-02-23 23:03:14 -05001033}
1034
Jesse Barnes58ef3792012-02-23 09:45:49 -05001035static void
1036drm_assign_planes(struct weston_output *output)
1037{
Kristian Høgsberga6edab32012-07-14 01:06:28 -04001038 struct drm_compositor *c =
1039 (struct drm_compositor *) output->compositor;
Jason Ekstranda7af7042013-10-12 22:38:11 -05001040 struct weston_view *ev, *next;
Jesse Barnes58ef3792012-02-23 09:45:49 -05001041 pixman_region32_t overlap, surface_overlap;
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04001042 struct weston_plane *primary, *next_plane;
Jesse Barnes58ef3792012-02-23 09:45:49 -05001043
1044 /*
1045 * Find a surface for each sprite in the output using some heuristics:
1046 * 1) size
1047 * 2) frequency of update
1048 * 3) opacity (though some hw might support alpha blending)
1049 * 4) clipping (this can be fixed with color keys)
1050 *
1051 * The idea is to save on blitting since this should save power.
1052 * If we can get a large video surface on the sprite for example,
1053 * the main display surface may not need to update at all, and
1054 * the client buffer can be used directly for the sprite surface
1055 * as we do for flipping full screen surfaces.
1056 */
1057 pixman_region32_init(&overlap);
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04001058 primary = &c->base.primary_plane;
Jason Ekstranda7af7042013-10-12 22:38:11 -05001059
Jason Ekstranda7af7042013-10-12 22:38:11 -05001060 wl_list_for_each_safe(ev, next, &c->base.view_list, link) {
Ander Conselvan de Oliveira895b1fd2013-11-19 15:22:05 +02001061 struct weston_surface *es = ev->surface;
1062
1063 /* Test whether this buffer can ever go into a plane:
1064 * non-shm, or small enough to be a cursor.
1065 *
1066 * Also, keep a reference when using the pixman renderer.
1067 * That makes it possible to do a seamless switch to the GL
1068 * renderer and since the pixman renderer keeps a reference
1069 * to the buffer anyway, there is no side effects.
Pekka Paalanenccfeae22012-12-04 15:58:14 +02001070 */
Ander Conselvan de Oliveira895b1fd2013-11-19 15:22:05 +02001071 if (c->use_pixman ||
1072 (es->buffer_ref.buffer &&
1073 (!wl_shm_buffer_get(es->buffer_ref.buffer->resource) ||
Jason Ekstrand918f2dd2013-12-02 21:01:53 -06001074 (ev->surface->width <= 64 && ev->surface->height <= 64))))
Ander Conselvan de Oliveira895b1fd2013-11-19 15:22:05 +02001075 es->keep_buffer = 1;
1076 else
1077 es->keep_buffer = 0;
Pekka Paalanenccfeae22012-12-04 15:58:14 +02001078
Jesse Barnes58ef3792012-02-23 09:45:49 -05001079 pixman_region32_init(&surface_overlap);
1080 pixman_region32_intersect(&surface_overlap, &overlap,
Jason Ekstranda7af7042013-10-12 22:38:11 -05001081 &ev->transform.boundingbox);
Jesse Barnes58ef3792012-02-23 09:45:49 -05001082
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04001083 next_plane = NULL;
Kristian Høgsberg6143f7d2012-07-14 00:31:32 -04001084 if (pixman_region32_not_empty(&surface_overlap))
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04001085 next_plane = primary;
1086 if (next_plane == NULL)
Jason Ekstranda7af7042013-10-12 22:38:11 -05001087 next_plane = drm_output_prepare_cursor_view(output, ev);
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04001088 if (next_plane == NULL)
Jason Ekstranda7af7042013-10-12 22:38:11 -05001089 next_plane = drm_output_prepare_scanout_view(output, ev);
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04001090 if (next_plane == NULL)
Jason Ekstranda7af7042013-10-12 22:38:11 -05001091 next_plane = drm_output_prepare_overlay_view(output, ev);
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04001092 if (next_plane == NULL)
1093 next_plane = primary;
Jason Ekstranda7af7042013-10-12 22:38:11 -05001094 weston_view_move_to_plane(ev, next_plane);
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04001095 if (next_plane == primary)
Jesse Barnes58ef3792012-02-23 09:45:49 -05001096 pixman_region32_union(&overlap, &overlap,
Jason Ekstranda7af7042013-10-12 22:38:11 -05001097 &ev->transform.boundingbox);
Kristian Høgsberg6143f7d2012-07-14 00:31:32 -04001098
Jesse Barnes58ef3792012-02-23 09:45:49 -05001099 pixman_region32_fini(&surface_overlap);
1100 }
1101 pixman_region32_fini(&overlap);
Jesse Barnes58ef3792012-02-23 09:45:49 -05001102}
1103
Matt Roper361d2ad2011-08-29 13:52:23 -07001104static void
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02001105drm_output_fini_pixman(struct drm_output *output);
1106
1107static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001108drm_output_destroy(struct weston_output *output_base)
Matt Roper361d2ad2011-08-29 13:52:23 -07001109{
1110 struct drm_output *output = (struct drm_output *) output_base;
1111 struct drm_compositor *c =
Benjamin Franzke117483d2011-08-30 11:38:26 +02001112 (struct drm_compositor *) output->base.compositor;
Matt Roper361d2ad2011-08-29 13:52:23 -07001113 drmModeCrtcPtr origcrtc = output->original_crtc;
Matt Roper361d2ad2011-08-29 13:52:23 -07001114
Xiong Zhangabd5d472013-10-11 14:43:07 +08001115 if (output->page_flip_pending) {
1116 output->destroy_pending = 1;
1117 weston_log("destroy output while page flip pending\n");
1118 return;
1119 }
1120
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02001121 if (output->backlight)
1122 backlight_destroy(output->backlight);
1123
Ander Conselvan de Oliveiraa0a433a2013-06-04 16:24:04 +03001124 drmModeFreeProperty(output->dpms_prop);
1125
Matt Roper361d2ad2011-08-29 13:52:23 -07001126 /* Turn off hardware cursor */
Kristian Høgsberga6edab32012-07-14 01:06:28 -04001127 drmModeSetCursor(c->drm.fd, output->crtc_id, 0, 0, 0);
Matt Roper361d2ad2011-08-29 13:52:23 -07001128
1129 /* Restore original CRTC state */
1130 drmModeSetCrtc(c->drm.fd, origcrtc->crtc_id, origcrtc->buffer_id,
Benjamin Franzke117483d2011-08-30 11:38:26 +02001131 origcrtc->x, origcrtc->y,
1132 &output->connector_id, 1, &origcrtc->mode);
Matt Roper361d2ad2011-08-29 13:52:23 -07001133 drmModeFreeCrtc(origcrtc);
1134
Benjamin Franzke48c4ea22011-08-30 11:44:56 +02001135 c->crtc_allocator &= ~(1 << output->crtc_id);
1136 c->connector_allocator &= ~(1 << output->connector_id);
1137
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02001138 if (c->use_pixman) {
1139 drm_output_fini_pixman(output);
1140 } else {
Ander Conselvan de Oliveira97f29522013-10-14 15:57:11 +03001141 gl_renderer->output_destroy(output_base);
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02001142 gbm_surface_destroy(output->surface);
1143 }
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -04001144
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04001145 weston_plane_release(&output->fb_plane);
1146 weston_plane_release(&output->cursor_plane);
1147
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001148 weston_output_destroy(&output->base);
Benjamin Franzke48c4ea22011-08-30 11:44:56 +02001149
Matt Roper361d2ad2011-08-29 13:52:23 -07001150 free(output);
1151}
1152
Alex Wub7b8bda2012-04-17 17:20:48 +08001153static struct drm_mode *
1154choose_mode (struct drm_output *output, struct weston_mode *target_mode)
1155{
1156 struct drm_mode *tmp_mode = NULL, *mode;
1157
Hardeningff39efa2013-09-18 23:56:35 +02001158 if (output->base.current_mode->width == target_mode->width &&
1159 output->base.current_mode->height == target_mode->height &&
1160 (output->base.current_mode->refresh == target_mode->refresh ||
Alex Wub7b8bda2012-04-17 17:20:48 +08001161 target_mode->refresh == 0))
Hardeningff39efa2013-09-18 23:56:35 +02001162 return (struct drm_mode *)output->base.current_mode;
Alex Wub7b8bda2012-04-17 17:20:48 +08001163
1164 wl_list_for_each(mode, &output->base.mode_list, base.link) {
1165 if (mode->mode_info.hdisplay == target_mode->width &&
1166 mode->mode_info.vdisplay == target_mode->height) {
1167 if (mode->mode_info.vrefresh == target_mode->refresh ||
1168 target_mode->refresh == 0) {
1169 return mode;
1170 } else if (!tmp_mode)
1171 tmp_mode = mode;
1172 }
1173 }
1174
1175 return tmp_mode;
1176}
1177
1178static int
Ander Conselvan de Oliveira6c01c9c2012-12-14 13:37:30 -02001179drm_output_init_egl(struct drm_output *output, struct drm_compositor *ec);
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02001180static int
1181drm_output_init_pixman(struct drm_output *output, struct drm_compositor *c);
Ander Conselvan de Oliveira6c01c9c2012-12-14 13:37:30 -02001182
1183static int
Alex Wub7b8bda2012-04-17 17:20:48 +08001184drm_output_switch_mode(struct weston_output *output_base, struct weston_mode *mode)
1185{
1186 struct drm_output *output;
1187 struct drm_mode *drm_mode;
Alex Wub7b8bda2012-04-17 17:20:48 +08001188 struct drm_compositor *ec;
Alex Wub7b8bda2012-04-17 17:20:48 +08001189
1190 if (output_base == NULL) {
Martin Minarik6d118362012-06-07 18:01:59 +02001191 weston_log("output is NULL.\n");
Alex Wub7b8bda2012-04-17 17:20:48 +08001192 return -1;
1193 }
1194
1195 if (mode == NULL) {
Martin Minarik6d118362012-06-07 18:01:59 +02001196 weston_log("mode is NULL.\n");
Alex Wub7b8bda2012-04-17 17:20:48 +08001197 return -1;
1198 }
1199
1200 ec = (struct drm_compositor *)output_base->compositor;
1201 output = (struct drm_output *)output_base;
1202 drm_mode = choose_mode (output, mode);
1203
1204 if (!drm_mode) {
Martin Minarik6d118362012-06-07 18:01:59 +02001205 weston_log("%s, invalid resolution:%dx%d\n", __func__, mode->width, mode->height);
Alex Wub7b8bda2012-04-17 17:20:48 +08001206 return -1;
Ander Conselvan de Oliveira6c01c9c2012-12-14 13:37:30 -02001207 }
1208
Hardeningff39efa2013-09-18 23:56:35 +02001209 if (&drm_mode->base == output->base.current_mode)
Alex Wub7b8bda2012-04-17 17:20:48 +08001210 return 0;
Alex Wub7b8bda2012-04-17 17:20:48 +08001211
Hardeningff39efa2013-09-18 23:56:35 +02001212 output->base.current_mode->flags = 0;
Alex Wub7b8bda2012-04-17 17:20:48 +08001213
Hardeningff39efa2013-09-18 23:56:35 +02001214 output->base.current_mode = &drm_mode->base;
1215 output->base.current_mode->flags =
Alex Wub7b8bda2012-04-17 17:20:48 +08001216 WL_OUTPUT_MODE_CURRENT | WL_OUTPUT_MODE_PREFERRED;
1217
Alex Wub7b8bda2012-04-17 17:20:48 +08001218 /* reset rendering stuff. */
Ander Conselvan de Oliveira526d4612013-01-25 15:13:03 +02001219 drm_output_release_fb(output, output->current);
1220 drm_output_release_fb(output, output->next);
1221 output->current = output->next = NULL;
Alex Wub7b8bda2012-04-17 17:20:48 +08001222
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02001223 if (ec->use_pixman) {
1224 drm_output_fini_pixman(output);
1225 if (drm_output_init_pixman(output, ec) < 0) {
1226 weston_log("failed to init output pixman state with "
1227 "new mode\n");
1228 return -1;
1229 }
1230 } else {
Ander Conselvan de Oliveira97f29522013-10-14 15:57:11 +03001231 gl_renderer->output_destroy(&output->base);
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02001232 gbm_surface_destroy(output->surface);
Alex Wub7b8bda2012-04-17 17:20:48 +08001233
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02001234 if (drm_output_init_egl(output, ec) < 0) {
1235 weston_log("failed to init output egl state with "
1236 "new mode");
1237 return -1;
1238 }
Ander Conselvan de Oliveira6c01c9c2012-12-14 13:37:30 -02001239 }
1240
Alex Wub7b8bda2012-04-17 17:20:48 +08001241 return 0;
Alex Wub7b8bda2012-04-17 17:20:48 +08001242}
1243
Kristian Høgsbergb1868472011-04-22 12:27:57 -04001244static int
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001245on_drm_input(int fd, uint32_t mask, void *data)
1246{
1247 drmEventContext evctx;
1248
1249 memset(&evctx, 0, sizeof evctx);
1250 evctx.version = DRM_EVENT_CONTEXT_VERSION;
1251 evctx.page_flip_handler = page_flip_handler;
Jesse Barnes58ef3792012-02-23 09:45:49 -05001252 evctx.vblank_handler = vblank_handler;
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001253 drmHandleEvent(fd, &evctx);
Kristian Høgsbergb1868472011-04-22 12:27:57 -04001254
1255 return 1;
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001256}
1257
1258static int
Ander Conselvan de Oliveira22929172013-01-25 15:13:02 +02001259init_drm(struct drm_compositor *ec, struct udev_device *device)
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001260{
Kristian Høgsbergb5ef5912012-03-28 22:53:49 -04001261 const char *filename, *sysnum;
Ander Conselvan de Oliveira95eb3a22013-05-07 14:16:59 +03001262 uint64_t cap;
1263 int fd, ret;
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -04001264
Kristian Høgsbergb71302e2012-05-10 12:28:35 -04001265 sysnum = udev_device_get_sysnum(device);
1266 if (sysnum)
1267 ec->drm.id = atoi(sysnum);
1268 if (!sysnum || ec->drm.id < 0) {
Martin Minarik6d118362012-06-07 18:01:59 +02001269 weston_log("cannot get device sysnum\n");
Kristian Høgsbergb71302e2012-05-10 12:28:35 -04001270 return -1;
1271 }
1272
Kristian Høgsberg5fcd0aa2010-08-09 14:43:33 -04001273 filename = udev_device_get_devnode(device);
Kristian Høgsberg05ad1e42013-09-17 14:41:03 -07001274 fd = weston_launcher_open(ec->base.launcher, filename, O_RDWR);
Kristian Høgsberg5fcd0aa2010-08-09 14:43:33 -04001275 if (fd < 0) {
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001276 /* Probably permissions error */
Martin Minarik6d118362012-06-07 18:01:59 +02001277 weston_log("couldn't open %s, skipping\n",
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001278 udev_device_get_devnode(device));
1279 return -1;
1280 }
1281
Kristian Høgsbergfc9c5e02012-06-08 16:45:33 -04001282 weston_log("using %s\n", filename);
1283
Benjamin Franzke2af7f102011-03-02 11:14:59 +01001284 ec->drm.fd = fd;
Ander Conselvan de Oliveira6aae4d32013-08-23 17:15:48 +03001285 ec->drm.filename = strdup(filename);
Ander Conselvan de Oliveira22929172013-01-25 15:13:02 +02001286
Ander Conselvan de Oliveira95eb3a22013-05-07 14:16:59 +03001287 ret = drmGetCap(fd, DRM_CAP_TIMESTAMP_MONOTONIC, &cap);
1288 if (ret == 0 && cap == 1)
1289 ec->clock = CLOCK_MONOTONIC;
1290 else
1291 ec->clock = CLOCK_REALTIME;
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +02001292
Ander Conselvan de Oliveira22929172013-01-25 15:13:02 +02001293 return 0;
1294}
1295
Ander Conselvan de Oliveira65796812013-11-19 15:22:04 +02001296static struct gbm_device *
1297create_gbm_device(int fd)
Ander Conselvan de Oliveira22929172013-01-25 15:13:02 +02001298{
Ander Conselvan de Oliveira65796812013-11-19 15:22:04 +02001299 struct gbm_device *gbm;
Alexandru DAMIANbe0ac5b2013-10-02 17:51:05 +01001300
Ander Conselvan de Oliveira97f29522013-10-14 15:57:11 +03001301 gl_renderer = weston_load_module("gl-renderer.so",
1302 "gl_renderer_interface");
1303 if (!gl_renderer)
Ander Conselvan de Oliveira65796812013-11-19 15:22:04 +02001304 return NULL;
Ander Conselvan de Oliveira97f29522013-10-14 15:57:11 +03001305
1306 /* GBM will load a dri driver, but even though they need symbols from
1307 * libglapi, in some version of Mesa they are not linked to it. Since
1308 * only the gl-renderer module links to it, the call above won't make
1309 * these symbols globally available, and loading the DRI driver fails.
1310 * Workaround this by dlopen()'ing libglapi with RTLD_GLOBAL. */
1311 dlopen("libglapi.so.0", RTLD_LAZY | RTLD_GLOBAL);
1312
Ander Conselvan de Oliveira65796812013-11-19 15:22:04 +02001313 gbm = gbm_create_device(fd);
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001314
Ander Conselvan de Oliveira65796812013-11-19 15:22:04 +02001315 return gbm;
1316}
1317
1318static int
1319drm_compositor_create_gl_renderer(struct drm_compositor *ec)
1320{
1321 EGLint format;
John Kåre Alsakeref591aa2013-03-02 12:27:39 +01001322
Alexandru DAMIANbe0ac5b2013-10-02 17:51:05 +01001323 format = ec->format;
Ander Conselvan de Oliveira97f29522013-10-14 15:57:11 +03001324 if (gl_renderer->create(&ec->base, ec->gbm,
1325 gl_renderer->opaque_attribs, &format) < 0) {
Ander Conselvan de Oliveira65796812013-11-19 15:22:04 +02001326 return -1;
1327 }
1328
1329 return 0;
1330}
1331
1332static int
1333init_egl(struct drm_compositor *ec)
1334{
1335 ec->gbm = create_gbm_device(ec->drm.fd);
1336
1337 if (!ec->gbm)
1338 return -1;
1339
1340 if (drm_compositor_create_gl_renderer(ec) < 0) {
John Kåre Alsaker1b7ad162012-11-13 19:10:19 +01001341 gbm_device_destroy(ec->gbm);
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -04001342 return -1;
1343 }
1344
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001345 return 0;
1346}
1347
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02001348static int
1349init_pixman(struct drm_compositor *ec)
1350{
1351 return pixman_renderer_init(&ec->base);
1352}
1353
Ander Conselvan de Oliveira42c46462012-08-09 16:45:00 +03001354static struct drm_mode *
Alexander Larsson0b135062013-05-28 16:23:36 +02001355drm_output_add_mode(struct drm_output *output, drmModeModeInfo *info)
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001356{
1357 struct drm_mode *mode;
Kristian Høgsbergc4621b02012-05-10 12:23:53 -04001358 uint64_t refresh;
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001359
1360 mode = malloc(sizeof *mode);
1361 if (mode == NULL)
Ander Conselvan de Oliveira42c46462012-08-09 16:45:00 +03001362 return NULL;
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001363
1364 mode->base.flags = 0;
Alexander Larsson0b135062013-05-28 16:23:36 +02001365 mode->base.width = info->hdisplay;
1366 mode->base.height = info->vdisplay;
Kristian Høgsbergc4621b02012-05-10 12:23:53 -04001367
1368 /* Calculate higher precision (mHz) refresh rate */
1369 refresh = (info->clock * 1000000LL / info->htotal +
1370 info->vtotal / 2) / info->vtotal;
1371
1372 if (info->flags & DRM_MODE_FLAG_INTERLACE)
1373 refresh *= 2;
1374 if (info->flags & DRM_MODE_FLAG_DBLSCAN)
1375 refresh /= 2;
1376 if (info->vscan > 1)
1377 refresh /= info->vscan;
1378
1379 mode->base.refresh = refresh;
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001380 mode->mode_info = *info;
Kristian Høgsberg061c4252012-06-28 11:28:15 -04001381
1382 if (info->type & DRM_MODE_TYPE_PREFERRED)
1383 mode->base.flags |= WL_OUTPUT_MODE_PREFERRED;
1384
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001385 wl_list_insert(output->base.mode_list.prev, &mode->base.link);
1386
Ander Conselvan de Oliveira42c46462012-08-09 16:45:00 +03001387 return mode;
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001388}
1389
1390static int
1391drm_subpixel_to_wayland(int drm_value)
1392{
1393 switch (drm_value) {
1394 default:
1395 case DRM_MODE_SUBPIXEL_UNKNOWN:
1396 return WL_OUTPUT_SUBPIXEL_UNKNOWN;
1397 case DRM_MODE_SUBPIXEL_NONE:
1398 return WL_OUTPUT_SUBPIXEL_NONE;
1399 case DRM_MODE_SUBPIXEL_HORIZONTAL_RGB:
1400 return WL_OUTPUT_SUBPIXEL_HORIZONTAL_RGB;
1401 case DRM_MODE_SUBPIXEL_HORIZONTAL_BGR:
1402 return WL_OUTPUT_SUBPIXEL_HORIZONTAL_BGR;
1403 case DRM_MODE_SUBPIXEL_VERTICAL_RGB:
1404 return WL_OUTPUT_SUBPIXEL_VERTICAL_RGB;
1405 case DRM_MODE_SUBPIXEL_VERTICAL_BGR:
1406 return WL_OUTPUT_SUBPIXEL_VERTICAL_BGR;
1407 }
1408}
1409
Tiago Vignatti5ab91ad2012-03-12 19:40:09 -03001410/* returns a value between 0-255 range, where higher is brighter */
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02001411static uint32_t
1412drm_get_backlight(struct drm_output *output)
1413{
1414 long brightness, max_brightness, norm;
1415
1416 brightness = backlight_get_brightness(output->backlight);
1417 max_brightness = backlight_get_max_brightness(output->backlight);
1418
Tiago Vignatti5ab91ad2012-03-12 19:40:09 -03001419 /* convert it on a scale of 0 to 255 */
1420 norm = (brightness * 255)/(max_brightness);
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02001421
1422 return (uint32_t) norm;
1423}
1424
Tiago Vignatti5ab91ad2012-03-12 19:40:09 -03001425/* values accepted are between 0-255 range */
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02001426static void
1427drm_set_backlight(struct weston_output *output_base, uint32_t value)
1428{
1429 struct drm_output *output = (struct drm_output *) output_base;
1430 long max_brightness, new_brightness;
1431
1432 if (!output->backlight)
1433 return;
1434
Kristian Høgsberg875ab9e2012-03-30 11:52:39 -04001435 if (value > 255)
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02001436 return;
1437
1438 max_brightness = backlight_get_max_brightness(output->backlight);
1439
1440 /* get denormalized value */
Tiago Vignatti5ab91ad2012-03-12 19:40:09 -03001441 new_brightness = (value * max_brightness) / 255;
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02001442
1443 backlight_set_brightness(output->backlight, new_brightness);
1444}
1445
1446static drmModePropertyPtr
1447drm_get_prop(int fd, drmModeConnectorPtr connector, const char *name)
1448{
1449 drmModePropertyPtr props;
1450 int i;
1451
1452 for (i = 0; i < connector->count_props; i++) {
1453 props = drmModeGetProperty(fd, connector->props[i]);
1454 if (!props)
1455 continue;
1456
1457 if (!strcmp(props->name, name))
1458 return props;
1459
1460 drmModeFreeProperty(props);
1461 }
1462
1463 return NULL;
1464}
1465
1466static void
1467drm_set_dpms(struct weston_output *output_base, enum dpms_enum level)
1468{
1469 struct drm_output *output = (struct drm_output *) output_base;
1470 struct weston_compositor *ec = output_base->compositor;
1471 struct drm_compositor *c = (struct drm_compositor *) ec;
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02001472
Ander Conselvan de Oliveiraa0a433a2013-06-04 16:24:04 +03001473 if (!output->dpms_prop)
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02001474 return;
1475
Ander Conselvan de Oliveiraa0a433a2013-06-04 16:24:04 +03001476 drmModeConnectorSetProperty(c->drm.fd, output->connector_id,
1477 output->dpms_prop->prop_id, level);
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02001478}
1479
Kristian Høgsberg2f9ed712012-07-26 17:57:15 -04001480static const char *connector_type_names[] = {
1481 "None",
1482 "VGA",
1483 "DVI",
1484 "DVI",
1485 "DVI",
1486 "Composite",
1487 "TV",
1488 "LVDS",
1489 "CTV",
1490 "DIN",
1491 "DP",
1492 "HDMI",
1493 "HDMI",
1494 "TV",
1495 "eDP",
1496};
1497
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001498static int
Kristian Høgsberg9ca38462012-07-26 22:44:55 -04001499find_crtc_for_connector(struct drm_compositor *ec,
1500 drmModeRes *resources, drmModeConnector *connector)
1501{
1502 drmModeEncoder *encoder;
1503 uint32_t possible_crtcs;
1504 int i, j;
1505
1506 for (j = 0; j < connector->count_encoders; j++) {
1507 encoder = drmModeGetEncoder(ec->drm.fd, connector->encoders[j]);
1508 if (encoder == NULL) {
1509 weston_log("Failed to get encoder.\n");
1510 return -1;
1511 }
1512 possible_crtcs = encoder->possible_crtcs;
1513 drmModeFreeEncoder(encoder);
1514
1515 for (i = 0; i < resources->count_crtcs; i++) {
1516 if (possible_crtcs & (1 << i) &&
1517 !(ec->crtc_allocator & (1 << resources->crtcs[i])))
1518 return i;
1519 }
1520 }
1521
1522 return -1;
1523}
1524
Ander Conselvan de Oliveira475cf152012-12-14 13:37:29 -02001525/* Init output state that depends on gl or gbm */
1526static int
1527drm_output_init_egl(struct drm_output *output, struct drm_compositor *ec)
1528{
Ander Conselvan de Oliveira6c01c9c2012-12-14 13:37:30 -02001529 int i, flags;
1530
Ander Conselvan de Oliveira475cf152012-12-14 13:37:29 -02001531 output->surface = gbm_surface_create(ec->gbm,
Hardeningff39efa2013-09-18 23:56:35 +02001532 output->base.current_mode->width,
1533 output->base.current_mode->height,
Kristian Høgsbergc3ea26c2013-09-25 15:46:42 -07001534 ec->format,
Ander Conselvan de Oliveira475cf152012-12-14 13:37:29 -02001535 GBM_BO_USE_SCANOUT |
1536 GBM_BO_USE_RENDERING);
1537 if (!output->surface) {
1538 weston_log("failed to create gbm surface\n");
1539 return -1;
1540 }
1541
Ander Conselvan de Oliveira97f29522013-10-14 15:57:11 +03001542 if (gl_renderer->output_create(&output->base, output->surface) < 0) {
Ander Conselvan de Oliveira6c01c9c2012-12-14 13:37:30 -02001543 weston_log("failed to create gl renderer output state\n");
Ander Conselvan de Oliveira475cf152012-12-14 13:37:29 -02001544 gbm_surface_destroy(output->surface);
1545 return -1;
1546 }
1547
Ander Conselvan de Oliveira6c01c9c2012-12-14 13:37:30 -02001548 flags = GBM_BO_USE_CURSOR_64X64 | GBM_BO_USE_WRITE;
1549
1550 for (i = 0; i < 2; i++) {
1551 if (output->cursor_bo[i])
1552 continue;
1553
1554 output->cursor_bo[i] =
1555 gbm_bo_create(ec->gbm, 64, 64, GBM_FORMAT_ARGB8888,
1556 flags);
1557 }
1558
Ander Conselvan de Oliveira475cf152012-12-14 13:37:29 -02001559 if (output->cursor_bo[0] == NULL || output->cursor_bo[1] == NULL) {
1560 weston_log("cursor buffers unavailable, using gl cursors\n");
1561 ec->cursors_are_broken = 1;
1562 }
1563
1564 return 0;
1565}
1566
Kristian Høgsberg9ca38462012-07-26 22:44:55 -04001567static int
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02001568drm_output_init_pixman(struct drm_output *output, struct drm_compositor *c)
1569{
Hardeningff39efa2013-09-18 23:56:35 +02001570 int w = output->base.current_mode->width;
1571 int h = output->base.current_mode->height;
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02001572 unsigned int i;
1573
1574 /* FIXME error checking */
1575
1576 for (i = 0; i < ARRAY_LENGTH(output->dumb); i++) {
Alexander Larsson0b135062013-05-28 16:23:36 +02001577 output->dumb[i] = drm_fb_create_dumb(c, w, h);
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02001578 if (!output->dumb[i])
1579 goto err;
1580
1581 output->image[i] =
Alexander Larsson0b135062013-05-28 16:23:36 +02001582 pixman_image_create_bits(PIXMAN_x8r8g8b8, w, h,
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02001583 output->dumb[i]->map,
1584 output->dumb[i]->stride);
1585 if (!output->image[i])
1586 goto err;
1587 }
1588
1589 if (pixman_renderer_output_create(&output->base) < 0)
1590 goto err;
1591
1592 pixman_region32_init_rect(&output->previous_damage,
Alexander Larsson0b135062013-05-28 16:23:36 +02001593 output->base.x, output->base.y, output->base.width, output->base.height);
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02001594
1595 return 0;
1596
1597err:
1598 for (i = 0; i < ARRAY_LENGTH(output->dumb); i++) {
1599 if (output->dumb[i])
1600 drm_fb_destroy_dumb(output->dumb[i]);
1601 if (output->image[i])
1602 pixman_image_unref(output->image[i]);
1603
1604 output->dumb[i] = NULL;
1605 output->image[i] = NULL;
1606 }
1607
1608 return -1;
1609}
1610
1611static void
1612drm_output_fini_pixman(struct drm_output *output)
1613{
1614 unsigned int i;
1615
1616 pixman_renderer_output_destroy(&output->base);
1617 pixman_region32_fini(&output->previous_damage);
1618
1619 for (i = 0; i < ARRAY_LENGTH(output->dumb); i++) {
1620 drm_fb_destroy_dumb(output->dumb[i]);
1621 pixman_image_unref(output->image[i]);
1622 output->dumb[i] = NULL;
1623 output->image[i] = NULL;
1624 }
1625}
1626
Richard Hughes2b2092a2013-04-24 14:58:02 +01001627static void
1628edid_parse_string(const uint8_t *data, char text[])
1629{
1630 int i;
1631 int replaced = 0;
1632
1633 /* this is always 12 bytes, but we can't guarantee it's null
1634 * terminated or not junk. */
1635 strncpy(text, (const char *) data, 12);
1636
1637 /* remove insane chars */
1638 for (i = 0; text[i] != '\0'; i++) {
1639 if (text[i] == '\n' ||
1640 text[i] == '\r') {
1641 text[i] = '\0';
1642 break;
1643 }
1644 }
1645
1646 /* ensure string is printable */
1647 for (i = 0; text[i] != '\0'; i++) {
1648 if (!isprint(text[i])) {
1649 text[i] = '-';
1650 replaced++;
1651 }
1652 }
1653
1654 /* if the string is random junk, ignore the string */
1655 if (replaced > 4)
1656 text[0] = '\0';
1657}
1658
1659#define EDID_DESCRIPTOR_ALPHANUMERIC_DATA_STRING 0xfe
1660#define EDID_DESCRIPTOR_DISPLAY_PRODUCT_NAME 0xfc
1661#define EDID_DESCRIPTOR_DISPLAY_PRODUCT_SERIAL_NUMBER 0xff
1662#define EDID_OFFSET_DATA_BLOCKS 0x36
1663#define EDID_OFFSET_LAST_BLOCK 0x6c
1664#define EDID_OFFSET_PNPID 0x08
1665#define EDID_OFFSET_SERIAL 0x0c
1666
1667static int
1668edid_parse(struct drm_edid *edid, const uint8_t *data, size_t length)
1669{
1670 int i;
1671 uint32_t serial_number;
1672
1673 /* check header */
1674 if (length < 128)
1675 return -1;
1676 if (data[0] != 0x00 || data[1] != 0xff)
1677 return -1;
1678
1679 /* decode the PNP ID from three 5 bit words packed into 2 bytes
1680 * /--08--\/--09--\
1681 * 7654321076543210
1682 * |\---/\---/\---/
1683 * R C1 C2 C3 */
1684 edid->pnp_id[0] = 'A' + ((data[EDID_OFFSET_PNPID + 0] & 0x7c) / 4) - 1;
1685 edid->pnp_id[1] = 'A' + ((data[EDID_OFFSET_PNPID + 0] & 0x3) * 8) + ((data[EDID_OFFSET_PNPID + 1] & 0xe0) / 32) - 1;
1686 edid->pnp_id[2] = 'A' + (data[EDID_OFFSET_PNPID + 1] & 0x1f) - 1;
1687 edid->pnp_id[3] = '\0';
1688
1689 /* maybe there isn't a ASCII serial number descriptor, so use this instead */
1690 serial_number = (uint32_t) data[EDID_OFFSET_SERIAL + 0];
1691 serial_number += (uint32_t) data[EDID_OFFSET_SERIAL + 1] * 0x100;
1692 serial_number += (uint32_t) data[EDID_OFFSET_SERIAL + 2] * 0x10000;
1693 serial_number += (uint32_t) data[EDID_OFFSET_SERIAL + 3] * 0x1000000;
1694 if (serial_number > 0)
1695 sprintf(edid->serial_number, "%lu", (unsigned long) serial_number);
1696
1697 /* parse EDID data */
1698 for (i = EDID_OFFSET_DATA_BLOCKS;
1699 i <= EDID_OFFSET_LAST_BLOCK;
1700 i += 18) {
1701 /* ignore pixel clock data */
1702 if (data[i] != 0)
1703 continue;
1704 if (data[i+2] != 0)
1705 continue;
1706
1707 /* any useful blocks? */
1708 if (data[i+3] == EDID_DESCRIPTOR_DISPLAY_PRODUCT_NAME) {
1709 edid_parse_string(&data[i+5],
1710 edid->monitor_name);
1711 } else if (data[i+3] == EDID_DESCRIPTOR_DISPLAY_PRODUCT_SERIAL_NUMBER) {
1712 edid_parse_string(&data[i+5],
1713 edid->serial_number);
1714 } else if (data[i+3] == EDID_DESCRIPTOR_ALPHANUMERIC_DATA_STRING) {
1715 edid_parse_string(&data[i+5],
1716 edid->eisa_id);
1717 }
1718 }
1719 return 0;
1720}
1721
1722static void
1723find_and_parse_output_edid(struct drm_compositor *ec,
1724 struct drm_output *output,
1725 drmModeConnector *connector)
1726{
1727 drmModePropertyBlobPtr edid_blob = NULL;
1728 drmModePropertyPtr property;
1729 int i;
1730 int rc;
1731
1732 for (i = 0; i < connector->count_props && !edid_blob; i++) {
1733 property = drmModeGetProperty(ec->drm.fd, connector->props[i]);
1734 if (!property)
1735 continue;
1736 if ((property->flags & DRM_MODE_PROP_BLOB) &&
1737 !strcmp(property->name, "EDID")) {
1738 edid_blob = drmModeGetPropertyBlob(ec->drm.fd,
1739 connector->prop_values[i]);
1740 }
1741 drmModeFreeProperty(property);
1742 }
1743 if (!edid_blob)
1744 return;
1745
1746 rc = edid_parse(&output->edid,
1747 edid_blob->data,
1748 edid_blob->length);
1749 if (!rc) {
1750 weston_log("EDID data '%s', '%s', '%s'\n",
1751 output->edid.pnp_id,
1752 output->edid.monitor_name,
1753 output->edid.serial_number);
1754 if (output->edid.pnp_id[0] != '\0')
1755 output->base.make = output->edid.pnp_id;
1756 if (output->edid.monitor_name[0] != '\0')
1757 output->base.model = output->edid.monitor_name;
1758 if (output->edid.serial_number[0] != '\0')
1759 output->base.serial_number = output->edid.serial_number;
1760 }
1761 drmModeFreePropertyBlob(edid_blob);
1762}
1763
Kristian Høgsberga30989a2013-05-23 17:23:15 -04001764
1765
1766static int
1767parse_modeline(const char *s, drmModeModeInfo *mode)
1768{
1769 char hsync[16];
1770 char vsync[16];
1771 float fclock;
1772
1773 mode->type = DRM_MODE_TYPE_USERDEF;
1774 mode->hskew = 0;
1775 mode->vscan = 0;
1776 mode->vrefresh = 0;
1777 mode->flags = 0;
1778
Rob Bradford307e09e2013-07-26 16:29:40 +01001779 if (sscanf(s, "%f %hd %hd %hd %hd %hd %hd %hd %hd %15s %15s",
Kristian Høgsberga30989a2013-05-23 17:23:15 -04001780 &fclock,
1781 &mode->hdisplay,
1782 &mode->hsync_start,
1783 &mode->hsync_end,
1784 &mode->htotal,
1785 &mode->vdisplay,
1786 &mode->vsync_start,
1787 &mode->vsync_end,
1788 &mode->vtotal, hsync, vsync) != 11)
1789 return -1;
1790
1791 mode->clock = fclock * 1000;
1792 if (strcmp(hsync, "+hsync") == 0)
1793 mode->flags |= DRM_MODE_FLAG_PHSYNC;
1794 else if (strcmp(hsync, "-hsync") == 0)
1795 mode->flags |= DRM_MODE_FLAG_NHSYNC;
1796 else
1797 return -1;
1798
1799 if (strcmp(vsync, "+vsync") == 0)
1800 mode->flags |= DRM_MODE_FLAG_PVSYNC;
1801 else if (strcmp(vsync, "-vsync") == 0)
1802 mode->flags |= DRM_MODE_FLAG_NVSYNC;
1803 else
1804 return -1;
1805
1806 return 0;
1807}
1808
1809static uint32_t
1810parse_transform(const char *transform, const char *output_name)
1811{
1812 static const struct { const char *name; uint32_t token; } names[] = {
1813 { "normal", WL_OUTPUT_TRANSFORM_NORMAL },
1814 { "90", WL_OUTPUT_TRANSFORM_90 },
1815 { "180", WL_OUTPUT_TRANSFORM_180 },
1816 { "270", WL_OUTPUT_TRANSFORM_270 },
1817 { "flipped", WL_OUTPUT_TRANSFORM_FLIPPED },
1818 { "flipped-90", WL_OUTPUT_TRANSFORM_FLIPPED_90 },
1819 { "flipped-180", WL_OUTPUT_TRANSFORM_FLIPPED_180 },
1820 { "flipped-270", WL_OUTPUT_TRANSFORM_FLIPPED_270 },
1821 };
1822 unsigned int i;
1823
1824 for (i = 0; i < ARRAY_LENGTH(names); i++)
1825 if (strcmp(names[i].name, transform) == 0)
1826 return names[i].token;
1827
1828 weston_log("Invalid transform \"%s\" for output %s\n",
1829 transform, output_name);
1830
1831 return WL_OUTPUT_TRANSFORM_NORMAL;
1832}
1833
Rob Bradford66bd9f52013-06-25 18:56:42 +01001834static void
1835setup_output_seat_constraint(struct drm_compositor *ec,
1836 struct weston_output *output,
1837 const char *s)
1838{
1839 if (strcmp(s, "") != 0) {
1840 struct udev_seat *seat;
1841
1842 seat = udev_seat_get_named(&ec->base, s);
1843 if (seat)
1844 seat->base.output = output;
1845
1846 if (seat && seat->base.pointer)
1847 weston_pointer_clamp(seat->base.pointer,
1848 &seat->base.pointer->x,
1849 &seat->base.pointer->y);
1850 }
1851}
1852
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02001853static int
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04001854create_output_for_connector(struct drm_compositor *ec,
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001855 drmModeRes *resources,
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +01001856 drmModeConnector *connector,
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02001857 int x, int y, struct udev_device *drm_device)
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001858{
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04001859 struct drm_output *output;
Fabien DESSENNE4b255872013-12-12 17:13:56 +01001860 struct drm_mode *drm_mode, *next, *preferred, *current, *configured, *best;
Ander Conselvan de Oliveira42c46462012-08-09 16:45:00 +03001861 struct weston_mode *m;
Kristian Høgsberga30989a2013-05-23 17:23:15 -04001862 struct weston_config_section *section;
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001863 drmModeEncoder *encoder;
Kristian Høgsberga30989a2013-05-23 17:23:15 -04001864 drmModeModeInfo crtc_mode, modeline;
Kristian Høgsberg061c4252012-06-28 11:28:15 -04001865 drmModeCrtc *crtc;
Kristian Høgsberga30989a2013-05-23 17:23:15 -04001866 int i, width, height, scale;
1867 char name[32], *s;
Kristian Høgsberg2f9ed712012-07-26 17:57:15 -04001868 const char *type_name;
Kristian Høgsberga30989a2013-05-23 17:23:15 -04001869 enum output_config config;
1870 uint32_t transform;
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001871
Kristian Høgsberg9ca38462012-07-26 22:44:55 -04001872 i = find_crtc_for_connector(ec, resources, connector);
1873 if (i < 0) {
1874 weston_log("No usable crtc/encoder pair for connector.\n");
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001875 return -1;
1876 }
1877
Peter Huttererf3d62272013-08-08 11:57:05 +10001878 output = zalloc(sizeof *output);
Kristian Høgsberg9ca38462012-07-26 22:44:55 -04001879 if (output == NULL)
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001880 return -1;
1881
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001882 output->base.subpixel = drm_subpixel_to_wayland(connector->subpixel);
1883 output->base.make = "unknown";
1884 output->base.model = "unknown";
Richard Hughes2b2092a2013-04-24 14:58:02 +01001885 output->base.serial_number = "unknown";
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001886 wl_list_init(&output->base.mode_list);
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04001887
Kristian Høgsberg2f9ed712012-07-26 17:57:15 -04001888 if (connector->connector_type < ARRAY_LENGTH(connector_type_names))
1889 type_name = connector_type_names[connector->connector_type];
1890 else
1891 type_name = "UNKNOWN";
1892 snprintf(name, 32, "%s%d", type_name, connector->connector_type_id);
Richard Hughesafe690c2013-05-02 10:10:04 +01001893 output->base.name = strdup(name);
Kristian Høgsberg2f9ed712012-07-26 17:57:15 -04001894
Kristian Høgsberga30989a2013-05-23 17:23:15 -04001895 section = weston_config_get_section(ec->base.config, "output", "name",
1896 output->base.name);
1897 weston_config_section_get_string(section, "mode", &s, "preferred");
1898 if (strcmp(s, "off") == 0)
1899 config = OUTPUT_CONFIG_OFF;
1900 else if (strcmp(s, "preferred") == 0)
1901 config = OUTPUT_CONFIG_PREFERRED;
1902 else if (strcmp(s, "current") == 0)
1903 config = OUTPUT_CONFIG_CURRENT;
1904 else if (sscanf(s, "%dx%d", &width, &height) == 2)
1905 config = OUTPUT_CONFIG_MODE;
1906 else if (parse_modeline(s, &modeline) == 0)
1907 config = OUTPUT_CONFIG_MODELINE;
1908 else {
1909 weston_log("Invalid mode \"%s\" for output %s\n",
1910 s, output->base.name);
1911 config = OUTPUT_CONFIG_PREFERRED;
Alexander Larssond9a7bb72013-05-22 14:41:39 +02001912 }
Kristian Høgsberga30989a2013-05-23 17:23:15 -04001913 free(s);
1914
1915 weston_config_section_get_int(section, "scale", &scale, 1);
1916 weston_config_section_get_string(section, "transform", &s, "normal");
1917 transform = parse_transform(s, output->base.name);
1918 free(s);
Alexander Larssond9a7bb72013-05-22 14:41:39 +02001919
Rob Bradford66bd9f52013-06-25 18:56:42 +01001920 weston_config_section_get_string(section, "seat", &s, "");
1921 setup_output_seat_constraint(ec, &output->base, s);
1922 free(s);
1923
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001924 output->crtc_id = resources->crtcs[i];
Rob Clark5ca1a472012-08-08 20:27:37 -05001925 output->pipe = i;
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001926 ec->crtc_allocator |= (1 << output->crtc_id);
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001927 output->connector_id = connector->connector_id;
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001928 ec->connector_allocator |= (1 << output->connector_id);
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001929
Matt Roper361d2ad2011-08-29 13:52:23 -07001930 output->original_crtc = drmModeGetCrtc(ec->drm.fd, output->crtc_id);
Ander Conselvan de Oliveiraa0a433a2013-06-04 16:24:04 +03001931 output->dpms_prop = drm_get_prop(ec->drm.fd, connector, "DPMS");
Matt Roper361d2ad2011-08-29 13:52:23 -07001932
Kristian Høgsberg061c4252012-06-28 11:28:15 -04001933 /* Get the current mode on the crtc that's currently driving
1934 * this connector. */
1935 encoder = drmModeGetEncoder(ec->drm.fd, connector->encoder_id);
Wang Quanxianacb805a2012-07-30 18:09:46 -04001936 memset(&crtc_mode, 0, sizeof crtc_mode);
1937 if (encoder != NULL) {
1938 crtc = drmModeGetCrtc(ec->drm.fd, encoder->crtc_id);
1939 drmModeFreeEncoder(encoder);
1940 if (crtc == NULL)
1941 goto err_free;
1942 if (crtc->mode_valid)
1943 crtc_mode = crtc->mode;
1944 drmModeFreeCrtc(crtc);
1945 }
Kristian Høgsberg061c4252012-06-28 11:28:15 -04001946
David Herrmann0f0d54e2011-12-08 17:05:45 +01001947 for (i = 0; i < connector->count_modes; i++) {
Alexander Larsson0b135062013-05-28 16:23:36 +02001948 drm_mode = drm_output_add_mode(output, &connector->modes[i]);
Ander Conselvan de Oliveira42c46462012-08-09 16:45:00 +03001949 if (!drm_mode)
David Herrmann0f0d54e2011-12-08 17:05:45 +01001950 goto err_free;
1951 }
1952
Kristian Høgsberga30989a2013-05-23 17:23:15 -04001953 if (config == OUTPUT_CONFIG_OFF) {
1954 weston_log("Disabling output %s\n", output->base.name);
1955 drmModeSetCrtc(ec->drm.fd, output->crtc_id,
1956 0, 0, 0, 0, 0, NULL);
1957 goto err_free;
1958 }
1959
Kristian Høgsberg061c4252012-06-28 11:28:15 -04001960 preferred = NULL;
1961 current = NULL;
Scott Moreau8ab5d452012-07-30 19:51:08 -06001962 configured = NULL;
Fabien DESSENNE4b255872013-12-12 17:13:56 +01001963 best = NULL;
Scott Moreau8ab5d452012-07-30 19:51:08 -06001964
Giulio Camuffoc0b94872013-06-19 15:19:19 +02001965 wl_list_for_each_reverse(drm_mode, &output->base.mode_list, base.link) {
Kristian Høgsberga30989a2013-05-23 17:23:15 -04001966 if (config == OUTPUT_CONFIG_MODE &&
Alexander Larsson0b135062013-05-28 16:23:36 +02001967 width == drm_mode->base.width &&
1968 height == drm_mode->base.height)
Ander Conselvan de Oliveira42c46462012-08-09 16:45:00 +03001969 configured = drm_mode;
Wang Quanxianacb805a2012-07-30 18:09:46 -04001970 if (!memcmp(&crtc_mode, &drm_mode->mode_info, sizeof crtc_mode))
Ander Conselvan de Oliveira42c46462012-08-09 16:45:00 +03001971 current = drm_mode;
Kristian Høgsberg061c4252012-06-28 11:28:15 -04001972 if (drm_mode->base.flags & WL_OUTPUT_MODE_PREFERRED)
Ander Conselvan de Oliveira42c46462012-08-09 16:45:00 +03001973 preferred = drm_mode;
Fabien DESSENNE4b255872013-12-12 17:13:56 +01001974 best = drm_mode;
David Herrmann0f0d54e2011-12-08 17:05:45 +01001975 }
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001976
Kristian Høgsberga30989a2013-05-23 17:23:15 -04001977 if (config == OUTPUT_CONFIG_MODELINE) {
Alexander Larsson0b135062013-05-28 16:23:36 +02001978 configured = drm_output_add_mode(output, &modeline);
Ander Conselvan de Oliveira42c46462012-08-09 16:45:00 +03001979 if (!configured)
Scott Moreau8f37e0b2012-07-31 15:30:41 -06001980 goto err_free;
Scott Moreau8f37e0b2012-07-31 15:30:41 -06001981 }
1982
Wang Quanxianacb805a2012-07-30 18:09:46 -04001983 if (current == NULL && crtc_mode.clock != 0) {
Alexander Larsson0b135062013-05-28 16:23:36 +02001984 current = drm_output_add_mode(output, &crtc_mode);
Ander Conselvan de Oliveira42c46462012-08-09 16:45:00 +03001985 if (!current)
Kristian Høgsberg061c4252012-06-28 11:28:15 -04001986 goto err_free;
Kristian Høgsberg061c4252012-06-28 11:28:15 -04001987 }
1988
Kristian Høgsberga30989a2013-05-23 17:23:15 -04001989 if (config == OUTPUT_CONFIG_CURRENT)
Scott Moreau8ab5d452012-07-30 19:51:08 -06001990 configured = current;
1991
Wang Quanxianacb805a2012-07-30 18:09:46 -04001992 if (option_current_mode && current)
Hardeningff39efa2013-09-18 23:56:35 +02001993 output->base.current_mode = &current->base;
Scott Moreau8ab5d452012-07-30 19:51:08 -06001994 else if (configured)
Hardeningff39efa2013-09-18 23:56:35 +02001995 output->base.current_mode = &configured->base;
Wang Quanxianacb805a2012-07-30 18:09:46 -04001996 else if (preferred)
Hardeningff39efa2013-09-18 23:56:35 +02001997 output->base.current_mode = &preferred->base;
Wang Quanxianacb805a2012-07-30 18:09:46 -04001998 else if (current)
Hardeningff39efa2013-09-18 23:56:35 +02001999 output->base.current_mode = &current->base;
Fabien DESSENNE4b255872013-12-12 17:13:56 +01002000 else if (best)
2001 output->base.current_mode = &best->base;
Wang Quanxianacb805a2012-07-30 18:09:46 -04002002
Hardeningff39efa2013-09-18 23:56:35 +02002003 if (output->base.current_mode == NULL) {
Richard Hughesafe690c2013-05-02 10:10:04 +01002004 weston_log("no available modes for %s\n", output->base.name);
Wang Quanxianacb805a2012-07-30 18:09:46 -04002005 goto err_free;
Kristian Høgsberg061c4252012-06-28 11:28:15 -04002006 }
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04002007
Hardeningff39efa2013-09-18 23:56:35 +02002008 output->base.current_mode->flags |= WL_OUTPUT_MODE_CURRENT;
Wang Quanxianacb805a2012-07-30 18:09:46 -04002009
John Kåre Alsaker94659272012-11-13 19:10:18 +01002010 weston_output_init(&output->base, &ec->base, x, y,
2011 connector->mmWidth, connector->mmHeight,
Kristian Høgsberga30989a2013-05-23 17:23:15 -04002012 transform, scale);
John Kåre Alsaker94659272012-11-13 19:10:18 +01002013
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02002014 if (ec->use_pixman) {
2015 if (drm_output_init_pixman(output, ec) < 0) {
2016 weston_log("Failed to init output pixman state\n");
2017 goto err_output;
2018 }
2019 } else if (drm_output_init_egl(output, ec) < 0) {
Ander Conselvan de Oliveira475cf152012-12-14 13:37:29 -02002020 weston_log("Failed to init output gl state\n");
John Kåre Alsaker94659272012-11-13 19:10:18 +01002021 goto err_output;
Kristian Høgsberg1d1e0a52012-10-21 13:29:26 -04002022 }
Kristian Høgsberg8e1f77f2012-05-03 11:39:35 -04002023
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02002024 output->backlight = backlight_init(drm_device,
2025 connector->connector_type);
2026 if (output->backlight) {
Kristian Høgsberg220819f2013-05-23 20:29:40 -04002027 weston_log("Initialized backlight, device %s\n",
2028 output->backlight->path);
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02002029 output->base.set_backlight = drm_set_backlight;
2030 output->base.backlight_current = drm_get_backlight(output);
Kristian Høgsberg220819f2013-05-23 20:29:40 -04002031 } else {
2032 weston_log("Failed to initialize backlight\n");
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02002033 }
2034
Kristian Høgsberga4b7e202011-10-24 13:26:32 -04002035 wl_list_insert(ec->base.output_list.prev, &output->base.link);
2036
Richard Hughes2b2092a2013-04-24 14:58:02 +01002037 find_and_parse_output_edid(ec, output, connector);
Richard Hughesb24e48e2013-05-09 20:31:09 +01002038 if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)
2039 output->base.connection_internal = 1;
Richard Hughes2b2092a2013-04-24 14:58:02 +01002040
Jonas Ådahle5a12252013-04-05 23:07:11 +02002041 output->base.start_repaint_loop = drm_output_start_repaint_loop;
Kristian Høgsberg68c479a2012-01-25 23:32:28 -05002042 output->base.repaint = drm_output_repaint;
Matt Roper361d2ad2011-08-29 13:52:23 -07002043 output->base.destroy = drm_output_destroy;
Jesse Barnes58ef3792012-02-23 09:45:49 -05002044 output->base.assign_planes = drm_assign_planes;
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02002045 output->base.set_dpms = drm_set_dpms;
Alex Wub7b8bda2012-04-17 17:20:48 +08002046 output->base.switch_mode = drm_output_switch_mode;
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +01002047
Richard Hughese7299962013-05-01 21:52:12 +01002048 output->base.gamma_size = output->original_crtc->gamma_size;
2049 output->base.set_gamma = drm_output_set_gamma;
2050
Xiong Zhang97116532013-10-23 13:58:31 +08002051 weston_plane_init(&output->cursor_plane, &ec->base, 0, 0);
2052 weston_plane_init(&output->fb_plane, &ec->base, 0, 0);
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04002053
Ander Conselvan de Oliveira8ad19822013-03-05 17:30:27 +02002054 weston_compositor_stack_plane(&ec->base, &output->cursor_plane, NULL);
2055 weston_compositor_stack_plane(&ec->base, &output->fb_plane,
2056 &ec->base.primary_plane);
2057
Kristian Høgsberg2f9ed712012-07-26 17:57:15 -04002058 weston_log("Output %s, (connector %d, crtc %d)\n",
Richard Hughesafe690c2013-05-02 10:10:04 +01002059 output->base.name, output->connector_id, output->crtc_id);
Kristian Høgsberg061c4252012-06-28 11:28:15 -04002060 wl_list_for_each(m, &output->base.mode_list, link)
2061 weston_log_continue(" mode %dx%d@%.1f%s%s%s\n",
2062 m->width, m->height, m->refresh / 1000.0,
2063 m->flags & WL_OUTPUT_MODE_PREFERRED ?
2064 ", preferred" : "",
2065 m->flags & WL_OUTPUT_MODE_CURRENT ?
2066 ", current" : "",
2067 connector->count_modes == 0 ?
2068 ", built-in" : "");
Kristian Høgsbergfc9c5e02012-06-08 16:45:33 -04002069
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002070 return 0;
David Herrmann0f0d54e2011-12-08 17:05:45 +01002071
John Kåre Alsaker94659272012-11-13 19:10:18 +01002072err_output:
2073 weston_output_destroy(&output->base);
David Herrmann0f0d54e2011-12-08 17:05:45 +01002074err_free:
2075 wl_list_for_each_safe(drm_mode, next, &output->base.mode_list,
2076 base.link) {
2077 wl_list_remove(&drm_mode->base.link);
2078 free(drm_mode);
2079 }
2080
2081 drmModeFreeCrtc(output->original_crtc);
2082 ec->crtc_allocator &= ~(1 << output->crtc_id);
2083 ec->connector_allocator &= ~(1 << output->connector_id);
David Herrmann0f0d54e2011-12-08 17:05:45 +01002084 free(output);
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -04002085
David Herrmann0f0d54e2011-12-08 17:05:45 +01002086 return -1;
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002087}
2088
Jesse Barnes58ef3792012-02-23 09:45:49 -05002089static void
2090create_sprites(struct drm_compositor *ec)
2091{
2092 struct drm_sprite *sprite;
2093 drmModePlaneRes *plane_res;
2094 drmModePlane *plane;
Kristian Høgsberg875ab9e2012-03-30 11:52:39 -04002095 uint32_t i;
Jesse Barnes58ef3792012-02-23 09:45:49 -05002096
2097 plane_res = drmModeGetPlaneResources(ec->drm.fd);
2098 if (!plane_res) {
Martin Minarik6d118362012-06-07 18:01:59 +02002099 weston_log("failed to get plane resources: %s\n",
Jesse Barnes58ef3792012-02-23 09:45:49 -05002100 strerror(errno));
2101 return;
2102 }
2103
2104 for (i = 0; i < plane_res->count_planes; i++) {
2105 plane = drmModeGetPlane(ec->drm.fd, plane_res->planes[i]);
2106 if (!plane)
2107 continue;
2108
Peter Huttererf3d62272013-08-08 11:57:05 +10002109 sprite = zalloc(sizeof(*sprite) + ((sizeof(uint32_t)) *
Jesse Barnes58ef3792012-02-23 09:45:49 -05002110 plane->count_formats));
2111 if (!sprite) {
Martin Minarik6d118362012-06-07 18:01:59 +02002112 weston_log("%s: out of memory\n",
Jesse Barnes58ef3792012-02-23 09:45:49 -05002113 __func__);
Chris Michael8b376872014-01-02 11:39:40 +00002114 drmModeFreePlane(plane);
Jesse Barnes58ef3792012-02-23 09:45:49 -05002115 continue;
2116 }
2117
Jesse Barnes58ef3792012-02-23 09:45:49 -05002118 sprite->possible_crtcs = plane->possible_crtcs;
2119 sprite->plane_id = plane->plane_id;
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +02002120 sprite->current = NULL;
2121 sprite->next = NULL;
Jesse Barnes58ef3792012-02-23 09:45:49 -05002122 sprite->compositor = ec;
2123 sprite->count_formats = plane->count_formats;
2124 memcpy(sprite->formats, plane->formats,
Rob Clark8efbc8e2012-03-11 19:48:44 -05002125 plane->count_formats * sizeof(plane->formats[0]));
Jesse Barnes58ef3792012-02-23 09:45:49 -05002126 drmModeFreePlane(plane);
Xiong Zhang97116532013-10-23 13:58:31 +08002127 weston_plane_init(&sprite->plane, &ec->base, 0, 0);
Ander Conselvan de Oliveira8ad19822013-03-05 17:30:27 +02002128 weston_compositor_stack_plane(&ec->base, &sprite->plane,
2129 &ec->base.primary_plane);
Jesse Barnes58ef3792012-02-23 09:45:49 -05002130
2131 wl_list_insert(&ec->sprite_list, &sprite->link);
2132 }
2133
Samuel Iglesias Gonsalvezde466732013-06-13 10:03:33 +02002134 drmModeFreePlaneResources(plane_res);
Jesse Barnes58ef3792012-02-23 09:45:49 -05002135}
2136
Kristian Høgsberg85fd3272012-02-23 21:45:32 -05002137static void
2138destroy_sprites(struct drm_compositor *compositor)
2139{
2140 struct drm_sprite *sprite, *next;
2141 struct drm_output *output;
2142
2143 output = container_of(compositor->base.output_list.next,
2144 struct drm_output, base.link);
2145
2146 wl_list_for_each_safe(sprite, next, &compositor->sprite_list, link) {
2147 drmModeSetPlane(compositor->drm.fd,
2148 sprite->plane_id,
2149 output->crtc_id, 0, 0,
2150 0, 0, 0, 0, 0, 0, 0, 0);
Ander Conselvan de Oliveira526d4612013-01-25 15:13:03 +02002151 drm_output_release_fb(output, sprite->current);
2152 drm_output_release_fb(output, sprite->next);
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04002153 weston_plane_release(&sprite->plane);
Kristian Høgsberg85fd3272012-02-23 21:45:32 -05002154 free(sprite);
2155 }
2156}
Jesse Barnes58ef3792012-02-23 09:45:49 -05002157
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002158static int
Kristian Høgsberg875ab9e2012-03-30 11:52:39 -04002159create_outputs(struct drm_compositor *ec, uint32_t option_connector,
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02002160 struct udev_device *drm_device)
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002161{
2162 drmModeConnector *connector;
2163 drmModeRes *resources;
2164 int i;
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +01002165 int x = 0, y = 0;
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002166
Benjamin Franzke2af7f102011-03-02 11:14:59 +01002167 resources = drmModeGetResources(ec->drm.fd);
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002168 if (!resources) {
Martin Minarik6d118362012-06-07 18:01:59 +02002169 weston_log("drmModeGetResources failed\n");
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002170 return -1;
2171 }
2172
Jesse Barnes58ef3792012-02-23 09:45:49 -05002173 ec->crtcs = calloc(resources->count_crtcs, sizeof(uint32_t));
Christopher Michaeleb866cd2012-03-07 14:55:21 -05002174 if (!ec->crtcs) {
2175 drmModeFreeResources(resources);
Jesse Barnes58ef3792012-02-23 09:45:49 -05002176 return -1;
Christopher Michaeleb866cd2012-03-07 14:55:21 -05002177 }
Jesse Barnes58ef3792012-02-23 09:45:49 -05002178
Rob Clark4339add2012-08-09 14:18:28 -05002179 ec->min_width = resources->min_width;
2180 ec->max_width = resources->max_width;
2181 ec->min_height = resources->min_height;
2182 ec->max_height = resources->max_height;
2183
Jesse Barnes58ef3792012-02-23 09:45:49 -05002184 ec->num_crtcs = resources->count_crtcs;
2185 memcpy(ec->crtcs, resources->crtcs, sizeof(uint32_t) * ec->num_crtcs);
2186
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002187 for (i = 0; i < resources->count_connectors; i++) {
Benjamin Franzke117483d2011-08-30 11:38:26 +02002188 connector = drmModeGetConnector(ec->drm.fd,
2189 resources->connectors[i]);
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002190 if (connector == NULL)
2191 continue;
2192
2193 if (connector->connection == DRM_MODE_CONNECTED &&
2194 (option_connector == 0 ||
Benjamin Franzke9eaee352011-08-02 13:03:54 +02002195 connector->connector_id == option_connector)) {
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +01002196 if (create_output_for_connector(ec, resources,
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02002197 connector, x, y,
2198 drm_device) < 0) {
Benjamin Franzke439d9862011-10-07 08:20:53 +02002199 drmModeFreeConnector(connector);
2200 continue;
2201 }
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002202
Benjamin Franzke9eaee352011-08-02 13:03:54 +02002203 x += container_of(ec->base.output_list.prev,
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002204 struct weston_output,
Scott Moreau1bad5db2012-08-18 01:04:05 -06002205 link)->width;
Benjamin Franzke9eaee352011-08-02 13:03:54 +02002206 }
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +01002207
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002208 drmModeFreeConnector(connector);
2209 }
2210
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04002211 if (wl_list_empty(&ec->base.output_list)) {
Martin Minarik6d118362012-06-07 18:01:59 +02002212 weston_log("No currently active connector found.\n");
Christopher Michaeleb866cd2012-03-07 14:55:21 -05002213 drmModeFreeResources(resources);
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002214 return -1;
2215 }
2216
2217 drmModeFreeResources(resources);
2218
2219 return 0;
2220}
2221
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002222static void
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02002223update_outputs(struct drm_compositor *ec, struct udev_device *drm_device)
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002224{
2225 drmModeConnector *connector;
2226 drmModeRes *resources;
2227 struct drm_output *output, *next;
2228 int x = 0, y = 0;
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002229 uint32_t connected = 0, disconnects = 0;
2230 int i;
2231
2232 resources = drmModeGetResources(ec->drm.fd);
2233 if (!resources) {
Martin Minarik6d118362012-06-07 18:01:59 +02002234 weston_log("drmModeGetResources failed\n");
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002235 return;
2236 }
2237
2238 /* collect new connects */
2239 for (i = 0; i < resources->count_connectors; i++) {
Benjamin Franzke117483d2011-08-30 11:38:26 +02002240 int connector_id = resources->connectors[i];
2241
2242 connector = drmModeGetConnector(ec->drm.fd, connector_id);
David Herrmann7551cff2011-12-08 17:05:43 +01002243 if (connector == NULL)
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002244 continue;
2245
David Herrmann7551cff2011-12-08 17:05:43 +01002246 if (connector->connection != DRM_MODE_CONNECTED) {
2247 drmModeFreeConnector(connector);
2248 continue;
2249 }
2250
Benjamin Franzke117483d2011-08-30 11:38:26 +02002251 connected |= (1 << connector_id);
2252
2253 if (!(ec->connector_allocator & (1 << connector_id))) {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002254 struct weston_output *last =
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002255 container_of(ec->base.output_list.prev,
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002256 struct weston_output, link);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002257
2258 /* XXX: not yet needed, we die with 0 outputs */
2259 if (!wl_list_empty(&ec->base.output_list))
Scott Moreau1bad5db2012-08-18 01:04:05 -06002260 x = last->x + last->width;
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002261 else
2262 x = 0;
2263 y = 0;
2264 create_output_for_connector(ec, resources,
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02002265 connector, x, y,
2266 drm_device);
Martin Minarik6d118362012-06-07 18:01:59 +02002267 weston_log("connector %d connected\n", connector_id);
Benjamin Franzke117483d2011-08-30 11:38:26 +02002268
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002269 }
2270 drmModeFreeConnector(connector);
2271 }
2272 drmModeFreeResources(resources);
2273
2274 disconnects = ec->connector_allocator & ~connected;
2275 if (disconnects) {
2276 wl_list_for_each_safe(output, next, &ec->base.output_list,
2277 base.link) {
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002278 if (disconnects & (1 << output->connector_id)) {
2279 disconnects &= ~(1 << output->connector_id);
Martin Minarik6d118362012-06-07 18:01:59 +02002280 weston_log("connector %d disconnected\n",
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002281 output->connector_id);
Benjamin Franzke48c4ea22011-08-30 11:44:56 +02002282 drm_output_destroy(&output->base);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002283 }
2284 }
2285 }
2286
2287 /* FIXME: handle zero outputs, without terminating */
2288 if (ec->connector_allocator == 0)
2289 wl_display_terminate(ec->base.wl_display);
2290}
2291
2292static int
David Herrmannd7488c22012-03-11 20:05:21 +01002293udev_event_is_hotplug(struct drm_compositor *ec, struct udev_device *device)
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002294{
David Herrmannd7488c22012-03-11 20:05:21 +01002295 const char *sysnum;
David Herrmann6ac52db2012-03-11 20:05:22 +01002296 const char *val;
David Herrmannd7488c22012-03-11 20:05:21 +01002297
2298 sysnum = udev_device_get_sysnum(device);
2299 if (!sysnum || atoi(sysnum) != ec->drm.id)
2300 return 0;
Benjamin Franzke117483d2011-08-30 11:38:26 +02002301
David Herrmann6ac52db2012-03-11 20:05:22 +01002302 val = udev_device_get_property_value(device, "HOTPLUG");
2303 if (!val)
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002304 return 0;
2305
David Herrmann6ac52db2012-03-11 20:05:22 +01002306 return strcmp(val, "1") == 0;
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002307}
2308
Kristian Høgsbergb1868472011-04-22 12:27:57 -04002309static int
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002310udev_drm_event(int fd, uint32_t mask, void *data)
2311{
2312 struct drm_compositor *ec = data;
2313 struct udev_device *event;
2314
2315 event = udev_monitor_receive_device(ec->udev_monitor);
Benjamin Franzke117483d2011-08-30 11:38:26 +02002316
David Herrmannd7488c22012-03-11 20:05:21 +01002317 if (udev_event_is_hotplug(ec, event))
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02002318 update_outputs(ec, event);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002319
2320 udev_device_unref(event);
Kristian Høgsbergb1868472011-04-22 12:27:57 -04002321
2322 return 1;
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002323}
2324
Kristian Høgsbergcaa64422010-12-01 16:52:15 -05002325static void
Kristian Høgsberg7b884bc2012-07-31 14:32:01 -04002326drm_restore(struct weston_compositor *ec)
2327{
Kristian Høgsberg3f495872013-09-18 23:00:17 -07002328 weston_launcher_restore(ec->launcher);
Kristian Høgsberg7b884bc2012-07-31 14:32:01 -04002329}
2330
2331static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002332drm_destroy(struct weston_compositor *ec)
Kristian Høgsbergcaa64422010-12-01 16:52:15 -05002333{
2334 struct drm_compositor *d = (struct drm_compositor *) ec;
2335
Rob Bradfordd355b802013-05-31 18:09:55 +01002336 udev_input_destroy(&d->input);
Jonas Ådahlc97af922012-03-28 22:36:09 +02002337
2338 wl_event_source_remove(d->udev_drm_source);
2339 wl_event_source_remove(d->drm_source);
2340
Kristian Høgsberg3d64a3e2013-05-10 12:36:04 -04002341 destroy_sprites(d);
2342
Ander Conselvan de Oliveira6b162142013-10-25 16:26:32 +03002343 weston_compositor_shutdown(ec);
2344
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02002345 if (d->gbm)
2346 gbm_device_destroy(d->gbm);
2347
Kristian Høgsberg3f495872013-09-18 23:00:17 -07002348 weston_launcher_destroy(d->base.launcher);
Kristian Høgsbergcaa64422010-12-01 16:52:15 -05002349
Rob Bradford45c15b82013-07-26 16:29:35 +01002350 close(d->drm.fd);
2351
Kristian Høgsberge4762a62011-01-14 14:59:13 -05002352 free(d);
Kristian Høgsbergcaa64422010-12-01 16:52:15 -05002353}
2354
Kristian Høgsberg9396fc52011-05-06 15:15:37 -04002355static void
Kristian Høgsberg835cd492012-01-18 11:48:46 -05002356drm_compositor_set_modes(struct drm_compositor *compositor)
2357{
2358 struct drm_output *output;
2359 struct drm_mode *drm_mode;
2360 int ret;
2361
2362 wl_list_for_each(output, &compositor->base.output_list, base.link) {
Ander Conselvan de Oliveira2002f882013-02-26 13:44:58 +02002363 if (!output->current) {
2364 /* If something that would cause the output to
2365 * switch mode happened while in another vt, we
2366 * might not have a current drm_fb. In that case,
2367 * schedule a repaint and let drm_output_repaint
2368 * handle setting the mode. */
2369 weston_output_schedule_repaint(&output->base);
2370 continue;
2371 }
2372
Hardeningff39efa2013-09-18 23:56:35 +02002373 drm_mode = (struct drm_mode *) output->base.current_mode;
Kristian Høgsberg835cd492012-01-18 11:48:46 -05002374 ret = drmModeSetCrtc(compositor->drm.fd, output->crtc_id,
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +03002375 output->current->fb_id, 0, 0,
Kristian Høgsberg835cd492012-01-18 11:48:46 -05002376 &output->connector_id, 1,
2377 &drm_mode->mode_info);
2378 if (ret < 0) {
Martin Minarik6d118362012-06-07 18:01:59 +02002379 weston_log(
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -04002380 "failed to set mode %dx%d for output at %d,%d: %m\n",
Kristian Høgsberg835cd492012-01-18 11:48:46 -05002381 drm_mode->base.width, drm_mode->base.height,
2382 output->base.x, output->base.y);
2383 }
2384 }
2385}
2386
2387static void
Kristian Høgsberg61741a22013-09-17 16:02:57 -07002388session_notify(struct wl_listener *listener, void *data)
Kristian Høgsberg9396fc52011-05-06 15:15:37 -04002389{
Kristian Høgsberg61741a22013-09-17 16:02:57 -07002390 struct weston_compositor *compositor = data;
2391 struct drm_compositor *ec = data;
Kristian Høgsberg85fd3272012-02-23 21:45:32 -05002392 struct drm_sprite *sprite;
Kristian Høgsberga6edab32012-07-14 01:06:28 -04002393 struct drm_output *output;
Kristian Høgsberg9396fc52011-05-06 15:15:37 -04002394
Kristian Høgsberg61741a22013-09-17 16:02:57 -07002395 if (ec->base.session_active) {
2396 weston_log("activating session\n");
Pekka Paalanenbce2d3f2011-12-02 13:07:27 +02002397 compositor->state = ec->prev_state;
Kristian Høgsberg835cd492012-01-18 11:48:46 -05002398 drm_compositor_set_modes(ec);
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002399 weston_compositor_damage_all(compositor);
Rob Bradfordd355b802013-05-31 18:09:55 +01002400 udev_input_enable(&ec->input, ec->udev);
Kristian Høgsberg61741a22013-09-17 16:02:57 -07002401 } else {
2402 weston_log("deactivating session\n");
Rob Bradfordd355b802013-05-31 18:09:55 +01002403 udev_input_disable(&ec->input);
Kristian Høgsberg4014a6b2012-04-10 00:08:45 -04002404
Pekka Paalanenbce2d3f2011-12-02 13:07:27 +02002405 ec->prev_state = compositor->state;
Philipp Brüschweiler57edf7f2013-03-29 13:01:56 +01002406 weston_compositor_offscreen(compositor);
Kristian Høgsbergd8e181b2011-05-06 15:38:28 -04002407
Kristian Høgsberg34f80ff2012-01-18 11:50:31 -05002408 /* If we have a repaint scheduled (either from a
2409 * pending pageflip or the idle handler), make sure we
2410 * cancel that so we don't try to pageflip when we're
Philipp Brüschweiler57edf7f2013-03-29 13:01:56 +01002411 * vt switched away. The OFFSCREEN state will prevent
Kristian Høgsberg34f80ff2012-01-18 11:50:31 -05002412 * further attemps at repainting. When we switch
2413 * back, we schedule a repaint, which will process
2414 * pending frame callbacks. */
2415
Kristian Høgsberga6edab32012-07-14 01:06:28 -04002416 wl_list_for_each(output, &ec->base.output_list, base.link) {
2417 output->base.repaint_needed = 0;
2418 drmModeSetCursor(ec->drm.fd, output->crtc_id, 0, 0, 0);
Kristian Høgsberg34f80ff2012-01-18 11:50:31 -05002419 }
2420
Kristian Høgsberga6edab32012-07-14 01:06:28 -04002421 output = container_of(ec->base.output_list.next,
2422 struct drm_output, base.link);
Kristian Høgsberg85fd3272012-02-23 21:45:32 -05002423
2424 wl_list_for_each(sprite, &ec->sprite_list, link)
2425 drmModeSetPlane(ec->drm.fd,
2426 sprite->plane_id,
Kristian Høgsberga6edab32012-07-14 01:06:28 -04002427 output->crtc_id, 0, 0,
Kristian Høgsberg85fd3272012-02-23 21:45:32 -05002428 0, 0, 0, 0, 0, 0, 0, 0);
Kristian Høgsberg9396fc52011-05-06 15:15:37 -04002429 };
2430}
2431
Kristian Høgsberg5d1c0c52012-04-10 00:11:50 -04002432static void
Kristian Høgsberge3148752013-05-06 23:19:49 -04002433switch_vt_binding(struct weston_seat *seat, uint32_t time, uint32_t key, void *data)
Kristian Høgsberg5d1c0c52012-04-10 00:11:50 -04002434{
Kristian Høgsberg3f495872013-09-18 23:00:17 -07002435 struct weston_compositor *compositor = data;
Kristian Høgsberg5d1c0c52012-04-10 00:11:50 -04002436
Kristian Høgsberg3f495872013-09-18 23:00:17 -07002437 weston_launcher_activate_vt(compositor->launcher, key - KEY_F1 + 1);
Kristian Høgsberg5d1c0c52012-04-10 00:11:50 -04002438}
2439
David Herrmann0af066f2012-10-29 19:21:16 +01002440/*
2441 * Find primary GPU
2442 * Some systems may have multiple DRM devices attached to a single seat. This
2443 * function loops over all devices and tries to find a PCI device with the
2444 * boot_vga sysfs attribute set to 1.
2445 * If no such device is found, the first DRM device reported by udev is used.
2446 */
2447static struct udev_device*
2448find_primary_gpu(struct drm_compositor *ec, const char *seat)
2449{
2450 struct udev_enumerate *e;
2451 struct udev_list_entry *entry;
2452 const char *path, *device_seat, *id;
2453 struct udev_device *device, *drm_device, *pci;
2454
2455 e = udev_enumerate_new(ec->udev);
2456 udev_enumerate_add_match_subsystem(e, "drm");
2457 udev_enumerate_add_match_sysname(e, "card[0-9]*");
2458
2459 udev_enumerate_scan_devices(e);
2460 drm_device = NULL;
2461 udev_list_entry_foreach(entry, udev_enumerate_get_list_entry(e)) {
2462 path = udev_list_entry_get_name(entry);
2463 device = udev_device_new_from_syspath(ec->udev, path);
2464 if (!device)
2465 continue;
2466 device_seat = udev_device_get_property_value(device, "ID_SEAT");
2467 if (!device_seat)
2468 device_seat = default_seat;
2469 if (strcmp(device_seat, seat)) {
2470 udev_device_unref(device);
2471 continue;
2472 }
2473
2474 pci = udev_device_get_parent_with_subsystem_devtype(device,
2475 "pci", NULL);
2476 if (pci) {
2477 id = udev_device_get_sysattr_value(pci, "boot_vga");
2478 if (id && !strcmp(id, "1")) {
2479 if (drm_device)
2480 udev_device_unref(drm_device);
2481 drm_device = device;
2482 break;
2483 }
2484 }
2485
2486 if (!drm_device)
2487 drm_device = device;
2488 else
2489 udev_device_unref(device);
2490 }
2491
2492 udev_enumerate_unref(e);
2493 return drm_device;
2494}
2495
Ander Conselvan de Oliveirada1c9082012-10-31 17:55:46 +02002496static void
Kristian Høgsberge3148752013-05-06 23:19:49 -04002497planes_binding(struct weston_seat *seat, uint32_t time, uint32_t key, void *data)
Ander Conselvan de Oliveirada1c9082012-10-31 17:55:46 +02002498{
2499 struct drm_compositor *c = data;
2500
Ander Conselvan de Oliveira7e918da2012-11-22 15:56:59 +02002501 switch (key) {
2502 case KEY_C:
2503 c->cursors_are_broken ^= 1;
2504 break;
2505 case KEY_V:
2506 c->sprites_are_broken ^= 1;
2507 break;
2508 case KEY_O:
2509 c->sprites_hidden ^= 1;
2510 break;
2511 default:
2512 break;
2513 }
Ander Conselvan de Oliveira180f42a2012-11-21 15:11:37 +02002514}
2515
Kristian Høgsberg0eac34a2013-08-30 14:28:22 -07002516#ifdef BUILD_VAAPI_RECORDER
Ander Conselvan de Oliveira6aae4d32013-08-23 17:15:48 +03002517static void
2518recorder_frame_notify(struct wl_listener *listener, void *data)
2519{
2520 struct drm_output *output;
2521 struct drm_compositor *c;
2522 int fd, ret;
2523
2524 output = container_of(listener, struct drm_output,
2525 recorder_frame_listener);
2526 c = (struct drm_compositor *) output->base.compositor;
2527
2528 if (!output->recorder)
2529 return;
2530
2531 ret = drmPrimeHandleToFD(c->drm.fd, output->current->handle,
2532 DRM_CLOEXEC, &fd);
2533 if (ret) {
2534 weston_log("[libva recorder] "
2535 "failed to create prime fd for front buffer\n");
2536 return;
2537 }
2538
2539 vaapi_recorder_frame(output->recorder, fd, output->current->stride / 4);
Ander Conselvan de Oliveira6aae4d32013-08-23 17:15:48 +03002540}
2541
2542static void *
2543create_recorder(struct drm_compositor *c, int width, int height,
2544 const char *filename)
2545{
2546 int fd;
2547 drm_magic_t magic;
2548
2549 fd = open(c->drm.filename, O_RDWR | O_CLOEXEC);
2550 if (fd < 0)
2551 return NULL;
2552
2553 drmGetMagic(fd, &magic);
2554 drmAuthMagic(c->drm.fd, magic);
2555
2556 return vaapi_recorder_create(fd, width, height, filename);
2557}
2558
2559static void
2560recorder_binding(struct weston_seat *seat, uint32_t time, uint32_t key,
2561 void *data)
2562{
2563 struct drm_compositor *c = data;
2564 struct drm_output *output;
2565 int width, height;
2566
2567 output = container_of(c->base.output_list.next,
2568 struct drm_output, base.link);
2569
2570 if (!output->recorder) {
Hardeningff39efa2013-09-18 23:56:35 +02002571 width = output->base.current_mode->width;
2572 height = output->base.current_mode->height;
Ander Conselvan de Oliveira6aae4d32013-08-23 17:15:48 +03002573
2574 output->recorder =
2575 create_recorder(c, width, height, "capture.h264");
2576 if (!output->recorder) {
2577 weston_log("failed to create vaapi recorder\n");
2578 return;
2579 }
2580
2581 output->base.disable_planes++;
2582
2583 output->recorder_frame_listener.notify = recorder_frame_notify;
2584 wl_signal_add(&output->base.frame_signal,
2585 &output->recorder_frame_listener);
2586
2587 weston_output_schedule_repaint(&output->base);
2588
2589 weston_log("[libva recorder] initialized\n");
2590 } else {
2591 vaapi_recorder_destroy(output->recorder);
Ander Conselvan de Oliveira6aae4d32013-08-23 17:15:48 +03002592 output->recorder = NULL;
2593
2594 output->base.disable_planes--;
2595
2596 wl_list_remove(&output->recorder_frame_listener.link);
2597 weston_log("[libva recorder] done\n");
2598 }
2599}
2600#else
2601static void
2602recorder_binding(struct weston_seat *seat, uint32_t time, uint32_t key,
2603 void *data)
2604{
2605 weston_log("Compiled without libva support\n");
2606}
2607#endif
2608
Ander Conselvan de Oliveira65796812013-11-19 15:22:04 +02002609static void
2610switch_to_gl_renderer(struct drm_compositor *c)
2611{
2612 struct drm_output *output;
2613
2614 if (!c->use_pixman)
2615 return;
2616
2617 weston_log("Switching to GL renderer\n");
2618
2619 c->gbm = create_gbm_device(c->drm.fd);
2620 if (!c->gbm) {
2621 weston_log("Failed to create gbm device. "
2622 "Aborting renderer switch\n");
2623 return;
2624 }
2625
2626 wl_list_for_each(output, &c->base.output_list, base.link)
2627 pixman_renderer_output_destroy(&output->base);
2628
2629 c->base.renderer->destroy(&c->base);
2630
2631 if (drm_compositor_create_gl_renderer(c) < 0) {
2632 gbm_device_destroy(c->gbm);
2633 weston_log("Failed to create GL renderer. Quitting.\n");
2634 /* FIXME: we need a function to shutdown cleanly */
2635 assert(0);
2636 }
2637
2638 wl_list_for_each(output, &c->base.output_list, base.link)
2639 drm_output_init_egl(output, c);
2640
2641 c->use_pixman = 0;
2642}
2643
2644static void
2645renderer_switch_binding(struct weston_seat *seat, uint32_t time, uint32_t key,
2646 void *data)
2647{
2648 struct drm_compositor *c = (struct drm_compositor *) seat->compositor;
2649
2650 switch_to_gl_renderer(c);
2651}
2652
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002653static struct weston_compositor *
Kristian Høgsberg8d51f142011-07-15 21:28:38 -04002654drm_compositor_create(struct wl_display *display,
Kristian Høgsbergd8e98332013-10-16 16:15:11 -07002655 struct drm_parameters *param,
Kristian Høgsberg14e438c2013-05-26 21:48:14 -04002656 int *argc, char *argv[],
2657 struct weston_config *config)
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002658{
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04002659 struct drm_compositor *ec;
Kristian Høgsberg8e6f3762013-10-16 16:31:42 -07002660 struct weston_config_section *section;
David Herrmann0af066f2012-10-29 19:21:16 +01002661 struct udev_device *drm_device;
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002662 struct wl_event_loop *loop;
David Herrmann0af066f2012-10-29 19:21:16 +01002663 const char *path;
Kristian Høgsberg8e6f3762013-10-16 16:31:42 -07002664 char *s;
Kristian Høgsberg5d1c0c52012-04-10 00:11:50 -04002665 uint32_t key;
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002666
Kristian Høgsbergfc9c5e02012-06-08 16:45:33 -04002667 weston_log("initializing drm backend\n");
2668
Peter Huttererf3d62272013-08-08 11:57:05 +10002669 ec = zalloc(sizeof *ec);
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04002670 if (ec == NULL)
2671 return NULL;
Daniel Stone725c2c32012-06-22 14:04:36 +01002672
Kristian Høgsbergde37d672012-11-02 10:14:40 -04002673 /* KMS support for sprites is not complete yet, so disable the
2674 * functionality for now. */
2675 ec->sprites_are_broken = 1;
Kristian Høgsberg8e6f3762013-10-16 16:31:42 -07002676
2677 section = weston_config_get_section(config, "core", NULL, NULL);
2678 weston_config_section_get_string(section,
2679 "gbm-format", &s, "xrgb8888");
2680 if (strcmp(s, "xrgb8888") == 0)
2681 ec->format = GBM_FORMAT_XRGB8888;
2682 else if (strcmp(s, "rgb565") == 0)
2683 ec->format = GBM_FORMAT_RGB565;
2684 else if (strcmp(s, "xrgb2101010") == 0)
2685 ec->format = GBM_FORMAT_XRGB2101010;
2686 else {
2687 weston_log("fatal: unrecognized pixel format: %s\n", s);
2688 free(s);
2689 goto err_base;
2690 }
2691 free(s);
2692
Kristian Høgsbergd8e98332013-10-16 16:15:11 -07002693 ec->use_pixman = param->use_pixman;
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02002694
Daniel Stone725c2c32012-06-22 14:04:36 +01002695 if (weston_compositor_init(&ec->base, display, argc, argv,
Kristian Høgsberg14e438c2013-05-26 21:48:14 -04002696 config) < 0) {
Scott Moreau8eb67482013-02-23 12:04:56 -07002697 weston_log("%s failed\n", __func__);
Daniel Stonea96b93c2012-06-22 14:04:37 +01002698 goto err_base;
2699 }
Daniel Stone725c2c32012-06-22 14:04:36 +01002700
Rafal Mielniczuk32069c02013-03-27 18:39:28 +01002701 /* Check if we run drm-backend using weston-launch */
David Herrmanncc5b2ed2013-10-22 00:28:09 +02002702 ec->base.launcher = weston_launcher_connect(&ec->base, param->tty,
2703 param->seat_id);
Kristian Høgsberg3f495872013-09-18 23:00:17 -07002704 if (ec->base.launcher == NULL) {
Rafal Mielniczuk32069c02013-03-27 18:39:28 +01002705 weston_log("fatal: drm backend should be run "
Kristian Høgsbergb76237e2013-04-04 21:36:20 -04002706 "using weston-launch binary or as root\n");
Rafal Mielniczuk32069c02013-03-27 18:39:28 +01002707 goto err_compositor;
2708 }
2709
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002710 ec->udev = udev_new();
2711 if (ec->udev == NULL) {
Martin Minarik6d118362012-06-07 18:01:59 +02002712 weston_log("failed to initialize udev context\n");
Kristian Høgsberg3f495872013-09-18 23:00:17 -07002713 goto err_launcher;
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002714 }
2715
Kristian Høgsbergc5b9ddb2012-01-15 14:29:09 -05002716 ec->base.wl_display = display;
Kristian Høgsberg61741a22013-09-17 16:02:57 -07002717 ec->session_listener.notify = session_notify;
2718 wl_signal_add(&ec->base.session_signal, &ec->session_listener);
Kristian Høgsbergc5b9ddb2012-01-15 14:29:09 -05002719
Kristian Høgsbergd8e98332013-10-16 16:15:11 -07002720 drm_device = find_primary_gpu(ec, param->seat_id);
Kristian Høgsberg8d51f142011-07-15 21:28:38 -04002721 if (drm_device == NULL) {
Martin Minarik6d118362012-06-07 18:01:59 +02002722 weston_log("no drm device found\n");
Kristian Høgsberg3f495872013-09-18 23:00:17 -07002723 goto err_udev;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04002724 }
David Herrmann0af066f2012-10-29 19:21:16 +01002725 path = udev_device_get_syspath(drm_device);
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002726
Ander Conselvan de Oliveira22929172013-01-25 15:13:02 +02002727 if (init_drm(ec, drm_device) < 0) {
2728 weston_log("failed to initialize kms\n");
2729 goto err_udev_dev;
2730 }
2731
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02002732 if (ec->use_pixman) {
2733 if (init_pixman(ec) < 0) {
2734 weston_log("failed to initialize pixman renderer\n");
2735 goto err_udev_dev;
2736 }
2737 } else {
2738 if (init_egl(ec) < 0) {
2739 weston_log("failed to initialize egl\n");
2740 goto err_udev_dev;
2741 }
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04002742 }
Kristian Høgsberg8525a502011-01-14 16:20:21 -05002743
2744 ec->base.destroy = drm_destroy;
Kristian Høgsberg7b884bc2012-07-31 14:32:01 -04002745 ec->base.restore = drm_restore;
Benjamin Franzke431da9a2011-04-20 11:02:58 +02002746
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002747 ec->prev_state = WESTON_COMPOSITOR_ACTIVE;
Pekka Paalanenbce2d3f2011-12-02 13:07:27 +02002748
Kristian Høgsberg5d1c0c52012-04-10 00:11:50 -04002749 for (key = KEY_F1; key < KEY_F9; key++)
Daniel Stone325fc2d2012-05-30 16:31:58 +01002750 weston_compositor_add_key_binding(&ec->base, key,
2751 MODIFIER_CTRL | MODIFIER_ALT,
2752 switch_vt_binding, ec);
Kristian Høgsberg5d1c0c52012-04-10 00:11:50 -04002753
Jesse Barnes58ef3792012-02-23 09:45:49 -05002754 wl_list_init(&ec->sprite_list);
2755 create_sprites(ec);
2756
Kristian Høgsbergd8e98332013-10-16 16:15:11 -07002757 if (create_outputs(ec, param->connector, drm_device) < 0) {
Martin Minarik6d118362012-06-07 18:01:59 +02002758 weston_log("failed to create output for %s\n", path);
Daniel Stonea96b93c2012-06-22 14:04:37 +01002759 goto err_sprite;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04002760 }
2761
Benjamin Franzke02dee2c2011-10-07 08:27:26 +02002762 path = NULL;
2763
Kristian Høgsbergd8e98332013-10-16 16:15:11 -07002764 if (udev_input_init(&ec->input,
2765 &ec->base, ec->udev, param->seat_id) < 0) {
Kristian Høgsberg2f07ef62013-02-16 14:29:24 -05002766 weston_log("failed to create input devices\n");
2767 goto err_sprite;
2768 }
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04002769
2770 loop = wl_display_get_event_loop(ec->base.wl_display);
2771 ec->drm_source =
Benjamin Franzke2af7f102011-03-02 11:14:59 +01002772 wl_event_loop_add_fd(loop, ec->drm.fd,
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04002773 WL_EVENT_READABLE, on_drm_input, ec);
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04002774
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002775 ec->udev_monitor = udev_monitor_new_from_netlink(ec->udev, "udev");
2776 if (ec->udev_monitor == NULL) {
Martin Minarik6d118362012-06-07 18:01:59 +02002777 weston_log("failed to intialize udev monitor\n");
Daniel Stonea96b93c2012-06-22 14:04:37 +01002778 goto err_drm_source;
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002779 }
2780 udev_monitor_filter_add_match_subsystem_devtype(ec->udev_monitor,
2781 "drm", NULL);
2782 ec->udev_drm_source =
Benjamin Franzke117483d2011-08-30 11:38:26 +02002783 wl_event_loop_add_fd(loop,
2784 udev_monitor_get_fd(ec->udev_monitor),
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002785 WL_EVENT_READABLE, udev_drm_event, ec);
2786
2787 if (udev_monitor_enable_receiving(ec->udev_monitor) < 0) {
Martin Minarik6d118362012-06-07 18:01:59 +02002788 weston_log("failed to enable udev-monitor receiving\n");
Daniel Stonea96b93c2012-06-22 14:04:37 +01002789 goto err_udev_monitor;
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002790 }
2791
Daniel Stonea96b93c2012-06-22 14:04:37 +01002792 udev_device_unref(drm_device);
Daniel Stonea96b93c2012-06-22 14:04:37 +01002793
Ander Conselvan de Oliveirac509d2b2012-11-08 17:20:45 +02002794 weston_compositor_add_debug_binding(&ec->base, KEY_O,
Ander Conselvan de Oliveira7e918da2012-11-22 15:56:59 +02002795 planes_binding, ec);
Ander Conselvan de Oliveira180f42a2012-11-21 15:11:37 +02002796 weston_compositor_add_debug_binding(&ec->base, KEY_C,
Ander Conselvan de Oliveira7e918da2012-11-22 15:56:59 +02002797 planes_binding, ec);
2798 weston_compositor_add_debug_binding(&ec->base, KEY_V,
2799 planes_binding, ec);
Ander Conselvan de Oliveira6aae4d32013-08-23 17:15:48 +03002800 weston_compositor_add_debug_binding(&ec->base, KEY_Q,
2801 recorder_binding, ec);
Ander Conselvan de Oliveira65796812013-11-19 15:22:04 +02002802 weston_compositor_add_debug_binding(&ec->base, KEY_W,
2803 renderer_switch_binding, ec);
Ander Conselvan de Oliveirada1c9082012-10-31 17:55:46 +02002804
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04002805 return &ec->base;
Daniel Stonea96b93c2012-06-22 14:04:37 +01002806
2807err_udev_monitor:
2808 wl_event_source_remove(ec->udev_drm_source);
2809 udev_monitor_unref(ec->udev_monitor);
2810err_drm_source:
2811 wl_event_source_remove(ec->drm_source);
Rob Bradfordd355b802013-05-31 18:09:55 +01002812 udev_input_destroy(&ec->input);
Kristian Høgsberg2bc5e8e2012-09-06 20:51:00 -04002813err_sprite:
Vasily Khoruzhick52cfd612013-01-08 19:09:01 +03002814 ec->base.renderer->destroy(&ec->base);
John Kåre Alsaker1b7ad162012-11-13 19:10:19 +01002815 gbm_device_destroy(ec->gbm);
Kristian Høgsberg2bc5e8e2012-09-06 20:51:00 -04002816 destroy_sprites(ec);
Daniel Stonea96b93c2012-06-22 14:04:37 +01002817err_udev_dev:
2818 udev_device_unref(drm_device);
Kristian Høgsberg3f495872013-09-18 23:00:17 -07002819err_launcher:
2820 weston_launcher_destroy(ec->base.launcher);
Daniel Stonea96b93c2012-06-22 14:04:37 +01002821err_udev:
2822 udev_unref(ec->udev);
2823err_compositor:
2824 weston_compositor_shutdown(&ec->base);
2825err_base:
2826 free(ec);
2827 return NULL;
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002828}
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002829
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002830WL_EXPORT struct weston_compositor *
Kristian Høgsberg4172f662013-02-20 15:27:49 -05002831backend_init(struct wl_display *display, int *argc, char *argv[],
Kristian Høgsberg14e438c2013-05-26 21:48:14 -04002832 struct weston_config *config)
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002833{
Kristian Høgsbergd8e98332013-10-16 16:15:11 -07002834 struct drm_parameters param = { 0, };
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002835
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04002836 const struct weston_option drm_options[] = {
Kristian Høgsbergd8e98332013-10-16 16:15:11 -07002837 { WESTON_OPTION_INTEGER, "connector", 0, &param.connector },
2838 { WESTON_OPTION_STRING, "seat", 0, &param.seat_id },
2839 { WESTON_OPTION_INTEGER, "tty", 0, &param.tty },
Kristian Høgsberg061c4252012-06-28 11:28:15 -04002840 { WESTON_OPTION_BOOLEAN, "current-mode", 0, &option_current_mode },
Kristian Høgsbergd8e98332013-10-16 16:15:11 -07002841 { WESTON_OPTION_BOOLEAN, "use-pixman", 0, &param.use_pixman },
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04002842 };
Benjamin Franzke117483d2011-08-30 11:38:26 +02002843
Kristian Høgsbergd8e98332013-10-16 16:15:11 -07002844 param.seat_id = default_seat;
2845
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04002846 parse_options(drm_options, ARRAY_LENGTH(drm_options), argc, argv);
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002847
Kristian Høgsbergd8e98332013-10-16 16:15:11 -07002848 return drm_compositor_create(display, &param, argc, argv, config);
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002849}