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