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 "intel_winsys.h"
  33
  34 #include "ilo_core.h"
  35 #include "ilo_dev.h"
  36 #include "ilo_format.h"
  37 #include "ilo_state_cc.h"
  38 #include "ilo_state_raster.h"
  39 #include "ilo_state_sbe.h"
  40 #include "ilo_state_shader.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_state_ps *ps,
 204                 uint32_t kernel_offset)
 205 {
 206    const uint8_t cmd_len = 9;
 207    uint32_t *dw;
 208
 209    ILO_DEV_ASSERT(builder->dev, 6, 6);
 210
 211    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 212
 213    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_WM) | (cmd_len - 2);
 214    dw[1] = kernel_offset;
 215    /* see raster_set_gen6_3dstate_wm() and ps_set_gen6_3dstate_wm() */
 216    dw[2] = ps->ps[0];
 217    dw[3] = ps->ps[1];
 218    dw[4] = rs->wm[0] | ps->ps[2];
 219    dw[5] = rs->wm[1] | ps->ps[3];
 220    dw[6] = rs->wm[2] | ps->ps[4];
 221    dw[7] = 0; /* kernel 1 */
 222    dw[8] = 0; /* kernel 2 */
 223 }
 224
 225 static inline void
 226 gen7_3DSTATE_WM(struct ilo_builder *builder,
 227                 const struct ilo_state_raster *rs,
 228                 const struct ilo_state_ps *ps)
 229 {
 230    const uint8_t cmd_len = 3;
 231    uint32_t *dw;
 232
 233    ILO_DEV_ASSERT(builder->dev, 7, 7.5);
 234
 235    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 236
 237    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_WM) | (cmd_len - 2);
 238    /* see raster_set_gen8_3DSTATE_WM() and ps_set_gen7_3dstate_wm() */
 239    dw[1] = rs->wm[0] | ps->ps[0];
 240    dw[2] = ps->ps[1];
 241 }
 242
 243 static inline void
 244 gen8_3DSTATE_WM(struct ilo_builder *builder,
 245                 const struct ilo_state_raster *rs)
 246 {
 247    const uint8_t cmd_len = 2;
 248    uint32_t *dw;
 249
 250    ILO_DEV_ASSERT(builder->dev, 8, 8);
 251
 252    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 253
 254    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_WM) | (cmd_len - 2);
 255    /* see raster_set_gen8_3DSTATE_WM() */
 256    dw[1] = rs->wm[0];
 257 }
 258
 259 static inline void
 260 gen8_3DSTATE_WM_DEPTH_STENCIL(struct ilo_builder *builder,
 261                               const struct ilo_state_cc *cc)
 262 {
 263    const uint8_t cmd_len = 3;
 264    uint32_t *dw;
 265
 266    ILO_DEV_ASSERT(builder->dev, 8, 8);
 267
 268    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 269
 270    dw[0] = GEN8_RENDER_CMD(3D, 3DSTATE_WM_DEPTH_STENCIL) | (cmd_len - 2);
 271    /* see cc_set_gen8_3DSTATE_WM_DEPTH_STENCIL() */
 272    dw[1] = cc->ds[0];
 273    dw[2] = cc->ds[1];
 274 }
 275
 276 static inline void
 277 gen8_3DSTATE_WM_HZ_OP(struct ilo_builder *builder,
 278                       const struct ilo_state_raster *rs,
 279                       uint16_t width, uint16_t height)
 280 {
 281    const uint8_t cmd_len = 5;
 282    uint32_t *dw;
 283
 284    ILO_DEV_ASSERT(builder->dev, 8, 8);
 285
 286    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 287
 288    dw[0] = GEN8_RENDER_CMD(3D, 3DSTATE_WM_HZ_OP) | (cmd_len - 2);
 289    /* see raster_set_gen8_3dstate_wm_hz_op() */
 290    dw[1] = rs->wm[1];
 291    dw[2] = 0;
 292    /* exclusive */
 293    dw[3] = height << 16 | width;
 294    dw[4] = rs->wm[2];
 295 }
 296
 297 static inline void
 298 gen8_disable_3DSTATE_WM_HZ_OP(struct ilo_builder *builder)
 299 {
 300    const uint8_t cmd_len = 5;
 301    uint32_t *dw;
 302
 303    ILO_DEV_ASSERT(builder->dev, 8, 8);
 304
 305    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 306
 307    dw[0] = GEN8_RENDER_CMD(3D, 3DSTATE_WM_HZ_OP) | (cmd_len - 2);
 308    dw[1] = 0;
 309    dw[2] = 0;
 310    dw[3] = 0;
 311    dw[4] = 0;
 312 }
 313
 314 static inline void
 315 gen8_3DSTATE_WM_CHROMAKEY(struct ilo_builder *builder)
 316 {
 317    const uint8_t cmd_len = 2;
 318    uint32_t *dw;
 319
 320    ILO_DEV_ASSERT(builder->dev, 8, 8);
 321
 322    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 323
 324    dw[0] = GEN8_RENDER_CMD(3D, 3DSTATE_WM_CHROMAKEY) | (cmd_len - 2);
 325    dw[1] = 0;
 326 }
 327
 328 static inline void
 329 gen7_3DSTATE_PS(struct ilo_builder *builder,
 330                 const struct ilo_state_ps *ps,
 331                 uint32_t kernel_offset)
 332 {
 333    const uint8_t cmd_len = 8;
 334    uint32_t *dw;
 335
 336    ILO_DEV_ASSERT(builder->dev, 7, 7.5);
 337
 338    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 339
 340    dw[0] = GEN7_RENDER_CMD(3D, 3DSTATE_PS) | (cmd_len - 2);
 341    dw[1] = kernel_offset;
 342    /* see ps_set_gen7_3DSTATE_PS() */
 343    dw[2] = ps->ps[2];
 344    dw[3] = ps->ps[3];
 345    dw[4] = ps->ps[4];
 346    dw[5] = ps->ps[5];
 347    dw[6] = 0; /* kernel 1 */
 348    dw[7] = 0; /* kernel 2 */
 349 }
 350
 351 static inline void
 352 gen8_3DSTATE_PS(struct ilo_builder *builder,
 353                 const struct ilo_state_ps *ps,
 354                 uint32_t kernel_offset)
 355 {
 356    const uint8_t cmd_len = 12;
 357    uint32_t *dw;
 358
 359    ILO_DEV_ASSERT(builder->dev, 8, 8);
 360
 361    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 362
 363    dw[0] = GEN7_RENDER_CMD(3D, 3DSTATE_PS) | (cmd_len - 2);
 364    dw[1] = kernel_offset;
 365    dw[2] = 0;
 366    /* see ps_set_gen8_3DSTATE_PS() */
 367    dw[3] = ps->ps[0];
 368    dw[4] = ps->ps[1];
 369    dw[5] = 0;
 370    dw[6] = ps->ps[2];
 371    dw[7] = ps->ps[3];
 372    dw[8] = 0; /* kernel 1 */
 373    dw[9] = 0;
 374    dw[10] = 0; /* kernel 2 */
 375    dw[11] = 0;
 376 }
 377
 378 static inline void
 379 gen8_3DSTATE_PS_EXTRA(struct ilo_builder *builder,
 380                       const struct ilo_state_ps *ps)
 381 {
 382    const uint8_t cmd_len = 2;
 383    uint32_t *dw;
 384
 385    ILO_DEV_ASSERT(builder->dev, 8, 8);
 386
 387    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 388
 389    dw[0] = GEN8_RENDER_CMD(3D, 3DSTATE_PS_EXTRA) | (cmd_len - 2);
 390    /* see ps_set_gen8_3DSTATE_PS_EXTRA() */
 391    dw[1] = ps->ps[4];
 392 }
 393
 394 static inline void
 395 gen8_3DSTATE_PS_BLEND(struct ilo_builder *builder,
 396                       const struct ilo_state_cc *cc)
 397 {
 398    const uint8_t cmd_len = 2;
 399    uint32_t *dw;
 400
 401    ILO_DEV_ASSERT(builder->dev, 8, 8);
 402
 403    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 404
 405    dw[0] = GEN8_RENDER_CMD(3D, 3DSTATE_PS_BLEND) | (cmd_len - 2);
 406    /* see cc_set_gen8_3DSTATE_PS_BLEND() */
 407    dw[1] = cc->blend[0];
 408 }
 409
 410 static inline void
 411 gen6_3DSTATE_CONSTANT_PS(struct ilo_builder *builder,
 412                          const uint32_t *bufs, const int *sizes,
 413                          int num_bufs)
 414 {
 415    gen6_3dstate_constant(builder, GEN6_RENDER_OPCODE_3DSTATE_CONSTANT_PS,
 416          bufs, sizes, num_bufs);
 417 }
 418
 419 static inline void
 420 gen7_3DSTATE_CONSTANT_PS(struct ilo_builder *builder,
 421                          const uint32_t *bufs, const int *sizes,
 422                          int num_bufs)
 423 {
 424    gen7_3dstate_constant(builder, GEN6_RENDER_OPCODE_3DSTATE_CONSTANT_PS,
 425          bufs, sizes, num_bufs);
 426 }
 427
 428 static inline void
 429 gen7_3DSTATE_BINDING_TABLE_POINTERS_PS(struct ilo_builder *builder,
 430                                        uint32_t binding_table)
 431 {
 432    ILO_DEV_ASSERT(builder->dev, 7, 8);
 433
 434    gen7_3dstate_pointer(builder,
 435          GEN7_RENDER_OPCODE_3DSTATE_BINDING_TABLE_POINTERS_PS,
 436          binding_table);
 437 }
 438
 439 static inline void
 440 gen7_3DSTATE_SAMPLER_STATE_POINTERS_PS(struct ilo_builder *builder,
 441                                        uint32_t sampler_state)
 442 {
 443    ILO_DEV_ASSERT(builder->dev, 7, 8);
 444
 445    gen7_3dstate_pointer(builder,
 446          GEN7_RENDER_OPCODE_3DSTATE_SAMPLER_STATE_POINTERS_PS,
 447          sampler_state);
 448 }
 449
 450 static inline void
 451 gen6_3DSTATE_MULTISAMPLE(struct ilo_builder *builder,
 452                          const struct ilo_state_raster *rs,
 453                          const uint32_t *pattern, int pattern_len)
 454 {
 455    const uint8_t cmd_len = (ilo_dev_gen(builder->dev) >= ILO_GEN(7)) ? 4 : 3;
 456    uint32_t *dw;
 457
 458    ILO_DEV_ASSERT(builder->dev, 6, 7.5);
 459
 460    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 461
 462    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_MULTISAMPLE) | (cmd_len - 2);
 463    /* see raster_set_gen8_3DSTATE_MULTISAMPLE() */
 464    dw[1] = rs->sample[0];
 465
 466    assert(pattern_len == 1 || pattern_len == 2);
 467    dw[2] = pattern[0];
 468    if (ilo_dev_gen(builder->dev) >= ILO_GEN(7))
 469       dw[3] = (pattern_len == 2) ? pattern[1] : 0;
 470 }
 471
 472 static inline void
 473 gen8_3DSTATE_MULTISAMPLE(struct ilo_builder *builder,
 474                          const struct ilo_state_raster *rs)
 475 {
 476    const uint8_t cmd_len = 2;
 477    uint32_t *dw;
 478
 479    ILO_DEV_ASSERT(builder->dev, 8, 8);
 480
 481    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 482
 483    dw[0] = GEN8_RENDER_CMD(3D, 3DSTATE_MULTISAMPLE) | (cmd_len - 2);
 484    /* see raster_set_gen8_3DSTATE_MULTISAMPLE() */
 485    dw[1] = rs->sample[0];
 486 }
 487
 488 static inline void
 489 gen8_3DSTATE_SAMPLE_PATTERN(struct ilo_builder *builder,
 490                             const uint32_t *pattern_1x,
 491                             const uint32_t *pattern_2x,
 492                             const uint32_t *pattern_4x,
 493                             const uint32_t *pattern_8x,
 494                             const uint32_t *pattern_16x)
 495 {
 496    const uint8_t cmd_len = 9;
 497    uint32_t *dw;
 498
 499    ILO_DEV_ASSERT(builder->dev, 8, 8);
 500
 501    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 502
 503    dw[0] = GEN8_RENDER_CMD(3D, 3DSTATE_SAMPLE_PATTERN) | (cmd_len - 2);
 504    dw[1] = pattern_16x[3];
 505    dw[2] = pattern_16x[2];
 506    dw[3] = pattern_16x[1];
 507    dw[4] = pattern_16x[0];
 508    dw[5] = pattern_8x[1];
 509    dw[6] = pattern_8x[0];
 510    dw[7] = pattern_4x[0];
 511    dw[8] = pattern_1x[0] << 16 |
 512            pattern_2x[0];
 513 }
 514
 515 static inline void
 516 gen6_3DSTATE_SAMPLE_MASK(struct ilo_builder *builder,
 517                          const struct ilo_state_raster *rs)
 518 {
 519    const uint8_t cmd_len = 2;
 520    uint32_t *dw;
 521
 522    ILO_DEV_ASSERT(builder->dev, 6, 8);
 523
 524    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 525
 526    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_SAMPLE_MASK) | (cmd_len - 2);
 527    /* see raster_set_gen6_3DSTATE_SAMPLE_MASK() */
 528    dw[1] = rs->sample[1];
 529 }
 530
 531 static inline void
 532 gen6_3DSTATE_DRAWING_RECTANGLE(struct ilo_builder *builder,
 533                                unsigned x, unsigned y,
 534                                unsigned width, unsigned height)
 535 {
 536    const uint8_t cmd_len = 4;
 537    unsigned xmax = x + width - 1;
 538    unsigned ymax = y + height - 1;
 539    unsigned rect_limit;
 540    uint32_t *dw;
 541
 542    ILO_DEV_ASSERT(builder->dev, 6, 8);
 543
 544    if (ilo_dev_gen(builder->dev) >= ILO_GEN(7)) {
 545       rect_limit = 16383;
 546    }
 547    else {
 548       /*
 549        * From the Sandy Bridge PRM, volume 2 part 1, page 230:
 550        *
 551        *     "[DevSNB] Errata: This field (Clipped Drawing Rectangle Y Min)
 552        *      must be an even number"
 553        */
 554       assert(y % 2 == 0);
 555
 556       rect_limit = 8191;
 557    }
 558
 559    if (x > rect_limit) x = rect_limit;
 560    if (y > rect_limit) y = rect_limit;
 561    if (xmax > rect_limit) xmax = rect_limit;
 562    if (ymax > rect_limit) ymax = rect_limit;
 563
 564    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 565
 566    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_DRAWING_RECTANGLE) | (cmd_len - 2);
 567    dw[1] = y << 16 | x;
 568    dw[2] = ymax << 16 | xmax;
 569    /*
 570     * There is no need to set the origin.  It is intended to support front
 571     * buffer rendering.
 572     */
 573    dw[3] = 0;
 574 }
 575
 576 static inline void
 577 gen6_3DSTATE_POLY_STIPPLE_OFFSET(struct ilo_builder *builder,
 578                                  int x_offset, int y_offset)
 579 {
 580    const uint8_t cmd_len = 2;
 581    uint32_t *dw;
 582
 583    ILO_DEV_ASSERT(builder->dev, 6, 8);
 584
 585    assert(x_offset >= 0 && x_offset <= 31);
 586    assert(y_offset >= 0 && y_offset <= 31);
 587
 588    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 589
 590    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_POLY_STIPPLE_OFFSET) | (cmd_len - 2);
 591    dw[1] = x_offset << 8 | y_offset;
 592 }
 593
 594 static inline void
 595 gen6_3DSTATE_POLY_STIPPLE_PATTERN(struct ilo_builder *builder,
 596                                   const struct pipe_poly_stipple *pattern)
 597 {
 598    const uint8_t cmd_len = 33;
 599    uint32_t *dw;
 600    int i;
 601
 602    ILO_DEV_ASSERT(builder->dev, 6, 8);
 603
 604    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 605
 606    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_POLY_STIPPLE_PATTERN) | (cmd_len - 2);
 607    dw++;
 608
 609    STATIC_ASSERT(Elements(pattern->stipple) == 32);
 610    for (i = 0; i < 32; i++)
 611       dw[i] = pattern->stipple[i];
 612 }
 613
 614 static inline void
 615 gen6_3DSTATE_LINE_STIPPLE(struct ilo_builder *builder,
 616                           unsigned pattern, unsigned factor)
 617 {
 618    const uint8_t cmd_len = 3;
 619    unsigned inverse;
 620    uint32_t *dw;
 621
 622    ILO_DEV_ASSERT(builder->dev, 6, 8);
 623
 624    assert((pattern & 0xffff) == pattern);
 625    assert(factor >= 1 && factor <= 256);
 626
 627    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 628
 629    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_LINE_STIPPLE) | (cmd_len - 2);
 630    dw[1] = pattern;
 631
 632    if (ilo_dev_gen(builder->dev) >= ILO_GEN(7)) {
 633       /* in U1.16 */
 634       inverse = 65536 / factor;
 635
 636       dw[2] = inverse << GEN7_LINE_STIPPLE_DW2_INVERSE_REPEAT_COUNT__SHIFT |
 637               factor;
 638    }
 639    else {
 640       /* in U1.13 */
 641       inverse = 8192 / factor;
 642
 643       dw[2] = inverse << GEN6_LINE_STIPPLE_DW2_INVERSE_REPEAT_COUNT__SHIFT |
 644               factor;
 645    }
 646 }
 647
 648 static inline void
 649 gen6_3DSTATE_AA_LINE_PARAMETERS(struct ilo_builder *builder,
 650                                 const struct ilo_state_raster *rs)
 651 {
 652    const uint8_t cmd_len = 3;
 653    uint32_t *dw;
 654
 655    ILO_DEV_ASSERT(builder->dev, 6, 8);
 656
 657    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 658
 659    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_AA_LINE_PARAMETERS) | (cmd_len - 2);
 660    /* constant */
 661    dw[1] = 0 << GEN6_AA_LINE_DW1_BIAS__SHIFT |
 662            0 << GEN6_AA_LINE_DW1_SLOPE__SHIFT;
 663    dw[2] = 0 << GEN6_AA_LINE_DW2_CAP_BIAS__SHIFT |
 664            0 << GEN6_AA_LINE_DW2_CAP_SLOPE__SHIFT;
 665 }
 666
 667 static inline void
 668 gen6_3DSTATE_DEPTH_BUFFER(struct ilo_builder *builder,
 669                           const struct ilo_state_zs *zs)
 670 {
 671    const uint32_t cmd = (ilo_dev_gen(builder->dev) >= ILO_GEN(7)) ?
 672       GEN7_RENDER_CMD(3D, 3DSTATE_DEPTH_BUFFER) :
 673       GEN6_RENDER_CMD(3D, 3DSTATE_DEPTH_BUFFER);
 674    const uint8_t cmd_len = (ilo_dev_gen(builder->dev) >= ILO_GEN(8)) ? 8 : 7;
 675    uint32_t *dw;
 676    unsigned pos;
 677
 678    ILO_DEV_ASSERT(builder->dev, 6, 8);
 679
 680    pos = ilo_builder_batch_pointer(builder, cmd_len, &dw);
 681
 682    dw[0] = cmd | (cmd_len - 2);
 683
 684    /*
 685     * see zs_set_gen6_3DSTATE_DEPTH_BUFFER() and
 686     * zs_set_gen7_3DSTATE_DEPTH_BUFFER()
 687     */
 688    if (ilo_dev_gen(builder->dev) >= ILO_GEN(8)) {
 689       dw[1] = zs->depth[0];
 690       dw[2] = 0;
 691       dw[3] = 0;
 692       dw[4] = zs->depth[2];
 693       dw[5] = zs->depth[3];
 694       dw[6] = 0;
 695       dw[7] = zs->depth[4];
 696
 697       dw[5] |= builder->mocs << GEN8_DEPTH_DW5_MOCS__SHIFT;
 698
 699       if (zs->depth_bo) {
 700          ilo_builder_batch_reloc64(builder, pos + 2, zs->depth_bo,
 701                zs->depth[1], (zs->z_readonly) ? 0 : INTEL_RELOC_WRITE);
 702       }
 703    } else {
 704       dw[1] = zs->depth[0];
 705       dw[2] = 0;
 706       dw[3] = zs->depth[2];
 707       dw[4] = zs->depth[3];
 708       dw[5] = 0;
 709       dw[6] = zs->depth[4];
 710
 711       if (ilo_dev_gen(builder->dev) >= ILO_GEN(7))
 712          dw[4] |= builder->mocs << GEN7_DEPTH_DW4_MOCS__SHIFT;
 713       else
 714          dw[6] |= builder->mocs << GEN6_DEPTH_DW6_MOCS__SHIFT;
 715
 716       if (zs->depth_bo) {
 717          ilo_builder_batch_reloc(builder, pos + 2, zs->depth_bo,
 718                zs->depth[1], (zs->z_readonly) ? 0 : INTEL_RELOC_WRITE);
 719       }
 720    }
 721 }
 722
 723 static inline void
 724 gen6_3DSTATE_STENCIL_BUFFER(struct ilo_builder *builder,
 725                             const struct ilo_state_zs *zs)
 726 {
 727    const uint32_t cmd = (ilo_dev_gen(builder->dev) >= ILO_GEN(7)) ?
 728       GEN7_RENDER_CMD(3D, 3DSTATE_STENCIL_BUFFER) :
 729       GEN6_RENDER_CMD(3D, 3DSTATE_STENCIL_BUFFER);
 730    const uint8_t cmd_len = (ilo_dev_gen(builder->dev) >= ILO_GEN(8)) ? 5 : 3;
 731    uint32_t *dw;
 732    unsigned pos;
 733
 734    ILO_DEV_ASSERT(builder->dev, 6, 8);
 735
 736    pos = ilo_builder_batch_pointer(builder, cmd_len, &dw);
 737
 738    dw[0] = cmd | (cmd_len - 2);
 739
 740    /* see zs_set_gen6_3DSTATE_STENCIL_BUFFER() */
 741    if (ilo_dev_gen(builder->dev) >= ILO_GEN(8)) {
 742       dw[1] = zs->stencil[0];
 743       dw[2] = 0;
 744       dw[3] = 0;
 745       dw[4] = zs->stencil[2];
 746
 747       dw[1] |= builder->mocs << GEN8_STENCIL_DW1_MOCS__SHIFT;
 748
 749       if (zs->stencil_bo) {
 750          ilo_builder_batch_reloc64(builder, pos + 2, zs->stencil_bo,
 751                zs->stencil[1], (zs->s_readonly) ? 0 : INTEL_RELOC_WRITE);
 752       }
 753    } else {
 754       dw[1] = zs->stencil[0];
 755       dw[2] = 0;
 756
 757       dw[1] |= builder->mocs << GEN6_STENCIL_DW1_MOCS__SHIFT;
 758
 759       if (zs->stencil_bo) {
 760          ilo_builder_batch_reloc(builder, pos + 2, zs->stencil_bo,
 761                zs->stencil[1], (zs->s_readonly) ? 0 : INTEL_RELOC_WRITE);
 762       }
 763    }
 764 }
 765
 766 static inline void
 767 gen6_3DSTATE_HIER_DEPTH_BUFFER(struct ilo_builder *builder,
 768                                const struct ilo_state_zs *zs)
 769 {
 770    const uint32_t cmd = (ilo_dev_gen(builder->dev) >= ILO_GEN(7)) ?
 771       GEN7_RENDER_CMD(3D, 3DSTATE_HIER_DEPTH_BUFFER) :
 772       GEN6_RENDER_CMD(3D, 3DSTATE_HIER_DEPTH_BUFFER);
 773    const uint8_t cmd_len = (ilo_dev_gen(builder->dev) >= ILO_GEN(8)) ? 5 : 3;
 774    uint32_t *dw;
 775    unsigned pos;
 776
 777    ILO_DEV_ASSERT(builder->dev, 6, 8);
 778
 779    pos = ilo_builder_batch_pointer(builder, cmd_len, &dw);
 780
 781    dw[0] = cmd | (cmd_len - 2);
 782
 783    /* see zs_set_gen6_3DSTATE_HIER_DEPTH_BUFFER() */
 784    if (ilo_dev_gen(builder->dev) >= ILO_GEN(8)) {
 785       dw[1] = zs->hiz[0];
 786       dw[2] = 0;
 787       dw[3] = 0;
 788       dw[4] = zs->hiz[2];
 789
 790       dw[1] |= builder->mocs << GEN8_HIZ_DW1_MOCS__SHIFT;
 791
 792       if (zs->hiz_bo) {
 793          ilo_builder_batch_reloc64(builder, pos + 2, zs->hiz_bo,
 794                zs->hiz[1], (zs->z_readonly) ? 0 : INTEL_RELOC_WRITE);
 795       }
 796    } else {
 797       dw[1] = zs->hiz[0];
 798       dw[2] = 0;
 799
 800       dw[1] |= builder->mocs << GEN6_HIZ_DW1_MOCS__SHIFT;
 801
 802       if (zs->hiz_bo) {
 803          ilo_builder_batch_reloc(builder, pos + 2, zs->hiz_bo,
 804                zs->hiz[1], (zs->z_readonly) ? 0 : INTEL_RELOC_WRITE);
 805       }
 806    }
 807 }
 808
 809 static inline void
 810 gen6_3DSTATE_CLEAR_PARAMS(struct ilo_builder *builder,
 811                           uint32_t clear_val)
 812 {
 813    const uint8_t cmd_len = 2;
 814    uint32_t *dw;
 815
 816    ILO_DEV_ASSERT(builder->dev, 6, 6);
 817
 818    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 819
 820    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_CLEAR_PARAMS) |
 821            GEN6_CLEAR_PARAMS_DW0_VALID |
 822            (cmd_len - 2);
 823    dw[1] = clear_val;
 824 }
 825
 826 static inline void
 827 gen7_3DSTATE_CLEAR_PARAMS(struct ilo_builder *builder,
 828                           uint32_t clear_val)
 829 {
 830    const uint8_t cmd_len = 3;
 831    uint32_t *dw;
 832
 833    ILO_DEV_ASSERT(builder->dev, 7, 8);
 834
 835    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 836
 837    dw[0] = GEN7_RENDER_CMD(3D, 3DSTATE_CLEAR_PARAMS) | (cmd_len - 2);
 838    dw[1] = clear_val;
 839    dw[2] = GEN7_CLEAR_PARAMS_DW2_VALID;
 840 }
 841
 842 static inline void
 843 gen6_3DSTATE_VIEWPORT_STATE_POINTERS(struct ilo_builder *builder,
 844                                      uint32_t clip_viewport,
 845                                      uint32_t sf_viewport,
 846                                      uint32_t cc_viewport)
 847 {
 848    const uint8_t cmd_len = 4;
 849    uint32_t *dw;
 850
 851    ILO_DEV_ASSERT(builder->dev, 6, 6);
 852
 853    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 854
 855    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_VIEWPORT_STATE_POINTERS) |
 856            GEN6_VP_PTR_DW0_CLIP_CHANGED |
 857            GEN6_VP_PTR_DW0_SF_CHANGED |
 858            GEN6_VP_PTR_DW0_CC_CHANGED |
 859            (cmd_len - 2);
 860    dw[1] = clip_viewport;
 861    dw[2] = sf_viewport;
 862    dw[3] = cc_viewport;
 863 }
 864
 865 static inline void
 866 gen6_3DSTATE_SCISSOR_STATE_POINTERS(struct ilo_builder *builder,
 867                                     uint32_t scissor_rect)
 868 {
 869    const uint8_t cmd_len = 2;
 870    uint32_t *dw;
 871
 872    ILO_DEV_ASSERT(builder->dev, 6, 8);
 873
 874    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 875
 876    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_SCISSOR_STATE_POINTERS) |
 877            (cmd_len - 2);
 878    dw[1] = scissor_rect;
 879 }
 880
 881 static inline void
 882 gen6_3DSTATE_CC_STATE_POINTERS(struct ilo_builder *builder,
 883                                uint32_t blend_state,
 884                                uint32_t depth_stencil_state,
 885                                uint32_t color_calc_state)
 886 {
 887    const uint8_t cmd_len = 4;
 888    uint32_t *dw;
 889
 890    ILO_DEV_ASSERT(builder->dev, 6, 6);
 891
 892    ilo_builder_batch_pointer(builder, cmd_len, &dw);
 893
 894    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_CC_STATE_POINTERS) | (cmd_len - 2);
 895    dw[1] = blend_state | GEN6_CC_PTR_DW1_BLEND_CHANGED;
 896    dw[2] = depth_stencil_state | GEN6_CC_PTR_DW2_ZS_CHANGED;
 897    dw[3] = color_calc_state | GEN6_CC_PTR_DW3_CC_CHANGED;
 898 }
 899
 900 static inline void
 901 gen7_3DSTATE_VIEWPORT_STATE_POINTERS_SF_CLIP(struct ilo_builder *builder,
 902                                              uint32_t sf_clip_viewport)
 903 {
 904    ILO_DEV_ASSERT(builder->dev, 7, 8);
 905
 906    gen7_3dstate_pointer(builder,
 907          GEN7_RENDER_OPCODE_3DSTATE_VIEWPORT_STATE_POINTERS_SF_CLIP,
 908          sf_clip_viewport);
 909 }
 910
 911 static inline void
 912 gen7_3DSTATE_VIEWPORT_STATE_POINTERS_CC(struct ilo_builder *builder,
 913                                         uint32_t cc_viewport)
 914 {
 915    ILO_DEV_ASSERT(builder->dev, 7, 8);
 916
 917    gen7_3dstate_pointer(builder,
 918          GEN7_RENDER_OPCODE_3DSTATE_VIEWPORT_STATE_POINTERS_CC,
 919          cc_viewport);
 920 }
 921
 922 static inline void
 923 gen7_3DSTATE_CC_STATE_POINTERS(struct ilo_builder *builder,
 924                                uint32_t color_calc_state)
 925 {
 926    ILO_DEV_ASSERT(builder->dev, 7, 8);
 927
 928    if (ilo_dev_gen(builder->dev) >= ILO_GEN(8))
 929       color_calc_state |= 1;
 930
 931    gen7_3dstate_pointer(builder,
 932          GEN6_RENDER_OPCODE_3DSTATE_CC_STATE_POINTERS, color_calc_state);
 933 }
 934
 935 static inline void
 936 gen7_3DSTATE_DEPTH_STENCIL_STATE_POINTERS(struct ilo_builder *builder,
 937                                           uint32_t depth_stencil_state)
 938 {
 939    ILO_DEV_ASSERT(builder->dev, 7, 8);
 940
 941    gen7_3dstate_pointer(builder,
 942          GEN7_RENDER_OPCODE_3DSTATE_DEPTH_STENCIL_STATE_POINTERS,
 943          depth_stencil_state);
 944 }
 945
 946 static inline void
 947 gen7_3DSTATE_BLEND_STATE_POINTERS(struct ilo_builder *builder,
 948                                   uint32_t blend_state)
 949 {
 950    ILO_DEV_ASSERT(builder->dev, 7, 8);
 951
 952    if (ilo_dev_gen(builder->dev) >= ILO_GEN(8))
 953       blend_state |= 1;
 954
 955    gen7_3dstate_pointer(builder,
 956          GEN7_RENDER_OPCODE_3DSTATE_BLEND_STATE_POINTERS,
 957          blend_state);
 958 }
 959
 960 static inline uint32_t
 961 gen6_CLIP_VIEWPORT(struct ilo_builder *builder,
 962                    const struct ilo_state_viewport *vp)
 963 {
 964    const int state_align = 32;
 965    const int state_len = 4 * vp->count;
 966    uint32_t state_offset, *dw;
 967    int i;
 968
 969    ILO_DEV_ASSERT(builder->dev, 6, 6);
 970
 971    state_offset = ilo_builder_dynamic_pointer(builder,
 972          ILO_BUILDER_ITEM_CLIP_VIEWPORT, state_align, state_len, &dw);
 973
 974    for (i = 0; i < vp->count; i++) {
 975       /* see viewport_matrix_set_gen7_SF_CLIP_VIEWPORT() */
 976       dw[0] = vp->sf_clip[i][8];
 977       dw[1] = vp->sf_clip[i][9];
 978       dw[2] = vp->sf_clip[i][10];
 979       dw[3] = vp->sf_clip[i][11];
 980
 981       dw += 4;
 982    }
 983
 984    return state_offset;
 985 }
 986
 987 static inline uint32_t
 988 gen6_SF_VIEWPORT(struct ilo_builder *builder,
 989                  const struct ilo_state_viewport *vp)
 990 {
 991    const int state_align = 32;
 992    const int state_len = 8 * vp->count;
 993    uint32_t state_offset, *dw;
 994    int i;
 995
 996    ILO_DEV_ASSERT(builder->dev, 6, 6);
 997
 998    state_offset = ilo_builder_dynamic_pointer(builder,
 999          ILO_BUILDER_ITEM_SF_VIEWPORT, state_align, state_len, &dw);
1000
1001    for (i = 0; i < vp->count; i++) {
1002       /* see viewport_matrix_set_gen7_SF_CLIP_VIEWPORT() */
1003       memcpy(dw, vp->sf_clip[i], sizeof(*dw) * 8);
1004
1005       dw += 8;
1006    }
1007
1008    return state_offset;
1009 }
1010
1011 static inline uint32_t
1012 gen7_SF_CLIP_VIEWPORT(struct ilo_builder *builder,
1013                       const struct ilo_state_viewport *vp)
1014 {
1015    const int state_align = 64;
1016    const int state_len = 16 * vp->count;
1017
1018    ILO_DEV_ASSERT(builder->dev, 7, 8);
1019
1020    /* see viewport_matrix_set_gen7_SF_CLIP_VIEWPORT() */
1021    return ilo_builder_dynamic_write(builder, ILO_BUILDER_ITEM_SF_VIEWPORT,
1022          state_align, state_len, (const uint32_t *) vp->sf_clip);
1023 }
1024
1025 static inline uint32_t
1026 gen6_CC_VIEWPORT(struct ilo_builder *builder,
1027                  const struct ilo_state_viewport *vp)
1028 {
1029    const int state_align = 32;
1030    const int state_len = 2 * vp->count;
1031
1032    ILO_DEV_ASSERT(builder->dev, 6, 8);
1033
1034    /* see viewport_matrix_set_gen6_CC_VIEWPORT() */
1035    return ilo_builder_dynamic_write(builder, ILO_BUILDER_ITEM_CC_VIEWPORT,
1036          state_align, state_len, (const uint32_t *) vp->cc);
1037 }
1038
1039 static inline uint32_t
1040 gen6_SCISSOR_RECT(struct ilo_builder *builder,
1041                   const struct ilo_state_viewport *vp)
1042 {
1043    const int state_align = 32;
1044    const int state_len = 2 * vp->count;
1045
1046    ILO_DEV_ASSERT(builder->dev, 6, 8);
1047
1048    /* see viewport_scissor_set_gen6_SCISSOR_RECT() */
1049    return ilo_builder_dynamic_write(builder, ILO_BUILDER_ITEM_SCISSOR_RECT,
1050          state_align, state_len, (const uint32_t *) vp->scissor);
1051 }
1052
1053 static inline uint32_t
1054 gen6_COLOR_CALC_STATE(struct ilo_builder *builder,
1055                       const struct ilo_state_cc *cc)
1056 {
1057    const int state_align = 64;
1058    const int state_len = 6;
1059
1060    ILO_DEV_ASSERT(builder->dev, 6, 8);
1061
1062    /* see cc_params_set_gen6_COLOR_CALC_STATE() */
1063    return ilo_builder_dynamic_write(builder, ILO_BUILDER_ITEM_COLOR_CALC,
1064          state_align, state_len, cc->cc);
1065 }
1066
1067 static inline uint32_t
1068 gen6_DEPTH_STENCIL_STATE(struct ilo_builder *builder,
1069                          const struct ilo_state_cc *cc)
1070 {
1071    const int state_align = 64;
1072    const int state_len = 3;
1073
1074    ILO_DEV_ASSERT(builder->dev, 6, 7.5);
1075
1076    /* see cc_set_gen6_DEPTH_STENCIL_STATE() */
1077    return ilo_builder_dynamic_write(builder, ILO_BUILDER_ITEM_DEPTH_STENCIL,
1078          state_align, state_len, cc->ds);
1079 }
1080
1081 static inline uint32_t
1082 gen6_BLEND_STATE(struct ilo_builder *builder,
1083                  const struct ilo_state_cc *cc)
1084 {
1085    const int state_align = 64;
1086    const int state_len = 2 * cc->blend_state_count;
1087
1088    ILO_DEV_ASSERT(builder->dev, 6, 7.5);
1089
1090    if (!state_len)
1091       return 0;
1092
1093    /* see cc_set_gen6_BLEND_STATE() */
1094    return ilo_builder_dynamic_write(builder, ILO_BUILDER_ITEM_BLEND,
1095          state_align, state_len, cc->blend);
1096 }
1097
1098 static inline uint32_t
1099 gen8_BLEND_STATE(struct ilo_builder *builder,
1100                  const struct ilo_state_cc *cc)
1101 {
1102    const int state_align = 64;
1103    const int state_len = 1 + 2 * cc->blend_state_count;
1104
1105    ILO_DEV_ASSERT(builder->dev, 8, 8);
1106
1107    /* see cc_set_gen8_BLEND_STATE() */
1108    return ilo_builder_dynamic_write(builder, ILO_BUILDER_ITEM_BLEND,
1109          state_align, state_len, &cc->blend[1]);
1110 }
1111
1112 #endif /* ILO_BUILDER_3D_BOTTOM_H */