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 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 * 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 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 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 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 * 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 * 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 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 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 * 302 vl_dri2_screen_get_private(struct vl_screen *vscreen) 303 { 304 return vscreen; 305 } 306 307 static xcb_screen_t * 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 * 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 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
