src/mesa/drivers/dri/intel/intel_screen.c

   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
  42 PUBLIC 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
  92 DRI_CONF_END;
  93
  94 const 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
 109 static PFNGLXCREATECONTEXTMODES create_context_modes = NULL;
 110 #endif /*USE_NEW_INTERFACE */
 111
 112 /**
 113  * For debugging purposes, this returns a time in seconds.
 114  */
 115 double
 116 get_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
 125 void
 126 aub_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
 159 static const __DRItexBufferExtension intelTexBufferExtension = {
 160     { __DRI_TEX_BUFFER, __DRI_TEX_BUFFER_VERSION },
 161    intelSetTexBuffer,
 162    intelSetTexBuffer2,
 163 };
 164
 165 static void
 166 intelDRI2Flush(__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
 187 static const struct __DRI2flushExtensionRec intelFlushExtension = {
 188     { __DRI2_FLUSH, __DRI2_FLUSH_VERSION },
 189     intelDRI2Flush,
 190     dri2InvalidateDrawable,
 191 };
 192
 193 static __DRIimage *
 194 intel_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
 241 static __DRIimage *
 242 intel_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
 266 static __DRIimage *
 267 intel_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
 317 static void
 318 intel_destroy_image(__DRIimage *image)
 319 {
 320     intel_region_release(&image->region);
 321     FREE(image);
 322 }
 323
 324 static __DRIimage *
 325 intel_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
 354 static GLboolean
 355 intel_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
 380 static __DRIimage *
 381 intel_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
 404 static GLboolean
 405 intel_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
 415 static __DRIimage *
 416 intel_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
 457 static 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
 469 static const __DRIextension *intelScreenExtensions[] = {
 470     &intelTexBufferExtension.base,
 471     &intelFlushExtension.base,
 472     &intelImageExtension.base,
 473     &dri2ConfigQueryExtension.base,
 474     NULL
 475 };
 476
 477 static bool
 478 intel_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
 497 static bool
 498 intel_get_boolean(__DRIscreen *psp, int param)
 499 {
 500    int value = 0;
 501    return intel_get_param(psp, param, &value) && value;
 502 }
 503
 504 static void
 505 nop_callback(GLuint key, void *data, void *userData)
 506 {
 507 }
 508
 509 static void
 510 intelDestroyScreen(__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  */
 531 static GLboolean
 532 intelCreateBuffer(__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
 617 static void
 618 intelDestroyBuffer(__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  */
 629 extern bool
 630 i830CreateContext(const struct gl_config *mesaVis,
 631                   __DRIcontext *driContextPriv,
 632                   void *sharedContextPrivate);
 633
 634 extern bool
 635 i915CreateContext(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);
 642 extern bool
 643 brwCreateContext(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
 652 static GLboolean
 653 intelCreateContext(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
 737 static bool
 738 intel_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  */
 777 static void
 778 intel_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
 794 static bool
 795 intel_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
 818 static __DRIconfig**
 819 intel_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  */
 959 static 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
1040 struct intel_buffer {
1041    __DRIbuffer base;
1042    struct intel_region *region;
1043 };
1044
1045 static __DRIbuffer *
1046 intelAllocateBuffer(__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
1083 static void
1084 intelReleaseBuffer(__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
1093 const 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. */
1107 PUBLIC const __DRIextension *__driDriverExtensions[] = {
1108     &driCoreExtension.base,
1109     &driDRI2Extension.base,
1110     NULL
1111 };