projects / mesa.git / blob
? search:


57503b5c14eb72dc3d87bd171b932106c8e29dc6
[mesa.git] / src / gallium / drivers / freedreno / a6xx / fd6_image.c
1 /*
2 * Copyright (C) 2017 Rob Clark <robclark@freedesktop.org>
3 * Copyright © 2018 Google, Inc.
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice (including the next
13 * paragraph) shall be included in all copies or substantial portions of the
14 * Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22 * SOFTWARE.
23 *
24 * Authors:
25 * Rob Clark <robclark@freedesktop.org>
26 */
27
28 #include "pipe/p_state.h"
29
30 #include "freedreno_resource.h"
31 #include "freedreno_state.h"
32
33 #include "fd6_image.h"
34 #include "fd6_format.h"
35 #include "fd6_resource.h"
36 #include "fd6_texture.h"
37
38 struct fd6_image {
39 struct pipe_resource *prsc;
40 enum pipe_format pfmt;
41 enum a6xx_tex_fmt fmt;
42 enum a6xx_tex_fetchsize fetchsize;
43 enum a6xx_tex_type type;
44 bool srgb;
45 uint32_t cpp;
46 uint32_t level;
47 uint32_t width;
48 uint32_t height;
49 uint32_t depth;
50 uint32_t pitch;
51 uint32_t array_pitch;
52 struct fd_bo *bo;
53 uint32_t ubwc_offset;
54 uint32_t offset;
55 bool buffer;
56 };
57
58 static void translate_image(struct fd6_image *img, const struct pipe_image_view *pimg)
59 {
60 enum pipe_format format = pimg->format;
61 struct pipe_resource *prsc = pimg->resource;
62 struct fd_resource *rsc = fd_resource(prsc);
63
64 if (!prsc) {
65 memset(img, 0, sizeof(*img));
66 return;
67 }
68
69 img->prsc = prsc;
70 img->pfmt = format;
71 img->fmt = fd6_pipe2tex(format);
72 img->fetchsize = fd6_pipe2fetchsize(format);
73 img->type = fd6_tex_type(prsc->target);
74 img->srgb = util_format_is_srgb(format);
75 img->cpp = rsc->layout.cpp;
76 img->bo = rsc->bo;
77
78 /* Treat cube textures as 2d-array: */
79 if (img->type == A6XX_TEX_CUBE)
80 img->type = A6XX_TEX_2D;
81
82 if (prsc->target == PIPE_BUFFER) {
83 img->buffer = true;
84 img->ubwc_offset = 0; /* not valid for buffers */
85 img->offset = pimg->u.buf.offset;
86 img->pitch = 0;
87 img->array_pitch = 0;
88
89 /* size is encoded with low 15b in WIDTH and high bits in
90 * HEIGHT, in units of elements:
91 */
92 unsigned sz = prsc->width0;
93 img->width = sz & MASK(15);
94 img->height = sz >> 15;
95 img->depth = 0;
96 } else {
97 img->buffer = false;
98
99 unsigned lvl = pimg->u.tex.level;
100 struct fdl_slice *slice = fd_resource_slice(rsc, lvl);
101 unsigned layers = pimg->u.tex.last_layer - pimg->u.tex.first_layer + 1;
102
103 img->ubwc_offset = fd_resource_ubwc_offset(rsc, lvl, pimg->u.tex.first_layer);
104 img->offset = fd_resource_offset(rsc, lvl, pimg->u.tex.first_layer);
105 img->pitch = slice->pitch * rsc->layout.cpp;
106
107 switch (prsc->target) {
108 case PIPE_TEXTURE_RECT:
109 case PIPE_TEXTURE_1D:
110 case PIPE_TEXTURE_2D:
111 img->array_pitch = rsc->layout.layer_size;
112 img->depth = 1;
113 break;
114 case PIPE_TEXTURE_1D_ARRAY:
115 case PIPE_TEXTURE_2D_ARRAY:
116 case PIPE_TEXTURE_CUBE:
117 case PIPE_TEXTURE_CUBE_ARRAY:
118 img->array_pitch = rsc->layout.layer_size;
119 // TODO the CUBE/CUBE_ARRAY might need to be layers/6 for tex state,
120 // but empirically for ibo state it shouldn't be divided.
121 img->depth = layers;
122 break;
123 case PIPE_TEXTURE_3D:
124 img->array_pitch = slice->size0;
125 img->depth = u_minify(prsc->depth0, lvl);
126 break;
127 default:
128 break;
129 }
130
131 img->level = lvl;
132 img->width = u_minify(prsc->width0, lvl);
133 img->height = u_minify(prsc->height0, lvl);
134 }
135 }
136
137 static void translate_buf(struct fd6_image *img, const struct pipe_shader_buffer *pimg)
138 {
139 enum pipe_format format = PIPE_FORMAT_R32_UINT;
140 struct pipe_resource *prsc = pimg->buffer;
141 struct fd_resource *rsc = fd_resource(prsc);
142
143 if (!prsc) {
144 memset(img, 0, sizeof(*img));
145 return;
146 }
147
148 img->prsc = prsc;
149 img->pfmt = format;
150 img->fmt = fd6_pipe2tex(format);
151 img->fetchsize = fd6_pipe2fetchsize(format);
152 img->type = fd6_tex_type(prsc->target);
153 img->srgb = util_format_is_srgb(format);
154 img->cpp = rsc->layout.cpp;
155 img->bo = rsc->bo;
156 img->buffer = true;
157
158 img->ubwc_offset = 0; /* not valid for buffers */
159 img->offset = pimg->buffer_offset;
160 img->pitch = 0;
161 img->array_pitch = 0;
162
163 /* size is encoded with low 15b in WIDTH and high bits in HEIGHT,
164 * in units of elements:
165 */
166 unsigned sz = pimg->buffer_size / 4;
167 img->width = sz & MASK(15);
168 img->height = sz >> 15;
169 img->depth = 0;
170 }
171
172 static void emit_image_tex(struct fd_ringbuffer *ring, struct fd6_image *img)
173 {
174 struct fd_resource *rsc = fd_resource(img->prsc);
175 bool ubwc_enabled = fd_resource_ubwc_enabled(rsc, img->level);
176
177 OUT_RING(ring, fd6_tex_const_0(img->prsc, img->level, img->pfmt,
178 PIPE_SWIZZLE_X, PIPE_SWIZZLE_Y,
179 PIPE_SWIZZLE_Z, PIPE_SWIZZLE_W));
180 OUT_RING(ring, A6XX_TEX_CONST_1_WIDTH(img->width) |
181 A6XX_TEX_CONST_1_HEIGHT(img->height));
182 OUT_RING(ring, A6XX_TEX_CONST_2_FETCHSIZE(img->fetchsize) |
183 COND(img->buffer, A6XX_TEX_CONST_2_UNK4 | A6XX_TEX_CONST_2_UNK31) |
184 A6XX_TEX_CONST_2_TYPE(img->type) |
185 A6XX_TEX_CONST_2_PITCH(img->pitch));
186 OUT_RING(ring, A6XX_TEX_CONST_3_ARRAY_PITCH(img->array_pitch) |
187 COND(ubwc_enabled, A6XX_TEX_CONST_3_FLAG | A6XX_TEX_CONST_3_TILE_ALL));
188 if (img->bo) {
189 OUT_RELOC(ring, img->bo, img->offset,
190 (uint64_t)A6XX_TEX_CONST_5_DEPTH(img->depth) << 32, 0);
191 } else {
192 OUT_RING(ring, 0x00000000);
193 OUT_RING(ring, A6XX_TEX_CONST_5_DEPTH(img->depth));
194 }
195
196 OUT_RING(ring, 0x00000000); /* texconst6 */
197
198 if (ubwc_enabled) {
199 struct fdl_slice *ubwc_slice = &rsc->layout.ubwc_slices[img->level];
200 OUT_RELOC(ring, rsc->bo, img->ubwc_offset, 0, 0);
201 OUT_RING(ring, A6XX_TEX_CONST_9_FLAG_BUFFER_ARRAY_PITCH(rsc->layout.ubwc_layer_size >> 2));
202 OUT_RING(ring, A6XX_TEX_CONST_10_FLAG_BUFFER_PITCH(ubwc_slice->pitch));
203 } else {
204 OUT_RING(ring, 0x00000000); /* texconst7 */
205 OUT_RING(ring, 0x00000000); /* texconst8 */
206 OUT_RING(ring, 0x00000000); /* texconst9 */
207 OUT_RING(ring, 0x00000000); /* texconst10 */
208 }
209
210 OUT_RING(ring, 0x00000000); /* texconst11 */
211 OUT_RING(ring, 0x00000000); /* texconst12 */
212 OUT_RING(ring, 0x00000000); /* texconst13 */
213 OUT_RING(ring, 0x00000000); /* texconst14 */
214 OUT_RING(ring, 0x00000000); /* texconst15 */
215 }
216
217 void
218 fd6_emit_image_tex(struct fd_ringbuffer *ring, const struct pipe_image_view *pimg)
219 {
220 struct fd6_image img;
221 translate_image(&img, pimg);
222 emit_image_tex(ring, &img);
223 }
224
225 void
226 fd6_emit_ssbo_tex(struct fd_ringbuffer *ring, const struct pipe_shader_buffer *pbuf)
227 {
228 struct fd6_image img;
229 translate_buf(&img, pbuf);
230 emit_image_tex(ring, &img);
231 }
232
233 static void emit_image_ssbo(struct fd_ringbuffer *ring, struct fd6_image *img)
234 {
235 /* If the SSBO isn't present (becasue gallium doesn't pack atomic
236 * counters), zero-fill the slot.
237 */
238 if (!img->prsc) {
239 for (int i = 0; i < 16; i++)
240 OUT_RING(ring, 0);
241 return;
242 }
243
244 struct fd_resource *rsc = fd_resource(img->prsc);
245 enum a6xx_tile_mode tile_mode = fd_resource_tile_mode(img->prsc, img->level);
246 bool ubwc_enabled = fd_resource_ubwc_enabled(rsc, img->level);
247
248 OUT_RING(ring, A6XX_IBO_0_FMT(img->fmt) |
249 A6XX_IBO_0_TILE_MODE(tile_mode));
250 OUT_RING(ring, A6XX_IBO_1_WIDTH(img->width) |
251 A6XX_IBO_1_HEIGHT(img->height));
252 OUT_RING(ring, A6XX_IBO_2_PITCH(img->pitch) |
253 COND(img->buffer, A6XX_IBO_2_UNK4 | A6XX_IBO_2_UNK31) |
254 A6XX_IBO_2_TYPE(img->type));
255 OUT_RING(ring, A6XX_IBO_3_ARRAY_PITCH(img->array_pitch) |
256 COND(ubwc_enabled, A6XX_IBO_3_FLAG | A6XX_IBO_3_UNK27));
257 if (img->bo) {
258 OUT_RELOCW(ring, img->bo, img->offset,
259 (uint64_t)A6XX_IBO_5_DEPTH(img->depth) << 32, 0);
260 } else {
261 OUT_RING(ring, 0x00000000);
262 OUT_RING(ring, A6XX_IBO_5_DEPTH(img->depth));
263 }
264 OUT_RING(ring, 0x00000000);
265
266 if (ubwc_enabled) {
267 struct fdl_slice *ubwc_slice = &rsc->layout.ubwc_slices[img->level];
268 OUT_RELOCW(ring, rsc->bo, img->ubwc_offset, 0, 0);
269 OUT_RING(ring, A6XX_IBO_9_FLAG_BUFFER_ARRAY_PITCH(rsc->layout.ubwc_layer_size >> 2));
270 OUT_RING(ring, A6XX_IBO_10_FLAG_BUFFER_PITCH(ubwc_slice->pitch));
271 } else {
272 OUT_RING(ring, 0x00000000);
273 OUT_RING(ring, 0x00000000);
274 OUT_RING(ring, 0x00000000);
275 OUT_RING(ring, 0x00000000);
276 }
277
278 OUT_RING(ring, 0x00000000);
279 OUT_RING(ring, 0x00000000);
280 OUT_RING(ring, 0x00000000);
281 OUT_RING(ring, 0x00000000);
282 OUT_RING(ring, 0x00000000);
283 }
284
285 /* Build combined image/SSBO "IBO" state, returns ownership of state reference */
286 struct fd_ringbuffer *
287 fd6_build_ibo_state(struct fd_context *ctx, const struct ir3_shader_variant *v,
288 enum pipe_shader_type shader)
289 {
290 struct fd_shaderbuf_stateobj *bufso = &ctx->shaderbuf[shader];
291 struct fd_shaderimg_stateobj *imgso = &ctx->shaderimg[shader];
292
293 struct fd_ringbuffer *state =
294 fd_submit_new_ringbuffer(ctx->batch->submit,
295 (v->shader->nir->info.num_ssbos +
296 v->shader->nir->info.num_images) * 16 * 4,
297 FD_RINGBUFFER_STREAMING);
298
299 assert(shader == PIPE_SHADER_COMPUTE || shader == PIPE_SHADER_FRAGMENT);
300
301 for (unsigned i = 0; i < v->shader->nir->info.num_ssbos; i++) {
302 struct fd6_image img;
303 translate_buf(&img, &bufso->sb[i]);
304 emit_image_ssbo(state, &img);
305 }
306
307 for (unsigned i = 0; i < v->shader->nir->info.num_images; i++) {
308 struct fd6_image img;
309 translate_image(&img, &imgso->si[i]);
310 emit_image_ssbo(state, &img);
311 }
312
313 return state;
314 }
315
316 static void fd6_set_shader_images(struct pipe_context *pctx,
317 enum pipe_shader_type shader,
318 unsigned start, unsigned count,
319 const struct pipe_image_view *images)
320 {
321 struct fd_context *ctx = fd_context(pctx);
322 struct fd_shaderimg_stateobj *so = &ctx->shaderimg[shader];
323
324 fd_set_shader_images(pctx, shader, start, count, images);
325
326 if (!images)
327 return;
328
329 for (unsigned i = 0; i < count; i++) {
330 unsigned n = i + start;
331 struct pipe_image_view *buf = &so->si[n];
332
333 if (!buf->resource)
334 continue;
335
336 fd6_validate_format(ctx, fd_resource(buf->resource), buf->format);
337 }
338 }
339
340 void
341 fd6_image_init(struct pipe_context *pctx)
342 {
343 pctx->set_shader_images = fd6_set_shader_images;
344 }