1 /************************************************************************** 2 * 3 * Copyright 2003 Tungsten Graphics, Inc., Cedar Park, Texas. 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 TUNGSTEN GRAPHICS 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 #include <errno.h> 29 #include <time.h> 30 #include "main/glheader.h" 31 #include "main/context.h" 32 #include "main/framebuffer.h" 33 #include "main/renderbuffer.h" 34 #include "main/hash.h" 35 #include "main/fbobject.h" 36 #include "main/mfeatures.h" 37 #include "main/version.h" 38 #include "swrast/s_renderbuffer.h" 39 40 #include "utils.h" 41 #include "xmlpool.h" 42 43 PUBLIC const char __driConfigOptions[] = 44 DRI_CONF_BEGIN 45 DRI_CONF_SECTION_PERFORMANCE 46 DRI_CONF_VBLANK_MODE(DRI_CONF_VBLANK_ALWAYS_SYNC) 47 /* Options correspond to DRI_CONF_BO_REUSE_DISABLED, 48 * DRI_CONF_BO_REUSE_ALL 49 */ 50 DRI_CONF_OPT_BEGIN_V(bo_reuse, enum, 1, "0:1") 51 DRI_CONF_DESC_BEGIN(en, "Buffer object reuse") 52 DRI_CONF_ENUM(0, "Disable buffer object reuse") 53 DRI_CONF_ENUM(1, "Enable reuse of all sizes of buffer objects") 54 DRI_CONF_DESC_END 55 DRI_CONF_OPT_END 56 57 DRI_CONF_OPT_BEGIN(texture_tiling, bool, true) 58 DRI_CONF_DESC(en, "Enable texture tiling") 59 DRI_CONF_OPT_END 60 61 DRI_CONF_OPT_BEGIN(hiz, bool, true) 62 DRI_CONF_DESC(en, "Enable Hierarchical Z on gen6+") 63 DRI_CONF_OPT_END 64 65 DRI_CONF_OPT_BEGIN(early_z, bool, false) 66 DRI_CONF_DESC(en, "Enable early Z in classic mode (unstable, 945-only).") 67 DRI_CONF_OPT_END 68 69 DRI_CONF_OPT_BEGIN(fragment_shader, bool, true) 70 DRI_CONF_DESC(en, "Enable limited ARB_fragment_shader support on 915/945.") 71 DRI_CONF_OPT_END 72 73 DRI_CONF_SECTION_END 74 DRI_CONF_SECTION_QUALITY 75 DRI_CONF_FORCE_S3TC_ENABLE(false) 76 DRI_CONF_ALLOW_LARGE_TEXTURES(2) 77 DRI_CONF_SECTION_END 78 DRI_CONF_SECTION_DEBUG 79 DRI_CONF_NO_RAST(false) 80 DRI_CONF_ALWAYS_FLUSH_BATCH(false) 81 DRI_CONF_ALWAYS_FLUSH_CACHE(false) 82 DRI_CONF_FORCE_GLSL_EXTENSIONS_WARN(false) 83 DRI_CONF_DISABLE_BLEND_FUNC_EXTENDED(false) 84 85 DRI_CONF_OPT_BEGIN(stub_occlusion_query, bool, false) 86 DRI_CONF_DESC(en, "Enable stub ARB_occlusion_query support on 915/945.") 87 DRI_CONF_OPT_END 88 89 DRI_CONF_OPT_BEGIN(shader_precompile, bool, true) 90 DRI_CONF_DESC(en, "Perform code generation at shader link time.") 91 DRI_CONF_OPT_END 92 DRI_CONF_SECTION_END 93 DRI_CONF_END; 94 95 const GLuint __driNConfigOptions = 15; 96 97 #include "intel_batchbuffer.h" 98 #include "intel_buffers.h" 99 #include "intel_bufmgr.h" 100 #include "intel_chipset.h" 101 #include "intel_fbo.h" 102 #include "intel_mipmap_tree.h" 103 #include "intel_screen.h" 104 #include "intel_tex.h" 105 #include "intel_regions.h" 106 107 #include "i915_drm.h" 108 109 #ifdef USE_NEW_INTERFACE 110 static PFNGLXCREATECONTEXTMODES create_context_modes = NULL; 111 #endif /*USE_NEW_INTERFACE */ 112 113 /** 114 * For debugging purposes, this returns a time in seconds. 115 */ 116 double 117 get_time(void) 118 { 119 struct timespec tp; 120 121 clock_gettime(CLOCK_MONOTONIC, &tp); 122 123 return tp.tv_sec + tp.tv_nsec / 1000000000.0; 124 } 125 126 void 127 aub_dump_bmp(struct gl_context *ctx) 128 { 129 struct gl_framebuffer *fb = ctx->DrawBuffer; 130 131 for (int i = 0; i < fb->_NumColorDrawBuffers; i++) { 132 struct intel_renderbuffer *irb = 133 intel_renderbuffer(fb->_ColorDrawBuffers[i]); 134 135 if (irb && irb->mt) { 136 enum aub_dump_bmp_format format; 137 138 switch (irb->Base.Base.Format) { 139 case MESA_FORMAT_ARGB8888: 140 case MESA_FORMAT_XRGB8888: 141 format = AUB_DUMP_BMP_FORMAT_ARGB_8888; 142 break; 143 default: 144 continue; 145 } 146 147 drm_intel_gem_bo_aub_dump_bmp(irb->mt->region->bo, 148 irb->draw_x, 149 irb->draw_y, 150 irb->Base.Base.Width, 151 irb->Base.Base.Height, 152 format, 153 irb->mt->region->pitch * 154 irb->mt->region->cpp, 155 0); 156 } 157 } 158 } 159 160 static const __DRItexBufferExtension intelTexBufferExtension = { 161 { __DRI_TEX_BUFFER, __DRI_TEX_BUFFER_VERSION }, 162 intelSetTexBuffer, 163 intelSetTexBuffer2, 164 }; 165 166 static void 167 intelDRI2Flush(__DRIdrawable *drawable) 168 { 169 GET_CURRENT_CONTEXT(ctx); 170 struct intel_context *intel = intel_context(ctx); 171 if (intel == NULL) 172 return; 173 174 if (intel->gen < 4) 175 INTEL_FIREVERTICES(intel); 176 177 intel_downsample_for_dri2_flush(intel, drawable); 178 intel->need_throttle = true; 179 180 if (intel->batch.used) 181 intel_batchbuffer_flush(intel); 182 183 if (INTEL_DEBUG & DEBUG_AUB) { 184 aub_dump_bmp(ctx); 185 } 186 } 187 188 static const struct __DRI2flushExtensionRec intelFlushExtension = { 189 { __DRI2_FLUSH, __DRI2_FLUSH_VERSION }, 190 intelDRI2Flush, 191 dri2InvalidateDrawable, 192 }; 193 194 struct intel_image_format intel_image_formats[] = { 195 { __DRI_IMAGE_FOURCC_ARGB8888, __DRI_IMAGE_COMPONENTS_RGBA, 1, 196 { { 0, 0, 0, __DRI_IMAGE_FORMAT_ARGB8888, 4 } } }, 197 198 { __DRI_IMAGE_FOURCC_XRGB8888, __DRI_IMAGE_COMPONENTS_RGB, 1, 199 { { 0, 0, 0, __DRI_IMAGE_FORMAT_XRGB8888, 4 }, } }, 200 201 { __DRI_IMAGE_FOURCC_YUV410, __DRI_IMAGE_COMPONENTS_Y_U_V, 3, 202 { { 0, 0, 0, __DRI_IMAGE_FORMAT_R8, 1 }, 203 { 1, 2, 2, __DRI_IMAGE_FORMAT_R8, 1 }, 204 { 2, 2, 2, __DRI_IMAGE_FORMAT_R8, 1 } } }, 205 206 { __DRI_IMAGE_FOURCC_YUV411, __DRI_IMAGE_COMPONENTS_Y_U_V, 3, 207 { { 0, 0, 0, __DRI_IMAGE_FORMAT_R8, 1 }, 208 { 1, 2, 0, __DRI_IMAGE_FORMAT_R8, 1 }, 209 { 2, 2, 0, __DRI_IMAGE_FORMAT_R8, 1 } } }, 210 211 { __DRI_IMAGE_FOURCC_YUV420, __DRI_IMAGE_COMPONENTS_Y_U_V, 3, 212 { { 0, 0, 0, __DRI_IMAGE_FORMAT_R8, 1 }, 213 { 1, 1, 1, __DRI_IMAGE_FORMAT_R8, 1 }, 214 { 2, 1, 1, __DRI_IMAGE_FORMAT_R8, 1 } } }, 215 216 { __DRI_IMAGE_FOURCC_YUV422, __DRI_IMAGE_COMPONENTS_Y_U_V, 3, 217 { { 0, 0, 0, __DRI_IMAGE_FORMAT_R8, 1 }, 218 { 1, 1, 0, __DRI_IMAGE_FORMAT_R8, 1 }, 219 { 2, 1, 0, __DRI_IMAGE_FORMAT_R8, 1 } } }, 220 221 { __DRI_IMAGE_FOURCC_YUV444, __DRI_IMAGE_COMPONENTS_Y_U_V, 3, 222 { { 0, 0, 0, __DRI_IMAGE_FORMAT_R8, 1 }, 223 { 1, 0, 0, __DRI_IMAGE_FORMAT_R8, 1 }, 224 { 2, 0, 0, __DRI_IMAGE_FORMAT_R8, 1 } } }, 225 226 { __DRI_IMAGE_FOURCC_NV12, __DRI_IMAGE_COMPONENTS_Y_UV, 2, 227 { { 0, 0, 0, __DRI_IMAGE_FORMAT_R8, 1 }, 228 { 1, 1, 1, __DRI_IMAGE_FORMAT_GR88, 2 } } }, 229 230 { __DRI_IMAGE_FOURCC_NV16, __DRI_IMAGE_COMPONENTS_Y_UV, 2, 231 { { 0, 0, 0, __DRI_IMAGE_FORMAT_R8, 1 }, 232 { 1, 1, 0, __DRI_IMAGE_FORMAT_GR88, 2 } } }, 233 234 /* For YUYV buffers, we set up two overlapping DRI images and treat 235 * them as planar buffers in the compositors. Plane 0 is GR88 and 236 * samples YU or YV pairs and places Y into the R component, while 237 * plane 1 is ARGB and samples YUYV clusters and places pairs and 238 * places U into the G component and V into A. This lets the 239 * texture sampler interpolate the Y components correctly when 240 * sampling from plane 0, and interpolate U and V correctly when 241 * sampling from plane 1. */ 242 { __DRI_IMAGE_FOURCC_YUYV, __DRI_IMAGE_COMPONENTS_Y_XUXV, 2, 243 { { 0, 0, 0, __DRI_IMAGE_FORMAT_GR88, 2 }, 244 { 0, 1, 0, __DRI_IMAGE_FORMAT_ARGB8888, 4 } } } 245 }; 246 247 static __DRIimage * 248 intel_allocate_image(int dri_format, void *loaderPrivate) 249 { 250 __DRIimage *image; 251 252 image = CALLOC(sizeof *image); 253 if (image == NULL) 254 return NULL; 255 256 image->dri_format = dri_format; 257 image->offset = 0; 258 259 switch (dri_format) { 260 case __DRI_IMAGE_FORMAT_RGB565: 261 image->format = MESA_FORMAT_RGB565; 262 break; 263 case __DRI_IMAGE_FORMAT_XRGB8888: 264 image->format = MESA_FORMAT_XRGB8888; 265 break; 266 case __DRI_IMAGE_FORMAT_ARGB8888: 267 image->format = MESA_FORMAT_ARGB8888; 268 break; 269 case __DRI_IMAGE_FORMAT_ABGR8888: 270 image->format = MESA_FORMAT_RGBA8888_REV; 271 break; 272 case __DRI_IMAGE_FORMAT_XBGR8888: 273 image->format = MESA_FORMAT_RGBX8888_REV; 274 break; 275 case __DRI_IMAGE_FORMAT_R8: 276 image->format = MESA_FORMAT_R8; 277 break; 278 case __DRI_IMAGE_FORMAT_GR88: 279 image->format = MESA_FORMAT_GR88; 280 break; 281 case __DRI_IMAGE_FORMAT_NONE: 282 image->format = MESA_FORMAT_NONE; 283 break; 284 default: 285 free(image); 286 return NULL; 287 } 288 289 image->internal_format = _mesa_get_format_base_format(image->format); 290 image->data = loaderPrivate; 291 292 return image; 293 } 294 295 static __DRIimage * 296 intel_create_image_from_name(__DRIscreen *screen, 297 int width, int height, int format, 298 int name, int pitch, void *loaderPrivate) 299 { 300 struct intel_screen *intelScreen = screen->driverPrivate; 301 __DRIimage *image; 302 int cpp; 303 304 image = intel_allocate_image(format, loaderPrivate); 305 if (image->format == MESA_FORMAT_NONE) 306 cpp = 1; 307 else 308 cpp = _mesa_get_format_bytes(image->format); 309 image->region = intel_region_alloc_for_handle(intelScreen, 310 cpp, width, height, 311 pitch, name, "image"); 312 if (image->region == NULL) { 313 FREE(image); 314 return NULL; 315 } 316 317 return image; 318 } 319 320 static __DRIimage * 321 intel_create_image_from_renderbuffer(__DRIcontext *context, 322 int renderbuffer, void *loaderPrivate) 323 { 324 __DRIimage *image; 325 struct intel_context *intel = context->driverPrivate; 326 struct gl_renderbuffer *rb; 327 struct intel_renderbuffer *irb; 328 329 rb = _mesa_lookup_renderbuffer(&intel->ctx, renderbuffer); 330 if (!rb) { 331 _mesa_error(&intel->ctx, 332 GL_INVALID_OPERATION, "glRenderbufferExternalMESA"); 333 return NULL; 334 } 335 336 irb = intel_renderbuffer(rb); 337 image = CALLOC(sizeof *image); 338 if (image == NULL) 339 return NULL; 340 341 image->internal_format = rb->InternalFormat; 342 image->format = rb->Format; 343 image->offset = 0; 344 image->data = loaderPrivate; 345 intel_region_reference(&image->region, irb->mt->region); 346 347 switch (image->format) { 348 case MESA_FORMAT_RGB565: 349 image->dri_format = __DRI_IMAGE_FORMAT_RGB565; 350 break; 351 case MESA_FORMAT_XRGB8888: 352 image->dri_format = __DRI_IMAGE_FORMAT_XRGB8888; 353 break; 354 case MESA_FORMAT_ARGB8888: 355 image->dri_format = __DRI_IMAGE_FORMAT_ARGB8888; 356 break; 357 case MESA_FORMAT_RGBA8888_REV: 358 image->dri_format = __DRI_IMAGE_FORMAT_ABGR8888; 359 break; 360 case MESA_FORMAT_R8: 361 image->dri_format = __DRI_IMAGE_FORMAT_R8; 362 break; 363 case MESA_FORMAT_RG88: 364 image->dri_format = __DRI_IMAGE_FORMAT_GR88; 365 break; 366 } 367 368 return image; 369 } 370 371 static void 372 intel_destroy_image(__DRIimage *image) 373 { 374 intel_region_release(&image->region); 375 FREE(image); 376 } 377 378 static __DRIimage * 379 intel_create_image(__DRIscreen *screen, 380 int width, int height, int format, 381 unsigned int use, 382 void *loaderPrivate) 383 { 384 __DRIimage *image; 385 struct intel_screen *intelScreen = screen->driverPrivate; 386 uint32_t tiling; 387 int cpp; 388 389 tiling = I915_TILING_X; 390 if (use & __DRI_IMAGE_USE_CURSOR) { 391 if (width != 64 || height != 64) 392 return NULL; 393 tiling = I915_TILING_NONE; 394 } 395 396 image = intel_allocate_image(format, loaderPrivate); 397 cpp = _mesa_get_format_bytes(image->format); 398 image->region = 399 intel_region_alloc(intelScreen, tiling, cpp, width, height, true); 400 if (image->region == NULL) { 401 FREE(image); 402 return NULL; 403 } 404 405 return image; 406 } 407 408 static GLboolean 409 intel_query_image(__DRIimage *image, int attrib, int *value) 410 { 411 switch (attrib) { 412 case __DRI_IMAGE_ATTRIB_STRIDE: 413 *value = image->region->pitch * image->region->cpp; 414 return true; 415 case __DRI_IMAGE_ATTRIB_HANDLE: 416 *value = image->region->bo->handle; 417 return true; 418 case __DRI_IMAGE_ATTRIB_NAME: 419 return intel_region_flink(image->region, (uint32_t *) value); 420 case __DRI_IMAGE_ATTRIB_FORMAT: 421 *value = image->dri_format; 422 return true; 423 case __DRI_IMAGE_ATTRIB_WIDTH: 424 *value = image->region->width; 425 return true; 426 case __DRI_IMAGE_ATTRIB_HEIGHT: 427 *value = image->region->height; 428 return true; 429 case __DRI_IMAGE_ATTRIB_COMPONENTS: 430 if (image->planar_format == NULL) 431 return false; 432 *value = image->planar_format->components; 433 return true; 434 default: 435 return false; 436 } 437 } 438 439 static __DRIimage * 440 intel_dup_image(__DRIimage *orig_image, void *loaderPrivate) 441 { 442 __DRIimage *image; 443 444 image = CALLOC(sizeof *image); 445 if (image == NULL) 446 return NULL; 447 448 intel_region_reference(&image->region, orig_image->region); 449 if (image->region == NULL) { 450 FREE(image); 451 return NULL; 452 } 453 454 image->internal_format = orig_image->internal_format; 455 image->planar_format = orig_image->planar_format; 456 image->dri_format = orig_image->dri_format; 457 image->format = orig_image->format; 458 image->offset = orig_image->offset; 459 image->data = loaderPrivate; 460 461 memcpy(image->strides, orig_image->strides, sizeof(image->strides)); 462 memcpy(image->offsets, orig_image->offsets, sizeof(image->offsets)); 463 464 return image; 465 } 466 467 static GLboolean 468 intel_validate_usage(__DRIimage *image, unsigned int use) 469 { 470 if (use & __DRI_IMAGE_USE_CURSOR) { 471 if (image->region->width != 64 || image->region->height != 64) 472 return GL_FALSE; 473 } 474 475 return GL_TRUE; 476 } 477 478 static __DRIimage * 479 intel_create_image_from_names(__DRIscreen *screen, 480 int width, int height, int fourcc, 481 int *names, int num_names, 482 int *strides, int *offsets, 483 void *loaderPrivate) 484 { 485 struct intel_image_format *f = NULL; 486 __DRIimage *image; 487 int i, index; 488 489 if (screen == NULL || names == NULL || num_names != 1) 490 return NULL; 491 492 for (i = 0; i < ARRAY_SIZE(intel_image_formats); i++) { 493 if (intel_image_formats[i].fourcc == fourcc) { 494 f = &intel_image_formats[i]; 495 } 496 } 497 498 if (f == NULL) 499 return NULL; 500 501 image = intel_create_image_from_name(screen, width, height, 502 __DRI_IMAGE_FORMAT_NONE, 503 names[0], strides[0], 504 loaderPrivate); 505 506 if (image == NULL) 507 return NULL; 508 509 image->planar_format = f; 510 for (i = 0; i < f->nplanes; i++) { 511 index = f->planes[i].buffer_index; 512 image->offsets[index] = offsets[index]; 513 image->strides[index] = strides[index]; 514 } 515 516 return image; 517 } 518 519 static __DRIimage * 520 intel_from_planar(__DRIimage *parent, int plane, void *loaderPrivate) 521 { 522 int width, height, offset, stride, dri_format, cpp, index, pitch; 523 struct intel_image_format *f; 524 uint32_t mask_x, mask_y; 525 __DRIimage *image; 526 527 if (parent == NULL || parent->planar_format == NULL) 528 return NULL; 529 530 f = parent->planar_format; 531 532 if (plane >= f->nplanes) 533 return NULL; 534 535 width = parent->region->width >> f->planes[plane].width_shift; 536 height = parent->region->height >> f->planes[plane].height_shift; 537 dri_format = f->planes[plane].dri_format; 538 index = f->planes[plane].buffer_index; 539 offset = parent->offsets[index]; 540 stride = parent->strides[index]; 541 542 image = intel_allocate_image(dri_format, loaderPrivate); 543 cpp = _mesa_get_format_bytes(image->format); /* safe since no none format */ 544 pitch = stride / cpp; 545 if (offset + height * cpp * pitch > parent->region->bo->size) { 546 _mesa_warning(NULL, "intel_create_sub_image: subimage out of bounds"); 547 FREE(image); 548 return NULL; 549 } 550 551 image->region = calloc(sizeof(*image->region), 1); 552 if (image->region == NULL) { 553 FREE(image); 554 return NULL; 555 } 556 557 image->region->cpp = _mesa_get_format_bytes(image->format); 558 image->region->width = width; 559 image->region->height = height; 560 image->region->pitch = pitch; 561 image->region->refcount = 1; 562 image->region->bo = parent->region->bo; 563 drm_intel_bo_reference(image->region->bo); 564 image->region->tiling = parent->region->tiling; 565 image->region->screen = parent->region->screen; 566 image->offset = offset; 567 568 intel_region_get_tile_masks(image->region, &mask_x, &mask_y, false); 569 if (offset & mask_x) 570 _mesa_warning(NULL, 571 "intel_create_sub_image: offset not on tile boundary"); 572 573 return image; 574 } 575 576 static struct __DRIimageExtensionRec intelImageExtension = { 577 { __DRI_IMAGE, 5 }, 578 intel_create_image_from_name, 579 intel_create_image_from_renderbuffer, 580 intel_destroy_image, 581 intel_create_image, 582 intel_query_image, 583 intel_dup_image, 584 intel_validate_usage, 585 intel_create_image_from_names, 586 intel_from_planar 587 }; 588 589 static const __DRIextension *intelScreenExtensions[] = { 590 &intelTexBufferExtension.base, 591 &intelFlushExtension.base, 592 &intelImageExtension.base, 593 &dri2ConfigQueryExtension.base, 594 NULL 595 }; 596 597 static bool 598 intel_get_param(__DRIscreen *psp, int param, int *value) 599 { 600 int ret; 601 struct drm_i915_getparam gp; 602 603 memset(&gp, 0, sizeof(gp)); 604 gp.param = param; 605 gp.value = value; 606 607 ret = drmCommandWriteRead(psp->fd, DRM_I915_GETPARAM, &gp, sizeof(gp)); 608 if (ret) { 609 if (ret != -EINVAL) 610 _mesa_warning(NULL, "drm_i915_getparam: %d", ret); 611 return false; 612 } 613 614 return true; 615 } 616 617 static bool 618 intel_get_boolean(__DRIscreen *psp, int param) 619 { 620 int value = 0; 621 return intel_get_param(psp, param, &value) && value; 622 } 623 624 static void 625 nop_callback(GLuint key, void *data, void *userData) 626 { 627 } 628 629 static void 630 intelDestroyScreen(__DRIscreen * sPriv) 631 { 632 struct intel_screen *intelScreen = sPriv->driverPrivate; 633 634 dri_bufmgr_destroy(intelScreen->bufmgr); 635 driDestroyOptionInfo(&intelScreen->optionCache); 636 637 /* Some regions may still have references to them at this point, so 638 * flush the hash table to prevent _mesa_DeleteHashTable() from 639 * complaining about the hash not being empty; */ 640 _mesa_HashDeleteAll(intelScreen->named_regions, nop_callback, NULL); 641 _mesa_DeleteHashTable(intelScreen->named_regions); 642 643 FREE(intelScreen); 644 sPriv->driverPrivate = NULL; 645 } 646 647 648 /** 649 * This is called when we need to set up GL rendering to a new X window. 650 */ 651 static GLboolean 652 intelCreateBuffer(__DRIscreen * driScrnPriv, 653 __DRIdrawable * driDrawPriv, 654 const struct gl_config * mesaVis, GLboolean isPixmap) 655 { 656 struct intel_renderbuffer *rb; 657 struct intel_screen *screen = (struct intel_screen*) driScrnPriv->driverPrivate; 658 gl_format rgbFormat; 659 unsigned num_samples = intel_quantize_num_samples(screen, mesaVis->samples); 660 struct gl_framebuffer *fb; 661 662 if (isPixmap) 663 return false; 664 665 fb = CALLOC_STRUCT(gl_framebuffer); 666 if (!fb) 667 return false; 668 669 _mesa_initialize_window_framebuffer(fb, mesaVis); 670 671 if (mesaVis->redBits == 5) 672 rgbFormat = MESA_FORMAT_RGB565; 673 else if (mesaVis->alphaBits == 0) 674 rgbFormat = MESA_FORMAT_XRGB8888; 675 else 676 rgbFormat = MESA_FORMAT_ARGB8888; 677 678 /* setup the hardware-based renderbuffers */ 679 rb = intel_create_renderbuffer(rgbFormat, num_samples); 680 _mesa_add_renderbuffer(fb, BUFFER_FRONT_LEFT, &rb->Base.Base); 681 682 if (mesaVis->doubleBufferMode) { 683 rb = intel_create_renderbuffer(rgbFormat, num_samples); 684 _mesa_add_renderbuffer(fb, BUFFER_BACK_LEFT, &rb->Base.Base); 685 } 686 687 /* 688 * Assert here that the gl_config has an expected depth/stencil bit 689 * combination: one of d24/s8, d16/s0, d0/s0. (See intelInitScreen2(), 690 * which constructs the advertised configs.) 691 */ 692 if (mesaVis->depthBits == 24) { 693 assert(mesaVis->stencilBits == 8); 694 695 if (screen->hw_has_separate_stencil) { 696 rb = intel_create_private_renderbuffer(MESA_FORMAT_X8_Z24, 697 num_samples); 698 _mesa_add_renderbuffer(fb, BUFFER_DEPTH, &rb->Base.Base); 699 rb = intel_create_private_renderbuffer(MESA_FORMAT_S8, 700 num_samples); 701 _mesa_add_renderbuffer(fb, BUFFER_STENCIL, &rb->Base.Base); 702 } else { 703 /* 704 * Use combined depth/stencil. Note that the renderbuffer is 705 * attached to two attachment points. 706 */ 707 rb = intel_create_private_renderbuffer(MESA_FORMAT_S8_Z24, 708 num_samples); 709 _mesa_add_renderbuffer(fb, BUFFER_DEPTH, &rb->Base.Base); 710 _mesa_add_renderbuffer(fb, BUFFER_STENCIL, &rb->Base.Base); 711 } 712 } 713 else if (mesaVis->depthBits == 16) { 714 assert(mesaVis->stencilBits == 0); 715 rb = intel_create_private_renderbuffer(MESA_FORMAT_Z16, 716 num_samples); 717 _mesa_add_renderbuffer(fb, BUFFER_DEPTH, &rb->Base.Base); 718 } 719 else { 720 assert(mesaVis->depthBits == 0); 721 assert(mesaVis->stencilBits == 0); 722 } 723 724 /* now add any/all software-based renderbuffers we may need */ 725 _swrast_add_soft_renderbuffers(fb, 726 false, /* never sw color */ 727 false, /* never sw depth */ 728 false, /* never sw stencil */ 729 mesaVis->accumRedBits > 0, 730 false, /* never sw alpha */ 731 false /* never sw aux */ ); 732 driDrawPriv->driverPrivate = fb; 733 734 return true; 735 } 736 737 static void 738 intelDestroyBuffer(__DRIdrawable * driDrawPriv) 739 { 740 struct gl_framebuffer *fb = driDrawPriv->driverPrivate; 741 742 _mesa_reference_framebuffer(&fb, NULL); 743 } 744 745 /* There are probably better ways to do this, such as an 746 * init-designated function to register chipids and createcontext 747 * functions. 748 */ 749 extern bool 750 i830CreateContext(const struct gl_config *mesaVis, 751 __DRIcontext *driContextPriv, 752 void *sharedContextPrivate); 753 754 extern bool 755 i915CreateContext(int api, 756 const struct gl_config *mesaVis, 757 __DRIcontext *driContextPriv, 758 unsigned major_version, 759 unsigned minor_version, 760 unsigned *error, 761 void *sharedContextPrivate); 762 extern bool 763 brwCreateContext(int api, 764 const struct gl_config *mesaVis, 765 __DRIcontext *driContextPriv, 766 unsigned major_version, 767 unsigned minor_version, 768 uint32_t flags, 769 unsigned *error, 770 void *sharedContextPrivate); 771 772 static GLboolean 773 intelCreateContext(gl_api api, 774 const struct gl_config * mesaVis, 775 __DRIcontext * driContextPriv, 776 unsigned major_version, 777 unsigned minor_version, 778 uint32_t flags, 779 unsigned *error, 780 void *sharedContextPrivate) 781 { 782 __DRIscreen *sPriv = driContextPriv->driScreenPriv; 783 struct intel_screen *intelScreen = sPriv->driverPrivate; 784 bool success = false; 785 786 #ifdef I915 787 if (IS_9XX(intelScreen->deviceID)) { 788 success = i915CreateContext(api, mesaVis, driContextPriv, 789 major_version, minor_version, error, 790 sharedContextPrivate); 791 } else { 792 switch (api) { 793 case API_OPENGL: 794 if (major_version > 1 || minor_version > 3) { 795 *error = __DRI_CTX_ERROR_BAD_VERSION; 796 success = false; 797 } 798 break; 799 case API_OPENGLES: 800 break; 801 default: 802 *error = __DRI_CTX_ERROR_BAD_API; 803 success = false; 804 } 805 806 if (success) { 807 intelScreen->no_vbo = true; 808 success = i830CreateContext(mesaVis, driContextPriv, 809 sharedContextPrivate); 810 if (!success) 811 *error = __DRI_CTX_ERROR_NO_MEMORY; 812 } 813 } 814 #else 815 success = brwCreateContext(api, mesaVis, 816 driContextPriv, 817 major_version, minor_version, flags, 818 error, sharedContextPrivate); 819 #endif 820 821 if (success) 822 return true; 823 824 if (driContextPriv->driverPrivate != NULL) 825 intelDestroyContext(driContextPriv); 826 827 return false; 828 } 829 830 static bool 831 intel_init_bufmgr(struct intel_screen *intelScreen) 832 { 833 __DRIscreen *spriv = intelScreen->driScrnPriv; 834 int num_fences = 0; 835 836 intelScreen->no_hw = getenv("INTEL_NO_HW") != NULL; 837 838 intelScreen->bufmgr = intel_bufmgr_gem_init(spriv->fd, BATCH_SZ); 839 if (intelScreen->bufmgr == NULL) { 840 fprintf(stderr, "[%s:%u] Error initializing buffer manager.\n", 841 __func__, __LINE__); 842 return false; 843 } 844 845 if (!intel_get_param(spriv, I915_PARAM_NUM_FENCES_AVAIL, &num_fences) || 846 num_fences == 0) { 847 fprintf(stderr, "[%s: %u] Kernel 2.6.29 required.\n", __func__, __LINE__); 848 return false; 849 } 850 851 drm_intel_bufmgr_gem_enable_fenced_relocs(intelScreen->bufmgr); 852 853 intelScreen->named_regions = _mesa_NewHashTable(); 854 855 intelScreen->relaxed_relocations = 0; 856 intelScreen->relaxed_relocations |= 857 intel_get_boolean(spriv, I915_PARAM_HAS_RELAXED_DELTA) << 0; 858 859 return true; 860 } 861 862 /** 863 * Override intel_screen.hw_has_separate_stencil with environment variable 864 * INTEL_SEPARATE_STENCIL. 865 * 866 * Valid values for INTEL_SEPARATE_STENCIL are "0" and "1". If an invalid 867 * valid value is encountered, a warning is emitted and INTEL_SEPARATE_STENCIL 868 * is ignored. 869 */ 870 static void 871 intel_override_separate_stencil(struct intel_screen *screen) 872 { 873 const char *s = getenv("INTEL_SEPARATE_STENCIL"); 874 if (!s) { 875 return; 876 } else if (!strncmp("0", s, 2)) { 877 screen->hw_has_separate_stencil = false; 878 } else if (!strncmp("1", s, 2)) { 879 screen->hw_has_separate_stencil = true; 880 } else { 881 fprintf(stderr, 882 "warning: env variable INTEL_SEPARATE_STENCIL=\"%s\" has " 883 "invalid value and is ignored", s); 884 } 885 } 886 887 static bool 888 intel_detect_swizzling(struct intel_screen *screen) 889 { 890 drm_intel_bo *buffer; 891 unsigned long flags = 0; 892 unsigned long aligned_pitch; 893 uint32_t tiling = I915_TILING_X; 894 uint32_t swizzle_mode = 0; 895 896 buffer = drm_intel_bo_alloc_tiled(screen->bufmgr, "swizzle test", 897 64, 64, 4, 898 &tiling, &aligned_pitch, flags); 899 if (buffer == NULL) 900 return false; 901 902 drm_intel_bo_get_tiling(buffer, &tiling, &swizzle_mode); 903 drm_intel_bo_unreference(buffer); 904 905 if (swizzle_mode == I915_BIT_6_SWIZZLE_NONE) 906 return false; 907 else 908 return true; 909 } 910 911 static __DRIconfig** 912 intel_screen_make_configs(__DRIscreen *dri_screen) 913 { 914 static const GLenum back_buffer_modes[] = { 915 GLX_NONE, GLX_SWAP_UNDEFINED_OML, GLX_SWAP_COPY_OML 916 }; 917 918 static const uint8_t singlesample_samples[1] = {0}; 919 static const uint8_t multisample_samples[2] = {4, 8}; 920 921 struct intel_screen *screen = dri_screen->driverPrivate; 922 GLenum fb_format[3]; 923 GLenum fb_type[3]; 924 uint8_t depth_bits[4], stencil_bits[4]; 925 __DRIconfig **configs = NULL; 926 927 fb_format[0] = GL_RGB; 928 fb_type[0] = GL_UNSIGNED_SHORT_5_6_5; 929 930 fb_format[1] = GL_BGR; 931 fb_type[1] = GL_UNSIGNED_INT_8_8_8_8_REV; 932 933 fb_format[2] = GL_BGRA; 934 fb_type[2] = GL_UNSIGNED_INT_8_8_8_8_REV; 935 936 /* Generate singlesample configs without accumulation buffer. */ 937 for (int i = 0; i < ARRAY_SIZE(fb_format); i++) { 938 __DRIconfig **new_configs; 939 const int num_depth_stencil_bits = 2; 940 941 /* Starting with DRI2 protocol version 1.1 we can request a depth/stencil 942 * buffer that has a different number of bits per pixel than the color 943 * buffer. This isn't yet supported here. 944 */ 945 depth_bits[0] = 0; 946 stencil_bits[0] = 0; 947 948 if (fb_type[i] == GL_UNSIGNED_SHORT_5_6_5) { 949 depth_bits[1] = 16; 950 stencil_bits[1] = 0; 951 } else { 952 depth_bits[1] = 24; 953 stencil_bits[1] = 8; 954 } 955 956 new_configs = driCreateConfigs(fb_format[i], fb_type[i], 957 depth_bits, 958 stencil_bits, 959 num_depth_stencil_bits, 960 back_buffer_modes, 961 ARRAY_SIZE(back_buffer_modes), 962 singlesample_samples, 1, 963 false); 964 configs = driConcatConfigs(configs, new_configs); 965 } 966 967 /* Generate the minimum possible set of configs that include an 968 * accumulation buffer. 969 */ 970 for (int i = 0; i < ARRAY_SIZE(fb_format); i++) { 971 __DRIconfig **new_configs; 972 973 if (fb_type[i] == GL_UNSIGNED_SHORT_5_6_5) { 974 depth_bits[0] = 16; 975 stencil_bits[0] = 0; 976 } else { 977 depth_bits[0] = 24; 978 stencil_bits[0] = 8; 979 } 980 981 new_configs = driCreateConfigs(fb_format[i], fb_type[i], 982 depth_bits, stencil_bits, 1, 983 back_buffer_modes + 1, 1, 984 singlesample_samples, 1, 985 true); 986 configs = driConcatConfigs(configs, new_configs); 987 } 988 989 /* Generate multisample configs. 990 * 991 * This loop breaks early, and hence is a no-op, on gen < 6. 992 * 993 * Multisample configs must follow the singlesample configs in order to 994 * work around an X server bug present in 1.12. The X server chooses to 995 * associate the first listed RGBA888-Z24S8 config, regardless of its 996 * sample count, with the 32-bit depth visual used for compositing. 997 * 998 * Only doublebuffer configs with GLX_SWAP_UNDEFINED_OML behavior are 999 * supported. Singlebuffer configs are not supported because no one wants 1000 * them. GLX_SWAP_COPY_OML is not supported due to page flipping. 1001 */ 1002 for (int i = 0; i < ARRAY_SIZE(fb_format); i++) { 1003 if (screen->gen < 6) 1004 break; 1005 1006 __DRIconfig **new_configs; 1007 const int num_depth_stencil_bits = 2; 1008 int num_msaa_modes = 0; 1009 1010 depth_bits[0] = 0; 1011 stencil_bits[0] = 0; 1012 1013 if (fb_type[i] == GL_UNSIGNED_SHORT_5_6_5) { 1014 depth_bits[1] = 16; 1015 stencil_bits[1] = 0; 1016 } else { 1017 depth_bits[1] = 24; 1018 stencil_bits[1] = 8; 1019 } 1020 1021 if (screen->gen >= 7) 1022 num_msaa_modes = 2; 1023 else if (screen->gen == 6) 1024 num_msaa_modes = 1; 1025 1026 new_configs = driCreateConfigs(fb_format[i], fb_type[i], 1027 depth_bits, 1028 stencil_bits, 1029 num_depth_stencil_bits, 1030 back_buffer_modes + 1, 1, 1031 multisample_samples, 1032 num_msaa_modes, 1033 false); 1034 configs = driConcatConfigs(configs, new_configs); 1035 } 1036 1037 if (configs == NULL) { 1038 fprintf(stderr, "[%s:%u] Error creating FBConfig!\n", __func__, 1039 __LINE__); 1040 return NULL; 1041 } 1042 1043 return configs; 1044 } 1045 1046 /** 1047 * This is the driver specific part of the createNewScreen entry point. 1048 * Called when using DRI2. 1049 * 1050 * \return the struct gl_config supported by this driver 1051 */ 1052 static const 1053 __DRIconfig **intelInitScreen2(__DRIscreen *psp) 1054 { 1055 struct intel_screen *intelScreen; 1056 unsigned int api_mask; 1057 1058 if (psp->dri2.loader->base.version <= 2 || 1059 psp->dri2.loader->getBuffersWithFormat == NULL) { 1060 fprintf(stderr, 1061 "\nERROR! DRI2 loader with getBuffersWithFormat() " 1062 "support required\n"); 1063 return false; 1064 } 1065 1066 /* Allocate the private area */ 1067 intelScreen = CALLOC(sizeof *intelScreen); 1068 if (!intelScreen) { 1069 fprintf(stderr, "\nERROR! Allocating private area failed\n"); 1070 return false; 1071 } 1072 /* parse information in __driConfigOptions */ 1073 driParseOptionInfo(&intelScreen->optionCache, 1074 __driConfigOptions, __driNConfigOptions); 1075 1076 intelScreen->driScrnPriv = psp; 1077 psp->driverPrivate = (void *) intelScreen; 1078 1079 if (!intel_init_bufmgr(intelScreen)) 1080 return false; 1081 1082 intelScreen->deviceID = drm_intel_bufmgr_gem_get_devid(intelScreen->bufmgr); 1083 1084 intelScreen->kernel_has_gen7_sol_reset = 1085 intel_get_boolean(intelScreen->driScrnPriv, 1086 I915_PARAM_HAS_GEN7_SOL_RESET); 1087 1088 if (IS_GEN7(intelScreen->deviceID)) { 1089 intelScreen->gen = 7; 1090 } else if (IS_GEN6(intelScreen->deviceID)) { 1091 intelScreen->gen = 6; 1092 } else if (IS_GEN5(intelScreen->deviceID)) { 1093 intelScreen->gen = 5; 1094 } else if (IS_965(intelScreen->deviceID)) { 1095 intelScreen->gen = 4; 1096 } else if (IS_9XX(intelScreen->deviceID)) { 1097 intelScreen->gen = 3; 1098 } else { 1099 intelScreen->gen = 2; 1100 } 1101 1102 intelScreen->hw_has_separate_stencil = intelScreen->gen >= 6; 1103 intelScreen->hw_must_use_separate_stencil = intelScreen->gen >= 7; 1104 1105 int has_llc = 0; 1106 bool success = intel_get_param(intelScreen->driScrnPriv, I915_PARAM_HAS_LLC, 1107 &has_llc); 1108 if (success && has_llc) 1109 intelScreen->hw_has_llc = true; 1110 else if (!success && intelScreen->gen >= 6) 1111 intelScreen->hw_has_llc = true; 1112 1113 intel_override_separate_stencil(intelScreen); 1114 1115 api_mask = (1 << __DRI_API_OPENGL); 1116 #if FEATURE_ES1 1117 api_mask |= (1 << __DRI_API_GLES); 1118 #endif 1119 #if FEATURE_ES2 1120 api_mask |= (1 << __DRI_API_GLES2); 1121 #endif 1122 1123 if (IS_9XX(intelScreen->deviceID) || IS_965(intelScreen->deviceID)) 1124 psp->api_mask = api_mask; 1125 1126 intelScreen->hw_has_swizzling = intel_detect_swizzling(intelScreen); 1127 1128 psp->extensions = intelScreenExtensions; 1129 1130 return (const __DRIconfig**) intel_screen_make_configs(psp); 1131 } 1132 1133 struct intel_buffer { 1134 __DRIbuffer base; 1135 struct intel_region *region; 1136 }; 1137 1138 static __DRIbuffer * 1139 intelAllocateBuffer(__DRIscreen *screen, 1140 unsigned attachment, unsigned format, 1141 int width, int height) 1142 { 1143 struct intel_buffer *intelBuffer; 1144 struct intel_screen *intelScreen = screen->driverPrivate; 1145 1146 assert(attachment == __DRI_BUFFER_FRONT_LEFT || 1147 attachment == __DRI_BUFFER_BACK_LEFT); 1148 1149 intelBuffer = CALLOC(sizeof *intelBuffer); 1150 if (intelBuffer == NULL) 1151 return NULL; 1152 1153 /* The front and back buffers are color buffers, which are X tiled. */ 1154 intelBuffer->region = intel_region_alloc(intelScreen, 1155 I915_TILING_X, 1156 format / 8, 1157 width, 1158 height, 1159 true); 1160 1161 if (intelBuffer->region == NULL) { 1162 FREE(intelBuffer); 1163 return NULL; 1164 } 1165 1166 intel_region_flink(intelBuffer->region, &intelBuffer->base.name); 1167 1168 intelBuffer->base.attachment = attachment; 1169 intelBuffer->base.cpp = intelBuffer->region->cpp; 1170 intelBuffer->base.pitch = 1171 intelBuffer->region->pitch * intelBuffer->region->cpp; 1172 1173 return &intelBuffer->base; 1174 } 1175 1176 static void 1177 intelReleaseBuffer(__DRIscreen *screen, __DRIbuffer *buffer) 1178 { 1179 struct intel_buffer *intelBuffer = (struct intel_buffer *) buffer; 1180 1181 intel_region_release(&intelBuffer->region); 1182 free(intelBuffer); 1183 } 1184 1185 1186 const struct __DriverAPIRec driDriverAPI = { 1187 .InitScreen = intelInitScreen2, 1188 .DestroyScreen = intelDestroyScreen, 1189 .CreateContext = intelCreateContext, 1190 .DestroyContext = intelDestroyContext, 1191 .CreateBuffer = intelCreateBuffer, 1192 .DestroyBuffer = intelDestroyBuffer, 1193 .MakeCurrent = intelMakeCurrent, 1194 .UnbindContext = intelUnbindContext, 1195 .AllocateBuffer = intelAllocateBuffer, 1196 .ReleaseBuffer = intelReleaseBuffer 1197 }; 1198 1199 /* This is the table of extensions that the loader will dlsym() for. */ 1200 PUBLIC const __DRIextension *__driDriverExtensions[] = { 1201 &driCoreExtension.base, 1202 &driDRI2Extension.base, 1203 NULL 1204 }; 1205
