2 * Copyright (C) 2008 VMware, Inc.
3 * Copyright (C) 2014 Broadcom
4 * Copyright (C) 2018-2019 Alyssa Rosenzweig
5 * Copyright (C) 2019-2020 Collabora, Ltd.
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice (including the next
15 * paragraph) shall be included in all copies or substantial portions of the
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
21 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
28 #include "util/macros.h"
29 #include "util/u_math.h"
30 #include "pan_texture.h"
32 /* Generates a texture descriptor. Ideally, descriptors are immutable after the
33 * texture is created, so we can keep these hanging around in GPU memory in a
34 * dedicated BO and not have to worry. In practice there are some minor gotchas
35 * with this (the driver sometimes will change the format of a texture on the
36 * fly for compression) but it's fast enough to just regenerate the descriptor
37 * in those cases, rather than monkeypatching at drawtime.
39 * A texture descriptor consists of a 32-byte mali_texture_descriptor structure
40 * followed by a variable number of pointers. Due to this variance and
41 * potentially large size, we actually upload directly rather than returning
42 * the descriptor. Whether the user does a copy themselves or not is irrelevant
46 /* Check if we need to set a custom stride by computing the "expected"
47 * stride and comparing it to what the user actually wants. Only applies
48 * to linear textures, since tiled/compressed textures have strict
49 * alignment requirements for their strides as it is */
52 panfrost_needs_explicit_stride(
53 struct panfrost_slice
*slices
,
55 unsigned first_level
, unsigned last_level
,
56 unsigned bytes_per_pixel
)
58 for (unsigned l
= first_level
; l
<= last_level
; ++l
) {
59 unsigned actual
= slices
[l
].stride
;
60 unsigned expected
= u_minify(width
, l
) * bytes_per_pixel
;
62 if (actual
!= expected
)
69 /* A Scalable Texture Compression (ASTC) corresponds to just a few texture type
70 * in the hardware, but in fact can be parametrized to have various widths and
71 * heights for the so-called "stretch factor". It turns out these parameters
72 * are stuffed in the bottom bits of the payload pointers. This functions
73 * computes these magic stuffing constants based on the ASTC format in use. The
74 * constant in a given dimension is 3-bits, and two are stored side-by-side for
75 * each active dimension.
79 panfrost_astc_stretch(unsigned dim
)
81 assert(dim
>= 4 && dim
<= 12);
82 return MIN2(dim
, 11) - 4;
85 /* Texture addresses are tagged with information about compressed formats.
86 * AFBC uses a bit for whether the colorspace transform is enabled (RGB and
88 * For ASTC, this is a "stretch factor" encoding the block size. */
91 panfrost_compression_tag(
92 const struct util_format_description
*desc
,
93 enum mali_format format
, enum mali_texture_layout layout
)
95 if (layout
== MALI_TEXTURE_AFBC
)
96 return desc
->nr_channels
>= 3;
97 else if (format
== MALI_ASTC_2D_LDR
|| format
== MALI_ASTC_2D_HDR
)
98 return (panfrost_astc_stretch(desc
->block
.height
) << 3) |
99 panfrost_astc_stretch(desc
->block
.width
);
105 /* Cubemaps have 6 faces as "layers" in between each actual layer. We
106 * need to fix this up. TODO: logic wrong in the asserted out cases ...
107 * can they happen, perhaps from cubemap arrays? */
110 panfrost_adjust_cube_dimensions(
111 unsigned *first_face
, unsigned *last_face
,
112 unsigned *first_layer
, unsigned *last_layer
)
114 *first_face
= *first_layer
% 6;
115 *last_face
= *last_layer
% 6;
119 assert((*first_layer
== *last_layer
) || (*first_face
== 0 && *last_face
== 5));
122 /* Following the texture descriptor is a number of pointers. How many? */
125 panfrost_texture_num_elements(
126 unsigned first_level
, unsigned last_level
,
127 unsigned first_layer
, unsigned last_layer
,
129 bool is_cube
, bool manual_stride
)
131 unsigned first_face
= 0, last_face
= 0;
134 panfrost_adjust_cube_dimensions(&first_face
, &last_face
,
135 &first_layer
, &last_layer
);
138 unsigned levels
= 1 + last_level
- first_level
;
139 unsigned layers
= 1 + last_layer
- first_layer
;
140 unsigned faces
= 1 + last_face
- first_face
;
141 unsigned num_elements
= levels
* layers
* faces
* MAX2(nr_samples
, 1);
149 /* Conservative estimate of the size of the texture payload a priori.
150 * Average case, size equal to the actual size. Worst case, off by 2x (if
151 * a manual stride is not needed on a linear texture). Returned value
152 * must be greater than or equal to the actual size, so it's safe to use
153 * as an allocation amount */
156 panfrost_estimate_texture_payload_size(
157 unsigned first_level
, unsigned last_level
,
158 unsigned first_layer
, unsigned last_layer
,
160 enum mali_texture_type type
, enum mali_texture_layout layout
)
162 /* Assume worst case */
163 unsigned manual_stride
= (layout
== MALI_TEXTURE_LINEAR
);
165 unsigned elements
= panfrost_texture_num_elements(
166 first_level
, last_level
,
167 first_layer
, last_layer
,
169 type
== MALI_TEX_CUBE
, manual_stride
);
171 return sizeof(mali_ptr
) * elements
;
174 /* Bifrost requires a tile stride for tiled textures. This stride is computed
175 * as (16 * bpp * width) assuming there is at least one tile (width >= 16).
176 * Otherwise if height <= 16, the blob puts zero. Interactions with AFBC are
181 panfrost_nonlinear_stride(enum mali_texture_layout layout
,
182 unsigned bytes_per_pixel
,
186 if (layout
== MALI_TEXTURE_TILED
) {
187 return (height
<= 16) ? 0 : (16 * bytes_per_pixel
* ALIGN_POT(width
, 16));
189 unreachable("TODO: AFBC on Bifrost");
194 panfrost_emit_texture_payload(
196 const struct util_format_description
*desc
,
197 enum mali_format mali_format
,
198 enum mali_texture_type type
,
199 enum mali_texture_layout layout
,
200 unsigned width
, unsigned height
,
201 unsigned first_level
, unsigned last_level
,
202 unsigned first_layer
, unsigned last_layer
,
204 unsigned cube_stride
,
207 struct panfrost_slice
*slices
)
209 base
|= panfrost_compression_tag(desc
, mali_format
, layout
);
211 /* Inject the addresses in, interleaving array indices, mip levels,
212 * cube faces, and strides in that order */
214 unsigned first_face
= 0, last_face
= 0, face_mult
= 1;
216 if (type
== MALI_TEX_CUBE
) {
218 panfrost_adjust_cube_dimensions(&first_face
, &last_face
, &first_layer
, &last_layer
);
221 nr_samples
= MAX2(nr_samples
, 1);
225 for (unsigned w
= first_layer
; w
<= last_layer
; ++w
) {
226 for (unsigned l
= first_level
; l
<= last_level
; ++l
) {
227 for (unsigned f
= first_face
; f
<= last_face
; ++f
) {
228 for (unsigned s
= 0; s
< nr_samples
; ++s
) {
229 payload
[idx
++] = base
+ panfrost_texture_offset(
230 slices
, type
== MALI_TEX_3D
,
231 cube_stride
, l
, w
* face_mult
+ f
, s
);
234 payload
[idx
++] = (layout
== MALI_TEXTURE_LINEAR
) ?
236 panfrost_nonlinear_stride(layout
,
237 MAX2(desc
->block
.bits
/ 8, 1),
239 u_minify(height
, l
));
247 #define MALI_SWIZZLE_R001 \
248 (MALI_CHANNEL_RED << 0) | \
249 (MALI_CHANNEL_ZERO << 3) | \
250 (MALI_CHANNEL_ZERO << 6) | \
251 (MALI_CHANNEL_ONE << 9)
253 #define MALI_SWIZZLE_A001 \
254 (MALI_CHANNEL_ALPHA << 0) | \
255 (MALI_CHANNEL_ZERO << 3) | \
256 (MALI_CHANNEL_ZERO << 6) | \
257 (MALI_CHANNEL_ONE << 9)
261 panfrost_new_texture(
263 uint16_t width
, uint16_t height
,
264 uint16_t depth
, uint16_t array_size
,
265 enum pipe_format format
,
266 enum mali_texture_type type
,
267 enum mali_texture_layout layout
,
268 unsigned first_level
, unsigned last_level
,
269 unsigned first_layer
, unsigned last_layer
,
271 unsigned cube_stride
,
274 struct panfrost_slice
*slices
)
276 const struct util_format_description
*desc
=
277 util_format_description(format
);
279 unsigned bytes_per_pixel
= util_format_get_blocksize(format
);
281 enum mali_format mali_format
= panfrost_pipe_format_table
[desc
->format
].hw
;
284 bool manual_stride
= (layout
== MALI_TEXTURE_LINEAR
)
285 && panfrost_needs_explicit_stride(slices
, width
,
286 first_level
, last_level
, bytes_per_pixel
);
288 struct mali_texture_descriptor descriptor
= {
289 .width
= MALI_POSITIVE(u_minify(width
, first_level
)),
290 .height
= MALI_POSITIVE(u_minify(height
, first_level
)),
291 .depth
= MALI_POSITIVE(u_minify(depth
, first_level
)),
292 .array_size
= MALI_POSITIVE(array_size
),
294 .swizzle
= (format
== PIPE_FORMAT_X24S8_UINT
) ?
296 (format
== PIPE_FORMAT_S8_UINT
) ?
298 panfrost_translate_swizzle_4(desc
->swizzle
),
299 .format
= mali_format
,
300 .srgb
= (desc
->colorspace
== UTIL_FORMAT_COLORSPACE_SRGB
),
303 .manual_stride
= manual_stride
,
306 .levels
= last_level
- first_level
,
310 memcpy(out
, &descriptor
, sizeof(descriptor
));
312 mali_ptr
*payload
= (mali_ptr
*) (out
+ sizeof(struct mali_texture_descriptor
));
313 panfrost_emit_texture_payload(
320 first_level
, last_level
,
321 first_layer
, last_layer
,
330 panfrost_new_texture_bifrost(
331 struct bifrost_texture_descriptor
*descriptor
,
332 uint16_t width
, uint16_t height
,
333 uint16_t depth
, uint16_t array_size
,
334 enum pipe_format format
,
335 enum mali_texture_type type
,
336 enum mali_texture_layout layout
,
337 unsigned first_level
, unsigned last_level
,
338 unsigned first_layer
, unsigned last_layer
,
340 unsigned cube_stride
,
343 struct panfrost_slice
*slices
,
344 struct panfrost_bo
*payload
)
346 const struct util_format_description
*desc
=
347 util_format_description(format
);
349 enum mali_format mali_format
= panfrost_pipe_format_table
[desc
->format
].hw
;
352 panfrost_emit_texture_payload(
353 (mali_ptr
*) payload
->cpu
,
359 first_level
, last_level
,
360 first_layer
, last_layer
,
363 true, /* Stride explicit on Bifrost */
367 descriptor
->format_unk
= 0x2;
368 descriptor
->type
= type
;
369 descriptor
->format
= mali_format
;
370 descriptor
->srgb
= (desc
->colorspace
== UTIL_FORMAT_COLORSPACE_SRGB
);
371 descriptor
->format_unk3
= 0x0;
372 descriptor
->width
= MALI_POSITIVE(u_minify(width
, first_level
));
373 descriptor
->height
= MALI_POSITIVE(u_minify(height
, first_level
));
374 descriptor
->swizzle
= swizzle
;
375 descriptor
->layout
= layout
;
376 descriptor
->levels
= last_level
- first_level
;
377 descriptor
->unk1
= 0x0;
378 descriptor
->levels_unk
= 0;
379 descriptor
->level_2
= last_level
- first_level
;
380 descriptor
->payload
= payload
->gpu
;
381 descriptor
->array_size
= MALI_POSITIVE(array_size
);
382 descriptor
->unk4
= 0x0;
383 descriptor
->depth
= MALI_POSITIVE(u_minify(depth
, first_level
));
384 descriptor
->unk5
= 0x0;
387 /* Computes sizes for checksumming, which is 8 bytes per 16x16 tile.
388 * Checksumming is believed to be a CRC variant (CRC64 based on the size?).
389 * This feature is also known as "transaction elimination". */
391 #define CHECKSUM_TILE_WIDTH 16
392 #define CHECKSUM_TILE_HEIGHT 16
393 #define CHECKSUM_BYTES_PER_TILE 8
396 panfrost_compute_checksum_size(
397 struct panfrost_slice
*slice
,
401 unsigned aligned_width
= ALIGN_POT(width
, CHECKSUM_TILE_WIDTH
);
402 unsigned aligned_height
= ALIGN_POT(height
, CHECKSUM_TILE_HEIGHT
);
404 unsigned tile_count_x
= aligned_width
/ CHECKSUM_TILE_WIDTH
;
405 unsigned tile_count_y
= aligned_height
/ CHECKSUM_TILE_HEIGHT
;
407 slice
->checksum_stride
= tile_count_x
* CHECKSUM_BYTES_PER_TILE
;
409 return slice
->checksum_stride
* tile_count_y
;
413 panfrost_get_layer_stride(struct panfrost_slice
*slices
, bool is_3d
, unsigned cube_stride
, unsigned level
)
415 return is_3d
? slices
[level
].size0
: cube_stride
;
418 /* Computes the offset into a texture at a particular level/face. Add to
419 * the base address of a texture to get the address to that level/face */
422 panfrost_texture_offset(struct panfrost_slice
*slices
, bool is_3d
, unsigned cube_stride
, unsigned level
, unsigned face
, unsigned sample
)
424 unsigned layer_stride
= panfrost_get_layer_stride(slices
, is_3d
, cube_stride
, level
);
425 return slices
[level
].offset
+ (face
* layer_stride
) + (sample
* slices
[level
].size0
);