1 /*
2 * Copyright © 2021 Collabora Ltd.
3 *
4 * Derived from tu_image.c which is:
5 * Copyright © 2016 Red Hat.
6 * Copyright © 2016 Bas Nieuwenhuizen
7 * Copyright © 2015 Intel Corporation
8 *
9 * Permission is hereby granted, free of charge, to any person obtaining a
10 * copy of this software and associated documentation files (the "Software"),
11 * to deal in the Software without restriction, including without limitation
12 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
13 * and/or sell copies of the Software, and to permit persons to whom the
14 * Software is furnished to do so, subject to the following conditions:
15 *
16 * The above copyright notice and this permission notice (including the next
17 * paragraph) shall be included in all copies or substantial portions of the
18 * Software.
19 *
20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
23 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
24 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
25 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
26 * DEALINGS IN THE SOFTWARE.
27 */
28
29 #include "genxml/gen_macros.h"
30 #include "panvk_private.h"
31
32 #include "drm-uapi/drm_fourcc.h"
33 #include "util/u_atomic.h"
34 #include "util/u_debug.h"
35 #include "vk_format.h"
36 #include "vk_object.h"
37 #include "vk_util.h"
38
39 static enum mali_texture_dimension
panvk_view_type_to_mali_tex_dim(VkImageViewType type)40 panvk_view_type_to_mali_tex_dim(VkImageViewType type)
41 {
42 switch (type) {
43 case VK_IMAGE_VIEW_TYPE_1D:
44 case VK_IMAGE_VIEW_TYPE_1D_ARRAY:
45 return MALI_TEXTURE_DIMENSION_1D;
46 case VK_IMAGE_VIEW_TYPE_2D:
47 case VK_IMAGE_VIEW_TYPE_2D_ARRAY:
48 return MALI_TEXTURE_DIMENSION_2D;
49 case VK_IMAGE_VIEW_TYPE_3D:
50 return MALI_TEXTURE_DIMENSION_3D;
51 case VK_IMAGE_VIEW_TYPE_CUBE:
52 case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY:
53 return MALI_TEXTURE_DIMENSION_CUBE;
54 default:
55 unreachable("Invalid view type");
56 }
57 }
58
59 static void
panvk_convert_swizzle(const VkComponentMapping * in,unsigned char * out)60 panvk_convert_swizzle(const VkComponentMapping *in, unsigned char *out)
61 {
62 const VkComponentSwizzle *comp = &in->r;
63 for (unsigned i = 0; i < 4; i++) {
64 switch (comp[i]) {
65 case VK_COMPONENT_SWIZZLE_ZERO:
66 out[i] = PIPE_SWIZZLE_0;
67 break;
68 case VK_COMPONENT_SWIZZLE_ONE:
69 out[i] = PIPE_SWIZZLE_1;
70 break;
71 case VK_COMPONENT_SWIZZLE_R:
72 out[i] = PIPE_SWIZZLE_X;
73 break;
74 case VK_COMPONENT_SWIZZLE_G:
75 out[i] = PIPE_SWIZZLE_Y;
76 break;
77 case VK_COMPONENT_SWIZZLE_B:
78 out[i] = PIPE_SWIZZLE_Z;
79 break;
80 case VK_COMPONENT_SWIZZLE_A:
81 out[i] = PIPE_SWIZZLE_W;
82 break;
83 default:
84 unreachable("Invalid swizzle");
85 }
86 }
87 }
88
89 VkResult
panvk_per_arch(CreateImageView)90 panvk_per_arch(CreateImageView)(VkDevice _device,
91 const VkImageViewCreateInfo *pCreateInfo,
92 const VkAllocationCallbacks *pAllocator,
93 VkImageView *pView)
94 {
95 VK_FROM_HANDLE(panvk_device, device, _device);
96 VK_FROM_HANDLE(panvk_image, image, pCreateInfo->image);
97 struct panvk_image_view *view;
98
99 view = vk_image_view_create(&device->vk, false, pCreateInfo, pAllocator,
100 sizeof(*view));
101 if (view == NULL)
102 return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
103
104 view->pview = (struct pan_image_view){
105 .planes[0] = &image->pimage,
106 .format = vk_format_to_pipe_format(view->vk.view_format),
107 .dim = panvk_view_type_to_mali_tex_dim(view->vk.view_type),
108 .nr_samples = image->pimage.layout.nr_samples,
109 .first_level = view->vk.base_mip_level,
110 .last_level = view->vk.base_mip_level + view->vk.level_count - 1,
111 .first_layer = view->vk.base_array_layer,
112 .last_layer = view->vk.base_array_layer + view->vk.layer_count - 1,
113 };
114 panvk_convert_swizzle(&view->vk.swizzle, view->pview.swizzle);
115
116 if (view->vk.usage &
117 (VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT)) {
118 unsigned bo_size =
119 GENX(panfrost_estimate_texture_payload_size)(&view->pview) +
120 pan_size(TEXTURE);
121
122 view->bo = panvk_priv_bo_create(device, bo_size, 0, pAllocator,
123 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
124
125 STATIC_ASSERT(sizeof(view->descs.tex) >= pan_size(TEXTURE));
126
127 struct panfrost_ptr ptr = {
128 .gpu = view->bo->addr.dev,
129 .cpu = view->bo->addr.host,
130 };
131
132 GENX(panfrost_new_texture)(&view->pview, &view->descs.tex, &ptr);
133 }
134
135 if (view->vk.usage & VK_IMAGE_USAGE_STORAGE_BIT) {
136 uint8_t *attrib_buf = (uint8_t *)view->descs.img_attrib_buf;
137 bool is_3d = image->pimage.layout.dim == MALI_TEXTURE_DIMENSION_3D;
138 unsigned offset = image->pimage.data.offset;
139 offset +=
140 panfrost_texture_offset(&image->pimage.layout, view->pview.first_level,
141 is_3d ? 0 : view->pview.first_layer,
142 is_3d ? view->pview.first_layer : 0);
143
144 pan_pack(attrib_buf, ATTRIBUTE_BUFFER, cfg) {
145 cfg.type = image->pimage.layout.modifier == DRM_FORMAT_MOD_LINEAR
146 ? MALI_ATTRIBUTE_TYPE_3D_LINEAR
147 : MALI_ATTRIBUTE_TYPE_3D_INTERLEAVED;
148 cfg.pointer = image->pimage.data.base + offset;
149 cfg.stride = util_format_get_blocksize(view->pview.format);
150 cfg.size = pan_kmod_bo_size(image->bo) - offset;
151 }
152
153 attrib_buf += pan_size(ATTRIBUTE_BUFFER);
154 pan_pack(attrib_buf, ATTRIBUTE_BUFFER_CONTINUATION_3D, cfg) {
155 unsigned level = view->pview.first_level;
156
157 cfg.s_dimension = u_minify(image->pimage.layout.width, level);
158 cfg.t_dimension = u_minify(image->pimage.layout.height, level);
159 cfg.r_dimension =
160 view->pview.dim == MALI_TEXTURE_DIMENSION_3D
161 ? u_minify(image->pimage.layout.depth, level)
162 : (view->pview.last_layer - view->pview.first_layer + 1);
163 cfg.row_stride = image->pimage.layout.slices[level].row_stride;
164 if (cfg.r_dimension > 1) {
165 cfg.slice_stride =
166 panfrost_get_layer_stride(&image->pimage.layout, level);
167 }
168 }
169 }
170
171 *pView = panvk_image_view_to_handle(view);
172 return VK_SUCCESS;
173 }
174
175 VkResult
panvk_per_arch(CreateBufferView)176 panvk_per_arch(CreateBufferView)(VkDevice _device,
177 const VkBufferViewCreateInfo *pCreateInfo,
178 const VkAllocationCallbacks *pAllocator,
179 VkBufferView *pView)
180 {
181 VK_FROM_HANDLE(panvk_device, device, _device);
182 VK_FROM_HANDLE(panvk_buffer, buffer, pCreateInfo->buffer);
183
184 struct panvk_buffer_view *view = vk_object_zalloc(
185 &device->vk, pAllocator, sizeof(*view), VK_OBJECT_TYPE_BUFFER_VIEW);
186
187 if (!view)
188 return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
189
190 view->fmt = vk_format_to_pipe_format(pCreateInfo->format);
191
192 mali_ptr address = panvk_buffer_gpu_ptr(buffer, pCreateInfo->offset);
193 unsigned size =
194 panvk_buffer_range(buffer, pCreateInfo->offset, pCreateInfo->range);
195 unsigned blksz = util_format_get_blocksize(view->fmt);
196 view->elems = size / blksz;
197
198 assert(!(address & 63));
199
200 if (buffer->vk.usage & VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT) {
201 unsigned bo_size = pan_size(SURFACE_WITH_STRIDE);
202 view->bo = panvk_priv_bo_create(device, bo_size, 0, pAllocator,
203 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
204
205 pan_pack(view->bo->addr.host, SURFACE_WITH_STRIDE, cfg) {
206 cfg.pointer = address;
207 }
208
209 pan_pack(view->descs.tex, TEXTURE, cfg) {
210 cfg.dimension = MALI_TEXTURE_DIMENSION_1D;
211 cfg.format = GENX(panfrost_format_from_pipe_format)(view->fmt)->hw;
212 cfg.width = view->elems;
213 cfg.depth = cfg.height = 1;
214 cfg.swizzle = PAN_V6_SWIZZLE(R, G, B, A);
215 cfg.texel_ordering = MALI_TEXTURE_LAYOUT_LINEAR;
216 cfg.levels = 1;
217 cfg.array_size = 1;
218 cfg.surfaces = view->bo->addr.dev;
219 cfg.maximum_lod = cfg.minimum_lod = 0;
220 }
221 }
222
223 if (buffer->vk.usage & VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT) {
224 uint8_t *attrib_buf = (uint8_t *)view->descs.img_attrib_buf;
225
226 pan_pack(attrib_buf, ATTRIBUTE_BUFFER, cfg) {
227 cfg.type = MALI_ATTRIBUTE_TYPE_3D_LINEAR;
228 cfg.pointer = address;
229 cfg.stride = blksz;
230 cfg.size = view->elems * blksz;
231 }
232
233 attrib_buf += pan_size(ATTRIBUTE_BUFFER);
234 pan_pack(attrib_buf, ATTRIBUTE_BUFFER_CONTINUATION_3D, cfg) {
235 cfg.s_dimension = view->elems;
236 cfg.t_dimension = 1;
237 cfg.r_dimension = 1;
238 cfg.row_stride = view->elems * blksz;
239 }
240 }
241
242 *pView = panvk_buffer_view_to_handle(view);
243 return VK_SUCCESS;
244 }
245