src/mesa/drivers/dri/i965/brw_context.c

   1 /*
   2  Copyright 2003 VMware, Inc.
   3  Copyright (C) Intel Corp.  2006.  All Rights Reserved.
   4  Intel funded Tungsten Graphics to
   5  develop this 3D driver.
   6
   7  Permission is hereby granted, free of charge, to any person obtaining
   8  a copy of this software and associated documentation files (the
   9  "Software"), to deal in the Software without restriction, including
  10  without limitation the rights to use, copy, modify, merge, publish,
  11  distribute, sublicense, and/or sell copies of the Software, and to
  12  permit persons to whom the Software is furnished to do so, subject to
  13  the following conditions:
  14
  15  The above copyright notice and this permission notice (including the
  16  next paragraph) shall be included in all copies or substantial
  17  portions of the Software.
  18
  19  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  20  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  21  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  22  IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
  23  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  24  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  25  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  26
  27  **********************************************************************/
  28  /*
  29   * Authors:
  30   *   Keith Whitwell <keithw@vmware.com>
  31   */
  32
  33
  34 #include "main/api_exec.h"
  35 #include "main/context.h"
  36 #include "main/fbobject.h"
  37 #include "main/extensions.h"
  38 #include "main/imports.h"
  39 #include "main/macros.h"
  40 #include "main/points.h"
  41 #include "main/version.h"
  42 #include "main/vtxfmt.h"
  43 #include "main/texobj.h"
  44
  45 #include "vbo/vbo_context.h"
  46
  47 #include "drivers/common/driverfuncs.h"
  48 #include "drivers/common/meta.h"
  49 #include "utils.h"
  50
  51 #include "brw_context.h"
  52 #include "brw_defines.h"
  53 #include "brw_draw.h"
  54 #include "brw_state.h"
  55
  56 #include "intel_batchbuffer.h"
  57 #include "intel_buffer_objects.h"
  58 #include "intel_buffers.h"
  59 #include "intel_fbo.h"
  60 #include "intel_mipmap_tree.h"
  61 #include "intel_pixel.h"
  62 #include "intel_image.h"
  63 #include "intel_tex.h"
  64 #include "intel_tex_obj.h"
  65
  66 #include "swrast_setup/swrast_setup.h"
  67 #include "tnl/tnl.h"
  68 #include "tnl/t_pipeline.h"
  69 #include "util/ralloc.h"
  70
  71 /***************************************
  72  * Mesa's Driver Functions
  73  ***************************************/
  74
  75 static size_t
  76 brw_query_samples_for_format(struct gl_context *ctx, GLenum target,
  77                              GLenum internalFormat, int samples[16])
  78 {
  79    struct brw_context *brw = brw_context(ctx);
  80
  81    (void) target;
  82
  83    switch (brw->gen) {
  84    case 9:
  85    case 8:
  86       samples[0] = 8;
  87       samples[1] = 4;
  88       samples[2] = 2;
  89       return 3;
  90
  91    case 7:
  92       samples[0] = 8;
  93       samples[1] = 4;
  94       return 2;
  95
  96    case 6:
  97       samples[0] = 4;
  98       return 1;
  99
 100    default:
 101       assert(brw->gen < 6);
 102       samples[0] = 1;
 103       return 1;
 104    }
 105 }
 106
 107 const char *const brw_vendor_string = "Intel Open Source Technology Center";
 108
 109 const char *
 110 brw_get_renderer_string(unsigned deviceID)
 111 {
 112    const char *chipset;
 113    static char buffer[128];
 114
 115    switch (deviceID) {
 116 #undef CHIPSET
 117 #define CHIPSET(id, symbol, str) case id: chipset = str; break;
 118 #include "pci_ids/i965_pci_ids.h"
 119    default:
 120       chipset = "Unknown Intel Chipset";
 121       break;
 122    }
 123
 124    (void) driGetRendererString(buffer, chipset, 0);
 125    return buffer;
 126 }
 127
 128 static const GLubyte *
 129 intel_get_string(struct gl_context * ctx, GLenum name)
 130 {
 131    const struct brw_context *const brw = brw_context(ctx);
 132
 133    switch (name) {
 134    case GL_VENDOR:
 135       return (GLubyte *) brw_vendor_string;
 136
 137    case GL_RENDERER:
 138       return
 139          (GLubyte *) brw_get_renderer_string(brw->intelScreen->deviceID);
 140
 141    default:
 142       return NULL;
 143    }
 144 }
 145
 146 static void
 147 intel_viewport(struct gl_context *ctx)
 148 {
 149    struct brw_context *brw = brw_context(ctx);
 150    __DRIcontext *driContext = brw->driContext;
 151
 152    if (_mesa_is_winsys_fbo(ctx->DrawBuffer)) {
 153       dri2InvalidateDrawable(driContext->driDrawablePriv);
 154       dri2InvalidateDrawable(driContext->driReadablePriv);
 155    }
 156 }
 157
 158 static void
 159 intel_update_state(struct gl_context * ctx, GLuint new_state)
 160 {
 161    struct brw_context *brw = brw_context(ctx);
 162    struct intel_texture_object *tex_obj;
 163    struct intel_renderbuffer *depth_irb;
 164
 165    if (ctx->swrast_context)
 166       _swrast_InvalidateState(ctx, new_state);
 167    _vbo_InvalidateState(ctx, new_state);
 168
 169    brw->NewGLState |= new_state;
 170
 171    _mesa_unlock_context_textures(ctx);
 172
 173    /* Resolve the depth buffer's HiZ buffer. */
 174    depth_irb = intel_get_renderbuffer(ctx->DrawBuffer, BUFFER_DEPTH);
 175    if (depth_irb)
 176       intel_renderbuffer_resolve_hiz(brw, depth_irb);
 177
 178    /* Resolve depth buffer and render cache of each enabled texture. */
 179    int maxEnabledUnit = ctx->Texture._MaxEnabledTexImageUnit;
 180    for (int i = 0; i <= maxEnabledUnit; i++) {
 181       if (!ctx->Texture.Unit[i]._Current)
 182          continue;
 183       tex_obj = intel_texture_object(ctx->Texture.Unit[i]._Current);
 184       if (!tex_obj || !tex_obj->mt)
 185          continue;
 186       intel_miptree_all_slices_resolve_depth(brw, tex_obj->mt);
 187       intel_miptree_resolve_color(brw, tex_obj->mt);
 188       brw_render_cache_set_check_flush(brw, tex_obj->mt->bo);
 189    }
 190
 191    _mesa_lock_context_textures(ctx);
 192 }
 193
 194 #define flushFront(screen)      ((screen)->image.loader ? (screen)->image.loader->flushFrontBuffer : (screen)->dri2.loader->flushFrontBuffer)
 195
 196 static void
 197 intel_flush_front(struct gl_context *ctx)
 198 {
 199    struct brw_context *brw = brw_context(ctx);
 200    __DRIcontext *driContext = brw->driContext;
 201    __DRIdrawable *driDrawable = driContext->driDrawablePriv;
 202    __DRIscreen *const screen = brw->intelScreen->driScrnPriv;
 203
 204    if (brw->front_buffer_dirty && _mesa_is_winsys_fbo(ctx->DrawBuffer)) {
 205       if (flushFront(screen) && driDrawable &&
 206           driDrawable->loaderPrivate) {
 207
 208          /* Resolve before flushing FAKE_FRONT_LEFT to FRONT_LEFT.
 209           *
 210           * This potentially resolves both front and back buffer. It
 211           * is unnecessary to resolve the back, but harms nothing except
 212           * performance. And no one cares about front-buffer render
 213           * performance.
 214           */
 215          intel_resolve_for_dri2_flush(brw, driDrawable);
 216          intel_batchbuffer_flush(brw);
 217
 218          flushFront(screen)(driDrawable, driDrawable->loaderPrivate);
 219
 220          /* We set the dirty bit in intel_prepare_render() if we're
 221           * front buffer rendering once we get there.
 222           */
 223          brw->front_buffer_dirty = false;
 224       }
 225    }
 226 }
 227
 228 static void
 229 intel_glFlush(struct gl_context *ctx)
 230 {
 231    struct brw_context *brw = brw_context(ctx);
 232
 233    intel_batchbuffer_flush(brw);
 234    intel_flush_front(ctx);
 235    if (brw_is_front_buffer_drawing(ctx->DrawBuffer))
 236       brw->need_throttle = true;
 237 }
 238
 239 static void
 240 intel_finish(struct gl_context * ctx)
 241 {
 242    struct brw_context *brw = brw_context(ctx);
 243
 244    intel_glFlush(ctx);
 245
 246    if (brw->batch.last_bo)
 247       drm_intel_bo_wait_rendering(brw->batch.last_bo);
 248 }
 249
 250 static void
 251 brw_init_driver_functions(struct brw_context *brw,
 252                           struct dd_function_table *functions)
 253 {
 254    _mesa_init_driver_functions(functions);
 255
 256    /* GLX uses DRI2 invalidate events to handle window resizing.
 257     * Unfortunately, EGL does not - libEGL is written in XCB (not Xlib),
 258     * which doesn't provide a mechanism for snooping the event queues.
 259     *
 260     * So EGL still relies on viewport hacks to handle window resizing.
 261     * This should go away with DRI3000.
 262     */
 263    if (!brw->driContext->driScreenPriv->dri2.useInvalidate)
 264       functions->Viewport = intel_viewport;
 265
 266    functions->Flush = intel_glFlush;
 267    functions->Finish = intel_finish;
 268    functions->GetString = intel_get_string;
 269    functions->UpdateState = intel_update_state;
 270
 271    intelInitTextureFuncs(functions);
 272    intelInitTextureImageFuncs(functions);
 273    intelInitTextureSubImageFuncs(functions);
 274    intelInitTextureCopyImageFuncs(functions);
 275    intelInitCopyImageFuncs(functions);
 276    intelInitClearFuncs(functions);
 277    intelInitBufferFuncs(functions);
 278    intelInitPixelFuncs(functions);
 279    intelInitBufferObjectFuncs(functions);
 280    intel_init_syncobj_functions(functions);
 281    brw_init_object_purgeable_functions(functions);
 282
 283    brwInitFragProgFuncs( functions );
 284    brw_init_common_queryobj_functions(functions);
 285    if (brw->gen >= 6)
 286       gen6_init_queryobj_functions(functions);
 287    else
 288       gen4_init_queryobj_functions(functions);
 289
 290    functions->QuerySamplesForFormat = brw_query_samples_for_format;
 291
 292    functions->NewTransformFeedback = brw_new_transform_feedback;
 293    functions->DeleteTransformFeedback = brw_delete_transform_feedback;
 294    functions->GetTransformFeedbackVertexCount =
 295       brw_get_transform_feedback_vertex_count;
 296    if (brw->gen >= 7) {
 297       functions->BeginTransformFeedback = gen7_begin_transform_feedback;
 298       functions->EndTransformFeedback = gen7_end_transform_feedback;
 299       functions->PauseTransformFeedback = gen7_pause_transform_feedback;
 300       functions->ResumeTransformFeedback = gen7_resume_transform_feedback;
 301    } else {
 302       functions->BeginTransformFeedback = brw_begin_transform_feedback;
 303       functions->EndTransformFeedback = brw_end_transform_feedback;
 304    }
 305
 306    if (brw->gen >= 6)
 307       functions->GetSamplePosition = gen6_get_sample_position;
 308 }
 309
 310 static void
 311 brw_initialize_context_constants(struct brw_context *brw)
 312 {
 313    struct gl_context *ctx = &brw->ctx;
 314
 315    unsigned max_samplers =
 316       brw->gen >= 8 || brw->is_haswell ? BRW_MAX_TEX_UNIT : 16;
 317
 318    ctx->Const.QueryCounterBits.Timestamp = 36;
 319
 320    ctx->Const.StripTextureBorder = true;
 321
 322    ctx->Const.MaxDualSourceDrawBuffers = 1;
 323    ctx->Const.MaxDrawBuffers = BRW_MAX_DRAW_BUFFERS;
 324    ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits = max_samplers;
 325    ctx->Const.MaxTextureCoordUnits = 8; /* Mesa limit */
 326    ctx->Const.MaxTextureUnits =
 327       MIN2(ctx->Const.MaxTextureCoordUnits,
 328            ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits);
 329    ctx->Const.Program[MESA_SHADER_VERTEX].MaxTextureImageUnits = max_samplers;
 330    if (brw->gen >= 6)
 331       ctx->Const.Program[MESA_SHADER_GEOMETRY].MaxTextureImageUnits = max_samplers;
 332    else
 333       ctx->Const.Program[MESA_SHADER_GEOMETRY].MaxTextureImageUnits = 0;
 334    if (_mesa_extension_override_enables.ARB_compute_shader) {
 335       ctx->Const.Program[MESA_SHADER_COMPUTE].MaxTextureImageUnits = BRW_MAX_TEX_UNIT;
 336       ctx->Const.MaxUniformBufferBindings += 12;
 337    } else {
 338       ctx->Const.Program[MESA_SHADER_COMPUTE].MaxTextureImageUnits = 0;
 339    }
 340    ctx->Const.MaxCombinedTextureImageUnits =
 341       ctx->Const.Program[MESA_SHADER_VERTEX].MaxTextureImageUnits +
 342       ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits +
 343       ctx->Const.Program[MESA_SHADER_GEOMETRY].MaxTextureImageUnits +
 344       ctx->Const.Program[MESA_SHADER_COMPUTE].MaxTextureImageUnits;
 345
 346    ctx->Const.MaxTextureLevels = 14; /* 8192 */
 347    if (ctx->Const.MaxTextureLevels > MAX_TEXTURE_LEVELS)
 348       ctx->Const.MaxTextureLevels = MAX_TEXTURE_LEVELS;
 349    ctx->Const.Max3DTextureLevels = 12; /* 2048 */
 350    ctx->Const.MaxCubeTextureLevels = 14; /* 8192 */
 351    ctx->Const.MaxTextureMbytes = 1536;
 352
 353    if (brw->gen >= 7)
 354       ctx->Const.MaxArrayTextureLayers = 2048;
 355    else
 356       ctx->Const.MaxArrayTextureLayers = 512;
 357
 358    ctx->Const.MaxTextureRectSize = 1 << 12;
 359
 360    ctx->Const.MaxTextureMaxAnisotropy = 16.0;
 361
 362    ctx->Const.MaxRenderbufferSize = 8192;
 363
 364    /* Hardware only supports a limited number of transform feedback buffers.
 365     * So we need to override the Mesa default (which is based only on software
 366     * limits).
 367     */
 368    ctx->Const.MaxTransformFeedbackBuffers = BRW_MAX_SOL_BUFFERS;
 369
 370    /* On Gen6, in the worst case, we use up one binding table entry per
 371     * transform feedback component (see comments above the definition of
 372     * BRW_MAX_SOL_BINDINGS, in brw_context.h), so we need to advertise a value
 373     * for MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS equal to
 374     * BRW_MAX_SOL_BINDINGS.
 375     *
 376     * In "separate components" mode, we need to divide this value by
 377     * BRW_MAX_SOL_BUFFERS, so that the total number of binding table entries
 378     * used up by all buffers will not exceed BRW_MAX_SOL_BINDINGS.
 379     */
 380    ctx->Const.MaxTransformFeedbackInterleavedComponents = BRW_MAX_SOL_BINDINGS;
 381    ctx->Const.MaxTransformFeedbackSeparateComponents =
 382       BRW_MAX_SOL_BINDINGS / BRW_MAX_SOL_BUFFERS;
 383
 384    ctx->Const.AlwaysUseGetTransformFeedbackVertexCount = true;
 385
 386    int max_samples;
 387    const int *msaa_modes = intel_supported_msaa_modes(brw->intelScreen);
 388    const int clamp_max_samples =
 389       driQueryOptioni(&brw->optionCache, "clamp_max_samples");
 390
 391    if (clamp_max_samples < 0) {
 392       max_samples = msaa_modes[0];
 393    } else {
 394       /* Select the largest supported MSAA mode that does not exceed
 395        * clamp_max_samples.
 396        */
 397       max_samples = 0;
 398       for (int i = 0; msaa_modes[i] != 0; ++i) {
 399          if (msaa_modes[i] <= clamp_max_samples) {
 400             max_samples = msaa_modes[i];
 401             break;
 402          }
 403       }
 404    }
 405
 406    ctx->Const.MaxSamples = max_samples;
 407    ctx->Const.MaxColorTextureSamples = max_samples;
 408    ctx->Const.MaxDepthTextureSamples = max_samples;
 409    ctx->Const.MaxIntegerSamples = max_samples;
 410
 411    /* gen6_set_sample_maps() sets SampleMap{2,4,8}x variables which are used
 412     * to map indices of rectangular grid to sample numbers within a pixel.
 413     * These variables are used by GL_EXT_framebuffer_multisample_blit_scaled
 414     * extension implementation. For more details see the comment above
 415     * gen6_set_sample_maps() definition.
 416     */
 417    gen6_set_sample_maps(ctx);
 418
 419    if (brw->gen >= 7)
 420       ctx->Const.MaxProgramTextureGatherComponents = 4;
 421    else if (brw->gen == 6)
 422       ctx->Const.MaxProgramTextureGatherComponents = 1;
 423
 424    ctx->Const.MinLineWidth = 1.0;
 425    ctx->Const.MinLineWidthAA = 1.0;
 426    if (brw->gen >= 9 || brw->is_cherryview) {
 427       ctx->Const.MaxLineWidth = 40.0;
 428       ctx->Const.MaxLineWidthAA = 40.0;
 429       ctx->Const.LineWidthGranularity = 0.125;
 430    } else if (brw->gen >= 6) {
 431       ctx->Const.MaxLineWidth = 7.875;
 432       ctx->Const.MaxLineWidthAA = 7.875;
 433       ctx->Const.LineWidthGranularity = 0.125;
 434    } else {
 435       ctx->Const.MaxLineWidth = 7.0;
 436       ctx->Const.MaxLineWidthAA = 7.0;
 437       ctx->Const.LineWidthGranularity = 0.5;
 438    }
 439
 440    ctx->Const.MinPointSize = 1.0;
 441    ctx->Const.MinPointSizeAA = 1.0;
 442    ctx->Const.MaxPointSize = 255.0;
 443    ctx->Const.MaxPointSizeAA = 255.0;
 444    ctx->Const.PointSizeGranularity = 1.0;
 445
 446    if (brw->gen >= 5 || brw->is_g4x)
 447       ctx->Const.MaxClipPlanes = 8;
 448
 449    ctx->Const.Program[MESA_SHADER_VERTEX].MaxNativeInstructions = 16 * 1024;
 450    ctx->Const.Program[MESA_SHADER_VERTEX].MaxAluInstructions = 0;
 451    ctx->Const.Program[MESA_SHADER_VERTEX].MaxTexInstructions = 0;
 452    ctx->Const.Program[MESA_SHADER_VERTEX].MaxTexIndirections = 0;
 453    ctx->Const.Program[MESA_SHADER_VERTEX].MaxNativeAluInstructions = 0;
 454    ctx->Const.Program[MESA_SHADER_VERTEX].MaxNativeTexInstructions = 0;
 455    ctx->Const.Program[MESA_SHADER_VERTEX].MaxNativeTexIndirections = 0;
 456    ctx->Const.Program[MESA_SHADER_VERTEX].MaxNativeAttribs = 16;
 457    ctx->Const.Program[MESA_SHADER_VERTEX].MaxNativeTemps = 256;
 458    ctx->Const.Program[MESA_SHADER_VERTEX].MaxNativeAddressRegs = 1;
 459    ctx->Const.Program[MESA_SHADER_VERTEX].MaxNativeParameters = 1024;
 460    ctx->Const.Program[MESA_SHADER_VERTEX].MaxEnvParams =
 461       MIN2(ctx->Const.Program[MESA_SHADER_VERTEX].MaxNativeParameters,
 462            ctx->Const.Program[MESA_SHADER_VERTEX].MaxEnvParams);
 463
 464    ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxNativeInstructions = 1024;
 465    ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxNativeAluInstructions = 1024;
 466    ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxNativeTexInstructions = 1024;
 467    ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxNativeTexIndirections = 1024;
 468    ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxNativeAttribs = 12;
 469    ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxNativeTemps = 256;
 470    ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxNativeAddressRegs = 0;
 471    ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxNativeParameters = 1024;
 472    ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxEnvParams =
 473       MIN2(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxNativeParameters,
 474            ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxEnvParams);
 475
 476    /* Fragment shaders use real, 32-bit twos-complement integers for all
 477     * integer types.
 478     */
 479    ctx->Const.Program[MESA_SHADER_FRAGMENT].LowInt.RangeMin = 31;
 480    ctx->Const.Program[MESA_SHADER_FRAGMENT].LowInt.RangeMax = 30;
 481    ctx->Const.Program[MESA_SHADER_FRAGMENT].LowInt.Precision = 0;
 482    ctx->Const.Program[MESA_SHADER_FRAGMENT].HighInt = ctx->Const.Program[MESA_SHADER_FRAGMENT].LowInt;
 483    ctx->Const.Program[MESA_SHADER_FRAGMENT].MediumInt = ctx->Const.Program[MESA_SHADER_FRAGMENT].LowInt;
 484
 485    ctx->Const.Program[MESA_SHADER_VERTEX].LowInt.RangeMin = 31;
 486    ctx->Const.Program[MESA_SHADER_VERTEX].LowInt.RangeMax = 30;
 487    ctx->Const.Program[MESA_SHADER_VERTEX].LowInt.Precision = 0;
 488    ctx->Const.Program[MESA_SHADER_VERTEX].HighInt = ctx->Const.Program[MESA_SHADER_VERTEX].LowInt;
 489    ctx->Const.Program[MESA_SHADER_VERTEX].MediumInt = ctx->Const.Program[MESA_SHADER_VERTEX].LowInt;
 490
 491    if (brw->gen >= 7) {
 492       ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxAtomicCounters = MAX_ATOMIC_COUNTERS;
 493       ctx->Const.Program[MESA_SHADER_VERTEX].MaxAtomicCounters = MAX_ATOMIC_COUNTERS;
 494       ctx->Const.Program[MESA_SHADER_GEOMETRY].MaxAtomicCounters = MAX_ATOMIC_COUNTERS;
 495       ctx->Const.Program[MESA_SHADER_COMPUTE].MaxAtomicCounters = MAX_ATOMIC_COUNTERS;
 496       ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxAtomicBuffers = BRW_MAX_ABO;
 497       ctx->Const.Program[MESA_SHADER_VERTEX].MaxAtomicBuffers = BRW_MAX_ABO;
 498       ctx->Const.Program[MESA_SHADER_GEOMETRY].MaxAtomicBuffers = BRW_MAX_ABO;
 499       ctx->Const.Program[MESA_SHADER_COMPUTE].MaxAtomicBuffers = BRW_MAX_ABO;
 500       ctx->Const.MaxCombinedAtomicBuffers = 3 * BRW_MAX_ABO;
 501    }
 502
 503    /* Gen6 converts quads to polygon in beginning of 3D pipeline,
 504     * but we're not sure how it's actually done for vertex order,
 505     * that affect provoking vertex decision. Always use last vertex
 506     * convention for quad primitive which works as expected for now.
 507     */
 508    if (brw->gen >= 6)
 509       ctx->Const.QuadsFollowProvokingVertexConvention = false;
 510
 511    ctx->Const.NativeIntegers = true;
 512    ctx->Const.VertexID_is_zero_based = true;
 513
 514    /* Regarding the CMP instruction, the Ivybridge PRM says:
 515     *
 516     *   "For each enabled channel 0b or 1b is assigned to the appropriate flag
 517     *    bit and 0/all zeros or all ones (e.g, byte 0xFF, word 0xFFFF, DWord
 518     *    0xFFFFFFFF) is assigned to dst."
 519     *
 520     * but PRMs for earlier generations say
 521     *
 522     *   "In dword format, one GRF may store up to 8 results. When the register
 523     *    is used later as a vector of Booleans, as only LSB at each channel
 524     *    contains meaning [sic] data, software should make sure all higher bits
 525     *    are masked out (e.g. by 'and-ing' an [sic] 0x01 constant)."
 526     *
 527     * We select the representation of a true boolean uniform to be ~0, and fix
 528     * the results of Gen <= 5 CMP instruction's with -(result & 1).
 529     */
 530    ctx->Const.UniformBooleanTrue = ~0;
 531
 532    /* From the gen4 PRM, volume 4 page 127:
 533     *
 534     *     "For SURFTYPE_BUFFER non-rendertarget surfaces, this field specifies
 535     *      the base address of the first element of the surface, computed in
 536     *      software by adding the surface base address to the byte offset of
 537     *      the element in the buffer."
 538     *
 539     * However, unaligned accesses are slower, so enforce buffer alignment.
 540     */
 541    ctx->Const.UniformBufferOffsetAlignment = 16;
 542    ctx->Const.TextureBufferOffsetAlignment = 16;
 543
 544    if (brw->gen >= 6) {
 545       ctx->Const.MaxVarying = 32;
 546       ctx->Const.Program[MESA_SHADER_VERTEX].MaxOutputComponents = 128;
 547       ctx->Const.Program[MESA_SHADER_GEOMETRY].MaxInputComponents = 64;
 548       ctx->Const.Program[MESA_SHADER_GEOMETRY].MaxOutputComponents = 128;
 549       ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxInputComponents = 128;
 550    }
 551
 552    /* We want the GLSL compiler to emit code that uses condition codes */
 553    for (int i = 0; i < MESA_SHADER_STAGES; i++) {
 554       ctx->Const.ShaderCompilerOptions[i].MaxIfDepth = brw->gen < 6 ? 16 : UINT_MAX;
 555       ctx->Const.ShaderCompilerOptions[i].EmitCondCodes = true;
 556       ctx->Const.ShaderCompilerOptions[i].EmitNoNoise = true;
 557       ctx->Const.ShaderCompilerOptions[i].EmitNoMainReturn = true;
 558       ctx->Const.ShaderCompilerOptions[i].EmitNoIndirectInput = true;
 559       ctx->Const.ShaderCompilerOptions[i].EmitNoIndirectOutput =
 560          (i == MESA_SHADER_FRAGMENT);
 561       ctx->Const.ShaderCompilerOptions[i].EmitNoIndirectTemp =
 562          (i == MESA_SHADER_FRAGMENT);
 563       ctx->Const.ShaderCompilerOptions[i].EmitNoIndirectUniform = false;
 564       ctx->Const.ShaderCompilerOptions[i].LowerClipDistance = true;
 565
 566       /* !ARB_gpu_shader5 */
 567       if (brw->gen < 7)
 568          ctx->Const.ShaderCompilerOptions[i].EmitNoIndirectSampler = true;
 569    }
 570
 571    ctx->Const.ShaderCompilerOptions[MESA_SHADER_VERTEX].OptimizeForAOS = true;
 572    ctx->Const.ShaderCompilerOptions[MESA_SHADER_GEOMETRY].OptimizeForAOS = true;
 573
 574    if (brw->scalar_vs) {
 575       /* If we're using the scalar backend for vertex shaders, we need to
 576        * configure these accordingly.
 577        */
 578       ctx->Const.ShaderCompilerOptions[MESA_SHADER_VERTEX].EmitNoIndirectOutput = true;
 579       ctx->Const.ShaderCompilerOptions[MESA_SHADER_VERTEX].EmitNoIndirectTemp = true;
 580       ctx->Const.ShaderCompilerOptions[MESA_SHADER_VERTEX].OptimizeForAOS = false;
 581    }
 582
 583    /* ARB_viewport_array */
 584    if (brw->gen >= 7 && ctx->API == API_OPENGL_CORE) {
 585       ctx->Const.MaxViewports = GEN7_NUM_VIEWPORTS;
 586       ctx->Const.ViewportSubpixelBits = 0;
 587
 588       /* Cast to float before negating becuase MaxViewportWidth is unsigned.
 589        */
 590       ctx->Const.ViewportBounds.Min = -(float)ctx->Const.MaxViewportWidth;
 591       ctx->Const.ViewportBounds.Max = ctx->Const.MaxViewportWidth;
 592    }
 593
 594    /* ARB_gpu_shader5 */
 595    if (brw->gen >= 7)
 596       ctx->Const.MaxVertexStreams = MIN2(4, MAX_VERTEX_STREAMS);
 597 }
 598
 599 /**
 600  * Process driconf (drirc) options, setting appropriate context flags.
 601  *
 602  * intelInitExtensions still pokes at optionCache directly, in order to
 603  * avoid advertising various extensions.  No flags are set, so it makes
 604  * sense to continue doing that there.
 605  */
 606 static void
 607 brw_process_driconf_options(struct brw_context *brw)
 608 {
 609    struct gl_context *ctx = &brw->ctx;
 610
 611    driOptionCache *options = &brw->optionCache;
 612    driParseConfigFiles(options, &brw->intelScreen->optionCache,
 613                        brw->driContext->driScreenPriv->myNum, "i965");
 614
 615    int bo_reuse_mode = driQueryOptioni(options, "bo_reuse");
 616    switch (bo_reuse_mode) {
 617    case DRI_CONF_BO_REUSE_DISABLED:
 618       break;
 619    case DRI_CONF_BO_REUSE_ALL:
 620       intel_bufmgr_gem_enable_reuse(brw->bufmgr);
 621       break;
 622    }
 623
 624    if (!driQueryOptionb(options, "hiz")) {
 625        brw->has_hiz = false;
 626        /* On gen6, you can only do separate stencil with HIZ. */
 627        if (brw->gen == 6)
 628           brw->has_separate_stencil = false;
 629    }
 630
 631    if (driQueryOptionb(options, "always_flush_batch")) {
 632       fprintf(stderr, "flushing batchbuffer before/after each draw call\n");
 633       brw->always_flush_batch = true;
 634    }
 635
 636    if (driQueryOptionb(options, "always_flush_cache")) {
 637       fprintf(stderr, "flushing GPU caches before/after each draw call\n");
 638       brw->always_flush_cache = true;
 639    }
 640
 641    if (driQueryOptionb(options, "disable_throttling")) {
 642       fprintf(stderr, "disabling flush throttling\n");
 643       brw->disable_throttling = true;
 644    }
 645
 646    brw->precompile = driQueryOptionb(&brw->optionCache, "shader_precompile");
 647
 648    ctx->Const.ForceGLSLExtensionsWarn =
 649       driQueryOptionb(options, "force_glsl_extensions_warn");
 650
 651    ctx->Const.DisableGLSLLineContinuations =
 652       driQueryOptionb(options, "disable_glsl_line_continuations");
 653
 654    ctx->Const.AllowGLSLExtensionDirectiveMidShader =
 655       driQueryOptionb(options, "allow_glsl_extension_directive_midshader");
 656 }
 657
 658 GLboolean
 659 brwCreateContext(gl_api api,
 660                  const struct gl_config *mesaVis,
 661                  __DRIcontext *driContextPriv,
 662                  unsigned major_version,
 663                  unsigned minor_version,
 664                  uint32_t flags,
 665                  bool notify_reset,
 666                  unsigned *dri_ctx_error,
 667                  void *sharedContextPrivate)
 668 {
 669    __DRIscreen *sPriv = driContextPriv->driScreenPriv;
 670    struct gl_context *shareCtx = (struct gl_context *) sharedContextPrivate;
 671    struct intel_screen *screen = sPriv->driverPrivate;
 672    const struct brw_device_info *devinfo = screen->devinfo;
 673    struct dd_function_table functions;
 674
 675    /* Only allow the __DRI_CTX_FLAG_ROBUST_BUFFER_ACCESS flag if the kernel
 676     * provides us with context reset notifications.
 677     */
 678    uint32_t allowed_flags = __DRI_CTX_FLAG_DEBUG
 679       | __DRI_CTX_FLAG_FORWARD_COMPATIBLE;
 680
 681    if (screen->has_context_reset_notification)
 682       allowed_flags |= __DRI_CTX_FLAG_ROBUST_BUFFER_ACCESS;
 683
 684    if (flags & ~allowed_flags) {
 685       *dri_ctx_error = __DRI_CTX_ERROR_UNKNOWN_FLAG;
 686       return false;
 687    }
 688
 689    struct brw_context *brw = rzalloc(NULL, struct brw_context);
 690    if (!brw) {
 691       fprintf(stderr, "%s: failed to alloc context\n", __FUNCTION__);
 692       *dri_ctx_error = __DRI_CTX_ERROR_NO_MEMORY;
 693       return false;
 694    }
 695
 696    driContextPriv->driverPrivate = brw;
 697    brw->driContext = driContextPriv;
 698    brw->intelScreen = screen;
 699    brw->bufmgr = screen->bufmgr;
 700
 701    brw->gen = devinfo->gen;
 702    brw->gt = devinfo->gt;
 703    brw->is_g4x = devinfo->is_g4x;
 704    brw->is_baytrail = devinfo->is_baytrail;
 705    brw->is_haswell = devinfo->is_haswell;
 706    brw->is_cherryview = devinfo->is_cherryview;
 707    brw->has_llc = devinfo->has_llc;
 708    brw->has_hiz = devinfo->has_hiz_and_separate_stencil;
 709    brw->has_separate_stencil = devinfo->has_hiz_and_separate_stencil;
 710    brw->has_pln = devinfo->has_pln;
 711    brw->has_compr4 = devinfo->has_compr4;
 712    brw->has_surface_tile_offset = devinfo->has_surface_tile_offset;
 713    brw->has_negative_rhw_bug = devinfo->has_negative_rhw_bug;
 714    brw->needs_unlit_centroid_workaround =
 715       devinfo->needs_unlit_centroid_workaround;
 716
 717    brw->must_use_separate_stencil = screen->hw_must_use_separate_stencil;
 718    brw->has_swizzling = screen->hw_has_swizzling;
 719
 720    brw->vs.base.stage = MESA_SHADER_VERTEX;
 721    brw->gs.base.stage = MESA_SHADER_GEOMETRY;
 722    brw->wm.base.stage = MESA_SHADER_FRAGMENT;
 723    if (brw->gen >= 8) {
 724       gen8_init_vtable_surface_functions(brw);
 725       brw->vtbl.emit_depth_stencil_hiz = gen8_emit_depth_stencil_hiz;
 726    } else if (brw->gen >= 7) {
 727       gen7_init_vtable_surface_functions(brw);
 728       brw->vtbl.emit_depth_stencil_hiz = gen7_emit_depth_stencil_hiz;
 729    } else if (brw->gen >= 6) {
 730       gen6_init_vtable_surface_functions(brw);
 731       brw->vtbl.emit_depth_stencil_hiz = gen6_emit_depth_stencil_hiz;
 732    } else {
 733       gen4_init_vtable_surface_functions(brw);
 734       brw->vtbl.emit_depth_stencil_hiz = brw_emit_depth_stencil_hiz;
 735    }
 736
 737    brw_init_driver_functions(brw, &functions);
 738
 739    if (notify_reset)
 740       functions.GetGraphicsResetStatus = brw_get_graphics_reset_status;
 741
 742    struct gl_context *ctx = &brw->ctx;
 743
 744    if (!_mesa_initialize_context(ctx, api, mesaVis, shareCtx, &functions)) {
 745       *dri_ctx_error = __DRI_CTX_ERROR_NO_MEMORY;
 746       fprintf(stderr, "%s: failed to init mesa context\n", __FUNCTION__);
 747       intelDestroyContext(driContextPriv);
 748       return false;
 749    }
 750
 751    driContextSetFlags(ctx, flags);
 752
 753    /* Initialize the software rasterizer and helper modules.
 754     *
 755     * As of GL 3.1 core, the gen4+ driver doesn't need the swrast context for
 756     * software fallbacks (which we have to support on legacy GL to do weird
 757     * glDrawPixels(), glBitmap(), and other functions).
 758     */
 759    if (api != API_OPENGL_CORE && api != API_OPENGLES2) {
 760       _swrast_CreateContext(ctx);
 761    }
 762
 763    _vbo_CreateContext(ctx);
 764    if (ctx->swrast_context) {
 765       _tnl_CreateContext(ctx);
 766       TNL_CONTEXT(ctx)->Driver.RunPipeline = _tnl_run_pipeline;
 767       _swsetup_CreateContext(ctx);
 768
 769       /* Configure swrast to match hardware characteristics: */
 770       _swrast_allow_pixel_fog(ctx, false);
 771       _swrast_allow_vertex_fog(ctx, true);
 772    }
 773
 774    _mesa_meta_init(ctx);
 775
 776    brw_process_driconf_options(brw);
 777    brw_process_intel_debug_variable(brw);
 778
 779    if (brw->gen >= 8 && !(INTEL_DEBUG & DEBUG_VEC4VS))
 780       brw->scalar_vs = true;
 781
 782    brw_initialize_context_constants(brw);
 783
 784    ctx->Const.ResetStrategy = notify_reset
 785       ? GL_LOSE_CONTEXT_ON_RESET_ARB : GL_NO_RESET_NOTIFICATION_ARB;
 786
 787    /* Reinitialize the context point state.  It depends on ctx->Const values. */
 788    _mesa_init_point(ctx);
 789
 790    intel_fbo_init(brw);
 791
 792    intel_batchbuffer_init(brw);
 793
 794    if (brw->gen >= 6) {
 795       /* Create a new hardware context.  Using a hardware context means that
 796        * our GPU state will be saved/restored on context switch, allowing us
 797        * to assume that the GPU is in the same state we left it in.
 798        *
 799        * This is required for transform feedback buffer offsets, query objects,
 800        * and also allows us to reduce how much state we have to emit.
 801        */
 802       brw->hw_ctx = drm_intel_gem_context_create(brw->bufmgr);
 803
 804       if (!brw->hw_ctx) {
 805          fprintf(stderr, "Gen6+ requires Kernel 3.6 or later.\n");
 806          intelDestroyContext(driContextPriv);
 807          return false;
 808       }
 809    }
 810
 811    brw_init_state(brw);
 812
 813    intelInitExtensions(ctx);
 814
 815    brw_init_surface_formats(brw);
 816
 817    brw->max_vs_threads = devinfo->max_vs_threads;
 818    brw->max_gs_threads = devinfo->max_gs_threads;
 819    brw->max_wm_threads = devinfo->max_wm_threads;
 820    brw->urb.size = devinfo->urb.size;
 821    brw->urb.min_vs_entries = devinfo->urb.min_vs_entries;
 822    brw->urb.max_vs_entries = devinfo->urb.max_vs_entries;
 823    brw->urb.max_gs_entries = devinfo->urb.max_gs_entries;
 824
 825    /* Estimate the size of the mappable aperture into the GTT.  There's an
 826     * ioctl to get the whole GTT size, but not one to get the mappable subset.
 827     * It turns out it's basically always 256MB, though some ancient hardware
 828     * was smaller.
 829     */
 830    uint32_t gtt_size = 256 * 1024 * 1024;
 831
 832    /* We don't want to map two objects such that a memcpy between them would
 833     * just fault one mapping in and then the other over and over forever.  So
 834     * we would need to divide the GTT size by 2.  Additionally, some GTT is
 835     * taken up by things like the framebuffer and the ringbuffer and such, so
 836     * be more conservative.
 837     */
 838    brw->max_gtt_map_object_size = gtt_size / 4;
 839
 840    if (brw->gen == 6)
 841       brw->urb.gs_present = false;
 842
 843    brw->prim_restart.in_progress = false;
 844    brw->prim_restart.enable_cut_index = false;
 845    brw->gs.enabled = false;
 846    brw->sf.viewport_transform_enable = true;
 847
 848    ctx->VertexProgram._MaintainTnlProgram = true;
 849    ctx->FragmentProgram._MaintainTexEnvProgram = true;
 850
 851    brw_draw_init( brw );
 852
 853    if ((flags & __DRI_CTX_FLAG_DEBUG) != 0) {
 854       /* Turn on some extra GL_ARB_debug_output generation. */
 855       brw->perf_debug = true;
 856    }
 857
 858    if ((flags & __DRI_CTX_FLAG_ROBUST_BUFFER_ACCESS) != 0)
 859       ctx->Const.ContextFlags |= GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB;
 860
 861    if (INTEL_DEBUG & DEBUG_SHADER_TIME)
 862       brw_init_shader_time(brw);
 863
 864    _mesa_compute_version(ctx);
 865
 866    _mesa_initialize_dispatch_tables(ctx);
 867    _mesa_initialize_vbo_vtxfmt(ctx);
 868
 869    if (ctx->Extensions.AMD_performance_monitor) {
 870       brw_init_performance_monitors(brw);
 871    }
 872
 873    vbo_use_buffer_objects(ctx);
 874    vbo_always_unmap_buffers(ctx);
 875
 876    return true;
 877 }
 878
 879 void
 880 intelDestroyContext(__DRIcontext * driContextPriv)
 881 {
 882    struct brw_context *brw =
 883       (struct brw_context *) driContextPriv->driverPrivate;
 884    struct gl_context *ctx = &brw->ctx;
 885
 886    assert(brw); /* should never be null */
 887    if (!brw)
 888       return;
 889
 890    /* Dump a final BMP in case the application doesn't call SwapBuffers */
 891    if (INTEL_DEBUG & DEBUG_AUB) {
 892       intel_batchbuffer_flush(brw);
 893       aub_dump_bmp(&brw->ctx);
 894    }
 895
 896    _mesa_meta_free(&brw->ctx);
 897    brw_meta_fast_clear_free(brw);
 898
 899    if (INTEL_DEBUG & DEBUG_SHADER_TIME) {
 900       /* Force a report. */
 901       brw->shader_time.report_time = 0;
 902
 903       brw_collect_and_report_shader_time(brw);
 904       brw_destroy_shader_time(brw);
 905    }
 906
 907    brw_destroy_state(brw);
 908    brw_draw_destroy(brw);
 909
 910    drm_intel_bo_unreference(brw->curbe.curbe_bo);
 911
 912    drm_intel_gem_context_destroy(brw->hw_ctx);
 913
 914    if (ctx->swrast_context) {
 915       _swsetup_DestroyContext(&brw->ctx);
 916       _tnl_DestroyContext(&brw->ctx);
 917    }
 918    _vbo_DestroyContext(&brw->ctx);
 919
 920    if (ctx->swrast_context)
 921       _swrast_DestroyContext(&brw->ctx);
 922
 923    intel_batchbuffer_free(brw);
 924
 925    drm_intel_bo_unreference(brw->first_post_swapbuffers_batch);
 926    brw->first_post_swapbuffers_batch = NULL;
 927
 928    driDestroyOptionCache(&brw->optionCache);
 929
 930    /* free the Mesa context */
 931    _mesa_free_context_data(&brw->ctx);
 932
 933    ralloc_free(brw);
 934    driContextPriv->driverPrivate = NULL;
 935 }
 936
 937 GLboolean
 938 intelUnbindContext(__DRIcontext * driContextPriv)
 939 {
 940    /* Unset current context and dispath table */
 941    _mesa_make_current(NULL, NULL, NULL);
 942
 943    return true;
 944 }
 945
 946 /**
 947  * Fixes up the context for GLES23 with our default-to-sRGB-capable behavior
 948  * on window system framebuffers.
 949  *
 950  * Desktop GL is fairly reasonable in its handling of sRGB: You can ask if
 951  * your renderbuffer can do sRGB encode, and you can flip a switch that does
 952  * sRGB encode if the renderbuffer can handle it.  You can ask specifically
 953  * for a visual where you're guaranteed to be capable, but it turns out that
 954  * everyone just makes all their ARGB8888 visuals capable and doesn't offer
 955  * incapable ones, becuase there's no difference between the two in resources
 956  * used.  Applications thus get built that accidentally rely on the default
 957  * visual choice being sRGB, so we make ours sRGB capable.  Everything sounds
 958  * great...
 959  *
 960  * But for GLES2/3, they decided that it was silly to not turn on sRGB encode
 961  * for sRGB renderbuffers you made with the GL_EXT_texture_sRGB equivalent.
 962  * So they removed the enable knob and made it "if the renderbuffer is sRGB
 963  * capable, do sRGB encode".  Then, for your window system renderbuffers, you
 964  * can ask for sRGB visuals and get sRGB encode, or not ask for sRGB visuals
 965  * and get no sRGB encode (assuming that both kinds of visual are available).
 966  * Thus our choice to support sRGB by default on our visuals for desktop would
 967  * result in broken rendering of GLES apps that aren't expecting sRGB encode.
 968  *
 969  * Unfortunately, renderbuffer setup happens before a context is created.  So
 970  * in intel_screen.c we always set up sRGB, and here, if you're a GLES2/3
 971  * context (without an sRGB visual, though we don't have sRGB visuals exposed
 972  * yet), we go turn that back off before anyone finds out.
 973  */
 974 static void
 975 intel_gles3_srgb_workaround(struct brw_context *brw,
 976                             struct gl_framebuffer *fb)
 977 {
 978    struct gl_context *ctx = &brw->ctx;
 979
 980    if (_mesa_is_desktop_gl(ctx) || !fb->Visual.sRGBCapable)
 981       return;
 982
 983    /* Some day when we support the sRGB capable bit on visuals available for
 984     * GLES, we'll need to respect that and not disable things here.
 985     */
 986    fb->Visual.sRGBCapable = false;
 987    for (int i = 0; i < BUFFER_COUNT; i++) {
 988       if (fb->Attachment[i].Renderbuffer &&
 989           fb->Attachment[i].Renderbuffer->Format == MESA_FORMAT_B8G8R8A8_SRGB) {
 990          fb->Attachment[i].Renderbuffer->Format = MESA_FORMAT_B8G8R8A8_UNORM;
 991       }
 992    }
 993 }
 994
 995 GLboolean
 996 intelMakeCurrent(__DRIcontext * driContextPriv,
 997                  __DRIdrawable * driDrawPriv,
 998                  __DRIdrawable * driReadPriv)
 999 {
1000    struct brw_context *brw;
1001    GET_CURRENT_CONTEXT(curCtx);
1002
1003    if (driContextPriv)
1004       brw = (struct brw_context *) driContextPriv->driverPrivate;
1005    else
1006       brw = NULL;
1007
1008    /* According to the glXMakeCurrent() man page: "Pending commands to
1009     * the previous context, if any, are flushed before it is released."
1010     * But only flush if we're actually changing contexts.
1011     */
1012    if (brw_context(curCtx) && brw_context(curCtx) != brw) {
1013       _mesa_flush(curCtx);
1014    }
1015
1016    if (driContextPriv) {
1017       struct gl_context *ctx = &brw->ctx;
1018       struct gl_framebuffer *fb, *readFb;
1019
1020       if (driDrawPriv == NULL) {
1021          fb = _mesa_get_incomplete_framebuffer();
1022       } else {
1023          fb = driDrawPriv->driverPrivate;
1024          driContextPriv->dri2.draw_stamp = driDrawPriv->dri2.stamp - 1;
1025       }
1026
1027       if (driReadPriv == NULL) {
1028          readFb = _mesa_get_incomplete_framebuffer();
1029       } else {
1030          readFb = driReadPriv->driverPrivate;
1031          driContextPriv->dri2.read_stamp = driReadPriv->dri2.stamp - 1;
1032       }
1033
1034       /* The sRGB workaround changes the renderbuffer's format. We must change
1035        * the format before the renderbuffer's miptree get's allocated, otherwise
1036        * the formats of the renderbuffer and its miptree will differ.
1037        */
1038       intel_gles3_srgb_workaround(brw, fb);
1039       intel_gles3_srgb_workaround(brw, readFb);
1040
1041       /* If the context viewport hasn't been initialized, force a call out to
1042        * the loader to get buffers so we have a drawable size for the initial
1043        * viewport. */
1044       if (!brw->ctx.ViewportInitialized)
1045          intel_prepare_render(brw);
1046
1047       _mesa_make_current(ctx, fb, readFb);
1048    } else {
1049       _mesa_make_current(NULL, NULL, NULL);
1050    }
1051
1052    return true;
1053 }
1054
1055 void
1056 intel_resolve_for_dri2_flush(struct brw_context *brw,
1057                              __DRIdrawable *drawable)
1058 {
1059    if (brw->gen < 6) {
1060       /* MSAA and fast color clear are not supported, so don't waste time
1061        * checking whether a resolve is needed.
1062        */
1063       return;
1064    }
1065
1066    struct gl_framebuffer *fb = drawable->driverPrivate;
1067    struct intel_renderbuffer *rb;
1068
1069    /* Usually, only the back buffer will need to be downsampled. However,
1070     * the front buffer will also need it if the user has rendered into it.
1071     */
1072    static const gl_buffer_index buffers[2] = {
1073          BUFFER_BACK_LEFT,
1074          BUFFER_FRONT_LEFT,
1075    };
1076
1077    for (int i = 0; i < 2; ++i) {
1078       rb = intel_get_renderbuffer(fb, buffers[i]);
1079       if (rb == NULL || rb->mt == NULL)
1080          continue;
1081       if (rb->mt->num_samples <= 1)
1082          intel_miptree_resolve_color(brw, rb->mt);
1083       else
1084          intel_renderbuffer_downsample(brw, rb);
1085    }
1086 }
1087
1088 static unsigned
1089 intel_bits_per_pixel(const struct intel_renderbuffer *rb)
1090 {
1091    return _mesa_get_format_bytes(intel_rb_format(rb)) * 8;
1092 }
1093
1094 static void
1095 intel_query_dri2_buffers(struct brw_context *brw,
1096                          __DRIdrawable *drawable,
1097                          __DRIbuffer **buffers,
1098                          int *count);
1099
1100 static void
1101 intel_process_dri2_buffer(struct brw_context *brw,
1102                           __DRIdrawable *drawable,
1103                           __DRIbuffer *buffer,
1104                           struct intel_renderbuffer *rb,
1105                           const char *buffer_name);
1106
1107 static void
1108 intel_update_image_buffers(struct brw_context *brw, __DRIdrawable *drawable);
1109
1110 static void
1111 intel_update_dri2_buffers(struct brw_context *brw, __DRIdrawable *drawable)
1112 {
1113    struct gl_framebuffer *fb = drawable->driverPrivate;
1114    struct intel_renderbuffer *rb;
1115    __DRIbuffer *buffers = NULL;
1116    int i, count;
1117    const char *region_name;
1118
1119    /* Set this up front, so that in case our buffers get invalidated
1120     * while we're getting new buffers, we don't clobber the stamp and
1121     * thus ignore the invalidate. */
1122    drawable->lastStamp = drawable->dri2.stamp;
1123
1124    if (unlikely(INTEL_DEBUG & DEBUG_DRI))
1125       fprintf(stderr, "enter %s, drawable %p\n", __func__, drawable);
1126
1127    intel_query_dri2_buffers(brw, drawable, &buffers, &count);
1128
1129    if (buffers == NULL)
1130       return;
1131
1132    for (i = 0; i < count; i++) {
1133        switch (buffers[i].attachment) {
1134        case __DRI_BUFFER_FRONT_LEFT:
1135            rb = intel_get_renderbuffer(fb, BUFFER_FRONT_LEFT);
1136            region_name = "dri2 front buffer";
1137            break;
1138
1139        case __DRI_BUFFER_FAKE_FRONT_LEFT:
1140            rb = intel_get_renderbuffer(fb, BUFFER_FRONT_LEFT);
1141            region_name = "dri2 fake front buffer";
1142            break;
1143
1144        case __DRI_BUFFER_BACK_LEFT:
1145            rb = intel_get_renderbuffer(fb, BUFFER_BACK_LEFT);
1146            region_name = "dri2 back buffer";
1147            break;
1148
1149        case __DRI_BUFFER_DEPTH:
1150        case __DRI_BUFFER_HIZ:
1151        case __DRI_BUFFER_DEPTH_STENCIL:
1152        case __DRI_BUFFER_STENCIL:
1153        case __DRI_BUFFER_ACCUM:
1154        default:
1155            fprintf(stderr,
1156                    "unhandled buffer attach event, attachment type %d\n",
1157                    buffers[i].attachment);
1158            return;
1159        }
1160
1161        intel_process_dri2_buffer(brw, drawable, &buffers[i], rb, region_name);
1162    }
1163
1164 }
1165
1166 void
1167 intel_update_renderbuffers(__DRIcontext *context, __DRIdrawable *drawable)
1168 {
1169    struct brw_context *brw = context->driverPrivate;
1170    __DRIscreen *screen = brw->intelScreen->driScrnPriv;
1171
1172    /* Set this up front, so that in case our buffers get invalidated
1173     * while we're getting new buffers, we don't clobber the stamp and
1174     * thus ignore the invalidate. */
1175    drawable->lastStamp = drawable->dri2.stamp;
1176
1177    if (unlikely(INTEL_DEBUG & DEBUG_DRI))
1178       fprintf(stderr, "enter %s, drawable %p\n", __func__, drawable);
1179
1180    if (screen->image.loader)
1181       intel_update_image_buffers(brw, drawable);
1182    else
1183       intel_update_dri2_buffers(brw, drawable);
1184
1185    driUpdateFramebufferSize(&brw->ctx, drawable);
1186 }
1187
1188 /**
1189  * intel_prepare_render should be called anywhere that curent read/drawbuffer
1190  * state is required.
1191  */
1192 void
1193 intel_prepare_render(struct brw_context *brw)
1194 {
1195    struct gl_context *ctx = &brw->ctx;
1196    __DRIcontext *driContext = brw->driContext;
1197    __DRIdrawable *drawable;
1198
1199    drawable = driContext->driDrawablePriv;
1200    if (drawable && drawable->dri2.stamp != driContext->dri2.draw_stamp) {
1201       if (drawable->lastStamp != drawable->dri2.stamp)
1202          intel_update_renderbuffers(driContext, drawable);
1203       driContext->dri2.draw_stamp = drawable->dri2.stamp;
1204    }
1205
1206    drawable = driContext->driReadablePriv;
1207    if (drawable && drawable->dri2.stamp != driContext->dri2.read_stamp) {
1208       if (drawable->lastStamp != drawable->dri2.stamp)
1209          intel_update_renderbuffers(driContext, drawable);
1210       driContext->dri2.read_stamp = drawable->dri2.stamp;
1211    }
1212
1213    /* If we're currently rendering to the front buffer, the rendering
1214     * that will happen next will probably dirty the front buffer.  So
1215     * mark it as dirty here.
1216     */
1217    if (brw_is_front_buffer_drawing(ctx->DrawBuffer))
1218       brw->front_buffer_dirty = true;
1219
1220    /* Wait for the swapbuffers before the one we just emitted, so we
1221     * don't get too many swaps outstanding for apps that are GPU-heavy
1222     * but not CPU-heavy.
1223     *
1224     * We're using intelDRI2Flush (called from the loader before
1225     * swapbuffer) and glFlush (for front buffer rendering) as the
1226     * indicator that a frame is done and then throttle when we get
1227     * here as we prepare to render the next frame.  At this point for
1228     * round trips for swap/copy and getting new buffers are done and
1229     * we'll spend less time waiting on the GPU.
1230     *
1231     * Unfortunately, we don't have a handle to the batch containing
1232     * the swap, and getting our hands on that doesn't seem worth it,
1233     * so we just us the first batch we emitted after the last swap.
1234     */
1235    if (brw->need_throttle && brw->first_post_swapbuffers_batch) {
1236       if (!brw->disable_throttling)
1237          drm_intel_bo_wait_rendering(brw->first_post_swapbuffers_batch);
1238       drm_intel_bo_unreference(brw->first_post_swapbuffers_batch);
1239       brw->first_post_swapbuffers_batch = NULL;
1240       brw->need_throttle = false;
1241    }
1242 }
1243
1244 /**
1245  * \brief Query DRI2 to obtain a DRIdrawable's buffers.
1246  *
1247  * To determine which DRI buffers to request, examine the renderbuffers
1248  * attached to the drawable's framebuffer. Then request the buffers with
1249  * DRI2GetBuffers() or DRI2GetBuffersWithFormat().
1250  *
1251  * This is called from intel_update_renderbuffers().
1252  *
1253  * \param drawable      Drawable whose buffers are queried.
1254  * \param buffers       [out] List of buffers returned by DRI2 query.
1255  * \param buffer_count  [out] Number of buffers returned.
1256  *
1257  * \see intel_update_renderbuffers()
1258  * \see DRI2GetBuffers()
1259  * \see DRI2GetBuffersWithFormat()
1260  */
1261 static void
1262 intel_query_dri2_buffers(struct brw_context *brw,
1263                          __DRIdrawable *drawable,
1264                          __DRIbuffer **buffers,
1265                          int *buffer_count)
1266 {
1267    __DRIscreen *screen = brw->intelScreen->driScrnPriv;
1268    struct gl_framebuffer *fb = drawable->driverPrivate;
1269    int i = 0;
1270    unsigned attachments[8];
1271
1272    struct intel_renderbuffer *front_rb;
1273    struct intel_renderbuffer *back_rb;
1274
1275    front_rb = intel_get_renderbuffer(fb, BUFFER_FRONT_LEFT);
1276    back_rb = intel_get_renderbuffer(fb, BUFFER_BACK_LEFT);
1277
1278    memset(attachments, 0, sizeof(attachments));
1279    if ((brw_is_front_buffer_drawing(fb) ||
1280         brw_is_front_buffer_reading(fb) ||
1281         !back_rb) && front_rb) {
1282       /* If a fake front buffer is in use, then querying for
1283        * __DRI_BUFFER_FRONT_LEFT will cause the server to copy the image from
1284        * the real front buffer to the fake front buffer.  So before doing the
1285        * query, we need to make sure all the pending drawing has landed in the
1286        * real front buffer.
1287        */
1288       intel_batchbuffer_flush(brw);
1289       intel_flush_front(&brw->ctx);
1290
1291       attachments[i++] = __DRI_BUFFER_FRONT_LEFT;
1292       attachments[i++] = intel_bits_per_pixel(front_rb);
1293    } else if (front_rb && brw->front_buffer_dirty) {
1294       /* We have pending front buffer rendering, but we aren't querying for a
1295        * front buffer.  If the front buffer we have is a fake front buffer,
1296        * the X server is going to throw it away when it processes the query.
1297        * So before doing the query, make sure all the pending drawing has
1298        * landed in the real front buffer.
1299        */
1300       intel_batchbuffer_flush(brw);
1301       intel_flush_front(&brw->ctx);
1302    }
1303
1304    if (back_rb) {
1305       attachments[i++] = __DRI_BUFFER_BACK_LEFT;
1306       attachments[i++] = intel_bits_per_pixel(back_rb);
1307    }
1308
1309    assert(i <= ARRAY_SIZE(attachments));
1310
1311    *buffers = screen->dri2.loader->getBuffersWithFormat(drawable,
1312                                                         &drawable->w,
1313                                                         &drawable->h,
1314                                                         attachments, i / 2,
1315                                                         buffer_count,
1316                                                         drawable->loaderPrivate);
1317 }
1318
1319 /**
1320  * \brief Assign a DRI buffer's DRM region to a renderbuffer.
1321  *
1322  * This is called from intel_update_renderbuffers().
1323  *
1324  * \par Note:
1325  *    DRI buffers whose attachment point is DRI2BufferStencil or
1326  *    DRI2BufferDepthStencil are handled as special cases.
1327  *
1328  * \param buffer_name is a human readable name, such as "dri2 front buffer",
1329  *        that is passed to drm_intel_bo_gem_create_from_name().
1330  *
1331  * \see intel_update_renderbuffers()
1332  */
1333 static void
1334 intel_process_dri2_buffer(struct brw_context *brw,
1335                           __DRIdrawable *drawable,
1336                           __DRIbuffer *buffer,
1337                           struct intel_renderbuffer *rb,
1338                           const char *buffer_name)
1339 {
1340    struct gl_framebuffer *fb = drawable->driverPrivate;
1341    drm_intel_bo *bo;
1342
1343    if (!rb)
1344       return;
1345
1346    unsigned num_samples = rb->Base.Base.NumSamples;
1347
1348    /* We try to avoid closing and reopening the same BO name, because the first
1349     * use of a mapping of the buffer involves a bunch of page faulting which is
1350     * moderately expensive.
1351     */
1352    struct intel_mipmap_tree *last_mt;
1353    if (num_samples == 0)
1354       last_mt = rb->mt;
1355    else
1356       last_mt = rb->singlesample_mt;
1357
1358    uint32_t old_name = 0;
1359    if (last_mt) {
1360        /* The bo already has a name because the miptree was created by a
1361         * previous call to intel_process_dri2_buffer(). If a bo already has a
1362         * name, then drm_intel_bo_flink() is a low-cost getter.  It does not
1363         * create a new name.
1364         */
1365       drm_intel_bo_flink(last_mt->bo, &old_name);
1366    }
1367
1368    if (old_name == buffer->name)
1369       return;
1370
1371    if (unlikely(INTEL_DEBUG & DEBUG_DRI)) {
1372       fprintf(stderr,
1373               "attaching buffer %d, at %d, cpp %d, pitch %d\n",
1374               buffer->name, buffer->attachment,
1375               buffer->cpp, buffer->pitch);
1376    }
1377
1378    intel_miptree_release(&rb->mt);
1379    bo = drm_intel_bo_gem_create_from_name(brw->bufmgr, buffer_name,
1380                                           buffer->name);
1381    if (!bo) {
1382       fprintf(stderr,
1383               "Failed to open BO for returned DRI2 buffer "
1384               "(%dx%d, %s, named %d).\n"
1385               "This is likely a bug in the X Server that will lead to a "
1386               "crash soon.\n",
1387               drawable->w, drawable->h, buffer_name, buffer->name);
1388       return;
1389    }
1390
1391    intel_update_winsys_renderbuffer_miptree(brw, rb, bo,
1392                                             drawable->w, drawable->h,
1393                                             buffer->pitch);
1394
1395    if (brw_is_front_buffer_drawing(fb) &&
1396        (buffer->attachment == __DRI_BUFFER_FRONT_LEFT ||
1397         buffer->attachment == __DRI_BUFFER_FAKE_FRONT_LEFT) &&
1398        rb->Base.Base.NumSamples > 1) {
1399       intel_renderbuffer_upsample(brw, rb);
1400    }
1401
1402    assert(rb->mt);
1403
1404    drm_intel_bo_unreference(bo);
1405 }
1406
1407 /**
1408  * \brief Query DRI image loader to obtain a DRIdrawable's buffers.
1409  *
1410  * To determine which DRI buffers to request, examine the renderbuffers
1411  * attached to the drawable's framebuffer. Then request the buffers from
1412  * the image loader
1413  *
1414  * This is called from intel_update_renderbuffers().
1415  *
1416  * \param drawable      Drawable whose buffers are queried.
1417  * \param buffers       [out] List of buffers returned by DRI2 query.
1418  * \param buffer_count  [out] Number of buffers returned.
1419  *
1420  * \see intel_update_renderbuffers()
1421  */
1422
1423 static void
1424 intel_update_image_buffer(struct brw_context *intel,
1425                           __DRIdrawable *drawable,
1426                           struct intel_renderbuffer *rb,
1427                           __DRIimage *buffer,
1428                           enum __DRIimageBufferMask buffer_type)
1429 {
1430    struct gl_framebuffer *fb = drawable->driverPrivate;
1431
1432    if (!rb || !buffer->bo)
1433       return;
1434
1435    unsigned num_samples = rb->Base.Base.NumSamples;
1436
1437    /* Check and see if we're already bound to the right
1438     * buffer object
1439     */
1440    struct intel_mipmap_tree *last_mt;
1441    if (num_samples == 0)
1442       last_mt = rb->mt;
1443    else
1444       last_mt = rb->singlesample_mt;
1445
1446    if (last_mt && last_mt->bo == buffer->bo)
1447       return;
1448
1449    intel_update_winsys_renderbuffer_miptree(intel, rb, buffer->bo,
1450                                             buffer->width, buffer->height,
1451                                             buffer->pitch);
1452
1453    if (brw_is_front_buffer_drawing(fb) &&
1454        buffer_type == __DRI_IMAGE_BUFFER_FRONT &&
1455        rb->Base.Base.NumSamples > 1) {
1456       intel_renderbuffer_upsample(intel, rb);
1457    }
1458 }
1459
1460 static void
1461 intel_update_image_buffers(struct brw_context *brw, __DRIdrawable *drawable)
1462 {
1463    struct gl_framebuffer *fb = drawable->driverPrivate;
1464    __DRIscreen *screen = brw->intelScreen->driScrnPriv;
1465    struct intel_renderbuffer *front_rb;
1466    struct intel_renderbuffer *back_rb;
1467    struct __DRIimageList images;
1468    unsigned int format;
1469    uint32_t buffer_mask = 0;
1470
1471    front_rb = intel_get_renderbuffer(fb, BUFFER_FRONT_LEFT);
1472    back_rb = intel_get_renderbuffer(fb, BUFFER_BACK_LEFT);
1473
1474    if (back_rb)
1475       format = intel_rb_format(back_rb);
1476    else if (front_rb)
1477       format = intel_rb_format(front_rb);
1478    else
1479       return;
1480
1481    if (front_rb && (brw_is_front_buffer_drawing(fb) ||
1482                     brw_is_front_buffer_reading(fb) || !back_rb)) {
1483       buffer_mask |= __DRI_IMAGE_BUFFER_FRONT;
1484    }
1485
1486    if (back_rb)
1487       buffer_mask |= __DRI_IMAGE_BUFFER_BACK;
1488
1489    (*screen->image.loader->getBuffers) (drawable,
1490                                         driGLFormatToImageFormat(format),
1491                                         &drawable->dri2.stamp,
1492                                         drawable->loaderPrivate,
1493                                         buffer_mask,
1494                                         &images);
1495
1496    if (images.image_mask & __DRI_IMAGE_BUFFER_FRONT) {
1497       drawable->w = images.front->width;
1498       drawable->h = images.front->height;
1499       intel_update_image_buffer(brw,
1500                                 drawable,
1501                                 front_rb,
1502                                 images.front,
1503                                 __DRI_IMAGE_BUFFER_FRONT);
1504    }
1505    if (images.image_mask & __DRI_IMAGE_BUFFER_BACK) {
1506       drawable->w = images.back->width;
1507       drawable->h = images.back->height;
1508       intel_update_image_buffer(brw,
1509                                 drawable,
1510                                 back_rb,
1511                                 images.back,
1512                                 __DRI_IMAGE_BUFFER_BACK);
1513    }
1514 }