diff --git a/src/freedreno/vulkan/tu_clear_blit.c b/src/freedreno/vulkan/tu_clear_blit.c
index 2dd7887e8d2..d1ddfa70c23 100644
--- a/src/freedreno/vulkan/tu_clear_blit.c
+++ b/src/freedreno/vulkan/tu_clear_blit.c
@@ -82,38 +82,38 @@ r2d_coords(struct tu_cs *cs,
 }
 
 static void
-r2d_clear_value(struct tu_cs *cs, VkFormat format, const VkClearValue *val)
+r2d_clear_value(struct tu_cs *cs, enum pipe_format format, const VkClearValue *val)
 {
    uint32_t clear_value[4] = {};
 
    switch (format) {
-   case VK_FORMAT_X8_D24_UNORM_PACK32:
-   case VK_FORMAT_D24_UNORM_S8_UINT:
+   case PIPE_FORMAT_Z24_UNORM_S8_UINT:
+   case PIPE_FORMAT_Z24X8_UNORM:
       /* cleared as r8g8b8a8_unorm using special format */
       clear_value[0] = tu_pack_float32_for_unorm(val->depthStencil.depth, 24);
       clear_value[1] = clear_value[0] >> 8;
       clear_value[2] = clear_value[0] >> 16;
       clear_value[3] = val->depthStencil.stencil;
       break;
-   case VK_FORMAT_D16_UNORM:
-   case VK_FORMAT_D32_SFLOAT:
+   case PIPE_FORMAT_Z16_UNORM:
+   case PIPE_FORMAT_Z32_FLOAT:
       /* R2D_FLOAT32 */
       clear_value[0] = fui(val->depthStencil.depth);
       break;
-   case VK_FORMAT_S8_UINT:
+   case PIPE_FORMAT_S8_UINT:
       clear_value[0] = val->depthStencil.stencil;
       break;
-   case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
+   case PIPE_FORMAT_R9G9B9E5_FLOAT:
       /* cleared as UINT32 */
       clear_value[0] = float3_to_rgb9e5(val->color.float32);
       break;
    default:
-      assert(!vk_format_is_depth_or_stencil(format));
-      const struct util_format_description *desc = vk_format_description(format);
-      enum a6xx_2d_ifmt ifmt = format_to_ifmt(tu_vk_format_to_pipe_format(format));
+      assert(!util_format_is_depth_or_stencil(format));
+      const struct util_format_description *desc = util_format_description(format);
+      enum a6xx_2d_ifmt ifmt = format_to_ifmt(format);
 
       assert(desc && (desc->layout == UTIL_FORMAT_LAYOUT_PLAIN ||
-                      format == VK_FORMAT_B10G11R11_UFLOAT_PACK32));
+                      format == PIPE_FORMAT_R11G11B10_FLOAT));
 
       for (unsigned i = 0; i < desc->nr_channels; i++) {
          const struct util_format_channel_description *ch = &desc->channel[i];
@@ -179,17 +179,17 @@ r2d_src_stencil(struct tu_cmd_buffer *cmd,
 static void
 r2d_src_buffer(struct tu_cmd_buffer *cmd,
                struct tu_cs *cs,
-               VkFormat vk_format,
+               enum pipe_format format,
                uint64_t va, uint32_t pitch,
                uint32_t width, uint32_t height)
 {
-   struct tu_native_format format = tu6_format_texture(tu_vk_format_to_pipe_format(vk_format), TILE6_LINEAR);
+   struct tu_native_format fmt = tu6_format_texture(format, TILE6_LINEAR);
 
    tu_cs_emit_regs(cs,
                    A6XX_SP_PS_2D_SRC_INFO(
-                      .color_format = format.fmt,
-                      .color_swap = format.swap,
-                      .srgb = vk_format_is_srgb(vk_format),
+                      .color_format = fmt.fmt,
+                      .color_swap = fmt.swap,
+                      .srgb = util_format_is_srgb(format),
                       .unk20 = 1,
                       .unk22 = 1),
                    A6XX_SP_PS_2D_SRC_SIZE(.width = width, .height = height),
@@ -218,15 +218,15 @@ r2d_dst_stencil(struct tu_cs *cs, const struct tu_image_view *iview, uint32_t la
 }
 
 static void
-r2d_dst_buffer(struct tu_cs *cs, VkFormat vk_format, uint64_t va, uint32_t pitch)
+r2d_dst_buffer(struct tu_cs *cs, enum pipe_format format, uint64_t va, uint32_t pitch)
 {
-   struct tu_native_format format = tu6_format_color(tu_vk_format_to_pipe_format(vk_format), TILE6_LINEAR);
+   struct tu_native_format fmt = tu6_format_color(format, TILE6_LINEAR);
 
    tu_cs_emit_regs(cs,
                    A6XX_RB_2D_DST_INFO(
-                      .color_format = format.fmt,
-                      .color_swap = format.swap,
-                      .srgb = vk_format_is_srgb(vk_format)),
+                      .color_format = fmt.fmt,
+                      .color_swap = fmt.swap,
+                      .srgb = util_format_is_srgb(format)),
                    A6XX_RB_2D_DST(.qword = va),
                    A6XX_RB_2D_DST_PITCH(pitch));
 }
@@ -234,25 +234,25 @@ r2d_dst_buffer(struct tu_cs *cs, VkFormat vk_format, uint64_t va, uint32_t pitch
 static void
 r2d_setup_common(struct tu_cmd_buffer *cmd,
                  struct tu_cs *cs,
-                 VkFormat vk_format,
+                 enum pipe_format format,
                  VkImageAspectFlags aspect_mask,
                  unsigned blit_param,
                  bool clear,
                  bool ubwc,
                  bool scissor)
 {
-   enum pipe_format format = tu_vk_format_to_pipe_format(vk_format);
    enum a6xx_format fmt = tu6_base_format(format);
    enum a6xx_2d_ifmt ifmt = format_to_ifmt(format);
+
    uint32_t unknown_8c01 = 0;
 
-   if ((vk_format == VK_FORMAT_D24_UNORM_S8_UINT ||
-        vk_format == VK_FORMAT_X8_D24_UNORM_PACK32) && ubwc) {
+   if ((format == PIPE_FORMAT_Z24_UNORM_S8_UINT ||
+       format == PIPE_FORMAT_Z24X8_UNORM) && ubwc) {
       fmt = FMT6_Z24_UNORM_S8_UINT_AS_R8G8B8A8;
    }
 
    /* note: the only format with partial clearing is D24S8 */
-   if (vk_format == VK_FORMAT_D24_UNORM_S8_UINT) {
+   if (format == PIPE_FORMAT_Z24_UNORM_S8_UINT) {
       /* preserve stencil channel */
       if (aspect_mask == VK_IMAGE_ASPECT_DEPTH_BIT)
          unknown_8c01 = 0x08000041;
@@ -271,7 +271,7 @@ r2d_setup_common(struct tu_cmd_buffer *cmd,
          .d24s8 = fmt == FMT6_Z24_UNORM_S8_UINT_AS_R8G8B8A8 && !clear,
          .color_format = fmt,
          .mask = 0xf,
-         .ifmt = vk_format_is_srgb(vk_format) ? R2D_UNORM8_SRGB : ifmt,
+         .ifmt = util_format_is_srgb(format) ? R2D_UNORM8_SRGB : ifmt,
       ).value;
 
    tu_cs_emit_pkt4(cs, REG_A6XX_RB_2D_BLIT_CNTL, 1);
@@ -284,17 +284,17 @@ r2d_setup_common(struct tu_cmd_buffer *cmd,
       fmt = FMT6_16_16_16_16_FLOAT;
 
    tu_cs_emit_regs(cs, A6XX_SP_2D_DST_FORMAT(
-         .sint = vk_format_is_sint(vk_format),
-         .uint = vk_format_is_uint(vk_format),
+         .sint = util_format_is_pure_sint(format),
+         .uint = util_format_is_pure_uint(format),
          .color_format = fmt,
-         .srgb = vk_format_is_srgb(vk_format),
+         .srgb = util_format_is_srgb(format),
          .mask = 0xf));
 }
 
 static void
 r2d_setup(struct tu_cmd_buffer *cmd,
           struct tu_cs *cs,
-          VkFormat vk_format,
+          enum pipe_format format,
           VkImageAspectFlags aspect_mask,
           unsigned blit_param,
           bool clear,
@@ -305,7 +305,7 @@ r2d_setup(struct tu_cmd_buffer *cmd,
 
    tu_emit_cache_flush_ccu(cmd, cs, TU_CMD_CCU_SYSMEM);
 
-   r2d_setup_common(cmd, cs, vk_format, aspect_mask, blit_param, clear, ubwc, false);
+   r2d_setup_common(cmd, cs, format, aspect_mask, blit_param, clear, ubwc, false);
 }
 
 static void
@@ -750,7 +750,7 @@ r3d_coords(struct tu_cs *cs,
 }
 
 static void
-r3d_clear_value(struct tu_cs *cs, VkFormat format, const VkClearValue *val)
+r3d_clear_value(struct tu_cs *cs, enum pipe_format format, const VkClearValue *val)
 {
    tu_cs_emit_pkt7(cs, CP_LOAD_STATE6_FRAG, 3 + 4);
    tu_cs_emit(cs, CP_LOAD_STATE6_0_DST_OFF(0) |
@@ -761,8 +761,8 @@ r3d_clear_value(struct tu_cs *cs, VkFormat format, const VkClearValue *val)
    tu_cs_emit(cs, CP_LOAD_STATE6_1_EXT_SRC_ADDR(0));
    tu_cs_emit(cs, CP_LOAD_STATE6_2_EXT_SRC_ADDR_HI(0));
    switch (format) {
-   case VK_FORMAT_X8_D24_UNORM_PACK32:
-   case VK_FORMAT_D24_UNORM_S8_UINT: {
+   case PIPE_FORMAT_Z24X8_UNORM:
+   case PIPE_FORMAT_Z24_UNORM_S8_UINT: {
       /* cleared as r8g8b8a8_unorm using special format */
       uint32_t tmp = tu_pack_float32_for_unorm(val->depthStencil.depth, 24);
       tu_cs_emit(cs, fui((tmp & 0xff) / 255.0f));
@@ -770,14 +770,14 @@ r3d_clear_value(struct tu_cs *cs, VkFormat format, const VkClearValue *val)
       tu_cs_emit(cs, fui((tmp >> 16 & 0xff) / 255.0f));
       tu_cs_emit(cs, fui((val->depthStencil.stencil & 0xff) / 255.0f));
    } break;
-   case VK_FORMAT_D16_UNORM:
-   case VK_FORMAT_D32_SFLOAT:
+   case PIPE_FORMAT_Z16_UNORM:
+   case PIPE_FORMAT_Z32_FLOAT:
       tu_cs_emit(cs, fui(val->depthStencil.depth));
       tu_cs_emit(cs, 0);
       tu_cs_emit(cs, 0);
       tu_cs_emit(cs, 0);
       break;
-   case VK_FORMAT_S8_UINT:
+   case PIPE_FORMAT_S8_UINT:
       tu_cs_emit(cs, val->depthStencil.stencil & 0xff);
       tu_cs_emit(cs, 0);
       tu_cs_emit(cs, 0);
@@ -785,7 +785,7 @@ r3d_clear_value(struct tu_cs *cs, VkFormat format, const VkClearValue *val)
       break;
    default:
       /* as color formats use clear value as-is */
-      assert(!vk_format_is_depth_or_stencil(format));
+      assert(!util_format_is_depth_or_stencil(format));
       tu_cs_emit_array(cs, val->color.uint32, 4);
       break;
    }
@@ -868,23 +868,23 @@ r3d_src(struct tu_cmd_buffer *cmd,
 static void
 r3d_src_buffer(struct tu_cmd_buffer *cmd,
                struct tu_cs *cs,
-               VkFormat vk_format,
+               enum pipe_format format,
                uint64_t va, uint32_t pitch,
                uint32_t width, uint32_t height)
 {
    uint32_t desc[A6XX_TEX_CONST_DWORDS];
 
-   struct tu_native_format format = tu6_format_texture(tu_vk_format_to_pipe_format(vk_format), TILE6_LINEAR);
+   struct tu_native_format fmt = tu6_format_texture(format, TILE6_LINEAR);
 
    desc[0] =
-      COND(vk_format_is_srgb(vk_format), A6XX_TEX_CONST_0_SRGB) |
-      A6XX_TEX_CONST_0_FMT(format.fmt) |
-      A6XX_TEX_CONST_0_SWAP(format.swap) |
+      COND(util_format_is_srgb(format), A6XX_TEX_CONST_0_SRGB) |
+      A6XX_TEX_CONST_0_FMT(fmt.fmt) |
+      A6XX_TEX_CONST_0_SWAP(fmt.swap) |
       A6XX_TEX_CONST_0_SWIZ_X(A6XX_TEX_X) |
       // XXX to swizzle into .w for stencil buffer_to_image
-      A6XX_TEX_CONST_0_SWIZ_Y(vk_format == VK_FORMAT_R8_UNORM ? A6XX_TEX_X : A6XX_TEX_Y) |
-      A6XX_TEX_CONST_0_SWIZ_Z(vk_format == VK_FORMAT_R8_UNORM ? A6XX_TEX_X : A6XX_TEX_Z) |
-      A6XX_TEX_CONST_0_SWIZ_W(vk_format == VK_FORMAT_R8_UNORM ? A6XX_TEX_X : A6XX_TEX_W);
+      A6XX_TEX_CONST_0_SWIZ_Y(format == PIPE_FORMAT_R8_UNORM ? A6XX_TEX_X : A6XX_TEX_Y) |
+      A6XX_TEX_CONST_0_SWIZ_Z(format == PIPE_FORMAT_R8_UNORM ? A6XX_TEX_X : A6XX_TEX_Z) |
+      A6XX_TEX_CONST_0_SWIZ_W(format == PIPE_FORMAT_R8_UNORM ? A6XX_TEX_X : A6XX_TEX_W);
    desc[1] = A6XX_TEX_CONST_1_WIDTH(width) | A6XX_TEX_CONST_1_HEIGHT(height);
    desc[2] =
       A6XX_TEX_CONST_2_PITCH(pitch) |
@@ -902,7 +902,7 @@ static void
 r3d_src_gmem(struct tu_cmd_buffer *cmd,
              struct tu_cs *cs,
              const struct tu_image_view *iview,
-             VkFormat format,
+             enum pipe_format format,
              uint32_t gmem_offset,
              uint32_t cpp)
 {
@@ -911,7 +911,7 @@ r3d_src_gmem(struct tu_cmd_buffer *cmd,
 
    /* patch the format so that depth/stencil get the right format */
    desc[0] &= ~A6XX_TEX_CONST_0_FMT__MASK;
-   desc[0] |= A6XX_TEX_CONST_0_FMT(tu6_format_texture(tu_vk_format_to_pipe_format(format), TILE6_2).fmt);
+   desc[0] |= A6XX_TEX_CONST_0_FMT(tu6_format_texture(format, TILE6_2).fmt);
 
    /* patched for gmem */
    desc[0] &= ~(A6XX_TEX_CONST_0_SWAP__MASK | A6XX_TEX_CONST_0_TILE_MODE__MASK);
@@ -954,12 +954,12 @@ r3d_dst_stencil(struct tu_cs *cs, const struct tu_image_view *iview, uint32_t la
 }
 
 static void
-r3d_dst_buffer(struct tu_cs *cs, VkFormat vk_format, uint64_t va, uint32_t pitch)
+r3d_dst_buffer(struct tu_cs *cs, enum pipe_format format, uint64_t va, uint32_t pitch)
 {
-   struct tu_native_format format = tu6_format_color(tu_vk_format_to_pipe_format(vk_format), TILE6_LINEAR);
+   struct tu_native_format fmt = tu6_format_color(format, TILE6_LINEAR);
 
    tu_cs_emit_regs(cs,
-                   A6XX_RB_MRT_BUF_INFO(0, .color_format = format.fmt, .color_swap = format.swap),
+                   A6XX_RB_MRT_BUF_INFO(0, .color_format = fmt.fmt, .color_swap = fmt.swap),
                    A6XX_RB_MRT_PITCH(0, pitch),
                    A6XX_RB_MRT_ARRAY_PITCH(0, 0),
                    A6XX_RB_MRT_BASE(0, .qword = va),
@@ -969,14 +969,14 @@ r3d_dst_buffer(struct tu_cs *cs, VkFormat vk_format, uint64_t va, uint32_t pitch
 }
 
 static uint8_t
-aspect_write_mask(VkFormat vk_format, VkImageAspectFlags aspect_mask)
+aspect_write_mask(enum pipe_format format, VkImageAspectFlags aspect_mask)
 {
    uint8_t mask = 0xf;
    assert(aspect_mask);
    /* note: the only format with partial writing is D24S8,
     * clear/blit uses the _AS_R8G8B8A8 format to access it
     */
-   if (vk_format == VK_FORMAT_D24_UNORM_S8_UINT) {
+   if (format == PIPE_FORMAT_Z24_UNORM_S8_UINT) {
       if (aspect_mask == VK_IMAGE_ASPECT_DEPTH_BIT)
          mask = 0x7;
       if (aspect_mask == VK_IMAGE_ASPECT_STENCIL_BIT)
@@ -988,18 +988,18 @@ aspect_write_mask(VkFormat vk_format, VkImageAspectFlags aspect_mask)
 static void
 r3d_setup(struct tu_cmd_buffer *cmd,
           struct tu_cs *cs,
-          VkFormat vk_format,
+          enum pipe_format format,
           VkImageAspectFlags aspect_mask,
           unsigned blit_param,
           bool clear,
           bool ubwc,
           VkSampleCountFlagBits samples)
 {
-   enum a6xx_format format = tu6_base_format(tu_vk_format_to_pipe_format(vk_format));
+   enum a6xx_format fmt = tu6_base_format(format);
 
-   if ((vk_format == VK_FORMAT_D24_UNORM_S8_UINT ||
-        vk_format == VK_FORMAT_X8_D24_UNORM_PACK32) && ubwc) {
-      format = FMT6_Z24_UNORM_S8_UINT_AS_R8G8B8A8;
+   if ((format == PIPE_FORMAT_Z24_UNORM_S8_UINT ||
+        format == PIPE_FORMAT_Z24X8_UNORM) && ubwc) {
+      fmt = FMT6_Z24_UNORM_S8_UINT_AS_R8G8B8A8;
    }
 
    if (!cmd->state.pass) {
@@ -1037,14 +1037,14 @@ r3d_setup(struct tu_cmd_buffer *cmd,
    tu_cs_emit_regs(cs, A6XX_SP_FS_RENDER_COMPONENTS(.rt0 = 0xf));
 
    tu_cs_emit_regs(cs, A6XX_SP_FS_MRT_REG(0,
-                        .color_format = format,
-                        .color_sint = vk_format_is_sint(vk_format),
-                        .color_uint = vk_format_is_uint(vk_format)));
+                        .color_format = fmt,
+                        .color_sint = util_format_is_pure_sint(format),
+                        .color_uint = util_format_is_pure_uint(format)));
 
    tu_cs_emit_regs(cs, A6XX_RB_MRT_CONTROL(0,
-      .component_enable = aspect_write_mask(vk_format, aspect_mask)));
-   tu_cs_emit_regs(cs, A6XX_RB_SRGB_CNTL(vk_format_is_srgb(vk_format)));
-   tu_cs_emit_regs(cs, A6XX_SP_SRGB_CNTL(vk_format_is_srgb(vk_format)));
+      .component_enable = aspect_write_mask(format, aspect_mask)));
+   tu_cs_emit_regs(cs, A6XX_RB_SRGB_CNTL(util_format_is_srgb(format)));
+   tu_cs_emit_regs(cs, A6XX_SP_SRGB_CNTL(util_format_is_srgb(format)));
 
    tu_cs_emit_regs(cs, A6XX_GRAS_LRZ_CNTL(0));
    tu_cs_emit_regs(cs, A6XX_RB_LRZ_CNTL(0));
@@ -1085,7 +1085,7 @@ struct blit_ops {
                   const VkOffset2D *dst,
                   const VkOffset2D *src,
                   const VkExtent2D *extent);
-   void (*clear_value)(struct tu_cs *cs, VkFormat format, const VkClearValue *val);
+   void (*clear_value)(struct tu_cs *cs, enum pipe_format format, const VkClearValue *val);
    void (*src)(
         struct tu_cmd_buffer *cmd,
         struct tu_cs *cs,
@@ -1093,14 +1093,14 @@ struct blit_ops {
         uint32_t layer,
         VkFilter filter);
    void (*src_buffer)(struct tu_cmd_buffer *cmd, struct tu_cs *cs,
-                      VkFormat vk_format,
+                      enum pipe_format format,
                       uint64_t va, uint32_t pitch,
                       uint32_t width, uint32_t height);
    void (*dst)(struct tu_cs *cs, const struct fdl6_view *iview, uint32_t layer);
-   void (*dst_buffer)(struct tu_cs *cs, VkFormat vk_format, uint64_t va, uint32_t pitch);
+   void (*dst_buffer)(struct tu_cs *cs, enum pipe_format format, uint64_t va, uint32_t pitch);
    void (*setup)(struct tu_cmd_buffer *cmd,
                  struct tu_cs *cs,
-                 VkFormat vk_format,
+                 enum pipe_format format,
                  VkImageAspectFlags aspect_mask,
                  unsigned blit_param, /* CmdBlitImage: rotation in 2D path and z scaling in 3D path */
                  bool clear,
@@ -1151,76 +1151,53 @@ coords(const struct blit_ops *ops,
  * compression behavior, so no just returning R8_UINT/R16_UINT/R32_UINT for
  * everything.
  */
-static VkFormat
-copy_format(VkFormat format, VkImageAspectFlags aspect_mask, bool copy_buffer)
+static enum pipe_format
+copy_format(VkFormat vk_format, VkImageAspectFlags aspect_mask, bool copy_buffer)
 {
-   if (vk_format_is_compressed(format)) {
-      switch (vk_format_get_blocksize(format)) {
-      case 1: return VK_FORMAT_R8_UINT;
-      case 2: return VK_FORMAT_R16_UINT;
-      case 4: return VK_FORMAT_R32_UINT;
-      case 8: return VK_FORMAT_R32G32_UINT;
-      case 16:return VK_FORMAT_R32G32B32A32_UINT;
+   if (vk_format_is_compressed(vk_format)) {
+      switch (vk_format_get_blocksize(vk_format)) {
+      case 1: return PIPE_FORMAT_R8_UINT;
+      case 2: return PIPE_FORMAT_R16_UINT;
+      case 4: return PIPE_FORMAT_R32_UINT;
+      case 8: return PIPE_FORMAT_R32G32_UINT;
+      case 16:return PIPE_FORMAT_R32G32B32A32_UINT;
       default:
          unreachable("unhandled format size");
       }
    }
 
-   switch (format) {
+   enum pipe_format format = tu_vk_format_to_pipe_format(vk_format);
+
    /* For SNORM formats, copy them as the equivalent UNORM format.  If we treat
     * them as snorm then the 0x80 (-1.0 snorm8) value will get clamped to 0x81
     * (also -1.0), when we're supposed to be memcpying the bits. See
     * https://gitlab.khronos.org/Tracker/vk-gl-cts/-/issues/2917 for discussion.
     */
-   case VK_FORMAT_R8_SNORM:
-      return VK_FORMAT_R8_UNORM;
-   case VK_FORMAT_R8G8_SNORM:
-      return VK_FORMAT_R8G8_UNORM;
-   case VK_FORMAT_R8G8B8_SNORM:
-      return VK_FORMAT_R8G8B8_UNORM;
-   case VK_FORMAT_B8G8R8_SNORM:
-      return VK_FORMAT_B8G8R8_UNORM;
-   case VK_FORMAT_R8G8B8A8_SNORM:
-      return VK_FORMAT_R8G8B8A8_UNORM;
-   case VK_FORMAT_B8G8R8A8_SNORM:
-      return VK_FORMAT_B8G8R8A8_UNORM;
-   case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
-      return VK_FORMAT_A8B8G8R8_UNORM_PACK32;
-   case VK_FORMAT_A2R10G10B10_SNORM_PACK32:
-      return VK_FORMAT_A2R10G10B10_UNORM_PACK32;
-   case VK_FORMAT_A2B10G10R10_SNORM_PACK32:
-      return VK_FORMAT_A2B10G10R10_UNORM_PACK32;
-   case VK_FORMAT_R16_SNORM:
-      return VK_FORMAT_R16_UNORM;
-   case VK_FORMAT_R16G16_SNORM:
-      return VK_FORMAT_R16G16_UNORM;
-   case VK_FORMAT_R16G16B16_SNORM:
-      return VK_FORMAT_R16G16B16_UNORM;
-   case VK_FORMAT_R16G16B16A16_SNORM:
-      return VK_FORMAT_R16G16B16A16_UNORM;
+   format = util_format_snorm_to_unorm(format);
 
-   case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
-      return VK_FORMAT_R32_UINT;
+   switch (format) {
+   case PIPE_FORMAT_R9G9B9E5_FLOAT:
+      return PIPE_FORMAT_R32_UINT;
 
-   case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
+   case PIPE_FORMAT_R8_G8B8_420_UNORM:
       if (aspect_mask == VK_IMAGE_ASPECT_PLANE_1_BIT)
-         return VK_FORMAT_R8G8_UNORM;
+         return PIPE_FORMAT_R8G8_UNORM;
       else
-         return VK_FORMAT_R8_UNORM;
-   case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
-      return VK_FORMAT_R8_UNORM;
+         return PIPE_FORMAT_R8_UNORM;
+   case PIPE_FORMAT_R8_G8_B8_420_UNORM:
+      return PIPE_FORMAT_R8_UNORM;
 
-   case VK_FORMAT_D24_UNORM_S8_UINT:
+   case PIPE_FORMAT_Z24_UNORM_S8_UINT:
       if (aspect_mask == VK_IMAGE_ASPECT_STENCIL_BIT && copy_buffer)
-         return VK_FORMAT_R8_UNORM;
+         return PIPE_FORMAT_R8_UNORM;
       else
          return format;
 
-   case VK_FORMAT_D32_SFLOAT_S8_UINT:
+   case PIPE_FORMAT_Z32_FLOAT_S8X24_UINT:
       if (aspect_mask == VK_IMAGE_ASPECT_STENCIL_BIT)
-         return VK_FORMAT_S8_UINT;
+         return PIPE_FORMAT_S8_UINT;
       assert(aspect_mask == VK_IMAGE_ASPECT_DEPTH_BIT);
-      return VK_FORMAT_D32_SFLOAT;
+      return PIPE_FORMAT_Z32_FLOAT;
 
    default:
       return format;
@@ -1235,10 +1212,10 @@ tu6_clear_lrz(struct tu_cmd_buffer *cmd,
 {
    const struct blit_ops *ops = &r2d_ops;
 
-   ops->setup(cmd, cs, VK_FORMAT_D16_UNORM, VK_IMAGE_ASPECT_DEPTH_BIT, 0, true, false,
+   ops->setup(cmd, cs, PIPE_FORMAT_Z16_UNORM, VK_IMAGE_ASPECT_DEPTH_BIT, 0, true, false,
               VK_SAMPLE_COUNT_1_BIT);
-   ops->clear_value(cs, VK_FORMAT_D16_UNORM, value);
-   ops->dst_buffer(cs, VK_FORMAT_D16_UNORM,
+   ops->clear_value(cs, PIPE_FORMAT_Z16_UNORM, value);
+   ops->dst_buffer(cs, PIPE_FORMAT_Z16_UNORM,
                    image->bo->iova + image->bo_offset + image->lrz_offset,
                    image->lrz_pitch * 2);
    ops->coords(cs, &(VkOffset2D) {}, NULL, &(VkExtent2D) {image->lrz_pitch, image->lrz_height});
@@ -1249,7 +1226,7 @@ tu6_clear_lrz(struct tu_cmd_buffer *cmd,
 static void
 tu_image_view_copy_blit(struct fdl6_view *iview,
                         struct tu_image *image,
-                        VkFormat format,
+                        enum pipe_format format,
                         const VkImageSubresourceLayers *subres,
                         uint32_t layer,
                         bool stencil_read,
@@ -1258,8 +1235,8 @@ tu_image_view_copy_blit(struct fdl6_view *iview,
    VkImageAspectFlags aspect_mask = subres->aspectMask;
 
    /* always use the AS_R8G8B8A8 format for these */
-   if (format == VK_FORMAT_D24_UNORM_S8_UINT ||
-       format == VK_FORMAT_X8_D24_UNORM_PACK32) {
+   if (format == PIPE_FORMAT_Z24_UNORM_S8_UINT ||
+       format == PIPE_FORMAT_Z24X8_UNORM) {
       aspect_mask = VK_IMAGE_ASPECT_COLOR_BIT;
    }
 
@@ -1272,8 +1249,7 @@ tu_image_view_copy_blit(struct fdl6_view *iview,
       .layer_count = 1,
       .base_miplevel = subres->mipLevel,
       .level_count = 1,
-      .format = tu_format_for_aspect(tu_vk_format_to_pipe_format(format),
-                                     aspect_mask),
+      .format = tu_format_for_aspect(format, aspect_mask),
       .swiz = {
          /* image_to_buffer from d24s8 with stencil aspect mask writes out to r8 */
          stencil_read ? PIPE_SWIZZLE_W : PIPE_SWIZZLE_X,
@@ -1286,7 +1262,7 @@ tu_image_view_copy_blit(struct fdl6_view *iview,
 static void
 tu_image_view_copy(struct fdl6_view *iview,
                    struct tu_image *image,
-                   VkFormat format,
+                   enum pipe_format format,
                    const VkImageSubresourceLayers *subres,
                    uint32_t layer,
                    bool stencil_read)
@@ -1300,7 +1276,7 @@ tu_image_view_blit(struct fdl6_view *iview,
                    const VkImageSubresourceLayers *subres,
                    uint32_t layer)
 {
-   VkFormat format =
+   enum pipe_format format =
       tu6_plane_format(image->vk_format, tu6_plane_index(image->vk_format,
                                                          subres->aspectMask));
    tu_image_view_copy_blit(iview, image, format, subres, layer, false, false);
@@ -1382,7 +1358,7 @@ tu6_blit_image(struct tu_cmd_buffer *cmd,
 
    trace_start_blit(&cmd->trace, cs);
 
-   ops->setup(cmd, cs, format, info->dstSubresource.aspectMask,
+   ops->setup(cmd, cs, tu_vk_format_to_pipe_format(format), info->dstSubresource.aspectMask,
               blit_param, false, dst_image->layout[0].ubwc,
               dst_image->layout[0].nr_samples);
 
@@ -1411,7 +1387,7 @@ tu6_blit_image(struct tu_cmd_buffer *cmd,
                       MIN2(info->dstOffsets[0].z, info->dstOffsets[1].z));
 
    if (z_scale) {
-      VkFormat src_format =
+      enum pipe_format src_format =
          tu6_plane_format(src_image->vk_format,
                           tu6_plane_index(src_image->vk_format,
                                           info->srcSubresource.aspectMask));
@@ -1509,8 +1485,10 @@ tu_copy_buffer_to_image(struct tu_cmd_buffer *cmd,
 {
    struct tu_cs *cs = &cmd->cs;
    uint32_t layers = MAX2(info->imageExtent.depth, info->imageSubresource.layerCount);
-   VkFormat src_format =
+   enum pipe_format src_format =
       copy_format(dst_image->vk_format, info->imageSubresource.aspectMask, true);
+   enum pipe_format dst_format =
+      copy_format(dst_image->vk_format, info->imageSubresource.aspectMask, false);
    const struct blit_ops *ops = &r2d_ops;
 
    /* special case for buffer to stencil */
@@ -1530,17 +1508,14 @@ tu_copy_buffer_to_image(struct tu_cmd_buffer *cmd,
 
    copy_compressed(dst_image->vk_format, &offset, &extent, &src_width, &src_height);
 
-   uint32_t pitch = src_width * vk_format_get_blocksize(src_format);
+   uint32_t pitch = src_width * util_format_get_blocksize(src_format);
    uint32_t layer_size = src_height * pitch;
 
-   ops->setup(cmd, cs,
-              copy_format(dst_image->vk_format, info->imageSubresource.aspectMask, false),
+   ops->setup(cmd, cs, dst_format,
               info->imageSubresource.aspectMask, 0, false, dst_image->layout[0].ubwc,
               dst_image->layout[0].nr_samples);
 
    struct fdl6_view dst;
-   VkFormat dst_format =
-      copy_format(dst_image->vk_format, info->imageSubresource.aspectMask, false);
    tu_image_view_copy(&dst, dst_image, dst_format, &info->imageSubresource, offset.z, false);
 
    for (uint32_t i = 0; i < layers; i++) {
@@ -1549,7 +1524,7 @@ tu_copy_buffer_to_image(struct tu_cmd_buffer *cmd,
       uint64_t src_va = tu_buffer_iova(src_buffer) + info->bufferOffset + layer_size * i;
       if ((src_va & 63) || (pitch & 63)) {
          for (uint32_t y = 0; y < extent.height; y++) {
-            uint32_t x = (src_va & 63) / vk_format_get_blocksize(src_format);
+            uint32_t x = (src_va & 63) / util_format_get_blocksize(src_format);
             ops->src_buffer(cmd, cs, src_format, src_va & ~63, pitch,
                             x + extent.width, 1);
             ops->coords(cs, &(VkOffset2D){offset.x, offset.y + y},  &(VkOffset2D){x},
@@ -1591,8 +1566,10 @@ tu_copy_image_to_buffer(struct tu_cmd_buffer *cmd,
 {
    struct tu_cs *cs = &cmd->cs;
    uint32_t layers = MAX2(info->imageExtent.depth, info->imageSubresource.layerCount);
-   VkFormat dst_format =
+   enum pipe_format dst_format =
       copy_format(src_image->vk_format, info->imageSubresource.aspectMask, true);
+   enum pipe_format src_format =
+      copy_format(src_image->vk_format, info->imageSubresource.aspectMask, false);
    bool stencil_read = false;
 
    if (src_image->vk_format == VK_FORMAT_D24_UNORM_S8_UINT &&
@@ -1608,15 +1585,13 @@ tu_copy_image_to_buffer(struct tu_cmd_buffer *cmd,
 
    copy_compressed(src_image->vk_format, &offset, &extent, &dst_width, &dst_height);
 
-   uint32_t pitch = dst_width * vk_format_get_blocksize(dst_format);
+   uint32_t pitch = dst_width * util_format_get_blocksize(dst_format);
    uint32_t layer_size = pitch * dst_height;
 
    ops->setup(cmd, cs, dst_format, VK_IMAGE_ASPECT_COLOR_BIT, 0, false, false,
               VK_SAMPLE_COUNT_1_BIT);
 
    struct fdl6_view src;
-   VkFormat src_format =
-      copy_format(src_image->vk_format, info->imageSubresource.aspectMask, false);
    tu_image_view_copy(&src, src_image, src_format, &info->imageSubresource, offset.z, stencil_read);
 
    for (uint32_t i = 0; i < layers; i++) {
@@ -1625,7 +1600,7 @@ tu_copy_image_to_buffer(struct tu_cmd_buffer *cmd,
       uint64_t dst_va = tu_buffer_iova(dst_buffer) + info->bufferOffset + layer_size * i;
       if ((dst_va & 63) || (pitch & 63)) {
          for (uint32_t y = 0; y < extent.height; y++) {
-            uint32_t x = (dst_va & 63) / vk_format_get_blocksize(dst_format);
+            uint32_t x = (dst_va & 63) / util_format_get_blocksize(dst_format);
             ops->dst_buffer(cs, dst_format, dst_va & ~63, 0);
             ops->coords(cs, &(VkOffset2D) {x}, &(VkOffset2D){offset.x, offset.y + y},
                         &(VkExtent2D) {extent.width, 1});
@@ -1669,10 +1644,10 @@ tu_CmdCopyImageToBuffer(VkCommandBuffer commandBuffer,
  */
 
 static bool
-is_swapped_format(VkFormat format)
+is_swapped_format(enum pipe_format format)
 {
-   struct tu_native_format linear = tu6_format_texture(tu_vk_format_to_pipe_format(format), TILE6_LINEAR);
-   struct tu_native_format tiled = tu6_format_texture(tu_vk_format_to_pipe_format(format), TILE6_3);
+   struct tu_native_format linear = tu6_format_texture(format, TILE6_LINEAR);
+   struct tu_native_format tiled = tu6_format_texture(format, TILE6_3);
    return linear.fmt != tiled.fmt || linear.swap != tiled.swap;
 }
 
@@ -1699,7 +1674,7 @@ tu_copy_image_to_image(struct tu_cmd_buffer *cmd,
    if (dst_image->layout[0].nr_samples > 1)
       ops = &r3d_ops;
 
-   VkFormat format = VK_FORMAT_UNDEFINED;
+   enum pipe_format format = PIPE_FORMAT_NONE;
    VkOffset3D src_offset = info->srcOffset;
    VkOffset3D dst_offset = info->dstOffset;
    VkExtent3D extent = info->extent;
@@ -1724,8 +1699,8 @@ tu_copy_image_to_image(struct tu_cmd_buffer *cmd,
    copy_compressed(src_image->vk_format, &src_offset, &extent, NULL, NULL);
    copy_compressed(dst_image->vk_format, &dst_offset, NULL, NULL, NULL);
 
-   VkFormat dst_format = copy_format(dst_image->vk_format, info->dstSubresource.aspectMask, false);
-   VkFormat src_format = copy_format(src_image->vk_format, info->srcSubresource.aspectMask, false);
+   enum pipe_format dst_format = copy_format(dst_image->vk_format, info->dstSubresource.aspectMask, false);
+   enum pipe_format src_format = copy_format(src_image->vk_format, info->srcSubresource.aspectMask, false);
 
    bool use_staging_blit = false;
 
@@ -1776,7 +1751,7 @@ tu_copy_image_to_image(struct tu_cmd_buffer *cmd,
       staging_layout.ubwc = false;
 
       fdl6_layout(&staging_layout,
-                  vk_format_to_pipe_format(src_format),
+                  src_format,
                   src_image->layout[0].nr_samples,
                   extent.width,
                   extent.height,
@@ -1803,8 +1778,7 @@ tu_copy_image_to_image(struct tu_cmd_buffer *cmd,
          .layer_count = 1,
          .base_miplevel = 0,
          .level_count = info->srcSubresource.layerCount,
-         .format = tu_format_for_aspect(vk_format_to_pipe_format(src_format),
-                                        VK_IMAGE_ASPECT_COLOR_BIT),
+         .format = tu_format_for_aspect(src_format, VK_IMAGE_ASPECT_COLOR_BIT),
          .swiz = { PIPE_SWIZZLE_X, PIPE_SWIZZLE_Y, PIPE_SWIZZLE_Z, PIPE_SWIZZLE_W },
          .type = FDL_VIEW_TYPE_2D,
       }, false);
@@ -1832,8 +1806,7 @@ tu_copy_image_to_image(struct tu_cmd_buffer *cmd,
          .layer_count = 1,
          .base_miplevel = 0,
          .level_count = info->srcSubresource.layerCount,
-         .format = tu_format_for_aspect(vk_format_to_pipe_format(dst_format),
-                                        VK_IMAGE_ASPECT_COLOR_BIT),
+         .format = tu_format_for_aspect(dst_format, VK_IMAGE_ASPECT_COLOR_BIT),
          .swiz = { PIPE_SWIZZLE_X, PIPE_SWIZZLE_Y, PIPE_SWIZZLE_Z, PIPE_SWIZZLE_W },
          .type = FDL_VIEW_TYPE_2D,
       }, false);
@@ -1904,7 +1877,7 @@ copy_buffer(struct tu_cmd_buffer *cmd,
 {
    const struct blit_ops *ops = &r2d_ops;
    struct tu_cs *cs = &cmd->cs;
-   VkFormat format = block_size == 4 ? VK_FORMAT_R32_UINT : VK_FORMAT_R8_UNORM;
+   enum pipe_format format = block_size == 4 ? PIPE_FORMAT_R32_UINT : PIPE_FORMAT_R8_UNORM;
    uint64_t blocks = size / block_size;
 
    ops->setup(cmd, cs, format, VK_IMAGE_ASPECT_COLOR_BIT, 0, false, false,
@@ -1986,15 +1959,15 @@ tu_CmdFillBuffer(VkCommandBuffer commandBuffer,
    uint64_t dst_va = tu_buffer_iova(buffer) + dstOffset;
    uint32_t blocks = fillSize / 4;
 
-   ops->setup(cmd, cs, VK_FORMAT_R32_UINT, VK_IMAGE_ASPECT_COLOR_BIT, 0, true, false,
+   ops->setup(cmd, cs, PIPE_FORMAT_R32_UINT, VK_IMAGE_ASPECT_COLOR_BIT, 0, true, false,
               VK_SAMPLE_COUNT_1_BIT);
-   ops->clear_value(cs, VK_FORMAT_R32_UINT, &(VkClearValue){.color = {.uint32[0] = data}});
+   ops->clear_value(cs, PIPE_FORMAT_R32_UINT, &(VkClearValue){.color = {.uint32[0] = data}});
 
    while (blocks) {
       uint32_t dst_x = (dst_va & 63) / 4;
       uint32_t width = MIN2(blocks, 0x4000 - dst_x);
 
-      ops->dst_buffer(cs, VK_FORMAT_R32_UINT, dst_va & ~63, 0);
+      ops->dst_buffer(cs, PIPE_FORMAT_R32_UINT, dst_va & ~63, 0);
       ops->coords(cs, &(VkOffset2D) {dst_x}, NULL, &(VkExtent2D) {width, 1});
       ops->run(cmd, cs);
 
@@ -2020,8 +1993,9 @@ tu_CmdResolveImage(VkCommandBuffer commandBuffer,
    const struct blit_ops *ops = &r2d_ops;
    struct tu_cs *cs = &cmd->cs;
 
-   ops->setup(cmd, cs, dst_image->vk_format, VK_IMAGE_ASPECT_COLOR_BIT,
-              0, false, dst_image->layout[0].ubwc, VK_SAMPLE_COUNT_1_BIT);
+   ops->setup(cmd, cs, tu_vk_format_to_pipe_format(dst_image->vk_format),
+              VK_IMAGE_ASPECT_COLOR_BIT, 0, false, dst_image->layout[0].ubwc, 
+              VK_SAMPLE_COUNT_1_BIT);
 
    for (uint32_t i = 0; i < regionCount; ++i) {
       const VkImageResolve *info = &pRegions[i];
@@ -2067,8 +2041,9 @@ resolve_sysmem(struct tu_cmd_buffer *cmd,
 
    trace_start_sysmem_resolve(&cmd->trace, cs);
 
-   ops->setup(cmd, cs, format, VK_IMAGE_ASPECT_COLOR_BIT,
-              0, false, dst->view.ubwc_enabled, VK_SAMPLE_COUNT_1_BIT);
+   ops->setup(cmd, cs, tu_vk_format_to_pipe_format(format),
+              VK_IMAGE_ASPECT_COLOR_BIT, 0, false, dst->view.ubwc_enabled,
+              VK_SAMPLE_COUNT_1_BIT);
    ops->coords(cs, &rect->offset, &rect->offset, &rect->extent);
 
    for_each_layer(i, layer_mask, layers) {
@@ -2119,9 +2094,9 @@ clear_image(struct tu_cmd_buffer *cmd,
    uint32_t level_count = tu_get_levelCount(image, range);
    uint32_t layer_count = tu_get_layerCount(image, range);
    struct tu_cs *cs = &cmd->cs;
-   VkFormat format;
+   enum pipe_format format;
    if (image->vk_format == VK_FORMAT_E5B9G9R9_UFLOAT_PACK32) {
-      format = VK_FORMAT_R32_UINT;
+      format = PIPE_FORMAT_R32_UINT;
    } else {
       format = tu6_plane_format(image->vk_format,
                                 tu6_plane_index(image->vk_format,
@@ -2138,7 +2113,7 @@ clear_image(struct tu_cmd_buffer *cmd,
    ops->setup(cmd, cs, format, aspect_mask, 0, true, image->layout[0].ubwc,
               image->layout[0].nr_samples);
    if (image->vk_format == VK_FORMAT_E5B9G9R9_UFLOAT_PACK32)
-      ops->clear_value(cs, VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, clear_value);
+      ops->clear_value(cs, PIPE_FORMAT_R9G9B9E5_FLOAT, clear_value);
    else
       ops->clear_value(cs, format, clear_value);
 
@@ -2364,21 +2339,21 @@ tu_clear_sysmem_attachments(struct tu_cmd_buffer *cmd,
 }
 
 static void
-pack_gmem_clear_value(const VkClearValue *val, VkFormat format, uint32_t clear_value[4])
+pack_gmem_clear_value(const VkClearValue *val, enum pipe_format format, uint32_t clear_value[4])
 {
    switch (format) {
-   case VK_FORMAT_X8_D24_UNORM_PACK32:
-   case VK_FORMAT_D24_UNORM_S8_UINT:
+   case PIPE_FORMAT_Z24X8_UNORM:
+   case PIPE_FORMAT_Z24_UNORM_S8_UINT:
       clear_value[0] = tu_pack_float32_for_unorm(val->depthStencil.depth, 24) |
                        val->depthStencil.stencil << 24;
       return;
-   case VK_FORMAT_D16_UNORM:
+   case PIPE_FORMAT_Z16_UNORM:
       clear_value[0] = tu_pack_float32_for_unorm(val->depthStencil.depth, 16);
       return;
-   case VK_FORMAT_D32_SFLOAT:
+   case PIPE_FORMAT_Z32_FLOAT:
       clear_value[0] = fui(val->depthStencil.depth);
       return;
-   case VK_FORMAT_S8_UINT:
+   case PIPE_FORMAT_S8_UINT:
       clear_value[0] = val->depthStencil.stencil;
       return;
    default:
@@ -2387,33 +2362,33 @@ pack_gmem_clear_value(const VkClearValue *val, VkFormat format, uint32_t clear_v
 
    float tmp[4];
    memcpy(tmp, val->color.float32, 4 * sizeof(float));
-   if (vk_format_is_srgb(format)) {
+   if (util_format_is_srgb(format)) {
       for (int i = 0; i < 3; i++)
          tmp[i] = util_format_linear_to_srgb_float(tmp[i]);
    }
 
 #define PACK_F(type) util_format_##type##_pack_rgba_float \
    ( (uint8_t*) &clear_value[0], 0, tmp, 0, 1, 1)
-   switch (vk_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, PIPE_SWIZZLE_X)) {
+   switch (util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, PIPE_SWIZZLE_X)) {
    case 4:
       PACK_F(r4g4b4a4_unorm);
       break;
    case 5:
-      if (vk_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, PIPE_SWIZZLE_Y) == 6)
+      if (util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, PIPE_SWIZZLE_Y) == 6)
          PACK_F(r5g6b5_unorm);
       else
          PACK_F(r5g5b5a1_unorm);
       break;
    case 8:
-      if (vk_format_is_snorm(format))
+      if (util_format_is_snorm(format))
          PACK_F(r8g8b8a8_snorm);
-      else if (vk_format_is_unorm(format))
+      else if (util_format_is_unorm(format))
          PACK_F(r8g8b8a8_unorm);
       else
          pack_int8(clear_value, val->color.uint32);
       break;
    case 10:
-      if (vk_format_is_int(format))
+      if (util_format_is_pure_integer(format))
          pack_int10_2(clear_value, val->color.uint32);
       else
          PACK_F(r10g10b10a2_unorm);
@@ -2422,11 +2397,11 @@ pack_gmem_clear_value(const VkClearValue *val, VkFormat format, uint32_t clear_v
       clear_value[0] = float3_to_r11g11b10f(val->color.float32);
       break;
    case 16:
-      if (vk_format_is_snorm(format))
+      if (util_format_is_snorm(format))
          PACK_F(r16g16b16a16_snorm);
-      else if (vk_format_is_unorm(format))
+      else if (util_format_is_unorm(format))
          PACK_F(r16g16b16a16_unorm);
-      else if (vk_format_is_float(format))
+      else if (util_format_is_float(format))
          PACK_F(r16g16b16a16_float);
       else
          pack_int16(clear_value, val->color.uint32);
@@ -2443,13 +2418,13 @@ pack_gmem_clear_value(const VkClearValue *val, VkFormat format, uint32_t clear_v
 static void
 clear_gmem_attachment(struct tu_cmd_buffer *cmd,
                       struct tu_cs *cs,
-                      VkFormat format,
+                      enum pipe_format format,
                       uint8_t clear_mask,
                       uint32_t gmem_offset,
                       const VkClearValue *value)
 {
    tu_cs_emit_pkt4(cs, REG_A6XX_RB_BLIT_DST_INFO, 1);
-   tu_cs_emit(cs, A6XX_RB_BLIT_DST_INFO_COLOR_FORMAT(tu6_base_format(tu_vk_format_to_pipe_format(format))));
+   tu_cs_emit(cs, A6XX_RB_BLIT_DST_INFO_COLOR_FORMAT(tu6_base_format(format)));
 
    tu_cs_emit_regs(cs, A6XX_RB_BLIT_INFO(.gmem = 1, .clear_mask = clear_mask));
 
@@ -2480,15 +2455,16 @@ tu_emit_clear_gmem_attachment(struct tu_cmd_buffer *cmd,
 
    trace_start_gmem_clear(&cmd->trace, cs);
 
+   enum pipe_format format = tu_vk_format_to_pipe_format(att->format);
    if (att->format == VK_FORMAT_D32_SFLOAT_S8_UINT) {
       if (mask & VK_IMAGE_ASPECT_DEPTH_BIT)
-         clear_gmem_attachment(cmd, cs, VK_FORMAT_D32_SFLOAT, 0xf, att->gmem_offset, value);
+         clear_gmem_attachment(cmd, cs, PIPE_FORMAT_Z32_FLOAT, 0xf, att->gmem_offset, value);
       if (mask & VK_IMAGE_ASPECT_STENCIL_BIT)
-         clear_gmem_attachment(cmd, cs, VK_FORMAT_S8_UINT, 0xf, att->gmem_offset_stencil, value);
+         clear_gmem_attachment(cmd, cs, PIPE_FORMAT_S8_UINT, 0xf, att->gmem_offset_stencil, value);
       return;
    }
 
-   clear_gmem_attachment(cmd, cs, att->format, aspect_write_mask(att->format, mask), att->gmem_offset, value);
+   clear_gmem_attachment(cmd, cs, format, aspect_write_mask(format, mask), att->gmem_offset, value);
 
    trace_end_gmem_clear(&cmd->trace, cs, att->format, att->samples);
 }
@@ -2580,12 +2556,13 @@ tu_CmdClearAttachments(VkCommandBuffer commandBuffer,
 static void
 clear_sysmem_attachment(struct tu_cmd_buffer *cmd,
                         struct tu_cs *cs,
-                        VkFormat format,
+                        VkFormat vk_format,
                         VkImageAspectFlags clear_mask,
                         const VkRenderPassBeginInfo *info,
                         uint32_t a,
                         bool separate_stencil)
 {
+   enum pipe_format format = tu_vk_format_to_pipe_format(vk_format);
    const struct tu_framebuffer *fb = cmd->state.framebuffer;
    const struct tu_image_view *iview = cmd->state.attachments[a];
    const uint32_t clear_views = cmd->state.pass->attachments[a].clear_views;
@@ -2615,7 +2592,7 @@ clear_sysmem_attachment(struct tu_cmd_buffer *cmd,
    ops->teardown(cmd, cs);
 
    trace_end_sysmem_clear(&cmd->trace, cs,
-                          format, ops == &r3d_ops,
+                          vk_format, ops == &r3d_ops,
                           cmd->state.pass->attachments[a].samples);
 }
 
@@ -2785,7 +2762,7 @@ store_cp_blit(struct tu_cmd_buffer *cmd,
               const struct tu_image_view *iview,
               uint32_t samples,
               bool separate_stencil,
-              VkFormat format,
+              enum pipe_format format,
               uint32_t gmem_offset,
               uint32_t cpp)
 {
@@ -2798,12 +2775,12 @@ store_cp_blit(struct tu_cmd_buffer *cmd,
 
    tu_cs_emit_regs(cs,
                    A6XX_SP_PS_2D_SRC_INFO(
-                      .color_format = tu6_format_texture(tu_vk_format_to_pipe_format(format), TILE6_2).fmt,
+                      .color_format = tu6_format_texture(format, TILE6_2).fmt,
                       .tile_mode = TILE6_2,
-                      .srgb = vk_format_is_srgb(format),
+                      .srgb = util_format_is_srgb(format),
                       .samples = tu_msaa_samples(samples),
-                      .samples_average = !vk_format_is_int(format) &&
-                                         !vk_format_is_depth_or_stencil(format),
+                      .samples_average = !util_format_is_pure_integer(format) &&
+                                         !util_format_is_depth_or_stencil(format),
                       .unk20 = 1,
                       .unk22 = 1),
                    /* note: src size does not matter when not scaling */
@@ -2833,7 +2810,7 @@ store_3d_blit(struct tu_cmd_buffer *cmd,
               const struct tu_image_view *iview,
               uint32_t dst_samples,
               bool separate_stencil,
-              VkFormat format,
+              enum pipe_format format,
               const VkRect2D *render_area,
               uint32_t gmem_offset,
               uint32_t cpp)
@@ -2916,9 +2893,9 @@ tu_store_gmem_attachment(struct tu_cmd_buffer *cmd,
       return;
    }
 
-   VkFormat format = src->format;
-   if (format == VK_FORMAT_D32_SFLOAT_S8_UINT)
-      format = VK_FORMAT_D32_SFLOAT;
+   enum pipe_format format = tu_vk_format_to_pipe_format(src->format);
+   if (format == PIPE_FORMAT_Z32_FLOAT_S8X24_UINT)
+      format = PIPE_FORMAT_Z32_FLOAT;
 
    if (dst->samples > 1) {
       /* If we hit this path, we have to disable draw states after every tile
@@ -2936,7 +2913,7 @@ tu_store_gmem_attachment(struct tu_cmd_buffer *cmd,
                        render_area, src->gmem_offset, src->cpp);
       }
       if (dst->store_stencil) {
-         store_3d_blit(cmd, cs, iview, dst->samples, true, VK_FORMAT_S8_UINT,
+         store_3d_blit(cmd, cs, iview, dst->samples, true, PIPE_FORMAT_S8_UINT,
                        render_area, src->gmem_offset, src->samples);
       }
    } else {
@@ -2947,7 +2924,7 @@ tu_store_gmem_attachment(struct tu_cmd_buffer *cmd,
                        src->gmem_offset, src->cpp);
       }
       if (dst->store_stencil) {
-         store_cp_blit(cmd, cs, iview, src->samples, true, VK_FORMAT_S8_UINT,
+         store_cp_blit(cmd, cs, iview, src->samples, true, PIPE_FORMAT_S8_UINT,
                        src->gmem_offset_stencil, src->samples);
       }
    }
diff --git a/src/freedreno/vulkan/tu_image.c b/src/freedreno/vulkan/tu_image.c
index 0a04109b45a..4d9b2e953fa 100644
--- a/src/freedreno/vulkan/tu_image.c
+++ b/src/freedreno/vulkan/tu_image.c
@@ -51,19 +51,19 @@ tu6_plane_count(VkFormat format)
    }
 }
 
-VkFormat
+enum pipe_format
 tu6_plane_format(VkFormat format, uint32_t plane)
 {
    switch (format) {
    case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
       /* note: with UBWC, and Y plane UBWC is different from R8_UNORM */
-      return plane ? VK_FORMAT_R8G8_UNORM : VK_FORMAT_R8_UNORM;
+      return plane ? PIPE_FORMAT_R8G8_UNORM : PIPE_FORMAT_R8_UNORM;
    case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
-      return VK_FORMAT_R8_UNORM;
+      return PIPE_FORMAT_R8_UNORM;
    case VK_FORMAT_D32_SFLOAT_S8_UINT:
-      return plane ? VK_FORMAT_S8_UINT : VK_FORMAT_D32_SFLOAT;
+      return plane ? PIPE_FORMAT_S8_UINT : PIPE_FORMAT_Z32_FLOAT;
    default:
-      return format;
+      return tu_vk_format_to_pipe_format(format);
    }
 }
 
@@ -229,7 +229,7 @@ tu_image_view_init(struct tu_image_view *iview,
 {
    TU_FROM_HANDLE(tu_image, image, pCreateInfo->image);
    const VkImageSubresourceRange *range = &pCreateInfo->subresourceRange;
-   VkFormat format = pCreateInfo->format;
+   VkFormat vk_format = pCreateInfo->format;
    VkImageAspectFlagBits aspect_mask = pCreateInfo->subresourceRange.aspectMask;
 
    const struct VkSamplerYcbcrConversionInfo *ycbcr_conversion =
@@ -243,12 +243,15 @@ tu_image_view_init(struct tu_image_view *iview,
 
    layouts[0] = &image->layout[tu6_plane_index(image->vk_format, aspect_mask)];
 
+   enum pipe_format format;
    if (aspect_mask != VK_IMAGE_ASPECT_COLOR_BIT)
-      format = tu6_plane_format(format, tu6_plane_index(format, aspect_mask));
+      format = tu6_plane_format(vk_format, tu6_plane_index(vk_format, aspect_mask));
+   else
+      format = tu_vk_format_to_pipe_format(vk_format);
 
    if (aspect_mask == VK_IMAGE_ASPECT_COLOR_BIT &&
-       (format == VK_FORMAT_G8_B8R8_2PLANE_420_UNORM ||
-        format == VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM)) {
+       (vk_format == VK_FORMAT_G8_B8R8_2PLANE_420_UNORM ||
+        vk_format == VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM)) {
       layouts[1] = &image->layout[1];
       layouts[2] = &image->layout[2];
    }
@@ -259,8 +262,7 @@ tu_image_view_init(struct tu_image_view *iview,
    args.base_miplevel = range->baseMipLevel;
    args.layer_count = tu_get_layerCount(image, range);
    args.level_count = tu_get_levelCount(image, range);
-   args.format = tu_format_for_aspect(tu_vk_format_to_pipe_format(format),
-                                      aspect_mask);
+   args.format = tu_format_for_aspect(format, aspect_mask);
    vk_component_mapping_to_pipe_swizzle(pCreateInfo->components, args.swiz);
    if (conversion) {
       unsigned char conversion_swiz[4], create_swiz[4];
@@ -486,7 +488,7 @@ tu_CreateImage(VkDevice _device,
 
    for (uint32_t i = 0; i < tu6_plane_count(image->vk_format); i++) {
       struct fdl_layout *layout = &image->layout[i];
-      VkFormat format = tu6_plane_format(image->vk_format, i);
+      enum pipe_format format = tu6_plane_format(image->vk_format, i);
       uint32_t width0 = pCreateInfo->extent.width;
       uint32_t height0 = pCreateInfo->extent.height;
 
@@ -524,7 +526,7 @@ tu_CreateImage(VkDevice _device,
       layout->tile_mode = tile_mode;
       layout->ubwc = ubwc_enabled;
 
-      if (!fdl6_layout(layout, vk_format_to_pipe_format(format),
+      if (!fdl6_layout(layout, format,
                        pCreateInfo->samples,
                        width0, height0,
                        pCreateInfo->extent.depth,
diff --git a/src/freedreno/vulkan/tu_private.h b/src/freedreno/vulkan/tu_private.h
index 03e88d06a2a..850b633f516 100644
--- a/src/freedreno/vulkan/tu_private.h
+++ b/src/freedreno/vulkan/tu_private.h
@@ -1445,7 +1445,7 @@ tu_get_levelCount(const struct tu_image *image,
              : range->levelCount;
 }
 
-VkFormat tu6_plane_format(VkFormat format, uint32_t plane);
+enum pipe_format tu6_plane_format(VkFormat format, uint32_t plane);
 
 uint32_t tu6_plane_index(VkFormat format, VkImageAspectFlags aspect_mask);