Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2010 Jerome Glisse <glisse@freedesktop.org> |
| 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 | */ |
Marek Olšák | 7209703 | 2014-01-22 18:50:36 +0100 | [diff] [blame] | 23 | |
Andreas Hartmetz | 786af2f | 2014-01-04 18:44:33 +0100 | [diff] [blame] | 24 | #include "si_pipe.h" |
Marek Olšák | 7209703 | 2014-01-22 18:50:36 +0100 | [diff] [blame] | 25 | #include "si_public.h" |
Marek Olšák | 5ab25bb | 2016-10-17 12:30:42 +0200 | [diff] [blame] | 26 | #include "si_shader_internal.h" |
Marek Olšák | 955505f | 2014-08-07 21:14:31 +0200 | [diff] [blame] | 27 | #include "sid.h" |
Marek Olšák | 7209703 | 2014-01-22 18:50:36 +0100 | [diff] [blame] | 28 | |
Christian König | 5b2855b | 2013-04-03 10:18:35 +0200 | [diff] [blame] | 29 | #include "radeon/radeon_uvd.h" |
Samuel Pitoiset | 9cc328e | 2017-05-16 10:49:20 +0200 | [diff] [blame] | 30 | #include "util/hash_table.h" |
Marek Olšák | 7209703 | 2014-01-22 18:50:36 +0100 | [diff] [blame] | 31 | #include "util/u_memory.h" |
Bas Nieuwenhuizen | aabc7d6 | 2016-03-10 21:23:49 +0100 | [diff] [blame] | 32 | #include "util/u_suballoc.h" |
Marek Olšák | 322eb13 | 2017-03-27 16:53:19 +0200 | [diff] [blame] | 33 | #include "util/u_tests.h" |
Nicolai Hähnle | 53485c2 | 2017-06-28 17:37:53 +0200 | [diff] [blame] | 34 | #include "util/xmlconfig.h" |
Marek Olšák | 7209703 | 2014-01-22 18:50:36 +0100 | [diff] [blame] | 35 | #include "vl/vl_decoder.h" |
Marek Olšák | 28a03be | 2016-06-30 01:15:19 +0200 | [diff] [blame] | 36 | #include "../ddebug/dd_util.h" |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 37 | |
Nicolai Hähnle | acd0938 | 2017-05-16 02:04:48 +0200 | [diff] [blame] | 38 | #include "compiler/nir/nir.h" |
| 39 | |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 40 | /* |
| 41 | * pipe_context |
| 42 | */ |
Andreas Hartmetz | eb0ddb6 | 2014-01-07 03:07:55 +0100 | [diff] [blame] | 43 | static void si_destroy_context(struct pipe_context *context) |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 44 | { |
Andreas Hartmetz | 8662e66 | 2014-01-11 16:00:50 +0100 | [diff] [blame] | 45 | struct si_context *sctx = (struct si_context *)context; |
Marek Olšák | 59b3556 | 2014-09-19 00:16:12 +0200 | [diff] [blame] | 46 | int i; |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 47 | |
Marek Olšák | ebb9c7d | 2016-06-21 15:52:03 +0200 | [diff] [blame] | 48 | /* Unreference the framebuffer normally to disable related logic |
| 49 | * properly. |
| 50 | */ |
| 51 | struct pipe_framebuffer_state fb = {}; |
Marek Olšák | 24306c0 | 2017-05-24 18:17:38 +0200 | [diff] [blame] | 52 | if (context->set_framebuffer_state) |
| 53 | context->set_framebuffer_state(context, &fb); |
Bas Nieuwenhuizen | cbe3421 | 2016-05-31 13:44:03 +0200 | [diff] [blame] | 54 | |
Andreas Hartmetz | 8662e66 | 2014-01-11 16:00:50 +0100 | [diff] [blame] | 55 | si_release_all_descriptors(sctx); |
Marek Olšák | c8e70e6 | 2013-08-06 06:42:22 +0200 | [diff] [blame] | 56 | |
Bas Nieuwenhuizen | aabc7d6 | 2016-03-10 21:23:49 +0100 | [diff] [blame] | 57 | if (sctx->ce_suballocator) |
| 58 | u_suballocator_destroy(sctx->ce_suballocator); |
| 59 | |
Marek Olšák | edb59ef | 2017-05-15 23:45:57 +0200 | [diff] [blame] | 60 | r600_resource_reference(&sctx->ce_ram_saved_buffer, NULL); |
Marek Olšák | 711623f | 2014-09-18 21:40:02 +0200 | [diff] [blame] | 61 | pipe_resource_reference(&sctx->esgs_ring, NULL); |
| 62 | pipe_resource_reference(&sctx->gsvs_ring, NULL); |
Marek Olšák | b6f4fdf | 2015-02-22 17:25:37 +0100 | [diff] [blame] | 63 | pipe_resource_reference(&sctx->tf_ring, NULL); |
Bas Nieuwenhuizen | d27ff7d | 2016-05-02 09:54:11 +0200 | [diff] [blame] | 64 | pipe_resource_reference(&sctx->tess_offchip_ring, NULL); |
Andreas Hartmetz | 8662e66 | 2014-01-11 16:00:50 +0100 | [diff] [blame] | 65 | pipe_resource_reference(&sctx->null_const_buf.buffer, NULL); |
Marek Olšák | a9971e8 | 2015-08-30 14:13:10 +0200 | [diff] [blame] | 66 | r600_resource_reference(&sctx->border_color_buffer, NULL); |
| 67 | free(sctx->border_color_table); |
Tom Stellard | 2397a72 | 2014-12-10 09:13:59 -0500 | [diff] [blame] | 68 | r600_resource_reference(&sctx->scratch_buffer, NULL); |
Bas Nieuwenhuizen | ba1f66a | 2016-04-02 13:04:18 +0200 | [diff] [blame] | 69 | r600_resource_reference(&sctx->compute_scratch_buffer, NULL); |
Marek Olšák | 79bd1d4 | 2017-06-07 00:16:46 +0200 | [diff] [blame] | 70 | r600_resource_reference(&sctx->wait_mem_scratch, NULL); |
Michel Dänzer | 9ccaa24 | 2012-09-07 16:09:08 +0200 | [diff] [blame] | 71 | |
Marek Olšák | 638fa80 | 2014-12-31 00:42:22 +0100 | [diff] [blame] | 72 | si_pm4_free_state(sctx, sctx->init_config, ~0); |
Marek Olšák | b1c5f3f | 2015-11-08 13:34:44 +0100 | [diff] [blame] | 73 | if (sctx->init_config_gs_rings) |
| 74 | si_pm4_free_state(sctx, sctx->init_config_gs_rings, ~0); |
Jan Vesely | 47b390f | 2016-05-17 09:25:44 -0400 | [diff] [blame] | 75 | for (i = 0; i < ARRAY_SIZE(sctx->vgt_shader_config); i++) |
Marek Olšák | 59b3556 | 2014-09-19 00:16:12 +0200 | [diff] [blame] | 76 | si_pm4_delete_state(sctx, vgt_shader_config, sctx->vgt_shader_config[i]); |
Michel Dänzer | 404b29d | 2013-11-21 16:45:28 +0900 | [diff] [blame] | 77 | |
Marek Olšák | 9b54ce3 | 2015-10-07 01:48:18 +0200 | [diff] [blame] | 78 | if (sctx->fixed_func_tcs_shader.cso) |
| 79 | sctx->b.b.delete_tcs_state(&sctx->b.b, sctx->fixed_func_tcs_shader.cso); |
Marek Olšák | 6d6208a | 2015-05-06 19:34:09 +0200 | [diff] [blame] | 80 | if (sctx->custom_dsa_flush) |
| 81 | sctx->b.b.delete_depth_stencil_alpha_state(&sctx->b.b, sctx->custom_dsa_flush); |
| 82 | if (sctx->custom_blend_resolve) |
| 83 | sctx->b.b.delete_blend_state(&sctx->b.b, sctx->custom_blend_resolve); |
Marek Olšák | 7d67cbe | 2017-06-06 16:28:59 +0200 | [diff] [blame] | 84 | if (sctx->custom_blend_fmask_decompress) |
| 85 | sctx->b.b.delete_blend_state(&sctx->b.b, sctx->custom_blend_fmask_decompress); |
| 86 | if (sctx->custom_blend_eliminate_fastclear) |
| 87 | sctx->b.b.delete_blend_state(&sctx->b.b, sctx->custom_blend_eliminate_fastclear); |
Bas Nieuwenhuizen | 1e48ec7 | 2015-10-21 00:10:41 +0200 | [diff] [blame] | 88 | if (sctx->custom_blend_dcc_decompress) |
| 89 | sctx->b.b.delete_blend_state(&sctx->b.b, sctx->custom_blend_dcc_decompress); |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 90 | |
Marek Olšák | 6d6208a | 2015-05-06 19:34:09 +0200 | [diff] [blame] | 91 | if (sctx->blitter) |
| 92 | util_blitter_destroy(sctx->blitter); |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 93 | |
Andreas Hartmetz | 8662e66 | 2014-01-11 16:00:50 +0100 | [diff] [blame] | 94 | r600_common_context_cleanup(&sctx->b); |
Michel Dänzer | d64adc3 | 2015-03-26 11:32:59 +0900 | [diff] [blame] | 95 | |
Michel Dänzer | d64adc3 | 2015-03-26 11:32:59 +0900 | [diff] [blame] | 96 | LLVMDisposeTargetMachine(sctx->tm); |
Michel Dänzer | d64adc3 | 2015-03-26 11:32:59 +0900 | [diff] [blame] | 97 | |
Marek Olšák | 2c14a6d | 2015-08-19 11:53:25 +0200 | [diff] [blame] | 98 | r600_resource_reference(&sctx->trace_buf, NULL); |
| 99 | r600_resource_reference(&sctx->last_trace_buf, NULL); |
Nicolai Hähnle | ad84384 | 2016-06-20 16:30:29 +0200 | [diff] [blame] | 100 | radeon_clear_saved_cs(&sctx->last_gfx); |
| 101 | |
Samuel Pitoiset | 77bbdcd | 2017-05-16 10:11:54 +0200 | [diff] [blame] | 102 | pb_slabs_deinit(&sctx->bindless_descriptor_slabs); |
| 103 | util_dynarray_fini(&sctx->bindless_descriptors); |
| 104 | |
Samuel Pitoiset | 9cc328e | 2017-05-16 10:49:20 +0200 | [diff] [blame] | 105 | _mesa_hash_table_destroy(sctx->tex_handles, NULL); |
| 106 | _mesa_hash_table_destroy(sctx->img_handles, NULL); |
| 107 | |
| 108 | util_dynarray_fini(&sctx->resident_tex_handles); |
| 109 | util_dynarray_fini(&sctx->resident_img_handles); |
Samuel Pitoiset | 6ff6863 | 2017-06-14 13:55:12 +0200 | [diff] [blame] | 110 | util_dynarray_fini(&sctx->resident_tex_needs_color_decompress); |
| 111 | util_dynarray_fini(&sctx->resident_img_needs_color_decompress); |
Samuel Pitoiset | 06ed251 | 2017-06-14 13:55:11 +0200 | [diff] [blame] | 112 | util_dynarray_fini(&sctx->resident_tex_needs_depth_decompress); |
Andreas Hartmetz | 8662e66 | 2014-01-11 16:00:50 +0100 | [diff] [blame] | 113 | FREE(sctx); |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 114 | } |
| 115 | |
Marek Olšák | bf2c342 | 2015-04-30 17:02:38 +0200 | [diff] [blame] | 116 | static enum pipe_reset_status |
| 117 | si_amdgpu_get_reset_status(struct pipe_context *ctx) |
| 118 | { |
| 119 | struct si_context *sctx = (struct si_context *)ctx; |
| 120 | |
| 121 | return sctx->b.ws->ctx_query_reset_status(sctx->b.ctx); |
| 122 | } |
| 123 | |
Marek Olšák | 28a03be | 2016-06-30 01:15:19 +0200 | [diff] [blame] | 124 | /* Apitrace profiling: |
| 125 | * 1) qapitrace : Tools -> Profile: Measure CPU & GPU times |
| 126 | * 2) In the middle panel, zoom in (mouse wheel) on some bad draw call |
| 127 | * and remember its number. |
| 128 | * 3) In Mesa, enable queries and performance counters around that draw |
| 129 | * call and print the results. |
| 130 | * 4) glretrace --benchmark --markers .. |
| 131 | */ |
| 132 | static void si_emit_string_marker(struct pipe_context *ctx, |
| 133 | const char *string, int len) |
| 134 | { |
| 135 | struct si_context *sctx = (struct si_context *)ctx; |
| 136 | |
| 137 | dd_parse_apitrace_marker(string, len, &sctx->apitrace_call_number); |
| 138 | } |
| 139 | |
Marek Olšák | 6781a2a | 2016-06-11 18:53:15 +0200 | [diff] [blame] | 140 | static LLVMTargetMachineRef |
| 141 | si_create_llvm_target_machine(struct si_screen *sscreen) |
| 142 | { |
| 143 | const char *triple = "amdgcn--"; |
Marek Olšák | 2beb31b | 2017-04-07 18:30:28 +0200 | [diff] [blame] | 144 | char features[256]; |
| 145 | |
| 146 | snprintf(features, sizeof(features), |
Marek Olšák | facfab2 | 2017-07-05 23:33:13 +0200 | [diff] [blame] | 147 | "+DumpCode,+vgpr-spilling,-fp32-denormals,+fp64-denormals%s%s%s", |
Marek Olšák | 2beb31b | 2017-04-07 18:30:28 +0200 | [diff] [blame] | 148 | sscreen->b.chip_class >= GFX9 ? ",+xnack" : ",-xnack", |
Marek Olšák | facfab2 | 2017-07-05 23:33:13 +0200 | [diff] [blame] | 149 | sscreen->llvm_has_working_vgpr_indexing ? "" : ",-promote-alloca", |
Marek Olšák | 2beb31b | 2017-04-07 18:30:28 +0200 | [diff] [blame] | 150 | sscreen->b.debug_flags & DBG_SI_SCHED ? ",+si-scheduler" : ""); |
Marek Olšák | 6781a2a | 2016-06-11 18:53:15 +0200 | [diff] [blame] | 151 | |
Marek Olšák | 4560f2b | 2017-07-04 22:38:37 +0200 | [diff] [blame] | 152 | return LLVMCreateTargetMachine(ac_get_llvm_target(triple), triple, |
Marek Olšák | 6781a2a | 2016-06-11 18:53:15 +0200 | [diff] [blame] | 153 | r600_get_llvm_processor_name(sscreen->b.family), |
Marek Olšák | 2beb31b | 2017-04-07 18:30:28 +0200 | [diff] [blame] | 154 | features, |
Marek Olšák | 6781a2a | 2016-06-11 18:53:15 +0200 | [diff] [blame] | 155 | LLVMCodeGenLevelDefault, |
| 156 | LLVMRelocDefault, |
| 157 | LLVMCodeModelDefault); |
| 158 | } |
| 159 | |
Marek Olšák | 0fc21ec | 2015-07-25 18:40:59 +0200 | [diff] [blame] | 160 | static struct pipe_context *si_create_context(struct pipe_screen *screen, |
Marek Olšák | 1c8f7d3 | 2017-03-02 01:28:51 +0100 | [diff] [blame] | 161 | unsigned flags) |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 162 | { |
Andreas Hartmetz | 8662e66 | 2014-01-11 16:00:50 +0100 | [diff] [blame] | 163 | struct si_context *sctx = CALLOC_STRUCT(si_context); |
Andreas Hartmetz | aa7ae4f | 2014-01-11 16:01:11 +0100 | [diff] [blame] | 164 | struct si_screen* sscreen = (struct si_screen *)screen; |
Marek Olšák | dd72c32 | 2014-04-11 22:14:27 +0200 | [diff] [blame] | 165 | struct radeon_winsys *ws = sscreen->b.ws; |
Marek Olšák | 4569bf9 | 2013-10-30 20:44:23 +0100 | [diff] [blame] | 166 | int shader, i; |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 167 | |
Edward O'Callaghan | 13eb5f5 | 2015-12-04 22:08:22 +1100 | [diff] [blame] | 168 | if (!sctx) |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 169 | return NULL; |
| 170 | |
Marek Olšák | 027ad71 | 2016-07-01 00:10:15 +0200 | [diff] [blame] | 171 | if (flags & PIPE_CONTEXT_DEBUG) |
| 172 | sscreen->record_llvm_ir = true; /* racy but not critical */ |
| 173 | |
Marek Olšák | 4e5c70e | 2014-01-21 18:01:01 +0100 | [diff] [blame] | 174 | sctx->b.b.screen = screen; /* this must be set first */ |
Marek Olšák | 8b54859 | 2017-02-26 18:48:28 +0100 | [diff] [blame] | 175 | sctx->b.b.priv = NULL; |
Andreas Hartmetz | 8662e66 | 2014-01-11 16:00:50 +0100 | [diff] [blame] | 176 | sctx->b.b.destroy = si_destroy_context; |
Marek Olšák | 28a03be | 2016-06-30 01:15:19 +0200 | [diff] [blame] | 177 | sctx->b.b.emit_string_marker = si_emit_string_marker; |
Grazvydas Ignotas | 3206d4e | 2015-08-10 00:42:32 +0300 | [diff] [blame] | 178 | sctx->b.set_atom_dirty = (void *)si_set_atom_dirty; |
Marek Olšák | 4e5c70e | 2014-01-21 18:01:01 +0100 | [diff] [blame] | 179 | sctx->screen = sscreen; /* Easy accessing of screen/winsys. */ |
Marek Olšák | be6dc87 | 2015-08-15 12:46:17 +0200 | [diff] [blame] | 180 | sctx->is_debug = (flags & PIPE_CONTEXT_DEBUG) != 0; |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 181 | |
Marek Olšák | 700de07 | 2016-07-16 21:52:20 +0200 | [diff] [blame] | 182 | if (!r600_common_context_init(&sctx->b, &sscreen->b, flags)) |
Marek Olšák | 4e5c70e | 2014-01-21 18:01:01 +0100 | [diff] [blame] | 183 | goto fail; |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 184 | |
Marek Olšák | bf2c342 | 2015-04-30 17:02:38 +0200 | [diff] [blame] | 185 | if (sscreen->b.info.drm_major == 3) |
| 186 | sctx->b.b.get_device_reset_status = si_amdgpu_get_reset_status; |
| 187 | |
Andreas Hartmetz | 8662e66 | 2014-01-11 16:00:50 +0100 | [diff] [blame] | 188 | si_init_blit_functions(sctx); |
Andreas Hartmetz | 8662e66 | 2014-01-11 16:00:50 +0100 | [diff] [blame] | 189 | si_init_compute_functions(sctx); |
Marek Olšák | 2d3ae15 | 2015-07-25 01:25:07 +0200 | [diff] [blame] | 190 | si_init_cp_dma_functions(sctx); |
Marek Olšák | 110873e | 2015-08-15 23:56:22 +0200 | [diff] [blame] | 191 | si_init_debug_functions(sctx); |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 192 | |
Leo Liu | c23ffaf | 2017-04-17 12:14:00 -0400 | [diff] [blame] | 193 | if (sscreen->b.info.has_hw_decode) { |
Andreas Hartmetz | 8662e66 | 2014-01-11 16:00:50 +0100 | [diff] [blame] | 194 | sctx->b.b.create_video_codec = si_uvd_create_decoder; |
| 195 | sctx->b.b.create_video_buffer = si_video_buffer_create; |
Christian König | 5b2855b | 2013-04-03 10:18:35 +0200 | [diff] [blame] | 196 | } else { |
Andreas Hartmetz | 8662e66 | 2014-01-11 16:00:50 +0100 | [diff] [blame] | 197 | sctx->b.b.create_video_codec = vl_create_decoder; |
| 198 | sctx->b.b.create_video_buffer = vl_video_buffer_create; |
Christian König | 5b2855b | 2013-04-03 10:18:35 +0200 | [diff] [blame] | 199 | } |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 200 | |
Marek Olšák | 8140154 | 2016-03-11 15:24:05 +0100 | [diff] [blame] | 201 | sctx->b.gfx.cs = ws->cs_create(sctx->b.ctx, RING_GFX, |
| 202 | si_context_gfx_flush, sctx); |
Bas Nieuwenhuizen | 8fee75d | 2016-04-13 22:31:17 +0200 | [diff] [blame] | 203 | |
Marek Olšák | 49c798e | 2016-08-19 01:37:34 +0200 | [diff] [blame] | 204 | /* SI + AMDGPU + CE = GPU hang */ |
| 205 | if (!(sscreen->b.debug_flags & DBG_NO_CE) && ws->cs_add_const_ib && |
Marek Olšák | 31f988a | 2016-12-07 23:01:56 +0100 | [diff] [blame] | 206 | sscreen->b.chip_class != SI && |
| 207 | /* These can't use CE due to a power gating bug in the kernel. */ |
| 208 | sscreen->b.family != CHIP_CARRIZO && |
Marek Olšák | c66fc61 | 2017-05-13 00:40:34 +0200 | [diff] [blame] | 209 | sscreen->b.family != CHIP_STONEY) { |
Bas Nieuwenhuizen | 8fee75d | 2016-04-13 22:31:17 +0200 | [diff] [blame] | 210 | sctx->ce_ib = ws->cs_add_const_ib(sctx->b.gfx.cs); |
| 211 | if (!sctx->ce_ib) |
| 212 | goto fail; |
| 213 | |
| 214 | if (ws->cs_add_const_preamble_ib) { |
| 215 | sctx->ce_preamble_ib = |
| 216 | ws->cs_add_const_preamble_ib(sctx->b.gfx.cs); |
| 217 | |
| 218 | if (!sctx->ce_preamble_ib) |
| 219 | goto fail; |
| 220 | } |
Bas Nieuwenhuizen | aabc7d6 | 2016-03-10 21:23:49 +0100 | [diff] [blame] | 221 | |
| 222 | sctx->ce_suballocator = |
Marek Olšák | 45240ce | 2017-02-15 20:44:24 +0100 | [diff] [blame] | 223 | u_suballocator_create(&sctx->b.b, 1024 * 1024, 0, |
| 224 | PIPE_USAGE_DEFAULT, |
| 225 | R600_RESOURCE_FLAG_UNMAPPABLE, false); |
Bas Nieuwenhuizen | aabc7d6 | 2016-03-10 21:23:49 +0100 | [diff] [blame] | 226 | if (!sctx->ce_suballocator) |
| 227 | goto fail; |
Bas Nieuwenhuizen | 8fee75d | 2016-04-13 22:31:17 +0200 | [diff] [blame] | 228 | } |
| 229 | |
Marek Olšák | 6cc8f6c | 2015-11-07 14:00:30 +0100 | [diff] [blame] | 230 | sctx->b.gfx.flush = si_context_gfx_flush; |
Marek Olšák | c8e70e6 | 2013-08-06 06:42:22 +0200 | [diff] [blame] | 231 | |
Marek Olšák | a9971e8 | 2015-08-30 14:13:10 +0200 | [diff] [blame] | 232 | /* Border colors. */ |
| 233 | sctx->border_color_table = malloc(SI_MAX_BORDER_COLORS * |
| 234 | sizeof(*sctx->border_color_table)); |
| 235 | if (!sctx->border_color_table) |
| 236 | goto fail; |
| 237 | |
| 238 | sctx->border_color_buffer = (struct r600_resource*) |
Marek Olšák | 29144d0 | 2016-10-24 23:26:39 +0200 | [diff] [blame] | 239 | pipe_buffer_create(screen, 0, PIPE_USAGE_DEFAULT, |
Marek Olšák | a9971e8 | 2015-08-30 14:13:10 +0200 | [diff] [blame] | 240 | SI_MAX_BORDER_COLORS * |
| 241 | sizeof(*sctx->border_color_table)); |
| 242 | if (!sctx->border_color_buffer) |
| 243 | goto fail; |
| 244 | |
| 245 | sctx->border_color_map = |
Marek Olšák | cf811fa | 2015-12-07 00:00:59 +0100 | [diff] [blame] | 246 | ws->buffer_map(sctx->border_color_buffer->buf, |
Marek Olšák | a9971e8 | 2015-08-30 14:13:10 +0200 | [diff] [blame] | 247 | NULL, PIPE_TRANSFER_WRITE); |
| 248 | if (!sctx->border_color_map) |
| 249 | goto fail; |
| 250 | |
Andreas Hartmetz | 8662e66 | 2014-01-11 16:00:50 +0100 | [diff] [blame] | 251 | si_init_all_descriptors(sctx); |
Marek Olšák | 0aa2446 | 2015-07-16 14:42:38 +0200 | [diff] [blame] | 252 | si_init_state_functions(sctx); |
| 253 | si_init_shader_functions(sctx); |
Marek Olšák | 5f99c49 | 2017-01-25 02:47:15 +0100 | [diff] [blame] | 254 | si_init_ia_multi_vgt_param_table(sctx); |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 255 | |
Marek Olšák | 498a40c | 2016-04-22 22:03:24 +0200 | [diff] [blame] | 256 | if (sctx->b.chip_class >= CIK) |
| 257 | cik_init_sdma_functions(sctx); |
| 258 | else |
| 259 | si_init_dma_functions(sctx); |
| 260 | |
Marek Olšák | d13d2fd | 2014-09-06 17:07:50 +0200 | [diff] [blame] | 261 | if (sscreen->b.debug_flags & DBG_FORCE_DMA) |
| 262 | sctx->b.b.resource_copy_region = sctx->b.dma_copy; |
| 263 | |
Andreas Hartmetz | 8662e66 | 2014-01-11 16:00:50 +0100 | [diff] [blame] | 264 | sctx->blitter = util_blitter_create(&sctx->b.b); |
| 265 | if (sctx->blitter == NULL) |
Marek Olšák | a81c3e0 | 2013-08-14 01:04:39 +0200 | [diff] [blame] | 266 | goto fail; |
Marek Olšák | db51ab6 | 2014-08-18 00:55:40 +0200 | [diff] [blame] | 267 | sctx->blitter->draw_rectangle = r600_draw_rectangle; |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 268 | |
Marek Olšák | 74aa648 | 2015-08-29 15:05:53 +0200 | [diff] [blame] | 269 | sctx->sample_mask.sample_mask = 0xffff; |
| 270 | |
Marek Olšák | 9eb3b9d | 2013-08-31 00:13:43 +0200 | [diff] [blame] | 271 | /* these must be last */ |
Andreas Hartmetz | 8662e66 | 2014-01-11 16:00:50 +0100 | [diff] [blame] | 272 | si_begin_new_cs(sctx); |
Marek Olšák | 4569bf9 | 2013-10-30 20:44:23 +0100 | [diff] [blame] | 273 | |
Marek Olšák | 79bd1d4 | 2017-06-07 00:16:46 +0200 | [diff] [blame] | 274 | if (sctx->b.chip_class >= GFX9) { |
| 275 | sctx->wait_mem_scratch = (struct r600_resource*) |
| 276 | pipe_buffer_create(screen, 0, PIPE_USAGE_DEFAULT, 4); |
| 277 | if (!sctx->wait_mem_scratch) |
| 278 | goto fail; |
| 279 | |
| 280 | /* Initialize the memory. */ |
| 281 | struct radeon_winsys_cs *cs = sctx->b.gfx.cs; |
| 282 | radeon_emit(cs, PKT3(PKT3_WRITE_DATA, 3, 0)); |
| 283 | radeon_emit(cs, S_370_DST_SEL(V_370_MEMORY_SYNC) | |
| 284 | S_370_WR_CONFIRM(1) | |
| 285 | S_370_ENGINE_SEL(V_370_ME)); |
| 286 | radeon_emit(cs, sctx->wait_mem_scratch->gpu_address); |
| 287 | radeon_emit(cs, sctx->wait_mem_scratch->gpu_address >> 32); |
| 288 | radeon_emit(cs, sctx->wait_mem_number); |
| 289 | } |
| 290 | |
Marek Olšák | 2c13abb | 2016-08-18 15:25:51 +0200 | [diff] [blame] | 291 | /* CIK cannot unbind a constant buffer (S_BUFFER_LOAD doesn't skip loads |
| 292 | * if NUM_RECORDS == 0). We need to use a dummy buffer instead. */ |
Andreas Hartmetz | 8662e66 | 2014-01-11 16:00:50 +0100 | [diff] [blame] | 293 | if (sctx->b.chip_class == CIK) { |
Marek Olšák | 45240ce | 2017-02-15 20:44:24 +0100 | [diff] [blame] | 294 | sctx->null_const_buf.buffer = |
| 295 | r600_aligned_buffer_create(screen, |
| 296 | R600_RESOURCE_FLAG_UNMAPPABLE, |
| 297 | PIPE_USAGE_DEFAULT, 16, |
| 298 | sctx->screen->b.info.tcc_cache_line_size); |
Marek Olšák | ae418a7 | 2015-09-10 19:25:14 +0200 | [diff] [blame] | 299 | if (!sctx->null_const_buf.buffer) |
| 300 | goto fail; |
Andreas Hartmetz | 8662e66 | 2014-01-11 16:00:50 +0100 | [diff] [blame] | 301 | sctx->null_const_buf.buffer_size = sctx->null_const_buf.buffer->width0; |
Marek Olšák | 4569bf9 | 2013-10-30 20:44:23 +0100 | [diff] [blame] | 302 | |
| 303 | for (shader = 0; shader < SI_NUM_SHADERS; shader++) { |
Marek Olšák | ee2a818 | 2014-07-07 23:27:19 +0200 | [diff] [blame] | 304 | for (i = 0; i < SI_NUM_CONST_BUFFERS; i++) { |
Andreas Hartmetz | 8662e66 | 2014-01-11 16:00:50 +0100 | [diff] [blame] | 305 | sctx->b.b.set_constant_buffer(&sctx->b.b, shader, i, |
| 306 | &sctx->null_const_buf); |
Marek Olšák | 4569bf9 | 2013-10-30 20:44:23 +0100 | [diff] [blame] | 307 | } |
| 308 | } |
| 309 | |
Marek Olšák | 2c13abb | 2016-08-18 15:25:51 +0200 | [diff] [blame] | 310 | si_set_rw_buffer(sctx, SI_HS_CONST_DEFAULT_TESS_LEVELS, |
| 311 | &sctx->null_const_buf); |
Marek Olšák | 4a10d61 | 2017-06-09 18:46:07 +0200 | [diff] [blame] | 312 | si_set_rw_buffer(sctx, SI_VS_CONST_INSTANCE_DIVISORS, |
| 313 | &sctx->null_const_buf); |
Marek Olšák | 2c13abb | 2016-08-18 15:25:51 +0200 | [diff] [blame] | 314 | si_set_rw_buffer(sctx, SI_VS_CONST_CLIP_PLANES, |
| 315 | &sctx->null_const_buf); |
| 316 | si_set_rw_buffer(sctx, SI_PS_CONST_POLY_STIPPLE, |
| 317 | &sctx->null_const_buf); |
| 318 | si_set_rw_buffer(sctx, SI_PS_CONST_SAMPLE_POSITIONS, |
| 319 | &sctx->null_const_buf); |
| 320 | |
Marek Olšák | 4569bf9 | 2013-10-30 20:44:23 +0100 | [diff] [blame] | 321 | /* Clear the NULL constant buffer, because loads should return zeros. */ |
Andreas Hartmetz | 8662e66 | 2014-01-11 16:00:50 +0100 | [diff] [blame] | 322 | sctx->b.clear_buffer(&sctx->b.b, sctx->null_const_buf.buffer, 0, |
Marek Olšák | f564b61 | 2016-04-22 10:26:28 +0200 | [diff] [blame] | 323 | sctx->null_const_buf.buffer->width0, 0, |
| 324 | R600_COHERENCY_SHADER); |
Marek Olšák | 4569bf9 | 2013-10-30 20:44:23 +0100 | [diff] [blame] | 325 | } |
| 326 | |
Marek Olšák | 26b69ad | 2016-06-08 14:34:11 +0200 | [diff] [blame] | 327 | uint64_t max_threads_per_block; |
| 328 | screen->get_compute_param(screen, PIPE_SHADER_IR_TGSI, |
| 329 | PIPE_COMPUTE_CAP_MAX_THREADS_PER_BLOCK, |
| 330 | &max_threads_per_block); |
| 331 | |
| 332 | /* The maximum number of scratch waves. Scratch space isn't divided |
| 333 | * evenly between CUs. The number is only a function of the number of CUs. |
| 334 | * We can decrease the constant to decrease the scratch buffer size. |
| 335 | * |
| 336 | * sctx->scratch_waves must be >= the maximum posible size of |
| 337 | * 1 threadgroup, so that the hw doesn't hang from being unable |
| 338 | * to start any. |
| 339 | * |
| 340 | * The recommended value is 4 per CU at most. Higher numbers don't |
| 341 | * bring much benefit, but they still occupy chip resources (think |
| 342 | * async compute). I've seen ~2% performance difference between 4 and 32. |
Tom Stellard | 2397a72 | 2014-12-10 09:13:59 -0500 | [diff] [blame] | 343 | */ |
Marek Olšák | 26b69ad | 2016-06-08 14:34:11 +0200 | [diff] [blame] | 344 | sctx->scratch_waves = MAX2(32 * sscreen->b.info.num_good_compute_units, |
| 345 | max_threads_per_block / 64); |
Tom Stellard | 2397a72 | 2014-12-10 09:13:59 -0500 | [diff] [blame] | 346 | |
Marek Olšák | 6781a2a | 2016-06-11 18:53:15 +0200 | [diff] [blame] | 347 | sctx->tm = si_create_llvm_target_machine(sscreen); |
Michel Dänzer | d64adc3 | 2015-03-26 11:32:59 +0900 | [diff] [blame] | 348 | |
Samuel Pitoiset | 77bbdcd | 2017-05-16 10:11:54 +0200 | [diff] [blame] | 349 | /* Create a slab allocator for all bindless descriptors. */ |
| 350 | if (!pb_slabs_init(&sctx->bindless_descriptor_slabs, 6, 6, 1, sctx, |
| 351 | si_bindless_descriptor_can_reclaim_slab, |
| 352 | si_bindless_descriptor_slab_alloc, |
| 353 | si_bindless_descriptor_slab_free)) |
| 354 | goto fail; |
| 355 | |
| 356 | util_dynarray_init(&sctx->bindless_descriptors, NULL); |
| 357 | |
Samuel Pitoiset | 9cc328e | 2017-05-16 10:49:20 +0200 | [diff] [blame] | 358 | /* Bindless handles. */ |
| 359 | sctx->tex_handles = _mesa_hash_table_create(NULL, _mesa_hash_pointer, |
| 360 | _mesa_key_pointer_equal); |
| 361 | sctx->img_handles = _mesa_hash_table_create(NULL, _mesa_hash_pointer, |
| 362 | _mesa_key_pointer_equal); |
| 363 | |
| 364 | util_dynarray_init(&sctx->resident_tex_handles, NULL); |
| 365 | util_dynarray_init(&sctx->resident_img_handles, NULL); |
Samuel Pitoiset | 6ff6863 | 2017-06-14 13:55:12 +0200 | [diff] [blame] | 366 | util_dynarray_init(&sctx->resident_tex_needs_color_decompress, NULL); |
| 367 | util_dynarray_init(&sctx->resident_img_needs_color_decompress, NULL); |
Samuel Pitoiset | 06ed251 | 2017-06-14 13:55:11 +0200 | [diff] [blame] | 368 | util_dynarray_init(&sctx->resident_tex_needs_depth_decompress, NULL); |
Samuel Pitoiset | 9cc328e | 2017-05-16 10:49:20 +0200 | [diff] [blame] | 369 | |
Andreas Hartmetz | 8662e66 | 2014-01-11 16:00:50 +0100 | [diff] [blame] | 370 | return &sctx->b.b; |
Marek Olšák | a81c3e0 | 2013-08-14 01:04:39 +0200 | [diff] [blame] | 371 | fail: |
Marek Olšák | a9971e8 | 2015-08-30 14:13:10 +0200 | [diff] [blame] | 372 | fprintf(stderr, "radeonsi: Failed to create a context.\n"); |
Andreas Hartmetz | 8662e66 | 2014-01-11 16:00:50 +0100 | [diff] [blame] | 373 | si_destroy_context(&sctx->b.b); |
Marek Olšák | a81c3e0 | 2013-08-14 01:04:39 +0200 | [diff] [blame] | 374 | return NULL; |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 375 | } |
| 376 | |
Marek Olšák | 1c8f7d3 | 2017-03-02 01:28:51 +0100 | [diff] [blame] | 377 | static struct pipe_context *si_pipe_create_context(struct pipe_screen *screen, |
| 378 | void *priv, unsigned flags) |
| 379 | { |
| 380 | struct si_screen *sscreen = (struct si_screen *)screen; |
Marek Olšák | 5fb80a1 | 2017-07-09 23:44:57 +0200 | [diff] [blame] | 381 | struct pipe_context *ctx; |
| 382 | |
| 383 | if (sscreen->b.debug_flags & DBG_CHECK_VM) |
| 384 | flags |= PIPE_CONTEXT_DEBUG; |
| 385 | |
| 386 | ctx = si_create_context(screen, flags); |
Marek Olšák | 1c8f7d3 | 2017-03-02 01:28:51 +0100 | [diff] [blame] | 387 | |
| 388 | if (!(flags & PIPE_CONTEXT_PREFER_THREADED)) |
| 389 | return ctx; |
| 390 | |
| 391 | /* Clover (compute-only) is unsupported. |
| 392 | * |
| 393 | * Since the threaded context creates shader states from the non-driver |
| 394 | * thread, asynchronous compilation is required for create_{shader}_- |
| 395 | * state not to use pipe_context. Debug contexts (ddebug) disable |
| 396 | * asynchronous compilation, so don't use the threaded context with |
| 397 | * those. |
| 398 | */ |
| 399 | if (flags & (PIPE_CONTEXT_COMPUTE_ONLY | PIPE_CONTEXT_DEBUG)) |
| 400 | return ctx; |
| 401 | |
| 402 | /* When shaders are logged to stderr, asynchronous compilation is |
| 403 | * disabled too. */ |
| 404 | if (sscreen->b.debug_flags & (DBG_VS | DBG_TCS | DBG_TES | DBG_GS | |
| 405 | DBG_PS | DBG_CS)) |
| 406 | return ctx; |
| 407 | |
| 408 | return threaded_context_create(ctx, &sscreen->b.pool_transfers, |
| 409 | r600_replace_buffer_storage, |
| 410 | &((struct si_context*)ctx)->b.tc); |
| 411 | } |
| 412 | |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 413 | /* |
| 414 | * pipe_screen |
| 415 | */ |
Nicolai Hähnle | 7a0e543 | 2016-09-14 09:43:42 +0200 | [diff] [blame] | 416 | static bool si_have_tgsi_compute(struct si_screen *sscreen) |
| 417 | { |
| 418 | /* Old kernels disallowed some register writes for SI |
| 419 | * that are used for indirect dispatches. */ |
Marek Olšák | 12beef0 | 2017-04-25 02:18:10 +0200 | [diff] [blame] | 420 | return (sscreen->b.chip_class >= CIK || |
Nicolai Hähnle | 7a0e543 | 2016-09-14 09:43:42 +0200 | [diff] [blame] | 421 | sscreen->b.info.drm_major == 3 || |
| 422 | (sscreen->b.info.drm_major == 2 && |
| 423 | sscreen->b.info.drm_minor >= 45)); |
| 424 | } |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 425 | |
Andreas Hartmetz | eb0ddb6 | 2014-01-07 03:07:55 +0100 | [diff] [blame] | 426 | static int si_get_param(struct pipe_screen* pscreen, enum pipe_cap param) |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 427 | { |
Andreas Hartmetz | aa7ae4f | 2014-01-11 16:01:11 +0100 | [diff] [blame] | 428 | struct si_screen *sscreen = (struct si_screen *)pscreen; |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 429 | |
| 430 | switch (param) { |
| 431 | /* Supported features (boolean caps). */ |
Marek Olšák | 2c8ee2e | 2017-02-11 17:21:04 +0100 | [diff] [blame] | 432 | case PIPE_CAP_ACCELERATED: |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 433 | case PIPE_CAP_TWO_SIDED_STENCIL: |
Tom Stellard | 69a9218 | 2012-04-14 17:37:37 -0400 | [diff] [blame] | 434 | case PIPE_CAP_MAX_DUAL_SOURCE_RENDER_TARGETS: |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 435 | case PIPE_CAP_ANISOTROPIC_FILTER: |
| 436 | case PIPE_CAP_POINT_SPRITE: |
| 437 | case PIPE_CAP_OCCLUSION_QUERY: |
| 438 | case PIPE_CAP_TEXTURE_SHADOW_MAP: |
| 439 | case PIPE_CAP_TEXTURE_MIRROR_CLAMP: |
| 440 | case PIPE_CAP_BLEND_EQUATION_SEPARATE: |
| 441 | case PIPE_CAP_TEXTURE_SWIZZLE: |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 442 | case PIPE_CAP_DEPTH_CLIP_DISABLE: |
| 443 | case PIPE_CAP_SHADER_STENCIL_EXPORT: |
| 444 | case PIPE_CAP_VERTEX_ELEMENT_INSTANCE_DIVISOR: |
| 445 | case PIPE_CAP_MIXED_COLORBUFFER_FORMATS: |
| 446 | case PIPE_CAP_TGSI_FS_COORD_ORIGIN_UPPER_LEFT: |
| 447 | case PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_HALF_INTEGER: |
Marek Olšák | 3958378 | 2014-11-17 20:51:56 +0100 | [diff] [blame] | 448 | case PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_INTEGER: |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 449 | case PIPE_CAP_SM3: |
| 450 | case PIPE_CAP_SEAMLESS_CUBE_MAP: |
| 451 | case PIPE_CAP_PRIMITIVE_RESTART: |
| 452 | case PIPE_CAP_CONDITIONAL_RENDER: |
| 453 | case PIPE_CAP_TEXTURE_BARRIER: |
| 454 | case PIPE_CAP_INDEP_BLEND_ENABLE: |
| 455 | case PIPE_CAP_INDEP_BLEND_FUNC: |
| 456 | case PIPE_CAP_SEAMLESS_CUBE_MAP_PER_TEXTURE: |
| 457 | case PIPE_CAP_VERTEX_COLOR_UNCLAMPED: |
Marek Olšák | 437ab1d | 2012-04-24 15:19:31 +0200 | [diff] [blame] | 458 | case PIPE_CAP_USER_CONSTANT_BUFFERS: |
Fredrik Höglund | af37212 | 2012-06-18 22:50:02 +0200 | [diff] [blame] | 459 | case PIPE_CAP_START_INSTANCE: |
Michel Dänzer | d0f51fe | 2012-09-05 18:27:02 +0200 | [diff] [blame] | 460 | case PIPE_CAP_NPOT_TEXTURES: |
Ilia Mirkin | 12d39b4 | 2013-10-04 04:32:15 -0400 | [diff] [blame] | 461 | case PIPE_CAP_MIXED_FRAMEBUFFER_SIZES: |
Ilia Mirkin | 9515d65 | 2016-08-20 22:40:33 -0400 | [diff] [blame] | 462 | case PIPE_CAP_MIXED_COLOR_DEPTH_BITS: |
Marek Olšák | 5bc871a | 2015-10-07 02:36:38 +0200 | [diff] [blame] | 463 | case PIPE_CAP_VERTEX_COLOR_CLAMPED: |
Marek Olšák | 208d1ed | 2015-10-07 01:47:00 +0200 | [diff] [blame] | 464 | case PIPE_CAP_FRAGMENT_COLOR_CLAMPED: |
Marek Olšák | 3e10ab6 | 2013-03-14 17:18:43 +0100 | [diff] [blame] | 465 | case PIPE_CAP_PREFER_BLIT_BASED_TEXTURE_TRANSFER: |
Christian König | e4ed587 | 2013-03-21 18:02:52 +0100 | [diff] [blame] | 466 | case PIPE_CAP_TGSI_INSTANCEID: |
Tom Stellard | 302f53d | 2012-10-25 13:50:10 -0400 | [diff] [blame] | 467 | case PIPE_CAP_COMPUTE: |
Marek Olšák | dbeedbb | 2013-10-31 15:08:49 +0100 | [diff] [blame] | 468 | case PIPE_CAP_TEXTURE_BUFFER_OBJECTS: |
Ilia Mirkin | 32b7124 | 2014-07-03 11:15:18 -0400 | [diff] [blame] | 469 | case PIPE_CAP_TGSI_VS_LAYER_VIEWPORT: |
Marek Olšák | 8739c60 | 2014-01-22 00:08:11 +0100 | [diff] [blame] | 470 | case PIPE_CAP_QUERY_PIPELINE_STATISTICS: |
Marek Olšák | 6381dd7 | 2014-01-27 21:46:21 +0100 | [diff] [blame] | 471 | case PIPE_CAP_BUFFER_MAP_PERSISTENT_COHERENT: |
Marek Olšák | 2484daa | 2014-04-22 21:23:29 +0200 | [diff] [blame] | 472 | case PIPE_CAP_CUBE_MAP_ARRAY: |
Marek Olšák | f98a7d8 | 2014-05-07 13:15:41 +0200 | [diff] [blame] | 473 | case PIPE_CAP_SAMPLE_SHADING: |
Marek Olšák | 2a7b57a | 2014-04-24 03:03:43 +0200 | [diff] [blame] | 474 | case PIPE_CAP_DRAW_INDIRECT: |
Mathias Fröhlich | 5608813 | 2014-09-14 15:17:07 +0200 | [diff] [blame] | 475 | case PIPE_CAP_CLIP_HALFZ: |
Marek Olšák | ff80422 | 2014-11-08 16:03:13 +0100 | [diff] [blame] | 476 | case PIPE_CAP_TGSI_VS_WINDOW_SPACE_POSITION: |
Ilia Mirkin | 7c211a1 | 2015-02-01 09:01:50 -0500 | [diff] [blame] | 477 | case PIPE_CAP_POLYGON_OFFSET_CLAMP: |
Axel Davy | eb1c12d | 2015-01-17 14:30:17 +0100 | [diff] [blame] | 478 | case PIPE_CAP_MULTISAMPLE_Z_RESOLVE: |
Marek Olšák | f5832f3 | 2015-03-15 18:53:50 +0100 | [diff] [blame] | 479 | case PIPE_CAP_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION: |
Marek Olšák | e4339bc | 2015-05-09 19:36:17 +0200 | [diff] [blame] | 480 | case PIPE_CAP_TGSI_TEXCOORD: |
Dave Airlie | bb9d59a | 2015-07-17 05:35:30 +0100 | [diff] [blame] | 481 | case PIPE_CAP_TGSI_FS_FINE_DERIVATIVE: |
Edward O'Callaghan | 8254672 | 2015-07-27 11:01:47 +1000 | [diff] [blame] | 482 | case PIPE_CAP_CONDITIONAL_RENDER_INVERTED: |
Marek Olšák | 44dc1d3 | 2015-08-10 19:37:01 +0200 | [diff] [blame] | 483 | case PIPE_CAP_TEXTURE_FLOAT_LINEAR: |
| 484 | case PIPE_CAP_TEXTURE_HALF_FLOAT_LINEAR: |
Marek Olšák | 9b54ce3 | 2015-10-07 01:48:18 +0200 | [diff] [blame] | 485 | case PIPE_CAP_SHAREABLE_SHADERS: |
Marek Olšák | 97f58fb | 2015-08-10 02:23:21 +0200 | [diff] [blame] | 486 | case PIPE_CAP_DEPTH_BOUNDS_TEST: |
Marek Olšák | 1232196 | 2015-03-17 14:46:04 +0100 | [diff] [blame] | 487 | case PIPE_CAP_SAMPLER_VIEW_TARGET: |
Marek Olšák | e6d3846 | 2015-09-06 16:26:21 +0200 | [diff] [blame] | 488 | case PIPE_CAP_TEXTURE_QUERY_LOD: |
| 489 | case PIPE_CAP_TEXTURE_GATHER_SM5: |
Ilia Mirkin | 72ebd53 | 2015-09-18 19:08:35 -0400 | [diff] [blame] | 490 | case PIPE_CAP_TGSI_TXQS: |
Marek Olšák | 814b7d1 | 2015-09-28 23:50:12 +0200 | [diff] [blame] | 491 | case PIPE_CAP_FORCE_PERSAMPLE_INTERP: |
Marek Olšák | ce9db16 | 2015-08-24 01:19:35 +0200 | [diff] [blame] | 492 | case PIPE_CAP_COPY_BETWEEN_COMPRESSED_AND_PLAIN_FORMATS: |
Marek Olšák | 4ea0feb | 2016-01-02 23:09:58 +0100 | [diff] [blame] | 493 | case PIPE_CAP_TGSI_FS_POSITION_IS_SYSVAL: |
| 494 | case PIPE_CAP_TGSI_FS_FACE_IS_INTEGER_SYSVAL: |
Nicolai Hähnle | 321140d | 2016-01-14 09:41:04 -0500 | [diff] [blame] | 495 | case PIPE_CAP_INVALIDATE_BUFFER: |
Nicolai Hähnle | 7dd31b8 | 2016-01-26 10:29:50 -0500 | [diff] [blame] | 496 | case PIPE_CAP_SURFACE_REINTERPRET_BLOCKS: |
Marek Olšák | 635555a | 2016-02-02 02:09:36 +0100 | [diff] [blame] | 497 | case PIPE_CAP_QUERY_MEMORY_INFO: |
Marek Olšák | 100796c | 2016-02-10 21:48:59 +0100 | [diff] [blame] | 498 | case PIPE_CAP_TGSI_PACK_HALF_FLOAT: |
Edward O'Callaghan | 483a686 | 2016-01-02 05:53:57 +1100 | [diff] [blame] | 499 | case PIPE_CAP_FRAMEBUFFER_NO_ATTACHMENT: |
Bas Nieuwenhuizen | 126da23 | 2016-04-03 21:49:44 +0200 | [diff] [blame] | 500 | case PIPE_CAP_ROBUST_BUFFER_ACCESS_BEHAVIOR: |
Marek Olšák | 70a2547 | 2016-06-10 03:03:11 +0200 | [diff] [blame] | 501 | case PIPE_CAP_GENERATE_MIPMAP: |
Axel Davy | be7957b | 2016-06-14 22:41:50 +0200 | [diff] [blame] | 502 | case PIPE_CAP_POLYGON_OFFSET_UNITS_UNSCALED: |
Marek Olšák | 28a03be | 2016-06-30 01:15:19 +0200 | [diff] [blame] | 503 | case PIPE_CAP_STRING_MARKER: |
Marek Olšák | 739d526 | 2016-08-04 19:04:02 +0200 | [diff] [blame] | 504 | case PIPE_CAP_CLEAR_TEXTURE: |
Dave Airlie | f235dc0 | 2016-05-13 16:49:02 +1000 | [diff] [blame] | 505 | case PIPE_CAP_CULL_DISTANCE: |
Nicolai Hähnle | 789119d | 2016-10-06 23:10:22 +0200 | [diff] [blame] | 506 | case PIPE_CAP_TGSI_ARRAY_COMPONENTS: |
Nicolai Hähnle | 611166b | 2016-11-18 20:49:54 +0100 | [diff] [blame] | 507 | case PIPE_CAP_TGSI_CAN_READ_OUTPUTS: |
Nicolai Hähnle | c5e76a2 | 2017-01-24 21:22:32 +0100 | [diff] [blame] | 508 | case PIPE_CAP_GLSL_OPTIMIZE_CONSERVATIVELY: |
Marek Olšák | 2c8ee2e | 2017-02-11 17:21:04 +0100 | [diff] [blame] | 509 | case PIPE_CAP_STREAM_OUTPUT_PAUSE_RESUME: |
| 510 | case PIPE_CAP_STREAM_OUTPUT_INTERLEAVE_BUFFERS: |
Marek Olšák | 7e1faa7 | 2017-03-05 00:15:31 +0100 | [diff] [blame] | 511 | case PIPE_CAP_DOUBLES: |
Marek Olšák | 0550f3d | 2017-03-07 02:19:47 +0100 | [diff] [blame] | 512 | case PIPE_CAP_TGSI_TEX_TXF_LZ: |
Nicolai Hähnle | 2ac03e9 | 2017-04-13 22:16:26 +0200 | [diff] [blame] | 513 | case PIPE_CAP_TGSI_TES_LAYER_VIEWPORT: |
Samuel Pitoiset | 65d1e4d | 2017-02-27 13:15:38 +0100 | [diff] [blame] | 514 | case PIPE_CAP_BINDLESS_TEXTURE: |
Marek Olšák | 465bb47 | 2017-07-10 16:06:08 +0200 | [diff] [blame] | 515 | case PIPE_CAP_QUERY_TIMESTAMP: |
| 516 | case PIPE_CAP_QUERY_TIME_ELAPSED: |
Nicolai Hähnle | 01f1598 | 2017-06-25 18:31:11 +0200 | [diff] [blame] | 517 | case PIPE_CAP_NIR_SAMPLERS_AS_DEREF: |
Nicolai Hähnle | 78476cf | 2017-07-26 19:37:21 +0200 | [diff] [blame] | 518 | case PIPE_CAP_QUERY_SO_OVERFLOW: |
Samuel Pitoiset | 65d1e4d | 2017-02-27 13:15:38 +0100 | [diff] [blame] | 519 | return 1; |
| 520 | |
Nicolai Hähnle | a020cb3 | 2017-01-27 10:35:13 +0100 | [diff] [blame] | 521 | case PIPE_CAP_INT64: |
Ilia Mirkin | b090033 | 2017-02-04 22:31:29 -0500 | [diff] [blame] | 522 | case PIPE_CAP_INT64_DIVMOD: |
Nicolai Hähnle | cd3f386 | 2017-03-30 08:55:22 +0200 | [diff] [blame] | 523 | case PIPE_CAP_TGSI_CLOCK: |
Marek Olšák | 70dcb73 | 2017-04-30 01:18:43 +0200 | [diff] [blame] | 524 | case PIPE_CAP_CAN_BIND_CONST_BUFFER_AS_VERTEX: |
Marek Olšák | 5018937 | 2017-05-15 16:30:30 +0200 | [diff] [blame] | 525 | case PIPE_CAP_ALLOW_MAPPED_BUFFERS_DURING_EXECUTION: |
Marek Olšák | 12beef0 | 2017-04-25 02:18:10 +0200 | [diff] [blame] | 526 | return 1; |
Nicolai Hähnle | a020cb3 | 2017-01-27 10:35:13 +0100 | [diff] [blame] | 527 | |
Nicolai Hähnle | 02112c3 | 2017-03-29 20:29:37 +0200 | [diff] [blame] | 528 | case PIPE_CAP_TGSI_VOTE: |
| 529 | return HAVE_LLVM >= 0x0400; |
| 530 | |
Nicolai Hähnle | 9e1b2e4 | 2017-03-30 11:19:39 +0200 | [diff] [blame] | 531 | case PIPE_CAP_TGSI_BALLOT: |
| 532 | return HAVE_LLVM >= 0x0500; |
| 533 | |
Marek Olšák | 7713d59 | 2015-02-10 16:02:54 +0100 | [diff] [blame] | 534 | case PIPE_CAP_RESOURCE_FROM_USER_MEMORY: |
| 535 | return !SI_BIG_ENDIAN && sscreen->b.info.has_userptr; |
| 536 | |
Marek Olšák | 914365c | 2015-04-29 15:27:50 +0200 | [diff] [blame] | 537 | case PIPE_CAP_DEVICE_RESET_STATUS_QUERY: |
Marek Olšák | bf2c342 | 2015-04-30 17:02:38 +0200 | [diff] [blame] | 538 | return (sscreen->b.info.drm_major == 2 && |
| 539 | sscreen->b.info.drm_minor >= 43) || |
| 540 | sscreen->b.info.drm_major == 3; |
Marek Olšák | 914365c | 2015-04-29 15:27:50 +0200 | [diff] [blame] | 541 | |
Marek Olšák | 2f1c449 | 2013-07-30 22:29:30 +0200 | [diff] [blame] | 542 | case PIPE_CAP_TEXTURE_MULTISAMPLE: |
Marek Olšák | 751e869 | 2013-11-20 13:48:19 +0100 | [diff] [blame] | 543 | /* 2D tiling on CIK is supported since DRM 2.35.0 */ |
Marek Olšák | a66d934 | 2014-07-08 02:50:57 +0200 | [diff] [blame] | 544 | return sscreen->b.chip_class < CIK || |
Marek Olšák | 8ba70e0 | 2015-04-16 20:35:27 +0200 | [diff] [blame] | 545 | (sscreen->b.info.drm_major == 2 && |
| 546 | sscreen->b.info.drm_minor >= 35) || |
| 547 | sscreen->b.info.drm_major == 3; |
Marek Olšák | 2f1c449 | 2013-07-30 22:29:30 +0200 | [diff] [blame] | 548 | |
Marek Olšák | c9f2af3 | 2012-10-28 17:52:48 +0100 | [diff] [blame] | 549 | case PIPE_CAP_MIN_MAP_BUFFER_ALIGNMENT: |
Marek Olšák | de5094d | 2014-03-09 22:29:20 +0100 | [diff] [blame] | 550 | return R600_MAP_BUFFER_ALIGNMENT; |
Marek Olšák | c9f2af3 | 2012-10-28 17:52:48 +0100 | [diff] [blame] | 551 | |
Marek Olšák | 1b749dc | 2012-04-24 17:31:17 +0200 | [diff] [blame] | 552 | case PIPE_CAP_CONSTANT_BUFFER_OFFSET_ALIGNMENT: |
Marek Olšák | e219842 | 2014-03-09 20:05:54 +0100 | [diff] [blame] | 553 | case PIPE_CAP_TEXTURE_BUFFER_OFFSET_ALIGNMENT: |
Marek Olšák | e6d3846 | 2015-09-06 16:26:21 +0200 | [diff] [blame] | 554 | case PIPE_CAP_MAX_TEXTURE_GATHER_COMPONENTS: |
Marek Olšák | 2c8ee2e | 2017-02-11 17:21:04 +0100 | [diff] [blame] | 555 | case PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS: |
| 556 | case PIPE_CAP_MAX_VERTEX_STREAMS: |
Nicolai Hähnle | 9e9a2bb | 2016-04-13 09:11:44 -0500 | [diff] [blame] | 557 | case PIPE_CAP_SHADER_BUFFER_OFFSET_ALIGNMENT: |
Marek Olšák | 12beef0 | 2017-04-25 02:18:10 +0200 | [diff] [blame] | 558 | return 4; |
Marek Olšák | 1b749dc | 2012-04-24 17:31:17 +0200 | [diff] [blame] | 559 | |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 560 | case PIPE_CAP_GLSL_FEATURE_LEVEL: |
Nicolai Hähnle | dfe237a | 2017-05-16 01:51:41 +0200 | [diff] [blame] | 561 | if (sscreen->b.debug_flags & DBG_NIR) |
| 562 | return 140; /* no geometry and tessellation shaders yet */ |
Nicolai Hähnle | 1f95121 | 2016-10-06 22:57:55 +0200 | [diff] [blame] | 563 | if (si_have_tgsi_compute(sscreen)) |
Nicolai Hähnle | 84a74be | 2016-10-07 18:21:51 +0200 | [diff] [blame] | 564 | return 450; |
Marek Olšák | 12beef0 | 2017-04-25 02:18:10 +0200 | [diff] [blame] | 565 | return 420; |
Marek Olšák | dbeedbb | 2013-10-31 15:08:49 +0100 | [diff] [blame] | 566 | |
Marek Olšák | dbeedbb | 2013-10-31 15:08:49 +0100 | [diff] [blame] | 567 | case PIPE_CAP_MAX_TEXTURE_BUFFER_SIZE: |
Marek Olšák | 8a4ace4 | 2016-07-01 00:17:36 +0200 | [diff] [blame] | 568 | return MIN2(sscreen->b.info.max_alloc_size, INT_MAX); |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 569 | |
Marek Olšák | 9b91e0b | 2017-02-10 01:15:21 +0100 | [diff] [blame] | 570 | case PIPE_CAP_VERTEX_BUFFER_OFFSET_4BYTE_ALIGNED_ONLY: |
| 571 | case PIPE_CAP_VERTEX_BUFFER_STRIDE_4BYTE_ALIGNED_ONLY: |
| 572 | case PIPE_CAP_VERTEX_ELEMENT_SRC_OFFSET_4BYTE_ALIGNED_ONLY: |
| 573 | /* SI doesn't support unaligned loads. |
| 574 | * CIK needs DRM 2.50.0 on radeon. */ |
| 575 | return sscreen->b.chip_class == SI || |
| 576 | (sscreen->b.info.drm_major == 2 && |
| 577 | sscreen->b.info.drm_minor < 50); |
| 578 | |
Nicolai Hähnle | 570e50a | 2017-02-02 21:11:05 +0100 | [diff] [blame] | 579 | case PIPE_CAP_SPARSE_BUFFER_PAGE_SIZE: |
Marek Olšák | 353b60c | 2017-06-16 21:07:49 +0200 | [diff] [blame] | 580 | /* TODO: GFX9 hangs. */ |
| 581 | if (sscreen->b.chip_class >= GFX9) |
| 582 | return 0; |
Nicolai Hähnle | 570e50a | 2017-02-02 21:11:05 +0100 | [diff] [blame] | 583 | /* Disable on SI due to VM faults in CP DMA. Enable once these |
| 584 | * faults are mitigated in software. |
| 585 | */ |
| 586 | if (sscreen->b.chip_class >= CIK && |
| 587 | sscreen->b.info.drm_major == 3 && |
| 588 | sscreen->b.info.drm_minor >= 13) |
| 589 | return RADEON_SPARSE_PAGE_SIZE; |
| 590 | return 0; |
| 591 | |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 592 | /* Unsupported features. */ |
Marek Olšák | 2c8ee2e | 2017-02-11 17:21:04 +0100 | [diff] [blame] | 593 | case PIPE_CAP_BUFFER_SAMPLER_VIEW_RGBA_ONLY: |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 594 | case PIPE_CAP_TGSI_FS_COORD_ORIGIN_LOWER_LEFT: |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 595 | case PIPE_CAP_TGSI_CAN_COMPACT_CONSTANTS: |
Marek Olšák | 2a311b1 | 2012-04-24 01:23:33 +0200 | [diff] [blame] | 596 | case PIPE_CAP_USER_VERTEX_BUFFERS: |
Dave Airlie | 76ba50a | 2013-11-27 19:47:51 +1000 | [diff] [blame] | 597 | case PIPE_CAP_FAKE_SW_MSAA: |
Ilia Mirkin | d95df4f | 2014-04-26 23:44:57 -0400 | [diff] [blame] | 598 | case PIPE_CAP_TEXTURE_GATHER_OFFSETS: |
Roland Scheidegger | ade8b26 | 2014-12-12 04:13:43 +0100 | [diff] [blame] | 599 | case PIPE_CAP_VERTEXID_NOBASE: |
Kenneth Graunke | 70048eb | 2016-05-20 21:05:34 -0700 | [diff] [blame] | 600 | case PIPE_CAP_PRIMITIVE_RESTART_FOR_PATCHES: |
Ilia Mirkin | 07fcb06 | 2016-06-11 15:26:45 -0400 | [diff] [blame] | 601 | case PIPE_CAP_MAX_WINDOW_RECTANGLES: |
Rob Clark | 026a722 | 2016-04-01 16:10:42 -0400 | [diff] [blame] | 602 | case PIPE_CAP_NATIVE_FENCE_FD: |
Ilia Mirkin | ee3ebe6 | 2017-01-01 23:10:00 -0500 | [diff] [blame] | 603 | case PIPE_CAP_TGSI_FS_FBFETCH: |
Ilia Mirkin | 6e40938 | 2017-01-16 22:14:38 -0500 | [diff] [blame] | 604 | case PIPE_CAP_TGSI_MUL_ZERO_WINS: |
Marek Olšák | 2c8ee2e | 2017-02-11 17:21:04 +0100 | [diff] [blame] | 605 | case PIPE_CAP_UMA: |
Lyude | ffe2bd6 | 2017-03-16 18:00:05 -0400 | [diff] [blame] | 606 | case PIPE_CAP_POLYGON_MODE_FILL_RECTANGLE: |
Lyude | 467af44 | 2017-05-24 15:42:39 -0400 | [diff] [blame] | 607 | case PIPE_CAP_POST_DEPTH_COVERAGE: |
Timothy Arceri | 4e4042d | 2017-08-03 13:54:45 +1000 | [diff] [blame^] | 608 | case PIPE_CAP_MEMOBJ: |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 609 | return 0; |
| 610 | |
Nicolai Hähnle | 7a0e543 | 2016-09-14 09:43:42 +0200 | [diff] [blame] | 611 | case PIPE_CAP_QUERY_BUFFER_OBJECT: |
| 612 | return si_have_tgsi_compute(sscreen); |
| 613 | |
Nicolai Hähnle | e4cb3af | 2016-07-28 17:01:54 +0100 | [diff] [blame] | 614 | case PIPE_CAP_DRAW_PARAMETERS: |
| 615 | case PIPE_CAP_MULTI_DRAW_INDIRECT: |
| 616 | case PIPE_CAP_MULTI_DRAW_INDIRECT_PARAMS: |
| 617 | return sscreen->has_draw_indirect_multi; |
| 618 | |
Marek Olšák | bac12c8 | 2015-02-22 18:46:53 +0100 | [diff] [blame] | 619 | case PIPE_CAP_MAX_SHADER_PATCH_VARYINGS: |
| 620 | return 30; |
| 621 | |
Marek Olšák | 164de0d | 2013-10-30 21:44:07 +0100 | [diff] [blame] | 622 | case PIPE_CAP_TEXTURE_BORDER_COLOR_QUIRK: |
Marek Olšák | d60f72a | 2016-10-15 15:24:45 +0200 | [diff] [blame] | 623 | return sscreen->b.chip_class <= VI ? |
| 624 | PIPE_QUIRK_TEXTURE_BORDER_COLOR_SWIZZLE_R600 : 0; |
Marek Olšák | 164de0d | 2013-10-30 21:44:07 +0100 | [diff] [blame] | 625 | |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 626 | /* Stream output. */ |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 627 | case PIPE_CAP_MAX_STREAM_OUTPUT_SEPARATE_COMPONENTS: |
| 628 | case PIPE_CAP_MAX_STREAM_OUTPUT_INTERLEAVED_COMPONENTS: |
Marek Olšák | 2c8ee2e | 2017-02-11 17:21:04 +0100 | [diff] [blame] | 629 | return 32*4; |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 630 | |
Grigori Goronzy | d34d5fd | 2014-02-09 22:56:20 +0100 | [diff] [blame] | 631 | /* Geometry shader output. */ |
| 632 | case PIPE_CAP_MAX_GEOMETRY_OUTPUT_VERTICES: |
| 633 | return 1024; |
| 634 | case PIPE_CAP_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS: |
| 635 | return 4095; |
| 636 | |
Timothy Arceri | 89e6806 | 2014-08-19 21:09:58 -1000 | [diff] [blame] | 637 | case PIPE_CAP_MAX_VERTEX_ATTRIB_STRIDE: |
| 638 | return 2048; |
| 639 | |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 640 | /* Texturing. */ |
| 641 | case PIPE_CAP_MAX_TEXTURE_2D_LEVELS: |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 642 | case PIPE_CAP_MAX_TEXTURE_CUBE_LEVELS: |
Marek Olšák | 4f1f323 | 2014-03-09 20:03:57 +0100 | [diff] [blame] | 643 | return 15; /* 16384 */ |
| 644 | case PIPE_CAP_MAX_TEXTURE_3D_LEVELS: |
| 645 | /* textures support 8192, but layered rendering supports 2048 */ |
| 646 | return 12; |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 647 | case PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS: |
Marek Olšák | 4f1f323 | 2014-03-09 20:03:57 +0100 | [diff] [blame] | 648 | /* textures support 8192, but layered rendering supports 2048 */ |
| 649 | return 2048; |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 650 | |
Marek Olšák | 2c8ee2e | 2017-02-11 17:21:04 +0100 | [diff] [blame] | 651 | /* Viewports and render targets. */ |
Marek Olšák | a62cd69 | 2013-09-21 19:45:08 +0200 | [diff] [blame] | 652 | case PIPE_CAP_MAX_VIEWPORTS: |
Marek Olšák | 2ca5566 | 2016-04-10 04:26:50 +0200 | [diff] [blame] | 653 | return R600_MAX_VIEWPORTS; |
Józef Kucia | 14608ef | 2016-07-19 13:07:26 +0200 | [diff] [blame] | 654 | case PIPE_CAP_VIEWPORT_SUBPIXEL_BITS: |
Marek Olšák | 2c8ee2e | 2017-02-11 17:21:04 +0100 | [diff] [blame] | 655 | case PIPE_CAP_MAX_RENDER_TARGETS: |
Józef Kucia | 14608ef | 2016-07-19 13:07:26 +0200 | [diff] [blame] | 656 | return 8; |
Marek Olšák | a62cd69 | 2013-09-21 19:45:08 +0200 | [diff] [blame] | 657 | |
Ilia Mirkin | c2f9ad5 | 2014-04-09 14:58:53 -0400 | [diff] [blame] | 658 | case PIPE_CAP_MIN_TEXTURE_GATHER_OFFSET: |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 659 | case PIPE_CAP_MIN_TEXEL_OFFSET: |
Marek Olšák | c7b5a5c | 2014-06-06 03:00:18 +0200 | [diff] [blame] | 660 | return -32; |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 661 | |
Ilia Mirkin | c2f9ad5 | 2014-04-09 14:58:53 -0400 | [diff] [blame] | 662 | case PIPE_CAP_MAX_TEXTURE_GATHER_OFFSET: |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 663 | case PIPE_CAP_MAX_TEXEL_OFFSET: |
Marek Olšák | c7b5a5c | 2014-06-06 03:00:18 +0200 | [diff] [blame] | 664 | return 31; |
| 665 | |
Tom Stellard | 4e90bc9 | 2013-07-09 21:21:39 -0700 | [diff] [blame] | 666 | case PIPE_CAP_ENDIANNESS: |
| 667 | return PIPE_ENDIAN_LITTLE; |
Emil Velikov | de01443 | 2014-08-14 20:57:29 +0100 | [diff] [blame] | 668 | |
| 669 | case PIPE_CAP_VENDOR_ID: |
Marek Olšák | ec74dee | 2016-02-25 22:32:26 +0100 | [diff] [blame] | 670 | return ATI_VENDOR_ID; |
Emil Velikov | de01443 | 2014-08-14 20:57:29 +0100 | [diff] [blame] | 671 | case PIPE_CAP_DEVICE_ID: |
| 672 | return sscreen->b.info.pci_id; |
Emil Velikov | de01443 | 2014-08-14 20:57:29 +0100 | [diff] [blame] | 673 | case PIPE_CAP_VIDEO_MEMORY: |
| 674 | return sscreen->b.info.vram_size >> 20; |
Marek Olšák | dcb2b77 | 2016-02-29 20:22:37 +0100 | [diff] [blame] | 675 | case PIPE_CAP_PCI_GROUP: |
| 676 | return sscreen->b.info.pci_domain; |
| 677 | case PIPE_CAP_PCI_BUS: |
| 678 | return sscreen->b.info.pci_bus; |
| 679 | case PIPE_CAP_PCI_DEVICE: |
| 680 | return sscreen->b.info.pci_dev; |
| 681 | case PIPE_CAP_PCI_FUNCTION: |
| 682 | return sscreen->b.info.pci_func; |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 683 | } |
| 684 | return 0; |
| 685 | } |
| 686 | |
Brian Paul | 637e571 | 2017-03-05 12:13:02 -0700 | [diff] [blame] | 687 | static int si_get_shader_param(struct pipe_screen* pscreen, |
| 688 | enum pipe_shader_type shader, |
| 689 | enum pipe_shader_cap param) |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 690 | { |
Bas Nieuwenhuizen | 464cef5 | 2016-03-19 15:16:50 +0100 | [diff] [blame] | 691 | struct si_screen *sscreen = (struct si_screen *)pscreen; |
| 692 | |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 693 | switch(shader) |
| 694 | { |
| 695 | case PIPE_SHADER_FRAGMENT: |
| 696 | case PIPE_SHADER_VERTEX: |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 697 | case PIPE_SHADER_GEOMETRY: |
Marek Olšák | bac12c8 | 2015-02-22 18:46:53 +0100 | [diff] [blame] | 698 | case PIPE_SHADER_TESS_CTRL: |
| 699 | case PIPE_SHADER_TESS_EVAL: |
Marek Olšák | bac12c8 | 2015-02-22 18:46:53 +0100 | [diff] [blame] | 700 | break; |
Tom Stellard | 302f53d | 2012-10-25 13:50:10 -0400 | [diff] [blame] | 701 | case PIPE_SHADER_COMPUTE: |
| 702 | switch (param) { |
| 703 | case PIPE_SHADER_CAP_PREFERRED_IR: |
Tom Stellard | 1f4e48d | 2014-09-25 18:11:24 -0700 | [diff] [blame] | 704 | return PIPE_SHADER_IR_NATIVE; |
Samuel Pitoiset | 5e09ac7 | 2016-02-03 18:57:58 +0100 | [diff] [blame] | 705 | |
Bas Nieuwenhuizen | 464cef5 | 2016-03-19 15:16:50 +0100 | [diff] [blame] | 706 | case PIPE_SHADER_CAP_SUPPORTED_IRS: { |
| 707 | int ir = 1 << PIPE_SHADER_IR_NATIVE; |
Samuel Pitoiset | 5e09ac7 | 2016-02-03 18:57:58 +0100 | [diff] [blame] | 708 | |
Nicolai Hähnle | 7a0e543 | 2016-09-14 09:43:42 +0200 | [diff] [blame] | 709 | if (si_have_tgsi_compute(sscreen)) |
Bas Nieuwenhuizen | 464cef5 | 2016-03-19 15:16:50 +0100 | [diff] [blame] | 710 | ir |= 1 << PIPE_SHADER_IR_TGSI; |
| 711 | |
| 712 | return ir; |
| 713 | } |
Tom Stellard | da85ab4 | 2015-02-26 23:25:14 +0000 | [diff] [blame] | 714 | |
Tom Stellard | 72969e0 | 2014-08-07 15:31:17 -0400 | [diff] [blame] | 715 | case PIPE_SHADER_CAP_MAX_CONST_BUFFER_SIZE: { |
| 716 | uint64_t max_const_buffer_size; |
Bas Nieuwenhuizen | 1a5c8c2 | 2016-03-25 02:06:50 +0100 | [diff] [blame] | 717 | pscreen->get_compute_param(pscreen, PIPE_SHADER_IR_TGSI, |
Tom Stellard | 72969e0 | 2014-08-07 15:31:17 -0400 | [diff] [blame] | 718 | PIPE_COMPUTE_CAP_MAX_MEM_ALLOC_SIZE, |
| 719 | &max_const_buffer_size); |
Marek Olšák | 8a4ace4 | 2016-07-01 00:17:36 +0200 | [diff] [blame] | 720 | return MIN2(max_const_buffer_size, INT_MAX); |
Tom Stellard | 72969e0 | 2014-08-07 15:31:17 -0400 | [diff] [blame] | 721 | } |
Tom Stellard | 302f53d | 2012-10-25 13:50:10 -0400 | [diff] [blame] | 722 | default: |
Tom Stellard | 4c53d2a | 2015-03-21 00:27:16 +0000 | [diff] [blame] | 723 | /* If compute shaders don't require a special value |
| 724 | * for this cap, we can return the same value we |
| 725 | * do for other shader types. */ |
| 726 | break; |
Tom Stellard | 302f53d | 2012-10-25 13:50:10 -0400 | [diff] [blame] | 727 | } |
Tom Stellard | 4c53d2a | 2015-03-21 00:27:16 +0000 | [diff] [blame] | 728 | break; |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 729 | default: |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 730 | return 0; |
| 731 | } |
| 732 | |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 733 | switch (param) { |
Marek Olšák | 4e00e20 | 2016-11-04 12:41:34 +0100 | [diff] [blame] | 734 | /* Shader limits. */ |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 735 | case PIPE_SHADER_CAP_MAX_INSTRUCTIONS: |
| 736 | case PIPE_SHADER_CAP_MAX_ALU_INSTRUCTIONS: |
| 737 | case PIPE_SHADER_CAP_MAX_TEX_INSTRUCTIONS: |
| 738 | case PIPE_SHADER_CAP_MAX_TEX_INDIRECTIONS: |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 739 | case PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH: |
Marek Olšák | 3f6e006 | 2016-11-04 12:31:53 +0100 | [diff] [blame] | 740 | return 16384; |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 741 | case PIPE_SHADER_CAP_MAX_INPUTS: |
Marek Olšák | 22b8a77 | 2017-02-16 11:39:01 +0100 | [diff] [blame] | 742 | return shader == PIPE_SHADER_VERTEX ? SI_MAX_ATTRIBS : 32; |
Marek Olšák | 5f5b83c | 2014-10-01 20:28:17 +0200 | [diff] [blame] | 743 | case PIPE_SHADER_CAP_MAX_OUTPUTS: |
| 744 | return shader == PIPE_SHADER_FRAGMENT ? 8 : 32; |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 745 | case PIPE_SHADER_CAP_MAX_TEMPS: |
| 746 | return 256; /* Max native temporaries. */ |
Marek Olšák | 04f2c88 | 2014-07-24 20:32:08 +0200 | [diff] [blame] | 747 | case PIPE_SHADER_CAP_MAX_CONST_BUFFER_SIZE: |
| 748 | return 4096 * sizeof(float[4]); /* actually only memory limits this */ |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 749 | case PIPE_SHADER_CAP_MAX_CONST_BUFFERS: |
Marek Olšák | 0954d5e | 2016-04-19 02:14:53 +0200 | [diff] [blame] | 750 | return SI_NUM_CONST_BUFFERS; |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 751 | case PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS: |
Roland Scheidegger | 2983c03 | 2013-11-26 02:30:41 +0100 | [diff] [blame] | 752 | case PIPE_SHADER_CAP_MAX_SAMPLER_VIEWS: |
Marek Olšák | 0954d5e | 2016-04-19 02:14:53 +0200 | [diff] [blame] | 753 | return SI_NUM_SAMPLERS; |
Ilia Mirkin | 266d001 | 2015-09-26 20:27:42 -0400 | [diff] [blame] | 754 | case PIPE_SHADER_CAP_MAX_SHADER_BUFFERS: |
Marek Olšák | 12beef0 | 2017-04-25 02:18:10 +0200 | [diff] [blame] | 755 | return SI_NUM_SHADER_BUFFERS; |
Edward O'Callaghan | 5219eb1 | 2016-01-11 00:50:32 +1100 | [diff] [blame] | 756 | case PIPE_SHADER_CAP_MAX_SHADER_IMAGES: |
Marek Olšák | 12beef0 | 2017-04-25 02:18:10 +0200 | [diff] [blame] | 757 | return SI_NUM_IMAGES; |
Marek Olšák | 4e00e20 | 2016-11-04 12:41:34 +0100 | [diff] [blame] | 758 | case PIPE_SHADER_CAP_MAX_UNROLL_ITERATIONS_HINT: |
| 759 | return 32; |
| 760 | case PIPE_SHADER_CAP_PREFERRED_IR: |
Nicolai Hähnle | dfe237a | 2017-05-16 01:51:41 +0200 | [diff] [blame] | 761 | if (sscreen->b.debug_flags & DBG_NIR && |
| 762 | (shader == PIPE_SHADER_VERTEX || |
| 763 | shader == PIPE_SHADER_FRAGMENT)) |
| 764 | return PIPE_SHADER_IR_NIR; |
Marek Olšák | 4e00e20 | 2016-11-04 12:41:34 +0100 | [diff] [blame] | 765 | return PIPE_SHADER_IR_TGSI; |
Marek Olšák | 74e39de | 2016-10-28 23:08:50 +0200 | [diff] [blame] | 766 | case PIPE_SHADER_CAP_LOWER_IF_THRESHOLD: |
| 767 | return 3; |
Marek Olšák | 4e00e20 | 2016-11-04 12:41:34 +0100 | [diff] [blame] | 768 | |
| 769 | /* Supported boolean features. */ |
| 770 | case PIPE_SHADER_CAP_TGSI_CONT_SUPPORTED: |
| 771 | case PIPE_SHADER_CAP_TGSI_SQRT_SUPPORTED: |
Marek Olšák | 4e00e20 | 2016-11-04 12:41:34 +0100 | [diff] [blame] | 772 | case PIPE_SHADER_CAP_INDIRECT_TEMP_ADDR: |
| 773 | case PIPE_SHADER_CAP_INDIRECT_CONST_ADDR: |
| 774 | case PIPE_SHADER_CAP_INTEGERS: |
| 775 | case PIPE_SHADER_CAP_TGSI_FMA_SUPPORTED: |
| 776 | case PIPE_SHADER_CAP_TGSI_ANY_INOUT_DECL_RANGE: |
Samuel Pitoiset | 0bceefc | 2017-04-25 00:31:48 +0200 | [diff] [blame] | 777 | case PIPE_SHADER_CAP_TGSI_SKIP_MERGE_REGISTERS: |
Marek Olšák | 4e00e20 | 2016-11-04 12:41:34 +0100 | [diff] [blame] | 778 | return 1; |
| 779 | |
Marek Olšák | 4e00e20 | 2016-11-04 12:41:34 +0100 | [diff] [blame] | 780 | case PIPE_SHADER_CAP_INDIRECT_INPUT_ADDR: |
Marek Olšák | facfab2 | 2017-07-05 23:33:13 +0200 | [diff] [blame] | 781 | /* TODO: Indirect indexing of GS inputs is unimplemented. */ |
| 782 | return shader != PIPE_SHADER_GEOMETRY && |
| 783 | (sscreen->llvm_has_working_vgpr_indexing || |
| 784 | /* TCS and TES load inputs directly from LDS or |
| 785 | * offchip memory, so indirect indexing is trivial. */ |
| 786 | shader == PIPE_SHADER_TESS_CTRL || |
| 787 | shader == PIPE_SHADER_TESS_EVAL); |
| 788 | |
| 789 | case PIPE_SHADER_CAP_INDIRECT_OUTPUT_ADDR: |
| 790 | return sscreen->llvm_has_working_vgpr_indexing || |
| 791 | /* TCS stores outputs directly to memory. */ |
| 792 | shader == PIPE_SHADER_TESS_CTRL; |
Marek Olšák | 4e00e20 | 2016-11-04 12:41:34 +0100 | [diff] [blame] | 793 | |
| 794 | /* Unsupported boolean features. */ |
Marek Olšák | 4e00e20 | 2016-11-04 12:41:34 +0100 | [diff] [blame] | 795 | case PIPE_SHADER_CAP_SUBROUTINES: |
| 796 | case PIPE_SHADER_CAP_SUPPORTED_IRS: |
| 797 | case PIPE_SHADER_CAP_TGSI_DROUND_SUPPORTED: |
| 798 | case PIPE_SHADER_CAP_TGSI_DFRACEXP_DLDEXP_SUPPORTED: |
| 799 | return 0; |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 800 | } |
| 801 | return 0; |
| 802 | } |
| 803 | |
Nicolai Hähnle | acd0938 | 2017-05-16 02:04:48 +0200 | [diff] [blame] | 804 | static const struct nir_shader_compiler_options nir_options = { |
| 805 | .vertex_id_zero_based = true, |
| 806 | .lower_scmp = true, |
| 807 | .lower_flrp32 = true, |
| 808 | .lower_fsat = true, |
| 809 | .lower_fdiv = true, |
| 810 | .lower_sub = true, |
| 811 | .lower_pack_snorm_2x16 = true, |
| 812 | .lower_pack_snorm_4x8 = true, |
| 813 | .lower_pack_unorm_2x16 = true, |
| 814 | .lower_pack_unorm_4x8 = true, |
| 815 | .lower_unpack_snorm_2x16 = true, |
| 816 | .lower_unpack_snorm_4x8 = true, |
| 817 | .lower_unpack_unorm_2x16 = true, |
| 818 | .lower_unpack_unorm_4x8 = true, |
| 819 | .lower_extract_byte = true, |
| 820 | .lower_extract_word = true, |
| 821 | .max_unroll_iterations = 32, |
| 822 | .native_integers = true, |
| 823 | }; |
| 824 | |
| 825 | static const void * |
| 826 | si_get_compiler_options(struct pipe_screen *screen, |
| 827 | enum pipe_shader_ir ir, |
| 828 | enum pipe_shader_type shader) |
| 829 | { |
| 830 | assert(ir == PIPE_SHADER_IR_NIR); |
| 831 | return &nir_options; |
| 832 | } |
| 833 | |
Andreas Hartmetz | eb0ddb6 | 2014-01-07 03:07:55 +0100 | [diff] [blame] | 834 | static void si_destroy_screen(struct pipe_screen* pscreen) |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 835 | { |
Andreas Hartmetz | aa7ae4f | 2014-01-11 16:01:11 +0100 | [diff] [blame] | 836 | struct si_screen *sscreen = (struct si_screen *)pscreen; |
Marek Olšák | 70de433 | 2016-01-27 00:29:53 +0100 | [diff] [blame] | 837 | struct si_shader_part *parts[] = { |
| 838 | sscreen->vs_prologs, |
Marek Olšák | eb10919 | 2016-01-27 00:38:03 +0100 | [diff] [blame] | 839 | sscreen->tcs_epilogs, |
Nicolai Hähnle | 908f92a | 2016-10-31 12:50:09 +0100 | [diff] [blame] | 840 | sscreen->gs_prologs, |
Marek Olšák | 4636d9b | 2016-02-15 23:57:54 +0100 | [diff] [blame] | 841 | sscreen->ps_prologs, |
Marek Olšák | e79bb74 | 2016-01-27 00:50:29 +0100 | [diff] [blame] | 842 | sscreen->ps_epilogs |
Marek Olšák | 70de433 | 2016-01-27 00:29:53 +0100 | [diff] [blame] | 843 | }; |
| 844 | unsigned i; |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 845 | |
Marek Olšák | ac330d4 | 2014-04-09 00:26:32 +0200 | [diff] [blame] | 846 | if (!sscreen->b.ws->unref(sscreen->b.ws)) |
Christian König | 4871128 | 2013-09-25 13:59:56 +0200 | [diff] [blame] | 847 | return; |
| 848 | |
Marek Olšák | e9c6953 | 2017-03-03 00:24:03 +0100 | [diff] [blame] | 849 | util_queue_destroy(&sscreen->shader_compiler_queue); |
Marek Olšák | 86cc809 | 2017-05-31 13:18:53 +0200 | [diff] [blame] | 850 | util_queue_destroy(&sscreen->shader_compiler_queue_low_priority); |
Marek Olšák | 5c92c21 | 2016-06-11 19:57:40 +0200 | [diff] [blame] | 851 | |
| 852 | for (i = 0; i < ARRAY_SIZE(sscreen->tm); i++) |
| 853 | if (sscreen->tm[i]) |
| 854 | LLVMDisposeTargetMachine(sscreen->tm[i]); |
| 855 | |
Marek Olšák | 86cc809 | 2017-05-31 13:18:53 +0200 | [diff] [blame] | 856 | for (i = 0; i < ARRAY_SIZE(sscreen->tm_low_priority); i++) |
| 857 | if (sscreen->tm_low_priority[i]) |
| 858 | LLVMDisposeTargetMachine(sscreen->tm_low_priority[i]); |
| 859 | |
Marek Olšák | 70de433 | 2016-01-27 00:29:53 +0100 | [diff] [blame] | 860 | /* Free shader parts. */ |
| 861 | for (i = 0; i < ARRAY_SIZE(parts); i++) { |
| 862 | while (parts[i]) { |
| 863 | struct si_shader_part *part = parts[i]; |
| 864 | |
| 865 | parts[i] = part->next; |
| 866 | radeon_shader_binary_clean(&part->binary); |
| 867 | FREE(part); |
| 868 | } |
| 869 | } |
Timothy Arceri | be18828 | 2017-03-05 12:32:04 +1100 | [diff] [blame] | 870 | mtx_destroy(&sscreen->shader_parts_mutex); |
Marek Olšák | ff360a5 | 2016-02-11 15:49:34 +0100 | [diff] [blame] | 871 | si_destroy_shader_cache(sscreen); |
Tom Stellard | e28f9d0 | 2015-01-07 13:49:12 -0500 | [diff] [blame] | 872 | r600_destroy_common_screen(&sscreen->b); |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 873 | } |
| 874 | |
Marek Olšák | 0608304 | 2015-10-19 02:45:56 +0200 | [diff] [blame] | 875 | static bool si_init_gs_info(struct si_screen *sscreen) |
| 876 | { |
| 877 | switch (sscreen->b.family) { |
| 878 | case CHIP_OLAND: |
| 879 | case CHIP_HAINAN: |
| 880 | case CHIP_KAVERI: |
| 881 | case CHIP_KABINI: |
| 882 | case CHIP_MULLINS: |
| 883 | case CHIP_ICELAND: |
| 884 | case CHIP_CARRIZO: |
Alex Deucher | 830e57b | 2015-10-23 18:31:57 -0400 | [diff] [blame] | 885 | case CHIP_STONEY: |
Marek Olšák | 0608304 | 2015-10-19 02:45:56 +0200 | [diff] [blame] | 886 | sscreen->gs_table_depth = 16; |
| 887 | return true; |
| 888 | case CHIP_TAHITI: |
| 889 | case CHIP_PITCAIRN: |
| 890 | case CHIP_VERDE: |
| 891 | case CHIP_BONAIRE: |
| 892 | case CHIP_HAWAII: |
| 893 | case CHIP_TONGA: |
| 894 | case CHIP_FIJI: |
Sonny Jiang | 42e442d | 2015-11-04 16:13:07 -0500 | [diff] [blame] | 895 | case CHIP_POLARIS10: |
| 896 | case CHIP_POLARIS11: |
Junwei Zhang | 018ead4 | 2016-12-19 13:51:25 -0500 | [diff] [blame] | 897 | case CHIP_POLARIS12: |
Marek Olšák | c9b004a | 2016-10-15 14:17:56 +0200 | [diff] [blame] | 898 | case CHIP_VEGA10: |
Marek Olšák | 7622181 | 2017-02-27 22:26:10 +0100 | [diff] [blame] | 899 | case CHIP_RAVEN: |
Marek Olšák | 0608304 | 2015-10-19 02:45:56 +0200 | [diff] [blame] | 900 | sscreen->gs_table_depth = 32; |
| 901 | return true; |
| 902 | default: |
| 903 | return false; |
| 904 | } |
| 905 | } |
| 906 | |
Marek Olšák | ad8af99 | 2016-07-31 00:46:09 +0200 | [diff] [blame] | 907 | static void si_handle_env_var_force_family(struct si_screen *sscreen) |
| 908 | { |
| 909 | const char *family = debug_get_option("SI_FORCE_FAMILY", NULL); |
| 910 | unsigned i; |
| 911 | |
| 912 | if (!family) |
| 913 | return; |
| 914 | |
| 915 | for (i = CHIP_TAHITI; i < CHIP_LAST; i++) { |
| 916 | if (!strcmp(family, r600_get_llvm_processor_name(i))) { |
| 917 | /* Override family and chip_class. */ |
| 918 | sscreen->b.family = sscreen->b.info.family = i; |
| 919 | |
Marek Olšák | 68d6d09 | 2016-10-15 13:57:59 +0200 | [diff] [blame] | 920 | if (i >= CHIP_VEGA10) |
| 921 | sscreen->b.chip_class = sscreen->b.info.chip_class = GFX9; |
| 922 | else if (i >= CHIP_TONGA) |
Marek Olšák | ad8af99 | 2016-07-31 00:46:09 +0200 | [diff] [blame] | 923 | sscreen->b.chip_class = sscreen->b.info.chip_class = VI; |
| 924 | else if (i >= CHIP_BONAIRE) |
| 925 | sscreen->b.chip_class = sscreen->b.info.chip_class = CIK; |
| 926 | else |
| 927 | sscreen->b.chip_class = sscreen->b.info.chip_class = SI; |
| 928 | |
| 929 | /* Don't submit any IBs. */ |
| 930 | setenv("RADEON_NOOP", "1", 1); |
| 931 | return; |
| 932 | } |
| 933 | } |
| 934 | |
| 935 | fprintf(stderr, "radeonsi: Unknown family: %s\n", family); |
| 936 | exit(1); |
| 937 | } |
| 938 | |
Marek Olšák | 322eb13 | 2017-03-27 16:53:19 +0200 | [diff] [blame] | 939 | static void si_test_vmfault(struct si_screen *sscreen) |
| 940 | { |
| 941 | struct pipe_context *ctx = sscreen->b.aux_context; |
| 942 | struct si_context *sctx = (struct si_context *)ctx; |
| 943 | struct pipe_resource *buf = |
| 944 | pipe_buffer_create(&sscreen->b.b, 0, PIPE_USAGE_DEFAULT, 64); |
| 945 | |
| 946 | if (!buf) { |
| 947 | puts("Buffer allocation failed."); |
| 948 | exit(1); |
| 949 | } |
| 950 | |
| 951 | r600_resource(buf)->gpu_address = 0; /* cause a VM fault */ |
| 952 | |
| 953 | if (sscreen->b.debug_flags & DBG_TEST_VMFAULT_CP) { |
| 954 | si_copy_buffer(sctx, buf, buf, 0, 4, 4, 0); |
| 955 | ctx->flush(ctx, NULL, 0); |
| 956 | puts("VM fault test: CP - done."); |
| 957 | } |
| 958 | if (sscreen->b.debug_flags & DBG_TEST_VMFAULT_SDMA) { |
| 959 | sctx->b.dma_clear_buffer(ctx, buf, 0, 4, 0); |
| 960 | ctx->flush(ctx, NULL, 0); |
| 961 | puts("VM fault test: SDMA - done."); |
| 962 | } |
| 963 | if (sscreen->b.debug_flags & DBG_TEST_VMFAULT_SHADER) { |
| 964 | util_test_constant_buffer(ctx, buf); |
| 965 | puts("VM fault test: Shader - done."); |
| 966 | } |
| 967 | exit(0); |
| 968 | } |
| 969 | |
Marek Olšák | a98a04e | 2017-06-21 00:38:06 +0200 | [diff] [blame] | 970 | struct pipe_screen *radeonsi_screen_create(struct radeon_winsys *ws, |
Nicolai Hähnle | bc7f41e | 2017-06-28 14:47:32 +0200 | [diff] [blame] | 971 | const struct pipe_screen_config *config) |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 972 | { |
Andreas Hartmetz | aa7ae4f | 2014-01-11 16:01:11 +0100 | [diff] [blame] | 973 | struct si_screen *sscreen = CALLOC_STRUCT(si_screen); |
Marek Olšák | 86cc809 | 2017-05-31 13:18:53 +0200 | [diff] [blame] | 974 | unsigned num_threads, num_compiler_threads, num_compiler_threads_lowprio, i; |
Michel Dänzer | d64adc3 | 2015-03-26 11:32:59 +0900 | [diff] [blame] | 975 | |
Edward O'Callaghan | 13eb5f5 | 2015-12-04 22:08:22 +1100 | [diff] [blame] | 976 | if (!sscreen) { |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 977 | return NULL; |
| 978 | } |
| 979 | |
Marek Olšák | 09fc5d6 | 2013-09-22 21:47:35 +0200 | [diff] [blame] | 980 | /* Set functions first. */ |
Marek Olšák | 1c8f7d3 | 2017-03-02 01:28:51 +0100 | [diff] [blame] | 981 | sscreen->b.b.context_create = si_pipe_create_context; |
Andreas Hartmetz | aa7ae4f | 2014-01-11 16:01:11 +0100 | [diff] [blame] | 982 | sscreen->b.b.destroy = si_destroy_screen; |
Andreas Hartmetz | aa7ae4f | 2014-01-11 16:01:11 +0100 | [diff] [blame] | 983 | sscreen->b.b.get_param = si_get_param; |
| 984 | sscreen->b.b.get_shader_param = si_get_shader_param; |
Nicolai Hähnle | acd0938 | 2017-05-16 02:04:48 +0200 | [diff] [blame] | 985 | sscreen->b.b.get_compiler_options = si_get_compiler_options; |
Tom Stellard | 7b4592a | 2014-01-28 06:51:50 -0800 | [diff] [blame] | 986 | sscreen->b.b.resource_create = r600_resource_create_common; |
Marek Olšák | 09fc5d6 | 2013-09-22 21:47:35 +0200 | [diff] [blame] | 987 | |
Marek Olšák | ec74dee | 2016-02-25 22:32:26 +0100 | [diff] [blame] | 988 | si_init_screen_state_functions(sscreen); |
| 989 | |
Nicolai Hähnle | bc7f41e | 2017-06-28 14:47:32 +0200 | [diff] [blame] | 990 | if (!r600_common_screen_init(&sscreen->b, ws, config->flags) || |
Marek Olšák | ff360a5 | 2016-02-11 15:49:34 +0100 | [diff] [blame] | 991 | !si_init_gs_info(sscreen) || |
| 992 | !si_init_shader_cache(sscreen)) { |
Andreas Hartmetz | aa7ae4f | 2014-01-11 16:01:11 +0100 | [diff] [blame] | 993 | FREE(sscreen); |
Marek Olšák | 1bb77f8 | 2013-09-22 22:12:18 +0200 | [diff] [blame] | 994 | return NULL; |
| 995 | } |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 996 | |
Nicolai Hähnle | 53485c2 | 2017-06-28 17:37:53 +0200 | [diff] [blame] | 997 | if (driQueryOptionb(config->options, "radeonsi_enable_sisched")) |
| 998 | sscreen->b.debug_flags |= DBG_SI_SCHED; |
| 999 | |
Marek Olšák | 6f2947f | 2017-05-27 12:13:34 +0200 | [diff] [blame] | 1000 | /* Only enable as many threads as we have target machines, but at most |
| 1001 | * the number of CPUs - 1 if there is more than one. |
| 1002 | */ |
Marek Olšák | 86cc809 | 2017-05-31 13:18:53 +0200 | [diff] [blame] | 1003 | num_threads = sysconf(_SC_NPROCESSORS_ONLN); |
| 1004 | num_threads = MAX2(1, num_threads - 1); |
| 1005 | num_compiler_threads = MIN2(num_threads, ARRAY_SIZE(sscreen->tm)); |
| 1006 | num_compiler_threads_lowprio = |
| 1007 | MIN2(num_threads, ARRAY_SIZE(sscreen->tm_low_priority)); |
Marek Olšák | e9c6953 | 2017-03-03 00:24:03 +0100 | [diff] [blame] | 1008 | |
| 1009 | if (!util_queue_init(&sscreen->shader_compiler_queue, "si_shader", |
Marek Olšák | 9f320e0 | 2017-07-10 22:16:26 +0200 | [diff] [blame] | 1010 | 32, num_compiler_threads, |
| 1011 | UTIL_QUEUE_INIT_RESIZE_IF_FULL)) { |
Marek Olšák | e9c6953 | 2017-03-03 00:24:03 +0100 | [diff] [blame] | 1012 | si_destroy_shader_cache(sscreen); |
| 1013 | FREE(sscreen); |
| 1014 | return NULL; |
| 1015 | } |
| 1016 | |
Marek Olšák | 86cc809 | 2017-05-31 13:18:53 +0200 | [diff] [blame] | 1017 | if (!util_queue_init(&sscreen->shader_compiler_queue_low_priority, |
| 1018 | "si_shader_low", |
Marek Olšák | ed2b3f5 | 2017-07-24 23:56:30 +0200 | [diff] [blame] | 1019 | 32, num_compiler_threads_lowprio, |
Marek Olšák | ecec21a | 2017-07-17 16:03:29 -0400 | [diff] [blame] | 1020 | UTIL_QUEUE_INIT_RESIZE_IF_FULL | |
| 1021 | UTIL_QUEUE_INIT_USE_MINIMUM_PRIORITY)) { |
Marek Olšák | 86cc809 | 2017-05-31 13:18:53 +0200 | [diff] [blame] | 1022 | si_destroy_shader_cache(sscreen); |
| 1023 | FREE(sscreen); |
| 1024 | return NULL; |
| 1025 | } |
| 1026 | |
Marek Olšák | ad8af99 | 2016-07-31 00:46:09 +0200 | [diff] [blame] | 1027 | si_handle_env_var_force_family(sscreen); |
| 1028 | |
Marek Olšák | 3eacbc52 | 2016-06-21 21:29:39 +0200 | [diff] [blame] | 1029 | if (!debug_get_bool_option("RADEON_DISABLE_PERFCOUNTERS", false)) |
Nicolai Hähnle | ad22006 | 2015-11-25 15:30:03 +0100 | [diff] [blame] | 1030 | si_init_perfcounters(sscreen); |
| 1031 | |
Marek Olšák | dd56d04 | 2016-06-28 14:11:12 +0200 | [diff] [blame] | 1032 | /* Hawaii has a bug with offchip buffers > 256 that can be worked |
| 1033 | * around by setting 4K granularity. |
| 1034 | */ |
| 1035 | sscreen->tess_offchip_block_dw_size = |
| 1036 | sscreen->b.family == CHIP_HAWAII ? 4096 : 8192; |
| 1037 | |
Marek Olšák | eff81cb | 2016-06-28 14:19:04 +0200 | [diff] [blame] | 1038 | sscreen->has_distributed_tess = |
| 1039 | sscreen->b.chip_class >= VI && |
| 1040 | sscreen->b.info.max_se >= 2; |
| 1041 | |
Nicolai Hähnle | 96bbb62 | 2016-07-29 17:59:11 +0100 | [diff] [blame] | 1042 | sscreen->has_draw_indirect_multi = |
| 1043 | (sscreen->b.family >= CHIP_POLARIS10) || |
| 1044 | (sscreen->b.chip_class == VI && |
| 1045 | sscreen->b.info.pfp_fw_version >= 121 && |
| 1046 | sscreen->b.info.me_fw_version >= 87) || |
| 1047 | (sscreen->b.chip_class == CIK && |
| 1048 | sscreen->b.info.pfp_fw_version >= 211 && |
| 1049 | sscreen->b.info.me_fw_version >= 173) || |
| 1050 | (sscreen->b.chip_class == SI && |
Nicolai Hähnle | 65fbaab | 2017-07-25 16:47:27 +0200 | [diff] [blame] | 1051 | sscreen->b.info.pfp_fw_version >= 79 && |
| 1052 | sscreen->b.info.me_fw_version >= 142); |
Nicolai Hähnle | 96bbb62 | 2016-07-29 17:59:11 +0100 | [diff] [blame] | 1053 | |
Marek Olšák | 12beef0 | 2017-04-25 02:18:10 +0200 | [diff] [blame] | 1054 | sscreen->has_ds_bpermute = sscreen->b.chip_class >= VI; |
Marek Olšák | 829bd77 | 2017-02-27 23:17:07 +0100 | [diff] [blame] | 1055 | sscreen->has_msaa_sample_loc_bug = (sscreen->b.family >= CHIP_POLARIS10 && |
| 1056 | sscreen->b.family <= CHIP_POLARIS12) || |
Marek Olšák | 7622181 | 2017-02-27 22:26:10 +0100 | [diff] [blame] | 1057 | sscreen->b.family == CHIP_VEGA10 || |
| 1058 | sscreen->b.family == CHIP_RAVEN; |
Marek Olšák | facfab2 | 2017-07-05 23:33:13 +0200 | [diff] [blame] | 1059 | /* While it would be nice not to have this flag, we are constrained |
| 1060 | * by the reality that LLVM 5.0 doesn't have working VGPR indexing |
| 1061 | * on GFX9. |
| 1062 | */ |
| 1063 | sscreen->llvm_has_working_vgpr_indexing = sscreen->b.chip_class <= VI; |
Marek Olšák | 829bd77 | 2017-02-27 23:17:07 +0100 | [diff] [blame] | 1064 | |
Andreas Hartmetz | aa7ae4f | 2014-01-11 16:01:11 +0100 | [diff] [blame] | 1065 | sscreen->b.has_cp_dma = true; |
Marek Olšák | a66d934 | 2014-07-08 02:50:57 +0200 | [diff] [blame] | 1066 | sscreen->b.has_streamout = true; |
Marek Olšák | 6d21fd5 | 2016-11-06 20:08:24 +0100 | [diff] [blame] | 1067 | |
| 1068 | /* Some chips have RB+ registers, but don't support RB+. Those must |
| 1069 | * always disable it. |
| 1070 | */ |
| 1071 | if (sscreen->b.family == CHIP_STONEY || |
| 1072 | sscreen->b.chip_class >= GFX9) { |
| 1073 | sscreen->b.has_rbplus = true; |
| 1074 | |
| 1075 | sscreen->b.rbplus_allowed = |
| 1076 | !(sscreen->b.debug_flags & DBG_NO_RB_PLUS) && |
Marek Olšák | 7622181 | 2017-02-27 22:26:10 +0100 | [diff] [blame] | 1077 | (sscreen->b.family == CHIP_STONEY || |
| 1078 | sscreen->b.family == CHIP_RAVEN); |
Marek Olšák | 6d21fd5 | 2016-11-06 20:08:24 +0100 | [diff] [blame] | 1079 | } |
| 1080 | |
Timothy Arceri | 75b47dd | 2017-03-05 12:00:15 +1100 | [diff] [blame] | 1081 | (void) mtx_init(&sscreen->shader_parts_mutex, mtx_plain); |
Marek Olšák | 9aaf28d | 2016-01-28 01:29:59 +0100 | [diff] [blame] | 1082 | sscreen->use_monolithic_shaders = |
Marek Olšák | 9aaf28d | 2016-01-28 01:29:59 +0100 | [diff] [blame] | 1083 | (sscreen->b.debug_flags & DBG_MONOLITHIC_SHADERS) != 0; |
Marek Olšák | bba39d8 | 2013-11-28 15:09:35 +0100 | [diff] [blame] | 1084 | |
Nicolai Hähnle | 8e4de00 | 2016-09-15 16:24:17 +0200 | [diff] [blame] | 1085 | sscreen->b.barrier_flags.cp_to_L2 = SI_CONTEXT_INV_SMEM_L1 | |
Marek Olšák | d7141d8 | 2017-06-06 12:13:40 +0200 | [diff] [blame] | 1086 | SI_CONTEXT_INV_VMEM_L1; |
| 1087 | if (sscreen->b.chip_class <= VI) |
| 1088 | sscreen->b.barrier_flags.cp_to_L2 |= SI_CONTEXT_INV_GLOBAL_L2; |
| 1089 | |
Nicolai Hähnle | 8e4de00 | 2016-09-15 16:24:17 +0200 | [diff] [blame] | 1090 | sscreen->b.barrier_flags.compute_to_L2 = SI_CONTEXT_CS_PARTIAL_FLUSH; |
| 1091 | |
Marek Olšák | 3eacbc52 | 2016-06-21 21:29:39 +0200 | [diff] [blame] | 1092 | if (debug_get_bool_option("RADEON_DUMP_SHADERS", false)) |
Andreas Hartmetz | aa7ae4f | 2014-01-11 16:01:11 +0100 | [diff] [blame] | 1093 | sscreen->b.debug_flags |= DBG_FS | DBG_VS | DBG_GS | DBG_PS | DBG_CS; |
Marek Olšák | 0cb9de1 | 2013-09-22 15:34:12 +0200 | [diff] [blame] | 1094 | |
Marek Olšák | 5c92c21 | 2016-06-11 19:57:40 +0200 | [diff] [blame] | 1095 | for (i = 0; i < num_compiler_threads; i++) |
| 1096 | sscreen->tm[i] = si_create_llvm_target_machine(sscreen); |
Marek Olšák | 86cc809 | 2017-05-31 13:18:53 +0200 | [diff] [blame] | 1097 | for (i = 0; i < num_compiler_threads_lowprio; i++) |
| 1098 | sscreen->tm_low_priority[i] = si_create_llvm_target_machine(sscreen); |
Marek Olšák | 5c92c21 | 2016-06-11 19:57:40 +0200 | [diff] [blame] | 1099 | |
Marek Olšák | b893bbf | 2013-10-03 16:39:50 +0200 | [diff] [blame] | 1100 | /* Create the auxiliary context. This must be done last. */ |
Marek Olšák | 1c8f7d3 | 2017-03-02 01:28:51 +0100 | [diff] [blame] | 1101 | sscreen->b.aux_context = si_create_context(&sscreen->b.b, 0); |
Marek Olšák | b893bbf | 2013-10-03 16:39:50 +0200 | [diff] [blame] | 1102 | |
Marek Olšák | 3af28e5 | 2014-09-05 20:15:16 +0200 | [diff] [blame] | 1103 | if (sscreen->b.debug_flags & DBG_TEST_DMA) |
| 1104 | r600_test_dma(&sscreen->b); |
| 1105 | |
Marek Olšák | 322eb13 | 2017-03-27 16:53:19 +0200 | [diff] [blame] | 1106 | if (sscreen->b.debug_flags & (DBG_TEST_VMFAULT_CP | |
| 1107 | DBG_TEST_VMFAULT_SDMA | |
| 1108 | DBG_TEST_VMFAULT_SHADER)) |
| 1109 | si_test_vmfault(sscreen); |
| 1110 | |
Andreas Hartmetz | aa7ae4f | 2014-01-11 16:01:11 +0100 | [diff] [blame] | 1111 | return &sscreen->b.b; |
Tom Stellard | a75c616 | 2012-01-06 17:38:37 -0500 | [diff] [blame] | 1112 | } |