blob: 6e0a126dbf14fa47b2961e688e359592c36aa769 [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
Kristian Høgsberg0b9334a2011-04-12 11:34:32 -040024#define _GNU_SOURCE
25
Jesse Barnes58ef3792012-02-23 09:45:49 -050026#include <errno.h>
Kristian Høgsbergfc783d42010-06-11 12:56:24 -040027#include <stdlib.h>
28#include <string.h>
29#include <fcntl.h>
30#include <unistd.h>
Kristian Høgsberg5d1c0c52012-04-10 00:11:50 -040031#include <linux/input.h>
Ander Conselvan de Oliveirafd1f4c62012-06-26 17:09:14 +030032#include <assert.h>
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +020033#include <sys/mman.h>
Kristian Høgsbergfc783d42010-06-11 12:56:24 -040034
Benjamin Franzkec649a922011-03-02 11:56:04 +010035#include <xf86drm.h>
36#include <xf86drmMode.h>
Jesse Barnes58ef3792012-02-23 09:45:49 -050037#include <drm_fourcc.h>
Benjamin Franzkec649a922011-03-02 11:56:04 +010038
Benjamin Franzke060cf802011-04-30 09:32:11 +020039#include <gbm.h>
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +020040#include <libbacklight.h>
Pekka Paalanen33156972012-08-03 13:30:30 -040041#include <libudev.h>
Benjamin Franzke060cf802011-04-30 09:32:11 +020042
Kristian Høgsbergfc783d42010-06-11 12:56:24 -040043#include "compositor.h"
John Kåre Alsaker30d2b1f2012-11-13 19:10:28 +010044#include "gl-renderer.h"
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +020045#include "pixman-renderer.h"
Kristian Høgsberg98cfea62013-02-18 16:15:53 -050046#include "udev-seat.h"
Benjamin Franzkebfeda132012-01-30 14:04:04 +010047#include "launcher-util.h"
Kristian Høgsbergfc783d42010-06-11 12:56:24 -040048
Kristian Høgsberg061c4252012-06-28 11:28:15 -040049static int option_current_mode = 0;
Scott Moreau8ab5d452012-07-30 19:51:08 -060050static char *output_name;
51static char *output_mode;
Scott Moreau1bad5db2012-08-18 01:04:05 -060052static char *output_transform;
Scott Moreau8ab5d452012-07-30 19:51:08 -060053static struct wl_list configured_output_list;
54
55enum output_config {
56 OUTPUT_CONFIG_INVALID = 0,
57 OUTPUT_CONFIG_OFF,
58 OUTPUT_CONFIG_PREFERRED,
59 OUTPUT_CONFIG_CURRENT,
Scott Moreau8f37e0b2012-07-31 15:30:41 -060060 OUTPUT_CONFIG_MODE,
61 OUTPUT_CONFIG_MODELINE
Scott Moreau8ab5d452012-07-30 19:51:08 -060062};
63
64struct drm_configured_output {
65 char *name;
66 char *mode;
Scott Moreau1bad5db2012-08-18 01:04:05 -060067 uint32_t transform;
Scott Moreau8ab5d452012-07-30 19:51:08 -060068 int32_t width, height;
Scott Moreau8f37e0b2012-07-31 15:30:41 -060069 drmModeModeInfo crtc_mode;
Scott Moreau8ab5d452012-07-30 19:51:08 -060070 enum output_config config;
71 struct wl_list link;
72};
Kristian Høgsberg061c4252012-06-28 11:28:15 -040073
Kristian Høgsbergce5325d2010-06-14 11:54:00 -040074struct drm_compositor {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -050075 struct weston_compositor base;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -040076
77 struct udev *udev;
78 struct wl_event_source *drm_source;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -040079
Benjamin Franzke9c26ff32011-03-15 15:08:41 +010080 struct udev_monitor *udev_monitor;
81 struct wl_event_source *udev_drm_source;
82
Benjamin Franzke2af7f102011-03-02 11:14:59 +010083 struct {
David Herrmannd7488c22012-03-11 20:05:21 +010084 int id;
Benjamin Franzke2af7f102011-03-02 11:14:59 +010085 int fd;
86 } drm;
Benjamin Franzke060cf802011-04-30 09:32:11 +020087 struct gbm_device *gbm;
Jesse Barnes58ef3792012-02-23 09:45:49 -050088 uint32_t *crtcs;
89 int num_crtcs;
Marty Jack13d9db22011-02-09 19:01:42 -050090 uint32_t crtc_allocator;
Benjamin Franzke9c26ff32011-03-15 15:08:41 +010091 uint32_t connector_allocator;
Kristian Høgsberge4762a62011-01-14 14:59:13 -050092 struct tty *tty;
Pekka Paalanenbce2d3f2011-12-02 13:07:27 +020093
Rob Clark4339add2012-08-09 14:18:28 -050094 /* we need these parameters in order to not fail drmModeAddFB2()
95 * due to out of bounds dimensions, and then mistakenly set
96 * sprites_are_broken:
97 */
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +020098 uint32_t min_width, max_width;
99 uint32_t min_height, max_height;
100 int no_addfb2;
Rob Clark4339add2012-08-09 14:18:28 -0500101
Jesse Barnes58ef3792012-02-23 09:45:49 -0500102 struct wl_list sprite_list;
Kristian Høgsberg65bec242012-03-05 19:57:35 -0500103 int sprites_are_broken;
Ander Conselvan de Oliveirada1c9082012-10-31 17:55:46 +0200104 int sprites_hidden;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500105
Rob Clarkab5b1e32012-08-09 13:24:45 -0500106 int cursors_are_broken;
107
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +0200108 int use_pixman;
109
Pekka Paalanenbce2d3f2011-12-02 13:07:27 +0200110 uint32_t prev_state;
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
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400134struct drm_output {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500135 struct weston_output base;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400136
Kristian Høgsberg2f9ed712012-07-26 17:57:15 -0400137 char *name;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400138 uint32_t crtc_id;
Rob Clark5ca1a472012-08-08 20:27:37 -0500139 int pipe;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400140 uint32_t connector_id;
Matt Roper361d2ad2011-08-29 13:52:23 -0700141 drmModeCrtcPtr original_crtc;
Benjamin Franzke1178a3c2011-04-10 16:49:52 +0200142
Ander Conselvan de Oliveiraa7326962012-06-26 17:09:13 +0300143 int vblank_pending;
144 int page_flip_pending;
145
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -0400146 struct gbm_surface *surface;
Kristian Høgsberg8e1f77f2012-05-03 11:39:35 -0400147 struct gbm_bo *cursor_bo[2];
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400148 struct weston_plane cursor_plane;
149 struct weston_plane fb_plane;
Kristian Høgsberg5626d342012-08-03 11:50:05 -0400150 struct weston_surface *cursor_surface;
151 int current_cursor;
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300152 struct drm_fb *current, *next;
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +0200153 struct backlight *backlight;
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +0200154
155 struct drm_fb *dumb[2];
156 pixman_image_t *image[2];
157 int current_image;
158 pixman_region32_t previous_damage;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -0400159};
160
Jesse Barnes58ef3792012-02-23 09:45:49 -0500161/*
162 * An output has a primary display plane plus zero or more sprites for
163 * blending display contents.
164 */
165struct drm_sprite {
166 struct wl_list link;
167
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400168 struct weston_plane plane;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500169
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200170 struct drm_fb *current, *next;
Ander Conselvan de Oliveiraa7326962012-06-26 17:09:13 +0300171 struct drm_output *output;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500172 struct drm_compositor *compositor;
173
Jesse Barnes58ef3792012-02-23 09:45:49 -0500174 uint32_t possible_crtcs;
175 uint32_t plane_id;
176 uint32_t count_formats;
177
178 int32_t src_x, src_y;
179 uint32_t src_w, src_h;
180 uint32_t dest_x, dest_y;
181 uint32_t dest_w, dest_h;
182
183 uint32_t formats[];
184};
185
Kristian Høgsberg98cfea62013-02-18 16:15:53 -0500186static const char default_seat[] = "seat0";
Pekka Paalanen33156972012-08-03 13:30:30 -0400187
Kristian Høgsberg5626d342012-08-03 11:50:05 -0400188static void
189drm_output_set_cursor(struct drm_output *output);
Kristian Høgsberg5626d342012-08-03 11:50:05 -0400190
Jesse Barnes58ef3792012-02-23 09:45:49 -0500191static int
Jesse Barnes58ef3792012-02-23 09:45:49 -0500192drm_sprite_crtc_supported(struct weston_output *output_base, uint32_t supported)
193{
194 struct weston_compositor *ec = output_base->compositor;
195 struct drm_compositor *c =(struct drm_compositor *) ec;
196 struct drm_output *output = (struct drm_output *) output_base;
197 int crtc;
198
199 for (crtc = 0; crtc < c->num_crtcs; crtc++) {
200 if (c->crtcs[crtc] != output->crtc_id)
201 continue;
202
203 if (supported & (1 << crtc))
204 return -1;
205 }
206
207 return 0;
208}
209
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300210static void
211drm_fb_destroy_callback(struct gbm_bo *bo, void *data)
212{
213 struct drm_fb *fb = data;
214 struct gbm_device *gbm = gbm_bo_get_device(bo);
215
216 if (fb->fb_id)
217 drmModeRmFB(gbm_device_get_fd(gbm), fb->fb_id);
218
Pekka Paalanende685b82012-12-04 15:58:12 +0200219 weston_buffer_reference(&fb->buffer_ref, NULL);
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300220
221 free(data);
222}
223
224static struct drm_fb *
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +0200225drm_fb_create_dumb(struct drm_compositor *ec, unsigned width, unsigned height)
226{
227 struct drm_fb *fb;
228 int ret;
229
230 struct drm_mode_create_dumb create_arg;
231 struct drm_mode_destroy_dumb destroy_arg;
232 struct drm_mode_map_dumb map_arg;
233
234 fb = calloc(1, sizeof *fb);
235 if (!fb)
236 return NULL;
237
238 create_arg.bpp = 32;
239 create_arg.width = width;
240 create_arg.height = height;
241
242 ret = drmIoctl(ec->drm.fd, DRM_IOCTL_MODE_CREATE_DUMB, &create_arg);
243 if (ret)
244 goto err_fb;
245
246 fb->handle = create_arg.handle;
247 fb->stride = create_arg.pitch;
248 fb->size = create_arg.size;
249 fb->fd = ec->drm.fd;
250
251 ret = drmModeAddFB(ec->drm.fd, width, height, 24, 32,
252 fb->stride, fb->handle, &fb->fb_id);
253 if (ret)
254 goto err_bo;
255
256 memset(&map_arg, 0, sizeof(map_arg));
257 map_arg.handle = fb->handle;
258 drmIoctl(fb->fd, DRM_IOCTL_MODE_MAP_DUMB, &map_arg);
259
260 if (ret)
261 goto err_add_fb;
262
263 fb->map = mmap(0, fb->size, PROT_WRITE,
264 MAP_SHARED, ec->drm.fd, map_arg.offset);
265 if (fb->map == MAP_FAILED)
266 goto err_add_fb;
267
268 return fb;
269
270err_add_fb:
271 drmModeRmFB(ec->drm.fd, fb->fb_id);
272err_bo:
273 memset(&destroy_arg, 0, sizeof(destroy_arg));
274 destroy_arg.handle = create_arg.handle;
275 drmIoctl(ec->drm.fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy_arg);
276err_fb:
277 free(fb);
278 return NULL;
279}
280
281static void
282drm_fb_destroy_dumb(struct drm_fb *fb)
283{
284 struct drm_mode_destroy_dumb destroy_arg;
285
286 if (!fb->map)
287 return;
288
289 if (fb->fb_id)
290 drmModeRmFB(fb->fd, fb->fb_id);
291
292 weston_buffer_reference(&fb->buffer_ref, NULL);
293
294 munmap(fb->map, fb->size);
295
296 memset(&destroy_arg, 0, sizeof(destroy_arg));
297 destroy_arg.handle = fb->handle;
298 drmIoctl(fb->fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy_arg);
299
300 free(fb);
301}
302
303static struct drm_fb *
Kristian Høgsberga2f84cc2012-12-07 12:37:58 -0500304drm_fb_get_from_bo(struct gbm_bo *bo,
305 struct drm_compositor *compositor, uint32_t format)
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300306{
307 struct drm_fb *fb = gbm_bo_get_user_data(bo);
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +0200308 uint32_t width, height;
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200309 uint32_t handles[4], pitches[4], offsets[4];
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300310 int ret;
311
312 if (fb)
313 return fb;
314
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +0200315 fb = calloc(1, sizeof *fb);
316 if (!fb)
317 return NULL;
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300318
319 fb->bo = bo;
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300320
321 width = gbm_bo_get_width(bo);
322 height = gbm_bo_get_height(bo);
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +0200323 fb->stride = gbm_bo_get_stride(bo);
324 fb->handle = gbm_bo_get_handle(bo).u32;
325 fb->size = fb->stride * height;
326 fb->fd = compositor->drm.fd;
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300327
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200328 if (compositor->min_width > width || width > compositor->max_width ||
329 compositor->min_height > height ||
330 height > compositor->max_height) {
331 weston_log("bo geometry out of bounds\n");
332 goto err_free;
333 }
334
335 ret = -1;
336
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200337 if (format && !compositor->no_addfb2) {
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +0200338 handles[0] = fb->handle;
339 pitches[0] = fb->stride;
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200340 offsets[0] = 0;
341
342 ret = drmModeAddFB2(compositor->drm.fd, width, height,
343 format, handles, pitches, offsets,
344 &fb->fb_id, 0);
345 if (ret) {
346 weston_log("addfb2 failed: %m\n");
347 compositor->no_addfb2 = 1;
348 compositor->sprites_are_broken = 1;
349 }
350 }
351
352 if (ret)
353 ret = drmModeAddFB(compositor->drm.fd, width, height, 24, 32,
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +0200354 fb->stride, fb->handle, &fb->fb_id);
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200355
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300356 if (ret) {
Martin Minarik6d118362012-06-07 18:01:59 +0200357 weston_log("failed to create kms fb: %m\n");
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200358 goto err_free;
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300359 }
360
361 gbm_bo_set_user_data(bo, fb, drm_fb_destroy_callback);
362
363 return fb;
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200364
365err_free:
366 free(fb);
367 return NULL;
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300368}
369
370static void
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200371drm_fb_set_buffer(struct drm_fb *fb, struct wl_buffer *buffer)
372{
Pekka Paalanende685b82012-12-04 15:58:12 +0200373 assert(fb->buffer_ref.buffer == NULL);
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200374
375 fb->is_client_buffer = 1;
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200376
Pekka Paalanende685b82012-12-04 15:58:12 +0200377 weston_buffer_reference(&fb->buffer_ref, buffer);
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200378}
379
Ander Conselvan de Oliveira526d4612013-01-25 15:13:03 +0200380static void
381drm_output_release_fb(struct drm_output *output, struct drm_fb *fb)
382{
383 if (!fb)
384 return;
385
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +0200386 if (fb->map &&
387 (fb != output->dumb[0] && fb != output->dumb[1])) {
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +0200388 drm_fb_destroy_dumb(fb);
389 } else if (fb->bo) {
Ander Conselvan de Oliveira526d4612013-01-25 15:13:03 +0200390 if (fb->is_client_buffer)
391 gbm_bo_destroy(fb->bo);
392 else
393 gbm_surface_release_buffer(output->surface,
394 output->current->bo);
395 }
396}
397
Kristian Høgsberga2f84cc2012-12-07 12:37:58 -0500398static uint32_t
Ander Conselvan de Oliveirae9209412012-11-30 17:34:22 +0200399drm_output_check_scanout_format(struct drm_output *output,
400 struct weston_surface *es, struct gbm_bo *bo)
401{
Ander Conselvan de Oliveirae9209412012-11-30 17:34:22 +0200402 uint32_t format;
403 pixman_region32_t r;
404
405 format = gbm_bo_get_format(bo);
406
Kristian Høgsberga2f84cc2012-12-07 12:37:58 -0500407 switch (format) {
408 case GBM_FORMAT_XRGB8888:
409 return format;
410 case GBM_FORMAT_ARGB8888:
Ander Conselvan de Oliveirae9209412012-11-30 17:34:22 +0200411 /* We can only scanout an ARGB buffer if the surface's
412 * opaque region covers the whole output */
413 pixman_region32_init(&r);
414 pixman_region32_subtract(&r, &output->base.region,
415 &es->opaque);
416
417 if (!pixman_region32_not_empty(&r))
Kristian Høgsberga2f84cc2012-12-07 12:37:58 -0500418 format = GBM_FORMAT_XRGB8888;
419 else
420 format = 0;
Ander Conselvan de Oliveirae9209412012-11-30 17:34:22 +0200421
422 pixman_region32_fini(&r);
Ander Conselvan de Oliveirae9209412012-11-30 17:34:22 +0200423
Kristian Høgsberga2f84cc2012-12-07 12:37:58 -0500424 return format;
425 default:
426 return 0;
427 }
Ander Conselvan de Oliveirae9209412012-11-30 17:34:22 +0200428}
429
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400430static struct weston_plane *
Kristian Høgsberg6143f7d2012-07-14 00:31:32 -0400431drm_output_prepare_scanout_surface(struct weston_output *_output,
432 struct weston_surface *es)
Kristian Høgsberg5f5e42e2012-01-25 23:59:42 -0500433{
Kristian Høgsberg6143f7d2012-07-14 00:31:32 -0400434 struct drm_output *output = (struct drm_output *) _output;
Kristian Høgsberg5f5e42e2012-01-25 23:59:42 -0500435 struct drm_compositor *c =
436 (struct drm_compositor *) output->base.compositor;
Pekka Paalanende685b82012-12-04 15:58:12 +0200437 struct wl_buffer *buffer = es->buffer_ref.buffer;
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300438 struct gbm_bo *bo;
Kristian Høgsberga2f84cc2012-12-07 12:37:58 -0500439 uint32_t format;
Kristian Høgsberg5f5e42e2012-01-25 23:59:42 -0500440
Kristian Høgsberg101cb652012-02-17 10:45:16 -0500441 if (es->geometry.x != output->base.x ||
Pekka Paalanenba3cf952012-01-25 16:22:05 +0200442 es->geometry.y != output->base.y ||
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +0200443 buffer == NULL || c->gbm == NULL ||
Pekka Paalanende685b82012-12-04 15:58:12 +0200444 buffer->width != output->base.current->width ||
445 buffer->height != output->base.current->height ||
Ander Conselvan de Oliveira2908a3d2012-11-27 17:03:43 +0200446 output->base.transform != es->buffer_transform ||
447 es->transform.enabled)
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400448 return NULL;
Kristian Høgsberg5f5e42e2012-01-25 23:59:42 -0500449
Kristian Høgsberg2763a2e2012-07-13 22:54:43 -0400450 bo = gbm_bo_import(c->gbm, GBM_BO_IMPORT_WL_BUFFER,
Pekka Paalanende685b82012-12-04 15:58:12 +0200451 buffer, GBM_BO_USE_SCANOUT);
Kristian Høgsberg5f5e42e2012-01-25 23:59:42 -0500452
Rob Bradford9b101872012-09-14 23:25:41 +0100453 /* Unable to use the buffer for scanout */
454 if (!bo)
455 return NULL;
456
Kristian Høgsberga2f84cc2012-12-07 12:37:58 -0500457 format = drm_output_check_scanout_format(output, es, bo);
458 if (format == 0) {
Ander Conselvan de Oliveiraa64b15d2012-05-02 16:42:22 +0300459 gbm_bo_destroy(bo);
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400460 return NULL;
Ander Conselvan de Oliveiraa64b15d2012-05-02 16:42:22 +0300461 }
462
Kristian Høgsberga2f84cc2012-12-07 12:37:58 -0500463 output->next = drm_fb_get_from_bo(bo, c, format);
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300464 if (!output->next) {
465 gbm_bo_destroy(bo);
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400466 return NULL;
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300467 }
Kristian Høgsberg5f5e42e2012-01-25 23:59:42 -0500468
Pekka Paalanende685b82012-12-04 15:58:12 +0200469 drm_fb_set_buffer(output->next, buffer);
Kristian Høgsberg5f5e42e2012-01-25 23:59:42 -0500470
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400471 return &output->fb_plane;
Kristian Høgsberg5f5e42e2012-01-25 23:59:42 -0500472}
473
Kristian Høgsberg06cf6b02012-01-25 23:47:45 -0500474static void
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +0200475drm_output_render_gl(struct drm_output *output, pixman_region32_t *damage)
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -0400476{
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200477 struct drm_compositor *c =
478 (struct drm_compositor *) output->base.compositor;
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300479 struct gbm_bo *bo;
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -0400480
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200481 c->base.renderer->repaint_output(&output->base, damage);
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -0400482
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300483 bo = gbm_surface_lock_front_buffer(output->surface);
484 if (!bo) {
Martin Minarik6d118362012-06-07 18:01:59 +0200485 weston_log("failed to lock front buffer: %m\n");
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -0400486 return;
487 }
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300488
Kristian Høgsberga2f84cc2012-12-07 12:37:58 -0500489 output->next = drm_fb_get_from_bo(bo, c, GBM_FORMAT_XRGB8888);
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300490 if (!output->next) {
Martin Minarik6d118362012-06-07 18:01:59 +0200491 weston_log("failed to get drm_fb for bo\n");
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300492 gbm_surface_release_buffer(output->surface, bo);
493 return;
494 }
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -0400495}
496
497static void
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +0200498drm_output_render_pixman(struct drm_output *output, pixman_region32_t *damage)
499{
500 struct weston_compositor *ec = output->base.compositor;
501 pixman_region32_t total_damage, previous_damage;
502
503 pixman_region32_init(&total_damage);
504 pixman_region32_init(&previous_damage);
505
506 pixman_region32_copy(&previous_damage, damage);
507
508 pixman_region32_union(&total_damage, damage, &output->previous_damage);
509 pixman_region32_copy(&output->previous_damage, &previous_damage);
510
511 output->current_image ^= 1;
512
513 output->next = output->dumb[output->current_image];
514 pixman_renderer_output_set_buffer(&output->base,
515 output->image[output->current_image]);
516
517 ec->renderer->repaint_output(&output->base, &total_damage);
518
519 pixman_region32_fini(&total_damage);
520 pixman_region32_fini(&previous_damage);
521}
522
523static void
524drm_output_render(struct drm_output *output, pixman_region32_t *damage)
525{
526 struct drm_compositor *c =
527 (struct drm_compositor *) output->base.compositor;
528
529 if (c->use_pixman)
530 drm_output_render_pixman(output, damage);
531 else
532 drm_output_render_gl(output, damage);
533
534 pixman_region32_subtract(&c->base.primary_plane.damage,
535 &c->base.primary_plane.damage, damage);
536}
537
538static void
Kristian Høgsberg6ddcdae2012-02-28 22:31:58 -0500539drm_output_repaint(struct weston_output *output_base,
Kristian Høgsbergd7c17262012-09-05 21:54:15 -0400540 pixman_region32_t *damage)
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +0100541{
542 struct drm_output *output = (struct drm_output *) output_base;
Kristian Høgsberg06cf6b02012-01-25 23:47:45 -0500543 struct drm_compositor *compositor =
544 (struct drm_compositor *) output->base.compositor;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500545 struct drm_sprite *s;
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -0400546 struct drm_mode *mode;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500547 int ret = 0;
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +0100548
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300549 if (!output->next)
Kristian Høgsbergd7c17262012-09-05 21:54:15 -0400550 drm_output_render(output, damage);
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300551 if (!output->next)
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -0400552 return;
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +0100553
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -0400554 mode = container_of(output->base.current, struct drm_mode, base);
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300555 if (!output->current) {
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -0400556 ret = drmModeSetCrtc(compositor->drm.fd, output->crtc_id,
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300557 output->next->fb_id, 0, 0,
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -0400558 &output->connector_id, 1,
559 &mode->mode_info);
560 if (ret) {
Martin Minarik6d118362012-06-07 18:01:59 +0200561 weston_log("set mode failed: %m\n");
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -0400562 return;
563 }
Benjamin Franzke1178a3c2011-04-10 16:49:52 +0200564 }
565
Kristian Høgsberg06cf6b02012-01-25 23:47:45 -0500566 if (drmModePageFlip(compositor->drm.fd, output->crtc_id,
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300567 output->next->fb_id,
Kristian Høgsberg54f14c32012-01-18 11:47:41 -0500568 DRM_MODE_PAGE_FLIP_EVENT, output) < 0) {
Martin Minarik6d118362012-06-07 18:01:59 +0200569 weston_log("queueing pageflip failed: %m\n");
Kristian Høgsberg06cf6b02012-01-25 23:47:45 -0500570 return;
Kristian Høgsberg54f14c32012-01-18 11:47:41 -0500571 }
Benjamin Franzkeec4d3422011-03-14 12:07:26 +0100572
Ander Conselvan de Oliveiraa7326962012-06-26 17:09:13 +0300573 output->page_flip_pending = 1;
574
Kristian Høgsberg5626d342012-08-03 11:50:05 -0400575 drm_output_set_cursor(output);
576
Jesse Barnes58ef3792012-02-23 09:45:49 -0500577 /*
578 * Now, update all the sprite surfaces
579 */
580 wl_list_for_each(s, &compositor->sprite_list, link) {
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200581 uint32_t flags = 0, fb_id = 0;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500582 drmVBlank vbl = {
583 .request.type = DRM_VBLANK_RELATIVE | DRM_VBLANK_EVENT,
584 .request.sequence = 1,
585 };
586
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200587 if ((!s->current && !s->next) ||
Ander Conselvan de Oliveira2f7a30b2012-11-09 14:19:03 +0200588 !drm_sprite_crtc_supported(output_base, s->possible_crtcs))
Jesse Barnes58ef3792012-02-23 09:45:49 -0500589 continue;
590
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200591 if (s->next && !compositor->sprites_hidden)
592 fb_id = s->next->fb_id;
593
Jesse Barnes58ef3792012-02-23 09:45:49 -0500594 ret = drmModeSetPlane(compositor->drm.fd, s->plane_id,
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200595 output->crtc_id, fb_id, flags,
Jesse Barnes58ef3792012-02-23 09:45:49 -0500596 s->dest_x, s->dest_y,
597 s->dest_w, s->dest_h,
598 s->src_x, s->src_y,
599 s->src_w, s->src_h);
600 if (ret)
Martin Minarik6d118362012-06-07 18:01:59 +0200601 weston_log("setplane failed: %d: %s\n",
Jesse Barnes58ef3792012-02-23 09:45:49 -0500602 ret, strerror(errno));
603
Rob Clark5ca1a472012-08-08 20:27:37 -0500604 if (output->pipe > 0)
605 vbl.request.type |= DRM_VBLANK_SECONDARY;
606
Jesse Barnes58ef3792012-02-23 09:45:49 -0500607 /*
608 * Queue a vblank signal so we know when the surface
609 * becomes active on the display or has been replaced.
610 */
611 vbl.request.signal = (unsigned long)s;
612 ret = drmWaitVBlank(compositor->drm.fd, &vbl);
613 if (ret) {
Martin Minarik6d118362012-06-07 18:01:59 +0200614 weston_log("vblank event request failed: %d: %s\n",
Jesse Barnes58ef3792012-02-23 09:45:49 -0500615 ret, strerror(errno));
616 }
Ander Conselvan de Oliveiraa7326962012-06-26 17:09:13 +0300617
618 s->output = output;
619 output->vblank_pending = 1;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500620 }
621
Kristian Høgsberg06cf6b02012-01-25 23:47:45 -0500622 return;
Kristian Høgsbergfc783d42010-06-11 12:56:24 -0400623}
624
625static void
Jesse Barnes58ef3792012-02-23 09:45:49 -0500626vblank_handler(int fd, unsigned int frame, unsigned int sec, unsigned int usec,
627 void *data)
628{
629 struct drm_sprite *s = (struct drm_sprite *)data;
Ander Conselvan de Oliveiraa7326962012-06-26 17:09:13 +0300630 struct drm_output *output = s->output;
631 uint32_t msecs;
632
633 output->vblank_pending = 0;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500634
Ander Conselvan de Oliveira526d4612013-01-25 15:13:03 +0200635 drm_output_release_fb(output, s->current);
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200636 s->current = s->next;
637 s->next = NULL;
Ander Conselvan de Oliveiraa7326962012-06-26 17:09:13 +0300638
639 if (!output->page_flip_pending) {
640 msecs = sec * 1000 + usec / 1000;
641 weston_output_finish_frame(&output->base, msecs);
642 }
Jesse Barnes58ef3792012-02-23 09:45:49 -0500643}
644
645static void
Kristian Høgsbergfc783d42010-06-11 12:56:24 -0400646page_flip_handler(int fd, unsigned int frame,
647 unsigned int sec, unsigned int usec, void *data)
648{
Benjamin Franzke1178a3c2011-04-10 16:49:52 +0200649 struct drm_output *output = (struct drm_output *) data;
Kristian Høgsbergfc783d42010-06-11 12:56:24 -0400650 uint32_t msecs;
651
Ander Conselvan de Oliveiraa7326962012-06-26 17:09:13 +0300652 output->page_flip_pending = 0;
653
Ander Conselvan de Oliveira526d4612013-01-25 15:13:03 +0200654 drm_output_release_fb(output, output->current);
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +0300655 output->current = output->next;
656 output->next = NULL;
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -0400657
Ander Conselvan de Oliveiraa7326962012-06-26 17:09:13 +0300658 if (!output->vblank_pending) {
659 msecs = sec * 1000 + usec / 1000;
660 weston_output_finish_frame(&output->base, msecs);
661 }
Benjamin Franzke1178a3c2011-04-10 16:49:52 +0200662}
663
Kristian Høgsberga2f84cc2012-12-07 12:37:58 -0500664static uint32_t
665drm_output_check_sprite_format(struct drm_sprite *s,
666 struct weston_surface *es, struct gbm_bo *bo)
Jesse Barnes58ef3792012-02-23 09:45:49 -0500667{
Kristian Høgsberga2f84cc2012-12-07 12:37:58 -0500668 uint32_t i, format;
669
670 format = gbm_bo_get_format(bo);
671
672 if (format == GBM_FORMAT_ARGB8888) {
673 pixman_region32_t r;
674
Kristian Høgsberg63093a32013-03-01 14:29:16 -0500675 pixman_region32_init_rect(&r, 0, 0,
676 es->geometry.width,
677 es->geometry.height);
678 pixman_region32_subtract(&r, &r, &es->opaque);
Kristian Høgsberga2f84cc2012-12-07 12:37:58 -0500679
680 if (!pixman_region32_not_empty(&r))
681 format = GBM_FORMAT_XRGB8888;
682
683 pixman_region32_fini(&r);
684 }
Jesse Barnes58ef3792012-02-23 09:45:49 -0500685
686 for (i = 0; i < s->count_formats; i++)
687 if (s->formats[i] == format)
Kristian Høgsberga2f84cc2012-12-07 12:37:58 -0500688 return format;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500689
690 return 0;
691}
692
693static int
694drm_surface_transform_supported(struct weston_surface *es)
695{
Kristian Høgsbergd92c09c2013-01-29 16:56:15 -0500696 return !es->transform.enabled ||
697 (es->transform.matrix.type < WESTON_MATRIX_TRANSFORM_ROTATE);
Jesse Barnes58ef3792012-02-23 09:45:49 -0500698}
699
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400700static struct weston_plane *
Jesse Barnes58ef3792012-02-23 09:45:49 -0500701drm_output_prepare_overlay_surface(struct weston_output *output_base,
Kristian Høgsberg6143f7d2012-07-14 00:31:32 -0400702 struct weston_surface *es)
Jesse Barnes58ef3792012-02-23 09:45:49 -0500703{
704 struct weston_compositor *ec = output_base->compositor;
705 struct drm_compositor *c =(struct drm_compositor *) ec;
706 struct drm_sprite *s;
707 int found = 0;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500708 struct gbm_bo *bo;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500709 pixman_region32_t dest_rect, src_rect;
Ander Conselvan de Oliveira409eebf2012-12-05 15:14:04 +0200710 pixman_box32_t *box, tbox;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500711 uint32_t format;
Kristian Høgsberg3b00bae2012-07-13 15:25:07 -0400712 wl_fixed_t sx1, sy1, sx2, sy2;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500713
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +0200714 if (c->gbm == NULL)
715 return NULL;
716
Ander Conselvan de Oliveira409eebf2012-12-05 15:14:04 +0200717 if (es->buffer_transform != output_base->transform)
Ander Conselvan de Oliveira2908a3d2012-11-27 17:03:43 +0200718 return NULL;
719
Kristian Høgsberg65bec242012-03-05 19:57:35 -0500720 if (c->sprites_are_broken)
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400721 return NULL;
Kristian Høgsberg65bec242012-03-05 19:57:35 -0500722
Ander Conselvan de Oliveirad450b192012-06-26 17:09:12 +0300723 if (es->output_mask != (1u << output_base->id))
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400724 return NULL;
Ander Conselvan de Oliveirad450b192012-06-26 17:09:12 +0300725
Pekka Paalanende685b82012-12-04 15:58:12 +0200726 if (es->buffer_ref.buffer == NULL)
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400727 return NULL;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500728
Ville Syrjälä5a84f312012-11-16 11:48:46 +0200729 if (es->alpha != 1.0f)
730 return NULL;
731
Pekka Paalanende685b82012-12-04 15:58:12 +0200732 if (wl_buffer_is_shm(es->buffer_ref.buffer))
Rob Clark702ffae2012-08-09 14:18:27 -0500733 return NULL;
734
Jesse Barnes58ef3792012-02-23 09:45:49 -0500735 if (!drm_surface_transform_supported(es))
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400736 return NULL;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500737
Jesse Barnes58ef3792012-02-23 09:45:49 -0500738 wl_list_for_each(s, &c->sprite_list, link) {
739 if (!drm_sprite_crtc_supported(output_base, s->possible_crtcs))
740 continue;
741
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200742 if (!s->next) {
Jesse Barnes58ef3792012-02-23 09:45:49 -0500743 found = 1;
744 break;
745 }
746 }
747
748 /* No sprites available */
749 if (!found)
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400750 return NULL;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500751
Kristian Høgsberg2763a2e2012-07-13 22:54:43 -0400752 bo = gbm_bo_import(c->gbm, GBM_BO_IMPORT_WL_BUFFER,
Pekka Paalanende685b82012-12-04 15:58:12 +0200753 es->buffer_ref.buffer, GBM_BO_USE_SCANOUT);
Kristian Høgsberg2763a2e2012-07-13 22:54:43 -0400754 if (!bo)
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400755 return NULL;
Kristian Høgsberg2763a2e2012-07-13 22:54:43 -0400756
Kristian Høgsberga2f84cc2012-12-07 12:37:58 -0500757 format = drm_output_check_sprite_format(s, es, bo);
758 if (format == 0) {
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200759 gbm_bo_destroy(bo);
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400760 return NULL;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500761 }
762
Ander Conselvan de Oliveiraca5c6ae2012-12-07 13:18:11 +0200763 s->next = drm_fb_get_from_bo(bo, c, format);
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +0200764 if (!s->next) {
765 gbm_bo_destroy(bo);
766 return NULL;
767 }
768
Pekka Paalanende685b82012-12-04 15:58:12 +0200769 drm_fb_set_buffer(s->next, es->buffer_ref.buffer);
Jesse Barnes58ef3792012-02-23 09:45:49 -0500770
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400771 box = pixman_region32_extents(&es->transform.boundingbox);
772 s->plane.x = box->x1;
773 s->plane.y = box->y1;
774
Jesse Barnes58ef3792012-02-23 09:45:49 -0500775 /*
776 * Calculate the source & dest rects properly based on actual
Martin Olsson3b132e32012-09-29 15:13:56 +0200777 * position (note the caller has called weston_surface_update_transform()
Jesse Barnes58ef3792012-02-23 09:45:49 -0500778 * for us already).
779 */
780 pixman_region32_init(&dest_rect);
781 pixman_region32_intersect(&dest_rect, &es->transform.boundingbox,
782 &output_base->region);
783 pixman_region32_translate(&dest_rect, -output_base->x, -output_base->y);
784 box = pixman_region32_extents(&dest_rect);
Ander Conselvan de Oliveira409eebf2012-12-05 15:14:04 +0200785 tbox = weston_transformed_rect(output_base->width,
786 output_base->height,
787 output_base->transform, *box);
788 s->dest_x = tbox.x1;
789 s->dest_y = tbox.y1;
790 s->dest_w = tbox.x2 - tbox.x1;
791 s->dest_h = tbox.y2 - tbox.y1;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500792 pixman_region32_fini(&dest_rect);
793
794 pixman_region32_init(&src_rect);
795 pixman_region32_intersect(&src_rect, &es->transform.boundingbox,
796 &output_base->region);
Jesse Barnes58ef3792012-02-23 09:45:49 -0500797 box = pixman_region32_extents(&src_rect);
Kristian Høgsberg3b00bae2012-07-13 15:25:07 -0400798
799 weston_surface_from_global_fixed(es,
800 wl_fixed_from_int(box->x1),
801 wl_fixed_from_int(box->y1),
802 &sx1, &sy1);
803 weston_surface_from_global_fixed(es,
804 wl_fixed_from_int(box->x2),
805 wl_fixed_from_int(box->y2),
806 &sx2, &sy2);
807
808 if (sx1 < 0)
809 sx1 = 0;
810 if (sy1 < 0)
811 sy1 = 0;
812 if (sx2 > wl_fixed_from_int(es->geometry.width))
813 sx2 = wl_fixed_from_int(es->geometry.width);
814 if (sy2 > wl_fixed_from_int(es->geometry.height))
815 sy2 = wl_fixed_from_int(es->geometry.height);
816
Ander Conselvan de Oliveira409eebf2012-12-05 15:14:04 +0200817 tbox.x1 = sx1;
818 tbox.y1 = sy1;
819 tbox.x2 = sx2;
820 tbox.y2 = sy2;
821
822 tbox = weston_transformed_rect(wl_fixed_from_int(es->geometry.width),
823 wl_fixed_from_int(es->geometry.height),
824 es->buffer_transform, tbox);
825
826 s->src_x = tbox.x1 << 8;
827 s->src_y = tbox.y1 << 8;
828 s->src_w = (tbox.x2 - tbox.x1) << 8;
829 s->src_h = (tbox.y2 - tbox.y1) << 8;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500830 pixman_region32_fini(&src_rect);
831
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400832 return &s->plane;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500833}
834
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400835static struct weston_plane *
Kristian Høgsberg5626d342012-08-03 11:50:05 -0400836drm_output_prepare_cursor_surface(struct weston_output *output_base,
837 struct weston_surface *es)
Kristian Høgsbergd8bf90c2012-02-23 23:03:14 -0500838{
Kristian Høgsberg8a015802012-08-09 17:19:23 -0400839 struct drm_compositor *c =
840 (struct drm_compositor *) output_base->compositor;
Kristian Høgsberga6edab32012-07-14 01:06:28 -0400841 struct drm_output *output = (struct drm_output *) output_base;
Kristian Høgsberg5626d342012-08-03 11:50:05 -0400842
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +0200843 if (c->gbm == NULL)
844 return NULL;
Ander Conselvan de Oliveira2908a3d2012-11-27 17:03:43 +0200845 if (output->base.transform != WL_OUTPUT_TRANSFORM_NORMAL)
846 return NULL;
Kristian Høgsberg5626d342012-08-03 11:50:05 -0400847 if (output->cursor_surface)
848 return NULL;
849 if (es->output_mask != (1u << output_base->id))
850 return NULL;
Rob Clarkab5b1e32012-08-09 13:24:45 -0500851 if (c->cursors_are_broken)
Kristian Høgsberg8a015802012-08-09 17:19:23 -0400852 return NULL;
Pekka Paalanende685b82012-12-04 15:58:12 +0200853 if (es->buffer_ref.buffer == NULL ||
854 !wl_buffer_is_shm(es->buffer_ref.buffer) ||
Kristian Høgsberg5626d342012-08-03 11:50:05 -0400855 es->geometry.width > 64 || es->geometry.height > 64)
856 return NULL;
857
858 output->cursor_surface = es;
859
860 return &output->cursor_plane;
861}
862
863static void
864drm_output_set_cursor(struct drm_output *output)
865{
866 struct weston_surface *es = output->cursor_surface;
Kristian Høgsberga6edab32012-07-14 01:06:28 -0400867 struct drm_compositor *c =
868 (struct drm_compositor *) output->base.compositor;
869 EGLint handle, stride;
870 struct gbm_bo *bo;
871 uint32_t buf[64 * 64];
872 unsigned char *s;
Kristian Høgsberg24e42752012-07-18 12:08:37 -0400873 int i, x, y;
Kristian Høgsbergd8bf90c2012-02-23 23:03:14 -0500874
Kristian Høgsberg79af73e2012-08-03 15:45:23 -0400875 output->cursor_surface = NULL;
Kristian Høgsberg5626d342012-08-03 11:50:05 -0400876 if (es == NULL) {
877 drmModeSetCursor(c->drm.fd, output->crtc_id, 0, 0, 0);
878 return;
879 }
Kristian Høgsbergd8bf90c2012-02-23 23:03:14 -0500880
Pekka Paalanende685b82012-12-04 15:58:12 +0200881 if (es->buffer_ref.buffer &&
882 pixman_region32_not_empty(&output->cursor_plane.damage)) {
Kristian Høgsberg5626d342012-08-03 11:50:05 -0400883 pixman_region32_fini(&output->cursor_plane.damage);
884 pixman_region32_init(&output->cursor_plane.damage);
Kristian Høgsberg1f5de352012-07-18 12:09:58 -0400885 output->current_cursor ^= 1;
886 bo = output->cursor_bo[output->current_cursor];
887 memset(buf, 0, sizeof buf);
Pekka Paalanende685b82012-12-04 15:58:12 +0200888 stride = wl_shm_buffer_get_stride(es->buffer_ref.buffer);
889 s = wl_shm_buffer_get_data(es->buffer_ref.buffer);
Kristian Høgsberg1f5de352012-07-18 12:09:58 -0400890 for (i = 0; i < es->geometry.height; i++)
891 memcpy(buf + i * 64, s + i * stride,
892 es->geometry.width * 4);
Kristian Høgsbergd8bf90c2012-02-23 23:03:14 -0500893
Kristian Høgsberg1f5de352012-07-18 12:09:58 -0400894 if (gbm_bo_write(bo, buf, sizeof buf) < 0)
Pekka Paalanenae29da22012-08-06 14:57:05 +0300895 weston_log("failed update cursor: %m\n");
Kristian Høgsberga6edab32012-07-14 01:06:28 -0400896
Kristian Høgsberg1f5de352012-07-18 12:09:58 -0400897 handle = gbm_bo_get_handle(bo).s32;
898 if (drmModeSetCursor(c->drm.fd,
Rob Clarkab5b1e32012-08-09 13:24:45 -0500899 output->crtc_id, handle, 64, 64)) {
Pekka Paalanenae29da22012-08-06 14:57:05 +0300900 weston_log("failed to set cursor: %m\n");
Rob Clarkab5b1e32012-08-09 13:24:45 -0500901 c->cursors_are_broken = 1;
902 }
Kristian Høgsberga6edab32012-07-14 01:06:28 -0400903 }
904
Kristian Høgsberg24e42752012-07-18 12:08:37 -0400905 x = es->geometry.x - output->base.x;
906 y = es->geometry.y - output->base.y;
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400907 if (output->cursor_plane.x != x || output->cursor_plane.y != y) {
Rob Clarkab5b1e32012-08-09 13:24:45 -0500908 if (drmModeMoveCursor(c->drm.fd, output->crtc_id, x, y)) {
Kristian Høgsberg24e42752012-07-18 12:08:37 -0400909 weston_log("failed to move cursor: %m\n");
Rob Clarkab5b1e32012-08-09 13:24:45 -0500910 c->cursors_are_broken = 1;
911 }
912
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400913 output->cursor_plane.x = x;
914 output->cursor_plane.y = y;
Kristian Høgsberga6edab32012-07-14 01:06:28 -0400915 }
Kristian Høgsbergd8bf90c2012-02-23 23:03:14 -0500916}
917
Jesse Barnes58ef3792012-02-23 09:45:49 -0500918static void
919drm_assign_planes(struct weston_output *output)
920{
Kristian Høgsberga6edab32012-07-14 01:06:28 -0400921 struct drm_compositor *c =
922 (struct drm_compositor *) output->compositor;
Kristian Høgsberg8e1f77f2012-05-03 11:39:35 -0400923 struct weston_surface *es, *next;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500924 pixman_region32_t overlap, surface_overlap;
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400925 struct weston_plane *primary, *next_plane;
Jesse Barnes58ef3792012-02-23 09:45:49 -0500926
927 /*
928 * Find a surface for each sprite in the output using some heuristics:
929 * 1) size
930 * 2) frequency of update
931 * 3) opacity (though some hw might support alpha blending)
932 * 4) clipping (this can be fixed with color keys)
933 *
934 * The idea is to save on blitting since this should save power.
935 * If we can get a large video surface on the sprite for example,
936 * the main display surface may not need to update at all, and
937 * the client buffer can be used directly for the sprite surface
938 * as we do for flipping full screen surfaces.
939 */
940 pixman_region32_init(&overlap);
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400941 primary = &c->base.primary_plane;
Kristian Høgsberga6edab32012-07-14 01:06:28 -0400942 wl_list_for_each_safe(es, next, &c->base.surface_list, link) {
Pekka Paalanenccfeae22012-12-04 15:58:14 +0200943 /* test whether this buffer can ever go into a plane:
944 * non-shm, or small enough to be a cursor
945 */
946 if ((es->buffer_ref.buffer &&
947 !wl_buffer_is_shm(es->buffer_ref.buffer)) ||
948 (es->geometry.width <= 64 && es->geometry.height <= 64))
949 es->keep_buffer = 1;
950 else
951 es->keep_buffer = 0;
952
Jesse Barnes58ef3792012-02-23 09:45:49 -0500953 pixman_region32_init(&surface_overlap);
954 pixman_region32_intersect(&surface_overlap, &overlap,
955 &es->transform.boundingbox);
956
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400957 next_plane = NULL;
Kristian Høgsberg6143f7d2012-07-14 00:31:32 -0400958 if (pixman_region32_not_empty(&surface_overlap))
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400959 next_plane = primary;
960 if (next_plane == NULL)
Kristian Høgsberg5626d342012-08-03 11:50:05 -0400961 next_plane = drm_output_prepare_cursor_surface(output, es);
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400962 if (next_plane == NULL)
963 next_plane = drm_output_prepare_scanout_surface(output, es);
964 if (next_plane == NULL)
965 next_plane = drm_output_prepare_overlay_surface(output, es);
966 if (next_plane == NULL)
967 next_plane = primary;
968 weston_surface_move_to_plane(es, next_plane);
969 if (next_plane == primary)
Jesse Barnes58ef3792012-02-23 09:45:49 -0500970 pixman_region32_union(&overlap, &overlap,
971 &es->transform.boundingbox);
Kristian Høgsberg6143f7d2012-07-14 00:31:32 -0400972
Jesse Barnes58ef3792012-02-23 09:45:49 -0500973 pixman_region32_fini(&surface_overlap);
974 }
975 pixman_region32_fini(&overlap);
Jesse Barnes58ef3792012-02-23 09:45:49 -0500976}
977
Matt Roper361d2ad2011-08-29 13:52:23 -0700978static void
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +0200979drm_output_fini_pixman(struct drm_output *output);
980
981static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500982drm_output_destroy(struct weston_output *output_base)
Matt Roper361d2ad2011-08-29 13:52:23 -0700983{
984 struct drm_output *output = (struct drm_output *) output_base;
985 struct drm_compositor *c =
Benjamin Franzke117483d2011-08-30 11:38:26 +0200986 (struct drm_compositor *) output->base.compositor;
Matt Roper361d2ad2011-08-29 13:52:23 -0700987 drmModeCrtcPtr origcrtc = output->original_crtc;
Matt Roper361d2ad2011-08-29 13:52:23 -0700988
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +0200989 if (output->backlight)
990 backlight_destroy(output->backlight);
991
Matt Roper361d2ad2011-08-29 13:52:23 -0700992 /* Turn off hardware cursor */
Kristian Høgsberga6edab32012-07-14 01:06:28 -0400993 drmModeSetCursor(c->drm.fd, output->crtc_id, 0, 0, 0);
Matt Roper361d2ad2011-08-29 13:52:23 -0700994
995 /* Restore original CRTC state */
996 drmModeSetCrtc(c->drm.fd, origcrtc->crtc_id, origcrtc->buffer_id,
Benjamin Franzke117483d2011-08-30 11:38:26 +0200997 origcrtc->x, origcrtc->y,
998 &output->connector_id, 1, &origcrtc->mode);
Matt Roper361d2ad2011-08-29 13:52:23 -0700999 drmModeFreeCrtc(origcrtc);
1000
Benjamin Franzke48c4ea22011-08-30 11:44:56 +02001001 c->crtc_allocator &= ~(1 << output->crtc_id);
1002 c->connector_allocator &= ~(1 << output->connector_id);
1003
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02001004 if (c->use_pixman) {
1005 drm_output_fini_pixman(output);
1006 } else {
1007 gl_renderer_output_destroy(output_base);
1008 gbm_surface_destroy(output->surface);
1009 }
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -04001010
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04001011 weston_plane_release(&output->fb_plane);
1012 weston_plane_release(&output->cursor_plane);
1013
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001014 weston_output_destroy(&output->base);
Benjamin Franzke48c4ea22011-08-30 11:44:56 +02001015 wl_list_remove(&output->base.link);
1016
Kristian Høgsberg148ef012012-07-26 23:03:57 -04001017 free(output->name);
Matt Roper361d2ad2011-08-29 13:52:23 -07001018 free(output);
1019}
1020
Alex Wub7b8bda2012-04-17 17:20:48 +08001021static struct drm_mode *
1022choose_mode (struct drm_output *output, struct weston_mode *target_mode)
1023{
1024 struct drm_mode *tmp_mode = NULL, *mode;
1025
1026 if (output->base.current->width == target_mode->width &&
1027 output->base.current->height == target_mode->height &&
1028 (output->base.current->refresh == target_mode->refresh ||
1029 target_mode->refresh == 0))
1030 return (struct drm_mode *)output->base.current;
1031
1032 wl_list_for_each(mode, &output->base.mode_list, base.link) {
1033 if (mode->mode_info.hdisplay == target_mode->width &&
1034 mode->mode_info.vdisplay == target_mode->height) {
1035 if (mode->mode_info.vrefresh == target_mode->refresh ||
1036 target_mode->refresh == 0) {
1037 return mode;
1038 } else if (!tmp_mode)
1039 tmp_mode = mode;
1040 }
1041 }
1042
1043 return tmp_mode;
1044}
1045
1046static int
Ander Conselvan de Oliveira6c01c9c2012-12-14 13:37:30 -02001047drm_output_init_egl(struct drm_output *output, struct drm_compositor *ec);
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02001048static int
1049drm_output_init_pixman(struct drm_output *output, struct drm_compositor *c);
Ander Conselvan de Oliveira6c01c9c2012-12-14 13:37:30 -02001050
1051static int
Alex Wub7b8bda2012-04-17 17:20:48 +08001052drm_output_switch_mode(struct weston_output *output_base, struct weston_mode *mode)
1053{
1054 struct drm_output *output;
1055 struct drm_mode *drm_mode;
Alex Wub7b8bda2012-04-17 17:20:48 +08001056 struct drm_compositor *ec;
Alex Wub7b8bda2012-04-17 17:20:48 +08001057
1058 if (output_base == NULL) {
Martin Minarik6d118362012-06-07 18:01:59 +02001059 weston_log("output is NULL.\n");
Alex Wub7b8bda2012-04-17 17:20:48 +08001060 return -1;
1061 }
1062
1063 if (mode == NULL) {
Martin Minarik6d118362012-06-07 18:01:59 +02001064 weston_log("mode is NULL.\n");
Alex Wub7b8bda2012-04-17 17:20:48 +08001065 return -1;
1066 }
1067
1068 ec = (struct drm_compositor *)output_base->compositor;
1069 output = (struct drm_output *)output_base;
1070 drm_mode = choose_mode (output, mode);
1071
1072 if (!drm_mode) {
Martin Minarik6d118362012-06-07 18:01:59 +02001073 weston_log("%s, invalid resolution:%dx%d\n", __func__, mode->width, mode->height);
Alex Wub7b8bda2012-04-17 17:20:48 +08001074 return -1;
Ander Conselvan de Oliveira6c01c9c2012-12-14 13:37:30 -02001075 }
1076
1077 if (&drm_mode->base == output->base.current)
Alex Wub7b8bda2012-04-17 17:20:48 +08001078 return 0;
Alex Wub7b8bda2012-04-17 17:20:48 +08001079
Ander Conselvan de Oliveira6c01c9c2012-12-14 13:37:30 -02001080 output->base.current->flags = 0;
Alex Wub7b8bda2012-04-17 17:20:48 +08001081
Ander Conselvan de Oliveira6c01c9c2012-12-14 13:37:30 -02001082 output->base.current = &drm_mode->base;
1083 output->base.current->flags =
Alex Wub7b8bda2012-04-17 17:20:48 +08001084 WL_OUTPUT_MODE_CURRENT | WL_OUTPUT_MODE_PREFERRED;
1085
Alex Wub7b8bda2012-04-17 17:20:48 +08001086 /* reset rendering stuff. */
Ander Conselvan de Oliveira526d4612013-01-25 15:13:03 +02001087 drm_output_release_fb(output, output->current);
1088 drm_output_release_fb(output, output->next);
1089 output->current = output->next = NULL;
Alex Wub7b8bda2012-04-17 17:20:48 +08001090
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02001091 if (ec->use_pixman) {
1092 drm_output_fini_pixman(output);
1093 if (drm_output_init_pixman(output, ec) < 0) {
1094 weston_log("failed to init output pixman state with "
1095 "new mode\n");
1096 return -1;
1097 }
1098 } else {
1099 gl_renderer_output_destroy(&output->base);
1100 gbm_surface_destroy(output->surface);
Alex Wub7b8bda2012-04-17 17:20:48 +08001101
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02001102 if (drm_output_init_egl(output, ec) < 0) {
1103 weston_log("failed to init output egl state with "
1104 "new mode");
1105 return -1;
1106 }
Ander Conselvan de Oliveira6c01c9c2012-12-14 13:37:30 -02001107 }
1108
Alex Wub7b8bda2012-04-17 17:20:48 +08001109 return 0;
Alex Wub7b8bda2012-04-17 17:20:48 +08001110}
1111
Kristian Høgsbergb1868472011-04-22 12:27:57 -04001112static int
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001113on_drm_input(int fd, uint32_t mask, void *data)
1114{
1115 drmEventContext evctx;
1116
1117 memset(&evctx, 0, sizeof evctx);
1118 evctx.version = DRM_EVENT_CONTEXT_VERSION;
1119 evctx.page_flip_handler = page_flip_handler;
Jesse Barnes58ef3792012-02-23 09:45:49 -05001120 evctx.vblank_handler = vblank_handler;
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001121 drmHandleEvent(fd, &evctx);
Kristian Høgsbergb1868472011-04-22 12:27:57 -04001122
1123 return 1;
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001124}
1125
1126static int
Ander Conselvan de Oliveira22929172013-01-25 15:13:02 +02001127init_drm(struct drm_compositor *ec, struct udev_device *device)
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001128{
Kristian Høgsbergb5ef5912012-03-28 22:53:49 -04001129 const char *filename, *sysnum;
Kristian Høgsberg5fcd0aa2010-08-09 14:43:33 -04001130 int fd;
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -04001131
Kristian Høgsbergb71302e2012-05-10 12:28:35 -04001132 sysnum = udev_device_get_sysnum(device);
1133 if (sysnum)
1134 ec->drm.id = atoi(sysnum);
1135 if (!sysnum || ec->drm.id < 0) {
Martin Minarik6d118362012-06-07 18:01:59 +02001136 weston_log("cannot get device sysnum\n");
Kristian Høgsbergb71302e2012-05-10 12:28:35 -04001137 return -1;
1138 }
1139
Kristian Høgsberg5fcd0aa2010-08-09 14:43:33 -04001140 filename = udev_device_get_devnode(device);
David Herrmann63ff7062011-11-05 18:46:01 +01001141 fd = open(filename, O_RDWR | O_CLOEXEC);
Kristian Høgsberg5fcd0aa2010-08-09 14:43:33 -04001142 if (fd < 0) {
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001143 /* Probably permissions error */
Martin Minarik6d118362012-06-07 18:01:59 +02001144 weston_log("couldn't open %s, skipping\n",
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001145 udev_device_get_devnode(device));
1146 return -1;
1147 }
1148
Kristian Høgsbergfc9c5e02012-06-08 16:45:33 -04001149 weston_log("using %s\n", filename);
1150
Benjamin Franzke2af7f102011-03-02 11:14:59 +01001151 ec->drm.fd = fd;
Ander Conselvan de Oliveira22929172013-01-25 15:13:02 +02001152
Ander Conselvan de Oliveira1d41ad42013-01-25 15:13:04 +02001153
Ander Conselvan de Oliveira22929172013-01-25 15:13:02 +02001154 return 0;
1155}
1156
1157static int
1158init_egl(struct drm_compositor *ec)
1159{
Benjamin Franzke060cf802011-04-30 09:32:11 +02001160 ec->gbm = gbm_create_device(ec->drm.fd);
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001161
John Kåre Alsakeref591aa2013-03-02 12:27:39 +01001162 if (!ec->gbm)
1163 return -1;
1164
John Kåre Alsaker779b52a2012-11-13 19:10:29 +01001165 if (gl_renderer_create(&ec->base, ec->gbm, gl_renderer_opaque_attribs,
John Kåre Alsaker1b7ad162012-11-13 19:10:19 +01001166 NULL) < 0) {
1167 gbm_device_destroy(ec->gbm);
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -04001168 return -1;
1169 }
1170
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001171 return 0;
1172}
1173
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02001174static int
1175init_pixman(struct drm_compositor *ec)
1176{
1177 return pixman_renderer_init(&ec->base);
1178}
1179
Ander Conselvan de Oliveira42c46462012-08-09 16:45:00 +03001180static struct drm_mode *
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001181drm_output_add_mode(struct drm_output *output, drmModeModeInfo *info)
1182{
1183 struct drm_mode *mode;
Kristian Høgsbergc4621b02012-05-10 12:23:53 -04001184 uint64_t refresh;
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001185
1186 mode = malloc(sizeof *mode);
1187 if (mode == NULL)
Ander Conselvan de Oliveira42c46462012-08-09 16:45:00 +03001188 return NULL;
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001189
1190 mode->base.flags = 0;
1191 mode->base.width = info->hdisplay;
1192 mode->base.height = info->vdisplay;
Kristian Høgsbergc4621b02012-05-10 12:23:53 -04001193
1194 /* Calculate higher precision (mHz) refresh rate */
1195 refresh = (info->clock * 1000000LL / info->htotal +
1196 info->vtotal / 2) / info->vtotal;
1197
1198 if (info->flags & DRM_MODE_FLAG_INTERLACE)
1199 refresh *= 2;
1200 if (info->flags & DRM_MODE_FLAG_DBLSCAN)
1201 refresh /= 2;
1202 if (info->vscan > 1)
1203 refresh /= info->vscan;
1204
1205 mode->base.refresh = refresh;
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001206 mode->mode_info = *info;
Kristian Høgsberg061c4252012-06-28 11:28:15 -04001207
1208 if (info->type & DRM_MODE_TYPE_PREFERRED)
1209 mode->base.flags |= WL_OUTPUT_MODE_PREFERRED;
1210
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001211 wl_list_insert(output->base.mode_list.prev, &mode->base.link);
1212
Ander Conselvan de Oliveira42c46462012-08-09 16:45:00 +03001213 return mode;
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001214}
1215
1216static int
1217drm_subpixel_to_wayland(int drm_value)
1218{
1219 switch (drm_value) {
1220 default:
1221 case DRM_MODE_SUBPIXEL_UNKNOWN:
1222 return WL_OUTPUT_SUBPIXEL_UNKNOWN;
1223 case DRM_MODE_SUBPIXEL_NONE:
1224 return WL_OUTPUT_SUBPIXEL_NONE;
1225 case DRM_MODE_SUBPIXEL_HORIZONTAL_RGB:
1226 return WL_OUTPUT_SUBPIXEL_HORIZONTAL_RGB;
1227 case DRM_MODE_SUBPIXEL_HORIZONTAL_BGR:
1228 return WL_OUTPUT_SUBPIXEL_HORIZONTAL_BGR;
1229 case DRM_MODE_SUBPIXEL_VERTICAL_RGB:
1230 return WL_OUTPUT_SUBPIXEL_VERTICAL_RGB;
1231 case DRM_MODE_SUBPIXEL_VERTICAL_BGR:
1232 return WL_OUTPUT_SUBPIXEL_VERTICAL_BGR;
1233 }
1234}
1235
Tiago Vignatti5ab91ad2012-03-12 19:40:09 -03001236/* returns a value between 0-255 range, where higher is brighter */
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02001237static uint32_t
1238drm_get_backlight(struct drm_output *output)
1239{
1240 long brightness, max_brightness, norm;
1241
1242 brightness = backlight_get_brightness(output->backlight);
1243 max_brightness = backlight_get_max_brightness(output->backlight);
1244
Tiago Vignatti5ab91ad2012-03-12 19:40:09 -03001245 /* convert it on a scale of 0 to 255 */
1246 norm = (brightness * 255)/(max_brightness);
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02001247
1248 return (uint32_t) norm;
1249}
1250
Tiago Vignatti5ab91ad2012-03-12 19:40:09 -03001251/* values accepted are between 0-255 range */
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02001252static void
1253drm_set_backlight(struct weston_output *output_base, uint32_t value)
1254{
1255 struct drm_output *output = (struct drm_output *) output_base;
1256 long max_brightness, new_brightness;
1257
1258 if (!output->backlight)
1259 return;
1260
Kristian Høgsberg875ab9e2012-03-30 11:52:39 -04001261 if (value > 255)
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02001262 return;
1263
1264 max_brightness = backlight_get_max_brightness(output->backlight);
1265
1266 /* get denormalized value */
Tiago Vignatti5ab91ad2012-03-12 19:40:09 -03001267 new_brightness = (value * max_brightness) / 255;
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02001268
1269 backlight_set_brightness(output->backlight, new_brightness);
1270}
1271
1272static drmModePropertyPtr
1273drm_get_prop(int fd, drmModeConnectorPtr connector, const char *name)
1274{
1275 drmModePropertyPtr props;
1276 int i;
1277
1278 for (i = 0; i < connector->count_props; i++) {
1279 props = drmModeGetProperty(fd, connector->props[i]);
1280 if (!props)
1281 continue;
1282
1283 if (!strcmp(props->name, name))
1284 return props;
1285
1286 drmModeFreeProperty(props);
1287 }
1288
1289 return NULL;
1290}
1291
1292static void
1293drm_set_dpms(struct weston_output *output_base, enum dpms_enum level)
1294{
1295 struct drm_output *output = (struct drm_output *) output_base;
1296 struct weston_compositor *ec = output_base->compositor;
1297 struct drm_compositor *c = (struct drm_compositor *) ec;
1298 drmModeConnectorPtr connector;
1299 drmModePropertyPtr prop;
1300
1301 connector = drmModeGetConnector(c->drm.fd, output->connector_id);
1302 if (!connector)
1303 return;
1304
1305 prop = drm_get_prop(c->drm.fd, connector, "DPMS");
1306 if (!prop) {
1307 drmModeFreeConnector(connector);
1308 return;
1309 }
1310
1311 drmModeConnectorSetProperty(c->drm.fd, connector->connector_id,
1312 prop->prop_id, level);
1313 drmModeFreeProperty(prop);
1314 drmModeFreeConnector(connector);
1315}
1316
Kristian Høgsberg2f9ed712012-07-26 17:57:15 -04001317static const char *connector_type_names[] = {
1318 "None",
1319 "VGA",
1320 "DVI",
1321 "DVI",
1322 "DVI",
1323 "Composite",
1324 "TV",
1325 "LVDS",
1326 "CTV",
1327 "DIN",
1328 "DP",
1329 "HDMI",
1330 "HDMI",
1331 "TV",
1332 "eDP",
1333};
1334
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001335static int
Kristian Høgsberg9ca38462012-07-26 22:44:55 -04001336find_crtc_for_connector(struct drm_compositor *ec,
1337 drmModeRes *resources, drmModeConnector *connector)
1338{
1339 drmModeEncoder *encoder;
1340 uint32_t possible_crtcs;
1341 int i, j;
1342
1343 for (j = 0; j < connector->count_encoders; j++) {
1344 encoder = drmModeGetEncoder(ec->drm.fd, connector->encoders[j]);
1345 if (encoder == NULL) {
1346 weston_log("Failed to get encoder.\n");
1347 return -1;
1348 }
1349 possible_crtcs = encoder->possible_crtcs;
1350 drmModeFreeEncoder(encoder);
1351
1352 for (i = 0; i < resources->count_crtcs; i++) {
1353 if (possible_crtcs & (1 << i) &&
1354 !(ec->crtc_allocator & (1 << resources->crtcs[i])))
1355 return i;
1356 }
1357 }
1358
1359 return -1;
1360}
1361
Ander Conselvan de Oliveira475cf152012-12-14 13:37:29 -02001362/* Init output state that depends on gl or gbm */
1363static int
1364drm_output_init_egl(struct drm_output *output, struct drm_compositor *ec)
1365{
Ander Conselvan de Oliveira6c01c9c2012-12-14 13:37:30 -02001366 int i, flags;
1367
Ander Conselvan de Oliveira475cf152012-12-14 13:37:29 -02001368 output->surface = gbm_surface_create(ec->gbm,
1369 output->base.current->width,
1370 output->base.current->height,
1371 GBM_FORMAT_XRGB8888,
1372 GBM_BO_USE_SCANOUT |
1373 GBM_BO_USE_RENDERING);
1374 if (!output->surface) {
1375 weston_log("failed to create gbm surface\n");
1376 return -1;
1377 }
1378
1379 if (gl_renderer_output_create(&output->base, output->surface) < 0) {
Ander Conselvan de Oliveira6c01c9c2012-12-14 13:37:30 -02001380 weston_log("failed to create gl renderer output state\n");
Ander Conselvan de Oliveira475cf152012-12-14 13:37:29 -02001381 gbm_surface_destroy(output->surface);
1382 return -1;
1383 }
1384
Ander Conselvan de Oliveira6c01c9c2012-12-14 13:37:30 -02001385 flags = GBM_BO_USE_CURSOR_64X64 | GBM_BO_USE_WRITE;
1386
1387 for (i = 0; i < 2; i++) {
1388 if (output->cursor_bo[i])
1389 continue;
1390
1391 output->cursor_bo[i] =
1392 gbm_bo_create(ec->gbm, 64, 64, GBM_FORMAT_ARGB8888,
1393 flags);
1394 }
1395
Ander Conselvan de Oliveira475cf152012-12-14 13:37:29 -02001396 if (output->cursor_bo[0] == NULL || output->cursor_bo[1] == NULL) {
1397 weston_log("cursor buffers unavailable, using gl cursors\n");
1398 ec->cursors_are_broken = 1;
1399 }
1400
1401 return 0;
1402}
1403
Kristian Høgsberg9ca38462012-07-26 22:44:55 -04001404static int
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02001405drm_output_init_pixman(struct drm_output *output, struct drm_compositor *c)
1406{
1407 int w = output->base.current->width;
1408 int h = output->base.current->height;
1409 unsigned int i;
1410
1411 /* FIXME error checking */
1412
1413 for (i = 0; i < ARRAY_LENGTH(output->dumb); i++) {
1414 output->dumb[i] = drm_fb_create_dumb(c, w, h);
1415 if (!output->dumb[i])
1416 goto err;
1417
1418 output->image[i] =
1419 pixman_image_create_bits(PIXMAN_x8r8g8b8, w, h,
1420 output->dumb[i]->map,
1421 output->dumb[i]->stride);
1422 if (!output->image[i])
1423 goto err;
1424 }
1425
1426 if (pixman_renderer_output_create(&output->base) < 0)
1427 goto err;
1428
1429 pixman_region32_init_rect(&output->previous_damage,
1430 output->base.x, output->base.y, w, h);
1431
1432 return 0;
1433
1434err:
1435 for (i = 0; i < ARRAY_LENGTH(output->dumb); i++) {
1436 if (output->dumb[i])
1437 drm_fb_destroy_dumb(output->dumb[i]);
1438 if (output->image[i])
1439 pixman_image_unref(output->image[i]);
1440
1441 output->dumb[i] = NULL;
1442 output->image[i] = NULL;
1443 }
1444
1445 return -1;
1446}
1447
1448static void
1449drm_output_fini_pixman(struct drm_output *output)
1450{
1451 unsigned int i;
1452
1453 pixman_renderer_output_destroy(&output->base);
1454 pixman_region32_fini(&output->previous_damage);
1455
1456 for (i = 0; i < ARRAY_LENGTH(output->dumb); i++) {
1457 drm_fb_destroy_dumb(output->dumb[i]);
1458 pixman_image_unref(output->image[i]);
1459 output->dumb[i] = NULL;
1460 output->image[i] = NULL;
1461 }
1462}
1463
1464static int
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04001465create_output_for_connector(struct drm_compositor *ec,
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001466 drmModeRes *resources,
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +01001467 drmModeConnector *connector,
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02001468 int x, int y, struct udev_device *drm_device)
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001469{
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04001470 struct drm_output *output;
Ander Conselvan de Oliveira42c46462012-08-09 16:45:00 +03001471 struct drm_mode *drm_mode, *next, *preferred, *current, *configured;
1472 struct weston_mode *m;
Scott Moreau8ab5d452012-07-30 19:51:08 -06001473 struct drm_configured_output *o = NULL, *temp;
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001474 drmModeEncoder *encoder;
Kristian Høgsberg061c4252012-06-28 11:28:15 -04001475 drmModeModeInfo crtc_mode;
1476 drmModeCrtc *crtc;
Ander Conselvan de Oliveira42c46462012-08-09 16:45:00 +03001477 int i;
Kristian Høgsberg2f9ed712012-07-26 17:57:15 -04001478 char name[32];
1479 const char *type_name;
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001480
Kristian Høgsberg9ca38462012-07-26 22:44:55 -04001481 i = find_crtc_for_connector(ec, resources, connector);
1482 if (i < 0) {
1483 weston_log("No usable crtc/encoder pair for connector.\n");
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001484 return -1;
1485 }
1486
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001487 output = malloc(sizeof *output);
Kristian Høgsberg9ca38462012-07-26 22:44:55 -04001488 if (output == NULL)
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001489 return -1;
1490
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04001491 memset(output, 0, sizeof *output);
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001492 output->base.subpixel = drm_subpixel_to_wayland(connector->subpixel);
1493 output->base.make = "unknown";
1494 output->base.model = "unknown";
1495 wl_list_init(&output->base.mode_list);
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04001496
Kristian Høgsberg2f9ed712012-07-26 17:57:15 -04001497 if (connector->connector_type < ARRAY_LENGTH(connector_type_names))
1498 type_name = connector_type_names[connector->connector_type];
1499 else
1500 type_name = "UNKNOWN";
1501 snprintf(name, 32, "%s%d", type_name, connector->connector_type_id);
1502 output->name = strdup(name);
1503
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001504 output->crtc_id = resources->crtcs[i];
Rob Clark5ca1a472012-08-08 20:27:37 -05001505 output->pipe = i;
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001506 ec->crtc_allocator |= (1 << output->crtc_id);
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001507 output->connector_id = connector->connector_id;
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001508 ec->connector_allocator |= (1 << output->connector_id);
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001509
Matt Roper361d2ad2011-08-29 13:52:23 -07001510 output->original_crtc = drmModeGetCrtc(ec->drm.fd, output->crtc_id);
1511
Kristian Høgsberg061c4252012-06-28 11:28:15 -04001512 /* Get the current mode on the crtc that's currently driving
1513 * this connector. */
1514 encoder = drmModeGetEncoder(ec->drm.fd, connector->encoder_id);
Wang Quanxianacb805a2012-07-30 18:09:46 -04001515 memset(&crtc_mode, 0, sizeof crtc_mode);
1516 if (encoder != NULL) {
1517 crtc = drmModeGetCrtc(ec->drm.fd, encoder->crtc_id);
1518 drmModeFreeEncoder(encoder);
1519 if (crtc == NULL)
1520 goto err_free;
1521 if (crtc->mode_valid)
1522 crtc_mode = crtc->mode;
1523 drmModeFreeCrtc(crtc);
1524 }
Kristian Høgsberg061c4252012-06-28 11:28:15 -04001525
David Herrmann0f0d54e2011-12-08 17:05:45 +01001526 for (i = 0; i < connector->count_modes; i++) {
Ander Conselvan de Oliveira42c46462012-08-09 16:45:00 +03001527 drm_mode = drm_output_add_mode(output, &connector->modes[i]);
1528 if (!drm_mode)
David Herrmann0f0d54e2011-12-08 17:05:45 +01001529 goto err_free;
1530 }
1531
Kristian Høgsberg061c4252012-06-28 11:28:15 -04001532 preferred = NULL;
1533 current = NULL;
Scott Moreau8ab5d452012-07-30 19:51:08 -06001534 configured = NULL;
1535
1536 wl_list_for_each(temp, &configured_output_list, link) {
1537 if (strcmp(temp->name, output->name) == 0) {
Scott Moreau1bad5db2012-08-18 01:04:05 -06001538 if (temp->mode)
1539 weston_log("%s mode \"%s\" in config\n",
Scott Moreau8ab5d452012-07-30 19:51:08 -06001540 temp->name, temp->mode);
1541 o = temp;
1542 break;
1543 }
1544 }
1545
Ander Conselvan de Oliveiradc79e6d2012-08-09 16:45:01 +03001546 if (o && o->config == OUTPUT_CONFIG_OFF) {
Scott Moreau8ab5d452012-07-30 19:51:08 -06001547 weston_log("Disabling output %s\n", o->name);
1548
1549 drmModeSetCrtc(ec->drm.fd, output->crtc_id,
1550 0, 0, 0, 0, 0, NULL);
1551 goto err_free;
1552 }
1553
Kristian Høgsberg061c4252012-06-28 11:28:15 -04001554 wl_list_for_each(drm_mode, &output->base.mode_list, base.link) {
Scott Moreau1bad5db2012-08-18 01:04:05 -06001555 if (o && o->config == OUTPUT_CONFIG_MODE &&
1556 o->width == drm_mode->base.width &&
1557 o->height == drm_mode->base.height)
Ander Conselvan de Oliveira42c46462012-08-09 16:45:00 +03001558 configured = drm_mode;
Wang Quanxianacb805a2012-07-30 18:09:46 -04001559 if (!memcmp(&crtc_mode, &drm_mode->mode_info, sizeof crtc_mode))
Ander Conselvan de Oliveira42c46462012-08-09 16:45:00 +03001560 current = drm_mode;
Kristian Høgsberg061c4252012-06-28 11:28:15 -04001561 if (drm_mode->base.flags & WL_OUTPUT_MODE_PREFERRED)
Ander Conselvan de Oliveira42c46462012-08-09 16:45:00 +03001562 preferred = drm_mode;
David Herrmann0f0d54e2011-12-08 17:05:45 +01001563 }
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001564
Scott Moreau8f37e0b2012-07-31 15:30:41 -06001565 if (o && o->config == OUTPUT_CONFIG_MODELINE) {
Ander Conselvan de Oliveira42c46462012-08-09 16:45:00 +03001566 configured = drm_output_add_mode(output, &o->crtc_mode);
1567 if (!configured)
Scott Moreau8f37e0b2012-07-31 15:30:41 -06001568 goto err_free;
Scott Moreau8f37e0b2012-07-31 15:30:41 -06001569 current = configured;
1570 }
1571
Wang Quanxianacb805a2012-07-30 18:09:46 -04001572 if (current == NULL && crtc_mode.clock != 0) {
Ander Conselvan de Oliveira42c46462012-08-09 16:45:00 +03001573 current = drm_output_add_mode(output, &crtc_mode);
1574 if (!current)
Kristian Høgsberg061c4252012-06-28 11:28:15 -04001575 goto err_free;
Kristian Høgsberg061c4252012-06-28 11:28:15 -04001576 }
1577
Scott Moreau8ab5d452012-07-30 19:51:08 -06001578 if (o && o->config == OUTPUT_CONFIG_CURRENT)
1579 configured = current;
1580
Wang Quanxianacb805a2012-07-30 18:09:46 -04001581 if (option_current_mode && current)
Ander Conselvan de Oliveira42c46462012-08-09 16:45:00 +03001582 output->base.current = &current->base;
Scott Moreau8ab5d452012-07-30 19:51:08 -06001583 else if (configured)
Ander Conselvan de Oliveira42c46462012-08-09 16:45:00 +03001584 output->base.current = &configured->base;
Wang Quanxianacb805a2012-07-30 18:09:46 -04001585 else if (preferred)
Ander Conselvan de Oliveira42c46462012-08-09 16:45:00 +03001586 output->base.current = &preferred->base;
Wang Quanxianacb805a2012-07-30 18:09:46 -04001587 else if (current)
Ander Conselvan de Oliveira42c46462012-08-09 16:45:00 +03001588 output->base.current = &current->base;
Wang Quanxianacb805a2012-07-30 18:09:46 -04001589
1590 if (output->base.current == NULL) {
1591 weston_log("no available modes for %s\n", output->name);
1592 goto err_free;
Kristian Høgsberg061c4252012-06-28 11:28:15 -04001593 }
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001594
Wang Quanxianacb805a2012-07-30 18:09:46 -04001595 output->base.current->flags |= WL_OUTPUT_MODE_CURRENT;
1596
John Kåre Alsaker94659272012-11-13 19:10:18 +01001597 weston_output_init(&output->base, &ec->base, x, y,
1598 connector->mmWidth, connector->mmHeight,
1599 o ? o->transform : WL_OUTPUT_TRANSFORM_NORMAL);
1600
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02001601 if (ec->use_pixman) {
1602 if (drm_output_init_pixman(output, ec) < 0) {
1603 weston_log("Failed to init output pixman state\n");
1604 goto err_output;
1605 }
1606 } else if (drm_output_init_egl(output, ec) < 0) {
Ander Conselvan de Oliveira475cf152012-12-14 13:37:29 -02001607 weston_log("Failed to init output gl state\n");
John Kåre Alsaker94659272012-11-13 19:10:18 +01001608 goto err_output;
Kristian Høgsberg1d1e0a52012-10-21 13:29:26 -04001609 }
Kristian Høgsberg8e1f77f2012-05-03 11:39:35 -04001610
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02001611 output->backlight = backlight_init(drm_device,
1612 connector->connector_type);
1613 if (output->backlight) {
1614 output->base.set_backlight = drm_set_backlight;
1615 output->base.backlight_current = drm_get_backlight(output);
1616 }
1617
Kristian Høgsberga4b7e202011-10-24 13:26:32 -04001618 wl_list_insert(ec->base.output_list.prev, &output->base.link);
1619
Alex Wubd3354b2012-04-17 17:20:49 +08001620 output->base.origin = output->base.current;
Kristian Høgsberg68c479a2012-01-25 23:32:28 -05001621 output->base.repaint = drm_output_repaint;
Matt Roper361d2ad2011-08-29 13:52:23 -07001622 output->base.destroy = drm_output_destroy;
Jesse Barnes58ef3792012-02-23 09:45:49 -05001623 output->base.assign_planes = drm_assign_planes;
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02001624 output->base.set_dpms = drm_set_dpms;
Alex Wub7b8bda2012-04-17 17:20:48 +08001625 output->base.switch_mode = drm_output_switch_mode;
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +01001626
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04001627 weston_plane_init(&output->cursor_plane, 0, 0);
1628 weston_plane_init(&output->fb_plane, 0, 0);
1629
Ander Conselvan de Oliveira8ad19822013-03-05 17:30:27 +02001630 weston_compositor_stack_plane(&ec->base, &output->cursor_plane, NULL);
1631 weston_compositor_stack_plane(&ec->base, &output->fb_plane,
1632 &ec->base.primary_plane);
1633
Kristian Høgsberg2f9ed712012-07-26 17:57:15 -04001634 weston_log("Output %s, (connector %d, crtc %d)\n",
1635 output->name, output->connector_id, output->crtc_id);
Kristian Høgsberg061c4252012-06-28 11:28:15 -04001636 wl_list_for_each(m, &output->base.mode_list, link)
1637 weston_log_continue(" mode %dx%d@%.1f%s%s%s\n",
1638 m->width, m->height, m->refresh / 1000.0,
1639 m->flags & WL_OUTPUT_MODE_PREFERRED ?
1640 ", preferred" : "",
1641 m->flags & WL_OUTPUT_MODE_CURRENT ?
1642 ", current" : "",
1643 connector->count_modes == 0 ?
1644 ", built-in" : "");
Kristian Høgsbergfc9c5e02012-06-08 16:45:33 -04001645
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001646 return 0;
David Herrmann0f0d54e2011-12-08 17:05:45 +01001647
John Kåre Alsaker94659272012-11-13 19:10:18 +01001648err_output:
1649 weston_output_destroy(&output->base);
David Herrmann0f0d54e2011-12-08 17:05:45 +01001650err_free:
1651 wl_list_for_each_safe(drm_mode, next, &output->base.mode_list,
1652 base.link) {
1653 wl_list_remove(&drm_mode->base.link);
1654 free(drm_mode);
1655 }
1656
1657 drmModeFreeCrtc(output->original_crtc);
1658 ec->crtc_allocator &= ~(1 << output->crtc_id);
1659 ec->connector_allocator &= ~(1 << output->connector_id);
Kristian Høgsberg148ef012012-07-26 23:03:57 -04001660 free(output->name);
David Herrmann0f0d54e2011-12-08 17:05:45 +01001661 free(output);
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -04001662
David Herrmann0f0d54e2011-12-08 17:05:45 +01001663 return -1;
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001664}
1665
Jesse Barnes58ef3792012-02-23 09:45:49 -05001666static void
1667create_sprites(struct drm_compositor *ec)
1668{
1669 struct drm_sprite *sprite;
1670 drmModePlaneRes *plane_res;
1671 drmModePlane *plane;
Kristian Høgsberg875ab9e2012-03-30 11:52:39 -04001672 uint32_t i;
Jesse Barnes58ef3792012-02-23 09:45:49 -05001673
1674 plane_res = drmModeGetPlaneResources(ec->drm.fd);
1675 if (!plane_res) {
Martin Minarik6d118362012-06-07 18:01:59 +02001676 weston_log("failed to get plane resources: %s\n",
Jesse Barnes58ef3792012-02-23 09:45:49 -05001677 strerror(errno));
1678 return;
1679 }
1680
1681 for (i = 0; i < plane_res->count_planes; i++) {
1682 plane = drmModeGetPlane(ec->drm.fd, plane_res->planes[i]);
1683 if (!plane)
1684 continue;
1685
1686 sprite = malloc(sizeof(*sprite) + ((sizeof(uint32_t)) *
1687 plane->count_formats));
1688 if (!sprite) {
Martin Minarik6d118362012-06-07 18:01:59 +02001689 weston_log("%s: out of memory\n",
Jesse Barnes58ef3792012-02-23 09:45:49 -05001690 __func__);
1691 free(plane);
1692 continue;
1693 }
1694
1695 memset(sprite, 0, sizeof *sprite);
1696
1697 sprite->possible_crtcs = plane->possible_crtcs;
1698 sprite->plane_id = plane->plane_id;
Ander Conselvan de Oliveira8d360b42012-11-09 14:19:05 +02001699 sprite->current = NULL;
1700 sprite->next = NULL;
Jesse Barnes58ef3792012-02-23 09:45:49 -05001701 sprite->compositor = ec;
1702 sprite->count_formats = plane->count_formats;
1703 memcpy(sprite->formats, plane->formats,
Rob Clark8efbc8e2012-03-11 19:48:44 -05001704 plane->count_formats * sizeof(plane->formats[0]));
Jesse Barnes58ef3792012-02-23 09:45:49 -05001705 drmModeFreePlane(plane);
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04001706 weston_plane_init(&sprite->plane, 0, 0);
Ander Conselvan de Oliveira8ad19822013-03-05 17:30:27 +02001707 weston_compositor_stack_plane(&ec->base, &sprite->plane,
1708 &ec->base.primary_plane);
Jesse Barnes58ef3792012-02-23 09:45:49 -05001709
1710 wl_list_insert(&ec->sprite_list, &sprite->link);
1711 }
1712
1713 free(plane_res->planes);
1714 free(plane_res);
1715}
1716
Kristian Høgsberg85fd3272012-02-23 21:45:32 -05001717static void
1718destroy_sprites(struct drm_compositor *compositor)
1719{
1720 struct drm_sprite *sprite, *next;
1721 struct drm_output *output;
1722
1723 output = container_of(compositor->base.output_list.next,
1724 struct drm_output, base.link);
1725
1726 wl_list_for_each_safe(sprite, next, &compositor->sprite_list, link) {
1727 drmModeSetPlane(compositor->drm.fd,
1728 sprite->plane_id,
1729 output->crtc_id, 0, 0,
1730 0, 0, 0, 0, 0, 0, 0, 0);
Ander Conselvan de Oliveira526d4612013-01-25 15:13:03 +02001731 drm_output_release_fb(output, sprite->current);
1732 drm_output_release_fb(output, sprite->next);
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04001733 weston_plane_release(&sprite->plane);
Kristian Høgsberg85fd3272012-02-23 21:45:32 -05001734 free(sprite);
1735 }
1736}
Jesse Barnes58ef3792012-02-23 09:45:49 -05001737
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001738static int
Kristian Høgsberg875ab9e2012-03-30 11:52:39 -04001739create_outputs(struct drm_compositor *ec, uint32_t option_connector,
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02001740 struct udev_device *drm_device)
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001741{
1742 drmModeConnector *connector;
1743 drmModeRes *resources;
1744 int i;
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +01001745 int x = 0, y = 0;
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001746
Benjamin Franzke2af7f102011-03-02 11:14:59 +01001747 resources = drmModeGetResources(ec->drm.fd);
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001748 if (!resources) {
Martin Minarik6d118362012-06-07 18:01:59 +02001749 weston_log("drmModeGetResources failed\n");
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001750 return -1;
1751 }
1752
Jesse Barnes58ef3792012-02-23 09:45:49 -05001753 ec->crtcs = calloc(resources->count_crtcs, sizeof(uint32_t));
Christopher Michaeleb866cd2012-03-07 14:55:21 -05001754 if (!ec->crtcs) {
1755 drmModeFreeResources(resources);
Jesse Barnes58ef3792012-02-23 09:45:49 -05001756 return -1;
Christopher Michaeleb866cd2012-03-07 14:55:21 -05001757 }
Jesse Barnes58ef3792012-02-23 09:45:49 -05001758
Rob Clark4339add2012-08-09 14:18:28 -05001759 ec->min_width = resources->min_width;
1760 ec->max_width = resources->max_width;
1761 ec->min_height = resources->min_height;
1762 ec->max_height = resources->max_height;
1763
Jesse Barnes58ef3792012-02-23 09:45:49 -05001764 ec->num_crtcs = resources->count_crtcs;
1765 memcpy(ec->crtcs, resources->crtcs, sizeof(uint32_t) * ec->num_crtcs);
1766
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001767 for (i = 0; i < resources->count_connectors; i++) {
Benjamin Franzke117483d2011-08-30 11:38:26 +02001768 connector = drmModeGetConnector(ec->drm.fd,
1769 resources->connectors[i]);
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001770 if (connector == NULL)
1771 continue;
1772
1773 if (connector->connection == DRM_MODE_CONNECTED &&
1774 (option_connector == 0 ||
Benjamin Franzke9eaee352011-08-02 13:03:54 +02001775 connector->connector_id == option_connector)) {
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +01001776 if (create_output_for_connector(ec, resources,
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02001777 connector, x, y,
1778 drm_device) < 0) {
Benjamin Franzke439d9862011-10-07 08:20:53 +02001779 drmModeFreeConnector(connector);
1780 continue;
1781 }
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001782
Benjamin Franzke9eaee352011-08-02 13:03:54 +02001783 x += container_of(ec->base.output_list.prev,
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001784 struct weston_output,
Scott Moreau1bad5db2012-08-18 01:04:05 -06001785 link)->width;
Benjamin Franzke9eaee352011-08-02 13:03:54 +02001786 }
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +01001787
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001788 drmModeFreeConnector(connector);
1789 }
1790
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04001791 if (wl_list_empty(&ec->base.output_list)) {
Martin Minarik6d118362012-06-07 18:01:59 +02001792 weston_log("No currently active connector found.\n");
Christopher Michaeleb866cd2012-03-07 14:55:21 -05001793 drmModeFreeResources(resources);
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04001794 return -1;
1795 }
1796
1797 drmModeFreeResources(resources);
1798
1799 return 0;
1800}
1801
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001802static void
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02001803update_outputs(struct drm_compositor *ec, struct udev_device *drm_device)
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001804{
1805 drmModeConnector *connector;
1806 drmModeRes *resources;
1807 struct drm_output *output, *next;
1808 int x = 0, y = 0;
1809 int x_offset = 0, y_offset = 0;
1810 uint32_t connected = 0, disconnects = 0;
1811 int i;
1812
1813 resources = drmModeGetResources(ec->drm.fd);
1814 if (!resources) {
Martin Minarik6d118362012-06-07 18:01:59 +02001815 weston_log("drmModeGetResources failed\n");
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001816 return;
1817 }
1818
1819 /* collect new connects */
1820 for (i = 0; i < resources->count_connectors; i++) {
Benjamin Franzke117483d2011-08-30 11:38:26 +02001821 int connector_id = resources->connectors[i];
1822
1823 connector = drmModeGetConnector(ec->drm.fd, connector_id);
David Herrmann7551cff2011-12-08 17:05:43 +01001824 if (connector == NULL)
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001825 continue;
1826
David Herrmann7551cff2011-12-08 17:05:43 +01001827 if (connector->connection != DRM_MODE_CONNECTED) {
1828 drmModeFreeConnector(connector);
1829 continue;
1830 }
1831
Benjamin Franzke117483d2011-08-30 11:38:26 +02001832 connected |= (1 << connector_id);
1833
1834 if (!(ec->connector_allocator & (1 << connector_id))) {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001835 struct weston_output *last =
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001836 container_of(ec->base.output_list.prev,
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001837 struct weston_output, link);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001838
1839 /* XXX: not yet needed, we die with 0 outputs */
1840 if (!wl_list_empty(&ec->base.output_list))
Scott Moreau1bad5db2012-08-18 01:04:05 -06001841 x = last->x + last->width;
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001842 else
1843 x = 0;
1844 y = 0;
1845 create_output_for_connector(ec, resources,
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02001846 connector, x, y,
1847 drm_device);
Martin Minarik6d118362012-06-07 18:01:59 +02001848 weston_log("connector %d connected\n", connector_id);
Benjamin Franzke117483d2011-08-30 11:38:26 +02001849
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001850 }
1851 drmModeFreeConnector(connector);
1852 }
1853 drmModeFreeResources(resources);
1854
1855 disconnects = ec->connector_allocator & ~connected;
1856 if (disconnects) {
1857 wl_list_for_each_safe(output, next, &ec->base.output_list,
1858 base.link) {
1859 if (x_offset != 0 || y_offset != 0) {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001860 weston_output_move(&output->base,
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001861 output->base.x - x_offset,
1862 output->base.y - y_offset);
1863 }
1864
1865 if (disconnects & (1 << output->connector_id)) {
1866 disconnects &= ~(1 << output->connector_id);
Martin Minarik6d118362012-06-07 18:01:59 +02001867 weston_log("connector %d disconnected\n",
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001868 output->connector_id);
Scott Moreau1bad5db2012-08-18 01:04:05 -06001869 x_offset += output->base.width;
Benjamin Franzke48c4ea22011-08-30 11:44:56 +02001870 drm_output_destroy(&output->base);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001871 }
1872 }
1873 }
1874
1875 /* FIXME: handle zero outputs, without terminating */
1876 if (ec->connector_allocator == 0)
1877 wl_display_terminate(ec->base.wl_display);
1878}
1879
1880static int
David Herrmannd7488c22012-03-11 20:05:21 +01001881udev_event_is_hotplug(struct drm_compositor *ec, struct udev_device *device)
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001882{
David Herrmannd7488c22012-03-11 20:05:21 +01001883 const char *sysnum;
David Herrmann6ac52db2012-03-11 20:05:22 +01001884 const char *val;
David Herrmannd7488c22012-03-11 20:05:21 +01001885
1886 sysnum = udev_device_get_sysnum(device);
1887 if (!sysnum || atoi(sysnum) != ec->drm.id)
1888 return 0;
Benjamin Franzke117483d2011-08-30 11:38:26 +02001889
David Herrmann6ac52db2012-03-11 20:05:22 +01001890 val = udev_device_get_property_value(device, "HOTPLUG");
1891 if (!val)
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001892 return 0;
1893
David Herrmann6ac52db2012-03-11 20:05:22 +01001894 return strcmp(val, "1") == 0;
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001895}
1896
Kristian Høgsbergb1868472011-04-22 12:27:57 -04001897static int
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001898udev_drm_event(int fd, uint32_t mask, void *data)
1899{
1900 struct drm_compositor *ec = data;
1901 struct udev_device *event;
1902
1903 event = udev_monitor_receive_device(ec->udev_monitor);
Benjamin Franzke117483d2011-08-30 11:38:26 +02001904
David Herrmannd7488c22012-03-11 20:05:21 +01001905 if (udev_event_is_hotplug(ec, event))
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02001906 update_outputs(ec, event);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001907
1908 udev_device_unref(event);
Kristian Høgsbergb1868472011-04-22 12:27:57 -04001909
1910 return 1;
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001911}
1912
Kristian Høgsbergcaa64422010-12-01 16:52:15 -05001913static void
Kristian Høgsberg7b884bc2012-07-31 14:32:01 -04001914drm_restore(struct weston_compositor *ec)
1915{
1916 struct drm_compositor *d = (struct drm_compositor *) ec;
1917
1918 if (weston_launcher_drm_set_master(&d->base, d->drm.fd, 0) < 0)
1919 weston_log("failed to drop master: %m\n");
1920 tty_reset(d->tty);
1921}
1922
1923static void
Scott Moreauc50645c2012-07-31 22:29:56 -06001924drm_free_configured_output(struct drm_configured_output *output)
1925{
1926 free(output->name);
1927 free(output->mode);
1928 free(output);
1929}
1930
1931static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001932drm_destroy(struct weston_compositor *ec)
Kristian Høgsbergcaa64422010-12-01 16:52:15 -05001933{
1934 struct drm_compositor *d = (struct drm_compositor *) ec;
Kristian Høgsberge8091032013-02-18 15:43:29 -05001935 struct udev_seat *seat, *next;
Scott Moreau8ab5d452012-07-30 19:51:08 -06001936 struct drm_configured_output *o, *n;
Kristian Høgsbergcaa64422010-12-01 16:52:15 -05001937
Kristian Høgsberge8091032013-02-18 15:43:29 -05001938 wl_list_for_each_safe(seat, next, &ec->seat_list, base.link)
1939 udev_seat_destroy(seat);
Scott Moreau8ab5d452012-07-30 19:51:08 -06001940 wl_list_for_each_safe(o, n, &configured_output_list, link)
Scott Moreauc50645c2012-07-31 22:29:56 -06001941 drm_free_configured_output(o);
Jonas Ådahlc97af922012-03-28 22:36:09 +02001942
1943 wl_event_source_remove(d->udev_drm_source);
1944 wl_event_source_remove(d->drm_source);
1945
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001946 weston_compositor_shutdown(ec);
Jonas Ådahlc97af922012-03-28 22:36:09 +02001947
Vasily Khoruzhick52cfd612013-01-08 19:09:01 +03001948 ec->renderer->destroy(ec);
Kristian Høgsberg3a0de882012-09-06 21:44:24 -04001949
Kristian Høgsberg85fd3272012-02-23 21:45:32 -05001950 destroy_sprites(d);
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02001951
1952 if (d->gbm)
1953 gbm_device_destroy(d->gbm);
1954
Benjamin Franzkebfeda132012-01-30 14:04:04 +01001955 if (weston_launcher_drm_set_master(&d->base, d->drm.fd, 0) < 0)
Martin Minarik6d118362012-06-07 18:01:59 +02001956 weston_log("failed to drop master: %m\n");
Kristian Høgsberge4762a62011-01-14 14:59:13 -05001957 tty_destroy(d->tty);
Kristian Høgsbergcaa64422010-12-01 16:52:15 -05001958
Kristian Høgsberge4762a62011-01-14 14:59:13 -05001959 free(d);
Kristian Høgsbergcaa64422010-12-01 16:52:15 -05001960}
1961
Kristian Høgsberg9396fc52011-05-06 15:15:37 -04001962static void
Kristian Høgsberg835cd492012-01-18 11:48:46 -05001963drm_compositor_set_modes(struct drm_compositor *compositor)
1964{
1965 struct drm_output *output;
1966 struct drm_mode *drm_mode;
1967 int ret;
1968
1969 wl_list_for_each(output, &compositor->base.output_list, base.link) {
Ander Conselvan de Oliveira2002f882013-02-26 13:44:58 +02001970 if (!output->current) {
1971 /* If something that would cause the output to
1972 * switch mode happened while in another vt, we
1973 * might not have a current drm_fb. In that case,
1974 * schedule a repaint and let drm_output_repaint
1975 * handle setting the mode. */
1976 weston_output_schedule_repaint(&output->base);
1977 continue;
1978 }
1979
Kristian Høgsberg835cd492012-01-18 11:48:46 -05001980 drm_mode = (struct drm_mode *) output->base.current;
1981 ret = drmModeSetCrtc(compositor->drm.fd, output->crtc_id,
Ander Conselvan de Oliveira555c17d2012-05-02 16:42:21 +03001982 output->current->fb_id, 0, 0,
Kristian Høgsberg835cd492012-01-18 11:48:46 -05001983 &output->connector_id, 1,
1984 &drm_mode->mode_info);
1985 if (ret < 0) {
Martin Minarik6d118362012-06-07 18:01:59 +02001986 weston_log(
Kristian Høgsbergcbcd0472012-03-11 18:27:41 -04001987 "failed to set mode %dx%d for output at %d,%d: %m\n",
Kristian Høgsberg835cd492012-01-18 11:48:46 -05001988 drm_mode->base.width, drm_mode->base.height,
1989 output->base.x, output->base.y);
1990 }
1991 }
1992}
1993
1994static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001995vt_func(struct weston_compositor *compositor, int event)
Kristian Høgsberg9396fc52011-05-06 15:15:37 -04001996{
1997 struct drm_compositor *ec = (struct drm_compositor *) compositor;
Kristian Høgsberge8091032013-02-18 15:43:29 -05001998 struct udev_seat *seat;
Kristian Høgsberg85fd3272012-02-23 21:45:32 -05001999 struct drm_sprite *sprite;
Kristian Høgsberga6edab32012-07-14 01:06:28 -04002000 struct drm_output *output;
Kristian Høgsberg9396fc52011-05-06 15:15:37 -04002001
2002 switch (event) {
2003 case TTY_ENTER_VT:
Pekka Paalanen81a13a32012-08-03 14:39:10 +03002004 weston_log("entering VT\n");
Kristian Høgsberg9396fc52011-05-06 15:15:37 -04002005 compositor->focus = 1;
Benjamin Franzkebfeda132012-01-30 14:04:04 +01002006 if (weston_launcher_drm_set_master(&ec->base, ec->drm.fd, 1)) {
Martin Minarik6d118362012-06-07 18:01:59 +02002007 weston_log("failed to set master: %m\n");
Kristian Høgsberga018fb02012-01-16 10:52:52 -05002008 wl_display_terminate(compositor->wl_display);
2009 }
Pekka Paalanenbce2d3f2011-12-02 13:07:27 +02002010 compositor->state = ec->prev_state;
Kristian Høgsberg835cd492012-01-18 11:48:46 -05002011 drm_compositor_set_modes(ec);
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002012 weston_compositor_damage_all(compositor);
Kristian Høgsberg87644662013-02-18 16:50:19 -05002013 wl_list_for_each(seat, &compositor->seat_list, base.link)
2014 udev_seat_enable(seat, ec->udev);
Kristian Høgsberg9396fc52011-05-06 15:15:37 -04002015 break;
2016 case TTY_LEAVE_VT:
Pekka Paalanen81a13a32012-08-03 14:39:10 +03002017 weston_log("leaving VT\n");
Kristian Høgsberg87644662013-02-18 16:50:19 -05002018 wl_list_for_each(seat, &compositor->seat_list, base.link)
2019 udev_seat_disable(seat);
Kristian Høgsberg4014a6b2012-04-10 00:08:45 -04002020
Kristian Høgsberg9396fc52011-05-06 15:15:37 -04002021 compositor->focus = 0;
Pekka Paalanenbce2d3f2011-12-02 13:07:27 +02002022 ec->prev_state = compositor->state;
Philipp Brüschweiler57edf7f2013-03-29 13:01:56 +01002023 weston_compositor_offscreen(compositor);
Kristian Høgsbergd8e181b2011-05-06 15:38:28 -04002024
Kristian Høgsberg34f80ff2012-01-18 11:50:31 -05002025 /* If we have a repaint scheduled (either from a
2026 * pending pageflip or the idle handler), make sure we
2027 * cancel that so we don't try to pageflip when we're
Philipp Brüschweiler57edf7f2013-03-29 13:01:56 +01002028 * vt switched away. The OFFSCREEN state will prevent
Kristian Høgsberg34f80ff2012-01-18 11:50:31 -05002029 * further attemps at repainting. When we switch
2030 * back, we schedule a repaint, which will process
2031 * pending frame callbacks. */
2032
Kristian Høgsberga6edab32012-07-14 01:06:28 -04002033 wl_list_for_each(output, &ec->base.output_list, base.link) {
2034 output->base.repaint_needed = 0;
2035 drmModeSetCursor(ec->drm.fd, output->crtc_id, 0, 0, 0);
Kristian Høgsberg34f80ff2012-01-18 11:50:31 -05002036 }
2037
Kristian Høgsberga6edab32012-07-14 01:06:28 -04002038 output = container_of(ec->base.output_list.next,
2039 struct drm_output, base.link);
Kristian Høgsberg85fd3272012-02-23 21:45:32 -05002040
2041 wl_list_for_each(sprite, &ec->sprite_list, link)
2042 drmModeSetPlane(ec->drm.fd,
2043 sprite->plane_id,
Kristian Høgsberga6edab32012-07-14 01:06:28 -04002044 output->crtc_id, 0, 0,
Kristian Høgsberg85fd3272012-02-23 21:45:32 -05002045 0, 0, 0, 0, 0, 0, 0, 0);
2046
Benjamin Franzkebfeda132012-01-30 14:04:04 +01002047 if (weston_launcher_drm_set_master(&ec->base, ec->drm.fd, 0) < 0)
Martin Minarik6d118362012-06-07 18:01:59 +02002048 weston_log("failed to drop master: %m\n");
Kristian Høgsberga018fb02012-01-16 10:52:52 -05002049
Kristian Høgsberg9396fc52011-05-06 15:15:37 -04002050 break;
2051 };
2052}
2053
Kristian Høgsberg5d1c0c52012-04-10 00:11:50 -04002054static void
Daniel Stone325fc2d2012-05-30 16:31:58 +01002055switch_vt_binding(struct wl_seat *seat, uint32_t time, uint32_t key, void *data)
Kristian Høgsberg5d1c0c52012-04-10 00:11:50 -04002056{
2057 struct drm_compositor *ec = data;
2058
Daniel Stone325fc2d2012-05-30 16:31:58 +01002059 tty_activate_vt(ec->tty, key - KEY_F1 + 1);
Kristian Høgsberg5d1c0c52012-04-10 00:11:50 -04002060}
2061
David Herrmann0af066f2012-10-29 19:21:16 +01002062/*
2063 * Find primary GPU
2064 * Some systems may have multiple DRM devices attached to a single seat. This
2065 * function loops over all devices and tries to find a PCI device with the
2066 * boot_vga sysfs attribute set to 1.
2067 * If no such device is found, the first DRM device reported by udev is used.
2068 */
2069static struct udev_device*
2070find_primary_gpu(struct drm_compositor *ec, const char *seat)
2071{
2072 struct udev_enumerate *e;
2073 struct udev_list_entry *entry;
2074 const char *path, *device_seat, *id;
2075 struct udev_device *device, *drm_device, *pci;
2076
2077 e = udev_enumerate_new(ec->udev);
2078 udev_enumerate_add_match_subsystem(e, "drm");
2079 udev_enumerate_add_match_sysname(e, "card[0-9]*");
2080
2081 udev_enumerate_scan_devices(e);
2082 drm_device = NULL;
2083 udev_list_entry_foreach(entry, udev_enumerate_get_list_entry(e)) {
2084 path = udev_list_entry_get_name(entry);
2085 device = udev_device_new_from_syspath(ec->udev, path);
2086 if (!device)
2087 continue;
2088 device_seat = udev_device_get_property_value(device, "ID_SEAT");
2089 if (!device_seat)
2090 device_seat = default_seat;
2091 if (strcmp(device_seat, seat)) {
2092 udev_device_unref(device);
2093 continue;
2094 }
2095
2096 pci = udev_device_get_parent_with_subsystem_devtype(device,
2097 "pci", NULL);
2098 if (pci) {
2099 id = udev_device_get_sysattr_value(pci, "boot_vga");
2100 if (id && !strcmp(id, "1")) {
2101 if (drm_device)
2102 udev_device_unref(drm_device);
2103 drm_device = device;
2104 break;
2105 }
2106 }
2107
2108 if (!drm_device)
2109 drm_device = device;
2110 else
2111 udev_device_unref(device);
2112 }
2113
2114 udev_enumerate_unref(e);
2115 return drm_device;
2116}
2117
Ander Conselvan de Oliveirada1c9082012-10-31 17:55:46 +02002118static void
Ander Conselvan de Oliveira7e918da2012-11-22 15:56:59 +02002119planes_binding(struct wl_seat *seat, uint32_t time, uint32_t key, void *data)
Ander Conselvan de Oliveirada1c9082012-10-31 17:55:46 +02002120{
2121 struct drm_compositor *c = data;
2122
Ander Conselvan de Oliveira7e918da2012-11-22 15:56:59 +02002123 switch (key) {
2124 case KEY_C:
2125 c->cursors_are_broken ^= 1;
2126 break;
2127 case KEY_V:
2128 c->sprites_are_broken ^= 1;
2129 break;
2130 case KEY_O:
2131 c->sprites_hidden ^= 1;
2132 break;
2133 default:
2134 break;
2135 }
Ander Conselvan de Oliveira180f42a2012-11-21 15:11:37 +02002136}
2137
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002138static struct weston_compositor *
Kristian Høgsberg8d51f142011-07-15 21:28:38 -04002139drm_compositor_create(struct wl_display *display,
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02002140 int connector, const char *seat, int tty, int pixman,
Kristian Høgsberg4172f662013-02-20 15:27:49 -05002141 int *argc, char *argv[], const char *config_file)
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002142{
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04002143 struct drm_compositor *ec;
David Herrmann0af066f2012-10-29 19:21:16 +01002144 struct udev_device *drm_device;
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002145 struct wl_event_loop *loop;
Kristian Høgsberge8091032013-02-18 15:43:29 -05002146 struct udev_seat *udev_seat, *next;
David Herrmann0af066f2012-10-29 19:21:16 +01002147 const char *path;
Kristian Høgsberg5d1c0c52012-04-10 00:11:50 -04002148 uint32_t key;
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002149
Kristian Høgsbergfc9c5e02012-06-08 16:45:33 -04002150 weston_log("initializing drm backend\n");
2151
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04002152 ec = malloc(sizeof *ec);
2153 if (ec == NULL)
2154 return NULL;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04002155 memset(ec, 0, sizeof *ec);
Daniel Stone725c2c32012-06-22 14:04:36 +01002156
Kristian Høgsbergde37d672012-11-02 10:14:40 -04002157 /* KMS support for sprites is not complete yet, so disable the
2158 * functionality for now. */
2159 ec->sprites_are_broken = 1;
2160
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02002161 ec->use_pixman = pixman;
2162
Daniel Stone725c2c32012-06-22 14:04:36 +01002163 if (weston_compositor_init(&ec->base, display, argc, argv,
Daniel Stonea96b93c2012-06-22 14:04:37 +01002164 config_file) < 0) {
Scott Moreau8eb67482013-02-23 12:04:56 -07002165 weston_log("%s failed\n", __func__);
Daniel Stonea96b93c2012-06-22 14:04:37 +01002166 goto err_base;
2167 }
Daniel Stone725c2c32012-06-22 14:04:36 +01002168
Rafal Mielniczuk32069c02013-03-27 18:39:28 +01002169 /* Check if we run drm-backend using weston-launch */
2170 if (ec->base.launcher_sock == -1) {
2171 weston_log("fatal: drm backend should be run "
2172 "using weston-launch binary\n");
2173 goto err_compositor;
2174 }
2175
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002176 ec->udev = udev_new();
2177 if (ec->udev == NULL) {
Martin Minarik6d118362012-06-07 18:01:59 +02002178 weston_log("failed to initialize udev context\n");
Daniel Stonea96b93c2012-06-22 14:04:37 +01002179 goto err_compositor;
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002180 }
2181
Kristian Høgsbergc5b9ddb2012-01-15 14:29:09 -05002182 ec->base.wl_display = display;
2183 ec->tty = tty_create(&ec->base, vt_func, tty);
2184 if (!ec->tty) {
Martin Minarik6d118362012-06-07 18:01:59 +02002185 weston_log("failed to initialize tty\n");
Daniel Stonea96b93c2012-06-22 14:04:37 +01002186 goto err_udev;
Kristian Høgsbergc5b9ddb2012-01-15 14:29:09 -05002187 }
2188
David Herrmann0af066f2012-10-29 19:21:16 +01002189 drm_device = find_primary_gpu(ec, seat);
Kristian Høgsberg8d51f142011-07-15 21:28:38 -04002190 if (drm_device == NULL) {
Martin Minarik6d118362012-06-07 18:01:59 +02002191 weston_log("no drm device found\n");
David Herrmann0af066f2012-10-29 19:21:16 +01002192 goto err_tty;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04002193 }
David Herrmann0af066f2012-10-29 19:21:16 +01002194 path = udev_device_get_syspath(drm_device);
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002195
Ander Conselvan de Oliveira22929172013-01-25 15:13:02 +02002196 if (init_drm(ec, drm_device) < 0) {
2197 weston_log("failed to initialize kms\n");
2198 goto err_udev_dev;
2199 }
2200
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02002201 if (ec->use_pixman) {
2202 if (init_pixman(ec) < 0) {
2203 weston_log("failed to initialize pixman renderer\n");
2204 goto err_udev_dev;
2205 }
2206 } else {
2207 if (init_egl(ec) < 0) {
2208 weston_log("failed to initialize egl\n");
2209 goto err_udev_dev;
2210 }
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04002211 }
Kristian Høgsberg8525a502011-01-14 16:20:21 -05002212
2213 ec->base.destroy = drm_destroy;
Kristian Høgsberg7b884bc2012-07-31 14:32:01 -04002214 ec->base.restore = drm_restore;
Benjamin Franzke431da9a2011-04-20 11:02:58 +02002215
Kristian Høgsberg8525a502011-01-14 16:20:21 -05002216 ec->base.focus = 1;
2217
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002218 ec->prev_state = WESTON_COMPOSITOR_ACTIVE;
Pekka Paalanenbce2d3f2011-12-02 13:07:27 +02002219
Kristian Høgsberg5d1c0c52012-04-10 00:11:50 -04002220 for (key = KEY_F1; key < KEY_F9; key++)
Daniel Stone325fc2d2012-05-30 16:31:58 +01002221 weston_compositor_add_key_binding(&ec->base, key,
2222 MODIFIER_CTRL | MODIFIER_ALT,
2223 switch_vt_binding, ec);
Kristian Høgsberg5d1c0c52012-04-10 00:11:50 -04002224
Jesse Barnes58ef3792012-02-23 09:45:49 -05002225 wl_list_init(&ec->sprite_list);
2226 create_sprites(ec);
2227
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02002228 if (create_outputs(ec, connector, drm_device) < 0) {
Martin Minarik6d118362012-06-07 18:01:59 +02002229 weston_log("failed to create output for %s\n", path);
Daniel Stonea96b93c2012-06-22 14:04:37 +01002230 goto err_sprite;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04002231 }
2232
Benjamin Franzke02dee2c2011-10-07 08:27:26 +02002233 path = NULL;
2234
Kristian Høgsberge8091032013-02-18 15:43:29 -05002235 if (udev_seat_create(&ec->base, ec->udev, seat) == NULL) {
Kristian Høgsberg2f07ef62013-02-16 14:29:24 -05002236 weston_log("failed to create input devices\n");
2237 goto err_sprite;
2238 }
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04002239
2240 loop = wl_display_get_event_loop(ec->base.wl_display);
2241 ec->drm_source =
Benjamin Franzke2af7f102011-03-02 11:14:59 +01002242 wl_event_loop_add_fd(loop, ec->drm.fd,
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04002243 WL_EVENT_READABLE, on_drm_input, ec);
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04002244
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002245 ec->udev_monitor = udev_monitor_new_from_netlink(ec->udev, "udev");
2246 if (ec->udev_monitor == NULL) {
Martin Minarik6d118362012-06-07 18:01:59 +02002247 weston_log("failed to intialize udev monitor\n");
Daniel Stonea96b93c2012-06-22 14:04:37 +01002248 goto err_drm_source;
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002249 }
2250 udev_monitor_filter_add_match_subsystem_devtype(ec->udev_monitor,
2251 "drm", NULL);
2252 ec->udev_drm_source =
Benjamin Franzke117483d2011-08-30 11:38:26 +02002253 wl_event_loop_add_fd(loop,
2254 udev_monitor_get_fd(ec->udev_monitor),
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002255 WL_EVENT_READABLE, udev_drm_event, ec);
2256
2257 if (udev_monitor_enable_receiving(ec->udev_monitor) < 0) {
Martin Minarik6d118362012-06-07 18:01:59 +02002258 weston_log("failed to enable udev-monitor receiving\n");
Daniel Stonea96b93c2012-06-22 14:04:37 +01002259 goto err_udev_monitor;
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002260 }
2261
Daniel Stonea96b93c2012-06-22 14:04:37 +01002262 udev_device_unref(drm_device);
Daniel Stonea96b93c2012-06-22 14:04:37 +01002263
Ander Conselvan de Oliveirac509d2b2012-11-08 17:20:45 +02002264 weston_compositor_add_debug_binding(&ec->base, KEY_O,
Ander Conselvan de Oliveira7e918da2012-11-22 15:56:59 +02002265 planes_binding, ec);
Ander Conselvan de Oliveira180f42a2012-11-21 15:11:37 +02002266 weston_compositor_add_debug_binding(&ec->base, KEY_C,
Ander Conselvan de Oliveira7e918da2012-11-22 15:56:59 +02002267 planes_binding, ec);
2268 weston_compositor_add_debug_binding(&ec->base, KEY_V,
2269 planes_binding, ec);
Ander Conselvan de Oliveirada1c9082012-10-31 17:55:46 +02002270
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04002271 return &ec->base;
Daniel Stonea96b93c2012-06-22 14:04:37 +01002272
2273err_udev_monitor:
2274 wl_event_source_remove(ec->udev_drm_source);
2275 udev_monitor_unref(ec->udev_monitor);
2276err_drm_source:
2277 wl_event_source_remove(ec->drm_source);
Kristian Høgsberge8091032013-02-18 15:43:29 -05002278 wl_list_for_each_safe(udev_seat, next, &ec->base.seat_list, base.link)
2279 udev_seat_destroy(udev_seat);
Kristian Høgsberg2bc5e8e2012-09-06 20:51:00 -04002280err_sprite:
Vasily Khoruzhick52cfd612013-01-08 19:09:01 +03002281 ec->base.renderer->destroy(&ec->base);
John Kåre Alsaker1b7ad162012-11-13 19:10:19 +01002282 gbm_device_destroy(ec->gbm);
Kristian Høgsberg2bc5e8e2012-09-06 20:51:00 -04002283 destroy_sprites(ec);
Daniel Stonea96b93c2012-06-22 14:04:37 +01002284err_udev_dev:
2285 udev_device_unref(drm_device);
David Herrmann0af066f2012-10-29 19:21:16 +01002286err_tty:
Kristian Høgsberg50623842013-02-18 15:02:27 -05002287 if (weston_launcher_drm_set_master(&ec->base, ec->drm.fd, 0) < 0)
2288 weston_log("failed to drop master: %m\n");
Daniel Stonea96b93c2012-06-22 14:04:37 +01002289 tty_destroy(ec->tty);
2290err_udev:
2291 udev_unref(ec->udev);
2292err_compositor:
2293 weston_compositor_shutdown(&ec->base);
2294err_base:
2295 free(ec);
2296 return NULL;
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002297}
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002298
Scott Moreau8f37e0b2012-07-31 15:30:41 -06002299static int
2300set_sync_flags(drmModeModeInfo *mode, char *hsync, char *vsync)
2301{
2302 mode->flags = 0;
2303
2304 if (strcmp(hsync, "+hsync") == 0)
2305 mode->flags |= DRM_MODE_FLAG_PHSYNC;
2306 else if (strcmp(hsync, "-hsync") == 0)
2307 mode->flags |= DRM_MODE_FLAG_NHSYNC;
2308 else
2309 return -1;
2310
2311 if (strcmp(vsync, "+vsync") == 0)
2312 mode->flags |= DRM_MODE_FLAG_PVSYNC;
2313 else if (strcmp(vsync, "-vsync") == 0)
2314 mode->flags |= DRM_MODE_FLAG_NVSYNC;
2315 else
2316 return -1;
2317
2318 return 0;
2319}
2320
2321static int
2322check_for_modeline(struct drm_configured_output *output)
2323{
2324 drmModeModeInfo mode;
2325 char hsync[16];
2326 char vsync[16];
2327 char mode_name[16];
2328 float fclock;
2329
2330 mode.type = DRM_MODE_TYPE_USERDEF;
2331 mode.hskew = 0;
2332 mode.vscan = 0;
2333 mode.vrefresh = 0;
2334
2335 if (sscanf(output_mode, "%f %hd %hd %hd %hd %hd %hd %hd %hd %s %s",
2336 &fclock, &mode.hdisplay,
2337 &mode.hsync_start,
2338 &mode.hsync_end, &mode.htotal,
2339 &mode.vdisplay,
2340 &mode.vsync_start,
2341 &mode.vsync_end, &mode.vtotal,
2342 hsync, vsync) == 11) {
2343 if (set_sync_flags(&mode, hsync, vsync))
2344 return -1;
2345
2346 sprintf(mode_name, "%dx%d", mode.hdisplay, mode.vdisplay);
2347 strcpy(mode.name, mode_name);
2348
2349 mode.clock = fclock * 1000;
2350 } else
2351 return -1;
2352
2353 output->crtc_mode = mode;
2354
2355 return 0;
2356}
2357
Scott Moreau8ab5d452012-07-30 19:51:08 -06002358static void
Scott Moreau1bad5db2012-08-18 01:04:05 -06002359drm_output_set_transform(struct drm_configured_output *output)
2360{
2361 if (!output_transform) {
2362 output->transform = WL_OUTPUT_TRANSFORM_NORMAL;
2363 return;
2364 }
2365
2366 if (!strcmp(output_transform, "normal"))
2367 output->transform = WL_OUTPUT_TRANSFORM_NORMAL;
2368 else if (!strcmp(output_transform, "90"))
2369 output->transform = WL_OUTPUT_TRANSFORM_90;
2370 else if (!strcmp(output_transform, "180"))
2371 output->transform = WL_OUTPUT_TRANSFORM_180;
2372 else if (!strcmp(output_transform, "270"))
2373 output->transform = WL_OUTPUT_TRANSFORM_270;
2374 else if (!strcmp(output_transform, "flipped"))
2375 output->transform = WL_OUTPUT_TRANSFORM_FLIPPED;
2376 else if (!strcmp(output_transform, "flipped-90"))
2377 output->transform = WL_OUTPUT_TRANSFORM_FLIPPED_90;
2378 else if (!strcmp(output_transform, "flipped-180"))
2379 output->transform = WL_OUTPUT_TRANSFORM_FLIPPED_180;
2380 else if (!strcmp(output_transform, "flipped-270"))
2381 output->transform = WL_OUTPUT_TRANSFORM_FLIPPED_270;
2382 else {
2383 weston_log("Invalid transform \"%s\" for output %s\n",
2384 output_transform, output_name);
2385 output->transform = WL_OUTPUT_TRANSFORM_NORMAL;
2386 }
2387
2388 free(output_transform);
2389 output_transform = NULL;
2390}
2391
2392static void
Scott Moreau8ab5d452012-07-30 19:51:08 -06002393output_section_done(void *data)
2394{
2395 struct drm_configured_output *output;
2396
2397 output = malloc(sizeof *output);
2398
Scott Moreau1bad5db2012-08-18 01:04:05 -06002399 if (!output || !output_name || (output_name[0] == 'X') ||
2400 (!output_mode && !output_transform)) {
Kristian Høgsberg8ff69152012-07-31 22:18:28 -04002401 free(output_name);
Kristian Høgsberg8ff69152012-07-31 22:18:28 -04002402 free(output_mode);
Scott Moreau1bad5db2012-08-18 01:04:05 -06002403 free(output_transform);
Rob Bradford6b6795f2012-10-09 18:44:35 +01002404 free(output);
Scott Moreau1bad5db2012-08-18 01:04:05 -06002405 output_name = NULL;
Kristian Høgsberg8ff69152012-07-31 22:18:28 -04002406 output_mode = NULL;
Scott Moreau1bad5db2012-08-18 01:04:05 -06002407 output_transform = NULL;
Scott Moreau8ab5d452012-07-30 19:51:08 -06002408 return;
Kristian Høgsberg8ff69152012-07-31 22:18:28 -04002409 }
Scott Moreau8ab5d452012-07-30 19:51:08 -06002410
2411 output->config = OUTPUT_CONFIG_INVALID;
2412 output->name = output_name;
2413 output->mode = output_mode;
2414
Scott Moreau1bad5db2012-08-18 01:04:05 -06002415 if (output_mode) {
2416 if (strcmp(output_mode, "off") == 0)
2417 output->config = OUTPUT_CONFIG_OFF;
2418 else if (strcmp(output_mode, "preferred") == 0)
2419 output->config = OUTPUT_CONFIG_PREFERRED;
2420 else if (strcmp(output_mode, "current") == 0)
2421 output->config = OUTPUT_CONFIG_CURRENT;
2422 else if (sscanf(output_mode, "%dx%d",
2423 &output->width, &output->height) == 2)
2424 output->config = OUTPUT_CONFIG_MODE;
2425 else if (check_for_modeline(output) == 0)
2426 output->config = OUTPUT_CONFIG_MODELINE;
Scott Moreau8ab5d452012-07-30 19:51:08 -06002427
Scott Moreau1bad5db2012-08-18 01:04:05 -06002428 if (output->config == OUTPUT_CONFIG_INVALID)
2429 weston_log("Invalid mode \"%s\" for output %s\n",
2430 output_mode, output_name);
2431 output_mode = NULL;
Scott Moreau8ab5d452012-07-30 19:51:08 -06002432 }
Scott Moreau1bad5db2012-08-18 01:04:05 -06002433
2434 drm_output_set_transform(output);
2435
2436 wl_list_insert(&configured_output_list, &output->link);
2437
2438 if (output_transform)
2439 free(output_transform);
2440 output_transform = NULL;
Scott Moreau8ab5d452012-07-30 19:51:08 -06002441}
2442
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002443WL_EXPORT struct weston_compositor *
Kristian Høgsberg4172f662013-02-20 15:27:49 -05002444backend_init(struct wl_display *display, int *argc, char *argv[],
Daniel Stonec1be8e52012-06-01 11:14:02 -04002445 const char *config_file)
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002446{
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02002447 int connector = 0, tty = 0, use_pixman = 0;
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04002448 const char *seat = default_seat;
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002449
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04002450 const struct weston_option drm_options[] = {
2451 { WESTON_OPTION_INTEGER, "connector", 0, &connector },
2452 { WESTON_OPTION_STRING, "seat", 0, &seat },
2453 { WESTON_OPTION_INTEGER, "tty", 0, &tty },
Kristian Høgsberg061c4252012-06-28 11:28:15 -04002454 { WESTON_OPTION_BOOLEAN, "current-mode", 0, &option_current_mode },
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02002455 { WESTON_OPTION_BOOLEAN, "use-pixman", 0, &use_pixman },
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04002456 };
Benjamin Franzke117483d2011-08-30 11:38:26 +02002457
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04002458 parse_options(drm_options, ARRAY_LENGTH(drm_options), argc, argv);
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002459
Scott Moreau8ab5d452012-07-30 19:51:08 -06002460 wl_list_init(&configured_output_list);
2461
2462 const struct config_key drm_config_keys[] = {
2463 { "name", CONFIG_KEY_STRING, &output_name },
2464 { "mode", CONFIG_KEY_STRING, &output_mode },
Scott Moreau1bad5db2012-08-18 01:04:05 -06002465 { "transform", CONFIG_KEY_STRING, &output_transform },
Scott Moreau8ab5d452012-07-30 19:51:08 -06002466 };
2467
2468 const struct config_section config_section[] = {
2469 { "output", drm_config_keys,
2470 ARRAY_LENGTH(drm_config_keys), output_section_done },
2471 };
2472
2473 parse_config_file(config_file, config_section,
2474 ARRAY_LENGTH(config_section), NULL);
2475
Ander Conselvan de Oliveira5fb44142013-01-25 15:13:05 +02002476 return drm_compositor_create(display, connector, seat, tty, use_pixman,
2477 argc, argv, config_file);
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002478}