3a842381ac2d1abfca18a640f0b4602a08d5d30e
[mesa.git] / src / gallium / drivers / etnaviv / etnaviv_texture.c
1 /*
2 * Copyright (c) 2012-2015 Etnaviv Project
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, sub license,
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
12 * next paragraph) shall be included in all copies or substantial portions
13 * of the 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 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 * DEALINGS IN THE SOFTWARE.
22 *
23 * Authors:
24 * Wladimir J. van der Laan <laanwj@gmail.com>
25 */
26
27 #include "etnaviv_texture.h"
28
29 #include "hw/common.xml.h"
30
31 #include "etnaviv_clear_blit.h"
32 #include "etnaviv_context.h"
33 #include "etnaviv_emit.h"
34 #include "etnaviv_format.h"
35 #include "etnaviv_translate.h"
36 #include "util/u_inlines.h"
37 #include "util/u_memory.h"
38
39 static void *
40 etna_create_sampler_state(struct pipe_context *pipe,
41 const struct pipe_sampler_state *ss)
42 {
43 struct etna_sampler_state *cs = CALLOC_STRUCT(etna_sampler_state);
44
45 if (!cs)
46 return NULL;
47
48 cs->TE_SAMPLER_CONFIG0 =
49 VIVS_TE_SAMPLER_CONFIG0_UWRAP(translate_texture_wrapmode(ss->wrap_s)) |
50 VIVS_TE_SAMPLER_CONFIG0_VWRAP(translate_texture_wrapmode(ss->wrap_t)) |
51 VIVS_TE_SAMPLER_CONFIG0_MIN(translate_texture_filter(ss->min_img_filter)) |
52 VIVS_TE_SAMPLER_CONFIG0_MIP(translate_texture_mipfilter(ss->min_mip_filter)) |
53 VIVS_TE_SAMPLER_CONFIG0_MAG(translate_texture_filter(ss->mag_img_filter)) |
54 COND(ss->normalized_coords, VIVS_TE_SAMPLER_CONFIG0_ROUND_UV);
55 cs->TE_SAMPLER_CONFIG1 = 0; /* VIVS_TE_SAMPLER_CONFIG1 (swizzle, extended
56 format) fully determined by sampler view */
57 cs->TE_SAMPLER_LOD_CONFIG =
58 COND(ss->lod_bias != 0.0, VIVS_TE_SAMPLER_LOD_CONFIG_BIAS_ENABLE) |
59 VIVS_TE_SAMPLER_LOD_CONFIG_BIAS(etna_float_to_fixp55(ss->lod_bias));
60
61 if (ss->min_mip_filter != PIPE_TEX_MIPFILTER_NONE) {
62 cs->min_lod = etna_float_to_fixp55(ss->min_lod);
63 cs->max_lod = etna_float_to_fixp55(ss->max_lod);
64 } else {
65 /* when not mipmapping, we need to set max/min lod so that always
66 * lowest LOD is selected */
67 cs->min_lod = cs->max_lod = etna_float_to_fixp55(ss->min_lod);
68 }
69
70 return cs;
71 }
72
73 static void
74 etna_bind_sampler_states(struct pipe_context *pctx, enum pipe_shader_type shader,
75 unsigned start_slot, unsigned num_samplers,
76 void **samplers)
77 {
78 /* bind fragment sampler */
79 struct etna_context *ctx = etna_context(pctx);
80 int offset;
81
82 switch (shader) {
83 case PIPE_SHADER_FRAGMENT:
84 offset = 0;
85 ctx->num_fragment_samplers = num_samplers;
86 break;
87 case PIPE_SHADER_VERTEX:
88 offset = ctx->specs.vertex_sampler_offset;
89 break;
90 default:
91 assert(!"Invalid shader");
92 return;
93 }
94
95 uint32_t mask = 1 << offset;
96 for (int idx = 0; idx < num_samplers; ++idx, mask <<= 1) {
97 ctx->sampler[offset + idx] = samplers[idx];
98 if (samplers[idx])
99 ctx->active_samplers |= mask;
100 else
101 ctx->active_samplers &= ~mask;
102 }
103
104 ctx->dirty |= ETNA_DIRTY_SAMPLERS;
105 }
106
107 static void
108 etna_delete_sampler_state(struct pipe_context *pctx, void *ss)
109 {
110 FREE(ss);
111 }
112
113 static void
114 etna_update_sampler_source(struct pipe_sampler_view *view)
115 {
116 struct etna_resource *res = etna_resource(view->texture);
117
118 if (res->texture && etna_resource_older(etna_resource(res->texture), res)) {
119 /* Texture is older than render buffer, copy the texture using RS */
120 etna_copy_resource(view->context, res->texture, view->texture, 0,
121 view->texture->last_level);
122 etna_resource(res->texture)->seqno = res->seqno;
123 }
124 }
125
126 static bool
127 etna_resource_sampler_compatible(struct etna_resource *res)
128 {
129 if (util_format_is_compressed(res->base.format))
130 return true;
131
132 struct etna_screen *screen = etna_screen(res->base.screen);
133 /* This GPU supports texturing from supertiled textures? */
134 if (res->layout == ETNA_LAYOUT_SUPER_TILED && VIV_FEATURE(screen, chipMinorFeatures2, SUPERTILED_TEXTURE))
135 return true;
136
137 /* TODO: LINEAR_TEXTURE_SUPPORT */
138
139 /* Otherwise, only support tiled layouts */
140 if (res->layout != ETNA_LAYOUT_TILED)
141 return false;
142
143 /* If we have HALIGN support, we can allow for the RS padding */
144 if (VIV_FEATURE(screen, chipMinorFeatures1, TEXTURE_HALIGN))
145 return true;
146
147 /* Non-HALIGN GPUs only accept 4x4 tile-aligned textures */
148 if (res->halign != TEXTURE_HALIGN_FOUR)
149 return false;
150
151 return true;
152 }
153
154 static struct pipe_sampler_view *
155 etna_create_sampler_view(struct pipe_context *pctx, struct pipe_resource *prsc,
156 const struct pipe_sampler_view *so)
157 {
158 struct etna_sampler_view *sv = CALLOC_STRUCT(etna_sampler_view);
159 struct etna_resource *res = etna_resource(prsc);
160 struct etna_context *ctx = etna_context(pctx);
161
162 if (!sv)
163 return NULL;
164
165 if (!etna_resource_sampler_compatible(res)) {
166 /* The original resource is not compatible with the sampler.
167 * Allocate an appropriately tiled texture. */
168 if (!res->texture) {
169 struct pipe_resource templat = *prsc;
170
171 templat.bind &= ~(PIPE_BIND_DEPTH_STENCIL | PIPE_BIND_RENDER_TARGET |
172 PIPE_BIND_BLENDABLE);
173 res->texture =
174 etna_resource_alloc(pctx->screen, ETNA_LAYOUT_TILED, &templat);
175 }
176
177 if (!res->texture) {
178 free(sv);
179 return NULL;
180 }
181 res = etna_resource(res->texture);
182 }
183
184 sv->base = *so;
185 pipe_reference(NULL, &prsc->reference);
186 sv->base.texture = prsc;
187 sv->base.reference.count = 1;
188 sv->base.context = pctx;
189
190 /* merged with sampler state */
191 sv->TE_SAMPLER_CONFIG0 =
192 VIVS_TE_SAMPLER_CONFIG0_FORMAT(translate_texture_format(sv->base.format));
193 sv->TE_SAMPLER_CONFIG0_MASK = 0xffffffff;
194
195 switch (sv->base.target) {
196 case PIPE_TEXTURE_1D:
197 /* For 1D textures, we will have a height of 1, so we can use 2D
198 * but set T wrap to repeat */
199 sv->TE_SAMPLER_CONFIG0_MASK = ~VIVS_TE_SAMPLER_CONFIG0_VWRAP__MASK;
200 sv->TE_SAMPLER_CONFIG0 |= VIVS_TE_SAMPLER_CONFIG0_VWRAP(TEXTURE_WRAPMODE_REPEAT);
201 /* fallthrough */
202 case PIPE_TEXTURE_2D:
203 case PIPE_TEXTURE_RECT:
204 sv->TE_SAMPLER_CONFIG0 |= VIVS_TE_SAMPLER_CONFIG0_TYPE(TEXTURE_TYPE_2D);
205 break;
206 case PIPE_TEXTURE_CUBE:
207 sv->TE_SAMPLER_CONFIG0 |= VIVS_TE_SAMPLER_CONFIG0_TYPE(TEXTURE_TYPE_CUBE_MAP);
208 break;
209 default:
210 BUG("Unhandled texture target");
211 free(sv);
212 return NULL;
213 }
214
215 sv->TE_SAMPLER_CONFIG1 = VIVS_TE_SAMPLER_CONFIG1_SWIZZLE_R(so->swizzle_r) |
216 VIVS_TE_SAMPLER_CONFIG1_SWIZZLE_G(so->swizzle_g) |
217 VIVS_TE_SAMPLER_CONFIG1_SWIZZLE_B(so->swizzle_b) |
218 VIVS_TE_SAMPLER_CONFIG1_SWIZZLE_A(so->swizzle_a) |
219 VIVS_TE_SAMPLER_CONFIG1_HALIGN(res->halign);
220 sv->TE_SAMPLER_SIZE = VIVS_TE_SAMPLER_SIZE_WIDTH(res->base.width0) |
221 VIVS_TE_SAMPLER_SIZE_HEIGHT(res->base.height0);
222 sv->TE_SAMPLER_LOG_SIZE =
223 VIVS_TE_SAMPLER_LOG_SIZE_WIDTH(etna_log2_fixp55(res->base.width0)) |
224 VIVS_TE_SAMPLER_LOG_SIZE_HEIGHT(etna_log2_fixp55(res->base.height0));
225
226 /* Set up levels-of-detail */
227 for (int lod = 0; lod <= res->base.last_level; ++lod) {
228 sv->TE_SAMPLER_LOD_ADDR[lod].bo = res->bo;
229 sv->TE_SAMPLER_LOD_ADDR[lod].offset = res->levels[lod].offset;
230 sv->TE_SAMPLER_LOD_ADDR[lod].flags = ETNA_RELOC_READ;
231 }
232 sv->min_lod = sv->base.u.tex.first_level << 5;
233 sv->max_lod = MIN2(sv->base.u.tex.last_level, res->base.last_level) << 5;
234
235 /* Workaround for npot textures -- it appears that only CLAMP_TO_EDGE is
236 * supported when the appropriate capability is not set. */
237 if (!ctx->specs.npot_tex_any_wrap &&
238 (!util_is_power_of_two(res->base.width0) || !util_is_power_of_two(res->base.height0))) {
239 sv->TE_SAMPLER_CONFIG0_MASK = ~(VIVS_TE_SAMPLER_CONFIG0_UWRAP__MASK |
240 VIVS_TE_SAMPLER_CONFIG0_VWRAP__MASK);
241 sv->TE_SAMPLER_CONFIG0 |=
242 VIVS_TE_SAMPLER_CONFIG0_UWRAP(TEXTURE_WRAPMODE_CLAMP_TO_EDGE) |
243 VIVS_TE_SAMPLER_CONFIG0_VWRAP(TEXTURE_WRAPMODE_CLAMP_TO_EDGE);
244 }
245
246 return &sv->base;
247 }
248
249 static void
250 etna_sampler_view_destroy(struct pipe_context *pctx,
251 struct pipe_sampler_view *view)
252 {
253 pipe_resource_reference(&view->texture, NULL);
254 FREE(view);
255 }
256
257 static void
258 set_sampler_views(struct etna_context *ctx, unsigned start, unsigned end,
259 unsigned nr, struct pipe_sampler_view **views)
260 {
261 unsigned i, j;
262 uint32_t mask = 1 << start;
263
264 for (i = start, j = 0; j < nr; i++, j++, mask <<= 1) {
265 pipe_sampler_view_reference(&ctx->sampler_view[i], views[j]);
266 if (views[j])
267 ctx->active_sampler_views |= mask;
268 else
269 ctx->active_sampler_views &= ~mask;
270 }
271
272 for (; i < end; i++, mask <<= 1) {
273 pipe_sampler_view_reference(&ctx->sampler_view[i], NULL);
274 ctx->active_sampler_views &= ~mask;
275 }
276 }
277
278 static inline void
279 etna_fragtex_set_sampler_views(struct etna_context *ctx, unsigned nr,
280 struct pipe_sampler_view **views)
281 {
282 unsigned start = 0;
283 unsigned end = start + ctx->specs.fragment_sampler_count;
284
285 set_sampler_views(ctx, start, end, nr, views);
286 ctx->num_fragment_sampler_views = nr;
287 }
288
289
290 static inline void
291 etna_vertex_set_sampler_views(struct etna_context *ctx, unsigned nr,
292 struct pipe_sampler_view **views)
293 {
294 unsigned start = ctx->specs.vertex_sampler_offset;
295 unsigned end = start + ctx->specs.vertex_sampler_count;
296
297 set_sampler_views(ctx, start, end, nr, views);
298 }
299
300 static void
301 etna_set_sampler_views(struct pipe_context *pctx, enum pipe_shader_type shader,
302 unsigned start_slot, unsigned num_views,
303 struct pipe_sampler_view **views)
304 {
305 struct etna_context *ctx = etna_context(pctx);
306 assert(start_slot == 0);
307
308 ctx->dirty |= ETNA_DIRTY_SAMPLER_VIEWS | ETNA_DIRTY_TEXTURE_CACHES;
309
310 for (unsigned idx = 0; idx < num_views; ++idx) {
311 if (views[idx])
312 etna_update_sampler_source(views[idx]);
313 }
314
315 switch (shader) {
316 case PIPE_SHADER_FRAGMENT:
317 etna_fragtex_set_sampler_views(ctx, num_views, views);
318 break;
319 case PIPE_SHADER_VERTEX:
320 etna_vertex_set_sampler_views(ctx, num_views, views);
321 break;
322 default:;
323 }
324 }
325
326 static void
327 etna_texture_barrier(struct pipe_context *pctx, unsigned flags)
328 {
329 struct etna_context *ctx = etna_context(pctx);
330 /* clear color and texture cache to make sure that texture unit reads
331 * what has been written */
332 etna_set_state(ctx->stream, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR | VIVS_GL_FLUSH_CACHE_TEXTURE);
333 }
334
335 void
336 etna_texture_init(struct pipe_context *pctx)
337 {
338 pctx->create_sampler_state = etna_create_sampler_state;
339 pctx->bind_sampler_states = etna_bind_sampler_states;
340 pctx->delete_sampler_state = etna_delete_sampler_state;
341 pctx->set_sampler_views = etna_set_sampler_views;
342 pctx->create_sampler_view = etna_create_sampler_view;
343 pctx->sampler_view_destroy = etna_sampler_view_destroy;
344 pctx->texture_barrier = etna_texture_barrier;
345 }