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 if (i
< PIPE_SWIZZLE_X
|| i
> PIPE_SWIZZLE_W
)
49 unsigned idx
= i
- PIPE_SWIZZLE_X
;
50 out
[idx
] = PIPE_SWIZZLE_X
+ c
;
54 static struct mali_rt_format
55 panfrost_mfbd_format(struct pipe_surface
*surf
)
57 /* Explode details on the format */
59 const struct util_format_description
*desc
=
60 util_format_description(surf
->format
);
62 /* The swizzle for rendering is inverted from texturing */
64 unsigned char swizzle
[4];
65 panfrost_invert_swizzle(desc
->swizzle
, swizzle
);
67 /* Fill in accordingly, defaulting to 8-bit UNORM */
69 struct mali_rt_format fmt
= {
72 .nr_channels
= MALI_POSITIVE(desc
->nr_channels
),
75 .swizzle
= panfrost_translate_swizzle_4(swizzle
),
79 if (desc
->colorspace
== UTIL_FORMAT_COLORSPACE_SRGB
)
80 fmt
.flags
|= MALI_MFBD_FORMAT_SRGB
;
82 /* Set flags for alternative formats */
85 surf
->format
== PIPE_FORMAT_R16_FLOAT
||
86 surf
->format
== PIPE_FORMAT_R16_UINT
||
87 surf
->format
== PIPE_FORMAT_R16_SINT
||
88 surf
->format
== PIPE_FORMAT_B5G5R5A1_UNORM
;
91 surf
->format
== PIPE_FORMAT_R11G11B10_FLOAT
||
92 surf
->format
== PIPE_FORMAT_R16G16_FLOAT
||
93 surf
->format
== PIPE_FORMAT_R16G16_UINT
||
94 surf
->format
== PIPE_FORMAT_R16G16_SINT
||
95 surf
->format
== PIPE_FORMAT_R32_FLOAT
||
96 surf
->format
== PIPE_FORMAT_R32_UINT
||
97 surf
->format
== PIPE_FORMAT_R32_SINT
||
98 surf
->format
== PIPE_FORMAT_R10G10B10A2_UINT
;
101 surf
->format
== PIPE_FORMAT_R10G10B10A2_UNORM
||
102 surf
->format
== PIPE_FORMAT_B10G10R10A2_UNORM
||
103 surf
->format
== PIPE_FORMAT_R10G10B10X2_UNORM
||
104 surf
->format
== PIPE_FORMAT_B10G10R10X2_UNORM
;
107 surf
->format
== PIPE_FORMAT_R32G32_FLOAT
||
108 surf
->format
== PIPE_FORMAT_R32G32_SINT
||
109 surf
->format
== PIPE_FORMAT_R32G32_UINT
||
110 surf
->format
== PIPE_FORMAT_R16G16B16A16_FLOAT
||
111 surf
->format
== PIPE_FORMAT_R16G16B16A16_SINT
||
112 surf
->format
== PIPE_FORMAT_R16G16B16A16_UINT
;
115 surf
->format
== PIPE_FORMAT_R32G32B32A32_FLOAT
||
116 surf
->format
== PIPE_FORMAT_R32G32B32A32_SINT
||
117 surf
->format
== PIPE_FORMAT_R32G32B32A32_UINT
;
119 if (surf
->format
== PIPE_FORMAT_B5G6R5_UNORM
) {
120 fmt
.unk1
= 0x14000000;
121 fmt
.nr_channels
= MALI_POSITIVE(2);
123 } else if (surf
->format
== PIPE_FORMAT_B4G4R4A4_UNORM
) {
124 /* XXX: why does the specialized code not work but the generic
125 * 16-bit code work? */
127 fmt
.unk1
= 0x10000000;
129 fmt
.nr_channels
= MALI_POSITIVE(1);
132 fmt
.unk1
= 0x84000000;
134 fmt
.nr_channels
= MALI_POSITIVE(2);
135 } else if (rgb10_unorm
) {
136 fmt
.unk1
= 0x08000000;
138 fmt
.nr_channels
= MALI_POSITIVE(1);
139 } else if (float_32
) {
140 fmt
.unk1
= 0x88000000;
142 fmt
.nr_channels
= MALI_POSITIVE(4);
143 } else if (float_16
) {
144 fmt
.unk1
= 0x84000000;
146 fmt
.nr_channels
= MALI_POSITIVE(2);
147 } else if (float_64
) {
148 fmt
.unk1
= 0x8c000000;
150 fmt
.nr_channels
= MALI_POSITIVE(2);
151 } else if (float_128
) {
152 fmt
.unk1
= 0x90000000;
154 fmt
.nr_channels
= MALI_POSITIVE(4);
163 struct panfrost_job
*job
,
164 struct bifrost_framebuffer
*fb
,
165 struct bifrost_fb_extra
*fbx
,
166 struct bifrost_render_target
*rts
,
169 for (unsigned i
= 0; i
< rt_count
; ++i
) {
170 if (!(job
->clear
& (PIPE_CLEAR_COLOR0
<< i
)))
173 rts
[i
].clear_color_1
= job
->clear_color
[i
][0];
174 rts
[i
].clear_color_2
= job
->clear_color
[i
][1];
175 rts
[i
].clear_color_3
= job
->clear_color
[i
][2];
176 rts
[i
].clear_color_4
= job
->clear_color
[i
][3];
179 if (job
->clear
& PIPE_CLEAR_DEPTH
) {
180 fb
->clear_depth
= job
->clear_depth
;
183 if (job
->clear
& PIPE_CLEAR_STENCIL
) {
184 fb
->clear_stencil
= job
->clear_stencil
;
189 panfrost_mfbd_set_cbuf(
190 struct bifrost_render_target
*rt
,
191 struct pipe_surface
*surf
)
193 struct panfrost_resource
*rsrc
= pan_resource(surf
->texture
);
195 unsigned level
= surf
->u
.tex
.level
;
196 unsigned first_layer
= surf
->u
.tex
.first_layer
;
197 assert(surf
->u
.tex
.last_layer
== first_layer
);
198 int stride
= rsrc
->slices
[level
].stride
;
200 mali_ptr base
= panfrost_get_texture_address(rsrc
, level
, first_layer
);
202 rt
->format
= panfrost_mfbd_format(surf
);
204 /* Now, we set the layout specific pieces */
206 if (rsrc
->layout
== PAN_LINEAR
) {
207 rt
->format
.block
= MALI_MFBD_BLOCK_LINEAR
;
208 rt
->framebuffer
= base
;
209 rt
->framebuffer_stride
= stride
/ 16;
210 } else if (rsrc
->layout
== PAN_TILED
) {
211 rt
->format
.block
= MALI_MFBD_BLOCK_TILED
;
212 rt
->framebuffer
= base
;
213 rt
->framebuffer_stride
= stride
;
214 } else if (rsrc
->layout
== PAN_AFBC
) {
215 rt
->format
.block
= MALI_MFBD_BLOCK_AFBC
;
217 unsigned header_size
= rsrc
->slices
[level
].header_size
;
219 rt
->framebuffer
= base
+ header_size
;
220 rt
->afbc
.metadata
= base
;
222 rt
->afbc
.unk
= 0x30009;
224 /* TODO: Investigate shift */
225 rt
->framebuffer_stride
= stride
<< 1;
227 fprintf(stderr
, "Invalid render layout (cbuf)");
233 panfrost_mfbd_set_zsbuf(
234 struct bifrost_framebuffer
*fb
,
235 struct bifrost_fb_extra
*fbx
,
236 struct pipe_surface
*surf
)
238 struct panfrost_resource
*rsrc
= pan_resource(surf
->texture
);
240 unsigned level
= surf
->u
.tex
.level
;
241 assert(surf
->u
.tex
.first_layer
== 0);
243 unsigned offset
= rsrc
->slices
[level
].offset
;
245 if (rsrc
->layout
== PAN_AFBC
) {
246 mali_ptr base
= rsrc
->bo
->gpu
+ offset
;
247 unsigned header_size
= rsrc
->slices
[level
].header_size
;
249 fb
->mfbd_flags
|= MALI_MFBD_EXTRA
;
258 fbx
->ds_afbc
.depth_stencil
= base
+ header_size
;
259 fbx
->ds_afbc
.depth_stencil_afbc_metadata
= base
;
260 fbx
->ds_afbc
.depth_stencil_afbc_stride
= 0;
262 fbx
->ds_afbc
.zero1
= 0x10009;
263 fbx
->ds_afbc
.padding
= 0x1000;
264 } else if (rsrc
->layout
== PAN_LINEAR
) {
265 int stride
= rsrc
->slices
[level
].stride
;
266 fb
->mfbd_flags
|= MALI_MFBD_EXTRA
;
268 fbx
->flags
|= MALI_EXTRA_PRESENT
| MALI_EXTRA_ZS
| 0x1;
270 fbx
->ds_linear
.depth
= rsrc
->bo
->gpu
+ offset
;
271 fbx
->ds_linear
.depth_stride
= stride
;
277 /* Helper for sequential uploads used for MFBD */
279 #define UPLOAD(dest, offset, src, max) { \
280 size_t sz = sizeof(*src); \
281 memcpy(dest.cpu + offset, src, sz); \
282 assert((offset + sz) <= max); \
287 panfrost_mfbd_upload(
288 struct panfrost_context
*ctx
,
289 struct bifrost_framebuffer
*fb
,
290 struct bifrost_fb_extra
*fbx
,
291 struct bifrost_render_target
*rts
,
296 /* There may be extra data stuck in the middle */
297 bool has_extra
= fb
->mfbd_flags
& MALI_MFBD_EXTRA
;
299 /* Compute total size for transfer */
302 sizeof(struct bifrost_framebuffer
) +
303 (has_extra
? sizeof(struct bifrost_fb_extra
) : 0) +
304 sizeof(struct bifrost_render_target
) * cbufs
;
306 struct panfrost_transfer m_f_trans
=
307 panfrost_allocate_transient(ctx
, total_sz
);
309 /* Do the transfer */
311 UPLOAD(m_f_trans
, offset
, fb
, total_sz
);
314 UPLOAD(m_f_trans
, offset
, fbx
, total_sz
);
316 for (unsigned c
= 0; c
< cbufs
; ++c
) {
317 UPLOAD(m_f_trans
, offset
, &rts
[c
], total_sz
);
320 /* Return pointer suitable for the fragment section */
321 return m_f_trans
.gpu
| MALI_MFBD
| (has_extra
? 2 : 0);
326 /* Creates an MFBD for the FRAGMENT section of the bound framebuffer */
329 panfrost_mfbd_fragment(struct panfrost_context
*ctx
, bool has_draws
)
331 struct panfrost_job
*job
= panfrost_get_job_for_fbo(ctx
);
333 struct bifrost_framebuffer fb
= panfrost_emit_mfbd(ctx
, has_draws
);
334 struct bifrost_fb_extra fbx
= {};
335 struct bifrost_render_target rts
[4] = {};
339 fb
.mfbd_flags
= 0x100;
341 /* TODO: MRT clear */
342 panfrost_mfbd_clear(job
, &fb
, &fbx
, rts
, fb
.rt_count_2
);
344 for (int cb
= 0; cb
< ctx
->pipe_framebuffer
.nr_cbufs
; ++cb
) {
345 struct pipe_surface
*surf
= ctx
->pipe_framebuffer
.cbufs
[cb
];
346 unsigned bpp
= util_format_get_blocksize(surf
->format
);
348 panfrost_mfbd_set_cbuf(&rts
[cb
], surf
);
350 /* What is this? Looks like some extension of the bpp field.
351 * Maybe it establishes how much internal tilebuffer space is
353 fb
.rt_count_2
= MAX2(fb
.rt_count_2
, ALIGN_POT(bpp
, 4) / 4);
356 if (ctx
->pipe_framebuffer
.zsbuf
) {
357 panfrost_mfbd_set_zsbuf(&fb
, &fbx
, ctx
->pipe_framebuffer
.zsbuf
);
360 /* For the special case of a depth-only FBO, we need to attach a dummy render target */
362 if (ctx
->pipe_framebuffer
.nr_cbufs
== 0) {
363 struct mali_rt_format null_rt
= {
368 rts
[0].format
= null_rt
;
369 rts
[0].framebuffer
= 0;
370 rts
[0].framebuffer_stride
= 0;
373 /* When scanning out, the depth buffer is immediately invalidated, so
374 * we don't need to waste bandwidth writing it out. This can improve
375 * performance substantially (Z32_UNORM 1080p @ 60fps is 475 MB/s of
376 * memory bandwidth!).
378 * The exception is ReadPixels, but this is not supported on GLES so we
379 * can safely ignore it. */
381 if (panfrost_is_scanout(ctx
)) {
382 job
->requirements
&= ~PAN_REQ_DEPTH_WRITE
;
385 /* Actualize the requirements */
387 if (job
->requirements
& PAN_REQ_MSAA
) {
388 rts
[0].format
.flags
|= MALI_MFBD_FORMAT_MSAA
;
391 fb
.unk1
|= (1 << 4) | (1 << 1);
395 if (job
->requirements
& PAN_REQ_DEPTH_WRITE
)
396 fb
.mfbd_flags
|= MALI_MFBD_DEPTH_WRITE
;
398 /* Checksumming only works with a single render target */
400 if (ctx
->pipe_framebuffer
.nr_cbufs
== 1) {
401 struct pipe_surface
*surf
= ctx
->pipe_framebuffer
.cbufs
[0];
402 struct panfrost_resource
*rsrc
= pan_resource(surf
->texture
);
403 struct panfrost_bo
*bo
= rsrc
->bo
;
405 if (rsrc
->checksummed
) {
406 unsigned level
= surf
->u
.tex
.level
;
407 struct panfrost_slice
*slice
= &rsrc
->slices
[level
];
409 fb
.mfbd_flags
|= MALI_MFBD_EXTRA
;
410 fbx
.flags
|= MALI_EXTRA_PRESENT
;
411 fbx
.checksum_stride
= slice
->checksum_stride
;
412 fbx
.checksum
= bo
->gpu
+ slice
->checksum_offset
;
416 /* We always upload at least one (dummy) cbuf */
417 unsigned cbufs
= MAX2(ctx
->pipe_framebuffer
.nr_cbufs
, 1);
419 return panfrost_mfbd_upload(ctx
, &fb
, &fbx
, rts
, cbufs
);