Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  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_builder.h"
  39. #include "ilo_builder_3d_top.h"
  40.  
  41. static inline void
  42. gen6_3DSTATE_CLIP(struct ilo_builder *builder,
  43.                   const struct ilo_rasterizer_state *rasterizer,
  44.                   const struct ilo_shader_state *fs,
  45.                   bool enable_guardband,
  46.                   int num_viewports)
  47. {
  48.    const uint8_t cmd_len = 4;
  49.    uint32_t dw1, dw2, dw3, *dw;
  50.    int interps;
  51.  
  52.    ILO_DEV_ASSERT(builder->dev, 6, 8);
  53.  
  54.    dw1 = rasterizer->clip.payload[0];
  55.    dw2 = rasterizer->clip.payload[1];
  56.    dw3 = rasterizer->clip.payload[2];
  57.  
  58.    if (enable_guardband && rasterizer->clip.can_enable_guardband)
  59.       dw2 |= GEN6_CLIP_DW2_GB_TEST_ENABLE;
  60.  
  61.    interps = (fs) ?  ilo_shader_get_kernel_param(fs,
  62.          ILO_KERNEL_FS_BARYCENTRIC_INTERPOLATIONS) : 0;
  63.  
  64.    if (interps & (GEN6_INTERP_NONPERSPECTIVE_PIXEL |
  65.                   GEN6_INTERP_NONPERSPECTIVE_CENTROID |
  66.                   GEN6_INTERP_NONPERSPECTIVE_SAMPLE))
  67.       dw2 |= GEN6_CLIP_DW2_NONPERSPECTIVE_BARYCENTRIC_ENABLE;
  68.  
  69.    dw3 |= GEN6_CLIP_DW3_RTAINDEX_FORCED_ZERO |
  70.           (num_viewports - 1);
  71.  
  72.    ilo_builder_batch_pointer(builder, cmd_len, &dw);
  73.  
  74.    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_CLIP) | (cmd_len - 2);
  75.    dw[1] = dw1;
  76.    dw[2] = dw2;
  77.    dw[3] = dw3;
  78. }
  79.  
  80. static inline void
  81. gen6_disable_3DSTATE_CLIP(struct ilo_builder *builder)
  82. {
  83.    const uint8_t cmd_len = 4;
  84.    uint32_t *dw;
  85.  
  86.    ILO_DEV_ASSERT(builder->dev, 6, 7.5);
  87.  
  88.    ilo_builder_batch_pointer(builder, cmd_len, &dw);
  89.  
  90.    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_CLIP) | (cmd_len - 2);
  91.    dw[1] = 0;
  92.    dw[2] = 0;
  93.    dw[3] = 0;
  94. }
  95.  
  96. static inline void
  97. gen7_internal_3dstate_sf(struct ilo_builder *builder,
  98.                          uint8_t cmd_len, uint32_t *dw,
  99.                          const struct ilo_rasterizer_sf *sf,
  100.                          int num_samples)
  101. {
  102.    ILO_DEV_ASSERT(builder->dev, 6, 7.5);
  103.  
  104.    assert(cmd_len == 7);
  105.  
  106.    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_SF) | (cmd_len - 2);
  107.  
  108.    if (!sf) {
  109.       dw[1] = 0;
  110.       dw[2] = (num_samples > 1) ? GEN7_SF_DW2_MSRASTMODE_ON_PATTERN : 0;
  111.       dw[3] = 0;
  112.       dw[4] = 0;
  113.       dw[5] = 0;
  114.       dw[6] = 0;
  115.  
  116.       return;
  117.    }
  118.  
  119.    /* see rasterizer_init_sf_gen6() */
  120.    STATIC_ASSERT(Elements(sf->payload) >= 3);
  121.    dw[1] = sf->payload[0];
  122.    dw[2] = sf->payload[1];
  123.    dw[3] = sf->payload[2];
  124.  
  125.    if (num_samples > 1)
  126.       dw[2] |= sf->dw_msaa;
  127.  
  128.    dw[4] = sf->dw_depth_offset_const;
  129.    dw[5] = sf->dw_depth_offset_scale;
  130.    dw[6] = sf->dw_depth_offset_clamp;
  131. }
  132.  
  133. static inline void
  134. gen8_internal_3dstate_sbe(struct ilo_builder *builder,
  135.                           uint8_t cmd_len, uint32_t *dw,
  136.                           const struct ilo_shader_state *fs,
  137.                           int sprite_coord_mode)
  138. {
  139.    const struct ilo_kernel_routing *routing;
  140.    int vue_offset, vue_len, out_count;
  141.  
  142.    ILO_DEV_ASSERT(builder->dev, 6, 8);
  143.  
  144.    assert(cmd_len == 4);
  145.  
  146.    dw[0] = GEN7_RENDER_CMD(3D, 3DSTATE_SBE) | (cmd_len - 2);
  147.  
  148.    if (!fs) {
  149.       dw[1] = 1 << GEN7_SBE_DW1_URB_READ_LEN__SHIFT;
  150.       dw[2] = 0;
  151.       dw[3] = 0;
  152.       return;
  153.    }
  154.  
  155.    routing = ilo_shader_get_kernel_routing(fs);
  156.  
  157.    vue_offset = routing->source_skip;
  158.    assert(vue_offset % 2 == 0);
  159.    vue_offset /= 2;
  160.  
  161.    vue_len = (routing->source_len + 1) / 2;
  162.    if (!vue_len)
  163.       vue_len = 1;
  164.  
  165.    out_count = ilo_shader_get_kernel_param(fs, ILO_KERNEL_INPUT_COUNT);
  166.    assert(out_count <= 32);
  167.  
  168.    dw[1] = out_count << GEN7_SBE_DW1_ATTR_COUNT__SHIFT |
  169.            vue_len << GEN7_SBE_DW1_URB_READ_LEN__SHIFT;
  170.  
  171.    if (ilo_dev_gen(builder->dev) >= ILO_GEN(8)) {
  172.       dw[1] |= GEN8_SBE_DW1_USE_URB_READ_LEN |
  173.                GEN8_SBE_DW1_USE_URB_READ_OFFSET |
  174.                vue_offset << GEN8_SBE_DW1_URB_READ_OFFSET__SHIFT;
  175.    } else {
  176.       dw[1] |= vue_offset << GEN7_SBE_DW1_URB_READ_OFFSET__SHIFT;
  177.    }
  178.  
  179.    if (routing->swizzle_enable)
  180.       dw[1] |= GEN7_SBE_DW1_ATTR_SWIZZLE_ENABLE;
  181.  
  182.    switch (sprite_coord_mode) {
  183.    case PIPE_SPRITE_COORD_UPPER_LEFT:
  184.       dw[1] |= GEN7_SBE_DW1_POINT_SPRITE_TEXCOORD_UPPERLEFT;
  185.       break;
  186.    case PIPE_SPRITE_COORD_LOWER_LEFT:
  187.       dw[1] |= GEN7_SBE_DW1_POINT_SPRITE_TEXCOORD_LOWERLEFT;
  188.       break;
  189.    }
  190.  
  191.    /*
  192.     * From the Ivy Bridge PRM, volume 2 part 1, page 268:
  193.     *
  194.     *     "This field (Point Sprite Texture Coordinate Enable) must be
  195.     *      programmed to 0 when non-point primitives are rendered."
  196.     *
  197.     * TODO We do not check that yet.
  198.     */
  199.    dw[2] = routing->point_sprite_enable;
  200.  
  201.    dw[3] = routing->const_interp_enable;
  202. }
  203.  
  204. static inline void
  205. gen8_internal_3dstate_sbe_swiz(struct ilo_builder *builder,
  206.                                uint8_t cmd_len, uint32_t *dw,
  207.                                const struct ilo_shader_state *fs)
  208. {
  209.    const struct ilo_kernel_routing *routing;
  210.  
  211.    ILO_DEV_ASSERT(builder->dev, 6, 8);
  212.  
  213.    assert(cmd_len == 11);
  214.  
  215.    dw[0] = GEN8_RENDER_CMD(3D, 3DSTATE_SBE_SWIZ) | (cmd_len - 2);
  216.  
  217.    if (!fs) {
  218.       memset(&dw[1], 0, sizeof(*dw) * (cmd_len - 1));
  219.       return;
  220.    }
  221.  
  222.    routing = ilo_shader_get_kernel_routing(fs);
  223.  
  224.    STATIC_ASSERT(sizeof(routing->swizzles) >= sizeof(*dw) * 8);
  225.    memcpy(&dw[1], routing->swizzles, sizeof(*dw) * 8);
  226.  
  227.    /* WrapShortest enables */
  228.    dw[9] = 0;
  229.    dw[10] = 0;
  230. }
  231.  
  232. static inline void
  233. gen6_3DSTATE_SF(struct ilo_builder *builder,
  234.                 const struct ilo_rasterizer_state *rasterizer,
  235.                 const struct ilo_shader_state *fs,
  236.                 int sample_count)
  237. {
  238.    const uint8_t cmd_len = 20;
  239.    uint32_t gen8_3dstate_sbe[4], gen8_3dstate_sbe_swiz[11];
  240.    uint32_t gen7_3dstate_sf[7];
  241.    const struct ilo_rasterizer_sf *sf;
  242.    int sprite_coord_mode;
  243.    uint32_t *dw;
  244.  
  245.    ILO_DEV_ASSERT(builder->dev, 6, 6);
  246.  
  247.    sf = (rasterizer) ? &rasterizer->sf : NULL;
  248.    sprite_coord_mode = (rasterizer) ? rasterizer->state.sprite_coord_mode : 0;
  249.  
  250.    gen8_internal_3dstate_sbe(builder, Elements(gen8_3dstate_sbe),
  251.          gen8_3dstate_sbe, fs, sprite_coord_mode);
  252.    gen8_internal_3dstate_sbe_swiz(builder, Elements(gen8_3dstate_sbe_swiz),
  253.          gen8_3dstate_sbe_swiz, fs);
  254.    gen7_internal_3dstate_sf(builder, Elements(gen7_3dstate_sf),
  255.          gen7_3dstate_sf, sf, sample_count);
  256.  
  257.    ilo_builder_batch_pointer(builder, cmd_len, &dw);
  258.  
  259.    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_SF) | (cmd_len - 2);
  260.    dw[1] = gen8_3dstate_sbe[1];
  261.    memcpy(&dw[2], &gen7_3dstate_sf[1], sizeof(*dw) * 6);
  262.    memcpy(&dw[8], &gen8_3dstate_sbe_swiz[1], sizeof(*dw) * 8);
  263.    dw[16] = gen8_3dstate_sbe[2];
  264.    dw[17] = gen8_3dstate_sbe[3];
  265.    dw[18] = gen8_3dstate_sbe_swiz[9];
  266.    dw[19] = gen8_3dstate_sbe_swiz[10];
  267. }
  268.  
  269. static inline void
  270. gen7_3DSTATE_SF(struct ilo_builder *builder,
  271.                 const struct ilo_rasterizer_sf *sf,
  272.                 enum pipe_format zs_format,
  273.                 int sample_count)
  274. {
  275.    const uint8_t cmd_len = 7;
  276.    uint32_t *dw;
  277.  
  278.    ILO_DEV_ASSERT(builder->dev, 7, 7.5);
  279.  
  280.    ilo_builder_batch_pointer(builder, cmd_len, &dw);
  281.  
  282.    gen7_internal_3dstate_sf(builder, cmd_len, dw, sf, sample_count);
  283.  
  284.    if (ilo_dev_gen(builder->dev) >= ILO_GEN(7)) {
  285.       int hw_format;
  286.  
  287.       /* separate stencil */
  288.       switch (zs_format) {
  289.       case PIPE_FORMAT_Z16_UNORM:
  290.          hw_format = GEN6_ZFORMAT_D16_UNORM;
  291.          break;
  292.       case PIPE_FORMAT_Z32_FLOAT:
  293.       case PIPE_FORMAT_Z32_FLOAT_S8X24_UINT:
  294.          hw_format = GEN6_ZFORMAT_D32_FLOAT;
  295.          break;
  296.       case PIPE_FORMAT_Z24X8_UNORM:
  297.       case PIPE_FORMAT_Z24_UNORM_S8_UINT:
  298.          hw_format = GEN6_ZFORMAT_D24_UNORM_X8_UINT;
  299.          break;
  300.       default:
  301.          /* FLOAT surface is assumed when there is no depth buffer */
  302.          hw_format = GEN6_ZFORMAT_D32_FLOAT;
  303.          break;
  304.       }
  305.  
  306.       dw[1] |= hw_format << GEN7_SF_DW1_DEPTH_FORMAT__SHIFT;
  307.    }
  308. }
  309.  
  310. static inline void
  311. gen8_3DSTATE_SF(struct ilo_builder *builder,
  312.                 const struct ilo_rasterizer_sf *sf)
  313. {
  314.    const uint8_t cmd_len = 4;
  315.    uint32_t *dw;
  316.  
  317.    ILO_DEV_ASSERT(builder->dev, 8, 8);
  318.  
  319.    ilo_builder_batch_pointer(builder, cmd_len, &dw);
  320.  
  321.    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_SF) | (cmd_len - 2);
  322.  
  323.    /* see rasterizer_init_sf_gen8() */
  324.    STATIC_ASSERT(Elements(sf->payload) >= 3);
  325.    dw[1] = sf->payload[0];
  326.    dw[2] = sf->payload[1];
  327.    dw[3] = sf->payload[2];
  328. }
  329.  
  330. static inline void
  331. gen7_3DSTATE_SBE(struct ilo_builder *builder,
  332.                  const struct ilo_shader_state *fs,
  333.                  int sprite_coord_mode)
  334. {
  335.    const uint8_t cmd_len = 14;
  336.    uint32_t gen8_3dstate_sbe[4], gen8_3dstate_sbe_swiz[11];
  337.    uint32_t *dw;
  338.  
  339.    ILO_DEV_ASSERT(builder->dev, 7, 7.5);
  340.  
  341.    gen8_internal_3dstate_sbe(builder, Elements(gen8_3dstate_sbe),
  342.          gen8_3dstate_sbe, fs, sprite_coord_mode);
  343.    gen8_internal_3dstate_sbe_swiz(builder, Elements(gen8_3dstate_sbe_swiz),
  344.          gen8_3dstate_sbe_swiz, fs);
  345.  
  346.    ilo_builder_batch_pointer(builder, cmd_len, &dw);
  347.  
  348.    dw[0] = GEN7_RENDER_CMD(3D, 3DSTATE_SBE) | (cmd_len - 2);
  349.    dw[1] = gen8_3dstate_sbe[1];
  350.    memcpy(&dw[2], &gen8_3dstate_sbe_swiz[1], sizeof(*dw) * 8);
  351.    dw[10] = gen8_3dstate_sbe[2];
  352.    dw[11] = gen8_3dstate_sbe[3];
  353.    dw[12] = gen8_3dstate_sbe_swiz[9];
  354.    dw[13] = gen8_3dstate_sbe_swiz[10];
  355. }
  356.  
  357. static inline void
  358. gen8_3DSTATE_SBE(struct ilo_builder *builder,
  359.                  const struct ilo_shader_state *fs,
  360.                  int sprite_coord_mode)
  361. {
  362.    const uint8_t cmd_len = 4;
  363.    uint32_t *dw;
  364.  
  365.    ILO_DEV_ASSERT(builder->dev, 8, 8);
  366.  
  367.    ilo_builder_batch_pointer(builder, cmd_len, &dw);
  368.  
  369.    gen8_internal_3dstate_sbe(builder, cmd_len, dw, fs, sprite_coord_mode);
  370. }
  371.  
  372. static inline void
  373. gen8_3DSTATE_SBE_SWIZ(struct ilo_builder *builder,
  374.                       const struct ilo_shader_state *fs)
  375. {
  376.    const uint8_t cmd_len = 11;
  377.    uint32_t *dw;
  378.  
  379.    ILO_DEV_ASSERT(builder->dev, 8, 8);
  380.  
  381.    ilo_builder_batch_pointer(builder, cmd_len, &dw);
  382.  
  383.    gen8_internal_3dstate_sbe_swiz(builder, cmd_len, dw, fs);
  384. }
  385.  
  386. static inline void
  387. gen8_3DSTATE_RASTER(struct ilo_builder *builder,
  388.                     const struct ilo_rasterizer_sf *sf)
  389. {
  390.    const uint8_t cmd_len = 5;
  391.    uint32_t *dw;
  392.  
  393.    ILO_DEV_ASSERT(builder->dev, 8, 8);
  394.  
  395.    ilo_builder_batch_pointer(builder, cmd_len, &dw);
  396.  
  397.    dw[0] = GEN8_RENDER_CMD(3D, 3DSTATE_RASTER) | (cmd_len - 2);
  398.    dw[1] = sf->dw_raster;
  399.    dw[2] = sf->dw_depth_offset_const;
  400.    dw[3] = sf->dw_depth_offset_scale;
  401.    dw[4] = sf->dw_depth_offset_clamp;
  402. }
  403.  
  404. static inline void
  405. gen6_3DSTATE_WM(struct ilo_builder *builder,
  406.                 const struct ilo_shader_state *fs,
  407.                 const struct ilo_rasterizer_state *rasterizer,
  408.                 bool dual_blend, bool cc_may_kill)
  409. {
  410.    const uint8_t cmd_len = 9;
  411.    const int num_samples = 1;
  412.    const struct ilo_shader_cso *cso;
  413.    uint32_t dw2, dw4, dw5, dw6, *dw;
  414.  
  415.    ILO_DEV_ASSERT(builder->dev, 6, 6);
  416.  
  417.    cso = ilo_shader_get_kernel_cso(fs);
  418.    dw2 = cso->payload[0];
  419.    dw4 = cso->payload[1];
  420.    dw5 = cso->payload[2];
  421.    dw6 = cso->payload[3];
  422.  
  423.    /*
  424.     * From the Sandy Bridge PRM, volume 2 part 1, page 248:
  425.     *
  426.     *     "This bit (Statistics Enable) must be disabled if either of these
  427.     *      bits is set: Depth Buffer Clear , Hierarchical Depth Buffer Resolve
  428.     *      Enable or Depth Buffer Resolve Enable."
  429.     */
  430.    dw4 |= GEN6_WM_DW4_STATISTICS;
  431.  
  432.    if (cc_may_kill)
  433.       dw5 |= GEN6_WM_DW5_PS_KILL_PIXEL | GEN6_WM_DW5_PS_DISPATCH_ENABLE;
  434.  
  435.    if (dual_blend)
  436.       dw5 |= GEN6_WM_DW5_PS_DUAL_SOURCE_BLEND;
  437.  
  438.    dw5 |= rasterizer->wm.payload[0];
  439.  
  440.    dw6 |= rasterizer->wm.payload[1];
  441.  
  442.    if (num_samples > 1) {
  443.       dw6 |= rasterizer->wm.dw_msaa_rast |
  444.              rasterizer->wm.dw_msaa_disp;
  445.    }
  446.  
  447.    ilo_builder_batch_pointer(builder, cmd_len, &dw);
  448.  
  449.    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_WM) | (cmd_len - 2);
  450.    dw[1] = ilo_shader_get_kernel_offset(fs);
  451.    dw[2] = dw2;
  452.    dw[3] = 0; /* scratch */
  453.    dw[4] = dw4;
  454.    dw[5] = dw5;
  455.    dw[6] = dw6;
  456.    dw[7] = 0; /* kernel 1 */
  457.    dw[8] = 0; /* kernel 2 */
  458. }
  459.  
  460. static inline void
  461. gen6_hiz_3DSTATE_WM(struct ilo_builder *builder, uint32_t hiz_op)
  462. {
  463.    const uint8_t cmd_len = 9;
  464.    const int max_threads = (builder->dev->gt == 2) ? 80 : 40;
  465.    uint32_t *dw;
  466.  
  467.    ILO_DEV_ASSERT(builder->dev, 6, 6);
  468.  
  469.    ilo_builder_batch_pointer(builder, cmd_len, &dw);
  470.  
  471.    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_WM) | (cmd_len - 2);
  472.    dw[1] = 0;
  473.    dw[2] = 0;
  474.    dw[3] = 0;
  475.    dw[4] = hiz_op;
  476.    /* honor the valid range even if dispatching is disabled */
  477.    dw[5] = (max_threads - 1) << GEN6_WM_DW5_MAX_THREADS__SHIFT;
  478.    dw[6] = 0;
  479.    dw[7] = 0;
  480.    dw[8] = 0;
  481. }
  482.  
  483. static inline void
  484. gen7_3DSTATE_WM(struct ilo_builder *builder,
  485.                 const struct ilo_shader_state *fs,
  486.                 const struct ilo_rasterizer_state *rasterizer,
  487.                 bool cc_may_kill)
  488. {
  489.    const uint8_t cmd_len = 3;
  490.    const int num_samples = 1;
  491.    const struct ilo_shader_cso *cso;
  492.    uint32_t dw1, dw2, *dw;
  493.  
  494.    ILO_DEV_ASSERT(builder->dev, 7, 7.5);
  495.  
  496.    /* see rasterizer_init_wm_gen7() */
  497.    dw1 = rasterizer->wm.payload[0];
  498.    dw2 = rasterizer->wm.payload[1];
  499.  
  500.    /* see fs_init_cso_gen7() */
  501.    cso = ilo_shader_get_kernel_cso(fs);
  502.    dw1 |= cso->payload[3];
  503.  
  504.    dw1 |= GEN7_WM_DW1_STATISTICS;
  505.  
  506.    if (cc_may_kill)
  507.       dw1 |= GEN7_WM_DW1_PS_DISPATCH_ENABLE | GEN7_WM_DW1_PS_KILL_PIXEL;
  508.  
  509.    if (num_samples > 1) {
  510.       dw1 |= rasterizer->wm.dw_msaa_rast;
  511.       dw2 |= rasterizer->wm.dw_msaa_disp;
  512.    }
  513.  
  514.    ilo_builder_batch_pointer(builder, cmd_len, &dw);
  515.  
  516.    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_WM) | (cmd_len - 2);
  517.    dw[1] = dw1;
  518.    dw[2] = dw2;
  519. }
  520.  
  521. static inline void
  522. gen8_3DSTATE_WM(struct ilo_builder *builder,
  523.                 const struct ilo_shader_state *fs,
  524.                 const struct ilo_rasterizer_state *rasterizer)
  525. {
  526.    const uint8_t cmd_len = 2;
  527.    const struct ilo_shader_cso *cso;
  528.    uint32_t dw1, interps, *dw;
  529.  
  530.    ILO_DEV_ASSERT(builder->dev, 8, 8);
  531.  
  532.    /* see rasterizer_get_wm_gen8() */
  533.    dw1 = rasterizer->wm.payload[0];
  534.    dw1 |= GEN7_WM_DW1_STATISTICS;
  535.  
  536.    /* see fs_init_cso_gen8() */
  537.    cso = ilo_shader_get_kernel_cso(fs);
  538.    interps = cso->payload[4];
  539.  
  540.    assert(!(dw1 & interps));
  541.  
  542.    ilo_builder_batch_pointer(builder, cmd_len, &dw);
  543.  
  544.    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_WM) | (cmd_len - 2);
  545.    dw[1] = dw1 | interps;
  546. }
  547.  
  548. static inline void
  549. gen7_hiz_3DSTATE_WM(struct ilo_builder *builder, uint32_t hiz_op)
  550. {
  551.    const uint8_t cmd_len = 3;
  552.    uint32_t *dw;
  553.  
  554.    ILO_DEV_ASSERT(builder->dev, 7, 7.5);
  555.  
  556.    ilo_builder_batch_pointer(builder, cmd_len, &dw);
  557.    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_WM) | (cmd_len - 2);
  558.    dw[1] = hiz_op;
  559.    dw[2] = 0;
  560. }
  561.  
  562. static inline void
  563. gen8_3DSTATE_WM_DEPTH_STENCIL(struct ilo_builder *builder,
  564.                               const struct ilo_dsa_state *dsa)
  565. {
  566.    const uint8_t cmd_len = 3;
  567.    uint32_t dw1, dw2, *dw;
  568.  
  569.    ILO_DEV_ASSERT(builder->dev, 8, 8);
  570.  
  571.    dw1 = dsa->payload[0];
  572.    dw2 = dsa->payload[1];
  573.  
  574.    ilo_builder_batch_pointer(builder, cmd_len, &dw);
  575.  
  576.    dw[0] = GEN8_RENDER_CMD(3D, 3DSTATE_WM_DEPTH_STENCIL) | (cmd_len - 2);
  577.    dw[1] = dw1;
  578.    dw[2] = dw2;
  579. }
  580.  
  581. static inline void
  582. gen8_3DSTATE_WM_HZ_OP(struct ilo_builder *builder, uint32_t op,
  583.                       uint16_t width, uint16_t height, int sample_count)
  584. {
  585.    const uint8_t cmd_len = 5;
  586.    const uint32_t sample_mask = ((1 << sample_count) - 1) | 0x1;
  587.    uint32_t dw1, *dw;
  588.  
  589.    ILO_DEV_ASSERT(builder->dev, 8, 8);
  590.  
  591.    dw1 = op;
  592.  
  593.    switch (sample_count) {
  594.    case 0:
  595.    case 1:
  596.       dw1 |= GEN8_WM_HZ_DW1_NUMSAMPLES_1;
  597.       break;
  598.    case 2:
  599.       dw1 |= GEN8_WM_HZ_DW1_NUMSAMPLES_2;
  600.       break;
  601.    case 4:
  602.       dw1 |= GEN8_WM_HZ_DW1_NUMSAMPLES_4;
  603.       break;
  604.    case 8:
  605.       dw1 |= GEN8_WM_HZ_DW1_NUMSAMPLES_8;
  606.       break;
  607.    case 16:
  608.       dw1 |= GEN8_WM_HZ_DW1_NUMSAMPLES_16;
  609.       break;
  610.    default:
  611.       assert(!"unsupported sample count");
  612.       dw1 |= GEN8_WM_HZ_DW1_NUMSAMPLES_1;
  613.       break;
  614.    }
  615.  
  616.    ilo_builder_batch_pointer(builder, cmd_len, &dw);
  617.  
  618.    dw[0] = GEN8_RENDER_CMD(3D, 3DSTATE_WM_HZ_OP) | (cmd_len - 2);
  619.    dw[1] = dw1;
  620.    dw[2] = 0;
  621.    /* exclusive? */
  622.    dw[3] = height << 16 | width;
  623.    dw[4] = sample_mask;
  624. }
  625.  
  626. static inline void
  627. gen8_disable_3DSTATE_WM_HZ_OP(struct ilo_builder *builder)
  628. {
  629.    const uint8_t cmd_len = 5;
  630.    uint32_t *dw;
  631.  
  632.    ILO_DEV_ASSERT(builder->dev, 8, 8);
  633.  
  634.    ilo_builder_batch_pointer(builder, cmd_len, &dw);
  635.  
  636.    dw[0] = GEN8_RENDER_CMD(3D, 3DSTATE_WM_HZ_OP) | (cmd_len - 2);
  637.    dw[1] = 0;
  638.    dw[2] = 0;
  639.    dw[3] = 0;
  640.    dw[4] = 0;
  641. }
  642.  
  643. static inline void
  644. gen8_3DSTATE_WM_CHROMAKEY(struct ilo_builder *builder)
  645. {
  646.    const uint8_t cmd_len = 2;
  647.    uint32_t *dw;
  648.  
  649.    ILO_DEV_ASSERT(builder->dev, 8, 8);
  650.  
  651.    ilo_builder_batch_pointer(builder, cmd_len, &dw);
  652.  
  653.    dw[0] = GEN8_RENDER_CMD(3D, 3DSTATE_WM_CHROMAKEY) | (cmd_len - 2);
  654.    dw[1] = 0;
  655. }
  656.  
  657. static inline void
  658. gen7_3DSTATE_PS(struct ilo_builder *builder,
  659.                 const struct ilo_shader_state *fs,
  660.                 bool dual_blend)
  661. {
  662.    const uint8_t cmd_len = 8;
  663.    const struct ilo_shader_cso *cso;
  664.    uint32_t dw2, dw4, dw5, *dw;
  665.  
  666.    ILO_DEV_ASSERT(builder->dev, 7, 7.5);
  667.  
  668.    /* see fs_init_cso_gen7() */
  669.    cso = ilo_shader_get_kernel_cso(fs);
  670.    dw2 = cso->payload[0];
  671.    dw4 = cso->payload[1];
  672.    dw5 = cso->payload[2];
  673.  
  674.    if (dual_blend)
  675.       dw4 |= GEN7_PS_DW4_DUAL_SOURCE_BLEND;
  676.  
  677.    ilo_builder_batch_pointer(builder, cmd_len, &dw);
  678.  
  679.    dw[0] = GEN7_RENDER_CMD(3D, 3DSTATE_PS) | (cmd_len - 2);
  680.    dw[1] = ilo_shader_get_kernel_offset(fs);
  681.    dw[2] = dw2;
  682.    dw[3] = 0; /* scratch */
  683.    dw[4] = dw4;
  684.    dw[5] = dw5;
  685.    dw[6] = 0; /* kernel 1 */
  686.    dw[7] = 0; /* kernel 2 */
  687. }
  688.  
  689. static inline void
  690. gen7_disable_3DSTATE_PS(struct ilo_builder *builder)
  691. {
  692.    const uint8_t cmd_len = 8;
  693.    int max_threads;
  694.    uint32_t dw4, *dw;
  695.  
  696.    ILO_DEV_ASSERT(builder->dev, 7, 7.5);
  697.  
  698.    /* GPU hangs if none of the dispatch enable bits is set */
  699.    dw4 = GEN6_PS_DISPATCH_8 << GEN7_PS_DW4_DISPATCH_MODE__SHIFT;
  700.  
  701.    /* see brwCreateContext() */
  702.    switch (ilo_dev_gen(builder->dev)) {
  703.    case ILO_GEN(7.5):
  704.       max_threads = (builder->dev->gt == 3) ? 408 :
  705.                     (builder->dev->gt == 2) ? 204 : 102;
  706.       dw4 |= (max_threads - 1) << GEN75_PS_DW4_MAX_THREADS__SHIFT;
  707.       break;
  708.    case ILO_GEN(7):
  709.    default:
  710.       max_threads = (builder->dev->gt == 2) ? 172 : 48;
  711.       dw4 |= (max_threads - 1) << GEN7_PS_DW4_MAX_THREADS__SHIFT;
  712.       break;
  713.    }
  714.  
  715.    ilo_builder_batch_pointer(builder, cmd_len, &dw);
  716.  
  717.    dw[0] = GEN7_RENDER_CMD(3D, 3DSTATE_PS) | (cmd_len - 2);
  718.    dw[1] = 0;
  719.    dw[2] = 0;
  720.    dw[3] = 0;
  721.    dw[4] = dw4;
  722.    dw[5] = 0;
  723.    dw[6] = 0;
  724.    dw[7] = 0;
  725. }
  726.  
  727. static inline void
  728. gen8_3DSTATE_PS(struct ilo_builder *builder,
  729.                 const struct ilo_shader_state *fs)
  730. {
  731.    const uint8_t cmd_len = 12;
  732.    const struct ilo_shader_cso *cso;
  733.    uint32_t dw3, dw6, dw7, *dw;
  734.  
  735.    ILO_DEV_ASSERT(builder->dev, 8, 8);
  736.  
  737.    /* see fs_init_cso_gen8() */
  738.    cso = ilo_shader_get_kernel_cso(fs);
  739.    dw3 = cso->payload[0];
  740.    dw6 = cso->payload[1];
  741.    dw7 = cso->payload[2];
  742.  
  743.    ilo_builder_batch_pointer(builder, cmd_len, &dw);
  744.  
  745.    dw[0] = GEN7_RENDER_CMD(3D, 3DSTATE_PS) | (cmd_len - 2);
  746.    dw[1] = ilo_shader_get_kernel_offset(fs);
  747.    dw[2] = 0;
  748.    dw[3] = dw3;
  749.    dw[4] = 0; /* scratch */
  750.    dw[5] = 0;
  751.    dw[6] = dw6;
  752.    dw[7] = dw7;
  753.    dw[8] = 0; /* kernel 1 */
  754.    dw[9] = 0;
  755.    dw[10] = 0; /* kernel 2 */
  756.    dw[11] = 0;
  757. }
  758.  
  759. static inline void
  760. gen8_3DSTATE_PS_EXTRA(struct ilo_builder *builder,
  761.                       const struct ilo_shader_state *fs,
  762.                       bool cc_may_kill, bool per_sample)
  763. {
  764.    const uint8_t cmd_len = 2;
  765.    const struct ilo_shader_cso *cso;
  766.    uint32_t dw1, *dw;
  767.  
  768.    ILO_DEV_ASSERT(builder->dev, 8, 8);
  769.  
  770.    /* see fs_init_cso_gen8() */
  771.    cso = ilo_shader_get_kernel_cso(fs);
  772.    dw1 = cso->payload[3];
  773.  
  774.    if (cc_may_kill)
  775.       dw1 |= GEN8_PSX_DW1_DISPATCH_ENABLE | GEN8_PSX_DW1_KILL_PIXEL;
  776.    if (per_sample)
  777.       dw1 |= GEN8_PSX_DW1_PER_SAMPLE;
  778.  
  779.    ilo_builder_batch_pointer(builder, cmd_len, &dw);
  780.  
  781.    dw[0] = GEN8_RENDER_CMD(3D, 3DSTATE_PS_EXTRA) | (cmd_len - 2);
  782.    dw[1] = dw1;
  783. }
  784.  
  785. static inline void
  786. gen8_3DSTATE_PS_BLEND(struct ilo_builder *builder,
  787.                       const struct ilo_blend_state *blend,
  788.                       const struct ilo_fb_state *fb,
  789.                       const struct ilo_dsa_state *dsa)
  790. {
  791.    const uint8_t cmd_len = 2;
  792.    uint32_t dw1, *dw;
  793.  
  794.    ILO_DEV_ASSERT(builder->dev, 8, 8);
  795.  
  796.    dw1 = 0;
  797.    if (blend->alpha_to_coverage && fb->num_samples > 1)
  798.       dw1 |= GEN8_PS_BLEND_DW1_ALPHA_TO_COVERAGE;
  799.  
  800.    if (fb->state.nr_cbufs && fb->state.cbufs[0]) {
  801.       const struct ilo_fb_blend_caps *caps = &fb->blend_caps[0];
  802.  
  803.       dw1 |= GEN8_PS_BLEND_DW1_WRITABLE_RT;
  804.       if (caps->can_blend) {
  805.          if (caps->dst_alpha_forced_one)
  806.             dw1 |= blend->dw_ps_blend_dst_alpha_forced_one;
  807.          else
  808.             dw1 |= blend->dw_ps_blend;
  809.       }
  810.  
  811.       if (caps->can_alpha_test)
  812.          dw1 |= dsa->dw_ps_blend_alpha;
  813.    } else {
  814.       dw1 |= dsa->dw_ps_blend_alpha;
  815.    }
  816.  
  817.    ilo_builder_batch_pointer(builder, cmd_len, &dw);
  818.  
  819.    dw[0] = GEN8_RENDER_CMD(3D, 3DSTATE_PS_BLEND) | (cmd_len - 2);
  820.    dw[1] = dw1;
  821. }
  822.  
  823. static inline void
  824. gen6_3DSTATE_CONSTANT_PS(struct ilo_builder *builder,
  825.                          const uint32_t *bufs, const int *sizes,
  826.                          int num_bufs)
  827. {
  828.    gen6_3dstate_constant(builder, GEN6_RENDER_OPCODE_3DSTATE_CONSTANT_PS,
  829.          bufs, sizes, num_bufs);
  830. }
  831.  
  832. static inline void
  833. gen7_3DSTATE_CONSTANT_PS(struct ilo_builder *builder,
  834.                          const uint32_t *bufs, const int *sizes,
  835.                          int num_bufs)
  836. {
  837.    gen7_3dstate_constant(builder, GEN6_RENDER_OPCODE_3DSTATE_CONSTANT_PS,
  838.          bufs, sizes, num_bufs);
  839. }
  840.  
  841. static inline void
  842. gen7_3DSTATE_BINDING_TABLE_POINTERS_PS(struct ilo_builder *builder,
  843.                                        uint32_t binding_table)
  844. {
  845.    ILO_DEV_ASSERT(builder->dev, 7, 8);
  846.  
  847.    gen7_3dstate_pointer(builder,
  848.          GEN7_RENDER_OPCODE_3DSTATE_BINDING_TABLE_POINTERS_PS,
  849.          binding_table);
  850. }
  851.  
  852. static inline void
  853. gen7_3DSTATE_SAMPLER_STATE_POINTERS_PS(struct ilo_builder *builder,
  854.                                        uint32_t sampler_state)
  855. {
  856.    ILO_DEV_ASSERT(builder->dev, 7, 8);
  857.  
  858.    gen7_3dstate_pointer(builder,
  859.          GEN7_RENDER_OPCODE_3DSTATE_SAMPLER_STATE_POINTERS_PS,
  860.          sampler_state);
  861. }
  862.  
  863. static inline void
  864. gen6_3DSTATE_MULTISAMPLE(struct ilo_builder *builder,
  865.                          int num_samples, const uint32_t *pattern,
  866.                          bool pixel_location_center)
  867. {
  868.    const uint8_t cmd_len = (ilo_dev_gen(builder->dev) >= ILO_GEN(7)) ? 4 : 3;
  869.    uint32_t dw1, dw2, dw3, *dw;
  870.  
  871.    ILO_DEV_ASSERT(builder->dev, 6, 7.5);
  872.  
  873.    dw1 = (pixel_location_center) ? GEN6_MULTISAMPLE_DW1_PIXLOC_CENTER :
  874.       GEN6_MULTISAMPLE_DW1_PIXLOC_UL_CORNER;
  875.  
  876.    switch (num_samples) {
  877.    case 0:
  878.    case 1:
  879.       dw1 |= GEN6_MULTISAMPLE_DW1_NUMSAMPLES_1;
  880.       dw2 = 0;
  881.       dw3 = 0;
  882.       break;
  883.    case 4:
  884.       dw1 |= GEN6_MULTISAMPLE_DW1_NUMSAMPLES_4;
  885.       dw2 = pattern[0];
  886.       dw3 = 0;
  887.       break;
  888.    case 8:
  889.       assert(ilo_dev_gen(builder->dev) >= ILO_GEN(7));
  890.       dw1 |= GEN7_MULTISAMPLE_DW1_NUMSAMPLES_8;
  891.       dw2 = pattern[0];
  892.       dw3 = pattern[1];
  893.       break;
  894.    default:
  895.       assert(!"unsupported sample count");
  896.       dw1 |= GEN6_MULTISAMPLE_DW1_NUMSAMPLES_1;
  897.       dw2 = 0;
  898.       dw3 = 0;
  899.       break;
  900.    }
  901.  
  902.    ilo_builder_batch_pointer(builder, cmd_len, &dw);
  903.  
  904.    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_MULTISAMPLE) | (cmd_len - 2);
  905.    dw[1] = dw1;
  906.    dw[2] = dw2;
  907.    if (ilo_dev_gen(builder->dev) >= ILO_GEN(7))
  908.       dw[3] = dw3;
  909. }
  910.  
  911. static inline void
  912. gen8_3DSTATE_MULTISAMPLE(struct ilo_builder *builder,
  913.                          int num_samples,
  914.                          bool pixel_location_center)
  915. {
  916.    const uint8_t cmd_len = 2;
  917.    uint32_t dw1, *dw;
  918.  
  919.    ILO_DEV_ASSERT(builder->dev, 8, 8);
  920.  
  921.    dw1 = (pixel_location_center) ? GEN6_MULTISAMPLE_DW1_PIXLOC_CENTER :
  922.       GEN6_MULTISAMPLE_DW1_PIXLOC_UL_CORNER;
  923.  
  924.    switch (num_samples) {
  925.    case 0:
  926.    case 1:
  927.       dw1 |= GEN6_MULTISAMPLE_DW1_NUMSAMPLES_1;
  928.       break;
  929.    case 2:
  930.       dw1 |= GEN8_MULTISAMPLE_DW1_NUMSAMPLES_2;
  931.       break;
  932.    case 4:
  933.       dw1 |= GEN6_MULTISAMPLE_DW1_NUMSAMPLES_4;
  934.       break;
  935.    case 8:
  936.       dw1 |= GEN7_MULTISAMPLE_DW1_NUMSAMPLES_8;
  937.       break;
  938.    case 16:
  939.       dw1 |= GEN8_MULTISAMPLE_DW1_NUMSAMPLES_16;
  940.       break;
  941.    default:
  942.       assert(!"unsupported sample count");
  943.       dw1 |= GEN6_MULTISAMPLE_DW1_NUMSAMPLES_1;
  944.       break;
  945.    }
  946.  
  947.    ilo_builder_batch_pointer(builder, cmd_len, &dw);
  948.  
  949.    dw[0] = GEN8_RENDER_CMD(3D, 3DSTATE_MULTISAMPLE) | (cmd_len - 2);
  950.    dw[1] = dw1;
  951. }
  952.  
  953. static inline void
  954. gen8_3DSTATE_SAMPLE_PATTERN(struct ilo_builder *builder,
  955.                             const uint32_t *pattern_1x,
  956.                             const uint32_t *pattern_2x,
  957.                             const uint32_t *pattern_4x,
  958.                             const uint32_t *pattern_8x,
  959.                             const uint32_t *pattern_16x)
  960. {
  961.    const uint8_t cmd_len = 9;
  962.    uint32_t *dw;
  963.  
  964.    ILO_DEV_ASSERT(builder->dev, 8, 8);
  965.  
  966.    ilo_builder_batch_pointer(builder, cmd_len, &dw);
  967.  
  968.    dw[0] = GEN8_RENDER_CMD(3D, 3DSTATE_SAMPLE_PATTERN) | (cmd_len - 2);
  969.    dw[1] = pattern_16x[3];
  970.    dw[2] = pattern_16x[2];
  971.    dw[3] = pattern_16x[1];
  972.    dw[4] = pattern_16x[0];
  973.    dw[5] = pattern_8x[1];
  974.    dw[6] = pattern_8x[0];
  975.    dw[7] = pattern_4x[0];
  976.    dw[8] = pattern_1x[0] << 16 |
  977.            pattern_2x[0];
  978. }
  979.  
  980. static inline void
  981. gen6_3DSTATE_SAMPLE_MASK(struct ilo_builder *builder,
  982.                          unsigned sample_mask)
  983. {
  984.    const uint8_t cmd_len = 2;
  985.    const unsigned valid_mask = 0xf;
  986.    uint32_t *dw;
  987.  
  988.    ILO_DEV_ASSERT(builder->dev, 6, 6);
  989.  
  990.    sample_mask &= valid_mask;
  991.  
  992.    ilo_builder_batch_pointer(builder, cmd_len, &dw);
  993.  
  994.    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_SAMPLE_MASK) | (cmd_len - 2);
  995.    dw[1] = sample_mask;
  996. }
  997.  
  998. static inline void
  999. gen7_3DSTATE_SAMPLE_MASK(struct ilo_builder *builder,
  1000.                          unsigned sample_mask,
  1001.                          int num_samples)
  1002. {
  1003.    const uint8_t cmd_len = 2;
  1004.    const unsigned valid_mask = ((1 << num_samples) - 1) | 0x1;
  1005.    uint32_t *dw;
  1006.  
  1007.    ILO_DEV_ASSERT(builder->dev, 7, 8);
  1008.  
  1009.    /*
  1010.     * From the Ivy Bridge PRM, volume 2 part 1, page 294:
  1011.     *
  1012.     *     "If Number of Multisamples is NUMSAMPLES_1, bits 7:1 of this field
  1013.     *      (Sample Mask) must be zero.
  1014.     *
  1015.     *      If Number of Multisamples is NUMSAMPLES_4, bits 7:4 of this field
  1016.     *      must be zero."
  1017.     */
  1018.    sample_mask &= valid_mask;
  1019.  
  1020.    ilo_builder_batch_pointer(builder, cmd_len, &dw);
  1021.  
  1022.    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_SAMPLE_MASK) | (cmd_len - 2);
  1023.    dw[1] = sample_mask;
  1024. }
  1025.  
  1026. static inline void
  1027. gen6_3DSTATE_DRAWING_RECTANGLE(struct ilo_builder *builder,
  1028.                                unsigned x, unsigned y,
  1029.                                unsigned width, unsigned height)
  1030. {
  1031.    const uint8_t cmd_len = 4;
  1032.    unsigned xmax = x + width - 1;
  1033.    unsigned ymax = y + height - 1;
  1034.    unsigned rect_limit;
  1035.    uint32_t *dw;
  1036.  
  1037.    ILO_DEV_ASSERT(builder->dev, 6, 8);
  1038.  
  1039.    if (ilo_dev_gen(builder->dev) >= ILO_GEN(7)) {
  1040.       rect_limit = 16383;
  1041.    }
  1042.    else {
  1043.       /*
  1044.        * From the Sandy Bridge PRM, volume 2 part 1, page 230:
  1045.        *
  1046.        *     "[DevSNB] Errata: This field (Clipped Drawing Rectangle Y Min)
  1047.        *      must be an even number"
  1048.        */
  1049.       assert(y % 2 == 0);
  1050.  
  1051.       rect_limit = 8191;
  1052.    }
  1053.  
  1054.    if (x > rect_limit) x = rect_limit;
  1055.    if (y > rect_limit) y = rect_limit;
  1056.    if (xmax > rect_limit) xmax = rect_limit;
  1057.    if (ymax > rect_limit) ymax = rect_limit;
  1058.  
  1059.    ilo_builder_batch_pointer(builder, cmd_len, &dw);
  1060.  
  1061.    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_DRAWING_RECTANGLE) | (cmd_len - 2);
  1062.    dw[1] = y << 16 | x;
  1063.    dw[2] = ymax << 16 | xmax;
  1064.    /*
  1065.     * There is no need to set the origin.  It is intended to support front
  1066.     * buffer rendering.
  1067.     */
  1068.    dw[3] = 0;
  1069. }
  1070.  
  1071. static inline void
  1072. gen6_3DSTATE_POLY_STIPPLE_OFFSET(struct ilo_builder *builder,
  1073.                                  int x_offset, int y_offset)
  1074. {
  1075.    const uint8_t cmd_len = 2;
  1076.    uint32_t *dw;
  1077.  
  1078.    ILO_DEV_ASSERT(builder->dev, 6, 8);
  1079.  
  1080.    assert(x_offset >= 0 && x_offset <= 31);
  1081.    assert(y_offset >= 0 && y_offset <= 31);
  1082.  
  1083.    ilo_builder_batch_pointer(builder, cmd_len, &dw);
  1084.  
  1085.    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_POLY_STIPPLE_OFFSET) | (cmd_len - 2);
  1086.    dw[1] = x_offset << 8 | y_offset;
  1087. }
  1088.  
  1089. static inline void
  1090. gen6_3DSTATE_POLY_STIPPLE_PATTERN(struct ilo_builder *builder,
  1091.                                   const struct pipe_poly_stipple *pattern)
  1092. {
  1093.    const uint8_t cmd_len = 33;
  1094.    uint32_t *dw;
  1095.    int i;
  1096.  
  1097.    ILO_DEV_ASSERT(builder->dev, 6, 8);
  1098.  
  1099.    ilo_builder_batch_pointer(builder, cmd_len, &dw);
  1100.  
  1101.    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_POLY_STIPPLE_PATTERN) | (cmd_len - 2);
  1102.    dw++;
  1103.  
  1104.    STATIC_ASSERT(Elements(pattern->stipple) == 32);
  1105.    for (i = 0; i < 32; i++)
  1106.       dw[i] = pattern->stipple[i];
  1107. }
  1108.  
  1109. static inline void
  1110. gen6_3DSTATE_LINE_STIPPLE(struct ilo_builder *builder,
  1111.                           unsigned pattern, unsigned factor)
  1112. {
  1113.    const uint8_t cmd_len = 3;
  1114.    unsigned inverse;
  1115.    uint32_t *dw;
  1116.  
  1117.    ILO_DEV_ASSERT(builder->dev, 6, 8);
  1118.  
  1119.    assert((pattern & 0xffff) == pattern);
  1120.    assert(factor >= 1 && factor <= 256);
  1121.  
  1122.    ilo_builder_batch_pointer(builder, cmd_len, &dw);
  1123.  
  1124.    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_LINE_STIPPLE) | (cmd_len - 2);
  1125.    dw[1] = pattern;
  1126.  
  1127.    if (ilo_dev_gen(builder->dev) >= ILO_GEN(7)) {
  1128.       /* in U1.16 */
  1129.       inverse = 65536 / factor;
  1130.  
  1131.       dw[2] = inverse << GEN7_LINE_STIPPLE_DW2_INVERSE_REPEAT_COUNT__SHIFT |
  1132.               factor;
  1133.    }
  1134.    else {
  1135.       /* in U1.13 */
  1136.       inverse = 8192 / factor;
  1137.  
  1138.       dw[2] = inverse << GEN6_LINE_STIPPLE_DW2_INVERSE_REPEAT_COUNT__SHIFT |
  1139.               factor;
  1140.    }
  1141. }
  1142.  
  1143. static inline void
  1144. gen6_3DSTATE_AA_LINE_PARAMETERS(struct ilo_builder *builder)
  1145. {
  1146.    const uint8_t cmd_len = 3;
  1147.    const uint32_t dw[3] = {
  1148.       GEN6_RENDER_CMD(3D, 3DSTATE_AA_LINE_PARAMETERS) | (cmd_len - 2),
  1149.       0 << GEN6_AA_LINE_DW1_BIAS__SHIFT | 0,
  1150.       0 << GEN6_AA_LINE_DW2_CAP_BIAS__SHIFT | 0,
  1151.    };
  1152.  
  1153.    ILO_DEV_ASSERT(builder->dev, 6, 8);
  1154.  
  1155.    ilo_builder_batch_write(builder, cmd_len, dw);
  1156. }
  1157.  
  1158. static inline void
  1159. gen6_3DSTATE_DEPTH_BUFFER(struct ilo_builder *builder,
  1160.                           const struct ilo_zs_surface *zs,
  1161.                           bool aligned_8x4)
  1162. {
  1163.    const uint32_t cmd = (ilo_dev_gen(builder->dev) >= ILO_GEN(7)) ?
  1164.       GEN7_RENDER_CMD(3D, 3DSTATE_DEPTH_BUFFER) :
  1165.       GEN6_RENDER_CMD(3D, 3DSTATE_DEPTH_BUFFER);
  1166.    const uint8_t cmd_len = (ilo_dev_gen(builder->dev) >= ILO_GEN(8)) ? 8 : 7;
  1167.    uint32_t *dw;
  1168.    unsigned pos;
  1169.  
  1170.    ILO_DEV_ASSERT(builder->dev, 6, 8);
  1171.  
  1172.    pos = ilo_builder_batch_pointer(builder, cmd_len, &dw);
  1173.  
  1174.    dw[0] = cmd | (cmd_len - 2);
  1175.    dw[1] = zs->payload[0];
  1176.    dw[2] = 0;
  1177.  
  1178.    /* see ilo_gpe_init_zs_surface() */
  1179.    if (ilo_dev_gen(builder->dev) >= ILO_GEN(8)) {
  1180.       dw[3] = 0;
  1181.       dw[4] = (aligned_8x4) ? zs->dw_aligned_8x4 : zs->payload[2];
  1182.       dw[5] = zs->payload[3];
  1183.       dw[6] = zs->payload[4];
  1184.       dw[7] = zs->payload[5];
  1185.  
  1186.       dw[5] |= builder->mocs << GEN8_DEPTH_DW5_MOCS__SHIFT;
  1187.  
  1188.       if (zs->bo) {
  1189.          ilo_builder_batch_reloc64(builder, pos + 2, zs->bo,
  1190.                zs->payload[1], INTEL_RELOC_WRITE);
  1191.       }
  1192.    } else {
  1193.       dw[3] = (aligned_8x4) ? zs->dw_aligned_8x4 : zs->payload[2];
  1194.       dw[4] = zs->payload[3];
  1195.       dw[5] = zs->payload[4];
  1196.       dw[6] = zs->payload[5];
  1197.  
  1198.       if (ilo_dev_gen(builder->dev) >= ILO_GEN(7))
  1199.          dw[4] |= builder->mocs << GEN7_DEPTH_DW4_MOCS__SHIFT;
  1200.       else
  1201.          dw[6] |= builder->mocs << GEN6_DEPTH_DW6_MOCS__SHIFT;
  1202.  
  1203.       if (zs->bo) {
  1204.          ilo_builder_batch_reloc(builder, pos + 2, zs->bo,
  1205.                zs->payload[1], INTEL_RELOC_WRITE);
  1206.       }
  1207.    }
  1208. }
  1209.  
  1210. static inline void
  1211. gen6_3DSTATE_STENCIL_BUFFER(struct ilo_builder *builder,
  1212.                             const struct ilo_zs_surface *zs)
  1213. {
  1214.    const uint32_t cmd = (ilo_dev_gen(builder->dev) >= ILO_GEN(7)) ?
  1215.       GEN7_RENDER_CMD(3D, 3DSTATE_STENCIL_BUFFER) :
  1216.       GEN6_RENDER_CMD(3D, 3DSTATE_STENCIL_BUFFER);
  1217.    const uint8_t cmd_len = (ilo_dev_gen(builder->dev) >= ILO_GEN(8)) ? 5 : 3;
  1218.    uint32_t *dw;
  1219.    unsigned pos;
  1220.  
  1221.    ILO_DEV_ASSERT(builder->dev, 6, 8);
  1222.  
  1223.    pos = ilo_builder_batch_pointer(builder, cmd_len, &dw);
  1224.  
  1225.    dw[0] = cmd | (cmd_len - 2);
  1226.    /* see ilo_gpe_init_zs_surface() */
  1227.    dw[1] = zs->payload[6];
  1228.    dw[2] = 0;
  1229.  
  1230.    if (ilo_dev_gen(builder->dev) >= ILO_GEN(8)) {
  1231.       dw[1] |= builder->mocs << GEN8_STENCIL_DW1_MOCS__SHIFT;
  1232.  
  1233.       dw[3] = 0;
  1234.       dw[4] = zs->payload[8];
  1235.  
  1236.       if (zs->separate_s8_bo) {
  1237.          ilo_builder_batch_reloc64(builder, pos + 2,
  1238.                zs->separate_s8_bo, zs->payload[7], INTEL_RELOC_WRITE);
  1239.       }
  1240.    } else {
  1241.       dw[1] |= builder->mocs << GEN6_STENCIL_DW1_MOCS__SHIFT;
  1242.  
  1243.       if (zs->separate_s8_bo) {
  1244.          ilo_builder_batch_reloc(builder, pos + 2,
  1245.                zs->separate_s8_bo, zs->payload[7], INTEL_RELOC_WRITE);
  1246.       }
  1247.    }
  1248. }
  1249.  
  1250. static inline void
  1251. gen6_3DSTATE_HIER_DEPTH_BUFFER(struct ilo_builder *builder,
  1252.                                const struct ilo_zs_surface *zs)
  1253. {
  1254.    const uint32_t cmd = (ilo_dev_gen(builder->dev) >= ILO_GEN(7)) ?
  1255.       GEN7_RENDER_CMD(3D, 3DSTATE_HIER_DEPTH_BUFFER) :
  1256.       GEN6_RENDER_CMD(3D, 3DSTATE_HIER_DEPTH_BUFFER);
  1257.    const uint8_t cmd_len = (ilo_dev_gen(builder->dev) >= ILO_GEN(8)) ? 5 : 3;
  1258.    uint32_t *dw;
  1259.    unsigned pos;
  1260.  
  1261.    ILO_DEV_ASSERT(builder->dev, 6, 8);
  1262.  
  1263.    pos = ilo_builder_batch_pointer(builder, cmd_len, &dw);
  1264.  
  1265.    dw[0] = cmd | (cmd_len - 2);
  1266.    /* see ilo_gpe_init_zs_surface() */
  1267.    dw[1] = zs->payload[9];
  1268.    dw[2] = 0;
  1269.  
  1270.    if (ilo_dev_gen(builder->dev) >= ILO_GEN(8)) {
  1271.       dw[1] |= builder->mocs << GEN8_HIZ_DW1_MOCS__SHIFT;
  1272.  
  1273.       dw[3] = 0;
  1274.       dw[4] = zs->payload[11];
  1275.  
  1276.       if (zs->hiz_bo) {
  1277.          ilo_builder_batch_reloc64(builder, pos + 2,
  1278.                zs->hiz_bo, zs->payload[10], INTEL_RELOC_WRITE);
  1279.       }
  1280.    } else {
  1281.       dw[1] |= builder->mocs << GEN6_HIZ_DW1_MOCS__SHIFT;
  1282.  
  1283.       if (zs->hiz_bo) {
  1284.          ilo_builder_batch_reloc(builder, pos + 2,
  1285.                zs->hiz_bo, zs->payload[10], INTEL_RELOC_WRITE);
  1286.       }
  1287.    }
  1288. }
  1289.  
  1290. static inline void
  1291. gen6_3DSTATE_CLEAR_PARAMS(struct ilo_builder *builder,
  1292.                           uint32_t clear_val)
  1293. {
  1294.    const uint8_t cmd_len = 2;
  1295.    uint32_t *dw;
  1296.  
  1297.    ILO_DEV_ASSERT(builder->dev, 6, 6);
  1298.  
  1299.    ilo_builder_batch_pointer(builder, cmd_len, &dw);
  1300.  
  1301.    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_CLEAR_PARAMS) |
  1302.            GEN6_CLEAR_PARAMS_DW0_VALID |
  1303.            (cmd_len - 2);
  1304.    dw[1] = clear_val;
  1305. }
  1306.  
  1307. static inline void
  1308. gen7_3DSTATE_CLEAR_PARAMS(struct ilo_builder *builder,
  1309.                           uint32_t clear_val)
  1310. {
  1311.    const uint8_t cmd_len = 3;
  1312.    uint32_t *dw;
  1313.  
  1314.    ILO_DEV_ASSERT(builder->dev, 7, 8);
  1315.  
  1316.    ilo_builder_batch_pointer(builder, cmd_len, &dw);
  1317.  
  1318.    dw[0] = GEN7_RENDER_CMD(3D, 3DSTATE_CLEAR_PARAMS) | (cmd_len - 2);
  1319.    dw[1] = clear_val;
  1320.    dw[2] = GEN7_CLEAR_PARAMS_DW2_VALID;
  1321. }
  1322.  
  1323. static inline void
  1324. gen6_3DSTATE_VIEWPORT_STATE_POINTERS(struct ilo_builder *builder,
  1325.                                      uint32_t clip_viewport,
  1326.                                      uint32_t sf_viewport,
  1327.                                      uint32_t cc_viewport)
  1328. {
  1329.    const uint8_t cmd_len = 4;
  1330.    uint32_t *dw;
  1331.  
  1332.    ILO_DEV_ASSERT(builder->dev, 6, 6);
  1333.  
  1334.    ilo_builder_batch_pointer(builder, cmd_len, &dw);
  1335.  
  1336.    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_VIEWPORT_STATE_POINTERS) |
  1337.            GEN6_VP_PTR_DW0_CLIP_CHANGED |
  1338.            GEN6_VP_PTR_DW0_SF_CHANGED |
  1339.            GEN6_VP_PTR_DW0_CC_CHANGED |
  1340.            (cmd_len - 2);
  1341.    dw[1] = clip_viewport;
  1342.    dw[2] = sf_viewport;
  1343.    dw[3] = cc_viewport;
  1344. }
  1345.  
  1346. static inline void
  1347. gen6_3DSTATE_SCISSOR_STATE_POINTERS(struct ilo_builder *builder,
  1348.                                     uint32_t scissor_rect)
  1349. {
  1350.    const uint8_t cmd_len = 2;
  1351.    uint32_t *dw;
  1352.  
  1353.    ILO_DEV_ASSERT(builder->dev, 6, 8);
  1354.  
  1355.    ilo_builder_batch_pointer(builder, cmd_len, &dw);
  1356.  
  1357.    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_SCISSOR_STATE_POINTERS) |
  1358.            (cmd_len - 2);
  1359.    dw[1] = scissor_rect;
  1360. }
  1361.  
  1362. static inline void
  1363. gen6_3DSTATE_CC_STATE_POINTERS(struct ilo_builder *builder,
  1364.                                uint32_t blend_state,
  1365.                                uint32_t depth_stencil_state,
  1366.                                uint32_t color_calc_state)
  1367. {
  1368.    const uint8_t cmd_len = 4;
  1369.    uint32_t *dw;
  1370.  
  1371.    ILO_DEV_ASSERT(builder->dev, 6, 6);
  1372.  
  1373.    ilo_builder_batch_pointer(builder, cmd_len, &dw);
  1374.  
  1375.    dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_CC_STATE_POINTERS) | (cmd_len - 2);
  1376.    dw[1] = blend_state | GEN6_CC_PTR_DW1_BLEND_CHANGED;
  1377.    dw[2] = depth_stencil_state | GEN6_CC_PTR_DW2_ZS_CHANGED;
  1378.    dw[3] = color_calc_state | GEN6_CC_PTR_DW3_CC_CHANGED;
  1379. }
  1380.  
  1381. static inline void
  1382. gen7_3DSTATE_VIEWPORT_STATE_POINTERS_SF_CLIP(struct ilo_builder *builder,
  1383.                                              uint32_t sf_clip_viewport)
  1384. {
  1385.    ILO_DEV_ASSERT(builder->dev, 7, 8);
  1386.  
  1387.    gen7_3dstate_pointer(builder,
  1388.          GEN7_RENDER_OPCODE_3DSTATE_VIEWPORT_STATE_POINTERS_SF_CLIP,
  1389.          sf_clip_viewport);
  1390. }
  1391.  
  1392. static inline void
  1393. gen7_3DSTATE_VIEWPORT_STATE_POINTERS_CC(struct ilo_builder *builder,
  1394.                                         uint32_t cc_viewport)
  1395. {
  1396.    ILO_DEV_ASSERT(builder->dev, 7, 8);
  1397.  
  1398.    gen7_3dstate_pointer(builder,
  1399.          GEN7_RENDER_OPCODE_3DSTATE_VIEWPORT_STATE_POINTERS_CC,
  1400.          cc_viewport);
  1401. }
  1402.  
  1403. static inline void
  1404. gen7_3DSTATE_CC_STATE_POINTERS(struct ilo_builder *builder,
  1405.                                uint32_t color_calc_state)
  1406. {
  1407.    ILO_DEV_ASSERT(builder->dev, 7, 8);
  1408.  
  1409.    if (ilo_dev_gen(builder->dev) >= ILO_GEN(8))
  1410.       color_calc_state |= 1;
  1411.  
  1412.    gen7_3dstate_pointer(builder,
  1413.          GEN6_RENDER_OPCODE_3DSTATE_CC_STATE_POINTERS, color_calc_state);
  1414. }
  1415.  
  1416. static inline void
  1417. gen7_3DSTATE_DEPTH_STENCIL_STATE_POINTERS(struct ilo_builder *builder,
  1418.                                           uint32_t depth_stencil_state)
  1419. {
  1420.    ILO_DEV_ASSERT(builder->dev, 7, 8);
  1421.  
  1422.    gen7_3dstate_pointer(builder,
  1423.          GEN7_RENDER_OPCODE_3DSTATE_DEPTH_STENCIL_STATE_POINTERS,
  1424.          depth_stencil_state);
  1425. }
  1426.  
  1427. static inline void
  1428. gen7_3DSTATE_BLEND_STATE_POINTERS(struct ilo_builder *builder,
  1429.                                   uint32_t blend_state)
  1430. {
  1431.    ILO_DEV_ASSERT(builder->dev, 7, 8);
  1432.  
  1433.    if (ilo_dev_gen(builder->dev) >= ILO_GEN(8))
  1434.       blend_state |= 1;
  1435.  
  1436.    gen7_3dstate_pointer(builder,
  1437.          GEN7_RENDER_OPCODE_3DSTATE_BLEND_STATE_POINTERS,
  1438.          blend_state);
  1439. }
  1440.  
  1441. static inline uint32_t
  1442. gen6_CLIP_VIEWPORT(struct ilo_builder *builder,
  1443.                    const struct ilo_viewport_cso *viewports,
  1444.                    unsigned num_viewports)
  1445. {
  1446.    const int state_align = 32;
  1447.    const int state_len = 4 * num_viewports;
  1448.    uint32_t state_offset, *dw;
  1449.    unsigned i;
  1450.  
  1451.    ILO_DEV_ASSERT(builder->dev, 6, 6);
  1452.  
  1453.    /*
  1454.     * From the Sandy Bridge PRM, volume 2 part 1, page 193:
  1455.     *
  1456.     *     "The viewport-related state is stored as an array of up to 16
  1457.     *      elements..."
  1458.     */
  1459.    assert(num_viewports && num_viewports <= 16);
  1460.  
  1461.    state_offset = ilo_builder_dynamic_pointer(builder,
  1462.          ILO_BUILDER_ITEM_CLIP_VIEWPORT, state_align, state_len, &dw);
  1463.  
  1464.    for (i = 0; i < num_viewports; i++) {
  1465.       const struct ilo_viewport_cso *vp = &viewports[i];
  1466.  
  1467.       dw[0] = fui(vp->min_gbx);
  1468.       dw[1] = fui(vp->max_gbx);
  1469.       dw[2] = fui(vp->min_gby);
  1470.       dw[3] = fui(vp->max_gby);
  1471.  
  1472.       dw += 4;
  1473.    }
  1474.  
  1475.    return state_offset;
  1476. }
  1477.  
  1478. static inline uint32_t
  1479. gen6_SF_VIEWPORT(struct ilo_builder *builder,
  1480.                  const struct ilo_viewport_cso *viewports,
  1481.                  unsigned num_viewports)
  1482. {
  1483.    const int state_align = 32;
  1484.    const int state_len = 8 * num_viewports;
  1485.    uint32_t state_offset, *dw;
  1486.    unsigned i;
  1487.  
  1488.    ILO_DEV_ASSERT(builder->dev, 6, 6);
  1489.  
  1490.    /*
  1491.     * From the Sandy Bridge PRM, volume 2 part 1, page 262:
  1492.     *
  1493.     *     "The viewport-specific state used by the SF unit (SF_VIEWPORT) is
  1494.     *      stored as an array of up to 16 elements..."
  1495.     */
  1496.    assert(num_viewports && num_viewports <= 16);
  1497.  
  1498.    state_offset = ilo_builder_dynamic_pointer(builder,
  1499.          ILO_BUILDER_ITEM_SF_VIEWPORT, state_align, state_len, &dw);
  1500.  
  1501.    for (i = 0; i < num_viewports; i++) {
  1502.       const struct ilo_viewport_cso *vp = &viewports[i];
  1503.  
  1504.       dw[0] = fui(vp->m00);
  1505.       dw[1] = fui(vp->m11);
  1506.       dw[2] = fui(vp->m22);
  1507.       dw[3] = fui(vp->m30);
  1508.       dw[4] = fui(vp->m31);
  1509.       dw[5] = fui(vp->m32);
  1510.       dw[6] = 0;
  1511.       dw[7] = 0;
  1512.  
  1513.       dw += 8;
  1514.    }
  1515.  
  1516.    return state_offset;
  1517. }
  1518.  
  1519. static inline uint32_t
  1520. gen7_SF_CLIP_VIEWPORT(struct ilo_builder *builder,
  1521.                       const struct ilo_viewport_cso *viewports,
  1522.                       unsigned num_viewports)
  1523. {
  1524.    const int state_align = 64;
  1525.    const int state_len = 16 * num_viewports;
  1526.    uint32_t state_offset, *dw;
  1527.    unsigned i;
  1528.  
  1529.    ILO_DEV_ASSERT(builder->dev, 7, 8);
  1530.  
  1531.    /*
  1532.     * From the Ivy Bridge PRM, volume 2 part 1, page 270:
  1533.     *
  1534.     *     "The viewport-specific state used by both the SF and CL units
  1535.     *      (SF_CLIP_VIEWPORT) is stored as an array of up to 16 elements, each
  1536.     *      of which contains the DWords described below. The start of each
  1537.     *      element is spaced 16 DWords apart. The location of first element of
  1538.     *      the array, as specified by both Pointer to SF_VIEWPORT and Pointer
  1539.     *      to CLIP_VIEWPORT, is aligned to a 64-byte boundary."
  1540.     */
  1541.    assert(num_viewports && num_viewports <= 16);
  1542.  
  1543.    state_offset = ilo_builder_dynamic_pointer(builder,
  1544.          ILO_BUILDER_ITEM_SF_VIEWPORT, state_align, state_len, &dw);
  1545.  
  1546.    for (i = 0; i < num_viewports; i++) {
  1547.       const struct ilo_viewport_cso *vp = &viewports[i];
  1548.  
  1549.       dw[0] = fui(vp->m00);
  1550.       dw[1] = fui(vp->m11);
  1551.       dw[2] = fui(vp->m22);
  1552.       dw[3] = fui(vp->m30);
  1553.       dw[4] = fui(vp->m31);
  1554.       dw[5] = fui(vp->m32);
  1555.       dw[6] = 0;
  1556.       dw[7] = 0;
  1557.  
  1558.       dw[8] = fui(vp->min_gbx);
  1559.       dw[9] = fui(vp->max_gbx);
  1560.       dw[10] = fui(vp->min_gby);
  1561.       dw[11] = fui(vp->max_gby);
  1562.  
  1563.       if (ilo_dev_gen(builder->dev) >= ILO_GEN(8)) {
  1564.          dw[12] = fui(vp->min_x);
  1565.          dw[13] = fui(vp->max_x - 1.0f);
  1566.          dw[14] = fui(vp->min_y);
  1567.          dw[15] = fui(vp->max_y - 1.0f);
  1568.       } else {
  1569.          dw[12] = 0;
  1570.          dw[13] = 0;
  1571.          dw[14] = 0;
  1572.          dw[15] = 0;
  1573.       }
  1574.  
  1575.       dw += 16;
  1576.    }
  1577.  
  1578.    return state_offset;
  1579. }
  1580.  
  1581. static inline uint32_t
  1582. gen6_CC_VIEWPORT(struct ilo_builder *builder,
  1583.                  const struct ilo_viewport_cso *viewports,
  1584.                  unsigned num_viewports)
  1585. {
  1586.    const int state_align = 32;
  1587.    const int state_len = 2 * num_viewports;
  1588.    uint32_t state_offset, *dw;
  1589.    unsigned i;
  1590.  
  1591.    ILO_DEV_ASSERT(builder->dev, 6, 8);
  1592.  
  1593.    /*
  1594.     * From the Sandy Bridge PRM, volume 2 part 1, page 385:
  1595.     *
  1596.     *     "The viewport state is stored as an array of up to 16 elements..."
  1597.     */
  1598.    assert(num_viewports && num_viewports <= 16);
  1599.  
  1600.    state_offset = ilo_builder_dynamic_pointer(builder,
  1601.          ILO_BUILDER_ITEM_CC_VIEWPORT, state_align, state_len, &dw);
  1602.  
  1603.    for (i = 0; i < num_viewports; i++) {
  1604.       const struct ilo_viewport_cso *vp = &viewports[i];
  1605.  
  1606.       dw[0] = fui(vp->min_z);
  1607.       dw[1] = fui(vp->max_z);
  1608.  
  1609.       dw += 2;
  1610.    }
  1611.  
  1612.    return state_offset;
  1613. }
  1614.  
  1615. static inline uint32_t
  1616. gen6_SCISSOR_RECT(struct ilo_builder *builder,
  1617.                   const struct ilo_scissor_state *scissor,
  1618.                   unsigned num_viewports)
  1619. {
  1620.    const int state_align = 32;
  1621.    const int state_len = 2 * num_viewports;
  1622.  
  1623.    ILO_DEV_ASSERT(builder->dev, 6, 8);
  1624.  
  1625.    /*
  1626.     * From the Sandy Bridge PRM, volume 2 part 1, page 263:
  1627.     *
  1628.     *     "The viewport-specific state used by the SF unit (SCISSOR_RECT) is
  1629.     *      stored as an array of up to 16 elements..."
  1630.     */
  1631.    assert(num_viewports && num_viewports <= 16);
  1632.    assert(Elements(scissor->payload) >= state_len);
  1633.  
  1634.    return ilo_builder_dynamic_write(builder, ILO_BUILDER_ITEM_SCISSOR_RECT,
  1635.          state_align, state_len, scissor->payload);
  1636. }
  1637.  
  1638. static inline uint32_t
  1639. gen6_COLOR_CALC_STATE(struct ilo_builder *builder,
  1640.                       const struct pipe_stencil_ref *stencil_ref,
  1641.                       ubyte alpha_ref,
  1642.                       const struct pipe_blend_color *blend_color)
  1643. {
  1644.    const int state_align = 64;
  1645.    const int state_len = 6;
  1646.    uint32_t state_offset, *dw;
  1647.  
  1648.    ILO_DEV_ASSERT(builder->dev, 6, 8);
  1649.  
  1650.    state_offset = ilo_builder_dynamic_pointer(builder,
  1651.          ILO_BUILDER_ITEM_COLOR_CALC, state_align, state_len, &dw);
  1652.  
  1653.    dw[0] = stencil_ref->ref_value[0] << 24 |
  1654.            stencil_ref->ref_value[1] << 16 |
  1655.            GEN6_CC_DW0_ALPHATEST_UNORM8;
  1656.    dw[1] = alpha_ref;
  1657.    dw[2] = fui(blend_color->color[0]);
  1658.    dw[3] = fui(blend_color->color[1]);
  1659.    dw[4] = fui(blend_color->color[2]);
  1660.    dw[5] = fui(blend_color->color[3]);
  1661.  
  1662.    return state_offset;
  1663. }
  1664.  
  1665. static inline uint32_t
  1666. gen6_DEPTH_STENCIL_STATE(struct ilo_builder *builder,
  1667.                          const struct ilo_dsa_state *dsa)
  1668. {
  1669.    const int state_align = 64;
  1670.    const int state_len = 3;
  1671.  
  1672.    ILO_DEV_ASSERT(builder->dev, 6, 7.5);
  1673.  
  1674.    STATIC_ASSERT(Elements(dsa->payload) >= state_len);
  1675.  
  1676.    return ilo_builder_dynamic_write(builder, ILO_BUILDER_ITEM_DEPTH_STENCIL,
  1677.          state_align, state_len, dsa->payload);
  1678. }
  1679.  
  1680. static inline uint32_t
  1681. gen6_BLEND_STATE(struct ilo_builder *builder,
  1682.                  const struct ilo_blend_state *blend,
  1683.                  const struct ilo_fb_state *fb,
  1684.                  const struct ilo_dsa_state *dsa)
  1685. {
  1686.    const int state_align = 64;
  1687.    int state_len;
  1688.    uint32_t state_offset, *dw;
  1689.    unsigned num_targets, i;
  1690.  
  1691.    ILO_DEV_ASSERT(builder->dev, 6, 7.5);
  1692.  
  1693.    /*
  1694.     * From the Sandy Bridge PRM, volume 2 part 1, page 376:
  1695.     *
  1696.     *     "The blend state is stored as an array of up to 8 elements..."
  1697.     */
  1698.    num_targets = fb->state.nr_cbufs;
  1699.    assert(num_targets <= 8);
  1700.  
  1701.    if (!num_targets) {
  1702.       if (!dsa->dw_blend_alpha)
  1703.          return 0;
  1704.       /* to be able to reference alpha func */
  1705.       num_targets = 1;
  1706.    }
  1707.  
  1708.    state_len = 2 * num_targets;
  1709.  
  1710.    state_offset = ilo_builder_dynamic_pointer(builder,
  1711.          ILO_BUILDER_ITEM_BLEND, state_align, state_len, &dw);
  1712.  
  1713.    for (i = 0; i < num_targets; i++) {
  1714.       const struct ilo_blend_cso *cso = &blend->cso[i];
  1715.  
  1716.       dw[0] = cso->payload[0];
  1717.       dw[1] = cso->payload[1] | blend->dw_shared;
  1718.  
  1719.       if (i < fb->state.nr_cbufs && fb->state.cbufs[i]) {
  1720.          const struct ilo_fb_blend_caps *caps = &fb->blend_caps[i];
  1721.  
  1722.          if (caps->can_blend) {
  1723.             if (caps->dst_alpha_forced_one)
  1724.                dw[0] |= cso->dw_blend_dst_alpha_forced_one;
  1725.             else
  1726.                dw[0] |= cso->dw_blend;
  1727.          }
  1728.  
  1729.          if (caps->can_logicop)
  1730.             dw[1] |= blend->dw_logicop;
  1731.  
  1732.          if (caps->can_alpha_test)
  1733.             dw[1] |= dsa->dw_blend_alpha;
  1734.       } else {
  1735.          dw[1] |= GEN6_RT_DW1_WRITE_DISABLE_A |
  1736.                   GEN6_RT_DW1_WRITE_DISABLE_R |
  1737.                   GEN6_RT_DW1_WRITE_DISABLE_G |
  1738.                   GEN6_RT_DW1_WRITE_DISABLE_B |
  1739.                   dsa->dw_blend_alpha;
  1740.       }
  1741.  
  1742.       /*
  1743.        * From the Sandy Bridge PRM, volume 2 part 1, page 356:
  1744.        *
  1745.        *     "When NumSamples = 1, AlphaToCoverage and AlphaToCoverage
  1746.        *      Dither both must be disabled."
  1747.        *
  1748.        * There is no such limitation on GEN7, or for AlphaToOne.  But GL
  1749.        * requires that anyway.
  1750.        */
  1751.       if (fb->num_samples > 1)
  1752.          dw[1] |= blend->dw_alpha_mod;
  1753.  
  1754.       dw += 2;
  1755.    }
  1756.  
  1757.    return state_offset;
  1758. }
  1759.  
  1760. static inline uint32_t
  1761. gen8_BLEND_STATE(struct ilo_builder *builder,
  1762.                  const struct ilo_blend_state *blend,
  1763.                  const struct ilo_fb_state *fb,
  1764.                  const struct ilo_dsa_state *dsa)
  1765. {
  1766.    const int state_align = 64;
  1767.    const int state_len = 1 + 2 * fb->state.nr_cbufs;
  1768.    uint32_t state_offset, *dw;
  1769.    unsigned i;
  1770.  
  1771.    ILO_DEV_ASSERT(builder->dev, 8, 8);
  1772.  
  1773.    assert(fb->state.nr_cbufs <= 8);
  1774.  
  1775.    state_offset = ilo_builder_dynamic_pointer(builder,
  1776.          ILO_BUILDER_ITEM_BLEND, state_align, state_len, &dw);
  1777.  
  1778.    dw[0] = blend->dw_shared;
  1779.    if (fb->num_samples > 1)
  1780.       dw[0] |= blend->dw_alpha_mod;
  1781.    if (!fb->state.nr_cbufs || fb->blend_caps[0].can_alpha_test)
  1782.       dw[0] |= dsa->dw_blend_alpha;
  1783.    dw++;
  1784.  
  1785.    for (i = 0; i < fb->state.nr_cbufs; i++) {
  1786.       const struct ilo_fb_blend_caps *caps = &fb->blend_caps[i];
  1787.       const struct ilo_blend_cso *cso = &blend->cso[i];
  1788.  
  1789.       dw[0] = cso->payload[0];
  1790.       dw[1] = cso->payload[1];
  1791.  
  1792.       if (fb->state.cbufs[i]) {
  1793.          if (caps->can_blend) {
  1794.             if (caps->dst_alpha_forced_one)
  1795.                dw[0] |= cso->dw_blend_dst_alpha_forced_one;
  1796.             else
  1797.                dw[0] |= cso->dw_blend;
  1798.          }
  1799.  
  1800.          if (caps->can_logicop)
  1801.             dw[1] |= blend->dw_logicop;
  1802.       } else {
  1803.          dw[0] |= GEN8_RT_DW0_WRITE_DISABLE_A |
  1804.                   GEN8_RT_DW0_WRITE_DISABLE_R |
  1805.                   GEN8_RT_DW0_WRITE_DISABLE_G |
  1806.                   GEN8_RT_DW0_WRITE_DISABLE_B;
  1807.       }
  1808.  
  1809.       dw += 2;
  1810.    }
  1811.  
  1812.    return state_offset;
  1813. }
  1814.  
  1815. #endif /* ILO_BUILDER_3D_BOTTOM_H */
  1816.