anv: Rip out shadow surfaces

These are only used for storage-compatible compressed surfaces on
Broadwell and earlier and Stencil on Gfx7 where there isn't proper
stencil sampling support.

Reviewed-by: Lionel Landwerlin <lionel.g.landwerlin@intel.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/18402>

1 files changed, 1 insertions, 161 deletions

diff --git a/src/intel/vulkan/anv_blorp.c b/src/intel/vulkan/anv_blorp.c
index 2c405891df6..6eacf456b91 100644
--- a/src/intel/vulkan/anv_blorp.c
+++ b/src/intel/vulkan/anv_blorp.c
@@ -263,33 +263,6 @@ get_blorp_surf_for_anv_image(const struct anv_device *device,
    }
 }
 
-static bool
-get_blorp_surf_for_anv_shadow_image(const struct anv_device *device,
-                                    const struct anv_image *image,
-                                    VkImageAspectFlags aspect,
-                                    struct blorp_surf *blorp_surf)
-{
-
-   const uint32_t plane = anv_image_aspect_to_plane(image, aspect);
-   if (!anv_surface_is_valid(&image->planes[plane].shadow_surface))
-      return false;
-
-   const struct anv_surface *surface = &image->planes[plane].shadow_surface;
-   const struct anv_address address =
-      anv_image_address(image, &surface->memory_range);
-
-   *blorp_surf = (struct blorp_surf) {
-      .surf = &surface->isl,
-      .addr = {
-         .buffer = address.bo,
-         .offset = address.offset,
-         .mocs = anv_mocs(device, address.bo, ISL_SURF_USAGE_RENDER_TARGET_BIT),
-      },
-   };
-
-   return true;
-}
-
 static void
 copy_image(struct anv_cmd_buffer *cmd_buffer,
            struct blorp_batch *batch,
@@ -358,20 +331,6 @@ copy_image(struct anv_cmd_buffer *cmd_buffer,
                        dstOffset.x, dstOffset.y,
                        extent.width, extent.height);
          }
-
-         struct blorp_surf dst_shadow_surf;
-         if (get_blorp_surf_for_anv_shadow_image(cmd_buffer->device,
-                                                 dst_image,
-                                                 1UL << aspect_bit,
-                                                 &dst_shadow_surf)) {
-            for (unsigned i = 0; i < layer_count; i++) {
-               blorp_copy(batch, &src_surf, src_level, src_base_layer + i,
-                          &dst_shadow_surf, dst_level, dst_base_layer + i,
-                          srcOffset.x, srcOffset.y,
-                          dstOffset.x, dstOffset.y,
-                          extent.width, extent.height);
-            }
-         }
       }
    } else {
       struct blorp_surf src_surf, dst_surf;
@@ -394,19 +353,6 @@ copy_image(struct anv_cmd_buffer *cmd_buffer,
                     dstOffset.x, dstOffset.y,
                     extent.width, extent.height);
       }
-
-      struct blorp_surf dst_shadow_surf;
-      if (get_blorp_surf_for_anv_shadow_image(cmd_buffer->device,
-                                              dst_image, dst_mask,
-                                              &dst_shadow_surf)) {
-         for (unsigned i = 0; i < layer_count; i++) {
-            blorp_copy(batch, &src_surf, src_level, src_base_layer + i,
-                       &dst_shadow_surf, dst_level, dst_base_layer + i,
-                       srcOffset.x, srcOffset.y,
-                       dstOffset.x, dstOffset.y,
-                       extent.width, extent.height);
-         }
-      }
    }
 }
 
@@ -527,8 +473,6 @@ copy_buffer_to_image(struct anv_cmd_buffer *cmd_buffer,
                                  buffer_layout.row_stride_B, buffer_format,
                                  false, &buffer.surf, &buffer_isl_surf);
 
-   bool dst_has_shadow = false;
-   struct blorp_surf dst_shadow_surf;
    if (&image == dst) {
       /* In this case, the source is the buffer and, since blorp takes its
        * copy dimensions in terms of the source format, we have to use the
@@ -542,11 +486,6 @@ copy_buffer_to_image(struct anv_cmd_buffer *cmd_buffer,
                                         aspect, dst->surf.aux_usage,
                                         dst->level,
                                         dst->offset.z, extent.depth);
-
-      dst_has_shadow =
-         get_blorp_surf_for_anv_shadow_image(cmd_buffer->device,
-                                             anv_image, aspect,
-                                             &dst_shadow_surf);
    }
 
    for (unsigned z = 0; z < extent.depth; z++) {
@@ -555,14 +494,6 @@ copy_buffer_to_image(struct anv_cmd_buffer *cmd_buffer,
                  src->offset.x, src->offset.y, dst->offset.x, dst->offset.y,
                  extent.width, extent.height);
 
-      if (dst_has_shadow) {
-         blorp_copy(batch, &src->surf, src->level, src->offset.z,
-                    &dst_shadow_surf, dst->level, dst->offset.z,
-                    src->offset.x, src->offset.y,
-                    dst->offset.x, dst->offset.y,
-                    extent.width, extent.height);
-      }
-
       image.offset.z++;
       buffer.surf.addr.offset += buffer_layout.image_stride_B;
    }
@@ -1063,7 +994,7 @@ void anv_CmdClearDepthStencilImage(
    anv_blorp_batch_init(cmd_buffer, &batch, 0);
    assert((batch.flags & BLORP_BATCH_USE_COMPUTE) == 0);
 
-   struct blorp_surf depth, stencil, stencil_shadow;
+   struct blorp_surf depth, stencil;
    if (image->vk.aspects & VK_IMAGE_ASPECT_DEPTH_BIT) {
       get_blorp_surf_for_anv_image(cmd_buffer->device,
                                    image, VK_IMAGE_ASPECT_DEPTH_BIT,
@@ -1073,17 +1004,11 @@ void anv_CmdClearDepthStencilImage(
       memset(&depth, 0, sizeof(depth));
    }
 
-   bool has_stencil_shadow = false;
    if (image->vk.aspects & VK_IMAGE_ASPECT_STENCIL_BIT) {
       get_blorp_surf_for_anv_image(cmd_buffer->device,
                                    image, VK_IMAGE_ASPECT_STENCIL_BIT,
                                    VK_IMAGE_USAGE_TRANSFER_DST_BIT,
                                    imageLayout, ISL_AUX_USAGE_NONE, &stencil);
-
-      has_stencil_shadow =
-         get_blorp_surf_for_anv_shadow_image(cmd_buffer->device, image,
-                                             VK_IMAGE_ASPECT_STENCIL_BIT,
-                                             &stencil_shadow);
    } else {
       memset(&stencil, 0, sizeof(stencil));
    }
@@ -1115,17 +1040,6 @@ void anv_CmdClearDepthStencilImage(
                                    clear_depth, pDepthStencil->depth,
                                    clear_stencil ? 0xff : 0,
                                    pDepthStencil->stencil);
-
-         if (clear_stencil && has_stencil_shadow) {
-            union isl_color_value stencil_color = {
-               .u32 = { pDepthStencil->stencil, },
-            };
-            blorp_clear(&batch, &stencil_shadow,
-                        ISL_FORMAT_R8_UINT, ISL_SWIZZLE_IDENTITY,
-                        level, base_layer, layer_count,
-                        0, 0, level_width, level_height,
-                        stencil_color, 0 /* color_write_disable */);
-         }
       }
    }
 
@@ -1485,63 +1399,6 @@ void anv_CmdResolveImage2(
 }
 
 void
-anv_image_copy_to_shadow(struct anv_cmd_buffer *cmd_buffer,
-                         const struct anv_image *image,
-                         VkImageAspectFlagBits aspect,
-                         uint32_t base_level, uint32_t level_count,
-                         uint32_t base_layer, uint32_t layer_count)
-{
-   struct blorp_batch batch;
-   anv_blorp_batch_init(cmd_buffer, &batch, 0);
-
-   /* We don't know who touched the main surface last so flush a bunch of
-    * caches to ensure we get good data.
-    */
-   anv_add_pending_pipe_bits(cmd_buffer,
-                             ANV_PIPE_DEPTH_CACHE_FLUSH_BIT |
-                             ANV_PIPE_HDC_PIPELINE_FLUSH_BIT |
-                             ANV_PIPE_RENDER_TARGET_CACHE_FLUSH_BIT |
-                             ANV_PIPE_TEXTURE_CACHE_INVALIDATE_BIT,
-                             "before copy_to_shadow");
-
-   struct blorp_surf surf;
-   get_blorp_surf_for_anv_image(cmd_buffer->device,
-                                image, aspect,
-                                VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
-                                VK_IMAGE_LAYOUT_GENERAL,
-                                ISL_AUX_USAGE_NONE, &surf);
-   assert(surf.aux_usage == ISL_AUX_USAGE_NONE);
-
-   struct blorp_surf shadow_surf;
-   get_blorp_surf_for_anv_shadow_image(cmd_buffer->device,
-                                       image, aspect, &shadow_surf);
-
-   for (uint32_t l = 0; l < level_count; l++) {
-      const uint32_t level = base_level + l;
-
-      const VkExtent3D extent = vk_image_mip_level_extent(&image->vk, level);
-
-      if (image->vk.image_type == VK_IMAGE_TYPE_3D)
-         layer_count = extent.depth;
-
-      for (uint32_t a = 0; a < layer_count; a++) {
-         const uint32_t layer = base_layer + a;
-
-         blorp_copy(&batch, &surf, level, layer,
-                    &shadow_surf, level, layer,
-                    0, 0, 0, 0, extent.width, extent.height);
-      }
-   }
-
-   /* We just wrote to the buffer with the render cache.  Flush it. */
-   anv_add_pending_pipe_bits(cmd_buffer,
-                             ANV_PIPE_RENDER_TARGET_CACHE_FLUSH_BIT,
-                             "after copy_to_shadow");
-
-   anv_blorp_batch_finish(&batch);
-}
-
-void
 anv_image_clear_color(struct anv_cmd_buffer *cmd_buffer,
                       const struct anv_image *image,
                       VkImageAspectFlagBits aspect,
@@ -1639,23 +1496,6 @@ anv_image_clear_depth_stencil(struct anv_cmd_buffer *cmd_buffer,
                              ANV_PIPE_END_OF_PIPE_SYNC_BIT,
                              "after clear DS");
 
-   struct blorp_surf stencil_shadow;
-   if ((aspects & VK_IMAGE_ASPECT_STENCIL_BIT) &&
-       get_blorp_surf_for_anv_shadow_image(cmd_buffer->device, image,
-                                           VK_IMAGE_ASPECT_STENCIL_BIT,
-                                           &stencil_shadow)) {
-      union isl_color_value stencil_color = {
-         .u32 = { stencil_value },
-      };
-      blorp_clear(&batch, &stencil_shadow,
-                  ISL_FORMAT_R8_UINT, ISL_SWIZZLE_IDENTITY,
-                  level, base_layer, layer_count,
-                  area.offset.x, area.offset.y,
-                  area.offset.x + area.extent.width,
-                  area.offset.y + area.extent.height,
-                  stencil_color, 0 /* color_write_disable */);
-   }
-
    anv_blorp_batch_finish(&batch);
 }