src/gallium/drivers/ilo/core/ilo_builder_3d_bottom.h

   1 /*
   2  * Mesa 3-D graphics library
   3  *
   4  * Copyright (C) 2014 LunarG, Inc.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the "Software"),
   8  * to deal in the Software without restriction, including without limitation
   9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10  * and/or sell copies of the Software, and to permit persons to whom the
  11  * Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included
  14  * in all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  21  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  22  * DEALINGS IN THE SOFTWARE.
  23  *
  24  * Authors:
  25  *    Chia-I Wu <olv@lunarg.com>
  26  */
  27
  28 #ifndef ILO_BUILDER_3D_BOTTOM_H
  29 #define ILO_BUILDER_3D_BOTTOM_H
  30
  31 #include "genhw/genhw.h"
  32 #include "../ilo_shader.h"
  33 #include "intel_winsys.h"
  34
  35 #include "ilo_core.h"
  36 #include "ilo_dev.h"
  37 #include "ilo_format.h"
  38 #include "ilo_state_cc.h"
  39 #include "ilo_state_raster.h"
  40 #include "ilo_state_sbe.h"
  41 #include "ilo_state_viewport.h"
  42 #include "ilo_builder.h"
  43 #include "ilo_builder_3d_top.h"
  44
  45 static inline void
  46 gen6_3DSTATE_CLIP(struct ilo_builder *builder,
  47                   const struct ilo_state_raster *rs)
  48 {
  49    const uint8_t cmd_len = 4;
  50    uint32_t *dw;
  51
  52    ILO_DEV_ASSERT(builder->dev, 6, 8);
  53
  54    ilo_builder_batch_pointer(builder, cmd_len, &dw);
  55
  56    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_CLIP) | (cmd_len - 2);
  57    /* see raster_set_gen6_3DSTATE_CLIP() */
  58    dw[1] = rs->clip[0];
  59    dw[2] = rs->clip[1];
  60    dw[3] = rs->clip[2];
  61 }
  62
  63 static inline void
  64 gen6_3DSTATE_SF(struct ilo_builder *builder,
  65                 const struct ilo_state_raster *rs,
  66                 const struct ilo_state_sbe *sbe)
  67 {
  68    const uint8_t cmd_len = 20;
  69    uint32_t *dw;
  70
  71    ILO_DEV_ASSERT(builder->dev, 6, 6);
  72
  73    ilo_builder_batch_pointer(builder, cmd_len, &dw);
  74
  75    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_SF) | (cmd_len - 2);
  76    /* see sbe_set_gen8_3DSTATE_SBE() */
  77    dw[1] = sbe->sbe[0];
  78
  79    /* see raster_set_gen7_3DSTATE_SF() */
  80    dw[2] = rs->sf[0];
  81    dw[3] = rs->sf[1];
  82    dw[4] = rs->sf[2];
  83    dw[5] = rs->raster[1];
  84    dw[6] = rs->raster[2];
  85    dw[7] = rs->raster[3];
  86
  87    /* see sbe_set_gen8_3DSTATE_SBE_SWIZ() */
  88    memcpy(&dw[8], sbe->swiz, sizeof(*dw) * 8);
  89
  90    dw[16] = sbe->sbe[1];
  91    dw[17] = sbe->sbe[2];
  92    /* WrapShortest enables */
  93    dw[18] = 0;
  94    dw[19] = 0;
  95 }
  96
  97 static inline void
  98 gen7_3DSTATE_SF(struct ilo_builder *builder,
  99                 const struct ilo_state_raster *rs)
 100 {
 101    const uint8_t cmd_len = (ilo_dev_gen(builder->dev) >= ILO_GEN(8)) ? 4 : 7;
 102    uint32_t *dw;
 103
 104    ILO_DEV_ASSERT(builder->dev, 7, 8);
 105
 106    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 107
 108    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_SF) | (cmd_len - 2);
 109
 110    /* see raster_set_gen7_3DSTATE_SF() or raster_set_gen8_3DSTATE_SF() */
 111    dw[1] = rs->sf[0];
 112    dw[2] = rs->sf[1];
 113    dw[3] = rs->sf[2];
 114    if (ilo_dev_gen(builder->dev) < ILO_GEN(8)) {
 115       dw[4] = rs->raster[1];
 116       dw[5] = rs->raster[2];
 117       dw[6] = rs->raster[3];
 118    }
 119 }
 120
 121 static inline void
 122 gen7_3DSTATE_SBE(struct ilo_builder *builder,
 123                  const struct ilo_state_sbe *sbe)
 124 {
 125    const uint8_t cmd_len = 14;
 126    uint32_t *dw;
 127
 128    ILO_DEV_ASSERT(builder->dev, 7, 7.5);
 129
 130    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 131
 132    dw[0] = GEN7_RENDER_CMD(3D, 3DSTATE_SBE) | (cmd_len - 2);
 133    /* see sbe_set_gen8_3DSTATE_SBE() and sbe_set_gen8_3DSTATE_SBE_SWIZ() */
 134    dw[1] = sbe->sbe[0];
 135    memcpy(&dw[2], sbe->swiz, sizeof(*dw) * 8);
 136    dw[10] = sbe->sbe[1];
 137    dw[11] = sbe->sbe[2];
 138
 139    /* WrapShortest enables */
 140    dw[12] = 0;
 141    dw[13] = 0;
 142 }
 143
 144 static inline void
 145 gen8_3DSTATE_SBE(struct ilo_builder *builder,
 146                  const struct ilo_state_sbe *sbe)
 147 {
 148    const uint8_t cmd_len = 4;
 149    uint32_t *dw;
 150
 151    ILO_DEV_ASSERT(builder->dev, 8, 8);
 152
 153    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 154
 155    /* see sbe_set_gen8_3DSTATE_SBE() */
 156    dw[0] = GEN7_RENDER_CMD(3D, 3DSTATE_SBE) | (cmd_len - 2);
 157    dw[1] = sbe->sbe[0];
 158    dw[2] = sbe->sbe[1];
 159    dw[3] = sbe->sbe[2];
 160 }
 161
 162 static inline void
 163 gen8_3DSTATE_SBE_SWIZ(struct ilo_builder *builder,
 164                       const struct ilo_state_sbe *sbe)
 165 {
 166    const uint8_t cmd_len = 11;
 167    uint32_t *dw;
 168
 169    ILO_DEV_ASSERT(builder->dev, 8, 8);
 170
 171    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 172
 173    dw[0] = GEN8_RENDER_CMD(3D, 3DSTATE_SBE_SWIZ) | (cmd_len - 2);
 174    /* see sbe_set_gen8_3DSTATE_SBE_SWIZ() */
 175    memcpy(&dw[1], sbe->swiz, sizeof(*dw) * 8);
 176    /* WrapShortest enables */
 177    dw[9] = 0;
 178    dw[10] = 0;
 179 }
 180
 181 static inline void
 182 gen8_3DSTATE_RASTER(struct ilo_builder *builder,
 183                     const struct ilo_state_raster *rs)
 184 {
 185    const uint8_t cmd_len = 5;
 186    uint32_t *dw;
 187
 188    ILO_DEV_ASSERT(builder->dev, 8, 8);
 189
 190    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 191
 192    dw[0] = GEN8_RENDER_CMD(3D, 3DSTATE_RASTER) | (cmd_len - 2);
 193    /* see raster_set_gen8_3DSTATE_RASTER() */
 194    dw[1] = rs->raster[0];
 195    dw[2] = rs->raster[1];
 196    dw[3] = rs->raster[2];
 197    dw[4] = rs->raster[3];
 198 }
 199
 200 static inline void
 201 gen6_3DSTATE_WM(struct ilo_builder *builder,
 202                 const struct ilo_state_raster *rs,
 203                 const struct ilo_shader_state *fs,
 204                 bool dual_blend, bool cc_may_kill)
 205 {
 206    const uint8_t cmd_len = 9;
 207    const bool multisample = false;
 208    const int num_samples = 1;
 209    uint32_t dw2, dw4, dw5, dw6, *dw;
 210
 211    ILO_DEV_ASSERT(builder->dev, 6, 6);
 212
 213    dw2 = 0;
 214    /* see raster_set_gen6_3dstate_wm() */
 215    dw4 = rs->raster[0];
 216    dw5 = rs->raster[1];
 217    dw6 = rs->raster[2];
 218
 219    if (fs) {
 220       const struct ilo_shader_cso *cso;
 221
 222       cso = ilo_shader_get_kernel_cso(fs);
 223       /* see fs_init_cso_gen6() */
 224       dw2 |= cso->payload[0];
 225       dw4 |= cso->payload[1];
 226       dw5 |= cso->payload[2];
 227       dw6 |= cso->payload[3];
 228    } else {
 229       const int max_threads = (builder->dev->gt == 2) ? 80 : 40;
 230
 231       /* honor the valid range even if dispatching is disabled */
 232       dw5 |= (max_threads - 1) << GEN6_WM_DW5_MAX_THREADS__SHIFT;
 233    }
 234
 235    if (cc_may_kill)
 236       dw5 |= GEN6_WM_DW5_PS_KILL_PIXEL | GEN6_WM_DW5_PS_DISPATCH_ENABLE;
 237
 238    if (dual_blend)
 239       dw5 |= GEN6_WM_DW5_PS_DUAL_SOURCE_BLEND;
 240
 241    if (multisample && num_samples > 1)
 242       dw6 |= GEN6_WM_DW6_MSDISPMODE_PERPIXEL;
 243
 244    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 245
 246    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_WM) | (cmd_len - 2);
 247    dw[1] = ilo_shader_get_kernel_offset(fs);
 248    dw[2] = dw2;
 249    dw[3] = 0; /* scratch */
 250    dw[4] = dw4;
 251    dw[5] = dw5;
 252    dw[6] = dw6;
 253    dw[7] = 0; /* kernel 1 */
 254    dw[8] = 0; /* kernel 2 */
 255 }
 256
 257 static inline void
 258 gen7_3DSTATE_WM(struct ilo_builder *builder,
 259                 const struct ilo_state_raster *rs,
 260                 const struct ilo_shader_state *fs,
 261                 bool cc_may_kill)
 262 {
 263    const uint8_t cmd_len = 3;
 264    const bool multisample = false;
 265    const int num_samples = 1;
 266    uint32_t dw1, dw2, *dw;
 267
 268    ILO_DEV_ASSERT(builder->dev, 7, 7.5);
 269
 270    /* see raster_set_gen8_3DSTATE_WM() */
 271    dw1 = rs->wm[0];
 272
 273    if (fs) {
 274       const struct ilo_shader_cso *cso;
 275
 276       cso = ilo_shader_get_kernel_cso(fs);
 277       /* see fs_init_cso_gen7() */
 278       dw1 |= cso->payload[3];
 279    }
 280
 281    if (cc_may_kill)
 282       dw1 |= GEN7_WM_DW1_PS_DISPATCH_ENABLE | GEN7_WM_DW1_PS_KILL_PIXEL;
 283
 284    dw2 = 0;
 285    if (multisample && num_samples > 1)
 286       dw2 |= GEN7_WM_DW2_MSDISPMODE_PERPIXEL;
 287
 288    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 289
 290    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_WM) | (cmd_len - 2);
 291    dw[1] = dw1;
 292    dw[2] = dw2;
 293 }
 294
 295 static inline void
 296 gen8_3DSTATE_WM(struct ilo_builder *builder,
 297                 const struct ilo_state_raster *rs)
 298 {
 299    const uint8_t cmd_len = 2;
 300    uint32_t *dw;
 301
 302    ILO_DEV_ASSERT(builder->dev, 8, 8);
 303
 304    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 305
 306    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_WM) | (cmd_len - 2);
 307    /* see raster_set_gen8_3DSTATE_WM() */
 308    dw[1] = rs->wm[0];
 309 }
 310
 311 static inline void
 312 gen8_3DSTATE_WM_DEPTH_STENCIL(struct ilo_builder *builder,
 313                               const struct ilo_state_cc *cc)
 314 {
 315    const uint8_t cmd_len = 3;
 316    uint32_t *dw;
 317
 318    ILO_DEV_ASSERT(builder->dev, 8, 8);
 319
 320    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 321
 322    dw[0] = GEN8_RENDER_CMD(3D, 3DSTATE_WM_DEPTH_STENCIL) | (cmd_len - 2);
 323    /* see cc_set_gen8_3DSTATE_WM_DEPTH_STENCIL() */
 324    dw[1] = cc->ds[0];
 325    dw[2] = cc->ds[1];
 326 }
 327
 328 static inline void
 329 gen8_3DSTATE_WM_HZ_OP(struct ilo_builder *builder,
 330                       const struct ilo_state_raster *rs,
 331                       uint16_t width, uint16_t height)
 332 {
 333    const uint8_t cmd_len = 5;
 334    uint32_t *dw;
 335
 336    ILO_DEV_ASSERT(builder->dev, 8, 8);
 337
 338    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 339
 340    dw[0] = GEN8_RENDER_CMD(3D, 3DSTATE_WM_HZ_OP) | (cmd_len - 2);
 341    /* see raster_set_gen8_3dstate_wm_hz_op() */
 342    dw[1] = rs->wm[1];
 343    dw[2] = 0;
 344    /* exclusive */
 345    dw[3] = height << 16 | width;
 346    dw[4] = rs->wm[2];
 347 }
 348
 349 static inline void
 350 gen8_disable_3DSTATE_WM_HZ_OP(struct ilo_builder *builder)
 351 {
 352    const uint8_t cmd_len = 5;
 353    uint32_t *dw;
 354
 355    ILO_DEV_ASSERT(builder->dev, 8, 8);
 356
 357    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 358
 359    dw[0] = GEN8_RENDER_CMD(3D, 3DSTATE_WM_HZ_OP) | (cmd_len - 2);
 360    dw[1] = 0;
 361    dw[2] = 0;
 362    dw[3] = 0;
 363    dw[4] = 0;
 364 }
 365
 366 static inline void
 367 gen8_3DSTATE_WM_CHROMAKEY(struct ilo_builder *builder)
 368 {
 369    const uint8_t cmd_len = 2;
 370    uint32_t *dw;
 371
 372    ILO_DEV_ASSERT(builder->dev, 8, 8);
 373
 374    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 375
 376    dw[0] = GEN8_RENDER_CMD(3D, 3DSTATE_WM_CHROMAKEY) | (cmd_len - 2);
 377    dw[1] = 0;
 378 }
 379
 380 static inline void
 381 gen7_3DSTATE_PS(struct ilo_builder *builder,
 382                 const struct ilo_shader_state *fs,
 383                 bool dual_blend)
 384 {
 385    const uint8_t cmd_len = 8;
 386    const struct ilo_shader_cso *cso;
 387    uint32_t dw2, dw4, dw5, *dw;
 388
 389    ILO_DEV_ASSERT(builder->dev, 7, 7.5);
 390
 391    /* see fs_init_cso_gen7() */
 392    cso = ilo_shader_get_kernel_cso(fs);
 393    dw2 = cso->payload[0];
 394    dw4 = cso->payload[1];
 395    dw5 = cso->payload[2];
 396
 397    if (dual_blend)
 398       dw4 |= GEN7_PS_DW4_DUAL_SOURCE_BLEND;
 399
 400    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 401
 402    dw[0] = GEN7_RENDER_CMD(3D, 3DSTATE_PS) | (cmd_len - 2);
 403    dw[1] = ilo_shader_get_kernel_offset(fs);
 404    dw[2] = dw2;
 405    dw[3] = 0; /* scratch */
 406    dw[4] = dw4;
 407    dw[5] = dw5;
 408    dw[6] = 0; /* kernel 1 */
 409    dw[7] = 0; /* kernel 2 */
 410 }
 411
 412 static inline void
 413 gen7_disable_3DSTATE_PS(struct ilo_builder *builder)
 414 {
 415    const uint8_t cmd_len = 8;
 416    int max_threads;
 417    uint32_t dw4, *dw;
 418
 419    ILO_DEV_ASSERT(builder->dev, 7, 7.5);
 420
 421    /* GPU hangs if none of the dispatch enable bits is set */
 422    dw4 = GEN6_PS_DISPATCH_8 << GEN7_PS_DW4_DISPATCH_MODE__SHIFT;
 423
 424    /* see brwCreateContext() */
 425    switch (ilo_dev_gen(builder->dev)) {
 426    case ILO_GEN(7.5):
 427       max_threads = (builder->dev->gt == 3) ? 408 :
 428                     (builder->dev->gt == 2) ? 204 : 102;
 429       dw4 |= (max_threads - 1) << GEN75_PS_DW4_MAX_THREADS__SHIFT;
 430       break;
 431    case ILO_GEN(7):
 432    default:
 433       max_threads = (builder->dev->gt == 2) ? 172 : 48;
 434       dw4 |= (max_threads - 1) << GEN7_PS_DW4_MAX_THREADS__SHIFT;
 435       break;
 436    }
 437
 438    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 439
 440    dw[0] = GEN7_RENDER_CMD(3D, 3DSTATE_PS) | (cmd_len - 2);
 441    dw[1] = 0;
 442    dw[2] = 0;
 443    dw[3] = 0;
 444    dw[4] = dw4;
 445    dw[5] = 0;
 446    dw[6] = 0;
 447    dw[7] = 0;
 448 }
 449
 450 static inline void
 451 gen8_3DSTATE_PS(struct ilo_builder *builder,
 452                 const struct ilo_shader_state *fs)
 453 {
 454    const uint8_t cmd_len = 12;
 455    const struct ilo_shader_cso *cso;
 456    uint32_t dw3, dw6, dw7, *dw;
 457
 458    ILO_DEV_ASSERT(builder->dev, 8, 8);
 459
 460    /* see fs_init_cso_gen8() */
 461    cso = ilo_shader_get_kernel_cso(fs);
 462    dw3 = cso->payload[0];
 463    dw6 = cso->payload[1];
 464    dw7 = cso->payload[2];
 465
 466    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 467
 468    dw[0] = GEN7_RENDER_CMD(3D, 3DSTATE_PS) | (cmd_len - 2);
 469    dw[1] = ilo_shader_get_kernel_offset(fs);
 470    dw[2] = 0;
 471    dw[3] = dw3;
 472    dw[4] = 0; /* scratch */
 473    dw[5] = 0;
 474    dw[6] = dw6;
 475    dw[7] = dw7;
 476    dw[8] = 0; /* kernel 1 */
 477    dw[9] = 0;
 478    dw[10] = 0; /* kernel 2 */
 479    dw[11] = 0;
 480 }
 481
 482 static inline void
 483 gen8_3DSTATE_PS_EXTRA(struct ilo_builder *builder,
 484                       const struct ilo_shader_state *fs,
 485                       bool cc_may_kill, bool per_sample)
 486 {
 487    const uint8_t cmd_len = 2;
 488    const struct ilo_shader_cso *cso;
 489    uint32_t dw1, *dw;
 490
 491    ILO_DEV_ASSERT(builder->dev, 8, 8);
 492
 493    /* see fs_init_cso_gen8() */
 494    cso = ilo_shader_get_kernel_cso(fs);
 495    dw1 = cso->payload[3];
 496
 497    if (cc_may_kill)
 498       dw1 |= GEN8_PSX_DW1_VALID | GEN8_PSX_DW1_KILL_PIXEL;
 499    if (per_sample)
 500       dw1 |= GEN8_PSX_DW1_PER_SAMPLE;
 501
 502    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 503
 504    dw[0] = GEN8_RENDER_CMD(3D, 3DSTATE_PS_EXTRA) | (cmd_len - 2);
 505    dw[1] = dw1;
 506 }
 507
 508 static inline void
 509 gen8_3DSTATE_PS_BLEND(struct ilo_builder *builder,
 510                       const struct ilo_state_cc *cc)
 511 {
 512    const uint8_t cmd_len = 2;
 513    uint32_t *dw;
 514
 515    ILO_DEV_ASSERT(builder->dev, 8, 8);
 516
 517    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 518
 519    dw[0] = GEN8_RENDER_CMD(3D, 3DSTATE_PS_BLEND) | (cmd_len - 2);
 520    /* see cc_set_gen8_3DSTATE_PS_BLEND() */
 521    dw[1] = cc->blend[0];
 522 }
 523
 524 static inline void
 525 gen6_3DSTATE_CONSTANT_PS(struct ilo_builder *builder,
 526                          const uint32_t *bufs, const int *sizes,
 527                          int num_bufs)
 528 {
 529    gen6_3dstate_constant(builder, GEN6_RENDER_OPCODE_3DSTATE_CONSTANT_PS,
 530          bufs, sizes, num_bufs);
 531 }
 532
 533 static inline void
 534 gen7_3DSTATE_CONSTANT_PS(struct ilo_builder *builder,
 535                          const uint32_t *bufs, const int *sizes,
 536                          int num_bufs)
 537 {
 538    gen7_3dstate_constant(builder, GEN6_RENDER_OPCODE_3DSTATE_CONSTANT_PS,
 539          bufs, sizes, num_bufs);
 540 }
 541
 542 static inline void
 543 gen7_3DSTATE_BINDING_TABLE_POINTERS_PS(struct ilo_builder *builder,
 544                                        uint32_t binding_table)
 545 {
 546    ILO_DEV_ASSERT(builder->dev, 7, 8);
 547
 548    gen7_3dstate_pointer(builder,
 549          GEN7_RENDER_OPCODE_3DSTATE_BINDING_TABLE_POINTERS_PS,
 550          binding_table);
 551 }
 552
 553 static inline void
 554 gen7_3DSTATE_SAMPLER_STATE_POINTERS_PS(struct ilo_builder *builder,
 555                                        uint32_t sampler_state)
 556 {
 557    ILO_DEV_ASSERT(builder->dev, 7, 8);
 558
 559    gen7_3dstate_pointer(builder,
 560          GEN7_RENDER_OPCODE_3DSTATE_SAMPLER_STATE_POINTERS_PS,
 561          sampler_state);
 562 }
 563
 564 static inline void
 565 gen6_3DSTATE_MULTISAMPLE(struct ilo_builder *builder,
 566                          const struct ilo_state_raster *rs,
 567                          const uint32_t *pattern, int pattern_len)
 568 {
 569    const uint8_t cmd_len = (ilo_dev_gen(builder->dev) >= ILO_GEN(7)) ? 4 : 3;
 570    uint32_t *dw;
 571
 572    ILO_DEV_ASSERT(builder->dev, 6, 7.5);
 573
 574    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 575
 576    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_MULTISAMPLE) | (cmd_len - 2);
 577    /* see raster_set_gen8_3DSTATE_MULTISAMPLE() */
 578    dw[1] = rs->sample[0];
 579
 580    assert(pattern_len == 1 || pattern_len == 2);
 581    dw[2] = pattern[0];
 582    if (ilo_dev_gen(builder->dev) >= ILO_GEN(7))
 583       dw[3] = (pattern_len == 2) ? pattern[1] : 0;
 584 }
 585
 586 static inline void
 587 gen8_3DSTATE_MULTISAMPLE(struct ilo_builder *builder,
 588                          const struct ilo_state_raster *rs)
 589 {
 590    const uint8_t cmd_len = 2;
 591    uint32_t *dw;
 592
 593    ILO_DEV_ASSERT(builder->dev, 8, 8);
 594
 595    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 596
 597    dw[0] = GEN8_RENDER_CMD(3D, 3DSTATE_MULTISAMPLE) | (cmd_len - 2);
 598    /* see raster_set_gen8_3DSTATE_MULTISAMPLE() */
 599    dw[1] = rs->sample[0];
 600 }
 601
 602 static inline void
 603 gen8_3DSTATE_SAMPLE_PATTERN(struct ilo_builder *builder,
 604                             const uint32_t *pattern_1x,
 605                             const uint32_t *pattern_2x,
 606                             const uint32_t *pattern_4x,
 607                             const uint32_t *pattern_8x,
 608                             const uint32_t *pattern_16x)
 609 {
 610    const uint8_t cmd_len = 9;
 611    uint32_t *dw;
 612
 613    ILO_DEV_ASSERT(builder->dev, 8, 8);
 614
 615    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 616
 617    dw[0] = GEN8_RENDER_CMD(3D, 3DSTATE_SAMPLE_PATTERN) | (cmd_len - 2);
 618    dw[1] = pattern_16x[3];
 619    dw[2] = pattern_16x[2];
 620    dw[3] = pattern_16x[1];
 621    dw[4] = pattern_16x[0];
 622    dw[5] = pattern_8x[1];
 623    dw[6] = pattern_8x[0];
 624    dw[7] = pattern_4x[0];
 625    dw[8] = pattern_1x[0] << 16 |
 626            pattern_2x[0];
 627 }
 628
 629 static inline void
 630 gen6_3DSTATE_SAMPLE_MASK(struct ilo_builder *builder,
 631                          const struct ilo_state_raster *rs)
 632 {
 633    const uint8_t cmd_len = 2;
 634    uint32_t *dw;
 635
 636    ILO_DEV_ASSERT(builder->dev, 6, 8);
 637
 638    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 639
 640    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_SAMPLE_MASK) | (cmd_len - 2);
 641    /* see raster_set_gen6_3DSTATE_SAMPLE_MASK() */
 642    dw[1] = rs->sample[1];
 643 }
 644
 645 static inline void
 646 gen6_3DSTATE_DRAWING_RECTANGLE(struct ilo_builder *builder,
 647                                unsigned x, unsigned y,
 648                                unsigned width, unsigned height)
 649 {
 650    const uint8_t cmd_len = 4;
 651    unsigned xmax = x + width - 1;
 652    unsigned ymax = y + height - 1;
 653    unsigned rect_limit;
 654    uint32_t *dw;
 655
 656    ILO_DEV_ASSERT(builder->dev, 6, 8);
 657
 658    if (ilo_dev_gen(builder->dev) >= ILO_GEN(7)) {
 659       rect_limit = 16383;
 660    }
 661    else {
 662       /*
 663        * From the Sandy Bridge PRM, volume 2 part 1, page 230:
 664        *
 665        *     "[DevSNB] Errata: This field (Clipped Drawing Rectangle Y Min)
 666        *      must be an even number"
 667        */
 668       assert(y % 2 == 0);
 669
 670       rect_limit = 8191;
 671    }
 672
 673    if (x > rect_limit) x = rect_limit;
 674    if (y > rect_limit) y = rect_limit;
 675    if (xmax > rect_limit) xmax = rect_limit;
 676    if (ymax > rect_limit) ymax = rect_limit;
 677
 678    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 679
 680    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_DRAWING_RECTANGLE) | (cmd_len - 2);
 681    dw[1] = y << 16 | x;
 682    dw[2] = ymax << 16 | xmax;
 683    /*
 684     * There is no need to set the origin.  It is intended to support front
 685     * buffer rendering.
 686     */
 687    dw[3] = 0;
 688 }
 689
 690 static inline void
 691 gen6_3DSTATE_POLY_STIPPLE_OFFSET(struct ilo_builder *builder,
 692                                  int x_offset, int y_offset)
 693 {
 694    const uint8_t cmd_len = 2;
 695    uint32_t *dw;
 696
 697    ILO_DEV_ASSERT(builder->dev, 6, 8);
 698
 699    assert(x_offset >= 0 && x_offset <= 31);
 700    assert(y_offset >= 0 && y_offset <= 31);
 701
 702    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 703
 704    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_POLY_STIPPLE_OFFSET) | (cmd_len - 2);
 705    dw[1] = x_offset << 8 | y_offset;
 706 }
 707
 708 static inline void
 709 gen6_3DSTATE_POLY_STIPPLE_PATTERN(struct ilo_builder *builder,
 710                                   const struct pipe_poly_stipple *pattern)
 711 {
 712    const uint8_t cmd_len = 33;
 713    uint32_t *dw;
 714    int i;
 715
 716    ILO_DEV_ASSERT(builder->dev, 6, 8);
 717
 718    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 719
 720    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_POLY_STIPPLE_PATTERN) | (cmd_len - 2);
 721    dw++;
 722
 723    STATIC_ASSERT(Elements(pattern->stipple) == 32);
 724    for (i = 0; i < 32; i++)
 725       dw[i] = pattern->stipple[i];
 726 }
 727
 728 static inline void
 729 gen6_3DSTATE_LINE_STIPPLE(struct ilo_builder *builder,
 730                           unsigned pattern, unsigned factor)
 731 {
 732    const uint8_t cmd_len = 3;
 733    unsigned inverse;
 734    uint32_t *dw;
 735
 736    ILO_DEV_ASSERT(builder->dev, 6, 8);
 737
 738    assert((pattern & 0xffff) == pattern);
 739    assert(factor >= 1 && factor <= 256);
 740
 741    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 742
 743    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_LINE_STIPPLE) | (cmd_len - 2);
 744    dw[1] = pattern;
 745
 746    if (ilo_dev_gen(builder->dev) >= ILO_GEN(7)) {
 747       /* in U1.16 */
 748       inverse = 65536 / factor;
 749
 750       dw[2] = inverse << GEN7_LINE_STIPPLE_DW2_INVERSE_REPEAT_COUNT__SHIFT |
 751               factor;
 752    }
 753    else {
 754       /* in U1.13 */
 755       inverse = 8192 / factor;
 756
 757       dw[2] = inverse << GEN6_LINE_STIPPLE_DW2_INVERSE_REPEAT_COUNT__SHIFT |
 758               factor;
 759    }
 760 }
 761
 762 static inline void
 763 gen6_3DSTATE_AA_LINE_PARAMETERS(struct ilo_builder *builder)
 764 {
 765    const uint8_t cmd_len = 3;
 766    const uint32_t dw[3] = {
 767       GEN6_RENDER_CMD(3D, 3DSTATE_AA_LINE_PARAMETERS) | (cmd_len - 2),
 768       0 << GEN6_AA_LINE_DW1_BIAS__SHIFT | 0,
 769       0 << GEN6_AA_LINE_DW2_CAP_BIAS__SHIFT | 0,
 770    };
 771
 772    ILO_DEV_ASSERT(builder->dev, 6, 8);
 773
 774    ilo_builder_batch_write(builder, cmd_len, dw);
 775 }
 776
 777 static inline void
 778 gen6_3DSTATE_DEPTH_BUFFER(struct ilo_builder *builder,
 779                           const struct ilo_state_zs *zs)
 780 {
 781    const uint32_t cmd = (ilo_dev_gen(builder->dev) >= ILO_GEN(7)) ?
 782       GEN7_RENDER_CMD(3D, 3DSTATE_DEPTH_BUFFER) :
 783       GEN6_RENDER_CMD(3D, 3DSTATE_DEPTH_BUFFER);
 784    const uint8_t cmd_len = (ilo_dev_gen(builder->dev) >= ILO_GEN(8)) ? 8 : 7;
 785    uint32_t *dw;
 786    unsigned pos;
 787
 788    ILO_DEV_ASSERT(builder->dev, 6, 8);
 789
 790    pos = ilo_builder_batch_pointer(builder, cmd_len, &dw);
 791
 792    dw[0] = cmd | (cmd_len - 2);
 793
 794    /*
 795     * see zs_set_gen6_3DSTATE_DEPTH_BUFFER() and
 796     * zs_set_gen7_3DSTATE_DEPTH_BUFFER()
 797     */
 798    if (ilo_dev_gen(builder->dev) >= ILO_GEN(8)) {
 799       dw[1] = zs->depth[0];
 800       dw[2] = 0;
 801       dw[3] = 0;
 802       dw[4] = zs->depth[2];
 803       dw[5] = zs->depth[3];
 804       dw[6] = 0;
 805       dw[7] = zs->depth[4];
 806
 807       dw[5] |= builder->mocs << GEN8_DEPTH_DW5_MOCS__SHIFT;
 808
 809       if (zs->depth_bo) {
 810          ilo_builder_batch_reloc64(builder, pos + 2, zs->depth_bo,
 811                zs->depth[1], (zs->z_readonly) ? 0 : INTEL_RELOC_WRITE);
 812       }
 813    } else {
 814       dw[1] = zs->depth[0];
 815       dw[2] = 0;
 816       dw[3] = zs->depth[2];
 817       dw[4] = zs->depth[3];
 818       dw[5] = 0;
 819       dw[6] = zs->depth[4];
 820
 821       if (ilo_dev_gen(builder->dev) >= ILO_GEN(7))
 822          dw[4] |= builder->mocs << GEN7_DEPTH_DW4_MOCS__SHIFT;
 823       else
 824          dw[6] |= builder->mocs << GEN6_DEPTH_DW6_MOCS__SHIFT;
 825
 826       if (zs->depth_bo) {
 827          ilo_builder_batch_reloc(builder, pos + 2, zs->depth_bo,
 828                zs->depth[1], (zs->z_readonly) ? 0 : INTEL_RELOC_WRITE);
 829       }
 830    }
 831 }
 832
 833 static inline void
 834 gen6_3DSTATE_STENCIL_BUFFER(struct ilo_builder *builder,
 835                             const struct ilo_state_zs *zs)
 836 {
 837    const uint32_t cmd = (ilo_dev_gen(builder->dev) >= ILO_GEN(7)) ?
 838       GEN7_RENDER_CMD(3D, 3DSTATE_STENCIL_BUFFER) :
 839       GEN6_RENDER_CMD(3D, 3DSTATE_STENCIL_BUFFER);
 840    const uint8_t cmd_len = (ilo_dev_gen(builder->dev) >= ILO_GEN(8)) ? 5 : 3;
 841    uint32_t *dw;
 842    unsigned pos;
 843
 844    ILO_DEV_ASSERT(builder->dev, 6, 8);
 845
 846    pos = ilo_builder_batch_pointer(builder, cmd_len, &dw);
 847
 848    dw[0] = cmd | (cmd_len - 2);
 849
 850    /* see zs_set_gen6_3DSTATE_STENCIL_BUFFER() */
 851    if (ilo_dev_gen(builder->dev) >= ILO_GEN(8)) {
 852       dw[1] = zs->stencil[0];
 853       dw[2] = 0;
 854       dw[3] = 0;
 855       dw[4] = zs->stencil[2];
 856
 857       dw[1] |= builder->mocs << GEN8_STENCIL_DW1_MOCS__SHIFT;
 858
 859       if (zs->stencil_bo) {
 860          ilo_builder_batch_reloc64(builder, pos + 2, zs->stencil_bo,
 861                zs->stencil[1], (zs->s_readonly) ? 0 : INTEL_RELOC_WRITE);
 862       }
 863    } else {
 864       dw[1] = zs->stencil[0];
 865       dw[2] = 0;
 866
 867       dw[1] |= builder->mocs << GEN6_STENCIL_DW1_MOCS__SHIFT;
 868
 869       if (zs->stencil_bo) {
 870          ilo_builder_batch_reloc(builder, pos + 2, zs->stencil_bo,
 871                zs->stencil[1], (zs->s_readonly) ? 0 : INTEL_RELOC_WRITE);
 872       }
 873    }
 874 }
 875
 876 static inline void
 877 gen6_3DSTATE_HIER_DEPTH_BUFFER(struct ilo_builder *builder,
 878                                const struct ilo_state_zs *zs)
 879 {
 880    const uint32_t cmd = (ilo_dev_gen(builder->dev) >= ILO_GEN(7)) ?
 881       GEN7_RENDER_CMD(3D, 3DSTATE_HIER_DEPTH_BUFFER) :
 882       GEN6_RENDER_CMD(3D, 3DSTATE_HIER_DEPTH_BUFFER);
 883    const uint8_t cmd_len = (ilo_dev_gen(builder->dev) >= ILO_GEN(8)) ? 5 : 3;
 884    uint32_t *dw;
 885    unsigned pos;
 886
 887    ILO_DEV_ASSERT(builder->dev, 6, 8);
 888
 889    pos = ilo_builder_batch_pointer(builder, cmd_len, &dw);
 890
 891    dw[0] = cmd | (cmd_len - 2);
 892
 893    /* see zs_set_gen6_3DSTATE_HIER_DEPTH_BUFFER() */
 894    if (ilo_dev_gen(builder->dev) >= ILO_GEN(8)) {
 895       dw[1] = zs->hiz[0];
 896       dw[2] = 0;
 897       dw[3] = 0;
 898       dw[4] = zs->hiz[2];
 899
 900       dw[1] |= builder->mocs << GEN8_HIZ_DW1_MOCS__SHIFT;
 901
 902       if (zs->hiz_bo) {
 903          ilo_builder_batch_reloc64(builder, pos + 2, zs->hiz_bo,
 904                zs->hiz[1], (zs->z_readonly) ? 0 : INTEL_RELOC_WRITE);
 905       }
 906    } else {
 907       dw[1] = zs->hiz[0];
 908       dw[2] = 0;
 909
 910       dw[1] |= builder->mocs << GEN6_HIZ_DW1_MOCS__SHIFT;
 911
 912       if (zs->hiz_bo) {
 913          ilo_builder_batch_reloc(builder, pos + 2, zs->hiz_bo,
 914                zs->hiz[1], (zs->z_readonly) ? 0 : INTEL_RELOC_WRITE);
 915       }
 916    }
 917 }
 918
 919 static inline void
 920 gen6_3DSTATE_CLEAR_PARAMS(struct ilo_builder *builder,
 921                           uint32_t clear_val)
 922 {
 923    const uint8_t cmd_len = 2;
 924    uint32_t *dw;
 925
 926    ILO_DEV_ASSERT(builder->dev, 6, 6);
 927
 928    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 929
 930    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_CLEAR_PARAMS) |
 931            GEN6_CLEAR_PARAMS_DW0_VALID |
 932            (cmd_len - 2);
 933    dw[1] = clear_val;
 934 }
 935
 936 static inline void
 937 gen7_3DSTATE_CLEAR_PARAMS(struct ilo_builder *builder,
 938                           uint32_t clear_val)
 939 {
 940    const uint8_t cmd_len = 3;
 941    uint32_t *dw;
 942
 943    ILO_DEV_ASSERT(builder->dev, 7, 8);
 944
 945    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 946
 947    dw[0] = GEN7_RENDER_CMD(3D, 3DSTATE_CLEAR_PARAMS) | (cmd_len - 2);
 948    dw[1] = clear_val;
 949    dw[2] = GEN7_CLEAR_PARAMS_DW2_VALID;
 950 }
 951
 952 static inline void
 953 gen6_3DSTATE_VIEWPORT_STATE_POINTERS(struct ilo_builder *builder,
 954                                      uint32_t clip_viewport,
 955                                      uint32_t sf_viewport,
 956                                      uint32_t cc_viewport)
 957 {
 958    const uint8_t cmd_len = 4;
 959    uint32_t *dw;
 960
 961    ILO_DEV_ASSERT(builder->dev, 6, 6);
 962
 963    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 964
 965    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_VIEWPORT_STATE_POINTERS) |
 966            GEN6_VP_PTR_DW0_CLIP_CHANGED |
 967            GEN6_VP_PTR_DW0_SF_CHANGED |
 968            GEN6_VP_PTR_DW0_CC_CHANGED |
 969            (cmd_len - 2);
 970    dw[1] = clip_viewport;
 971    dw[2] = sf_viewport;
 972    dw[3] = cc_viewport;
 973 }
 974
 975 static inline void
 976 gen6_3DSTATE_SCISSOR_STATE_POINTERS(struct ilo_builder *builder,
 977                                     uint32_t scissor_rect)
 978 {
 979    const uint8_t cmd_len = 2;
 980    uint32_t *dw;
 981
 982    ILO_DEV_ASSERT(builder->dev, 6, 8);
 983
 984    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 985
 986    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_SCISSOR_STATE_POINTERS) |
 987            (cmd_len - 2);
 988    dw[1] = scissor_rect;
 989 }
 990
 991 static inline void
 992 gen6_3DSTATE_CC_STATE_POINTERS(struct ilo_builder *builder,
 993                                uint32_t blend_state,
 994                                uint32_t depth_stencil_state,
 995                                uint32_t color_calc_state)
 996 {
 997    const uint8_t cmd_len = 4;
 998    uint32_t *dw;
 999
1000    ILO_DEV_ASSERT(builder->dev, 6, 6);
1001
1002    ilo_builder_batch_pointer(builder, cmd_len, &dw);
1003
1004    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_CC_STATE_POINTERS) | (cmd_len - 2);
1005    dw[1] = blend_state | GEN6_CC_PTR_DW1_BLEND_CHANGED;
1006    dw[2] = depth_stencil_state | GEN6_CC_PTR_DW2_ZS_CHANGED;
1007    dw[3] = color_calc_state | GEN6_CC_PTR_DW3_CC_CHANGED;
1008 }
1009
1010 static inline void
1011 gen7_3DSTATE_VIEWPORT_STATE_POINTERS_SF_CLIP(struct ilo_builder *builder,
1012                                              uint32_t sf_clip_viewport)
1013 {
1014    ILO_DEV_ASSERT(builder->dev, 7, 8);
1015
1016    gen7_3dstate_pointer(builder,
1017          GEN7_RENDER_OPCODE_3DSTATE_VIEWPORT_STATE_POINTERS_SF_CLIP,
1018          sf_clip_viewport);
1019 }
1020
1021 static inline void
1022 gen7_3DSTATE_VIEWPORT_STATE_POINTERS_CC(struct ilo_builder *builder,
1023                                         uint32_t cc_viewport)
1024 {
1025    ILO_DEV_ASSERT(builder->dev, 7, 8);
1026
1027    gen7_3dstate_pointer(builder,
1028          GEN7_RENDER_OPCODE_3DSTATE_VIEWPORT_STATE_POINTERS_CC,
1029          cc_viewport);
1030 }
1031
1032 static inline void
1033 gen7_3DSTATE_CC_STATE_POINTERS(struct ilo_builder *builder,
1034                                uint32_t color_calc_state)
1035 {
1036    ILO_DEV_ASSERT(builder->dev, 7, 8);
1037
1038    if (ilo_dev_gen(builder->dev) >= ILO_GEN(8))
1039       color_calc_state |= 1;
1040
1041    gen7_3dstate_pointer(builder,
1042          GEN6_RENDER_OPCODE_3DSTATE_CC_STATE_POINTERS, color_calc_state);
1043 }
1044
1045 static inline void
1046 gen7_3DSTATE_DEPTH_STENCIL_STATE_POINTERS(struct ilo_builder *builder,
1047                                           uint32_t depth_stencil_state)
1048 {
1049    ILO_DEV_ASSERT(builder->dev, 7, 8);
1050
1051    gen7_3dstate_pointer(builder,
1052          GEN7_RENDER_OPCODE_3DSTATE_DEPTH_STENCIL_STATE_POINTERS,
1053          depth_stencil_state);
1054 }
1055
1056 static inline void
1057 gen7_3DSTATE_BLEND_STATE_POINTERS(struct ilo_builder *builder,
1058                                   uint32_t blend_state)
1059 {
1060    ILO_DEV_ASSERT(builder->dev, 7, 8);
1061
1062    if (ilo_dev_gen(builder->dev) >= ILO_GEN(8))
1063       blend_state |= 1;
1064
1065    gen7_3dstate_pointer(builder,
1066          GEN7_RENDER_OPCODE_3DSTATE_BLEND_STATE_POINTERS,
1067          blend_state);
1068 }
1069
1070 static inline uint32_t
1071 gen6_CLIP_VIEWPORT(struct ilo_builder *builder,
1072                    const struct ilo_state_viewport *vp)
1073 {
1074    const int state_align = 32;
1075    const int state_len = 4 * vp->count;
1076    uint32_t state_offset, *dw;
1077    int i;
1078
1079    ILO_DEV_ASSERT(builder->dev, 6, 6);
1080
1081    state_offset = ilo_builder_dynamic_pointer(builder,
1082          ILO_BUILDER_ITEM_CLIP_VIEWPORT, state_align, state_len, &dw);
1083
1084    for (i = 0; i < vp->count; i++) {
1085       /* see viewport_matrix_set_gen7_SF_CLIP_VIEWPORT() */
1086       dw[0] = vp->sf_clip[i][8];
1087       dw[1] = vp->sf_clip[i][9];
1088       dw[2] = vp->sf_clip[i][10];
1089       dw[3] = vp->sf_clip[i][11];
1090
1091       dw += 4;
1092    }
1093
1094    return state_offset;
1095 }
1096
1097 static inline uint32_t
1098 gen6_SF_VIEWPORT(struct ilo_builder *builder,
1099                  const struct ilo_state_viewport *vp)
1100 {
1101    const int state_align = 32;
1102    const int state_len = 8 * vp->count;
1103    uint32_t state_offset, *dw;
1104    int i;
1105
1106    ILO_DEV_ASSERT(builder->dev, 6, 6);
1107
1108    state_offset = ilo_builder_dynamic_pointer(builder,
1109          ILO_BUILDER_ITEM_SF_VIEWPORT, state_align, state_len, &dw);
1110
1111    for (i = 0; i < vp->count; i++) {
1112       /* see viewport_matrix_set_gen7_SF_CLIP_VIEWPORT() */
1113       memcpy(dw, vp->sf_clip[i], sizeof(*dw) * 8);
1114
1115       dw += 8;
1116    }
1117
1118    return state_offset;
1119 }
1120
1121 static inline uint32_t
1122 gen7_SF_CLIP_VIEWPORT(struct ilo_builder *builder,
1123                       const struct ilo_state_viewport *vp)
1124 {
1125    const int state_align = 64;
1126    const int state_len = 16 * vp->count;
1127
1128    ILO_DEV_ASSERT(builder->dev, 7, 8);
1129
1130    /* see viewport_matrix_set_gen7_SF_CLIP_VIEWPORT() */
1131    return ilo_builder_dynamic_write(builder, ILO_BUILDER_ITEM_SF_VIEWPORT,
1132          state_align, state_len, (const uint32_t *) vp->sf_clip);
1133 }
1134
1135 static inline uint32_t
1136 gen6_CC_VIEWPORT(struct ilo_builder *builder,
1137                  const struct ilo_state_viewport *vp)
1138 {
1139    const int state_align = 32;
1140    const int state_len = 2 * vp->count;
1141
1142    ILO_DEV_ASSERT(builder->dev, 6, 8);
1143
1144    /* see viewport_matrix_set_gen6_CC_VIEWPORT() */
1145    return ilo_builder_dynamic_write(builder, ILO_BUILDER_ITEM_CC_VIEWPORT,
1146          state_align, state_len, (const uint32_t *) vp->cc);
1147 }
1148
1149 static inline uint32_t
1150 gen6_SCISSOR_RECT(struct ilo_builder *builder,
1151                   const struct ilo_state_viewport *vp)
1152 {
1153    const int state_align = 32;
1154    const int state_len = 2 * vp->count;
1155
1156    ILO_DEV_ASSERT(builder->dev, 6, 8);
1157
1158    /* see viewport_scissor_set_gen6_SCISSOR_RECT() */
1159    return ilo_builder_dynamic_write(builder, ILO_BUILDER_ITEM_SCISSOR_RECT,
1160          state_align, state_len, (const uint32_t *) vp->scissor);
1161 }
1162
1163 static inline uint32_t
1164 gen6_COLOR_CALC_STATE(struct ilo_builder *builder,
1165                       const struct ilo_state_cc *cc)
1166 {
1167    const int state_align = 64;
1168    const int state_len = 6;
1169
1170    ILO_DEV_ASSERT(builder->dev, 6, 8);
1171
1172    /* see cc_params_set_gen6_COLOR_CALC_STATE() */
1173    return ilo_builder_dynamic_write(builder, ILO_BUILDER_ITEM_COLOR_CALC,
1174          state_align, state_len, cc->cc);
1175 }
1176
1177 static inline uint32_t
1178 gen6_DEPTH_STENCIL_STATE(struct ilo_builder *builder,
1179                          const struct ilo_state_cc *cc)
1180 {
1181    const int state_align = 64;
1182    const int state_len = 3;
1183
1184    ILO_DEV_ASSERT(builder->dev, 6, 7.5);
1185
1186    /* see cc_set_gen6_DEPTH_STENCIL_STATE() */
1187    return ilo_builder_dynamic_write(builder, ILO_BUILDER_ITEM_DEPTH_STENCIL,
1188          state_align, state_len, cc->ds);
1189 }
1190
1191 static inline uint32_t
1192 gen6_BLEND_STATE(struct ilo_builder *builder,
1193                  const struct ilo_state_cc *cc)
1194 {
1195    const int state_align = 64;
1196    const int state_len = 2 * cc->blend_state_count;
1197
1198    ILO_DEV_ASSERT(builder->dev, 6, 7.5);
1199
1200    if (!state_len)
1201       return 0;
1202
1203    /* see cc_set_gen6_BLEND_STATE() */
1204    return ilo_builder_dynamic_write(builder, ILO_BUILDER_ITEM_BLEND,
1205          state_align, state_len, cc->blend);
1206 }
1207
1208 static inline uint32_t
1209 gen8_BLEND_STATE(struct ilo_builder *builder,
1210                  const struct ilo_state_cc *cc)
1211 {
1212    const int state_align = 64;
1213    const int state_len = 1 + 2 * cc->blend_state_count;
1214
1215    ILO_DEV_ASSERT(builder->dev, 8, 8);
1216
1217    /* see cc_set_gen8_BLEND_STATE() */
1218    return ilo_builder_dynamic_write(builder, ILO_BUILDER_ITEM_BLEND,
1219          state_align, state_len, &cc->blend[1]);
1220 }
1221
1222 #endif /* ILO_BUILDER_3D_BOTTOM_H */