1 /**************************************************************************
2 *
3 * Copyright 2009 Younes Manton.
4 * All Rights Reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
13 *
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
16 * of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 *
26 **************************************************************************/
27
28 /* directly referenced from target Makefile, because of X dependencies */
29
30 #include <sys/types.h>
31 #include <sys/stat.h>
32 #include <fcntl.h>
33
34 #include <X11/Xlib-xcb.h>
35 #include <X11/extensions/dri2tokens.h>
36 #include <xcb/dri2.h>
37 #include <xf86drm.h>
38 #include <errno.h>
39
40 #include "loader.h"
41
42 #include "pipe/p_screen.h"
43 #include "pipe/p_context.h"
44 #include "pipe/p_state.h"
45 #include "pipe-loader/pipe_loader.h"
46 #include "state_tracker/drm_driver.h"
47
48 #include "util/u_memory.h"
49 #include "util/crc32.h"
50 #include "util/u_hash_table.h"
51 #include "util/u_inlines.h"
52
53 #include "vl/vl_compositor.h"
54 #include "vl/vl_winsys.h"
55
56 struct vl_dri_screen
57 {
58 struct vl_screen base;
59 xcb_connection_t *conn;
60 xcb_drawable_t drawable;
61
62 unsigned width, height;
63
64 bool current_buffer;
65 uint32_t buffer_names[2];
66 struct u_rect dirty_areas[2];
67
68 bool flushed;
69 xcb_dri2_swap_buffers_cookie_t swap_cookie;
70 xcb_dri2_wait_sbc_cookie_t wait_cookie;
71 xcb_dri2_get_buffers_cookie_t buffers_cookie;
72
73 int64_t last_ust, ns_frame, last_msc, next_msc;
74 };
75
76 static const unsigned attachments[1] = { XCB_DRI2_ATTACHMENT_BUFFER_BACK_LEFT };
77
78 static void vl_dri2_screen_destroy(struct vl_screen *vscreen);
79
80 static void
vl_dri2_handle_stamps(struct vl_dri_screen * scrn,uint32_t ust_hi,uint32_t ust_lo,uint32_t msc_hi,uint32_t msc_lo)81 vl_dri2_handle_stamps(struct vl_dri_screen *scrn,
82 uint32_t ust_hi, uint32_t ust_lo,
83 uint32_t msc_hi, uint32_t msc_lo)
84 {
85 int64_t ust = ((((uint64_t)ust_hi) << 32) | ust_lo) * 1000;
86 int64_t msc = (((uint64_t)msc_hi) << 32) | msc_lo;
87
88 if (scrn->last_ust && (ust > scrn->last_ust) &&
89 scrn->last_msc && (msc > scrn->last_msc))
90 scrn->ns_frame = (ust - scrn->last_ust) / (msc - scrn->last_msc);
91
92 scrn->last_ust = ust;
93 scrn->last_msc = msc;
94 }
95
96 static xcb_dri2_get_buffers_reply_t *
vl_dri2_get_flush_reply(struct vl_dri_screen * scrn)97 vl_dri2_get_flush_reply(struct vl_dri_screen *scrn)
98 {
99 xcb_dri2_wait_sbc_reply_t *wait_sbc_reply;
100
101 assert(scrn);
102
103 if (!scrn->flushed)
104 return NULL;
105
106 scrn->flushed = false;
107
108 free(xcb_dri2_swap_buffers_reply(scrn->conn, scrn->swap_cookie, NULL));
109
110 wait_sbc_reply = xcb_dri2_wait_sbc_reply(scrn->conn, scrn->wait_cookie, NULL);
111 if (!wait_sbc_reply)
112 return NULL;
113 vl_dri2_handle_stamps(scrn, wait_sbc_reply->ust_hi, wait_sbc_reply->ust_lo,
114 wait_sbc_reply->msc_hi, wait_sbc_reply->msc_lo);
115 free(wait_sbc_reply);
116
117 return xcb_dri2_get_buffers_reply(scrn->conn, scrn->buffers_cookie, NULL);
118 }
119
120 static void
vl_dri2_flush_frontbuffer(struct pipe_screen * screen,struct pipe_resource * resource,unsigned level,unsigned layer,void * context_private,struct pipe_box * sub_box)121 vl_dri2_flush_frontbuffer(struct pipe_screen *screen,
122 struct pipe_resource *resource,
123 unsigned level, unsigned layer,
124 void *context_private, struct pipe_box *sub_box)
125 {
126 struct vl_dri_screen *scrn = (struct vl_dri_screen *)context_private;
127 uint32_t msc_hi, msc_lo;
128
129 assert(screen);
130 assert(resource);
131 assert(context_private);
132
133 free(vl_dri2_get_flush_reply(scrn));
134
135 msc_hi = scrn->next_msc >> 32;
136 msc_lo = scrn->next_msc & 0xFFFFFFFF;
137
138 scrn->swap_cookie = xcb_dri2_swap_buffers_unchecked(scrn->conn, scrn->drawable,
139 msc_hi, msc_lo, 0, 0, 0, 0);
140 scrn->wait_cookie = xcb_dri2_wait_sbc_unchecked(scrn->conn, scrn->drawable, 0, 0);
141 scrn->buffers_cookie = xcb_dri2_get_buffers_unchecked(scrn->conn, scrn->drawable,
142 1, 1, attachments);
143
144 scrn->flushed = true;
145 scrn->current_buffer = !scrn->current_buffer;
146 }
147
148 static void
vl_dri2_destroy_drawable(struct vl_dri_screen * scrn)149 vl_dri2_destroy_drawable(struct vl_dri_screen *scrn)
150 {
151 xcb_void_cookie_t destroy_cookie;
152 if (scrn->drawable) {
153 free(vl_dri2_get_flush_reply(scrn));
154 destroy_cookie = xcb_dri2_destroy_drawable_checked(scrn->conn, scrn->drawable);
155 /* ignore any error here, since the drawable can be destroyed long ago */
156 free(xcb_request_check(scrn->conn, destroy_cookie));
157 }
158 }
159
160 static void
vl_dri2_set_drawable(struct vl_dri_screen * scrn,Drawable drawable)161 vl_dri2_set_drawable(struct vl_dri_screen *scrn, Drawable drawable)
162 {
163 assert(scrn);
164 assert(drawable);
165
166 if (scrn->drawable == drawable)
167 return;
168
169 vl_dri2_destroy_drawable(scrn);
170
171 xcb_dri2_create_drawable(scrn->conn, drawable);
172 scrn->current_buffer = false;
173 vl_compositor_reset_dirty_area(&scrn->dirty_areas[0]);
174 vl_compositor_reset_dirty_area(&scrn->dirty_areas[1]);
175 scrn->drawable = drawable;
176 }
177
178 static struct pipe_resource *
vl_dri2_screen_texture_from_drawable(struct vl_screen * vscreen,void * drawable)179 vl_dri2_screen_texture_from_drawable(struct vl_screen *vscreen, void *drawable)
180 {
181 struct vl_dri_screen *scrn = (struct vl_dri_screen *)vscreen;
182
183 struct winsys_handle dri2_handle;
184 struct pipe_resource template, *tex;
185
186 xcb_dri2_get_buffers_reply_t *reply;
187 xcb_dri2_dri2_buffer_t *buffers, *back_left;
188
189 unsigned i;
190
191 assert(scrn);
192
193 vl_dri2_set_drawable(scrn, (Drawable)drawable);
194 reply = vl_dri2_get_flush_reply(scrn);
195 if (!reply) {
196 xcb_dri2_get_buffers_cookie_t cookie;
197 cookie = xcb_dri2_get_buffers_unchecked(scrn->conn, (Drawable)drawable,
198 1, 1, attachments);
199 reply = xcb_dri2_get_buffers_reply(scrn->conn, cookie, NULL);
200 }
201 if (!reply)
202 return NULL;
203
204 buffers = xcb_dri2_get_buffers_buffers(reply);
205 if (!buffers) {
206 free(reply);
207 return NULL;
208 }
209
210 for (i = 0; i < reply->count; ++i) {
211 if (buffers[i].attachment == XCB_DRI2_ATTACHMENT_BUFFER_BACK_LEFT) {
212 back_left = &buffers[i];
213 break;
214 }
215 }
216
217 if (i == reply->count) {
218 free(reply);
219 return NULL;
220 }
221
222 if (reply->width != scrn->width || reply->height != scrn->height) {
223 vl_compositor_reset_dirty_area(&scrn->dirty_areas[0]);
224 vl_compositor_reset_dirty_area(&scrn->dirty_areas[1]);
225 scrn->width = reply->width;
226 scrn->height = reply->height;
227
228 } else if (back_left->name != scrn->buffer_names[scrn->current_buffer]) {
229 vl_compositor_reset_dirty_area(&scrn->dirty_areas[scrn->current_buffer]);
230 scrn->buffer_names[scrn->current_buffer] = back_left->name;
231 }
232
233 memset(&dri2_handle, 0, sizeof(dri2_handle));
234 dri2_handle.type = DRM_API_HANDLE_TYPE_SHARED;
235 dri2_handle.handle = back_left->name;
236 dri2_handle.stride = back_left->pitch;
237
238 memset(&template, 0, sizeof(template));
239 template.target = PIPE_TEXTURE_2D;
240 template.format = PIPE_FORMAT_B8G8R8X8_UNORM;
241 template.last_level = 0;
242 template.width0 = reply->width;
243 template.height0 = reply->height;
244 template.depth0 = 1;
245 template.array_size = 1;
246 template.usage = PIPE_USAGE_DEFAULT;
247 template.bind = PIPE_BIND_RENDER_TARGET;
248 template.flags = 0;
249
250 tex = scrn->base.pscreen->resource_from_handle(scrn->base.pscreen, &template,
251 &dri2_handle,
252 PIPE_HANDLE_USAGE_READ_WRITE);
253 free(reply);
254
255 return tex;
256 }
257
258 static struct u_rect *
vl_dri2_screen_get_dirty_area(struct vl_screen * vscreen)259 vl_dri2_screen_get_dirty_area(struct vl_screen *vscreen)
260 {
261 struct vl_dri_screen *scrn = (struct vl_dri_screen *)vscreen;
262 assert(scrn);
263 return &scrn->dirty_areas[scrn->current_buffer];
264 }
265
266 static uint64_t
vl_dri2_screen_get_timestamp(struct vl_screen * vscreen,void * drawable)267 vl_dri2_screen_get_timestamp(struct vl_screen *vscreen, void *drawable)
268 {
269 struct vl_dri_screen *scrn = (struct vl_dri_screen *)vscreen;
270 xcb_dri2_get_msc_cookie_t cookie;
271 xcb_dri2_get_msc_reply_t *reply;
272
273 assert(scrn);
274
275 vl_dri2_set_drawable(scrn, (Drawable)drawable);
276 if (!scrn->last_ust) {
277 cookie = xcb_dri2_get_msc_unchecked(scrn->conn, (Drawable)drawable);
278 reply = xcb_dri2_get_msc_reply(scrn->conn, cookie, NULL);
279
280 if (reply) {
281 vl_dri2_handle_stamps(scrn, reply->ust_hi, reply->ust_lo,
282 reply->msc_hi, reply->msc_lo);
283 free(reply);
284 }
285 }
286 return scrn->last_ust;
287 }
288
289 static void
vl_dri2_screen_set_next_timestamp(struct vl_screen * vscreen,uint64_t stamp)290 vl_dri2_screen_set_next_timestamp(struct vl_screen *vscreen, uint64_t stamp)
291 {
292 struct vl_dri_screen *scrn = (struct vl_dri_screen *)vscreen;
293 assert(scrn);
294 if (stamp && scrn->last_ust && scrn->ns_frame && scrn->last_msc)
295 scrn->next_msc = ((int64_t)stamp - scrn->last_ust + scrn->ns_frame/2) /
296 scrn->ns_frame + scrn->last_msc;
297 else
298 scrn->next_msc = 0;
299 }
300
301 static void *
vl_dri2_screen_get_private(struct vl_screen * vscreen)302 vl_dri2_screen_get_private(struct vl_screen *vscreen)
303 {
304 return vscreen;
305 }
306
307 static xcb_screen_t *
get_xcb_screen(xcb_screen_iterator_t iter,int screen)308 get_xcb_screen(xcb_screen_iterator_t iter, int screen)
309 {
310 for (; iter.rem; --screen, xcb_screen_next(&iter))
311 if (screen == 0)
312 return iter.data;
313
314 return NULL;
315 }
316
317 struct vl_screen *
vl_dri2_screen_create(Display * display,int screen)318 vl_dri2_screen_create(Display *display, int screen)
319 {
320 struct vl_dri_screen *scrn;
321 const xcb_query_extension_reply_t *extension;
322 xcb_dri2_query_version_cookie_t dri2_query_cookie;
323 xcb_dri2_query_version_reply_t *dri2_query = NULL;
324 xcb_dri2_connect_cookie_t connect_cookie;
325 xcb_dri2_connect_reply_t *connect = NULL;
326 xcb_dri2_authenticate_cookie_t authenticate_cookie;
327 xcb_dri2_authenticate_reply_t *authenticate = NULL;
328 xcb_screen_iterator_t s;
329 xcb_screen_t *xcb_screen;
330 xcb_generic_error_t *error = NULL;
331 char *device_name;
332 int fd, device_name_length;
333 unsigned driverType;
334
335 drm_magic_t magic;
336
337 assert(display);
338
339 scrn = CALLOC_STRUCT(vl_dri_screen);
340 if (!scrn)
341 return NULL;
342
343 scrn->conn = XGetXCBConnection(display);
344 if (!scrn->conn)
345 goto free_screen;
346
347 xcb_prefetch_extension_data(scrn->conn, &xcb_dri2_id);
348
349 extension = xcb_get_extension_data(scrn->conn, &xcb_dri2_id);
350 if (!(extension && extension->present))
351 goto free_screen;
352
353 dri2_query_cookie = xcb_dri2_query_version (scrn->conn,
354 XCB_DRI2_MAJOR_VERSION,
355 XCB_DRI2_MINOR_VERSION);
356 dri2_query = xcb_dri2_query_version_reply (scrn->conn, dri2_query_cookie, &error);
357 if (dri2_query == NULL || error != NULL || dri2_query->minor_version < 2)
358 goto free_query;
359
360 s = xcb_setup_roots_iterator(xcb_get_setup(scrn->conn));
361 xcb_screen = get_xcb_screen(s, screen);
362 if (!xcb_screen)
363 goto free_query;
364
365 driverType = XCB_DRI2_DRIVER_TYPE_DRI;
366 #ifdef DRI2DriverPrimeShift
367 {
368 char *prime = getenv("DRI_PRIME");
369 if (prime) {
370 unsigned primeid;
371 errno = 0;
372 primeid = strtoul(prime, NULL, 0);
373 if (errno == 0)
374 driverType |=
375 ((primeid & DRI2DriverPrimeMask) << DRI2DriverPrimeShift);
376 }
377 }
378 #endif
379
380 connect_cookie = xcb_dri2_connect_unchecked(scrn->conn,
381 xcb_screen->root,
382 driverType);
383 connect = xcb_dri2_connect_reply(scrn->conn, connect_cookie, NULL);
384 if (connect == NULL ||
385 connect->driver_name_length + connect->device_name_length == 0)
386 goto free_connect;
387
388 device_name_length = xcb_dri2_connect_device_name_length(connect);
389 device_name = CALLOC(1, device_name_length + 1);
390 if (!device_name)
391 goto free_connect;
392 memcpy(device_name, xcb_dri2_connect_device_name(connect), device_name_length);
393 fd = loader_open_device(device_name);
394 free(device_name);
395
396 if (fd < 0)
397 goto free_connect;
398
399 if (drmGetMagic(fd, &magic))
400 goto close_fd;
401
402 authenticate_cookie = xcb_dri2_authenticate_unchecked(scrn->conn,
403 xcb_screen->root,
404 magic);
405 authenticate = xcb_dri2_authenticate_reply(scrn->conn, authenticate_cookie, NULL);
406
407 if (authenticate == NULL || !authenticate->authenticated)
408 goto free_authenticate;
409
410 if (pipe_loader_drm_probe_fd(&scrn->base.dev, fd))
411 scrn->base.pscreen = pipe_loader_create_screen(scrn->base.dev);
412
413 if (!scrn->base.pscreen)
414 goto release_pipe;
415
416 scrn->base.destroy = vl_dri2_screen_destroy;
417 scrn->base.texture_from_drawable = vl_dri2_screen_texture_from_drawable;
418 scrn->base.get_dirty_area = vl_dri2_screen_get_dirty_area;
419 scrn->base.get_timestamp = vl_dri2_screen_get_timestamp;
420 scrn->base.set_next_timestamp = vl_dri2_screen_set_next_timestamp;
421 scrn->base.get_private = vl_dri2_screen_get_private;
422 scrn->base.pscreen->flush_frontbuffer = vl_dri2_flush_frontbuffer;
423 vl_compositor_reset_dirty_area(&scrn->dirty_areas[0]);
424 vl_compositor_reset_dirty_area(&scrn->dirty_areas[1]);
425
426 free(authenticate);
427 free(connect);
428 free(dri2_query);
429 free(error);
430
431 return &scrn->base;
432
433 release_pipe:
434 if (scrn->base.dev) {
435 pipe_loader_release(&scrn->base.dev, 1);
436 fd = -1;
437 }
438 free_authenticate:
439 free(authenticate);
440 close_fd:
441 if (fd != -1)
442 close(fd);
443 free_connect:
444 free(connect);
445 free_query:
446 free(dri2_query);
447 free(error);
448
449 free_screen:
450 FREE(scrn);
451 return NULL;
452 }
453
454 static void
vl_dri2_screen_destroy(struct vl_screen * vscreen)455 vl_dri2_screen_destroy(struct vl_screen *vscreen)
456 {
457 struct vl_dri_screen *scrn = (struct vl_dri_screen *)vscreen;
458
459 assert(vscreen);
460
461 if (scrn->flushed) {
462 free(xcb_dri2_swap_buffers_reply(scrn->conn, scrn->swap_cookie, NULL));
463 free(xcb_dri2_wait_sbc_reply(scrn->conn, scrn->wait_cookie, NULL));
464 free(xcb_dri2_get_buffers_reply(scrn->conn, scrn->buffers_cookie, NULL));
465 }
466
467 vl_dri2_destroy_drawable(scrn);
468 scrn->base.pscreen->destroy(scrn->base.pscreen);
469 pipe_loader_release(&scrn->base.dev, 1);
470 FREE(scrn);
471 }
472