}
static uint32_t
-blit_image_info(const struct tu_blit_surf *img, bool src, bool stencil_read)
+blit_image_info(const struct tu_blit_surf *img, struct tu_native_format fmt, bool stencil_read)
{
- const struct tu_native_format *fmt = tu6_get_native_format(img->fmt);
- enum a6xx_format rb = fmt->rb;
- enum a3xx_color_swap swap = img->tiled ? WZYX : fmt->swap;
- if (rb == FMT6_10_10_10_2_UNORM_DEST && src)
- rb = FMT6_10_10_10_2_UNORM;
- if (rb == FMT6_Z24_UNORM_S8_UINT)
- rb = FMT6_Z24_UNORM_S8_UINT_AS_R8G8B8A8;
+ if (fmt.fmt == FMT6_Z24_UNORM_S8_UINT)
+ fmt.fmt = FMT6_Z24_UNORM_S8_UINT_AS_R8G8B8A8;
if (stencil_read)
- swap = XYZW;
+ fmt.swap = XYZW;
- return A6XX_SP_PS_2D_SRC_INFO_COLOR_FORMAT(rb) |
+ return A6XX_SP_PS_2D_SRC_INFO_COLOR_FORMAT(fmt.fmt) |
A6XX_SP_PS_2D_SRC_INFO_TILE_MODE(img->tile_mode) |
- A6XX_SP_PS_2D_SRC_INFO_COLOR_SWAP(swap) |
+ A6XX_SP_PS_2D_SRC_INFO_COLOR_SWAP(fmt.swap) |
COND(vk_format_is_srgb(img->fmt), A6XX_SP_PS_2D_SRC_INFO_SRGB) |
COND(img->ubwc_size, A6XX_SP_PS_2D_SRC_INFO_FLAGS);
}
{
struct tu_physical_device *phys_dev = cmdbuf->device->physical_device;
- enum a6xx_format fmt = tu6_get_native_format(blt->dst.fmt)->rb;
- if (fmt == FMT6_Z24_UNORM_S8_UINT)
- fmt = FMT6_Z24_UNORM_S8_UINT_AS_R8G8B8A8;
+ struct tu_native_format dfmt = tu6_format_color(blt->dst.fmt, blt->dst.tiled);
+ struct tu_native_format sfmt = tu6_format_texture(blt->src.fmt, blt->src.tiled);
- enum a6xx_2d_ifmt ifmt = tu6_fmt_to_ifmt(fmt);
+ if (dfmt.fmt == FMT6_Z24_UNORM_S8_UINT)
+ dfmt.fmt = FMT6_Z24_UNORM_S8_UINT_AS_R8G8B8A8;
+
+ enum a6xx_2d_ifmt ifmt = tu6_fmt_to_ifmt(dfmt.fmt);
if (vk_format_is_srgb(blt->dst.fmt)) {
assert(ifmt == R2D_UNORM8);
uint32_t blit_cntl = A6XX_RB_2D_BLIT_CNTL_ROTATE(blt->rotation) |
COND(blt->type == TU_BLIT_CLEAR, A6XX_RB_2D_BLIT_CNTL_SOLID_COLOR) |
- A6XX_RB_2D_BLIT_CNTL_COLOR_FORMAT(fmt) | /* not required? */
- COND(fmt == FMT6_Z24_UNORM_S8_UINT_AS_R8G8B8A8, A6XX_RB_2D_BLIT_CNTL_D24S8) |
+ A6XX_RB_2D_BLIT_CNTL_COLOR_FORMAT(dfmt.fmt) | /* not required? */
+ COND(dfmt.fmt == FMT6_Z24_UNORM_S8_UINT_AS_R8G8B8A8,
+ A6XX_RB_2D_BLIT_CNTL_D24S8) |
A6XX_RB_2D_BLIT_CNTL_MASK(0xf) |
A6XX_RB_2D_BLIT_CNTL_IFMT(ifmt);
tu_cs_emit(cs, blt->clear_value[3]);
} else {
tu_cs_emit_pkt4(cs, REG_A6XX_SP_PS_2D_SRC_INFO, 10);
- tu_cs_emit(cs, blit_image_info(&blt->src, true, blt->stencil_read) |
+ tu_cs_emit(cs, blit_image_info(&blt->src, sfmt, blt->stencil_read) |
A6XX_SP_PS_2D_SRC_INFO_SAMPLES(tu_msaa_samples(blt->src.samples)) |
/* TODO: should disable this bit for integer formats ? */
COND(blt->src.samples > 1, A6XX_SP_PS_2D_SRC_INFO_SAMPLES_AVERAGE) |
* Emit destination:
*/
tu_cs_emit_pkt4(cs, REG_A6XX_RB_2D_DST_INFO, 9);
- tu_cs_emit(cs, blit_image_info(&blt->dst, false, false));
+ tu_cs_emit(cs, blit_image_info(&blt->dst, dfmt, false));
tu_cs_emit_qw(cs, blt->dst.va);
tu_cs_emit(cs, A6XX_RB_2D_DST_SIZE_PITCH(blt->dst.pitch));
tu_cs_emit(cs, 0x00000000);
tu_cs_emit_pkt4(cs, REG_A6XX_RB_UNKNOWN_8C01, 1);
tu_cs_emit(cs, 0);
- if (fmt == FMT6_10_10_10_2_UNORM_DEST)
- fmt = FMT6_16_16_16_16_FLOAT;
+ if (dfmt.fmt == FMT6_10_10_10_2_UNORM_DEST)
+ dfmt.fmt = FMT6_16_16_16_16_FLOAT;
tu_cs_emit_pkt4(cs, REG_A6XX_SP_2D_SRC_FORMAT, 1);
tu_cs_emit(cs, COND(vk_format_is_sint(blt->src.fmt), A6XX_SP_2D_SRC_FORMAT_SINT) |
COND(vk_format_is_uint(blt->src.fmt), A6XX_SP_2D_SRC_FORMAT_UINT) |
- A6XX_SP_2D_SRC_FORMAT_COLOR_FORMAT(fmt) |
+ A6XX_SP_2D_SRC_FORMAT_COLOR_FORMAT(dfmt.fmt) |
COND(ifmt == R2D_UNORM8_SRGB, A6XX_SP_2D_SRC_FORMAT_SRGB) |
A6XX_SP_2D_SRC_FORMAT_MASK(0xf));
if (vk_format_is_srgb(iview->vk_format))
srgb_cntl |= (1 << i);
- const struct tu_native_format *format =
- tu6_get_native_format(iview->vk_format);
- assert(format && format->rb >= 0);
+ const struct tu_native_format format =
+ tu6_format_color(iview->vk_format, iview->image->layout.tile_mode);
tu_cs_emit_regs(cs,
A6XX_RB_MRT_BUF_INFO(i,
.color_tile_mode = tile_mode,
- .color_format = format->rb,
- .color_swap = format->swap),
+ .color_format = format.fmt,
+ .color_swap = format.swap),
A6XX_RB_MRT_PITCH(i, tu_image_stride(iview->image, iview->base_mip)),
A6XX_RB_MRT_ARRAY_PITCH(i, iview->image->layout.layer_size),
A6XX_RB_MRT_BASE(i, tu_image_view_base_ref(iview)),
tu_cs_emit_regs(cs,
A6XX_SP_FS_MRT_REG(i,
- .color_format = format->rb,
+ .color_format = format.fmt,
.color_sint = vk_format_is_sint(iview->vk_format),
.color_uint = vk_format_is_uint(iview->vk_format)));
tu_cs_emit_regs(cs,
A6XX_RB_BLIT_INFO(.unk0 = !resolve, .gmem = !resolve));
- const struct tu_native_format *format =
- tu6_get_native_format(iview->vk_format);
- assert(format && format->rb >= 0);
+ const struct tu_native_format format =
+ tu6_format_color(iview->vk_format, iview->image->layout.tile_mode);
enum a6xx_tile_mode tile_mode =
tu6_get_image_tile_mode(iview->image, iview->base_mip);
A6XX_RB_BLIT_DST_INFO(
.tile_mode = tile_mode,
.samples = tu_msaa_samples(iview->image->samples),
- .color_format = format->rb,
- .color_swap = format->swap,
+ .color_format = format.fmt,
+ .color_swap = format.swap,
.flags = iview->image->layout.ubwc_layer_size != 0),
A6XX_RB_BLIT_DST(tu_image_view_base_ref(iview)),
A6XX_RB_BLIT_DST_PITCH(tu_image_stride(iview->image, iview->base_mip)),
#include "vk_util.h"
#include "drm-uapi/drm_fourcc.h"
-/**
- * Declare a format table. A format table is an array of tu_native_format.
- * It can map a consecutive range of VkFormat to the corresponding
- * tu_native_format.
- *
- * TU_FORMAT_TABLE_FIRST and TU_FORMAT_TABLE_LAST must already be defined and
- * have the values of the first and last VkFormat of the array respectively.
- */
-#define TU_FORMAT_TABLE(var) \
- static const VkFormat var##_first = TU_FORMAT_TABLE_FIRST; \
- static const VkFormat var##_last = TU_FORMAT_TABLE_LAST; \
- static const struct tu_native_format var[TU_FORMAT_TABLE_LAST - TU_FORMAT_TABLE_FIRST + 1]
-#undef TU_FORMAT_TABLE_FIRST
-#undef TU_FORMAT_TABLE_LAST
-
#define FMT6_x -1
-#define TU6_FMT(vkfmt, vtxfmt, texfmt, rbfmt, swapfmt, valid) \
- [VK_FORMAT_##vkfmt - TU_FORMAT_TABLE_FIRST] = { \
- .vtx = FMT6_##vtxfmt, \
- .tex = FMT6_##texfmt, \
- .rb = (FMT6_##rbfmt == FMT6_10_10_10_2_UNORM) ? FMT6_10_10_10_2_UNORM_DEST : FMT6_##rbfmt, \
- .swap = swapfmt, \
- .present = valid, \
+#define TU6_FMT(vkfmt, hwfmt, swapfmt, valid) \
+ [VK_FORMAT_##vkfmt] = { \
+ .fmt = FMT6_##hwfmt, \
+ .swap = swapfmt, \
+ .supported = valid, \
}
-/**
- * fmt/alias/swap are derived from VkFormat mechanically (and might not even
- * exist). It is the macro of choice that decides whether a VkFormat is
- * supported and how.
- */
-#define TU6_VTC(vk, fmt, swap) TU6_FMT(vk, fmt, fmt, fmt, swap, true)
-#define TU6_xTC(vk, fmt, swap) TU6_FMT(vk, x, fmt, fmt, swap, true)
-#define TU6_VTx(vk, fmt, swap) TU6_FMT(vk, fmt, fmt, x, swap, true)
-#define TU6_Vxx(vk, fmt, swap) TU6_FMT(vk, fmt, x, x, swap, true)
-#define TU6_xTx(vk, fmt, swap) TU6_FMT(vk, x, fmt, x, swap, true)
-#define TU6_xxx(vk, fmt, swap) TU6_FMT(vk, x, x, x, WZYX, false)
-
-#define TU_FORMAT_TABLE_FIRST VK_FORMAT_UNDEFINED
-#define TU_FORMAT_TABLE_LAST VK_FORMAT_ASTC_12x12_SRGB_BLOCK
-TU_FORMAT_TABLE(tu6_format_table0) = {
+#define TU6_VTC(vk, fmt, swap) TU6_FMT(vk, fmt, swap, FMT_VERTEX | FMT_TEXTURE | FMT_COLOR)
+#define TU6_xTC(vk, fmt, swap) TU6_FMT(vk, fmt, swap, FMT_TEXTURE | FMT_COLOR)
+#define TU6_Vxx(vk, fmt, swap) TU6_FMT(vk, fmt, swap, FMT_VERTEX)
+#define TU6_xTx(vk, fmt, swap) TU6_FMT(vk, fmt, swap, FMT_TEXTURE)
+#define TU6_xxx(vk, fmt, swap) TU6_FMT(vk, x, WZYX, false)
+
+static const struct tu_native_format tu6_format_table[] = {
TU6_xxx(UNDEFINED, x, x), /* 0 */
/* 8-bit packed */
TU6_xTx(ASTC_12x12_UNORM_BLOCK, ASTC_12x12, WZYX), /* 183 */
TU6_xTx(ASTC_12x12_SRGB_BLOCK, ASTC_12x12, WZYX), /* 184 */
};
-#undef TU_FORMAT_TABLE_FIRST
-#undef TU_FORMAT_TABLE_LAST
-const struct tu_native_format *
+struct tu_native_format
tu6_get_native_format(VkFormat format)
{
- const struct tu_native_format *fmt = NULL;
+ struct tu_native_format fmt = {};
- if (format >= tu6_format_table0_first && format <= tu6_format_table0_last)
- fmt = &tu6_format_table0[format - tu6_format_table0_first];
+ if (format >= ARRAY_SIZE(tu6_format_table))
+ return fmt;
- if (!fmt || !fmt->present)
- return NULL;
+ if (!tu6_format_table[format].supported)
+ return fmt;
if (vk_format_to_pipe_format(format) == PIPE_FORMAT_NONE) {
tu_finishme("vk_format %d missing matching pipe format.\n", format);
- return NULL;
+ return fmt;
}
- return (fmt && fmt->present) ? fmt : NULL;
+ return tu6_format_table[format];
+}
+
+struct tu_native_format
+tu6_format_vtx(VkFormat format)
+{
+ struct tu_native_format fmt = tu6_get_native_format(format);
+ assert(fmt.supported & FMT_VERTEX);
+ return fmt;
+}
+
+enum a6xx_format
+tu6_format_gmem(VkFormat format)
+{
+ struct tu_native_format fmt = tu6_get_native_format(format);
+ assert(fmt.supported & FMT_COLOR);
+
+ if (fmt.fmt == FMT6_10_10_10_2_UNORM)
+ return FMT6_10_10_10_2_UNORM_DEST;
+
+ return fmt.fmt;
+}
+
+struct tu_native_format
+tu6_format_color(VkFormat format, bool tiled)
+{
+ struct tu_native_format fmt = tu6_get_native_format(format);
+ assert(fmt.supported & FMT_COLOR);
+
+ if (fmt.fmt == FMT6_10_10_10_2_UNORM)
+ fmt.fmt = FMT6_10_10_10_2_UNORM_DEST;
+
+ if (tiled)
+ fmt.swap = WZYX;
+
+ return fmt;
+}
+
+struct tu_native_format
+tu6_format_texture(VkFormat format, bool tiled)
+{
+ struct tu_native_format fmt = tu6_get_native_format(format);
+ assert(fmt.supported & FMT_TEXTURE);
+
+ if (tiled)
+ fmt.swap = WZYX;
+
+ return fmt;
}
enum a6xx_2d_ifmt
case FMT6_16_16_FLOAT:
case FMT6_16_16_16_16_FLOAT:
case FMT6_11_11_10_FLOAT:
+ case FMT6_10_10_10_2_UNORM:
case FMT6_10_10_10_2_UNORM_DEST:
return R2D_FLOAT16;
return;
}
- enum a6xx_2d_ifmt ifmt = tu6_fmt_to_ifmt(tu6_get_native_format(format)->rb);
+ enum a6xx_2d_ifmt ifmt = tu6_fmt_to_ifmt(tu6_get_native_format(format).fmt);
assert(desc && (desc->layout == UTIL_FORMAT_LAYOUT_PLAIN ||
format == VK_FORMAT_B10G11R11_UFLOAT_PACK32));
{
VkFormatFeatureFlags linear = 0, optimal = 0, buffer = 0;
const struct util_format_description *desc = vk_format_description(format);
- const struct tu_native_format *native_fmt = tu6_get_native_format(format);
- if (!desc || !native_fmt) {
+ const struct tu_native_format native_fmt = tu6_get_native_format(format);
+ if (!desc || !native_fmt.supported) {
goto end;
}
buffer |= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT;
- if (native_fmt->vtx >= 0) {
+ if (native_fmt.supported & FMT_VERTEX)
buffer |= VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT;
- }
-
- if (native_fmt->tex >= 0 || native_fmt->rb >= 0)
- optimal |= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT;
- if (native_fmt->tex >= 0) {
- optimal |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT;
+ if (native_fmt.supported & FMT_TEXTURE) {
+ optimal |= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT |
+ VK_FORMAT_FEATURE_TRANSFER_DST_BIT |
+ VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT |
+ VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT;
buffer |= VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT;
}
- if (native_fmt->rb >= 0)
- optimal |= VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT;
+ if (native_fmt.supported & FMT_COLOR) {
+ assert(native_fmt.supported & FMT_TEXTURE);
+ optimal |= VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT |
+ VK_FORMAT_FEATURE_BLIT_SRC_BIT |
+ VK_FORMAT_FEATURE_BLIT_DST_BIT;
+ }
/* For the most part, we can do anything with a linear image that we could
* do with a tiled image. However, we can't support sysmem rendering with a
memset(iview->descriptor, 0, sizeof(iview->descriptor));
- const struct tu_native_format *fmt = tu6_get_native_format(iview->vk_format);
+ struct tu_native_format fmt =
+ tu6_format_texture(iview->vk_format, image->layout.tile_mode);
uint64_t base_addr = tu_image_base(image, iview->base_mip, iview->base_layer);
uint64_t ubwc_addr = tu_image_ubwc_base(image, iview->base_mip, iview->base_layer);
uint32_t depth = pCreateInfo->viewType == VK_IMAGE_VIEW_TYPE_3D ?
u_minify(image->extent.depth, iview->base_mip) : iview->layer_count;
- unsigned fmt_tex = fmt->tex;
+ unsigned fmt_tex = fmt.fmt;
if (iview->aspect_mask == VK_IMAGE_ASPECT_STENCIL_BIT &&
iview->vk_format == VK_FORMAT_D24_UNORM_S8_UINT)
fmt_tex = FMT6_S8Z24_UINT;
COND(vk_format_is_srgb(iview->vk_format), A6XX_TEX_CONST_0_SRGB) |
A6XX_TEX_CONST_0_FMT(fmt_tex) |
A6XX_TEX_CONST_0_SAMPLES(tu_msaa_samples(image->samples)) |
- A6XX_TEX_CONST_0_SWAP(image->layout.tile_mode ? WZYX : fmt->swap) |
+ A6XX_TEX_CONST_0_SWAP(fmt.swap) |
tu6_texswiz(&pCreateInfo->components, iview->vk_format, iview->aspect_mask) |
A6XX_TEX_CONST_0_MIPLVLS(iview->level_count - 1);
iview->descriptor[1] = A6XX_TEX_CONST_1_WIDTH(width) | A6XX_TEX_CONST_1_HEIGHT(height);
memset(iview->storage_descriptor, 0, sizeof(iview->storage_descriptor));
iview->storage_descriptor[0] =
- A6XX_IBO_0_FMT(fmt->tex) |
+ A6XX_IBO_0_FMT(fmt.fmt) |
A6XX_IBO_0_TILE_MODE(tile_mode);
iview->storage_descriptor[1] =
A6XX_IBO_1_WIDTH(width) |
enum VkFormat vfmt = pCreateInfo->format;
enum pipe_format pfmt = vk_format_to_pipe_format(vfmt);
- const struct tu_native_format *fmt = tu6_get_native_format(vfmt);
+ const struct tu_native_format fmt = tu6_format_texture(vfmt, false);
uint32_t range;
if (pCreateInfo->range == VK_WHOLE_SIZE)
view->descriptor[0] =
A6XX_TEX_CONST_0_TILE_MODE(TILE6_LINEAR) |
- A6XX_TEX_CONST_0_SWAP(fmt->swap) |
- A6XX_TEX_CONST_0_FMT(fmt->tex) |
+ A6XX_TEX_CONST_0_SWAP(fmt.swap) |
+ A6XX_TEX_CONST_0_FMT(fmt.fmt) |
A6XX_TEX_CONST_0_MIPLVLS(0) |
tu6_texswiz(&components, vfmt, VK_IMAGE_ASPECT_COLOR_BIT);
COND(vk_format_is_srgb(vfmt), A6XX_TEX_CONST_0_SRGB);
const VkClearValue *value)
{
VkFormat fmt = cmd->state.pass->attachments[attachment].format;
- const struct tu_native_format *format = tu6_get_native_format(fmt);
- assert(format && format->rb >= 0);
tu_cs_emit_pkt4(cs, REG_A6XX_RB_BLIT_DST_INFO, 1);
- tu_cs_emit(cs, A6XX_RB_BLIT_DST_INFO_COLOR_FORMAT(format->rb));
+ tu_cs_emit(cs, A6XX_RB_BLIT_DST_INFO_COLOR_FORMAT(tu6_format_gmem(fmt)));
tu_cs_emit_pkt4(cs, REG_A6XX_RB_BLIT_INFO, 1);
tu_cs_emit(cs, A6XX_RB_BLIT_INFO_GMEM | A6XX_RB_BLIT_INFO_CLEAR_MASK(component_mask));
tu_find_vertex_input_binding(vi_info, vi_attr);
assert(vi_attr && vi_binding);
- const struct tu_native_format *format =
- tu6_get_native_format(vi_attr->format);
- assert(format && format->vtx >= 0);
+ const struct tu_native_format format = tu6_format_vtx(vi_attr->format);
uint32_t vfd_decode = A6XX_VFD_DECODE_INSTR_IDX(vfd_decode_idx) |
- A6XX_VFD_DECODE_INSTR_FORMAT(format->vtx) |
- A6XX_VFD_DECODE_INSTR_SWAP(format->swap) |
+ A6XX_VFD_DECODE_INSTR_FORMAT(format.fmt) |
+ A6XX_VFD_DECODE_INSTR_SWAP(format.swap) |
A6XX_VFD_DECODE_INSTR_UNK30;
if (vi_binding->inputRate == VK_VERTEX_INPUT_RATE_INSTANCE)
vfd_decode |= A6XX_VFD_DECODE_INSTR_INSTANCED;
uint32_t custom_blend_mode;
};
+enum tu_supported_formats {
+ FMT_VERTEX = 1,
+ FMT_TEXTURE = 2,
+ FMT_COLOR = 4,
+};
+
struct tu_native_format
{
- int vtx; /* VFMTn_xxx or -1 */
- int tex; /* TFMTn_xxx or -1 */
- int rb; /* RBn_xxx or -1 */
- int swap; /* enum a3xx_color_swap */
- bool present; /* internal only; always true to external users */
+ enum a6xx_format fmt : 8;
+ enum a3xx_color_swap swap : 8;
+ enum tu_supported_formats supported : 8;
};
-const struct tu_native_format *
-tu6_get_native_format(VkFormat format);
+struct tu_native_format tu6_get_native_format(VkFormat format);
+struct tu_native_format tu6_format_vtx(VkFormat format);
+enum a6xx_format tu6_format_gmem(VkFormat format);
+struct tu_native_format tu6_format_color(VkFormat format, bool tiled);
+struct tu_native_format tu6_format_texture(VkFormat format, bool tiled);
void
tu_pack_clear_value(const VkClearValue *val,
projects / mesa.git / commitdiff