2 * Copyright 2018-2019 Alyssa Rosenzweig
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:
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
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
25 #include "pan_context.h"
27 #include "pan_format.h"
29 #include "util/u_format.h"
32 panfrost_invert_swizzle(const unsigned char *in
, unsigned char *out
)
34 /* First, default to all zeroes to prevent uninitialized junk */
36 for (unsigned c
= 0; c
< 4; ++c
)
37 out
[c
] = PIPE_SWIZZLE_0
;
39 /* Now "do" what the swizzle says */
41 for (unsigned c
= 0; c
< 4; ++c
) {
42 unsigned char i
= in
[c
];
45 assert(PIPE_SWIZZLE_X
== 0);
46 if (i
> PIPE_SWIZZLE_W
)
50 unsigned idx
= i
- PIPE_SWIZZLE_X
;
51 out
[idx
] = PIPE_SWIZZLE_X
+ c
;
55 static struct mali_rt_format
56 panfrost_mfbd_format(struct pipe_surface
*surf
)
58 /* Explode details on the format */
60 const struct util_format_description
*desc
=
61 util_format_description(surf
->format
);
63 /* The swizzle for rendering is inverted from texturing */
65 unsigned char swizzle
[4];
66 panfrost_invert_swizzle(desc
->swizzle
, swizzle
);
68 /* Fill in accordingly, defaulting to 8-bit UNORM */
70 struct mali_rt_format fmt
= {
73 .nr_channels
= MALI_POSITIVE(desc
->nr_channels
),
76 .swizzle
= panfrost_translate_swizzle_4(swizzle
),
80 if (desc
->colorspace
== UTIL_FORMAT_COLORSPACE_SRGB
)
81 fmt
.flags
|= MALI_MFBD_FORMAT_SRGB
;
83 /* sRGB handled as a dedicated flag */
84 enum pipe_format linearized
= util_format_linear(surf
->format
);
86 /* If RGB, we're good to go */
87 if (util_format_is_unorm8(desc
))
90 /* Set flags for alternative formats */
93 case PIPE_FORMAT_B5G6R5_UNORM
:
94 fmt
.unk1
= 0x14000000;
95 fmt
.nr_channels
= MALI_POSITIVE(2);
99 case PIPE_FORMAT_A4B4G4R4_UNORM
:
100 case PIPE_FORMAT_B4G4R4A4_UNORM
:
101 fmt
.unk1
= 0x10000000;
103 fmt
.nr_channels
= MALI_POSITIVE(1);
106 case PIPE_FORMAT_R10G10B10A2_UNORM
:
107 case PIPE_FORMAT_B10G10R10A2_UNORM
:
108 case PIPE_FORMAT_R10G10B10X2_UNORM
:
109 case PIPE_FORMAT_B10G10R10X2_UNORM
:
110 fmt
.unk1
= 0x08000000;
112 fmt
.nr_channels
= MALI_POSITIVE(1);
116 case PIPE_FORMAT_R8_UINT
:
117 case PIPE_FORMAT_R8_SINT
:
118 fmt
.unk1
= 0x80000000;
120 fmt
.nr_channels
= MALI_POSITIVE(1);
124 case PIPE_FORMAT_R11G11B10_FLOAT
:
125 case PIPE_FORMAT_R8G8B8A8_UINT
:
126 case PIPE_FORMAT_R8G8B8A8_SINT
:
127 case PIPE_FORMAT_R16G16_FLOAT
:
128 case PIPE_FORMAT_R16G16_UINT
:
129 case PIPE_FORMAT_R16G16_SINT
:
130 case PIPE_FORMAT_R32_FLOAT
:
131 case PIPE_FORMAT_R32_UINT
:
132 case PIPE_FORMAT_R32_SINT
:
133 case PIPE_FORMAT_R10G10B10A2_UINT
:
134 fmt
.unk1
= 0x88000000;
136 fmt
.nr_channels
= MALI_POSITIVE(4);
140 case PIPE_FORMAT_R8G8_UINT
:
141 case PIPE_FORMAT_R8G8_SINT
:
142 case PIPE_FORMAT_R16_FLOAT
:
143 case PIPE_FORMAT_R16_UINT
:
144 case PIPE_FORMAT_R16_SINT
:
145 case PIPE_FORMAT_B5G5R5A1_UNORM
:
146 fmt
.unk1
= 0x84000000;
148 fmt
.nr_channels
= MALI_POSITIVE(2);
152 case PIPE_FORMAT_R32G32_FLOAT
:
153 case PIPE_FORMAT_R32G32_SINT
:
154 case PIPE_FORMAT_R32G32_UINT
:
155 case PIPE_FORMAT_R16G16B16A16_FLOAT
:
156 case PIPE_FORMAT_R16G16B16A16_SINT
:
157 case PIPE_FORMAT_R16G16B16A16_UINT
:
158 fmt
.unk1
= 0x8c000000;
160 fmt
.nr_channels
= MALI_POSITIVE(2);
163 /* Generic 128-bit */
164 case PIPE_FORMAT_R32G32B32A32_FLOAT
:
165 case PIPE_FORMAT_R32G32B32A32_SINT
:
166 case PIPE_FORMAT_R32G32B32A32_UINT
:
167 fmt
.unk1
= 0x90000000;
169 fmt
.nr_channels
= MALI_POSITIVE(4);
173 unreachable("Invalid format rendering");
182 struct panfrost_job
*job
,
183 struct bifrost_framebuffer
*fb
,
184 struct bifrost_fb_extra
*fbx
,
185 struct bifrost_render_target
*rts
,
188 for (unsigned i
= 0; i
< rt_count
; ++i
) {
189 if (!(job
->clear
& (PIPE_CLEAR_COLOR0
<< i
)))
192 rts
[i
].clear_color_1
= job
->clear_color
[i
][0];
193 rts
[i
].clear_color_2
= job
->clear_color
[i
][1];
194 rts
[i
].clear_color_3
= job
->clear_color
[i
][2];
195 rts
[i
].clear_color_4
= job
->clear_color
[i
][3];
198 if (job
->clear
& PIPE_CLEAR_DEPTH
) {
199 fb
->clear_depth
= job
->clear_depth
;
202 if (job
->clear
& PIPE_CLEAR_STENCIL
) {
203 fb
->clear_stencil
= job
->clear_stencil
;
208 panfrost_mfbd_set_cbuf(
209 struct bifrost_render_target
*rt
,
210 struct pipe_surface
*surf
)
212 struct panfrost_resource
*rsrc
= pan_resource(surf
->texture
);
214 unsigned level
= surf
->u
.tex
.level
;
215 unsigned first_layer
= surf
->u
.tex
.first_layer
;
216 assert(surf
->u
.tex
.last_layer
== first_layer
);
217 int stride
= rsrc
->slices
[level
].stride
;
219 mali_ptr base
= panfrost_get_texture_address(rsrc
, level
, first_layer
);
221 rt
->format
= panfrost_mfbd_format(surf
);
223 /* Now, we set the layout specific pieces */
225 if (rsrc
->layout
== PAN_LINEAR
) {
226 rt
->format
.block
= MALI_MFBD_BLOCK_LINEAR
;
227 rt
->framebuffer
= base
;
228 rt
->framebuffer_stride
= stride
/ 16;
229 } else if (rsrc
->layout
== PAN_TILED
) {
230 rt
->format
.block
= MALI_MFBD_BLOCK_TILED
;
231 rt
->framebuffer
= base
;
232 rt
->framebuffer_stride
= stride
;
233 } else if (rsrc
->layout
== PAN_AFBC
) {
234 rt
->format
.block
= MALI_MFBD_BLOCK_AFBC
;
236 unsigned header_size
= rsrc
->slices
[level
].header_size
;
238 rt
->framebuffer
= base
+ header_size
;
239 rt
->afbc
.metadata
= base
;
241 rt
->afbc
.unk
= 0x30009;
243 /* TODO: The blob sets this to something nonzero, but it's not
244 * clear what/how to calculate/if it matters */
245 rt
->framebuffer_stride
= 0;
247 fprintf(stderr
, "Invalid render layout (cbuf)");
252 /* Is a format encoded like Z24S8 and therefore compatible for render? */
255 panfrost_is_z24s8_variant(enum pipe_format fmt
)
258 case PIPE_FORMAT_Z24_UNORM_S8_UINT
:
259 case PIPE_FORMAT_Z24X8_UNORM
:
267 panfrost_mfbd_set_zsbuf(
268 struct bifrost_framebuffer
*fb
,
269 struct bifrost_fb_extra
*fbx
,
270 struct pipe_surface
*surf
)
272 struct panfrost_resource
*rsrc
= pan_resource(surf
->texture
);
274 unsigned level
= surf
->u
.tex
.level
;
275 assert(surf
->u
.tex
.first_layer
== 0);
277 unsigned offset
= rsrc
->slices
[level
].offset
;
279 if (rsrc
->layout
== PAN_AFBC
) {
280 /* The only Z/S format we can compress is Z24S8 or variants
281 * thereof (handled by the state tracker) */
282 assert(panfrost_is_z24s8_variant(surf
->format
));
284 mali_ptr base
= rsrc
->bo
->gpu
+ offset
;
285 unsigned header_size
= rsrc
->slices
[level
].header_size
;
287 fb
->mfbd_flags
|= MALI_MFBD_EXTRA
;
296 fbx
->ds_afbc
.depth_stencil
= base
+ header_size
;
297 fbx
->ds_afbc
.depth_stencil_afbc_metadata
= base
;
298 fbx
->ds_afbc
.depth_stencil_afbc_stride
= 0;
300 fbx
->ds_afbc
.zero1
= 0x10009;
301 fbx
->ds_afbc
.padding
= 0x1000;
302 } else if (rsrc
->layout
== PAN_LINEAR
) {
303 /* TODO: Z32F(S8) support, which is always linear */
305 int stride
= rsrc
->slices
[level
].stride
;
307 fb
->mfbd_flags
|= MALI_MFBD_EXTRA
;
308 fbx
->flags
|= MALI_EXTRA_PRESENT
| MALI_EXTRA_ZS
;
310 fbx
->ds_linear
.depth
= rsrc
->bo
->gpu
+ offset
;
311 fbx
->ds_linear
.depth_stride
= stride
;
313 if (panfrost_is_z24s8_variant(surf
->format
)) {
315 } else if (surf
->format
== PIPE_FORMAT_Z32_UNORM
) {
316 /* default flags (0 in bottom place) */
317 } else if (surf
->format
== PIPE_FORMAT_Z32_FLOAT
) {
319 fb
->mfbd_flags
^= 0x100;
320 fb
->mfbd_flags
|= 0x200;
321 } else if (surf
->format
== PIPE_FORMAT_Z32_FLOAT_S8X24_UINT
) {
322 fbx
->flags
|= 0x1000A;
323 fb
->mfbd_flags
^= 0x100;
324 fb
->mfbd_flags
|= 0x201;
326 struct panfrost_resource
*stencil
= rsrc
->separate_stencil
;
327 struct panfrost_slice stencil_slice
= stencil
->slices
[level
];
329 fbx
->ds_linear
.stencil
= stencil
->bo
->gpu
+ stencil_slice
.offset
;
330 fbx
->ds_linear
.stencil_stride
= stencil_slice
.stride
;
338 /* Helper for sequential uploads used for MFBD */
340 #define UPLOAD(dest, offset, src, max) { \
341 size_t sz = sizeof(*src); \
342 memcpy(dest.cpu + offset, src, sz); \
343 assert((offset + sz) <= max); \
348 panfrost_mfbd_upload(
349 struct panfrost_context
*ctx
,
350 struct bifrost_framebuffer
*fb
,
351 struct bifrost_fb_extra
*fbx
,
352 struct bifrost_render_target
*rts
,
357 /* There may be extra data stuck in the middle */
358 bool has_extra
= fb
->mfbd_flags
& MALI_MFBD_EXTRA
;
360 /* Compute total size for transfer */
363 sizeof(struct bifrost_framebuffer
) +
364 (has_extra
? sizeof(struct bifrost_fb_extra
) : 0) +
365 sizeof(struct bifrost_render_target
) * 4;
367 struct panfrost_transfer m_f_trans
=
368 panfrost_allocate_transient(ctx
, total_sz
);
370 /* Do the transfer */
372 UPLOAD(m_f_trans
, offset
, fb
, total_sz
);
375 UPLOAD(m_f_trans
, offset
, fbx
, total_sz
);
377 for (unsigned c
= 0; c
< 4; ++c
) {
378 UPLOAD(m_f_trans
, offset
, &rts
[c
], total_sz
);
381 /* Return pointer suitable for the fragment section */
384 (has_extra
? MALI_MFBD_TAG_EXTRA
: 0) |
385 (MALI_POSITIVE(rt_count
) << 2);
387 return m_f_trans
.gpu
| tag
;
392 /* Creates an MFBD for the FRAGMENT section of the bound framebuffer */
395 panfrost_mfbd_fragment(struct panfrost_context
*ctx
, bool has_draws
)
397 struct panfrost_job
*job
= panfrost_get_job_for_fbo(ctx
);
399 struct bifrost_framebuffer fb
= panfrost_emit_mfbd(ctx
, has_draws
);
400 struct bifrost_fb_extra fbx
= {};
401 struct bifrost_render_target rts
[4] = {};
403 /* We always upload at least one dummy GL_NONE render target */
405 unsigned rt_descriptors
=
406 MAX2(ctx
->pipe_framebuffer
.nr_cbufs
, 1);
408 fb
.rt_count_1
= MALI_POSITIVE(rt_descriptors
);
409 fb
.rt_count_2
= rt_descriptors
;
410 fb
.mfbd_flags
= 0x100;
412 /* TODO: MRT clear */
413 panfrost_mfbd_clear(job
, &fb
, &fbx
, rts
, fb
.rt_count_2
);
416 /* Upload either the render target or a dummy GL_NONE target */
418 for (int cb
= 0; cb
< rt_descriptors
; ++cb
) {
419 struct pipe_surface
*surf
= ctx
->pipe_framebuffer
.cbufs
[cb
];
422 panfrost_mfbd_set_cbuf(&rts
[cb
], surf
);
424 /* What is this? Looks like some extension of the bpp
425 * field. Maybe it establishes how much internal
426 * tilebuffer space is reserved? */
428 unsigned bpp
= util_format_get_blocksize(surf
->format
);
429 fb
.rt_count_2
= MAX2(fb
.rt_count_2
, ALIGN_POT(bpp
, 4) / 4);
431 struct mali_rt_format null_rt
= {
436 rts
[cb
].format
= null_rt
;
437 rts
[cb
].framebuffer
= 0;
438 rts
[cb
].framebuffer_stride
= 0;
441 /* TODO: Break out the field */
442 rts
[cb
].format
.unk1
|= (cb
* 0x400);
445 if (ctx
->pipe_framebuffer
.zsbuf
) {
446 panfrost_mfbd_set_zsbuf(&fb
, &fbx
, ctx
->pipe_framebuffer
.zsbuf
);
449 /* When scanning out, the depth buffer is immediately invalidated, so
450 * we don't need to waste bandwidth writing it out. This can improve
451 * performance substantially (Z32_UNORM 1080p @ 60fps is 475 MB/s of
452 * memory bandwidth!).
454 * The exception is ReadPixels, but this is not supported on GLES so we
455 * can safely ignore it. */
457 if (panfrost_is_scanout(ctx
)) {
458 job
->requirements
&= ~PAN_REQ_DEPTH_WRITE
;
461 /* Actualize the requirements */
463 if (job
->requirements
& PAN_REQ_MSAA
) {
464 rts
[0].format
.flags
|= MALI_MFBD_FORMAT_MSAA
;
467 fb
.unk1
|= (1 << 4) | (1 << 1);
471 if (job
->requirements
& PAN_REQ_DEPTH_WRITE
)
472 fb
.mfbd_flags
|= MALI_MFBD_DEPTH_WRITE
;
474 /* Checksumming only works with a single render target */
476 if (ctx
->pipe_framebuffer
.nr_cbufs
== 1) {
477 struct pipe_surface
*surf
= ctx
->pipe_framebuffer
.cbufs
[0];
478 struct panfrost_resource
*rsrc
= pan_resource(surf
->texture
);
479 struct panfrost_bo
*bo
= rsrc
->bo
;
481 if (rsrc
->checksummed
) {
482 unsigned level
= surf
->u
.tex
.level
;
483 struct panfrost_slice
*slice
= &rsrc
->slices
[level
];
485 fb
.mfbd_flags
|= MALI_MFBD_EXTRA
;
486 fbx
.flags
|= MALI_EXTRA_PRESENT
;
487 fbx
.checksum_stride
= slice
->checksum_stride
;
488 fbx
.checksum
= bo
->gpu
+ slice
->checksum_offset
;
492 return panfrost_mfbd_upload(ctx
, &fb
, &fbx
, rts
, rt_descriptors
);