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
26 #include "pan_context.h"
27 #include "pan_cmdstream.h"
29 #include "panfrost-quirks.h"
31 static struct mali_rt_format
32 panfrost_mfbd_format(struct pipe_surface
*surf
)
34 struct panfrost_device
*dev
= pan_device(surf
->context
->screen
);
35 bool is_bifrost
= dev
->quirks
& IS_BIFROST
;
37 /* Explode details on the format */
39 const struct util_format_description
*desc
=
40 util_format_description(surf
->format
);
42 /* The swizzle for rendering is inverted from texturing */
44 unsigned char swizzle
[4];
45 panfrost_invert_swizzle(desc
->swizzle
, swizzle
);
47 /* Fill in accordingly, defaulting to 8-bit UNORM */
49 struct mali_rt_format fmt
= {
52 .nr_channels
= MALI_POSITIVE(desc
->nr_channels
),
56 .swizzle
= panfrost_translate_swizzle_4(swizzle
),
60 if (desc
->colorspace
== UTIL_FORMAT_COLORSPACE_SRGB
)
61 fmt
.flags
|= MALI_MFBD_FORMAT_SRGB
;
63 /* sRGB handled as a dedicated flag */
64 enum pipe_format linearized
= util_format_linear(surf
->format
);
66 /* If RGB, we're good to go */
67 if (util_format_is_unorm8(desc
))
70 /* Set flags for alternative formats */
73 case PIPE_FORMAT_B5G6R5_UNORM
:
74 fmt
.unk1
= 0x14000000;
75 fmt
.nr_channels
= MALI_POSITIVE(2);
79 case PIPE_FORMAT_A4B4G4R4_UNORM
:
80 case PIPE_FORMAT_B4G4R4A4_UNORM
:
81 fmt
.unk1
= 0x10000000;
83 fmt
.nr_channels
= MALI_POSITIVE(1);
86 case PIPE_FORMAT_R10G10B10A2_UNORM
:
87 case PIPE_FORMAT_B10G10R10A2_UNORM
:
88 case PIPE_FORMAT_R10G10B10X2_UNORM
:
89 case PIPE_FORMAT_B10G10R10X2_UNORM
:
90 fmt
.unk1
= 0x08000000;
92 fmt
.nr_channels
= MALI_POSITIVE(1);
96 case PIPE_FORMAT_R8_UINT
:
97 case PIPE_FORMAT_R8_SINT
:
98 fmt
.unk1
= 0x80000000;
100 fmt
.nr_channels
= MALI_POSITIVE(1);
104 case PIPE_FORMAT_R11G11B10_FLOAT
:
105 case PIPE_FORMAT_R8G8B8A8_UINT
:
106 case PIPE_FORMAT_R8G8B8A8_SINT
:
107 case PIPE_FORMAT_R16G16_FLOAT
:
108 case PIPE_FORMAT_R16G16_UINT
:
109 case PIPE_FORMAT_R16G16_SINT
:
110 case PIPE_FORMAT_R32_FLOAT
:
111 case PIPE_FORMAT_R32_UINT
:
112 case PIPE_FORMAT_R32_SINT
:
113 case PIPE_FORMAT_R10G10B10A2_UINT
:
114 fmt
.unk1
= 0x88000000;
116 fmt
.nr_channels
= MALI_POSITIVE(4);
120 case PIPE_FORMAT_R8G8_UINT
:
121 case PIPE_FORMAT_R8G8_SINT
:
122 case PIPE_FORMAT_R16_FLOAT
:
123 case PIPE_FORMAT_R16_UINT
:
124 case PIPE_FORMAT_R16_SINT
:
125 case PIPE_FORMAT_B5G5R5A1_UNORM
:
126 fmt
.unk1
= 0x84000000;
128 fmt
.nr_channels
= MALI_POSITIVE(2);
132 case PIPE_FORMAT_R32G32_FLOAT
:
133 case PIPE_FORMAT_R32G32_SINT
:
134 case PIPE_FORMAT_R32G32_UINT
:
135 case PIPE_FORMAT_R16G16B16A16_FLOAT
:
136 case PIPE_FORMAT_R16G16B16A16_SINT
:
137 case PIPE_FORMAT_R16G16B16A16_UINT
:
138 fmt
.unk1
= 0x8c000000;
140 fmt
.nr_channels
= MALI_POSITIVE(2);
143 /* Generic 128-bit */
144 case PIPE_FORMAT_R32G32B32A32_FLOAT
:
145 case PIPE_FORMAT_R32G32B32A32_SINT
:
146 case PIPE_FORMAT_R32G32B32A32_UINT
:
147 fmt
.unk1
= 0x90000000;
149 fmt
.nr_channels
= MALI_POSITIVE(4);
153 unreachable("Invalid format rendering");
162 struct panfrost_batch
*batch
,
163 struct mali_framebuffer
*fb
,
164 struct mali_framebuffer_extra
*fbx
,
165 struct mali_render_target
*rts
,
168 struct panfrost_context
*ctx
= batch
->ctx
;
169 struct pipe_context
*gallium
= (struct pipe_context
*) ctx
;
170 struct panfrost_device
*dev
= pan_device(gallium
->screen
);
172 for (unsigned i
= 0; i
< rt_count
; ++i
) {
173 if (!(batch
->clear
& (PIPE_CLEAR_COLOR0
<< i
)))
176 rts
[i
].clear_color_1
= batch
->clear_color
[i
][0];
177 rts
[i
].clear_color_2
= batch
->clear_color
[i
][1];
178 rts
[i
].clear_color_3
= batch
->clear_color
[i
][2];
179 rts
[i
].clear_color_4
= batch
->clear_color
[i
][3];
182 if (batch
->clear
& PIPE_CLEAR_DEPTH
) {
183 fb
->clear_depth
= batch
->clear_depth
;
186 if (batch
->clear
& PIPE_CLEAR_STENCIL
) {
187 fb
->clear_stencil
= batch
->clear_stencil
;
190 if (dev
->quirks
& IS_BIFROST
) {
191 fbx
->clear_color_1
= batch
->clear_color
[0][0];
192 fbx
->clear_color_2
= 0xc0000000 | (fbx
->clear_color_1
& 0xffff); /* WTF? */
197 panfrost_mfbd_set_cbuf(
198 struct mali_render_target
*rt
,
199 struct pipe_surface
*surf
)
201 struct panfrost_resource
*rsrc
= pan_resource(surf
->texture
);
203 unsigned level
= surf
->u
.tex
.level
;
204 unsigned first_layer
= surf
->u
.tex
.first_layer
;
205 assert(surf
->u
.tex
.last_layer
== first_layer
);
206 int stride
= rsrc
->slices
[level
].stride
;
208 mali_ptr base
= panfrost_get_texture_address(rsrc
, level
, first_layer
);
210 rt
->format
= panfrost_mfbd_format(surf
);
212 /* Now, we set the layout specific pieces */
214 if (rsrc
->layout
== MALI_TEXTURE_LINEAR
) {
215 rt
->format
.block
= MALI_BLOCK_LINEAR
;
216 rt
->framebuffer
= base
;
217 rt
->framebuffer_stride
= stride
/ 16;
218 } else if (rsrc
->layout
== MALI_TEXTURE_TILED
) {
219 rt
->format
.block
= MALI_BLOCK_TILED
;
220 rt
->framebuffer
= base
;
221 rt
->framebuffer_stride
= stride
;
222 } else if (rsrc
->layout
== MALI_TEXTURE_AFBC
) {
223 rt
->format
.block
= MALI_BLOCK_AFBC
;
225 unsigned header_size
= rsrc
->slices
[level
].header_size
;
227 rt
->framebuffer
= base
+ header_size
;
228 rt
->afbc
.metadata
= base
;
230 rt
->afbc
.unk
= 0x30009;
232 /* TODO: The blob sets this to something nonzero, but it's not
233 * clear what/how to calculate/if it matters */
234 rt
->framebuffer_stride
= 0;
236 fprintf(stderr
, "Invalid render layout (cbuf)");
242 panfrost_mfbd_set_zsbuf(
243 struct mali_framebuffer
*fb
,
244 struct mali_framebuffer_extra
*fbx
,
245 struct pipe_surface
*surf
)
247 struct panfrost_resource
*rsrc
= pan_resource(surf
->texture
);
249 unsigned level
= surf
->u
.tex
.level
;
250 unsigned first_layer
= surf
->u
.tex
.first_layer
;
251 assert(surf
->u
.tex
.last_layer
== first_layer
);
253 mali_ptr base
= panfrost_get_texture_address(rsrc
, level
, first_layer
);
255 if (rsrc
->layout
== MALI_TEXTURE_AFBC
) {
256 /* The only Z/S format we can compress is Z24S8 or variants
257 * thereof (handled by the gallium frontend) */
258 assert(panfrost_is_z24s8_variant(surf
->format
));
260 unsigned header_size
= rsrc
->slices
[level
].header_size
;
262 fb
->mfbd_flags
|= MALI_MFBD_EXTRA
;
264 fbx
->flags_hi
|= MALI_EXTRA_PRESENT
;
265 fbx
->flags_lo
|= MALI_EXTRA_ZS
| 0x1; /* unknown */
266 fbx
->zs_block
= MALI_BLOCK_AFBC
;
268 fbx
->ds_afbc
.depth_stencil
= base
+ header_size
;
269 fbx
->ds_afbc
.depth_stencil_afbc_metadata
= base
;
270 fbx
->ds_afbc
.depth_stencil_afbc_stride
= 0;
272 fbx
->ds_afbc
.zero1
= 0x10009;
273 fbx
->ds_afbc
.padding
= 0x1000;
274 } else if (rsrc
->layout
== MALI_TEXTURE_LINEAR
|| rsrc
->layout
== MALI_TEXTURE_TILED
) {
275 /* TODO: Z32F(S8) support, which is always linear */
277 int stride
= rsrc
->slices
[level
].stride
;
279 fb
->mfbd_flags
|= MALI_MFBD_EXTRA
;
280 fbx
->flags_hi
|= MALI_EXTRA_PRESENT
;
281 fbx
->flags_lo
|= MALI_EXTRA_ZS
;
283 fbx
->ds_linear
.depth
= base
;
285 if (rsrc
->layout
== MALI_TEXTURE_LINEAR
) {
286 fbx
->zs_block
= MALI_BLOCK_LINEAR
;
287 fbx
->ds_linear
.depth_stride
= stride
/ 16;
289 fbx
->zs_block
= MALI_BLOCK_TILED
;
290 fbx
->ds_linear
.depth_stride
= stride
;
293 if (panfrost_is_z24s8_variant(surf
->format
)) {
294 fbx
->flags_lo
|= 0x1;
295 } else if (surf
->format
== PIPE_FORMAT_Z32_UNORM
) {
296 /* default flags (0 in bottom place) */
297 } else if (surf
->format
== PIPE_FORMAT_Z32_FLOAT
) {
298 fbx
->flags_lo
|= 0xA;
299 fb
->mfbd_flags
^= 0x100;
300 fb
->mfbd_flags
|= 0x200;
301 } else if (surf
->format
== PIPE_FORMAT_Z32_FLOAT_S8X24_UINT
) {
302 fbx
->flags_hi
|= 0x400;
303 fbx
->flags_lo
|= 0xA;
304 fb
->mfbd_flags
^= 0x100;
305 fb
->mfbd_flags
|= 0x201;
307 struct panfrost_resource
*stencil
= rsrc
->separate_stencil
;
308 struct panfrost_slice stencil_slice
= stencil
->slices
[level
];
310 fbx
->ds_linear
.stencil
= panfrost_get_texture_address(stencil
, level
, first_layer
);
311 fbx
->ds_linear
.stencil_stride
= stencil_slice
.stride
;
319 /* Helper for sequential uploads used for MFBD */
321 #define UPLOAD(dest, offset, src, max) { \
322 size_t sz = sizeof(*src); \
323 memcpy(dest.cpu + offset, src, sz); \
324 assert((offset + sz) <= max); \
329 panfrost_mfbd_upload(struct panfrost_batch
*batch
,
330 struct mali_framebuffer
*fb
,
331 struct mali_framebuffer_extra
*fbx
,
332 struct mali_render_target
*rts
,
337 /* There may be extra data stuck in the middle */
338 bool has_extra
= fb
->mfbd_flags
& MALI_MFBD_EXTRA
;
340 /* Compute total size for transfer */
343 sizeof(struct mali_framebuffer
) +
344 (has_extra
? sizeof(struct mali_framebuffer_extra
) : 0) +
345 sizeof(struct mali_render_target
) * 4;
347 struct panfrost_transfer m_f_trans
=
348 panfrost_allocate_transient(batch
, total_sz
);
350 /* Do the transfer */
352 UPLOAD(m_f_trans
, offset
, fb
, total_sz
);
355 UPLOAD(m_f_trans
, offset
, fbx
, total_sz
);
357 for (unsigned c
= 0; c
< 4; ++c
) {
358 UPLOAD(m_f_trans
, offset
, &rts
[c
], total_sz
);
361 /* Return pointer suitable for the fragment section */
364 (has_extra
? MALI_MFBD_TAG_EXTRA
: 0) |
365 (MALI_POSITIVE(rt_count
) << 2);
367 return m_f_trans
.gpu
| tag
;
372 static struct mali_framebuffer
373 panfrost_emit_mfbd(struct panfrost_batch
*batch
, unsigned vertex_count
)
375 struct panfrost_context
*ctx
= batch
->ctx
;
376 struct pipe_context
*gallium
= (struct pipe_context
*) ctx
;
377 struct panfrost_device
*dev
= pan_device(gallium
->screen
);
379 unsigned width
= batch
->key
.width
;
380 unsigned height
= batch
->key
.height
;
382 struct mali_framebuffer mfbd
= {
383 .width1
= MALI_POSITIVE(width
),
384 .height1
= MALI_POSITIVE(height
),
385 .width2
= MALI_POSITIVE(width
),
386 .height2
= MALI_POSITIVE(height
),
390 .rt_count_1
= MALI_POSITIVE(batch
->key
.nr_cbufs
),
394 if (dev
->quirks
& IS_BIFROST
) {
395 mfbd
.msaa
.sample_locations
= panfrost_emit_sample_locations(batch
);
396 mfbd
.tiler_meta
= panfrost_batch_get_tiler_meta(batch
, vertex_count
);
398 unsigned shift
= panfrost_get_stack_shift(batch
->stack_size
);
399 struct panfrost_bo
*bo
= panfrost_batch_get_scratchpad(batch
,
401 dev
->thread_tls_alloc
,
403 mfbd
.shared_memory
.stack_shift
= shift
;
404 mfbd
.shared_memory
.scratchpad
= bo
->gpu
;
405 mfbd
.shared_memory
.shared_workgroup_count
= ~0;
407 mfbd
.tiler
= panfrost_emit_midg_tiler(batch
, vertex_count
);
414 panfrost_attach_mfbd(struct panfrost_batch
*batch
, unsigned vertex_count
)
416 struct mali_framebuffer mfbd
=
417 panfrost_emit_mfbd(batch
, vertex_count
);
419 memcpy(batch
->framebuffer
.cpu
, &mfbd
, sizeof(mfbd
));
422 /* Creates an MFBD for the FRAGMENT section of the bound framebuffer */
425 panfrost_mfbd_fragment(struct panfrost_batch
*batch
, bool has_draws
)
427 struct mali_framebuffer fb
= panfrost_emit_mfbd(batch
, has_draws
);
428 struct mali_framebuffer_extra fbx
= {0};
429 struct mali_render_target rts
[4] = {0};
431 /* We always upload at least one dummy GL_NONE render target */
433 unsigned rt_descriptors
= MAX2(batch
->key
.nr_cbufs
, 1);
435 fb
.rt_count_1
= MALI_POSITIVE(rt_descriptors
);
436 fb
.rt_count_2
= rt_descriptors
;
437 fb
.mfbd_flags
= 0x100;
439 /* TODO: MRT clear */
440 panfrost_mfbd_clear(batch
, &fb
, &fbx
, rts
, fb
.rt_count_2
);
443 /* Upload either the render target or a dummy GL_NONE target */
445 for (int cb
= 0; cb
< rt_descriptors
; ++cb
) {
446 struct pipe_surface
*surf
= batch
->key
.cbufs
[cb
];
449 panfrost_mfbd_set_cbuf(&rts
[cb
], surf
);
451 /* What is this? Looks like some extension of the bpp
452 * field. Maybe it establishes how much internal
453 * tilebuffer space is reserved? */
455 unsigned bpp
= util_format_get_blocksize(surf
->format
);
456 fb
.rt_count_2
= MAX2(fb
.rt_count_2
, ALIGN_POT(bpp
, 4) / 4);
458 struct mali_rt_format null_rt
= {
463 rts
[cb
].format
= null_rt
;
464 rts
[cb
].framebuffer
= 0;
465 rts
[cb
].framebuffer_stride
= 0;
468 /* TODO: Break out the field */
469 rts
[cb
].format
.unk1
|= (cb
* 0x400);
472 if (batch
->key
.zsbuf
) {
473 panfrost_mfbd_set_zsbuf(&fb
, &fbx
, batch
->key
.zsbuf
);
476 /* When scanning out, the depth buffer is immediately invalidated, so
477 * we don't need to waste bandwidth writing it out. This can improve
478 * performance substantially (Z32_UNORM 1080p @ 60fps is 475 MB/s of
479 * memory bandwidth!).
481 * The exception is ReadPixels, but this is not supported on GLES so we
482 * can safely ignore it. */
484 if (panfrost_batch_is_scanout(batch
))
485 batch
->requirements
&= ~PAN_REQ_DEPTH_WRITE
;
487 /* Actualize the requirements */
489 if (batch
->requirements
& PAN_REQ_MSAA
) {
490 rts
[0].format
.flags
|= MALI_MFBD_FORMAT_MSAA
;
493 fb
.unk1
|= (1 << 4) | (1 << 1);
497 if (batch
->requirements
& PAN_REQ_DEPTH_WRITE
)
498 fb
.mfbd_flags
|= MALI_MFBD_DEPTH_WRITE
;
500 /* Checksumming only works with a single render target */
502 if (batch
->key
.nr_cbufs
== 1) {
503 struct pipe_surface
*surf
= batch
->key
.cbufs
[0];
504 struct panfrost_resource
*rsrc
= pan_resource(surf
->texture
);
506 if (rsrc
->checksummed
) {
507 unsigned level
= surf
->u
.tex
.level
;
508 struct panfrost_slice
*slice
= &rsrc
->slices
[level
];
510 fb
.mfbd_flags
|= MALI_MFBD_EXTRA
;
511 fbx
.flags_lo
|= MALI_EXTRA_PRESENT
;
512 fbx
.checksum_stride
= slice
->checksum_stride
;
513 if (slice
->checksum_bo
)
514 fbx
.checksum
= slice
->checksum_bo
->gpu
;
516 fbx
.checksum
= rsrc
->bo
->gpu
+ slice
->checksum_offset
;
520 return panfrost_mfbd_upload(batch
, &fb
, &fbx
, rts
, rt_descriptors
);