Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Copyright 2012 Advanced Micro Devices, Inc.
  3.  *
  4.  * Permission is hereby granted, free of charge, to any person obtaining a
  5.  * copy of this software and associated documentation files (the "Software"),
  6.  * to deal in the Software without restriction, including without limitation
  7.  * on the rights to use, copy, modify, merge, publish, distribute, sub
  8.  * license, and/or sell copies of the Software, and to permit persons to whom
  9.  * the Software is furnished to do so, subject to the following conditions:
  10.  *
  11.  * The above copyright notice and this permission notice (including the next
  12.  * paragraph) shall be included in all copies or substantial portions of the
  13.  * Software.
  14.  *
  15.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17.  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  18.  * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
  19.  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  20.  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  21.  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  22.  *
  23.  * Authors:
  24.  *      Christian König <christian.koenig@amd.com>
  25.  *      Marek Olšák <maraeo@gmail.com>
  26.  */
  27.  
  28. #include "si_pipe.h"
  29. #include "si_shader.h"
  30. #include "sid.h"
  31.  
  32. #include "tgsi/tgsi_parse.h"
  33. #include "util/u_memory.h"
  34. #include "util/u_simple_shaders.h"
  35.  
  36. static void si_shader_es(struct si_shader *shader)
  37. {
  38.         struct si_pm4_state *pm4;
  39.         unsigned num_sgprs, num_user_sgprs;
  40.         unsigned vgpr_comp_cnt;
  41.         uint64_t va;
  42.  
  43.         pm4 = shader->pm4 = CALLOC_STRUCT(si_pm4_state);
  44.  
  45.         if (pm4 == NULL)
  46.                 return;
  47.  
  48.         va = shader->bo->gpu_address;
  49.         si_pm4_add_bo(pm4, shader->bo, RADEON_USAGE_READ, RADEON_PRIO_SHADER_DATA);
  50.  
  51.         vgpr_comp_cnt = shader->uses_instanceid ? 3 : 0;
  52.  
  53.         num_user_sgprs = SI_VS_NUM_USER_SGPR;
  54.         num_sgprs = shader->num_sgprs;
  55.         /* One SGPR after user SGPRs is pre-loaded with es2gs_offset */
  56.         if ((num_user_sgprs + 1) > num_sgprs) {
  57.                 /* Last 2 reserved SGPRs are used for VCC */
  58.                 num_sgprs = num_user_sgprs + 1 + 2;
  59.         }
  60.         assert(num_sgprs <= 104);
  61.  
  62.         si_pm4_set_reg(pm4, R_00B320_SPI_SHADER_PGM_LO_ES, va >> 8);
  63.         si_pm4_set_reg(pm4, R_00B324_SPI_SHADER_PGM_HI_ES, va >> 40);
  64.         si_pm4_set_reg(pm4, R_00B328_SPI_SHADER_PGM_RSRC1_ES,
  65.                        S_00B328_VGPRS((shader->num_vgprs - 1) / 4) |
  66.                        S_00B328_SGPRS((num_sgprs - 1) / 8) |
  67.                        S_00B328_VGPR_COMP_CNT(vgpr_comp_cnt) |
  68.                        S_00B328_DX10_CLAMP(shader->dx10_clamp_mode));
  69.         si_pm4_set_reg(pm4, R_00B32C_SPI_SHADER_PGM_RSRC2_ES,
  70.                        S_00B32C_USER_SGPR(num_user_sgprs) |
  71.                        S_00B32C_SCRATCH_EN(shader->scratch_bytes_per_wave > 0));
  72. }
  73.  
  74. static void si_shader_gs(struct si_shader *shader)
  75. {
  76.         unsigned gs_vert_itemsize = shader->selector->info.num_outputs * (16 >> 2);
  77.         unsigned gs_max_vert_out = shader->selector->gs_max_out_vertices;
  78.         unsigned gsvs_itemsize = gs_vert_itemsize * gs_max_vert_out;
  79.         unsigned cut_mode;
  80.         struct si_pm4_state *pm4;
  81.         unsigned num_sgprs, num_user_sgprs;
  82.         uint64_t va;
  83.  
  84.         /* The GSVS_RING_ITEMSIZE register takes 15 bits */
  85.         assert(gsvs_itemsize < (1 << 15));
  86.  
  87.         pm4 = shader->pm4 = CALLOC_STRUCT(si_pm4_state);
  88.  
  89.         if (pm4 == NULL)
  90.                 return;
  91.  
  92.         if (gs_max_vert_out <= 128) {
  93.                 cut_mode = V_028A40_GS_CUT_128;
  94.         } else if (gs_max_vert_out <= 256) {
  95.                 cut_mode = V_028A40_GS_CUT_256;
  96.         } else if (gs_max_vert_out <= 512) {
  97.                 cut_mode = V_028A40_GS_CUT_512;
  98.         } else {
  99.                 assert(gs_max_vert_out <= 1024);
  100.                 cut_mode = V_028A40_GS_CUT_1024;
  101.         }
  102.  
  103.         si_pm4_set_reg(pm4, R_028A40_VGT_GS_MODE,
  104.                        S_028A40_MODE(V_028A40_GS_SCENARIO_G) |
  105.                        S_028A40_CUT_MODE(cut_mode)|
  106.                        S_028A40_ES_WRITE_OPTIMIZE(1) |
  107.                        S_028A40_GS_WRITE_OPTIMIZE(1));
  108.  
  109.         si_pm4_set_reg(pm4, R_028A60_VGT_GSVS_RING_OFFSET_1, gsvs_itemsize);
  110.         si_pm4_set_reg(pm4, R_028A64_VGT_GSVS_RING_OFFSET_2, gsvs_itemsize);
  111.         si_pm4_set_reg(pm4, R_028A68_VGT_GSVS_RING_OFFSET_3, gsvs_itemsize);
  112.  
  113.         si_pm4_set_reg(pm4, R_028AAC_VGT_ESGS_RING_ITEMSIZE,
  114.                        util_bitcount64(shader->selector->gs_used_inputs) * (16 >> 2));
  115.         si_pm4_set_reg(pm4, R_028AB0_VGT_GSVS_RING_ITEMSIZE, gsvs_itemsize);
  116.  
  117.         si_pm4_set_reg(pm4, R_028B38_VGT_GS_MAX_VERT_OUT, gs_max_vert_out);
  118.  
  119.         si_pm4_set_reg(pm4, R_028B5C_VGT_GS_VERT_ITEMSIZE, gs_vert_itemsize);
  120.  
  121.         va = shader->bo->gpu_address;
  122.         si_pm4_add_bo(pm4, shader->bo, RADEON_USAGE_READ, RADEON_PRIO_SHADER_DATA);
  123.         si_pm4_set_reg(pm4, R_00B220_SPI_SHADER_PGM_LO_GS, va >> 8);
  124.         si_pm4_set_reg(pm4, R_00B224_SPI_SHADER_PGM_HI_GS, va >> 40);
  125.  
  126.         num_user_sgprs = SI_GS_NUM_USER_SGPR;
  127.         num_sgprs = shader->num_sgprs;
  128.         /* Two SGPRs after user SGPRs are pre-loaded with gs2vs_offset, gs_wave_id */
  129.         if ((num_user_sgprs + 2) > num_sgprs) {
  130.                 /* Last 2 reserved SGPRs are used for VCC */
  131.                 num_sgprs = num_user_sgprs + 2 + 2;
  132.         }
  133.         assert(num_sgprs <= 104);
  134.  
  135.         si_pm4_set_reg(pm4, R_00B228_SPI_SHADER_PGM_RSRC1_GS,
  136.                        S_00B228_VGPRS((shader->num_vgprs - 1) / 4) |
  137.                        S_00B228_SGPRS((num_sgprs - 1) / 8) |
  138.                        S_00B228_DX10_CLAMP(shader->dx10_clamp_mode));
  139.         si_pm4_set_reg(pm4, R_00B22C_SPI_SHADER_PGM_RSRC2_GS,
  140.                        S_00B22C_USER_SGPR(num_user_sgprs) |
  141.                        S_00B22C_SCRATCH_EN(shader->scratch_bytes_per_wave > 0));
  142. }
  143.  
  144. static void si_shader_vs(struct si_shader *shader)
  145. {
  146.         struct tgsi_shader_info *info = &shader->selector->info;
  147.         struct si_pm4_state *pm4;
  148.         unsigned num_sgprs, num_user_sgprs;
  149.         unsigned nparams, i, vgpr_comp_cnt;
  150.         uint64_t va;
  151.         unsigned window_space =
  152.            shader->selector->info.properties[TGSI_PROPERTY_VS_WINDOW_SPACE_POSITION];
  153.  
  154.         pm4 = shader->pm4 = CALLOC_STRUCT(si_pm4_state);
  155.  
  156.         if (pm4 == NULL)
  157.                 return;
  158.  
  159.         va = shader->bo->gpu_address;
  160.         si_pm4_add_bo(pm4, shader->bo, RADEON_USAGE_READ, RADEON_PRIO_SHADER_DATA);
  161.  
  162.         if (shader->is_gs_copy_shader) {
  163.                 vgpr_comp_cnt = 0; /* only VertexID is needed for GS-COPY. */
  164.                 num_user_sgprs = SI_GSCOPY_NUM_USER_SGPR;
  165.         } else if (shader->selector->type == PIPE_SHADER_VERTEX) {
  166.                 vgpr_comp_cnt = shader->uses_instanceid ? 3 : 0;
  167.                 num_user_sgprs = SI_VS_NUM_USER_SGPR;
  168.         } else
  169.                 assert(0);
  170.  
  171.         num_sgprs = shader->num_sgprs;
  172.         if (num_user_sgprs > num_sgprs) {
  173.                 /* Last 2 reserved SGPRs are used for VCC */
  174.                 num_sgprs = num_user_sgprs + 2;
  175.         }
  176.         assert(num_sgprs <= 104);
  177.  
  178.         /* Certain attributes (position, psize, etc.) don't count as params.
  179.          * VS is required to export at least one param and r600_shader_from_tgsi()
  180.          * takes care of adding a dummy export.
  181.          */
  182.         for (nparams = 0, i = 0 ; i < info->num_outputs; i++) {
  183.                 switch (info->output_semantic_name[i]) {
  184.                 case TGSI_SEMANTIC_CLIPVERTEX:
  185.                 case TGSI_SEMANTIC_POSITION:
  186.                 case TGSI_SEMANTIC_PSIZE:
  187.                         break;
  188.                 default:
  189.                         nparams++;
  190.                 }
  191.         }
  192.         if (nparams < 1)
  193.                 nparams = 1;
  194.  
  195.         si_pm4_set_reg(pm4, R_0286C4_SPI_VS_OUT_CONFIG,
  196.                        S_0286C4_VS_EXPORT_COUNT(nparams - 1));
  197.  
  198.         si_pm4_set_reg(pm4, R_02870C_SPI_SHADER_POS_FORMAT,
  199.                        S_02870C_POS0_EXPORT_FORMAT(V_02870C_SPI_SHADER_4COMP) |
  200.                        S_02870C_POS1_EXPORT_FORMAT(shader->nr_pos_exports > 1 ?
  201.                                                    V_02870C_SPI_SHADER_4COMP :
  202.                                                    V_02870C_SPI_SHADER_NONE) |
  203.                        S_02870C_POS2_EXPORT_FORMAT(shader->nr_pos_exports > 2 ?
  204.                                                    V_02870C_SPI_SHADER_4COMP :
  205.                                                    V_02870C_SPI_SHADER_NONE) |
  206.                        S_02870C_POS3_EXPORT_FORMAT(shader->nr_pos_exports > 3 ?
  207.                                                    V_02870C_SPI_SHADER_4COMP :
  208.                                                    V_02870C_SPI_SHADER_NONE));
  209.  
  210.         si_pm4_set_reg(pm4, R_00B120_SPI_SHADER_PGM_LO_VS, va >> 8);
  211.         si_pm4_set_reg(pm4, R_00B124_SPI_SHADER_PGM_HI_VS, va >> 40);
  212.         si_pm4_set_reg(pm4, R_00B128_SPI_SHADER_PGM_RSRC1_VS,
  213.                        S_00B128_VGPRS((shader->num_vgprs - 1) / 4) |
  214.                        S_00B128_SGPRS((num_sgprs - 1) / 8) |
  215.                        S_00B128_VGPR_COMP_CNT(vgpr_comp_cnt) |
  216.                        S_00B128_DX10_CLAMP(shader->dx10_clamp_mode));
  217.         si_pm4_set_reg(pm4, R_00B12C_SPI_SHADER_PGM_RSRC2_VS,
  218.                        S_00B12C_USER_SGPR(num_user_sgprs) |
  219.                        S_00B12C_SO_BASE0_EN(!!shader->selector->so.stride[0]) |
  220.                        S_00B12C_SO_BASE1_EN(!!shader->selector->so.stride[1]) |
  221.                        S_00B12C_SO_BASE2_EN(!!shader->selector->so.stride[2]) |
  222.                        S_00B12C_SO_BASE3_EN(!!shader->selector->so.stride[3]) |
  223.                        S_00B12C_SO_EN(!!shader->selector->so.num_outputs) |
  224.                        S_00B12C_SCRATCH_EN(shader->scratch_bytes_per_wave > 0));
  225.         if (window_space)
  226.                 si_pm4_set_reg(pm4, R_028818_PA_CL_VTE_CNTL,
  227.                                S_028818_VTX_XY_FMT(1) | S_028818_VTX_Z_FMT(1));
  228.         else
  229.                 si_pm4_set_reg(pm4, R_028818_PA_CL_VTE_CNTL,
  230.                                S_028818_VTX_W0_FMT(1) |
  231.                                S_028818_VPORT_X_SCALE_ENA(1) | S_028818_VPORT_X_OFFSET_ENA(1) |
  232.                                S_028818_VPORT_Y_SCALE_ENA(1) | S_028818_VPORT_Y_OFFSET_ENA(1) |
  233.                                S_028818_VPORT_Z_SCALE_ENA(1) | S_028818_VPORT_Z_OFFSET_ENA(1));
  234. }
  235.  
  236. static void si_shader_ps(struct si_shader *shader)
  237. {
  238.         struct tgsi_shader_info *info = &shader->selector->info;
  239.         struct si_pm4_state *pm4;
  240.         unsigned i, spi_ps_in_control;
  241.         unsigned num_sgprs, num_user_sgprs;
  242.         unsigned spi_baryc_cntl = 0, spi_ps_input_ena;
  243.         uint64_t va;
  244.  
  245.         pm4 = shader->pm4 = CALLOC_STRUCT(si_pm4_state);
  246.  
  247.         if (pm4 == NULL)
  248.                 return;
  249.  
  250.         for (i = 0; i < info->num_inputs; i++) {
  251.                 switch (info->input_semantic_name[i]) {
  252.                 case TGSI_SEMANTIC_POSITION:
  253.                         /* SPI_BARYC_CNTL.POS_FLOAT_LOCATION
  254.                          * Possible vaules:
  255.                          * 0 -> Position = pixel center (default)
  256.                          * 1 -> Position = pixel centroid
  257.                          * 2 -> Position = at sample position
  258.                          */
  259.                         switch (info->input_interpolate_loc[i]) {
  260.                         case TGSI_INTERPOLATE_LOC_CENTROID:
  261.                                 spi_baryc_cntl |= S_0286E0_POS_FLOAT_LOCATION(1);
  262.                                 break;
  263.                         case TGSI_INTERPOLATE_LOC_SAMPLE:
  264.                                 spi_baryc_cntl |= S_0286E0_POS_FLOAT_LOCATION(2);
  265.                                 break;
  266.                         }
  267.  
  268.                         if (info->properties[TGSI_PROPERTY_FS_COORD_PIXEL_CENTER] ==
  269.                             TGSI_FS_COORD_PIXEL_CENTER_INTEGER)
  270.                                 spi_baryc_cntl |= S_0286E0_POS_FLOAT_ULC(1);
  271.                         break;
  272.                 }
  273.         }
  274.  
  275.         spi_ps_in_control = S_0286D8_NUM_INTERP(shader->nparam) |
  276.                 S_0286D8_BC_OPTIMIZE_DISABLE(1);
  277.  
  278.         si_pm4_set_reg(pm4, R_0286E0_SPI_BARYC_CNTL, spi_baryc_cntl);
  279.         spi_ps_input_ena = shader->spi_ps_input_ena;
  280.         /* we need to enable at least one of them, otherwise we hang the GPU */
  281.         assert(G_0286CC_PERSP_SAMPLE_ENA(spi_ps_input_ena) ||
  282.             G_0286CC_PERSP_CENTER_ENA(spi_ps_input_ena) ||
  283.             G_0286CC_PERSP_CENTROID_ENA(spi_ps_input_ena) ||
  284.             G_0286CC_PERSP_PULL_MODEL_ENA(spi_ps_input_ena) ||
  285.             G_0286CC_LINEAR_SAMPLE_ENA(spi_ps_input_ena) ||
  286.             G_0286CC_LINEAR_CENTER_ENA(spi_ps_input_ena) ||
  287.             G_0286CC_LINEAR_CENTROID_ENA(spi_ps_input_ena) ||
  288.             G_0286CC_LINE_STIPPLE_TEX_ENA(spi_ps_input_ena));
  289.  
  290.         si_pm4_set_reg(pm4, R_0286CC_SPI_PS_INPUT_ENA, spi_ps_input_ena);
  291.         si_pm4_set_reg(pm4, R_0286D0_SPI_PS_INPUT_ADDR, spi_ps_input_ena);
  292.         si_pm4_set_reg(pm4, R_0286D8_SPI_PS_IN_CONTROL, spi_ps_in_control);
  293.  
  294.         si_pm4_set_reg(pm4, R_028710_SPI_SHADER_Z_FORMAT, shader->spi_shader_z_format);
  295.         si_pm4_set_reg(pm4, R_028714_SPI_SHADER_COL_FORMAT,
  296.                        shader->spi_shader_col_format);
  297.         si_pm4_set_reg(pm4, R_02823C_CB_SHADER_MASK, shader->cb_shader_mask);
  298.  
  299.         va = shader->bo->gpu_address;
  300.         si_pm4_add_bo(pm4, shader->bo, RADEON_USAGE_READ, RADEON_PRIO_SHADER_DATA);
  301.         si_pm4_set_reg(pm4, R_00B020_SPI_SHADER_PGM_LO_PS, va >> 8);
  302.         si_pm4_set_reg(pm4, R_00B024_SPI_SHADER_PGM_HI_PS, va >> 40);
  303.  
  304.         num_user_sgprs = SI_PS_NUM_USER_SGPR;
  305.         num_sgprs = shader->num_sgprs;
  306.         /* One SGPR after user SGPRs is pre-loaded with {prim_mask, lds_offset} */
  307.         if ((num_user_sgprs + 1) > num_sgprs) {
  308.                 /* Last 2 reserved SGPRs are used for VCC */
  309.                 num_sgprs = num_user_sgprs + 1 + 2;
  310.         }
  311.         assert(num_sgprs <= 104);
  312.  
  313.         si_pm4_set_reg(pm4, R_00B028_SPI_SHADER_PGM_RSRC1_PS,
  314.                        S_00B028_VGPRS((shader->num_vgprs - 1) / 4) |
  315.                        S_00B028_SGPRS((num_sgprs - 1) / 8) |
  316.                        S_00B028_DX10_CLAMP(shader->dx10_clamp_mode));
  317.         si_pm4_set_reg(pm4, R_00B02C_SPI_SHADER_PGM_RSRC2_PS,
  318.                        S_00B02C_EXTRA_LDS_SIZE(shader->lds_size) |
  319.                        S_00B02C_USER_SGPR(num_user_sgprs) |
  320.                        S_00B32C_SCRATCH_EN(shader->scratch_bytes_per_wave > 0));
  321. }
  322.  
  323. static void si_shader_init_pm4_state(struct si_shader *shader)
  324. {
  325.  
  326.         if (shader->pm4)
  327.                 si_pm4_free_state_simple(shader->pm4);
  328.  
  329.         switch (shader->selector->type) {
  330.         case PIPE_SHADER_VERTEX:
  331.                 if (shader->key.vs.as_es)
  332.                         si_shader_es(shader);
  333.                 else
  334.                         si_shader_vs(shader);
  335.                 break;
  336.         case PIPE_SHADER_GEOMETRY:
  337.                 si_shader_gs(shader);
  338.                 si_shader_vs(shader->gs_copy_shader);
  339.                 break;
  340.         case PIPE_SHADER_FRAGMENT:
  341.                 si_shader_ps(shader);
  342.                 break;
  343.         default:
  344.                 assert(0);
  345.         }
  346. }
  347.  
  348. /* Compute the key for the hw shader variant */
  349. static INLINE void si_shader_selector_key(struct pipe_context *ctx,
  350.                                           struct si_shader_selector *sel,
  351.                                           union si_shader_key *key)
  352. {
  353.         struct si_context *sctx = (struct si_context *)ctx;
  354.         memset(key, 0, sizeof(*key));
  355.  
  356.         if (sel->type == PIPE_SHADER_VERTEX) {
  357.                 unsigned i;
  358.                 if (!sctx->vertex_elements)
  359.                         return;
  360.  
  361.                 for (i = 0; i < sctx->vertex_elements->count; ++i)
  362.                         key->vs.instance_divisors[i] = sctx->vertex_elements->elements[i].instance_divisor;
  363.  
  364.                 if (sctx->gs_shader) {
  365.                         key->vs.as_es = 1;
  366.                         key->vs.gs_used_inputs = sctx->gs_shader->gs_used_inputs;
  367.                 }
  368.         } else if (sel->type == PIPE_SHADER_FRAGMENT) {
  369.                 struct si_state_rasterizer *rs = sctx->queued.named.rasterizer;
  370.  
  371.                 if (sel->info.properties[TGSI_PROPERTY_FS_COLOR0_WRITES_ALL_CBUFS])
  372.                         key->ps.last_cbuf = MAX2(sctx->framebuffer.state.nr_cbufs, 1) - 1;
  373.                 key->ps.export_16bpc = sctx->framebuffer.export_16bpc;
  374.  
  375.                 if (rs) {
  376.                         bool is_poly = (sctx->current_rast_prim >= PIPE_PRIM_TRIANGLES &&
  377.                                         sctx->current_rast_prim <= PIPE_PRIM_POLYGON) ||
  378.                                        sctx->current_rast_prim >= PIPE_PRIM_TRIANGLES_ADJACENCY;
  379.                         bool is_line = !is_poly && sctx->current_rast_prim != PIPE_PRIM_POINTS;
  380.  
  381.                         key->ps.color_two_side = rs->two_side;
  382.  
  383.                         if (sctx->queued.named.blend) {
  384.                                 key->ps.alpha_to_one = sctx->queued.named.blend->alpha_to_one &&
  385.                                                        rs->multisample_enable &&
  386.                                                        !sctx->framebuffer.cb0_is_integer;
  387.                         }
  388.  
  389.                         key->ps.poly_stipple = rs->poly_stipple_enable && is_poly;
  390.                         key->ps.poly_line_smoothing = ((is_poly && rs->poly_smooth) ||
  391.                                                        (is_line && rs->line_smooth)) &&
  392.                                                       sctx->framebuffer.nr_samples <= 1;
  393.                 }
  394.  
  395.                 key->ps.alpha_func = PIPE_FUNC_ALWAYS;
  396.  
  397.                 /* Alpha-test should be disabled if colorbuffer 0 is integer. */
  398.                 if (sctx->queued.named.dsa &&
  399.                     !sctx->framebuffer.cb0_is_integer)
  400.                         key->ps.alpha_func = sctx->queued.named.dsa->alpha_func;
  401.         }
  402. }
  403.  
  404. /* Select the hw shader variant depending on the current state. */
  405. static int si_shader_select(struct pipe_context *ctx,
  406.                             struct si_shader_selector *sel)
  407. {
  408.         struct si_context *sctx = (struct si_context *)ctx;
  409.         union si_shader_key key;
  410.         struct si_shader * shader = NULL;
  411.         int r;
  412.  
  413.         si_shader_selector_key(ctx, sel, &key);
  414.  
  415.         /* Check if we don't need to change anything.
  416.          * This path is also used for most shaders that don't need multiple
  417.          * variants, it will cost just a computation of the key and this
  418.          * test. */
  419.         if (likely(sel->current && memcmp(&sel->current->key, &key, sizeof(key)) == 0)) {
  420.                 return 0;
  421.         }
  422.  
  423.         /* lookup if we have other variants in the list */
  424.         if (sel->num_shaders > 1) {
  425.                 struct si_shader *p = sel->current, *c = p->next_variant;
  426.  
  427.                 while (c && memcmp(&c->key, &key, sizeof(key)) != 0) {
  428.                         p = c;
  429.                         c = c->next_variant;
  430.                 }
  431.  
  432.                 if (c) {
  433.                         p->next_variant = c->next_variant;
  434.                         shader = c;
  435.                 }
  436.         }
  437.  
  438.         if (shader) {
  439.                 shader->next_variant = sel->current;
  440.                 sel->current = shader;
  441.         } else {
  442.                 shader = CALLOC(1, sizeof(struct si_shader));
  443.                 shader->selector = sel;
  444.                 shader->key = key;
  445.  
  446.                 shader->next_variant = sel->current;
  447.                 sel->current = shader;
  448.                 r = si_shader_create((struct si_screen*)ctx->screen, sctx->tm,
  449.                                      shader);
  450.                 if (unlikely(r)) {
  451.                         R600_ERR("Failed to build shader variant (type=%u) %d\n",
  452.                                  sel->type, r);
  453.                         sel->current = NULL;
  454.                         FREE(shader);
  455.                         return r;
  456.                 }
  457.                 si_shader_init_pm4_state(shader);
  458.                 sel->num_shaders++;
  459.         }
  460.  
  461.         return 0;
  462. }
  463.  
  464. static void *si_create_shader_state(struct pipe_context *ctx,
  465.                                     const struct pipe_shader_state *state,
  466.                                     unsigned pipe_shader_type)
  467. {
  468.         struct si_screen *sscreen = (struct si_screen *)ctx->screen;
  469.         struct si_shader_selector *sel = CALLOC_STRUCT(si_shader_selector);
  470.         int i;
  471.  
  472.         sel->type = pipe_shader_type;
  473.         sel->tokens = tgsi_dup_tokens(state->tokens);
  474.         sel->so = state->stream_output;
  475.         tgsi_scan_shader(state->tokens, &sel->info);
  476.  
  477.         switch (pipe_shader_type) {
  478.         case PIPE_SHADER_GEOMETRY:
  479.                 sel->gs_output_prim =
  480.                         sel->info.properties[TGSI_PROPERTY_GS_OUTPUT_PRIM];
  481.                 sel->gs_max_out_vertices =
  482.                         sel->info.properties[TGSI_PROPERTY_GS_MAX_OUTPUT_VERTICES];
  483.  
  484.                 for (i = 0; i < sel->info.num_inputs; i++) {
  485.                         unsigned name = sel->info.input_semantic_name[i];
  486.                         unsigned index = sel->info.input_semantic_index[i];
  487.  
  488.                         switch (name) {
  489.                         case TGSI_SEMANTIC_PRIMID:
  490.                                 break;
  491.                         default:
  492.                                 sel->gs_used_inputs |=
  493.                                         1llu << si_shader_io_get_unique_index(name, index);
  494.                         }
  495.                 }
  496.         }
  497.  
  498.         if (sscreen->b.debug_flags & DBG_PRECOMPILE)
  499.                 si_shader_select(ctx, sel);
  500.  
  501.         return sel;
  502. }
  503.  
  504. static void *si_create_fs_state(struct pipe_context *ctx,
  505.                                 const struct pipe_shader_state *state)
  506. {
  507.         return si_create_shader_state(ctx, state, PIPE_SHADER_FRAGMENT);
  508. }
  509.  
  510. static void *si_create_gs_state(struct pipe_context *ctx,
  511.                                 const struct pipe_shader_state *state)
  512. {
  513.         return si_create_shader_state(ctx, state, PIPE_SHADER_GEOMETRY);
  514. }
  515.  
  516. static void *si_create_vs_state(struct pipe_context *ctx,
  517.                                 const struct pipe_shader_state *state)
  518. {
  519.         return si_create_shader_state(ctx, state, PIPE_SHADER_VERTEX);
  520. }
  521.  
  522. static void si_bind_vs_shader(struct pipe_context *ctx, void *state)
  523. {
  524.         struct si_context *sctx = (struct si_context *)ctx;
  525.         struct si_shader_selector *sel = state;
  526.  
  527.         if (sctx->vs_shader == sel || !sel)
  528.                 return;
  529.  
  530.         sctx->vs_shader = sel;
  531.         sctx->clip_regs.dirty = true;
  532. }
  533.  
  534. static void si_bind_gs_shader(struct pipe_context *ctx, void *state)
  535. {
  536.         struct si_context *sctx = (struct si_context *)ctx;
  537.         struct si_shader_selector *sel = state;
  538.  
  539.         if (sctx->gs_shader == sel)
  540.                 return;
  541.  
  542.         sctx->gs_shader = sel;
  543.         sctx->clip_regs.dirty = true;
  544.         sctx->last_rast_prim = -1; /* reset this so that it gets updated */
  545. }
  546.  
  547. static void si_make_dummy_ps(struct si_context *sctx)
  548. {
  549.         if (!sctx->dummy_pixel_shader) {
  550.                 sctx->dummy_pixel_shader =
  551.                         util_make_fragment_cloneinput_shader(&sctx->b.b, 0,
  552.                                                              TGSI_SEMANTIC_GENERIC,
  553.                                                              TGSI_INTERPOLATE_CONSTANT);
  554.         }
  555. }
  556.  
  557. static void si_bind_ps_shader(struct pipe_context *ctx, void *state)
  558. {
  559.         struct si_context *sctx = (struct si_context *)ctx;
  560.         struct si_shader_selector *sel = state;
  561.  
  562.         /* skip if supplied shader is one already in use */
  563.         if (sctx->ps_shader == sel)
  564.                 return;
  565.  
  566.         /* use a dummy shader if binding a NULL shader */
  567.         if (!sel) {
  568.                 si_make_dummy_ps(sctx);
  569.                 sel = sctx->dummy_pixel_shader;
  570.         }
  571.  
  572.         sctx->ps_shader = sel;
  573. }
  574.  
  575. static void si_delete_shader_selector(struct pipe_context *ctx,
  576.                                       struct si_shader_selector *sel)
  577. {
  578.         struct si_context *sctx = (struct si_context *)ctx;
  579.         struct si_shader *p = sel->current, *c;
  580.  
  581.         while (p) {
  582.                 c = p->next_variant;
  583.                 if (sel->type == PIPE_SHADER_GEOMETRY) {
  584.                         si_pm4_delete_state(sctx, gs, p->pm4);
  585.                         si_pm4_delete_state(sctx, vs, p->gs_copy_shader->pm4);
  586.                 } else if (sel->type == PIPE_SHADER_FRAGMENT)
  587.                         si_pm4_delete_state(sctx, ps, p->pm4);
  588.                 else if (p->key.vs.as_es)
  589.                         si_pm4_delete_state(sctx, es, p->pm4);
  590.                 else
  591.                         si_pm4_delete_state(sctx, vs, p->pm4);
  592.                 si_shader_destroy(ctx, p);
  593.                 free(p);
  594.                 p = c;
  595.         }
  596.  
  597.         free(sel->tokens);
  598.         free(sel);
  599. }
  600.  
  601. static void si_delete_vs_shader(struct pipe_context *ctx, void *state)
  602. {
  603.         struct si_context *sctx = (struct si_context *)ctx;
  604.         struct si_shader_selector *sel = (struct si_shader_selector *)state;
  605.  
  606.         if (sctx->vs_shader == sel) {
  607.                 sctx->vs_shader = NULL;
  608.         }
  609.  
  610.         si_delete_shader_selector(ctx, sel);
  611. }
  612.  
  613. static void si_delete_gs_shader(struct pipe_context *ctx, void *state)
  614. {
  615.         struct si_context *sctx = (struct si_context *)ctx;
  616.         struct si_shader_selector *sel = (struct si_shader_selector *)state;
  617.  
  618.         if (sctx->gs_shader == sel) {
  619.                 sctx->gs_shader = NULL;
  620.         }
  621.  
  622.         si_delete_shader_selector(ctx, sel);
  623. }
  624.  
  625. static void si_delete_ps_shader(struct pipe_context *ctx, void *state)
  626. {
  627.         struct si_context *sctx = (struct si_context *)ctx;
  628.         struct si_shader_selector *sel = (struct si_shader_selector *)state;
  629.  
  630.         if (sctx->ps_shader == sel) {
  631.                 sctx->ps_shader = NULL;
  632.         }
  633.  
  634.         si_delete_shader_selector(ctx, sel);
  635. }
  636.  
  637. static void si_update_spi_map(struct si_context *sctx)
  638. {
  639.         struct si_shader *ps = sctx->ps_shader->current;
  640.         struct si_shader *vs = si_get_vs_state(sctx);
  641.         struct tgsi_shader_info *psinfo = &ps->selector->info;
  642.         struct tgsi_shader_info *vsinfo = &vs->selector->info;
  643.         struct si_pm4_state *pm4 = CALLOC_STRUCT(si_pm4_state);
  644.         unsigned i, j, tmp;
  645.  
  646.         for (i = 0; i < psinfo->num_inputs; i++) {
  647.                 unsigned name = psinfo->input_semantic_name[i];
  648.                 unsigned index = psinfo->input_semantic_index[i];
  649.                 unsigned interpolate = psinfo->input_interpolate[i];
  650.                 unsigned param_offset = ps->ps_input_param_offset[i];
  651.  
  652.                 if (name == TGSI_SEMANTIC_POSITION ||
  653.                     name == TGSI_SEMANTIC_FACE)
  654.                         /* Read from preloaded VGPRs, not parameters */
  655.                         continue;
  656.  
  657. bcolor:
  658.                 tmp = 0;
  659.  
  660.                 if (interpolate == TGSI_INTERPOLATE_CONSTANT ||
  661.                     (interpolate == TGSI_INTERPOLATE_COLOR && sctx->flatshade))
  662.                         tmp |= S_028644_FLAT_SHADE(1);
  663.  
  664.                 if (name == TGSI_SEMANTIC_GENERIC &&
  665.                     sctx->sprite_coord_enable & (1 << index)) {
  666.                         tmp |= S_028644_PT_SPRITE_TEX(1);
  667.                 }
  668.  
  669.                 for (j = 0; j < vsinfo->num_outputs; j++) {
  670.                         if (name == vsinfo->output_semantic_name[j] &&
  671.                             index == vsinfo->output_semantic_index[j]) {
  672.                                 tmp |= S_028644_OFFSET(vs->vs_output_param_offset[j]);
  673.                                 break;
  674.                         }
  675.                 }
  676.  
  677.                 if (j == vsinfo->num_outputs && !G_028644_PT_SPRITE_TEX(tmp)) {
  678.                         /* No corresponding output found, load defaults into input.
  679.                          * Don't set any other bits.
  680.                          * (FLAT_SHADE=1 completely changes behavior) */
  681.                         tmp = S_028644_OFFSET(0x20);
  682.                 }
  683.  
  684.                 si_pm4_set_reg(pm4,
  685.                                R_028644_SPI_PS_INPUT_CNTL_0 + param_offset * 4,
  686.                                tmp);
  687.  
  688.                 if (name == TGSI_SEMANTIC_COLOR &&
  689.                     ps->key.ps.color_two_side) {
  690.                         name = TGSI_SEMANTIC_BCOLOR;
  691.                         param_offset++;
  692.                         goto bcolor;
  693.                 }
  694.         }
  695.  
  696.         si_pm4_set_state(sctx, spi, pm4);
  697. }
  698.  
  699. /* Initialize state related to ESGS / GSVS ring buffers */
  700. static void si_init_gs_rings(struct si_context *sctx)
  701. {
  702.         unsigned esgs_ring_size = 128 * 1024;
  703.         unsigned gsvs_ring_size = 64 * 1024 * 1024;
  704.  
  705.         assert(!sctx->gs_rings);
  706.         sctx->gs_rings = CALLOC_STRUCT(si_pm4_state);
  707.  
  708.         sctx->esgs_ring = pipe_buffer_create(sctx->b.b.screen, PIPE_BIND_CUSTOM,
  709.                                        PIPE_USAGE_DEFAULT, esgs_ring_size);
  710.  
  711.         sctx->gsvs_ring = pipe_buffer_create(sctx->b.b.screen, PIPE_BIND_CUSTOM,
  712.                                              PIPE_USAGE_DEFAULT, gsvs_ring_size);
  713.  
  714.         if (sctx->b.chip_class >= CIK) {
  715.                 si_pm4_set_reg(sctx->gs_rings, R_030900_VGT_ESGS_RING_SIZE,
  716.                                esgs_ring_size / 256);
  717.                 si_pm4_set_reg(sctx->gs_rings, R_030904_VGT_GSVS_RING_SIZE,
  718.                                gsvs_ring_size / 256);
  719.         } else {
  720.                 si_pm4_set_reg(sctx->gs_rings, R_0088C8_VGT_ESGS_RING_SIZE,
  721.                                esgs_ring_size / 256);
  722.                 si_pm4_set_reg(sctx->gs_rings, R_0088CC_VGT_GSVS_RING_SIZE,
  723.                                gsvs_ring_size / 256);
  724.         }
  725.  
  726.         si_set_ring_buffer(&sctx->b.b, PIPE_SHADER_VERTEX, SI_RING_ESGS,
  727.                            sctx->esgs_ring, 0, esgs_ring_size,
  728.                            true, true, 4, 64);
  729.         si_set_ring_buffer(&sctx->b.b, PIPE_SHADER_GEOMETRY, SI_RING_ESGS,
  730.                            sctx->esgs_ring, 0, esgs_ring_size,
  731.                            false, false, 0, 0);
  732.         si_set_ring_buffer(&sctx->b.b, PIPE_SHADER_VERTEX, SI_RING_GSVS,
  733.                            sctx->gsvs_ring, 0, gsvs_ring_size,
  734.                            false, false, 0, 0);
  735. }
  736.  
  737. /**
  738.  * @returns 1 if \p sel has been updated to use a new scratch buffer and 0
  739.  *          otherwise.
  740.  */
  741. static unsigned si_update_scratch_buffer(struct si_context *sctx,
  742.                                     struct si_shader_selector *sel)
  743. {
  744.         struct si_shader *shader;
  745.         uint64_t scratch_va = sctx->scratch_buffer->gpu_address;
  746.         unsigned char *ptr;
  747.  
  748.         if (!sel)
  749.                 return 0;
  750.  
  751.         shader = sel->current;
  752.  
  753.         /* This shader doesn't need a scratch buffer */
  754.         if (shader->scratch_bytes_per_wave == 0)
  755.                 return 0;
  756.  
  757.         /* This shader is already configured to use the current
  758.          * scratch buffer. */
  759.         if (shader->scratch_bo == sctx->scratch_buffer)
  760.                 return 0;
  761.  
  762.         assert(sctx->scratch_buffer);
  763.  
  764.         si_shader_apply_scratch_relocs(sctx, shader, scratch_va);
  765.  
  766.         /* Replace the shader bo with a new bo that has the relocs applied. */
  767.         r600_resource_reference(&shader->bo, NULL);
  768.         shader->bo = si_resource_create_custom(&sctx->screen->b.b, PIPE_USAGE_IMMUTABLE,
  769.                                                shader->binary.code_size);
  770.         ptr = sctx->screen->b.ws->buffer_map(shader->bo->cs_buf, NULL, PIPE_TRANSFER_WRITE);
  771.         util_memcpy_cpu_to_le32(ptr, shader->binary.code, shader->binary.code_size);
  772.         sctx->screen->b.ws->buffer_unmap(shader->bo->cs_buf);
  773.  
  774.         /* Update the shader state to use the new shader bo. */
  775.         si_shader_init_pm4_state(shader);
  776.  
  777.         r600_resource_reference(&shader->scratch_bo, sctx->scratch_buffer);
  778.  
  779.         return 1;
  780. }
  781.  
  782. static unsigned si_get_current_scratch_buffer_size(struct si_context *sctx)
  783. {
  784.         if (!sctx->scratch_buffer)
  785.                 return 0;
  786.  
  787.         return sctx->scratch_buffer->b.b.width0;
  788. }
  789.  
  790. static unsigned si_get_scratch_buffer_bytes_per_wave(struct si_context *sctx,
  791.                                         struct si_shader_selector *sel)
  792. {
  793.         if (!sel)
  794.                 return 0;
  795.  
  796.         return sel->current->scratch_bytes_per_wave;
  797. }
  798.  
  799. static unsigned si_get_max_scratch_bytes_per_wave(struct si_context *sctx)
  800. {
  801.  
  802.         return MAX3(si_get_scratch_buffer_bytes_per_wave(sctx, sctx->ps_shader),
  803.                         si_get_scratch_buffer_bytes_per_wave(sctx, sctx->gs_shader),
  804.                         si_get_scratch_buffer_bytes_per_wave(sctx, sctx->vs_shader));
  805. }
  806.  
  807. static void si_update_spi_tmpring_size(struct si_context *sctx)
  808. {
  809.         unsigned current_scratch_buffer_size =
  810.                 si_get_current_scratch_buffer_size(sctx);
  811.         unsigned scratch_bytes_per_wave =
  812.                 si_get_max_scratch_bytes_per_wave(sctx);
  813.         unsigned scratch_needed_size = scratch_bytes_per_wave *
  814.                 sctx->scratch_waves;
  815.  
  816.         if (scratch_needed_size > 0) {
  817.  
  818.                 if (scratch_needed_size > current_scratch_buffer_size) {
  819.                         /* Create a bigger scratch buffer */
  820.                         pipe_resource_reference(
  821.                                         (struct pipe_resource**)&sctx->scratch_buffer,
  822.                                         NULL);
  823.  
  824.                         sctx->scratch_buffer =
  825.                                         si_resource_create_custom(&sctx->screen->b.b,
  826.                                         PIPE_USAGE_DEFAULT, scratch_needed_size);
  827.                 }
  828.  
  829.                 /* Update the shaders, so they are using the latest scratch.  The
  830.                  * scratch buffer may have been changed since these shaders were
  831.                  * last used, so we still need to try to update them, even if
  832.                  * they require scratch buffers smaller than the current size.
  833.                  */
  834.                 if (si_update_scratch_buffer(sctx, sctx->ps_shader))
  835.                         si_pm4_bind_state(sctx, ps, sctx->ps_shader->current->pm4);
  836.                 if (si_update_scratch_buffer(sctx, sctx->gs_shader))
  837.                         si_pm4_bind_state(sctx, gs, sctx->gs_shader->current->pm4);
  838.  
  839.                 /* VS can be bound as ES or VS. */
  840.                 if (sctx->gs_shader) {
  841.                         if (si_update_scratch_buffer(sctx, sctx->vs_shader))
  842.                                 si_pm4_bind_state(sctx, es, sctx->vs_shader->current->pm4);
  843.                 } else {
  844.                         if (si_update_scratch_buffer(sctx, sctx->vs_shader))
  845.                                 si_pm4_bind_state(sctx, vs, sctx->vs_shader->current->pm4);
  846.                 }
  847.         }
  848.  
  849.         /* The LLVM shader backend should be reporting aligned scratch_sizes. */
  850.         assert((scratch_needed_size & ~0x3FF) == scratch_needed_size &&
  851.                 "scratch size should already be aligned correctly.");
  852.  
  853.         sctx->spi_tmpring_size = S_0286E8_WAVES(sctx->scratch_waves) |
  854.                                 S_0286E8_WAVESIZE(scratch_bytes_per_wave >> 10);
  855. }
  856.  
  857. void si_update_shaders(struct si_context *sctx)
  858. {
  859.         struct pipe_context *ctx = (struct pipe_context*)sctx;
  860.         struct si_state_rasterizer *rs = sctx->queued.named.rasterizer;
  861.  
  862.         if (sctx->gs_shader) {
  863.                 si_shader_select(ctx, sctx->gs_shader);
  864.                 si_pm4_bind_state(sctx, gs, sctx->gs_shader->current->pm4);
  865.                 si_pm4_bind_state(sctx, vs, sctx->gs_shader->current->gs_copy_shader->pm4);
  866.  
  867.                 sctx->b.streamout.stride_in_dw = sctx->gs_shader->so.stride;
  868.  
  869.                 si_shader_select(ctx, sctx->vs_shader);
  870.                 si_pm4_bind_state(sctx, es, sctx->vs_shader->current->pm4);
  871.  
  872.                 if (!sctx->gs_rings)
  873.                         si_init_gs_rings(sctx);
  874.                 if (sctx->emitted.named.gs_rings != sctx->gs_rings)
  875.                         sctx->b.flags |= SI_CONTEXT_VGT_FLUSH;
  876.                 si_pm4_bind_state(sctx, gs_rings, sctx->gs_rings);
  877.  
  878.                 si_set_ring_buffer(ctx, PIPE_SHADER_GEOMETRY, SI_RING_GSVS,
  879.                                    sctx->gsvs_ring,
  880.                                    sctx->gs_shader->gs_max_out_vertices *
  881.                                    sctx->gs_shader->info.num_outputs * 16,
  882.                                    64, true, true, 4, 16);
  883.  
  884.                 if (!sctx->gs_on) {
  885.                         sctx->gs_on = CALLOC_STRUCT(si_pm4_state);
  886.  
  887.                         si_pm4_set_reg(sctx->gs_on, R_028B54_VGT_SHADER_STAGES_EN,
  888.                                        S_028B54_ES_EN(V_028B54_ES_STAGE_REAL) |
  889.                                        S_028B54_GS_EN(1) |
  890.                                        S_028B54_VS_EN(V_028B54_VS_STAGE_COPY_SHADER));
  891.                 }
  892.                 si_pm4_bind_state(sctx, gs_onoff, sctx->gs_on);
  893.         } else {
  894.                 si_shader_select(ctx, sctx->vs_shader);
  895.                 si_pm4_bind_state(sctx, vs, sctx->vs_shader->current->pm4);
  896.  
  897.                 sctx->b.streamout.stride_in_dw = sctx->vs_shader->so.stride;
  898.  
  899.                 if (!sctx->gs_off) {
  900.                         sctx->gs_off = CALLOC_STRUCT(si_pm4_state);
  901.  
  902.                         si_pm4_set_reg(sctx->gs_off, R_028A40_VGT_GS_MODE, 0);
  903.                         si_pm4_set_reg(sctx->gs_off, R_028B54_VGT_SHADER_STAGES_EN, 0);
  904.                 }
  905.                 si_pm4_bind_state(sctx, gs_onoff, sctx->gs_off);
  906.                 si_pm4_bind_state(sctx, gs_rings, NULL);
  907.                 si_pm4_bind_state(sctx, gs, NULL);
  908.                 si_pm4_bind_state(sctx, es, NULL);
  909.         }
  910.  
  911.         si_shader_select(ctx, sctx->ps_shader);
  912.  
  913.         if (!sctx->ps_shader->current) {
  914.                 struct si_shader_selector *sel;
  915.  
  916.                 /* use a dummy shader if compiling the shader (variant) failed */
  917.                 si_make_dummy_ps(sctx);
  918.                 sel = sctx->dummy_pixel_shader;
  919.                 si_shader_select(ctx, sel);
  920.                 sctx->ps_shader->current = sel->current;
  921.         }
  922.  
  923.         si_pm4_bind_state(sctx, ps, sctx->ps_shader->current->pm4);
  924.  
  925.         if (si_pm4_state_changed(sctx, ps) || si_pm4_state_changed(sctx, vs) ||
  926.             sctx->sprite_coord_enable != rs->sprite_coord_enable ||
  927.             sctx->flatshade != rs->flatshade) {
  928.                 sctx->sprite_coord_enable = rs->sprite_coord_enable;
  929.                 sctx->flatshade = rs->flatshade;
  930.                 si_update_spi_map(sctx);
  931.         }
  932.  
  933.         if (si_pm4_state_changed(sctx, ps) || si_pm4_state_changed(sctx, vs) ||
  934.             si_pm4_state_changed(sctx, gs)) {
  935.                 si_update_spi_tmpring_size(sctx);
  936.         }
  937.  
  938.         if (sctx->ps_db_shader_control != sctx->ps_shader->current->db_shader_control) {
  939.                 sctx->ps_db_shader_control = sctx->ps_shader->current->db_shader_control;
  940.                 sctx->db_render_state.dirty = true;
  941.         }
  942.  
  943.         if (sctx->smoothing_enabled != sctx->ps_shader->current->key.ps.poly_line_smoothing) {
  944.                 sctx->smoothing_enabled = sctx->ps_shader->current->key.ps.poly_line_smoothing;
  945.                 sctx->msaa_config.dirty = true;
  946.  
  947.                 if (sctx->b.chip_class == SI)
  948.                         sctx->db_render_state.dirty = true;
  949.         }
  950. }
  951.  
  952. void si_init_shader_functions(struct si_context *sctx)
  953. {
  954.         sctx->b.b.create_vs_state = si_create_vs_state;
  955.         sctx->b.b.create_gs_state = si_create_gs_state;
  956.         sctx->b.b.create_fs_state = si_create_fs_state;
  957.  
  958.         sctx->b.b.bind_vs_state = si_bind_vs_shader;
  959.         sctx->b.b.bind_gs_state = si_bind_gs_shader;
  960.         sctx->b.b.bind_fs_state = si_bind_ps_shader;
  961.  
  962.         sctx->b.b.delete_vs_state = si_delete_vs_shader;
  963.         sctx->b.b.delete_gs_state = si_delete_gs_shader;
  964.         sctx->b.b.delete_fs_state = si_delete_ps_shader;
  965. }
  966.