Alyssa Rosenzweig | 293f251 | 2020-07-09 13:42:25 -0400 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2020 Collabora, Ltd. |
| 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 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| 8 | * and/or sell copies of the Software, and to permit persons to whom the |
| 9 | * 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 NONINFRINGEMENT. IN NO EVENT SHALL |
| 18 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| 19 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| 20 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
| 21 | * SOFTWARE. |
| 22 | * |
| 23 | * Authors: |
| 24 | * Alyssa Rosenzweig <alyssa.rosenzweig@collabora.com> |
| 25 | */ |
| 26 | |
| 27 | #include <math.h> |
| 28 | #include <stdio.h> |
| 29 | #include "pan_encoder.h" |
| 30 | #include "pan_pool.h" |
| 31 | #include "pan_scoreboard.h" |
| 32 | #include "pan_texture.h" |
| 33 | #include "panfrost-quirks.h" |
| 34 | #include "../midgard/midgard_compile.h" |
| 35 | #include "compiler/nir/nir_builder.h" |
| 36 | #include "util/u_math.h" |
| 37 | |
| 38 | /* On Midgard, the native blit infrastructure (via MFBD preloads) is broken or |
| 39 | * missing in many cases. We instead use software paths as fallbacks to |
| 40 | * implement blits, which are done as TILER jobs. No vertex shader is |
| 41 | * necessary since we can supply screen-space coordinates directly. |
| 42 | * |
| 43 | * This is primarily designed as a fallback for preloads but could be extended |
| 44 | * for other clears/blits if needed in the future. */ |
| 45 | |
| 46 | static void |
| 47 | panfrost_build_blit_shader(panfrost_program *program, unsigned gpu_id, gl_frag_result loc, nir_alu_type T, bool ms) |
| 48 | { |
| 49 | bool is_colour = loc >= FRAG_RESULT_DATA0; |
| 50 | |
Alyssa Rosenzweig | c92be29 | 2020-08-26 16:48:13 -0400 | [diff] [blame] | 51 | nir_builder _b; |
| 52 | nir_builder_init_simple_shader(&_b, NULL, MESA_SHADER_FRAGMENT, &midgard_nir_options); |
| 53 | nir_builder *b = &_b; |
| 54 | nir_shader *shader = b->shader; |
Alyssa Rosenzweig | 293f251 | 2020-07-09 13:42:25 -0400 | [diff] [blame] | 55 | |
Icecream95 | 90eaaad | 2020-09-26 12:16:02 +1200 | [diff] [blame] | 56 | shader->info.internal = true; |
| 57 | |
Alyssa Rosenzweig | 293f251 | 2020-07-09 13:42:25 -0400 | [diff] [blame] | 58 | nir_variable *c_src = nir_variable_create(shader, nir_var_shader_in, glsl_vector_type(GLSL_TYPE_FLOAT, 2), "coord"); |
| 59 | nir_variable *c_out = nir_variable_create(shader, nir_var_shader_out, glsl_vector_type( |
| 60 | GLSL_TYPE_FLOAT, is_colour ? 4 : 1), "out"); |
| 61 | |
| 62 | c_src->data.location = VARYING_SLOT_TEX0; |
| 63 | c_out->data.location = loc; |
| 64 | |
Alyssa Rosenzweig | 293f251 | 2020-07-09 13:42:25 -0400 | [diff] [blame] | 65 | nir_ssa_def *coord = nir_load_var(b, c_src); |
| 66 | |
| 67 | nir_tex_instr *tex = nir_tex_instr_create(shader, ms ? 3 : 1); |
| 68 | |
| 69 | tex->dest_type = T; |
| 70 | |
| 71 | if (ms) { |
| 72 | tex->src[0].src_type = nir_tex_src_coord; |
| 73 | tex->src[0].src = nir_src_for_ssa(nir_f2i32(b, coord)); |
| 74 | tex->coord_components = 2; |
| 75 | |
| 76 | tex->src[1].src_type = nir_tex_src_ms_index; |
| 77 | tex->src[1].src = nir_src_for_ssa(nir_load_sample_id(b)); |
| 78 | |
| 79 | tex->src[2].src_type = nir_tex_src_lod; |
| 80 | tex->src[2].src = nir_src_for_ssa(nir_imm_int(b, 0)); |
| 81 | tex->sampler_dim = GLSL_SAMPLER_DIM_MS; |
| 82 | tex->op = nir_texop_txf_ms; |
| 83 | } else { |
| 84 | tex->op = nir_texop_tex; |
| 85 | |
| 86 | tex->src[0].src_type = nir_tex_src_coord; |
| 87 | tex->src[0].src = nir_src_for_ssa(coord); |
| 88 | tex->coord_components = 2; |
| 89 | |
| 90 | tex->sampler_dim = GLSL_SAMPLER_DIM_2D; |
| 91 | } |
| 92 | |
| 93 | nir_ssa_dest_init(&tex->instr, &tex->dest, 4, 32, NULL); |
| 94 | nir_builder_instr_insert(b, &tex->instr); |
| 95 | |
| 96 | if (is_colour) |
| 97 | nir_store_var(b, c_out, &tex->dest.ssa, 0xFF); |
| 98 | else |
| 99 | nir_store_var(b, c_out, nir_channel(b, &tex->dest.ssa, 0), 0xFF); |
| 100 | |
Boris Brezillon | 0a74a04 | 2020-10-08 10:09:56 +0200 | [diff] [blame] | 101 | struct panfrost_compile_inputs inputs = { |
| 102 | .gpu_id = gpu_id, |
| 103 | }; |
| 104 | |
| 105 | midgard_compile_shader_nir(shader, program, &inputs); |
Alyssa Rosenzweig | da6d0e3 | 2020-08-18 08:10:25 -0400 | [diff] [blame] | 106 | ralloc_free(shader); |
Alyssa Rosenzweig | 293f251 | 2020-07-09 13:42:25 -0400 | [diff] [blame] | 107 | } |
| 108 | |
| 109 | /* Compile and upload all possible blit shaders ahead-of-time to reduce draw |
| 110 | * time overhead. There's only ~30 of them at the moment, so this is fine */ |
| 111 | |
| 112 | void |
| 113 | panfrost_init_blit_shaders(struct panfrost_device *dev) |
| 114 | { |
| 115 | static const struct { |
| 116 | gl_frag_result loc; |
| 117 | unsigned types; |
| 118 | } shader_descs[] = { |
| 119 | { FRAG_RESULT_DEPTH, 1 << PAN_BLIT_FLOAT }, |
| 120 | { FRAG_RESULT_STENCIL, 1 << PAN_BLIT_UINT }, |
| 121 | { FRAG_RESULT_DATA0, ~0 }, |
| 122 | { FRAG_RESULT_DATA1, ~0 }, |
| 123 | { FRAG_RESULT_DATA2, ~0 }, |
| 124 | { FRAG_RESULT_DATA3, ~0 }, |
| 125 | { FRAG_RESULT_DATA4, ~0 }, |
| 126 | { FRAG_RESULT_DATA5, ~0 }, |
| 127 | { FRAG_RESULT_DATA6, ~0 }, |
| 128 | { FRAG_RESULT_DATA7, ~0 } |
| 129 | }; |
| 130 | |
| 131 | nir_alu_type nir_types[PAN_BLIT_NUM_TYPES] = { |
| 132 | nir_type_float, |
| 133 | nir_type_uint, |
| 134 | nir_type_int |
| 135 | }; |
| 136 | |
| 137 | /* Total size = # of shaders * bytes per shader. There are |
| 138 | * shaders for each RT (so up to DATA7 -- overestimate is |
| 139 | * okay) and up to NUM_TYPES variants of each, * 2 for multisampling |
| 140 | * variants. These shaders are simple enough that they should be less |
| 141 | * than 8 quadwords each (again, overestimate is fine). */ |
| 142 | |
| 143 | unsigned offset = 0; |
| 144 | unsigned total_size = (FRAG_RESULT_DATA7 * PAN_BLIT_NUM_TYPES) |
| 145 | * (8 * 16) * 2; |
| 146 | |
| 147 | dev->blit_shaders.bo = panfrost_bo_create(dev, total_size, PAN_BO_EXECUTE); |
| 148 | |
| 149 | /* Don't bother generating multisampling variants if we don't actually |
| 150 | * support multisampling */ |
| 151 | bool has_ms = !(dev->quirks & MIDGARD_SFBD); |
| 152 | |
| 153 | for (unsigned ms = 0; ms <= has_ms; ++ms) { |
| 154 | for (unsigned i = 0; i < ARRAY_SIZE(shader_descs); ++i) { |
| 155 | unsigned loc = shader_descs[i].loc; |
| 156 | |
| 157 | for (enum pan_blit_type T = 0; T < PAN_BLIT_NUM_TYPES; ++T) { |
| 158 | if (!(shader_descs[i].types & (1 << T))) |
| 159 | continue; |
| 160 | |
| 161 | panfrost_program program; |
| 162 | panfrost_build_blit_shader(&program, dev->gpu_id, loc, |
| 163 | nir_types[T], ms); |
| 164 | |
| 165 | assert(offset + program.compiled.size < total_size); |
| 166 | memcpy(dev->blit_shaders.bo->cpu + offset, program.compiled.data, program.compiled.size); |
| 167 | |
| 168 | dev->blit_shaders.loads[loc][T][ms] = (dev->blit_shaders.bo->gpu + offset) | program.first_tag; |
| 169 | offset += ALIGN_POT(program.compiled.size, 64); |
| 170 | util_dynarray_fini(&program.compiled); |
| 171 | } |
| 172 | } |
| 173 | } |
| 174 | } |
| 175 | |
| 176 | /* Add a shader-based load on Midgard (draw-time for GL). Shaders are |
| 177 | * precached */ |
| 178 | |
| 179 | void |
| 180 | panfrost_load_midg( |
| 181 | struct pan_pool *pool, |
| 182 | struct pan_scoreboard *scoreboard, |
| 183 | mali_ptr blend_shader, |
| 184 | mali_ptr fbd, |
| 185 | mali_ptr coordinates, unsigned vertex_count, |
| 186 | struct pan_image *image, |
| 187 | unsigned loc) |
| 188 | { |
Alyssa Rosenzweig | 5b3b2a6 | 2020-08-21 16:22:10 -0400 | [diff] [blame] | 189 | bool srgb = util_format_is_srgb(image->format); |
Alyssa Rosenzweig | 293f251 | 2020-07-09 13:42:25 -0400 | [diff] [blame] | 190 | unsigned width = u_minify(image->width0, image->first_level); |
| 191 | unsigned height = u_minify(image->height0, image->first_level); |
| 192 | |
Alyssa Rosenzweig | 7f487e0 | 2020-08-05 19:33:20 -0400 | [diff] [blame] | 193 | struct panfrost_transfer viewport = panfrost_pool_alloc(pool, MALI_VIEWPORT_LENGTH); |
Alyssa Rosenzweig | f74186b | 2020-08-11 18:23:12 -0400 | [diff] [blame] | 194 | struct panfrost_transfer sampler = panfrost_pool_alloc(pool, MALI_MIDGARD_SAMPLER_LENGTH); |
Alyssa Rosenzweig | 4fc90f7 | 2020-08-13 16:06:12 -0400 | [diff] [blame] | 195 | struct panfrost_transfer varying = panfrost_pool_alloc(pool, MALI_ATTRIBUTE_LENGTH); |
| 196 | struct panfrost_transfer varying_buffer = panfrost_pool_alloc(pool, MALI_ATTRIBUTE_BUFFER_LENGTH); |
Alyssa Rosenzweig | 293f251 | 2020-07-09 13:42:25 -0400 | [diff] [blame] | 197 | |
Alyssa Rosenzweig | 7f487e0 | 2020-08-05 19:33:20 -0400 | [diff] [blame] | 198 | pan_pack(viewport.cpu, VIEWPORT, cfg) { |
| 199 | cfg.scissor_maximum_x = width - 1; /* Inclusive */ |
| 200 | cfg.scissor_maximum_y = height - 1; |
| 201 | } |
Alyssa Rosenzweig | 293f251 | 2020-07-09 13:42:25 -0400 | [diff] [blame] | 202 | |
Alyssa Rosenzweig | 4fc90f7 | 2020-08-13 16:06:12 -0400 | [diff] [blame] | 203 | pan_pack(varying_buffer.cpu, ATTRIBUTE_BUFFER, cfg) { |
| 204 | cfg.pointer = coordinates; |
| 205 | cfg.stride = 4 * sizeof(float); |
| 206 | cfg.size = cfg.stride * vertex_count; |
| 207 | } |
Alyssa Rosenzweig | 293f251 | 2020-07-09 13:42:25 -0400 | [diff] [blame] | 208 | |
Alyssa Rosenzweig | 4fc90f7 | 2020-08-13 16:06:12 -0400 | [diff] [blame] | 209 | pan_pack(varying.cpu, ATTRIBUTE, cfg) { |
Alyssa Rosenzweig | 2c8a722 | 2020-08-13 13:27:16 -0400 | [diff] [blame] | 210 | cfg.buffer_index = 0; |
| 211 | cfg.format = (MALI_CHANNEL_R << 0) | (MALI_CHANNEL_G << 3) | (MALI_RGBA32F << 12); |
| 212 | } |
Alyssa Rosenzweig | 293f251 | 2020-07-09 13:42:25 -0400 | [diff] [blame] | 213 | |
Alyssa Rosenzweig | 293f251 | 2020-07-09 13:42:25 -0400 | [diff] [blame] | 214 | /* Determine the sampler type needed. Stencil is always sampled as |
| 215 | * UINT. Pure (U)INT is always (U)INT. Everything else is FLOAT. */ |
| 216 | |
| 217 | enum pan_blit_type T = |
| 218 | (loc == FRAG_RESULT_STENCIL) ? PAN_BLIT_UINT : |
| 219 | (util_format_is_pure_uint(image->format)) ? PAN_BLIT_UINT : |
| 220 | (util_format_is_pure_sint(image->format)) ? PAN_BLIT_INT : |
| 221 | PAN_BLIT_FLOAT; |
| 222 | |
| 223 | bool ms = image->nr_samples > 1; |
| 224 | |
Boris Brezillon | 8389976 | 2020-09-16 13:31:37 +0200 | [diff] [blame] | 225 | struct panfrost_transfer shader_meta_t = |
| 226 | panfrost_pool_alloc_aligned(pool, |
| 227 | MALI_RENDERER_STATE_LENGTH + |
| 228 | 8 * MALI_BLEND_LENGTH, |
| 229 | 128); |
Alyssa Rosenzweig | 661b469 | 2020-08-21 10:34:06 -0400 | [diff] [blame] | 230 | |
Boris Brezillon | f734e67 | 2020-09-29 15:47:04 +0200 | [diff] [blame] | 231 | pan_pack(shader_meta_t.cpu, RENDERER_STATE, cfg) { |
Alyssa Rosenzweig | 5b3b2a6 | 2020-08-21 16:22:10 -0400 | [diff] [blame] | 232 | cfg.shader.shader = pool->dev->blit_shaders.loads[loc][T][ms]; |
| 233 | cfg.shader.varying_count = 1; |
| 234 | cfg.shader.texture_count = 1; |
| 235 | cfg.shader.sampler_count = 1; |
Alyssa Rosenzweig | 1b7d4f1 | 2020-08-20 16:25:14 -0400 | [diff] [blame] | 236 | |
Boris Brezillon | 519643b | 2020-10-13 18:32:14 +0200 | [diff] [blame^] | 237 | cfg.properties.midgard.work_register_count = 4; |
| 238 | cfg.properties.midgard.force_early_z = (loc >= FRAG_RESULT_DATA0); |
Boris Brezillon | 7bb85ea | 2020-09-15 17:03:28 +0200 | [diff] [blame] | 239 | cfg.properties.stencil_from_shader = (loc == FRAG_RESULT_STENCIL); |
| 240 | cfg.properties.depth_source = (loc == FRAG_RESULT_DEPTH) ? |
| 241 | MALI_DEPTH_SOURCE_SHADER : |
| 242 | MALI_DEPTH_SOURCE_FIXED_FUNCTION; |
Alyssa Rosenzweig | 293f251 | 2020-07-09 13:42:25 -0400 | [diff] [blame] | 243 | |
Alyssa Rosenzweig | 5b3b2a6 | 2020-08-21 16:22:10 -0400 | [diff] [blame] | 244 | cfg.multisample_misc.sample_mask = 0xFFFF; |
| 245 | cfg.multisample_misc.multisample_enable = ms; |
| 246 | cfg.multisample_misc.evaluate_per_sample = ms; |
| 247 | cfg.multisample_misc.depth_write_mask = (loc == FRAG_RESULT_DEPTH); |
| 248 | cfg.multisample_misc.depth_function = MALI_FUNC_ALWAYS; |
| 249 | |
| 250 | cfg.stencil_mask_misc.stencil_enable = (loc == FRAG_RESULT_STENCIL); |
| 251 | cfg.stencil_mask_misc.stencil_mask_front = 0xFF; |
| 252 | cfg.stencil_mask_misc.stencil_mask_back = 0xFF; |
| 253 | cfg.stencil_mask_misc.unknown_1 = 0x7; |
| 254 | |
| 255 | cfg.stencil_front.compare_function = MALI_FUNC_ALWAYS; |
| 256 | cfg.stencil_front.stencil_fail = MALI_STENCIL_OP_REPLACE; |
| 257 | cfg.stencil_front.depth_fail = MALI_STENCIL_OP_REPLACE; |
| 258 | cfg.stencil_front.depth_pass = MALI_STENCIL_OP_REPLACE; |
Alyssa Rosenzweig | 322ddbd | 2020-09-09 16:29:04 -0400 | [diff] [blame] | 259 | cfg.stencil_front.mask = 0xFF; |
Alyssa Rosenzweig | 5b3b2a6 | 2020-08-21 16:22:10 -0400 | [diff] [blame] | 260 | |
| 261 | cfg.stencil_back = cfg.stencil_front; |
| 262 | |
| 263 | if (pool->dev->quirks & MIDGARD_SFBD) { |
| 264 | cfg.stencil_mask_misc.sfbd_write_enable = true; |
| 265 | cfg.stencil_mask_misc.sfbd_dither_disable = true; |
| 266 | cfg.stencil_mask_misc.sfbd_srgb = srgb; |
Boris Brezillon | 7bb85ea | 2020-09-15 17:03:28 +0200 | [diff] [blame] | 267 | cfg.multisample_misc.sfbd_blend_shader = !!blend_shader; |
| 268 | if (cfg.multisample_misc.sfbd_blend_shader) { |
| 269 | cfg.sfbd_blend_shader = blend_shader; |
| 270 | } else { |
Boris Brezillon | 713419e | 2020-09-16 10:26:06 +0200 | [diff] [blame] | 271 | cfg.sfbd_blend_equation.rgb.a = MALI_BLEND_OPERAND_A_SRC; |
| 272 | cfg.sfbd_blend_equation.rgb.b = MALI_BLEND_OPERAND_B_SRC; |
| 273 | cfg.sfbd_blend_equation.rgb.c = MALI_BLEND_OPERAND_C_ZERO; |
| 274 | cfg.sfbd_blend_equation.alpha.a = MALI_BLEND_OPERAND_A_SRC; |
| 275 | cfg.sfbd_blend_equation.alpha.b = MALI_BLEND_OPERAND_B_SRC; |
| 276 | cfg.sfbd_blend_equation.alpha.c = MALI_BLEND_OPERAND_C_ZERO; |
| 277 | |
| 278 | if (loc >= FRAG_RESULT_DATA0) |
| 279 | cfg.sfbd_blend_equation.color_mask = 0xf; |
Boris Brezillon | 7bb85ea | 2020-09-15 17:03:28 +0200 | [diff] [blame] | 280 | cfg.sfbd_blend_constant = 0; |
| 281 | } |
Alyssa Rosenzweig | 5b3b2a6 | 2020-08-21 16:22:10 -0400 | [diff] [blame] | 282 | } else if (!(pool->dev->quirks & IS_BIFROST)) { |
Boris Brezillon | 7bb85ea | 2020-09-15 17:03:28 +0200 | [diff] [blame] | 283 | cfg.sfbd_blend_shader = blend_shader; |
Alyssa Rosenzweig | 5b3b2a6 | 2020-08-21 16:22:10 -0400 | [diff] [blame] | 284 | } |
| 285 | |
| 286 | assert(cfg.shader.shader); |
Alyssa Rosenzweig | 293f251 | 2020-07-09 13:42:25 -0400 | [diff] [blame] | 287 | } |
| 288 | |
Alyssa Rosenzweig | 293f251 | 2020-07-09 13:42:25 -0400 | [diff] [blame] | 289 | /* Create the texture descriptor. We partially compute the base address |
| 290 | * ourselves to account for layer, such that the texture descriptor |
| 291 | * itself is for a 2D texture with array size 1 even for 3D/array |
| 292 | * textures, removing the need to separately key the blit shaders for |
| 293 | * 2D and 3D variants */ |
| 294 | |
Alyssa Rosenzweig | 373a204 | 2020-08-17 14:27:57 -0400 | [diff] [blame] | 295 | struct panfrost_transfer texture_t = panfrost_pool_alloc_aligned( |
| 296 | pool, MALI_MIDGARD_TEXTURE_LENGTH + sizeof(mali_ptr) * 2 * MAX2(image->nr_samples, 1), 128); |
Alyssa Rosenzweig | 293f251 | 2020-07-09 13:42:25 -0400 | [diff] [blame] | 297 | |
| 298 | panfrost_new_texture(texture_t.cpu, |
| 299 | image->width0, image->height0, |
| 300 | MAX2(image->nr_samples, 1), 1, |
Alyssa Rosenzweig | f008a63 | 2020-08-11 17:27:36 -0400 | [diff] [blame] | 301 | image->format, MALI_TEXTURE_DIMENSION_2D, |
Alyssa Rosenzweig | 965537df | 2020-07-22 10:23:50 -0400 | [diff] [blame] | 302 | image->modifier, |
Alyssa Rosenzweig | 293f251 | 2020-07-09 13:42:25 -0400 | [diff] [blame] | 303 | image->first_level, image->last_level, |
| 304 | 0, 0, |
| 305 | image->nr_samples, |
| 306 | 0, |
Alyssa Rosenzweig | cdc3276 | 2020-08-12 16:46:07 -0400 | [diff] [blame] | 307 | (MALI_CHANNEL_R << 0) | (MALI_CHANNEL_G << 3) | (MALI_CHANNEL_B << 6) | (MALI_CHANNEL_A << 9), |
Alyssa Rosenzweig | 293f251 | 2020-07-09 13:42:25 -0400 | [diff] [blame] | 308 | image->bo->gpu + image->first_layer * |
| 309 | panfrost_get_layer_stride(image->slices, |
Alyssa Rosenzweig | f008a63 | 2020-08-11 17:27:36 -0400 | [diff] [blame] | 310 | image->dim == MALI_TEXTURE_DIMENSION_3D, |
Alyssa Rosenzweig | 293f251 | 2020-07-09 13:42:25 -0400 | [diff] [blame] | 311 | image->cubemap_stride, image->first_level), |
| 312 | image->slices); |
| 313 | |
Alyssa Rosenzweig | f74186b | 2020-08-11 18:23:12 -0400 | [diff] [blame] | 314 | pan_pack(sampler.cpu, MIDGARD_SAMPLER, cfg) |
| 315 | cfg.normalized_coordinates = false; |
Alyssa Rosenzweig | 293f251 | 2020-07-09 13:42:25 -0400 | [diff] [blame] | 316 | |
Alyssa Rosenzweig | 293f251 | 2020-07-09 13:42:25 -0400 | [diff] [blame] | 317 | for (unsigned i = 0; i < 8; ++i) { |
Boris Brezillon | 8389976 | 2020-09-16 13:31:37 +0200 | [diff] [blame] | 318 | void *dest = shader_meta_t.cpu + MALI_RENDERER_STATE_LENGTH + |
| 319 | MALI_BLEND_LENGTH * i; |
Alyssa Rosenzweig | 293f251 | 2020-07-09 13:42:25 -0400 | [diff] [blame] | 320 | |
Boris Brezillon | 8389976 | 2020-09-16 13:31:37 +0200 | [diff] [blame] | 321 | if (loc != (FRAG_RESULT_DATA0 + i)) { |
| 322 | memset(dest, 0x0, MALI_BLEND_LENGTH); |
| 323 | continue; |
| 324 | } |
Boris Brezillon | 713419e | 2020-09-16 10:26:06 +0200 | [diff] [blame] | 325 | |
Boris Brezillon | 8389976 | 2020-09-16 13:31:37 +0200 | [diff] [blame] | 326 | pan_pack(dest, BLEND, cfg) { |
| 327 | cfg.round_to_fb_precision = true; |
| 328 | cfg.srgb = srgb; |
| 329 | if (blend_shader) { |
| 330 | cfg.midgard.blend_shader = true; |
| 331 | cfg.midgard.shader_pc = blend_shader; |
| 332 | } else { |
| 333 | cfg.midgard.equation.rgb.a = MALI_BLEND_OPERAND_A_SRC; |
| 334 | cfg.midgard.equation.rgb.b = MALI_BLEND_OPERAND_B_SRC; |
| 335 | cfg.midgard.equation.rgb.c = MALI_BLEND_OPERAND_C_ZERO; |
| 336 | cfg.midgard.equation.alpha.a = MALI_BLEND_OPERAND_A_SRC; |
| 337 | cfg.midgard.equation.alpha.b = MALI_BLEND_OPERAND_B_SRC; |
| 338 | cfg.midgard.equation.alpha.c = MALI_BLEND_OPERAND_C_ZERO; |
| 339 | cfg.midgard.equation.color_mask = 0xf; |
Boris Brezillon | 713419e | 2020-09-16 10:26:06 +0200 | [diff] [blame] | 340 | } |
Alyssa Rosenzweig | 293f251 | 2020-07-09 13:42:25 -0400 | [diff] [blame] | 341 | } |
| 342 | } |
| 343 | |
Boris Brezillon | 6b92303 | 2020-09-08 20:32:41 +0200 | [diff] [blame] | 344 | struct panfrost_transfer t = |
| 345 | panfrost_pool_alloc_aligned(pool, MALI_MIDGARD_TILER_JOB_LENGTH, 64); |
Alyssa Rosenzweig | 59b6e3c | 2020-08-24 13:46:34 -0400 | [diff] [blame] | 346 | |
Boris Brezillon | 6b92303 | 2020-09-08 20:32:41 +0200 | [diff] [blame] | 347 | pan_section_pack(t.cpu, MIDGARD_TILER_JOB, DRAW, cfg) { |
Boris Brezillon | d343f23 | 2020-09-29 10:45:23 +0200 | [diff] [blame] | 348 | cfg.four_components_per_vertex = true; |
| 349 | cfg.draw_descriptor_is_64b = true; |
| 350 | cfg.texture_descriptor_is_64b = true; |
Alyssa Rosenzweig | 59b6e3c | 2020-08-24 13:46:34 -0400 | [diff] [blame] | 351 | cfg.position = coordinates; |
| 352 | cfg.textures = panfrost_pool_upload(pool, &texture_t.gpu, sizeof(texture_t.gpu)); |
| 353 | cfg.samplers = sampler.gpu; |
| 354 | cfg.state = shader_meta_t.gpu; |
| 355 | cfg.varying_buffers = varying_buffer.gpu; |
| 356 | cfg.varyings = varying.gpu; |
| 357 | cfg.viewport = viewport.gpu; |
Boris Brezillon | d343f23 | 2020-09-29 10:45:23 +0200 | [diff] [blame] | 358 | cfg.fbd = fbd; |
Alyssa Rosenzweig | 59b6e3c | 2020-08-24 13:46:34 -0400 | [diff] [blame] | 359 | } |
| 360 | |
Boris Brezillon | 6b92303 | 2020-09-08 20:32:41 +0200 | [diff] [blame] | 361 | pan_section_pack(t.cpu, MIDGARD_TILER_JOB, PRIMITIVE, cfg) { |
Alyssa Rosenzweig | b60d567 | 2020-08-25 16:59:14 -0400 | [diff] [blame] | 362 | cfg.draw_mode = MALI_DRAW_MODE_TRIANGLES; |
| 363 | cfg.index_count = vertex_count; |
Boris Brezillon | 51331d6 | 2020-09-29 11:21:33 +0200 | [diff] [blame] | 364 | cfg.job_task_split = 6; |
Alyssa Rosenzweig | b60d567 | 2020-08-25 16:59:14 -0400 | [diff] [blame] | 365 | } |
| 366 | |
Boris Brezillon | 6b92303 | 2020-09-08 20:32:41 +0200 | [diff] [blame] | 367 | panfrost_pack_work_groups_compute(pan_section_ptr(t.cpu, MIDGARD_TILER_JOB, INVOCATION), |
Boris Brezillon | d289209 | 2020-09-08 19:41:51 +0200 | [diff] [blame] | 368 | 1, vertex_count, 1, 1, 1, 1, true); |
Alyssa Rosenzweig | 59b6e3c | 2020-08-24 13:46:34 -0400 | [diff] [blame] | 369 | |
Boris Brezillon | 6b92303 | 2020-09-08 20:32:41 +0200 | [diff] [blame] | 370 | panfrost_add_job(pool, scoreboard, MALI_JOB_TYPE_TILER, false, 0, &t, true); |
Alyssa Rosenzweig | 293f251 | 2020-07-09 13:42:25 -0400 | [diff] [blame] | 371 | } |