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

   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 #ifndef BRWCONTEXT_INC
  34 #define BRWCONTEXT_INC
  35
  36 #include "intel_context.h"
  37 #include "brw_structs.h"
  38 #include "main/imports.h"
  39
  40
  41 /* Glossary:
  42  *
  43  * URB - uniform resource buffer.  A mid-sized buffer which is
  44  * partitioned between the fixed function units and used for passing
  45  * values (vertices, primitives, constants) between them.
  46  *
  47  * CURBE - constant URB entry.  An urb region (entry) used to hold
  48  * constant values which the fixed function units can be instructed to
  49  * preload into the GRF when spawning a thread.
  50  *
  51  * VUE - vertex URB entry.  An urb entry holding a vertex and usually
  52  * a vertex header.  The header contains control information and
  53  * things like primitive type, Begin/end flags and clip codes.
  54  *
  55  * PUE - primitive URB entry.  An urb entry produced by the setup (SF)
  56  * unit holding rasterization and interpolation parameters.
  57  *
  58  * GRF - general register file.  One of several register files
  59  * addressable by programmed threads.  The inputs (r0, payload, curbe,
  60  * urb) of the thread are preloaded to this area before the thread is
  61  * spawned.  The registers are individually 8 dwords wide and suitable
  62  * for general usage.  Registers holding thread input values are not
  63  * special and may be overwritten.
  64  *
  65  * MRF - message register file.  Threads communicate (and terminate)
  66  * by sending messages.  Message parameters are placed in contiguous
  67  * MRF registers.  All program output is via these messages.  URB
  68  * entries are populated by sending a message to the shared URB
  69  * function containing the new data, together with a control word,
  70  * often an unmodified copy of R0.
  71  *
  72  * R0 - GRF register 0.  Typically holds control information used when
  73  * sending messages to other threads.
  74  *
  75  * EU or GEN4 EU: The name of the programmable subsystem of the
  76  * i965 hardware.  Threads are executed by the EU, the registers
  77  * described above are part of the EU architecture.
  78  *
  79  * Fixed function units:
  80  *
  81  * CS - Command streamer.  Notional first unit, little software
  82  * interaction.  Holds the URB entries used for constant data, ie the
  83  * CURBEs.
  84  *
  85  * VF/VS - Vertex Fetch / Vertex Shader.  The fixed function part of
  86  * this unit is responsible for pulling vertices out of vertex buffers
  87  * in vram and injecting them into the processing pipe as VUEs.  If
  88  * enabled, it first passes them to a VS thread which is a good place
  89  * for the driver to implement any active vertex shader.
  90  *
  91  * GS - Geometry Shader.  This corresponds to a new DX10 concept.  If
  92  * enabled, incoming strips etc are passed to GS threads in individual
  93  * line/triangle/point units.  The GS thread may perform arbitary
  94  * computation and emit whatever primtives with whatever vertices it
  95  * chooses.  This makes GS an excellent place to implement GL's
  96  * unfilled polygon modes, though of course it is capable of much
  97  * more.  Additionally, GS is used to translate away primitives not
  98  * handled by latter units, including Quads and Lineloops.
  99  *
 100  * CS - Clipper.  Mesa's clipping algorithms are imported to run on
 101  * this unit.  The fixed function part performs cliptesting against
 102  * the 6 fixed clipplanes and makes descisions on whether or not the
 103  * incoming primitive needs to be passed to a thread for clipping.
 104  * User clip planes are handled via cooperation with the VS thread.
 105  *
 106  * SF - Strips Fans or Setup: Triangles are prepared for
 107  * rasterization.  Interpolation coefficients are calculated.
 108  * Flatshading and two-side lighting usually performed here.
 109  *
 110  * WM - Windower.  Interpolation of vertex attributes performed here.
 111  * Fragment shader implemented here.  SIMD aspects of EU taken full
 112  * advantage of, as pixels are processed in blocks of 16.
 113  *
 114  * CC - Color Calculator.  No EU threads associated with this unit.
 115  * Handles blending and (presumably) depth and stencil testing.
 116  */
 117
 118
 119 #define BRW_MAX_CURBE                    (32*16)
 120
 121 struct brw_context;
 122
 123 enum brw_state_id {
 124    BRW_STATE_URB_FENCE,
 125    BRW_STATE_FRAGMENT_PROGRAM,
 126    BRW_STATE_VERTEX_PROGRAM,
 127    BRW_STATE_INPUT_DIMENSIONS,
 128    BRW_STATE_CURBE_OFFSETS,
 129    BRW_STATE_REDUCED_PRIMITIVE,
 130    BRW_STATE_PRIMITIVE,
 131    BRW_STATE_CONTEXT,
 132    BRW_STATE_WM_INPUT_DIMENSIONS,
 133    BRW_STATE_PSP,
 134    BRW_STATE_WM_SURFACES,
 135    BRW_STATE_VS_BINDING_TABLE,
 136    BRW_STATE_GS_BINDING_TABLE,
 137    BRW_STATE_PS_BINDING_TABLE,
 138    BRW_STATE_INDICES,
 139    BRW_STATE_VERTICES,
 140    BRW_STATE_BATCH,
 141    BRW_STATE_NR_WM_SURFACES,
 142    BRW_STATE_NR_VS_SURFACES,
 143    BRW_STATE_INDEX_BUFFER,
 144    BRW_STATE_VS_CONSTBUF,
 145    BRW_STATE_WM_CONSTBUF,
 146    BRW_STATE_PROGRAM_CACHE,
 147    BRW_STATE_STATE_BASE_ADDRESS,
 148 };
 149
 150 #define BRW_NEW_URB_FENCE               (1 << BRW_STATE_URB_FENCE)
 151 #define BRW_NEW_FRAGMENT_PROGRAM        (1 << BRW_STATE_FRAGMENT_PROGRAM)
 152 #define BRW_NEW_VERTEX_PROGRAM          (1 << BRW_STATE_VERTEX_PROGRAM)
 153 #define BRW_NEW_INPUT_DIMENSIONS        (1 << BRW_STATE_INPUT_DIMENSIONS)
 154 #define BRW_NEW_CURBE_OFFSETS           (1 << BRW_STATE_CURBE_OFFSETS)
 155 #define BRW_NEW_REDUCED_PRIMITIVE       (1 << BRW_STATE_REDUCED_PRIMITIVE)
 156 #define BRW_NEW_PRIMITIVE               (1 << BRW_STATE_PRIMITIVE)
 157 #define BRW_NEW_CONTEXT                 (1 << BRW_STATE_CONTEXT)
 158 #define BRW_NEW_WM_INPUT_DIMENSIONS     (1 << BRW_STATE_WM_INPUT_DIMENSIONS)
 159 #define BRW_NEW_PSP                     (1 << BRW_STATE_PSP)
 160 #define BRW_NEW_WM_SURFACES             (1 << BRW_STATE_WM_SURFACES)
 161 #define BRW_NEW_VS_BINDING_TABLE        (1 << BRW_STATE_VS_BINDING_TABLE)
 162 #define BRW_NEW_GS_BINDING_TABLE        (1 << BRW_STATE_GS_BINDING_TABLE)
 163 #define BRW_NEW_PS_BINDING_TABLE        (1 << BRW_STATE_PS_BINDING_TABLE)
 164 #define BRW_NEW_INDICES                 (1 << BRW_STATE_INDICES)
 165 #define BRW_NEW_VERTICES                (1 << BRW_STATE_VERTICES)
 166 /**
 167  * Used for any batch entry with a relocated pointer that will be used
 168  * by any 3D rendering.
 169  */
 170 #define BRW_NEW_BATCH                  (1 << BRW_STATE_BATCH)
 171 /** \see brw.state.depth_region */
 172 #define BRW_NEW_NR_WM_SURFACES         (1 << BRW_STATE_NR_WM_SURFACES)
 173 #define BRW_NEW_NR_VS_SURFACES         (1 << BRW_STATE_NR_VS_SURFACES)
 174 #define BRW_NEW_INDEX_BUFFER           (1 << BRW_STATE_INDEX_BUFFER)
 175 #define BRW_NEW_VS_CONSTBUF            (1 << BRW_STATE_VS_CONSTBUF)
 176 #define BRW_NEW_WM_CONSTBUF            (1 << BRW_STATE_WM_CONSTBUF)
 177 #define BRW_NEW_PROGRAM_CACHE           (1 << BRW_STATE_PROGRAM_CACHE)
 178 #define BRW_NEW_STATE_BASE_ADDRESS      (1 << BRW_STATE_STATE_BASE_ADDRESS)
 179
 180 struct brw_state_flags {
 181    /** State update flags signalled by mesa internals */
 182    GLuint mesa;
 183    /**
 184     * State update flags signalled as the result of brw_tracked_state updates
 185     */
 186    GLuint brw;
 187    /** State update flags signalled by brw_state_cache.c searches */
 188    GLuint cache;
 189 };
 190
 191
 192 /** Subclass of Mesa vertex program */
 193 struct brw_vertex_program {
 194    struct gl_vertex_program program;
 195    GLuint id;
 196    GLboolean use_const_buffer;
 197 };
 198
 199
 200 /** Subclass of Mesa fragment program */
 201 struct brw_fragment_program {
 202    struct gl_fragment_program program;
 203    GLuint id;  /**< serial no. to identify frag progs, never re-used */
 204
 205    /** for debugging, which texture units are referenced */
 206    GLbitfield tex_units_used;
 207 };
 208
 209 struct brw_shader {
 210    struct gl_shader base;
 211
 212    /** Shader IR transformed for native compile, at link time. */
 213    struct exec_list *ir;
 214 };
 215
 216 struct brw_shader_program {
 217    struct gl_shader_program base;
 218 };
 219
 220 enum param_conversion {
 221    PARAM_NO_CONVERT,
 222    PARAM_CONVERT_F2I,
 223    PARAM_CONVERT_F2U,
 224    PARAM_CONVERT_F2B,
 225 };
 226
 227 /* Data about a particular attempt to compile a program.  Note that
 228  * there can be many of these, each in a different GL state
 229  * corresponding to a different brw_wm_prog_key struct, with different
 230  * compiled programs:
 231  */
 232 struct brw_wm_prog_data {
 233    GLuint curb_read_length;
 234    GLuint urb_read_length;
 235
 236    GLuint first_curbe_grf;
 237    GLuint first_curbe_grf_16;
 238    GLuint reg_blocks;
 239    GLuint reg_blocks_16;
 240    GLuint total_scratch;
 241
 242    GLuint nr_params;       /**< number of float params/constants */
 243    GLuint nr_pull_params;
 244    GLboolean error;
 245    int dispatch_width;
 246    uint32_t prog_offset_16;
 247
 248    /* Pointer to tracked values (only valid once
 249     * _mesa_load_state_parameters has been called at runtime).
 250     */
 251    const float *param[MAX_UNIFORMS * 4]; /* should be: BRW_MAX_CURBE */
 252    enum param_conversion param_convert[MAX_UNIFORMS * 4];
 253    const float *pull_param[MAX_UNIFORMS * 4];
 254    enum param_conversion pull_param_convert[MAX_UNIFORMS * 4];
 255 };
 256
 257 struct brw_sf_prog_data {
 258    GLuint urb_read_length;
 259    GLuint total_grf;
 260
 261    /* Each vertex may have upto 12 attributes, 4 components each,
 262     * except WPOS which requires only 2.  (11*4 + 2) == 44 ==> 11
 263     * rows.
 264     *
 265     * Actually we use 4 for each, so call it 12 rows.
 266     */
 267    GLuint urb_entry_size;
 268 };
 269
 270 struct brw_clip_prog_data {
 271    GLuint curb_read_length;     /* user planes? */
 272    GLuint clip_mode;
 273    GLuint urb_read_length;
 274    GLuint total_grf;
 275 };
 276
 277 struct brw_gs_prog_data {
 278    GLuint urb_read_length;
 279    GLuint total_grf;
 280 };
 281
 282 struct brw_vs_prog_data {
 283    GLuint curb_read_length;
 284    GLuint urb_read_length;
 285    GLuint total_grf;
 286    GLbitfield64 outputs_written;
 287    GLuint nr_params;       /**< number of float params/constants */
 288
 289    GLuint inputs_read;
 290
 291    /* Used for calculating urb partitions:
 292     */
 293    GLuint urb_entry_size;
 294 };
 295
 296
 297 /* Size == 0 if output either not written, or always [0,0,0,1]
 298  */
 299 struct brw_vs_ouput_sizes {
 300    GLubyte output_size[VERT_RESULT_MAX];
 301 };
 302
 303
 304 /** Number of texture sampler units */
 305 #define BRW_MAX_TEX_UNIT 16
 306
 307 /** Max number of render targets in a shader */
 308 #define BRW_MAX_DRAW_BUFFERS 8
 309
 310 /**
 311  * Size of our surface binding table for the WM.
 312  * This contains pointers to the drawing surfaces and current texture
 313  * objects and shader constant buffers (+2).
 314  */
 315 #define BRW_WM_MAX_SURF (BRW_MAX_DRAW_BUFFERS + BRW_MAX_TEX_UNIT + 1)
 316
 317 /**
 318  * Helpers to convert drawing buffers, textures and constant buffers
 319  * to surface binding table indexes, for WM.
 320  */
 321 #define SURF_INDEX_DRAW(d)           (d)
 322 #define SURF_INDEX_FRAG_CONST_BUFFER (BRW_MAX_DRAW_BUFFERS)
 323 #define SURF_INDEX_TEXTURE(t)        (BRW_MAX_DRAW_BUFFERS + 1 + (t))
 324
 325 /**
 326  * Size of surface binding table for the VS.
 327  * Only one constant buffer for now.
 328  */
 329 #define BRW_VS_MAX_SURF 1
 330
 331 /**
 332  * Only a VS constant buffer
 333  */
 334 #define SURF_INDEX_VERT_CONST_BUFFER 0
 335
 336
 337 enum brw_cache_id {
 338    BRW_BLEND_STATE,
 339    BRW_DEPTH_STENCIL_STATE,
 340    BRW_COLOR_CALC_STATE,
 341    BRW_CC_VP,
 342    BRW_CC_UNIT,
 343    BRW_WM_PROG,
 344    BRW_SAMPLER,
 345    BRW_WM_UNIT,
 346    BRW_SF_PROG,
 347    BRW_SF_VP,
 348    BRW_SF_UNIT, /* scissor state on gen6 */
 349    BRW_VS_UNIT,
 350    BRW_VS_PROG,
 351    BRW_GS_UNIT,
 352    BRW_GS_PROG,
 353    BRW_CLIP_VP,
 354    BRW_CLIP_UNIT,
 355    BRW_CLIP_PROG,
 356
 357    BRW_MAX_CACHE
 358 };
 359
 360 struct brw_cache_item {
 361    /**
 362     * Effectively part of the key, cache_id identifies what kind of state
 363     * buffer is involved, and also which brw->state.dirty.cache flag should
 364     * be set when this cache item is chosen.
 365     */
 366    enum brw_cache_id cache_id;
 367    /** 32-bit hash of the key data */
 368    GLuint hash;
 369    GLuint key_size;             /* for variable-sized keys */
 370    GLuint aux_size;
 371    const void *key;
 372
 373    uint32_t offset;
 374    uint32_t size;
 375
 376    struct brw_cache_item *next;
 377 };
 378
 379
 380
 381 struct brw_cache {
 382    struct brw_context *brw;
 383
 384    struct brw_cache_item **items;
 385    drm_intel_bo *bo;
 386    GLuint size, n_items;
 387
 388    uint32_t next_offset;
 389    bool bo_used_by_gpu;
 390 };
 391
 392
 393 /* Considered adding a member to this struct to document which flags
 394  * an update might raise so that ordering of the state atoms can be
 395  * checked or derived at runtime.  Dropped the idea in favor of having
 396  * a debug mode where the state is monitored for flags which are
 397  * raised that have already been tested against.
 398  */
 399 struct brw_tracked_state {
 400    struct brw_state_flags dirty;
 401    void (*prepare)( struct brw_context *brw );
 402    void (*emit)( struct brw_context *brw );
 403 };
 404
 405 /* Flags for brw->state.cache.
 406  */
 407 #define CACHE_NEW_BLEND_STATE            (1<<BRW_BLEND_STATE)
 408 #define CACHE_NEW_DEPTH_STENCIL_STATE    (1<<BRW_DEPTH_STENCIL_STATE)
 409 #define CACHE_NEW_COLOR_CALC_STATE       (1<<BRW_COLOR_CALC_STATE)
 410 #define CACHE_NEW_CC_VP                  (1<<BRW_CC_VP)
 411 #define CACHE_NEW_CC_UNIT                (1<<BRW_CC_UNIT)
 412 #define CACHE_NEW_WM_PROG                (1<<BRW_WM_PROG)
 413 #define CACHE_NEW_SAMPLER                (1<<BRW_SAMPLER)
 414 #define CACHE_NEW_WM_UNIT                (1<<BRW_WM_UNIT)
 415 #define CACHE_NEW_SF_PROG                (1<<BRW_SF_PROG)
 416 #define CACHE_NEW_SF_VP                  (1<<BRW_SF_VP)
 417 #define CACHE_NEW_SF_UNIT                (1<<BRW_SF_UNIT)
 418 #define CACHE_NEW_VS_UNIT                (1<<BRW_VS_UNIT)
 419 #define CACHE_NEW_VS_PROG                (1<<BRW_VS_PROG)
 420 #define CACHE_NEW_GS_UNIT                (1<<BRW_GS_UNIT)
 421 #define CACHE_NEW_GS_PROG                (1<<BRW_GS_PROG)
 422 #define CACHE_NEW_CLIP_VP                (1<<BRW_CLIP_VP)
 423 #define CACHE_NEW_CLIP_UNIT              (1<<BRW_CLIP_UNIT)
 424 #define CACHE_NEW_CLIP_PROG              (1<<BRW_CLIP_PROG)
 425
 426 struct brw_cached_batch_item {
 427    struct header *header;
 428    GLuint sz;
 429    struct brw_cached_batch_item *next;
 430 };
 431
 432
 433
 434 /* Protect against a future where VERT_ATTRIB_MAX > 32.  Wouldn't life
 435  * be easier if C allowed arrays of packed elements?
 436  */
 437 #define ATTRIB_BIT_DWORDS  ((VERT_ATTRIB_MAX+31)/32)
 438
 439 struct brw_vertex_buffer {
 440    /** Buffer object containing the uploaded vertex data */
 441    drm_intel_bo *bo;
 442    uint32_t offset;
 443    /** Byte stride between elements in the uploaded array */
 444    GLuint stride;
 445 };
 446 struct brw_vertex_element {
 447    const struct gl_client_array *glarray;
 448
 449    int buffer;
 450
 451    /** The corresponding Mesa vertex attribute */
 452    gl_vert_attrib attrib;
 453    /** Size of a complete element */
 454    GLuint element_size;
 455    /** Offset of the first element within the buffer object */
 456    unsigned int offset;
 457 };
 458
 459
 460
 461 struct brw_vertex_info {
 462    GLuint sizes[ATTRIB_BIT_DWORDS * 2]; /* sizes:2[VERT_ATTRIB_MAX] */
 463 };
 464
 465 struct brw_query_object {
 466    struct gl_query_object Base;
 467
 468    /** Last query BO associated with this query. */
 469    drm_intel_bo *bo;
 470    /** First index in bo with query data for this object. */
 471    int first_index;
 472    /** Last index in bo with query data for this object. */
 473    int last_index;
 474 };
 475
 476
 477 /**
 478  * brw_context is derived from intel_context.
 479  */
 480 struct brw_context
 481 {
 482    struct intel_context intel;  /**< base class, must be first field */
 483    GLuint primitive;
 484
 485    GLboolean emit_state_always;
 486    GLboolean has_surface_tile_offset;
 487    GLboolean has_compr4;
 488    GLboolean has_negative_rhw_bug;
 489    GLboolean has_aa_line_parameters;
 490    GLboolean has_pln;
 491
 492    struct {
 493       struct brw_state_flags dirty;
 494       /**
 495        * List of buffers accumulated in brw_validate_state to receive
 496        * drm_intel_bo_check_aperture treatment before exec, so we can
 497        * know if we should flush the batch and try again before
 498        * emitting primitives.
 499        *
 500        * This can be a fixed number as we only have a limited number of
 501        * objects referenced from the batchbuffer in a primitive emit,
 502        * consisting of the vertex buffers, pipelined state pointers,
 503        * the CURBE, the depth buffer, and a query BO.
 504        */
 505       drm_intel_bo *validated_bos[VERT_ATTRIB_MAX + BRW_WM_MAX_SURF + 16];
 506       int validated_bo_count;
 507    } state;
 508
 509    struct brw_cache cache;
 510    struct brw_cached_batch_item *cached_batch_items;
 511
 512    struct {
 513       struct brw_vertex_element inputs[VERT_ATTRIB_MAX];
 514       struct brw_vertex_buffer buffers[VERT_ATTRIB_MAX];
 515       struct {
 516               uint32_t handle;
 517               uint32_t offset;
 518               uint32_t stride;
 519       } current_buffers[VERT_ATTRIB_MAX];
 520
 521       struct brw_vertex_element *enabled[VERT_ATTRIB_MAX];
 522       GLuint nr_enabled;
 523       GLuint nr_buffers, nr_current_buffers;
 524
 525       /* Summary of size and varying of active arrays, so we can check
 526        * for changes to this state:
 527        */
 528       struct brw_vertex_info info;
 529       unsigned int min_index, max_index;
 530
 531       /* Offset from start of vertex buffer so we can avoid redefining
 532        * the same VB packed over and over again.
 533        */
 534       unsigned int start_vertex_bias;
 535    } vb;
 536
 537    struct {
 538       /**
 539        * Index buffer for this draw_prims call.
 540        *
 541        * Updates are signaled by BRW_NEW_INDICES.
 542        */
 543       const struct _mesa_index_buffer *ib;
 544
 545       /* Updates are signaled by BRW_NEW_INDEX_BUFFER. */
 546       drm_intel_bo *bo;
 547       GLuint type;
 548
 549       /* Offset to index buffer index to use in CMD_3D_PRIM so that we can
 550        * avoid re-uploading the IB packet over and over if we're actually
 551        * referencing the same index buffer.
 552        */
 553       unsigned int start_vertex_offset;
 554    } ib;
 555
 556    /* Active vertex program:
 557     */
 558    const struct gl_vertex_program *vertex_program;
 559    const struct gl_fragment_program *fragment_program;
 560
 561    /* hw-dependent 3DSTATE_VF_STATISTICS opcode */
 562    uint32_t CMD_VF_STATISTICS;
 563    /* hw-dependent 3DSTATE_PIPELINE_SELECT opcode */
 564    uint32_t CMD_PIPELINE_SELECT;
 565    int vs_max_threads;
 566    int wm_max_threads;
 567
 568    /* BRW_NEW_URB_ALLOCATIONS:
 569     */
 570    struct {
 571       GLuint vsize;             /* vertex size plus header in urb registers */
 572       GLuint csize;             /* constant buffer size in urb registers */
 573       GLuint sfsize;            /* setup data size in urb registers */
 574
 575       GLboolean constrained;
 576
 577       GLuint max_vs_entries;    /* Maximum number of VS entries */
 578       GLuint max_gs_entries;    /* Maximum number of GS entries */
 579
 580       GLuint nr_vs_entries;
 581       GLuint nr_gs_entries;
 582       GLuint nr_clip_entries;
 583       GLuint nr_sf_entries;
 584       GLuint nr_cs_entries;
 585
 586       /* gen6:
 587        * The length of each URB entry owned by the VS (or GS), as
 588        * a number of 1024-bit (128-byte) rows.  Should be >= 1.
 589        *
 590        * gen7: Same meaning, but in 512-bit (64-byte) rows.
 591        */
 592       GLuint vs_size;
 593       GLuint gs_size;
 594
 595       GLuint vs_start;
 596       GLuint gs_start;
 597       GLuint clip_start;
 598       GLuint sf_start;
 599       GLuint cs_start;
 600       GLuint size; /* Hardware URB size, in KB. */
 601    } urb;
 602
 603
 604    /* BRW_NEW_CURBE_OFFSETS:
 605     */
 606    struct {
 607       GLuint wm_start;  /**< pos of first wm const in CURBE buffer */
 608       GLuint wm_size;   /**< number of float[4] consts, multiple of 16 */
 609       GLuint clip_start;
 610       GLuint clip_size;
 611       GLuint vs_start;
 612       GLuint vs_size;
 613       GLuint total_size;
 614
 615       drm_intel_bo *curbe_bo;
 616       /** Offset within curbe_bo of space for current curbe entry */
 617       GLuint curbe_offset;
 618       /** Offset within curbe_bo of space for next curbe entry */
 619       GLuint curbe_next_offset;
 620
 621       /**
 622        * Copy of the last set of CURBEs uploaded.  Frequently we'll end up
 623        * in brw_curbe.c with the same set of constant data to be uploaded,
 624        * so we'd rather not upload new constants in that case (it can cause
 625        * a pipeline bubble since only up to 4 can be pipelined at a time).
 626        */
 627       GLfloat *last_buf;
 628       /**
 629        * Allocation for where to calculate the next set of CURBEs.
 630        * It's a hot enough path that malloc/free of that data matters.
 631        */
 632       GLfloat *next_buf;
 633       GLuint last_bufsz;
 634    } curbe;
 635
 636    struct {
 637       struct brw_vs_prog_data *prog_data;
 638       int8_t *constant_map; /* variable array following prog_data */
 639
 640       drm_intel_bo *const_bo;
 641       /** Offset in the program cache to the VS program */
 642       uint32_t prog_offset;
 643       uint32_t state_offset;
 644
 645       /** Binding table of pointers to surf_bo entries */
 646       uint32_t bind_bo_offset;
 647       uint32_t surf_offset[BRW_VS_MAX_SURF];
 648       GLuint nr_surfaces;
 649
 650       uint32_t push_const_offset; /* Offset in the batchbuffer */
 651       int push_const_size; /* in 256-bit register increments */
 652    } vs;
 653
 654    struct {
 655       struct brw_gs_prog_data *prog_data;
 656
 657       GLboolean prog_active;
 658       /** Offset in the program cache to the CLIP program pre-gen6 */
 659       uint32_t prog_offset;
 660       uint32_t state_offset;
 661    } gs;
 662
 663    struct {
 664       struct brw_clip_prog_data *prog_data;
 665
 666       /** Offset in the program cache to the CLIP program pre-gen6 */
 667       uint32_t prog_offset;
 668
 669       /* Offset in the batch to the CLIP state on pre-gen6. */
 670       uint32_t state_offset;
 671
 672       /* As of gen6, this is the offset in the batch to the CLIP VP,
 673        * instead of vp_bo.
 674        */
 675       uint32_t vp_offset;
 676    } clip;
 677
 678
 679    struct {
 680       struct brw_sf_prog_data *prog_data;
 681
 682       /** Offset in the program cache to the CLIP program pre-gen6 */
 683       uint32_t prog_offset;
 684       uint32_t state_offset;
 685       uint32_t vp_offset;
 686    } sf;
 687
 688    struct {
 689       struct brw_wm_prog_data *prog_data;
 690       struct brw_wm_compile *compile_data;
 691
 692       /** Input sizes, calculated from active vertex program.
 693        * One bit per fragment program input attribute.
 694        */
 695       GLbitfield input_size_masks[4];
 696
 697       /** offsets in the batch to sampler default colors (texture border color)
 698        */
 699       uint32_t sdc_offset[BRW_MAX_TEX_UNIT];
 700
 701       GLuint render_surf;
 702       GLuint nr_surfaces;
 703
 704       GLuint max_threads;
 705       drm_intel_bo *scratch_bo;
 706
 707       GLuint sampler_count;
 708       uint32_t sampler_offset;
 709
 710       /** Offset in the program cache to the WM program */
 711       uint32_t prog_offset;
 712
 713       /** Binding table of pointers to surf_bo entries */
 714       uint32_t bind_bo_offset;
 715       uint32_t surf_offset[BRW_WM_MAX_SURF];
 716       uint32_t state_offset; /* offset in batchbuffer to pre-gen6 WM state */
 717
 718       drm_intel_bo *const_bo; /* pull constant buffer. */
 719       /**
 720        * This is offset in the batch to the push constants on gen6.
 721        *
 722        * Pre-gen6, push constants live in the CURBE.
 723        */
 724       uint32_t push_const_offset;
 725    } wm;
 726
 727
 728    struct {
 729       uint32_t state_offset;
 730       uint32_t blend_state_offset;
 731       uint32_t depth_stencil_state_offset;
 732       uint32_t vp_offset;
 733    } cc;
 734
 735    struct {
 736       struct brw_query_object *obj;
 737       drm_intel_bo *bo;
 738       int index;
 739       GLboolean active;
 740    } query;
 741    /* Used to give every program string a unique id
 742     */
 743    GLuint program_id;
 744
 745    int num_prepare_atoms, num_emit_atoms;
 746    struct brw_tracked_state prepare_atoms[64], emit_atoms[64];
 747 };
 748
 749
 750 #define BRW_PACKCOLOR8888(r,g,b,a)  ((r<<24) | (g<<16) | (b<<8) | a)
 751
 752 struct brw_instruction_info {
 753     char    *name;
 754     int     nsrc;
 755     int     ndst;
 756     GLboolean is_arith;
 757 };
 758 extern const struct brw_instruction_info brw_opcodes[128];
 759
 760 /*======================================================================
 761  * brw_vtbl.c
 762  */
 763 void brwInitVtbl( struct brw_context *brw );
 764
 765 /*======================================================================
 766  * brw_context.c
 767  */
 768 GLboolean brwCreateContext( int api,
 769                             const struct gl_config *mesaVis,
 770                             __DRIcontext *driContextPriv,
 771                             void *sharedContextPrivate);
 772
 773 /*======================================================================
 774  * brw_queryobj.c
 775  */
 776 void brw_init_queryobj_functions(struct dd_function_table *functions);
 777 void brw_prepare_query_begin(struct brw_context *brw);
 778 void brw_emit_query_begin(struct brw_context *brw);
 779 void brw_emit_query_end(struct brw_context *brw);
 780
 781 /*======================================================================
 782  * brw_state_dump.c
 783  */
 784 void brw_debug_batch(struct intel_context *intel);
 785
 786 /*======================================================================
 787  * brw_tex.c
 788  */
 789 void brw_validate_textures( struct brw_context *brw );
 790
 791
 792 /*======================================================================
 793  * brw_program.c
 794  */
 795 void brwInitFragProgFuncs( struct dd_function_table *functions );
 796
 797
 798 /* brw_urb.c
 799  */
 800 void brw_upload_urb_fence(struct brw_context *brw);
 801
 802 /* brw_curbe.c
 803  */
 804 void brw_upload_cs_urb_state(struct brw_context *brw);
 805
 806 /* brw_disasm.c */
 807 int brw_disasm (FILE *file, struct brw_instruction *inst, int gen);
 808
 809 /*======================================================================
 810  * Inline conversion functions.  These are better-typed than the
 811  * macros used previously:
 812  */
 813 static INLINE struct brw_context *
 814 brw_context( struct gl_context *ctx )
 815 {
 816    return (struct brw_context *)ctx;
 817 }
 818
 819 static INLINE struct brw_vertex_program *
 820 brw_vertex_program(struct gl_vertex_program *p)
 821 {
 822    return (struct brw_vertex_program *) p;
 823 }
 824
 825 static INLINE const struct brw_vertex_program *
 826 brw_vertex_program_const(const struct gl_vertex_program *p)
 827 {
 828    return (const struct brw_vertex_program *) p;
 829 }
 830
 831 static INLINE struct brw_fragment_program *
 832 brw_fragment_program(struct gl_fragment_program *p)
 833 {
 834    return (struct brw_fragment_program *) p;
 835 }
 836
 837 static INLINE const struct brw_fragment_program *
 838 brw_fragment_program_const(const struct gl_fragment_program *p)
 839 {
 840    return (const struct brw_fragment_program *) p;
 841 }
 842
 843 static inline
 844 float convert_param(enum param_conversion conversion, float param)
 845 {
 846    union {
 847       float f;
 848       uint32_t u;
 849       int32_t i;
 850    } fi;
 851
 852    switch (conversion) {
 853    case PARAM_NO_CONVERT:
 854       return param;
 855    case PARAM_CONVERT_F2I:
 856       fi.i = param;
 857       return fi.f;
 858    case PARAM_CONVERT_F2U:
 859       fi.u = param;
 860       return fi.f;
 861    case PARAM_CONVERT_F2B:
 862       if (param != 0.0)
 863          fi.i = 1;
 864       else
 865          fi.i = 0;
 866       return fi.f;
 867    default:
 868       return param;
 869    }
 870 }
 871
 872 /**
 873  * Pre-gen6, the register file of the EUs was shared between threads,
 874  * and each thread used some subset allocated on a 16-register block
 875  * granularity.  The unit states wanted these block counts.
 876  */
 877 static inline int
 878 brw_register_blocks(int reg_count)
 879 {
 880    return ALIGN(reg_count, 16) / 16 - 1;
 881 }
 882
 883 static inline uint32_t
 884 brw_program_reloc(struct brw_context *brw, uint32_t state_offset,
 885                   uint32_t prog_offset)
 886 {
 887    struct intel_context *intel = &brw->intel;
 888
 889    if (intel->gen >= 5) {
 890       /* Using state base address. */
 891       return prog_offset;
 892    }
 893
 894    drm_intel_bo_emit_reloc(intel->batch.bo,
 895                            state_offset,
 896                            brw->cache.bo,
 897                            prog_offset,
 898                            I915_GEM_DOMAIN_INSTRUCTION, 0);
 899
 900    return brw->cache.bo->offset + prog_offset;
 901 }
 902
 903 GLboolean brw_do_cubemap_normalize(struct exec_list *instructions);
 904
 905 #endif