src/freedreno/vulkan/tu_meta_clear.c

   1 /*
   2  * Copyright © 2015 Intel Corporation
   3  *
   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:
  10  *
  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
  13  * Software.
  14  *
  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
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21  * DEALINGS IN THE SOFTWARE.
  22  */
  23
  24 #include "tu_private.h"
  25 #include "tu_blit.h"
  26 #include "tu_cs.h"
  27
  28 static void
  29 clear_image(struct tu_cmd_buffer *cmdbuf,
  30             struct tu_image *image,
  31             uint32_t clear_value[4],
  32             const VkImageSubresourceRange *range)
  33 {
  34    uint32_t level_count = tu_get_levelCount(image, range);
  35    uint32_t layer_count = tu_get_layerCount(image, range);
  36
  37    if (image->type == VK_IMAGE_TYPE_3D) {
  38       assert(layer_count == 1);
  39       assert(range->baseArrayLayer == 0);
  40    }
  41
  42    for (unsigned j = 0; j < level_count; j++) {
  43       if (image->type == VK_IMAGE_TYPE_3D)
  44          layer_count = u_minify(image->extent.depth, range->baseMipLevel + j);
  45
  46       tu_blit(cmdbuf, &(struct tu_blit) {
  47          .dst = tu_blit_surf_whole(image, range->baseMipLevel + j, range->baseArrayLayer),
  48          .layers = layer_count,
  49          .clear_value = {clear_value[0], clear_value[1], clear_value[2], clear_value[3]},
  50          .type = TU_BLIT_CLEAR,
  51       });
  52    }
  53 }
  54
  55 void
  56 tu_CmdClearColorImage(VkCommandBuffer commandBuffer,
  57                       VkImage image_h,
  58                       VkImageLayout imageLayout,
  59                       const VkClearColorValue *pColor,
  60                       uint32_t rangeCount,
  61                       const VkImageSubresourceRange *pRanges)
  62 {
  63    TU_FROM_HANDLE(tu_cmd_buffer, cmdbuf, commandBuffer);
  64    TU_FROM_HANDLE(tu_image, image, image_h);
  65    uint32_t clear_value[4] = {};
  66
  67    tu_2d_clear_color(pColor, image->vk_format, clear_value);
  68
  69    tu_bo_list_add(&cmdbuf->bo_list, image->bo, MSM_SUBMIT_BO_WRITE);
  70
  71    for (unsigned i = 0; i < rangeCount; i++)
  72       clear_image(cmdbuf, image, clear_value, pRanges + i);
  73 }
  74
  75 void
  76 tu_CmdClearDepthStencilImage(VkCommandBuffer commandBuffer,
  77                              VkImage image_h,
  78                              VkImageLayout imageLayout,
  79                              const VkClearDepthStencilValue *pDepthStencil,
  80                              uint32_t rangeCount,
  81                              const VkImageSubresourceRange *pRanges)
  82 {
  83    TU_FROM_HANDLE(tu_cmd_buffer, cmdbuf, commandBuffer);
  84    TU_FROM_HANDLE(tu_image, image, image_h);
  85    uint32_t clear_value[4] = {};
  86
  87    tu_2d_clear_zs(pDepthStencil, image->vk_format, clear_value);
  88
  89    tu_bo_list_add(&cmdbuf->bo_list, image->bo, MSM_SUBMIT_BO_WRITE);
  90
  91    for (unsigned i = 0; i < rangeCount; i++)
  92       clear_image(cmdbuf, image, clear_value, pRanges + i);
  93 }
  94
  95 void
  96 tu_CmdClearAttachments(VkCommandBuffer commandBuffer,
  97                        uint32_t attachmentCount,
  98                        const VkClearAttachment *pAttachments,
  99                        uint32_t rectCount,
 100                        const VkClearRect *pRects)
 101 {
 102    TU_FROM_HANDLE(tu_cmd_buffer, cmd, commandBuffer);
 103    const struct tu_subpass *subpass = cmd->state.subpass;
 104    struct tu_cs *cs = &cmd->draw_cs;
 105
 106    VkResult result = tu_cs_reserve_space(cmd->device, cs,
 107                                          rectCount * (3 + 15 * attachmentCount));
 108    if (result != VK_SUCCESS) {
 109       cmd->record_result = result;
 110       return;
 111    }
 112
 113    /* TODO: deal with layered rendering (when layered rendering is implemented)
 114     * TODO: disable bypass rendering for subpass (when bypass is implemented)
 115     */
 116
 117    for (unsigned i = 0; i < rectCount; i++) {
 118       unsigned x1 = pRects[i].rect.offset.x;
 119       unsigned y1 = pRects[i].rect.offset.y;
 120       unsigned x2 = x1 + pRects[i].rect.extent.width - 1;
 121       unsigned y2 = y1 + pRects[i].rect.extent.height - 1;
 122
 123       tu_cs_emit_pkt4(cs, REG_A6XX_RB_BLIT_SCISSOR_TL, 2);
 124       tu_cs_emit(cs, A6XX_RB_BLIT_SCISSOR_TL_X(x1) | A6XX_RB_BLIT_SCISSOR_TL_Y(y1));
 125       tu_cs_emit(cs, A6XX_RB_BLIT_SCISSOR_BR_X(x2) | A6XX_RB_BLIT_SCISSOR_BR_Y(y2));
 126
 127       for (unsigned j = 0; j < attachmentCount; j++) {
 128          uint32_t a;
 129          unsigned clear_mask = 0;
 130          if (pAttachments[j].aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) {
 131             clear_mask = 0xf;
 132             a = subpass->color_attachments[pAttachments[j].colorAttachment].attachment;
 133          } else {
 134             a = subpass->depth_stencil_attachment.attachment;
 135             if (pAttachments[j].aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT)
 136                clear_mask |= 1;
 137             if (pAttachments[j].aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT)
 138                clear_mask |= 2;
 139          }
 140
 141          if (a == VK_ATTACHMENT_UNUSED)
 142                continue;
 143
 144          VkFormat fmt = cmd->state.pass->attachments[a].format;
 145          const struct tu_native_format *format = tu6_get_native_format(fmt);
 146          assert(format && format->rb >= 0);
 147
 148          tu_cs_emit_pkt4(cs, REG_A6XX_RB_BLIT_DST_INFO, 1);
 149          tu_cs_emit(cs, A6XX_RB_BLIT_DST_INFO_COLOR_FORMAT(format->rb));
 150
 151          tu_cs_emit_pkt4(cs, REG_A6XX_RB_BLIT_INFO, 1);
 152          tu_cs_emit(cs, A6XX_RB_BLIT_INFO_GMEM | A6XX_RB_BLIT_INFO_CLEAR_MASK(clear_mask));
 153
 154          tu_cs_emit_pkt4(cs, REG_A6XX_RB_BLIT_BASE_GMEM, 1);
 155          tu_cs_emit(cs, cmd->state.tiling_config.gmem_offsets[a]);
 156
 157          tu_cs_emit_pkt4(cs, REG_A6XX_RB_UNKNOWN_88D0, 1);
 158          tu_cs_emit(cs, 0);
 159
 160          uint32_t clear_vals[4] = { 0 };
 161          tu_pack_clear_value(&pAttachments[j].clearValue, fmt, clear_vals);
 162
 163          tu_cs_emit_pkt4(cs, REG_A6XX_RB_BLIT_CLEAR_COLOR_DW0, 4);
 164          tu_cs_emit(cs, clear_vals[0]);
 165          tu_cs_emit(cs, clear_vals[1]);
 166          tu_cs_emit(cs, clear_vals[2]);
 167          tu_cs_emit(cs, clear_vals[3]);
 168
 169          tu6_emit_event_write(cmd, cs, BLIT, false);
 170       }
 171    }
 172 }