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

   1 /*
   2  Copyright (C) Intel Corp.  2006.  All Rights Reserved.
   3  Intel funded Tungsten Graphics (http://www.tungstengraphics.com) to
   4  develop this 3D driver.
   5
   6  Permission is hereby granted, free of charge, to any person obtaining
   7  a 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, sublicense, 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
  16  portions of the Software.
  17
  18  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  19  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  21  IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
  22  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  23  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  24  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25
  26  **********************************************************************/
  27  /*
  28   * Authors:
  29   *   Keith Whitwell <keith@tungstengraphics.com>
  30   */
  31
  32
  33 #include "main/imports.h"
  34 #include "main/macros.h"
  35 #include "main/simple_list.h"
  36
  37 #include "vbo/vbo_context.h"
  38
  39 #include "brw_context.h"
  40 #include "brw_defines.h"
  41 #include "brw_draw.h"
  42 #include "brw_state.h"
  43
  44 #include "intel_fbo.h"
  45 #include "intel_mipmap_tree.h"
  46 #include "intel_regions.h"
  47 #include "intel_span.h"
  48 #include "intel_tex.h"
  49 #include "intel_tex_obj.h"
  50
  51 #include "tnl/t_pipeline.h"
  52 #include "glsl/ralloc.h"
  53
  54 /***************************************
  55  * Mesa's Driver Functions
  56  ***************************************/
  57
  58 static void brwInitDriverFunctions(struct intel_screen *screen,
  59                                    struct dd_function_table *functions)
  60 {
  61    intelInitDriverFunctions( functions );
  62
  63    brwInitFragProgFuncs( functions );
  64    brw_init_queryobj_functions(functions);
  65
  66    functions->BeginTransformFeedback = brw_begin_transform_feedback;
  67
  68    if (screen->gen >= 7)
  69       functions->EndTransformFeedback = gen7_end_transform_feedback;
  70    else
  71       functions->EndTransformFeedback = brw_end_transform_feedback;
  72 }
  73
  74 bool
  75 brwCreateContext(int api,
  76                  const struct gl_config *mesaVis,
  77                  __DRIcontext *driContextPriv,
  78                  unsigned major_version,
  79                  unsigned minor_version,
  80                  uint32_t flags,
  81                  unsigned *error,
  82                  void *sharedContextPrivate)
  83 {
  84    __DRIscreen *sPriv = driContextPriv->driScreenPriv;
  85    struct intel_screen *screen = sPriv->driverPrivate;
  86    struct dd_function_table functions;
  87    unsigned i;
  88
  89    /* Filter against the requested API and version.
  90     */
  91    switch (api) {
  92    case API_OPENGL: {
  93 #ifdef TEXTURE_FLOAT_ENABLED
  94       const unsigned max_version =
  95          (screen->gen == 6 ||
  96           (screen->gen == 7 && screen->kernel_has_gen7_sol_reset))
  97          ? 30 : 21;
  98 #else
  99       const unsigned max_version = 21;
 100 #endif
 101       const unsigned req_version = major_version * 10 + minor_version;
 102
 103       if (req_version > max_version) {
 104          *error = __DRI_CTX_ERROR_BAD_VERSION;
 105          return false;
 106       }
 107       break;
 108    }
 109    case API_OPENGLES:
 110    case API_OPENGLES2:
 111       break;
 112    case API_OPENGL_CORE: {
 113 #ifdef TEXTURE_FLOAT_ENABLED
 114       const unsigned max_version =
 115          (screen->gen == 6 ||
 116           (screen->gen == 7 && screen->kernel_has_gen7_sol_reset))
 117          ? 31 : 0;
 118       const unsigned req_version = major_version * 10 + minor_version;
 119
 120       if (req_version > max_version) {
 121          *error = (max_version == 0)
 122             ? __DRI_CTX_ERROR_BAD_API : __DRI_CTX_ERROR_BAD_VERSION;
 123          return false;
 124       }
 125       break;
 126 #else
 127       *error = __DRI_CTX_ERROR_BAD_API;
 128       return false;
 129 #endif
 130    }
 131    default:
 132       *error = __DRI_CTX_ERROR_BAD_API;
 133       return false;
 134    }
 135
 136    struct brw_context *brw = rzalloc(NULL, struct brw_context);
 137    if (!brw) {
 138       printf("%s: failed to alloc context\n", __FUNCTION__);
 139       *error = __DRI_CTX_ERROR_NO_MEMORY;
 140       return false;
 141    }
 142
 143    brwInitDriverFunctions(screen, &functions);
 144
 145    struct intel_context *intel = &brw->intel;
 146    struct gl_context *ctx = &intel->ctx;
 147
 148    if (!intelInitContext( intel, api, mesaVis, driContextPriv,
 149                           sharedContextPrivate, &functions )) {
 150       printf("%s: failed to init intel context\n", __FUNCTION__);
 151       FREE(brw);
 152       *error = __DRI_CTX_ERROR_NO_MEMORY;
 153       return false;
 154    }
 155
 156    brwInitVtbl( brw );
 157
 158    brw_init_surface_formats(brw);
 159
 160    /* Initialize swrast, tnl driver tables: */
 161    intelInitSpanFuncs(ctx);
 162
 163    TNLcontext *tnl = TNL_CONTEXT(ctx);
 164    if (tnl)
 165       tnl->Driver.RunPipeline = _tnl_run_pipeline;
 166
 167    ctx->Const.MaxDualSourceDrawBuffers = 1;
 168    ctx->Const.MaxDrawBuffers = BRW_MAX_DRAW_BUFFERS;
 169    ctx->Const.MaxTextureImageUnits = BRW_MAX_TEX_UNIT;
 170    ctx->Const.MaxTextureCoordUnits = 8; /* Mesa limit */
 171    ctx->Const.MaxTextureUnits = MIN2(ctx->Const.MaxTextureCoordUnits,
 172                                      ctx->Const.MaxTextureImageUnits);
 173    ctx->Const.MaxVertexTextureImageUnits = BRW_MAX_TEX_UNIT;
 174    ctx->Const.MaxCombinedTextureImageUnits =
 175       ctx->Const.MaxVertexTextureImageUnits +
 176       ctx->Const.MaxTextureImageUnits;
 177
 178    ctx->Const.MaxTextureLevels = 14; /* 8192 */
 179    if (ctx->Const.MaxTextureLevels > MAX_TEXTURE_LEVELS)
 180            ctx->Const.MaxTextureLevels = MAX_TEXTURE_LEVELS;
 181    ctx->Const.Max3DTextureLevels = 9;
 182    ctx->Const.MaxCubeTextureLevels = 12;
 183
 184    if (intel->gen >= 7)
 185       ctx->Const.MaxArrayTextureLayers = 2048;
 186    else
 187       ctx->Const.MaxArrayTextureLayers = 512;
 188
 189    ctx->Const.MaxTextureRectSize = (1<<12);
 190
 191    ctx->Const.MaxTextureMaxAnisotropy = 16.0;
 192
 193    /* Hardware only supports a limited number of transform feedback buffers.
 194     * So we need to override the Mesa default (which is based only on software
 195     * limits).
 196     */
 197    ctx->Const.MaxTransformFeedbackBuffers = BRW_MAX_SOL_BUFFERS;
 198
 199    /* On Gen6, in the worst case, we use up one binding table entry per
 200     * transform feedback component (see comments above the definition of
 201     * BRW_MAX_SOL_BINDINGS, in brw_context.h), so we need to advertise a value
 202     * for MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS equal to
 203     * BRW_MAX_SOL_BINDINGS.
 204     *
 205     * In "separate components" mode, we need to divide this value by
 206     * BRW_MAX_SOL_BUFFERS, so that the total number of binding table entries
 207     * used up by all buffers will not exceed BRW_MAX_SOL_BINDINGS.
 208     */
 209    ctx->Const.MaxTransformFeedbackInterleavedComponents = BRW_MAX_SOL_BINDINGS;
 210    ctx->Const.MaxTransformFeedbackSeparateComponents =
 211       BRW_MAX_SOL_BINDINGS / BRW_MAX_SOL_BUFFERS;
 212
 213    if (intel->gen == 6)
 214       ctx->Const.MaxSamples = 4;
 215    else if (intel->gen >= 7)
 216       ctx->Const.MaxSamples = 8;
 217
 218    /* if conformance mode is set, swrast can handle any size AA point */
 219    ctx->Const.MaxPointSizeAA = 255.0;
 220
 221    /* We want the GLSL compiler to emit code that uses condition codes */
 222    for (i = 0; i <= MESA_SHADER_FRAGMENT; i++) {
 223       ctx->ShaderCompilerOptions[i].MaxIfDepth = intel->gen < 6 ? 16 : UINT_MAX;
 224       ctx->ShaderCompilerOptions[i].EmitCondCodes = true;
 225       ctx->ShaderCompilerOptions[i].EmitNVTempInitialization = true;
 226       ctx->ShaderCompilerOptions[i].EmitNoNoise = true;
 227       ctx->ShaderCompilerOptions[i].EmitNoMainReturn = true;
 228       ctx->ShaderCompilerOptions[i].EmitNoIndirectInput = true;
 229       ctx->ShaderCompilerOptions[i].EmitNoIndirectOutput = true;
 230
 231       ctx->ShaderCompilerOptions[i].EmitNoIndirectUniform =
 232          (i == MESA_SHADER_FRAGMENT);
 233       ctx->ShaderCompilerOptions[i].EmitNoIndirectTemp =
 234          (i == MESA_SHADER_FRAGMENT);
 235       ctx->ShaderCompilerOptions[i].LowerClipDistance = true;
 236    }
 237
 238    ctx->Const.VertexProgram.MaxNativeInstructions = (16 * 1024);
 239    ctx->Const.VertexProgram.MaxAluInstructions = 0;
 240    ctx->Const.VertexProgram.MaxTexInstructions = 0;
 241    ctx->Const.VertexProgram.MaxTexIndirections = 0;
 242    ctx->Const.VertexProgram.MaxNativeAluInstructions = 0;
 243    ctx->Const.VertexProgram.MaxNativeTexInstructions = 0;
 244    ctx->Const.VertexProgram.MaxNativeTexIndirections = 0;
 245    ctx->Const.VertexProgram.MaxNativeAttribs = 16;
 246    ctx->Const.VertexProgram.MaxNativeTemps = 256;
 247    ctx->Const.VertexProgram.MaxNativeAddressRegs = 1;
 248    ctx->Const.VertexProgram.MaxNativeParameters = 1024;
 249    ctx->Const.VertexProgram.MaxEnvParams =
 250       MIN2(ctx->Const.VertexProgram.MaxNativeParameters,
 251            ctx->Const.VertexProgram.MaxEnvParams);
 252
 253    ctx->Const.FragmentProgram.MaxNativeInstructions = (16 * 1024);
 254    ctx->Const.FragmentProgram.MaxNativeAluInstructions = (16 * 1024);
 255    ctx->Const.FragmentProgram.MaxNativeTexInstructions = (16 * 1024);
 256    ctx->Const.FragmentProgram.MaxNativeTexIndirections = (16 * 1024);
 257    ctx->Const.FragmentProgram.MaxNativeAttribs = 12;
 258    ctx->Const.FragmentProgram.MaxNativeTemps = 256;
 259    ctx->Const.FragmentProgram.MaxNativeAddressRegs = 0;
 260    ctx->Const.FragmentProgram.MaxNativeParameters = 1024;
 261    ctx->Const.FragmentProgram.MaxEnvParams =
 262       MIN2(ctx->Const.FragmentProgram.MaxNativeParameters,
 263            ctx->Const.FragmentProgram.MaxEnvParams);
 264
 265    /* Fragment shaders use real, 32-bit twos-complement integers for all
 266     * integer types.
 267     */
 268    ctx->Const.FragmentProgram.LowInt.RangeMin = 31;
 269    ctx->Const.FragmentProgram.LowInt.RangeMax = 30;
 270    ctx->Const.FragmentProgram.LowInt.Precision = 0;
 271    ctx->Const.FragmentProgram.HighInt = ctx->Const.FragmentProgram.MediumInt
 272       = ctx->Const.FragmentProgram.LowInt;
 273
 274    /* Gen6 converts quads to polygon in beginning of 3D pipeline,
 275       but we're not sure how it's actually done for vertex order,
 276       that affect provoking vertex decision. Always use last vertex
 277       convention for quad primitive which works as expected for now. */
 278    if (intel->gen >= 6)
 279        ctx->Const.QuadsFollowProvokingVertexConvention = false;
 280
 281    ctx->Const.QueryCounterBits.Timestamp = 36;
 282
 283    if (intel->is_g4x || intel->gen >= 5) {
 284       brw->CMD_VF_STATISTICS = GM45_3DSTATE_VF_STATISTICS;
 285       brw->CMD_PIPELINE_SELECT = CMD_PIPELINE_SELECT_GM45;
 286       brw->has_surface_tile_offset = true;
 287       if (intel->gen < 6)
 288           brw->has_compr4 = true;
 289       brw->has_aa_line_parameters = true;
 290       brw->has_pln = true;
 291   } else {
 292       brw->CMD_VF_STATISTICS = GEN4_3DSTATE_VF_STATISTICS;
 293       brw->CMD_PIPELINE_SELECT = CMD_PIPELINE_SELECT_965;
 294    }
 295
 296    /* WM maximum threads is number of EUs times number of threads per EU. */
 297    if (intel->gen >= 7) {
 298       if (intel->gt == 1) {
 299          brw->max_wm_threads = 48;
 300          brw->max_vs_threads = 36;
 301          brw->max_gs_threads = 36;
 302          brw->urb.size = 128;
 303          brw->urb.max_vs_entries = 512;
 304          brw->urb.max_gs_entries = 192;
 305       } else if (intel->gt == 2) {
 306          brw->max_wm_threads = 172;
 307          brw->max_vs_threads = 128;
 308          brw->max_gs_threads = 128;
 309          brw->urb.size = 256;
 310          brw->urb.max_vs_entries = 704;
 311          brw->urb.max_gs_entries = 320;
 312       } else {
 313          assert(!"Unknown gen7 device.");
 314       }
 315    } else if (intel->gen == 6) {
 316       if (intel->gt == 2) {
 317          brw->max_wm_threads = 80;
 318          brw->max_vs_threads = 60;
 319          brw->max_gs_threads = 60;
 320          brw->urb.size = 64;            /* volume 5c.5 section 5.1 */
 321          brw->urb.max_vs_entries = 256; /* volume 2a (see 3DSTATE_URB) */
 322          brw->urb.max_gs_entries = 256;
 323       } else {
 324          brw->max_wm_threads = 40;
 325          brw->max_vs_threads = 24;
 326          brw->max_gs_threads = 21; /* conservative; 24 if rendering disabled */
 327          brw->urb.size = 32;            /* volume 5c.5 section 5.1 */
 328          brw->urb.max_vs_entries = 256; /* volume 2a (see 3DSTATE_URB) */
 329          brw->urb.max_gs_entries = 256;
 330       }
 331       brw->urb.gen6_gs_previously_active = false;
 332    } else if (intel->gen == 5) {
 333       brw->urb.size = 1024;
 334       brw->max_vs_threads = 72;
 335       brw->max_gs_threads = 32;
 336       brw->max_wm_threads = 12 * 6;
 337    } else if (intel->is_g4x) {
 338       brw->urb.size = 384;
 339       brw->max_vs_threads = 32;
 340       brw->max_gs_threads = 2;
 341       brw->max_wm_threads = 10 * 5;
 342    } else if (intel->gen < 6) {
 343       brw->urb.size = 256;
 344       brw->max_vs_threads = 16;
 345       brw->max_gs_threads = 2;
 346       brw->max_wm_threads = 8 * 4;
 347       brw->has_negative_rhw_bug = true;
 348    }
 349
 350    if (intel->gen <= 7) {
 351       brw->needs_unlit_centroid_workaround = true;
 352    }
 353
 354    brw->prim_restart.in_progress = false;
 355    brw->prim_restart.enable_cut_index = false;
 356    intel->hw_ctx = drm_intel_gem_context_create(intel->bufmgr);
 357
 358    brw_init_state( brw );
 359
 360    brw->curbe.last_buf = calloc(1, 4096);
 361    brw->curbe.next_buf = calloc(1, 4096);
 362
 363    brw->state.dirty.mesa = ~0;
 364    brw->state.dirty.brw = ~0;
 365
 366    brw->emit_state_always = 0;
 367
 368    intel->batch.need_workaround_flush = true;
 369
 370    ctx->VertexProgram._MaintainTnlProgram = true;
 371    ctx->FragmentProgram._MaintainTexEnvProgram = true;
 372
 373    brw_draw_init( brw );
 374
 375    brw->precompile = driQueryOptionb(&intel->optionCache, "shader_precompile");
 376
 377    ctx->Const.NativeIntegers = true;
 378    ctx->Const.UniformBooleanTrue = 1;
 379
 380    ctx->Const.ForceGLSLExtensionsWarn = driQueryOptionb(&intel->optionCache, "force_glsl_extensions_warn");
 381
 382    ctx->Const.ContextFlags = 0;
 383    if ((flags & __DRI_CTX_FLAG_FORWARD_COMPATIBLE) != 0)
 384       ctx->Const.ContextFlags |= GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT;
 385
 386    if ((flags & __DRI_CTX_FLAG_DEBUG) != 0)
 387       ctx->Const.ContextFlags |= GL_CONTEXT_FLAG_DEBUG_BIT;
 388
 389    return true;
 390 }
 391