Debian Codegraph @

src/imagination/vulkan/pvr_formats.c

raw
1 /*
2 * Copyright © 2022 Imagination Technologies Ltd.
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a copy
5 * of this software and associated documentation files (the "Software"), to deal
6 * in the Software without restriction, including without limitation the rights
7 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8 * copies of the Software, and to permit persons to whom the Software is
9 * 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 THE
18 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 * SOFTWARE.
22 */
23
24 #include <assert.h>
25 #include <stdbool.h>
26 #include <stddef.h>
27 #include <stdint.h>
28 #include <vulkan/vulkan.h>
29
30 #include "drm-uapi/drm_fourcc.h"
31 #include "hwdef/rogue_hw_utils.h"
32
33 #include "pvr_common.h"
34 #include "pvr_csb.h"
35 #include "pvr_device.h"
36 #include "pvr_entrypoints.h"
37 #include "pvr_limits.h"
38 #include "pvr_formats.h"
39 #include "pvr_macros.h"
40 #include "pvr_physical_device.h"
41
42 #include "util/bitpack_helpers.h"
43 #include "util/bitscan.h"
44 #include "util/compiler.h"
45 #include "util/format/format_utils.h"
46 #include "util/format/u_formats.h"
47 #include "util/half_float.h"
48 #include "util/log.h"
49 #include "util/macros.h"
50 #include "util/u_math.h"
51 #include "vk_enum_defines.h"
52 #include "vk_enum_to_str.h"
53 #include "vk_format.h"
54 #include "vk_log.h"
55 #include "vk_util.h"
56
57 uint32_t pvr_get_pbe_accum_format_size_in_bytes(VkFormat vk_format)
58 {
59 enum pvr_pbe_accum_format pbe_accum_format;
60 uint32_t nr_components;
61
62 /* TODO: Decouple from arch-specific function */
63 pbe_accum_format = pvr_rogue_get_pbe_accum_format(vk_format);
64 nr_components = vk_format_get_nr_components(vk_format);
65
66 switch (pbe_accum_format) {
67 case PVR_PBE_ACCUM_FORMAT_U8:
68 case PVR_PBE_ACCUM_FORMAT_S8:
69 case PVR_PBE_ACCUM_FORMAT_UINT8:
70 case PVR_PBE_ACCUM_FORMAT_SINT8:
71 return nr_components * 1;
72
73 case PVR_PBE_ACCUM_FORMAT_U16:
74 case PVR_PBE_ACCUM_FORMAT_S16:
75 case PVR_PBE_ACCUM_FORMAT_F16:
76 case PVR_PBE_ACCUM_FORMAT_UINT16:
77 case PVR_PBE_ACCUM_FORMAT_SINT16:
78 return nr_components * 2;
79
80 case PVR_PBE_ACCUM_FORMAT_F32:
81 case PVR_PBE_ACCUM_FORMAT_UINT32:
82 case PVR_PBE_ACCUM_FORMAT_SINT32:
83 case PVR_PBE_ACCUM_FORMAT_UINT32_MEDP:
84 case PVR_PBE_ACCUM_FORMAT_SINT32_MEDP:
85 case PVR_PBE_ACCUM_FORMAT_U24:
86 return nr_components * 4;
87
88 case PVR_PBE_ACCUM_FORMAT_U1010102:
89 assert(nr_components == 4);
90 return 4;
91
92 default:
93 UNREACHABLE("Unknown pbe accum format. Implementation error");
94 }
95 }
96
97 /**
98 * \brief Packs VK_FORMAT_A2B10G10R10_UINT_PACK32 or A2R10G10B10.
99 *
100 * \param[in] values RGBA ordered values to pack.
101 * \param[in] swap_rb If true pack A2B10G10R10 else pack A2R10G10B10.
102 */
103 static inline uint32_t pvr_pack_a2x10y10z10_uint(
104 const uint32_t values[static const PVR_CLEAR_COLOR_ARRAY_SIZE],
105 bool swap_rb)
106 {
107 const uint32_t blue = swap_rb ? values[0] : values[2];
108 const uint32_t red = swap_rb ? values[2] : values[0];
109 uint32_t packed_val;
110
111 /* The user is allowed to specify a value which is over the range
112 * representable for a component so we need to AND before packing.
113 */
114
115 packed_val = util_bitpack_uint(values[3] & BITSET_MASK(2), 30, 31);
116 packed_val |= util_bitpack_uint(red & BITSET_MASK(10), 20, 29);
117 packed_val |= util_bitpack_uint(values[1] & BITSET_MASK(10), 10, 19);
118 packed_val |= util_bitpack_uint(blue & BITSET_MASK(10), 0, 9);
119
120 return packed_val;
121 }
122
123 #define APPLY_FUNC_4V(DST, FUNC, ARG) \
124 ASSIGN_4V(DST, FUNC(ARG[0]), FUNC(ARG[1]), FUNC(ARG[2]), FUNC(ARG[3]))
125
126 #define f32_to_unorm8(val) _mesa_float_to_unorm(val, 8)
127 #define f32_to_unorm16(val) _mesa_float_to_unorm(val, 16)
128 #define f32_to_snorm8(val) _mesa_float_to_snorm(val, 8)
129 #define f32_to_snorm16(val) _mesa_float_to_snorm(val, 16)
130 #define f32_to_f16(val) _mesa_float_to_half(val)
131
132 /**
133 * \brief Packs clear color input values into the appropriate accum format.
134 *
135 * The input value array must have zeroed out elements for components not
136 * present in the format. E.g. R8G8B8 has no A component so [3] must be 0.
137 *
138 * Note: the output is not swizzled so it's packed in RGBA order no matter the
139 * component order specified by the vk_format.
140 *
141 * \param[in] vk_format Vulkan format of the input color value.
142 * \param[in] value Unpacked RGBA input color values.
143 * \param[out] packed_out Accum format packed values.
144 */
145 void pvr_get_hw_clear_color(
146 VkFormat vk_format,
147 VkClearColorValue value,
148 uint32_t packed_out[static const PVR_CLEAR_COLOR_ARRAY_SIZE])
149 {
150 union {
151 uint32_t u32[PVR_CLEAR_COLOR_ARRAY_SIZE];
152 int32_t i32[PVR_CLEAR_COLOR_ARRAY_SIZE];
153 uint16_t u16[PVR_CLEAR_COLOR_ARRAY_SIZE * 2];
154 int16_t i16[PVR_CLEAR_COLOR_ARRAY_SIZE * 2];
155 uint8_t u8[PVR_CLEAR_COLOR_ARRAY_SIZE * 4];
156 int8_t i8[PVR_CLEAR_COLOR_ARRAY_SIZE * 4];
157 } packed_val = { 0 };
158
159 /* TODO: Decouple from arch-specific function */
160 const enum pvr_pbe_accum_format pbe_accum_format =
161 pvr_rogue_get_pbe_accum_format(vk_format);
162
163 static_assert(ARRAY_SIZE(value.uint32) == PVR_CLEAR_COLOR_ARRAY_SIZE,
164 "Size mismatch. Unknown/unhandled extra values.");
165
166 /* TODO: Right now we pack all RGBA values. Would we get any benefit in
167 * packing just the components required by the format?
168 */
169
170 switch (pbe_accum_format) {
171 case PVR_PBE_ACCUM_FORMAT_U8:
172 APPLY_FUNC_4V(packed_val.u8, f32_to_unorm8, value.float32);
173 break;
174 case PVR_PBE_ACCUM_FORMAT_S8:
175 APPLY_FUNC_4V(packed_val.i8, f32_to_snorm8, value.float32);
176 break;
177 case PVR_PBE_ACCUM_FORMAT_UINT8:
178 COPY_4V(packed_val.u8, value.uint32);
179 break;
180 case PVR_PBE_ACCUM_FORMAT_SINT8:
181 COPY_4V(packed_val.i8, value.int32);
182 break;
183
184 case PVR_PBE_ACCUM_FORMAT_U16:
185 APPLY_FUNC_4V(packed_val.u16, f32_to_unorm16, value.float32);
186 break;
187 case PVR_PBE_ACCUM_FORMAT_S16:
188 APPLY_FUNC_4V(packed_val.i16, f32_to_snorm16, value.float32);
189 break;
190 case PVR_PBE_ACCUM_FORMAT_F16:
191 APPLY_FUNC_4V(packed_val.u16, f32_to_f16, value.float32);
192 break;
193 case PVR_PBE_ACCUM_FORMAT_UINT16:
194 COPY_4V(packed_val.u16, value.uint32);
195 break;
196 case PVR_PBE_ACCUM_FORMAT_SINT16:
197 COPY_4V(packed_val.i16, value.int32);
198 break;
199
200 case PVR_PBE_ACCUM_FORMAT_U1010102:
201 /* The PBE can't handle swizzled 1010102 UINT. */
202 packed_val.u32[0] = pvr_pack_a2x10y10z10_uint(
203 value.uint32,
204 vk_format == VK_FORMAT_A2B10G10R10_UINT_PACK32);
205 break;
206
207 case PVR_PBE_ACCUM_FORMAT_F32:
208 COPY_4V(packed_val.u32, value.uint32);
209 break;
210 case PVR_PBE_ACCUM_FORMAT_UINT32:
211 COPY_4V(packed_val.u32, value.uint32);
212 break;
213 case PVR_PBE_ACCUM_FORMAT_SINT32:
214 COPY_4V(packed_val.i32, value.int32);
215 break;
216
217 default:
218 UNREACHABLE("Packing not supported for the accum format.");
219 break;
220 }
221
222 COPY_4V(packed_out, packed_val.u32);
223 }
224
225 #undef APPLY_FUNC_4V
226 #undef f32_to_unorm8
227 #undef f32_to_unorm16
228 #undef f32_to_snorm8
229 #undef f32_to_snorm16
230 #undef f32_to_f16
231
232 static inline const struct pvr_format *
233 pvr_get_format(struct pvr_physical_device *pdevice, VkFormat vk_format)
234 {
235 enum pipe_format format = vk_format_to_pipe_format(vk_format);
236 if (format < pdevice->formats.count &&
237 pdevice->formats.formats[format].bind != 0) {
238 return &pdevice->formats.formats[format];
239 }
240
241 mesa_logd("Format %s(%d) not supported\n",
242 vk_Format_to_str(vk_format),
243 vk_format);
244
245 return NULL;
246 }
247
248 static VkFormatFeatureFlags2
249 pvr_get_image_format_features2(struct pvr_physical_device *pdevice,
250 VkFormat vk_format,
251 VkImageTiling vk_tiling)
252 {
253 VkFormatFeatureFlags2 flags = 0;
254
255 const struct pvr_format *pvr_format = pvr_get_format(pdevice, vk_format);
256 if (!pvr_format)
257 return 0;
258
259 assert(pvr_format->bind != 0);
260
261 const struct vk_format_ycbcr_info *ycbcr_info =
262 vk_format_get_ycbcr_info(vk_format);
263
264 if (pvr_format->bind & PVR_BIND_SAMPLER_VIEW) {
265 if (vk_tiling == VK_IMAGE_TILING_OPTIMAL) {
266 const uint32_t first_component_size =
267 vk_format_get_component_bits(vk_format,
268 UTIL_FORMAT_COLORSPACE_RGB,
269 0);
270
271 flags |= VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT |
272 VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT |
273 VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT;
274
275 if (!vk_format_is_int(vk_format) &&
276 !vk_format_is_depth_or_stencil(vk_format) &&
277 (first_component_size < 32 ||
278 vk_format_is_block_compressed(vk_format))) {
279 flags |= VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT;
280 }
281
282 if (ycbcr_info) {
283 flags |= VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT;
284 } else {
285 flags |= VK_FORMAT_FEATURE_2_BLIT_SRC_BIT;
286 }
287 } else if (!vk_format_is_block_compressed(vk_format)) {
288 flags |= VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT |
289 VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT |
290 VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT;
291
292 if (ycbcr_info) {
293 flags |= VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT;
294 } else {
295 flags |= VK_FORMAT_FEATURE_2_BLIT_SRC_BIT;
296 }
297 }
298 }
299
300 if (pvr_format->bind & PVR_BIND_RENDER_TARGET) {
301 flags |= VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT |
302 VK_FORMAT_FEATURE_2_BLIT_DST_BIT;
303
304 if (!vk_format_is_int(vk_format)) {
305 flags |= VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT;
306 }
307 }
308
309 if (pvr_format->bind & PVR_BIND_DEPTH_STENCIL) {
310 flags |= VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT |
311 VK_FORMAT_FEATURE_2_BLIT_DST_BIT |
312 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT;
313 }
314
315 if (vk_tiling == VK_IMAGE_TILING_OPTIMAL) {
316 if (vk_format_is_color(vk_format) &&
317 vk_format_get_nr_components(vk_format) == 1 &&
318 vk_format_get_blocksizebits(vk_format) == 32 &&
319 vk_format_is_int(vk_format)) {
320 flags |= VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT |
321 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT;
322 }
323
324 if (vk_format_has_stencil(vk_format))
325 flags |= VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT;
326
327 if (pvr_format->bind & PVR_BIND_STORAGE_IMAGE)
328 flags |= VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT;
329 }
330
331 if (flags & VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT) {
332 flags |= VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT |
333 VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT;
334 }
335
336 return flags;
337 }
338
339 const uint8_t *pvr_get_format_swizzle(VkFormat vk_format)
340 {
341 const struct util_format_description *vf = vk_format_description(vk_format);
342
343 return vf->swizzle;
344 }
345
346 /* For DS formats, hardware can only access either depth or stencil at once.
347 * It expects to find whichever one it requires in the given context in the
348 * first channel, whereas pipe formats swizzle depth into the first channel and
349 * stencil into the second.
350 */
351 const uint8_t *
352 pvr_get_format_swizzle_for_tpu(const struct util_format_description *desc)
353 {
354 const bool has_stencil = util_format_has_stencil(desc);
355 const bool has_depth = util_format_has_depth(desc);
356
357 if (has_depth || has_stencil) {
358 static const uint8_t pvr_swizzle[4] = {
359 PIPE_SWIZZLE_X,
360 PIPE_SWIZZLE_NONE,
361 PIPE_SWIZZLE_NONE,
362 PIPE_SWIZZLE_NONE,
363 };
364
365 return pvr_swizzle;
366 }
367
368 return desc->swizzle;
369 }
370
371 static VkFormatFeatureFlags2
372 pvr_get_buffer_format_features2(struct pvr_physical_device *pdevice,
373 VkFormat vk_format)
374 {
375 const struct util_format_description *desc;
376 VkFormatFeatureFlags2 flags = 0;
377
378 const struct pvr_format *pvr_format = pvr_get_format(pdevice, vk_format);
379 if (!pvr_format)
380 return 0;
381
382 assert(pvr_format->bind != 0);
383
384 if (!vk_format_is_color(vk_format))
385 return 0;
386
387 desc = vk_format_description(vk_format);
388
389 if (pvr_format->bind & PVR_BIND_VERTEX_BUFFER)
390 flags |= VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT;
391
392 if (vk_format_is_scaled(vk_format))
393 return flags;
394
395 flags |= VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT |
396 VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT;
397
398 if (desc->layout == UTIL_FORMAT_LAYOUT_PLAIN &&
399 desc->colorspace == UTIL_FORMAT_COLORSPACE_RGB) {
400 if (desc->is_array && vk_format != VK_FORMAT_R32G32B32_UINT &&
401 vk_format != VK_FORMAT_R32G32B32_SINT &&
402 vk_format != VK_FORMAT_R32G32B32_SFLOAT) {
403 flags |= VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT;
404 } else if (vk_format == VK_FORMAT_A2B10G10R10_UNORM_PACK32 ||
405 vk_format == VK_FORMAT_A2B10G10R10_UINT_PACK32) {
406 flags |= VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT;
407 }
408 }
409
410 if (vk_format_is_color(vk_format) &&
411 vk_format_get_nr_components(vk_format) == 1 &&
412 vk_format_get_blocksizebits(vk_format) == 32 &&
413 vk_format_is_int(vk_format)) {
414 flags |= VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT |
415 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT;
416 }
417
418 switch (vk_format) {
419 case VK_FORMAT_R8G8B8A8_UNORM:
420 case VK_FORMAT_R8G8B8A8_SNORM:
421 case VK_FORMAT_R8G8B8A8_UINT:
422 case VK_FORMAT_R8G8B8A8_SINT:
423 case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
424 case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
425 case VK_FORMAT_A8B8G8R8_UINT_PACK32:
426 case VK_FORMAT_A8B8G8R8_SINT_PACK32:
427 case VK_FORMAT_R16G16B16A16_UINT:
428 case VK_FORMAT_R16G16B16A16_SINT:
429 case VK_FORMAT_R16G16B16A16_SFLOAT:
430 case VK_FORMAT_R32_SFLOAT:
431 case VK_FORMAT_R32G32_UINT:
432 case VK_FORMAT_R32G32_SINT:
433 case VK_FORMAT_R32G32_SFLOAT:
434 case VK_FORMAT_R32G32B32A32_UINT:
435 case VK_FORMAT_R32G32B32A32_SINT:
436 case VK_FORMAT_R32G32B32A32_SFLOAT:
437 flags |= VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT;
438 break;
439
440 case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
441 flags |= VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT;
442 break;
443
444 default:
445 break;
446 }
447
448 if (flags & VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT) {
449 flags |= VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT |
450 VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT;
451 }
452
453 return flags;
454 }
455
456 static void pvr_get_drm_format_modifier_properties_list(
457 struct pvr_physical_device *pdevice,
458 VkFormat vk_format,
459 VkBaseOutStructure *ext)
460 {
461 assert(ext->sType == VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT ||
462 ext->sType == VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT);
463
464 /* The two top-level data structures are the same. It's only when
465 * you get to walking the actual list of modifier properties that
466 * they differ.
467 */
468 VkDrmFormatModifierPropertiesListEXT *p = (void *)ext;
469 const VkFormatFeatureFlags2 linear_features =
470 pvr_get_image_format_features2(pdevice, vk_format, VK_IMAGE_TILING_LINEAR);
471
472 /* We support LINEAR only yet */
473 if (!linear_features) {
474 p->drmFormatModifierCount = 0;
475 return;
476 }
477
478 switch (ext->sType) {
479 case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: {
480 VK_OUTARRAY_MAKE_TYPED(VkDrmFormatModifierPropertiesEXT, out,
481 p->pDrmFormatModifierProperties,
482 &p->drmFormatModifierCount);
483
484 vk_outarray_append_typed(VkDrmFormatModifierPropertiesEXT, &out, mp) {
485 mp->drmFormatModifier = DRM_FORMAT_MOD_LINEAR;
486 mp->drmFormatModifierPlaneCount = 1;
487 mp->drmFormatModifierTilingFeatures =
488 vk_format_features2_to_features(linear_features);
489 }
490 break;
491 }
492
493 case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: {
494 VkDrmFormatModifierPropertiesList2EXT *p2 = (void *)p;
495 VK_OUTARRAY_MAKE_TYPED(VkDrmFormatModifierProperties2EXT, out,
496 p2->pDrmFormatModifierProperties,
497 &p2->drmFormatModifierCount);
498
499 vk_outarray_append_typed(VkDrmFormatModifierProperties2EXT, &out, mp) {
500 mp->drmFormatModifier = DRM_FORMAT_MOD_LINEAR;
501 mp->drmFormatModifierPlaneCount = 1;
502 mp->drmFormatModifierTilingFeatures = linear_features;
503 }
504 break;
505 }
506
507 default:
508 UNREACHABLE("Invalid structure type for modifier properties");
509 }
510 }
511
512 void pvr_GetPhysicalDeviceFormatProperties2(
513 VkPhysicalDevice physicalDevice,
514 VkFormat format,
515 VkFormatProperties2 *pFormatProperties)
516 {
517 VK_FROM_HANDLE(pvr_physical_device, pdevice, physicalDevice);
518 VkFormatFeatureFlags2 linear2, optimal2, buffer2;
519
520 linear2 =
521 pvr_get_image_format_features2(pdevice, format, VK_IMAGE_TILING_LINEAR);
522 optimal2 =
523 pvr_get_image_format_features2(pdevice, format, VK_IMAGE_TILING_OPTIMAL);
524 buffer2 = pvr_get_buffer_format_features2(pdevice, format);
525
526 pFormatProperties->formatProperties = (VkFormatProperties){
527 .linearTilingFeatures = vk_format_features2_to_features(linear2),
528 .optimalTilingFeatures = vk_format_features2_to_features(optimal2),
529 .bufferFeatures = vk_format_features2_to_features(buffer2),
530 };
531
532 vk_foreach_struct (ext, pFormatProperties->pNext) {
533 switch (ext->sType) {
534 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3: {
535 VkFormatProperties3 *pFormatProperties3 = (VkFormatProperties3 *)ext;
536 pFormatProperties3->linearTilingFeatures = linear2;
537 pFormatProperties3->optimalTilingFeatures = optimal2;
538 pFormatProperties3->bufferFeatures = buffer2;
539 break;
540 }
541 case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
542 case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT:
543 pvr_get_drm_format_modifier_properties_list(pdevice, format, ext);
544 break;
545 default:
546 vk_debug_ignored_stype(ext->sType);
547 break;
548 }
549 }
550 }
551
552 static VkFormatFeatureFlags2
553 vk_image_usage_to_format_features(VkImageUsageFlagBits usage_flag)
554 {
555 assert(util_bitcount(usage_flag) == 1);
556 switch (usage_flag) {
557 case VK_IMAGE_USAGE_TRANSFER_SRC_BIT:
558 return VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT |
559 VK_FORMAT_FEATURE_BLIT_SRC_BIT;
560 case VK_IMAGE_USAGE_TRANSFER_DST_BIT:
561 return VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT |
562 VK_FORMAT_FEATURE_BLIT_DST_BIT;
563 case VK_IMAGE_USAGE_SAMPLED_BIT:
564 return VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT;
565 case VK_IMAGE_USAGE_STORAGE_BIT:
566 return VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT;
567 case VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
568 return VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT;
569 case VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT:
570 return VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT;
571 case VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT:
572 return VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT |
573 VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT;
574 default:
575 return 0;
576 }
577 }
578
579 static VkResult
580 pvr_get_image_format_properties(struct pvr_physical_device *pdevice,
581 const VkPhysicalDeviceImageFormatInfo2 *info,
582 VkImageFormatProperties *pImageFormatProperties)
583 {
584 /* Input attachments aren't rendered but they must have the same size
585 * restrictions as any framebuffer attachment.
586 */
587 const VkImageStencilUsageCreateInfo *stencil_usage_info =
588 vk_find_struct_const(info->pNext, IMAGE_STENCIL_USAGE_CREATE_INFO);
589 const VkImageUsageFlags render_usage =
590 VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_STORAGE_BIT |
591 VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT |
592 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
593 VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
594 const struct pvr_format *pvr_format = pvr_get_format(pdevice, info->format);
595 VkFormatFeatureFlags2 tiling_features2;
596 VkImageUsageFlags usage =
597 info->usage | (stencil_usage_info ? stencil_usage_info->stencilUsage : 0);
598 VkImageTiling tiling = info->tiling;
599 VkResult result;
600
601 if (!pvr_format) {
602 result = vk_error(pdevice, VK_ERROR_FORMAT_NOT_SUPPORTED);
603 goto err_unsupported_format;
604 }
605
606 if (info->flags & VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT) {
607 result = vk_error(pdevice, VK_ERROR_FORMAT_NOT_SUPPORTED);
608 goto err_unsupported_format;
609 }
610
611 if (tiling == VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT) {
612 const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *drm_format_mod_info =
613 vk_find_struct_const(info->pNext,
614 PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT);
615
616 if (drm_format_mod_info &&
617 drm_format_mod_info->drmFormatModifier == DRM_FORMAT_MOD_LINEAR) {
618 tiling = VK_IMAGE_TILING_LINEAR;
619 } else {
620 result = vk_error(pdevice, VK_ERROR_FORMAT_NOT_SUPPORTED);
621 goto err_unsupported_format;
622 }
623 }
624
625 tiling_features2 =
626 pvr_get_image_format_features2(pdevice, info->format, tiling);
627 if (tiling_features2 == 0) {
628 result = vk_error(pdevice, VK_ERROR_FORMAT_NOT_SUPPORTED);
629 goto err_unsupported_format;
630 }
631
632 /* If VK_IMAGE_CREATE_EXTENDED_USAGE_BIT is set, the driver can't decide if a
633 * specific format isn't supported based on the usage.
634 */
635 if ((info->flags & VK_IMAGE_CREATE_EXTENDED_USAGE_BIT) == 0) {
636 if (usage & (VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT |
637 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) &&
638 !vk_format_is_depth_or_stencil(info->format) &&
639 !(pvr_format->bind & PVR_BIND_RENDER_TARGET)) {
640
641 result = vk_error(pdevice, VK_ERROR_FORMAT_NOT_SUPPORTED);
642 goto err_unsupported_format;
643 }
644
645 u_foreach_bit(b, usage) {
646 VkFormatFeatureFlags2 usage_features =
647 vk_image_usage_to_format_features(1 << b);
648 if (usage_features && !(tiling_features2 & usage_features)) {
649 result = vk_error(pdevice, VK_ERROR_FORMAT_NOT_SUPPORTED);
650 goto err_unsupported_format;
651 }
652 }
653 }
654
655 if (info->type == VK_IMAGE_TYPE_3D) {
656 const VkImageUsageFlags transfer_usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
657 VK_IMAGE_USAGE_TRANSFER_DST_BIT;
658
659 /* We don't support 3D depth/stencil images. */
660 if (tiling_features2 & VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT) {
661 result = vk_error(pdevice, VK_ERROR_FORMAT_NOT_SUPPORTED);
662 goto err_unsupported_format;
663 }
664
665 /* Linear tiled 3D images may only be used for transfer or blit
666 * operations.
667 */
668 if (tiling == VK_IMAGE_TILING_LINEAR && usage & ~transfer_usage) {
669 result = vk_error(pdevice, VK_ERROR_FORMAT_NOT_SUPPORTED);
670 goto err_unsupported_format;
671 }
672
673 /* Block compressed with 3D layout not supported */
674 if (vk_format_is_block_compressed(info->format)) {
675 result = vk_error(pdevice, VK_ERROR_FORMAT_NOT_SUPPORTED);
676 goto err_unsupported_format;
677 }
678 }
679
680 const uint32_t max_render_size_z =
681 rogue_get_render_size_max_z(&pdevice->dev_info);
682
683 if (usage & render_usage) {
684 const uint32_t max_render_size =
685 rogue_get_render_size_max(&pdevice->dev_info);
686
687 pImageFormatProperties->maxExtent.width = max_render_size;
688 pImageFormatProperties->maxExtent.height = max_render_size;
689 pImageFormatProperties->maxExtent.depth = max_render_size_z;
690 } else {
691 const uint32_t max_texture_extent_xy =
692 rogue_get_texture_extent_max(&pdevice->dev_info);
693
694 pImageFormatProperties->maxExtent.width = max_texture_extent_xy;
695 pImageFormatProperties->maxExtent.height = max_texture_extent_xy;
696 pImageFormatProperties->maxExtent.depth = max_render_size_z;
697 }
698
699 if (tiling == VK_IMAGE_TILING_LINEAR) {
700 pImageFormatProperties->maxExtent.depth = 1;
701 pImageFormatProperties->maxArrayLayers = 1;
702 pImageFormatProperties->sampleCounts = VK_SAMPLE_COUNT_1_BIT;
703 } else {
704 /* Default value is the minimum value found in all existing cores. */
705 const uint32_t max_multisample =
706 PVR_GET_FEATURE_VALUE(&pdevice->dev_info, max_multisample, 4);
707
708 const uint32_t max_sample_bits = ((max_multisample << 1) - 1);
709
710 const uint32_t max_array_layers =
711 rogue_get_render_size_max_z(&pdevice->dev_info);
712
713 pImageFormatProperties->maxArrayLayers = max_array_layers;
714 pImageFormatProperties->sampleCounts = max_sample_bits;
715 }
716
717 if (!(tiling_features2 & VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT ||
718 tiling_features2 & VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT)) {
719 pImageFormatProperties->sampleCounts = VK_SAMPLE_COUNT_1_BIT;
720 }
721
722 switch (info->type) {
723 case VK_IMAGE_TYPE_1D:
724 pImageFormatProperties->maxExtent.height = 1;
725 pImageFormatProperties->maxExtent.depth = 1;
726 pImageFormatProperties->sampleCounts = VK_SAMPLE_COUNT_1_BIT;
727 break;
728
729 case VK_IMAGE_TYPE_2D:
730 pImageFormatProperties->maxExtent.depth = 1;
731
732 /* If a 2D image is created to be used in a cube map, then the sample
733 * count must be restricted to 1 sample.
734 */
735 if (info->flags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT)
736 pImageFormatProperties->sampleCounts = VK_SAMPLE_COUNT_1_BIT;
737
738 break;
739
740 case VK_IMAGE_TYPE_3D:
741 pImageFormatProperties->maxArrayLayers = 1;
742 pImageFormatProperties->sampleCounts = VK_SAMPLE_COUNT_1_BIT;
743 break;
744
745 default:
746 UNREACHABLE("Invalid image type.");
747 }
748
749 /* The spec says maxMipLevels may be 1 when tiling is VK_IMAGE_TILING_LINEAR
750 * or VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT, so for simplicity don't
751 * support miplevels for these tilings.
752 */
753 if (tiling == VK_IMAGE_TILING_LINEAR) {
754 pImageFormatProperties->maxMipLevels = 1;
755 } else {
756 const uint32_t max_size = MAX3(pImageFormatProperties->maxExtent.width,
757 pImageFormatProperties->maxExtent.height,
758 pImageFormatProperties->maxExtent.depth);
759
760 pImageFormatProperties->maxMipLevels = util_logbase2(max_size) + 1U;
761 }
762
763 /* Return 2GB (minimum required from spec).
764 *
765 * From the Vulkan spec:
766 *
767 * maxResourceSize is an upper bound on the total image size in bytes,
768 * inclusive of all image subresources. Implementations may have an
769 * address space limit on total size of a resource, which is advertised by
770 * this property. maxResourceSize must be at least 2^31.
771 */
772 pImageFormatProperties->maxResourceSize = 2ULL * 1024 * 1024 * 1024;
773
774 return VK_SUCCESS;
775
776 err_unsupported_format:
777 /* From the Vulkan 1.0.42 spec:
778 *
779 * If the combination of parameters to
780 * vkGetPhysicalDeviceImageFormatProperties2 is not supported by the
781 * implementation for use in vkCreateImage, then all members of
782 * imageFormatProperties will be filled with zero.
783 */
784 *pImageFormatProperties = (VkImageFormatProperties){ 0 };
785
786 return result;
787 }
788
789 /* FIXME: Should this be returning VK_ERROR_FORMAT_NOT_SUPPORTED when tiling is
790 * linear and the image type is 3D or flags contains
791 * VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT? This should avoid well behaved apps
792 * attempting to create invalid image views, as pvr_pack_tex_state() will return
793 * VK_ERROR_FORMAT_NOT_SUPPORTED in these cases.
794 */
795 VkResult pvr_GetPhysicalDeviceImageFormatProperties2(
796 VkPhysicalDevice physicalDevice,
797 const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo,
798 VkImageFormatProperties2 *pImageFormatProperties)
799 {
800 const VkPhysicalDeviceExternalImageFormatInfo *external_info = NULL;
801 VK_FROM_HANDLE(pvr_physical_device, pdevice, physicalDevice);
802 VkExternalImageFormatProperties *external_props = NULL;
803 VkResult result = pvr_get_image_format_properties(
804 pdevice,
805 pImageFormatInfo,
806 &pImageFormatProperties->imageFormatProperties);
807 if (result != VK_SUCCESS)
808 return result;
809
810 /* Extract input structs */
811 vk_foreach_struct_const (ext, pImageFormatInfo->pNext) {
812 switch (ext->sType) {
813 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
814 external_info = (const void *)ext;
815 break;
816 case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
817 break;
818 case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
819 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
820 /* Nothing to do here, it's handled in
821 * pvr_get_image_format_properties)
822 */
823 break;
824 default:
825 vk_debug_ignored_stype(ext->sType);
826 break;
827 }
828 }
829
830 /* Extract output structs */
831 vk_foreach_struct (ext, pImageFormatProperties->pNext) {
832 switch (ext->sType) {
833 case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
834 external_props = (void *)ext;
835 break;
836 case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: {
837 VkSamplerYcbcrConversionImageFormatProperties *ycbcr_props =
838 (void *)ext;
839 ycbcr_props->combinedImageSamplerDescriptorCount = 1;
840 break;
841 }
842 default:
843 vk_debug_ignored_stype(ext->sType);
844 break;
845 }
846 }
847
848 /* From the Vulkan 1.0.42 spec:
849 *
850 * If handleType is 0, vkGetPhysicalDeviceImageFormatProperties2 will
851 * behave as if VkPhysicalDeviceExternalImageFormatInfo was not
852 * present and VkExternalImageFormatProperties will be ignored.
853 */
854 if (external_info && external_info->handleType != 0) {
855 switch (external_info->handleType) {
856 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT:
857 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT:
858 if (!external_props)
859 break;
860
861 external_props->externalMemoryProperties.externalMemoryFeatures =
862 VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT |
863 VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT;
864 external_props->externalMemoryProperties.compatibleHandleTypes =
865 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT |
866 VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT;
867 external_props->externalMemoryProperties.exportFromImportedHandleTypes =
868 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT |
869 VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT;
870 break;
871 default:
872 return vk_error(pdevice, VK_ERROR_FORMAT_NOT_SUPPORTED);
873 }
874 }
875
876 return VK_SUCCESS;
877 }
878
879 void pvr_GetPhysicalDeviceSparseImageFormatProperties(
880 VkPhysicalDevice physicalDevice,
881 VkFormat format,
882 VkImageType type,
883 VkSampleCountFlagBits samples,
884 VkImageUsageFlags usage,
885 VkImageTiling tiling,
886 uint32_t *pNumProperties,
887 VkSparseImageFormatProperties *pProperties)
888 {
889 /* Sparse images are not yet supported. */
890 *pNumProperties = 0;
891 }
892
893 void pvr_GetPhysicalDeviceSparseImageFormatProperties2(
894 VkPhysicalDevice physicalDevice,
895 const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo,
896 uint32_t *pPropertyCount,
897 VkSparseImageFormatProperties2 *pProperties)
898 {
899 /* Sparse images are not yet supported. */
900 *pPropertyCount = 0;
901 }
902
903 void pvr_GetPhysicalDeviceExternalBufferProperties(
904 VkPhysicalDevice physicalDevice,
905 const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo,
906 VkExternalBufferProperties *pExternalBufferProperties)
907 {
908 /* The Vulkan 1.0.42 spec says "handleType must be a valid
909 * VkExternalMemoryHandleTypeFlagBits value" in
910 * VkPhysicalDeviceExternalBufferInfo. This differs from
911 * VkPhysicalDeviceExternalImageFormatInfo, which surprisingly permits
912 * handleType == 0.
913 */
914 assert(pExternalBufferInfo->handleType != 0);
915
916 /* All of the current flags are for sparse which we don't support. */
917 if (pExternalBufferInfo->flags)
918 goto unsupported;
919
920 switch (pExternalBufferInfo->handleType) {
921 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT:
922 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT:
923 /* clang-format off */
924 pExternalBufferProperties->externalMemoryProperties.externalMemoryFeatures =
925 VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT |
926 VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT;
927 pExternalBufferProperties->externalMemoryProperties.exportFromImportedHandleTypes =
928 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT |
929 VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT;
930 pExternalBufferProperties->externalMemoryProperties.compatibleHandleTypes =
931 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT |
932 VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT;
933 /* clang-format on */
934 return;
935 default:
936 break;
937 }
938
939 unsupported:
940 /* From the Vulkan 1.1.113 spec:
941 *
942 * compatibleHandleTypes must include at least handleType.
943 */
944 pExternalBufferProperties->externalMemoryProperties =
945 (VkExternalMemoryProperties){
946 .compatibleHandleTypes = pExternalBufferInfo->handleType,
947 };
948 }
949
950 uint32_t pvr_pbe_pixel_num_loads(enum pvr_transfer_pbe_pixel_src pbe_format)
951 {
952 switch (pbe_format) {
953 case PVR_TRANSFER_PBE_PIXEL_SRC_UU8888:
954 case PVR_TRANSFER_PBE_PIXEL_SRC_US8888:
955 case PVR_TRANSFER_PBE_PIXEL_SRC_UU16U16:
956 case PVR_TRANSFER_PBE_PIXEL_SRC_US16S16:
957 case PVR_TRANSFER_PBE_PIXEL_SRC_SU8888:
958 case PVR_TRANSFER_PBE_PIXEL_SRC_SS8888:
959 case PVR_TRANSFER_PBE_PIXEL_SRC_SU16U16:
960 case PVR_TRANSFER_PBE_PIXEL_SRC_SS16S16:
961 case PVR_TRANSFER_PBE_PIXEL_SRC_UU1010102:
962 case PVR_TRANSFER_PBE_PIXEL_SRC_SU1010102:
963 case PVR_TRANSFER_PBE_PIXEL_SRC_RBSWAP_UU1010102:
964 case PVR_TRANSFER_PBE_PIXEL_SRC_RBSWAP_SU1010102:
965 case PVR_TRANSFER_PBE_PIXEL_SRC_SU32U32:
966 case PVR_TRANSFER_PBE_PIXEL_SRC_S4XU32:
967 case PVR_TRANSFER_PBE_PIXEL_SRC_US32S32:
968 case PVR_TRANSFER_PBE_PIXEL_SRC_U4XS32:
969 case PVR_TRANSFER_PBE_PIXEL_SRC_F16F16:
970 case PVR_TRANSFER_PBE_PIXEL_SRC_U16NORM:
971 case PVR_TRANSFER_PBE_PIXEL_SRC_S16NORM:
972 case PVR_TRANSFER_PBE_PIXEL_SRC_F32:
973 case PVR_TRANSFER_PBE_PIXEL_SRC_F32X2:
974 case PVR_TRANSFER_PBE_PIXEL_SRC_F32X4:
975 case PVR_TRANSFER_PBE_PIXEL_SRC_RAW32:
976 case PVR_TRANSFER_PBE_PIXEL_SRC_RAW64:
977 case PVR_TRANSFER_PBE_PIXEL_SRC_RAW128:
978 case PVR_TRANSFER_PBE_PIXEL_SRC_F16_U8:
979 case PVR_TRANSFER_PBE_PIXEL_SRC_SWAP_LMSB:
980 case PVR_TRANSFER_PBE_PIXEL_SRC_MOV_BY45:
981 case PVR_TRANSFER_PBE_PIXEL_SRC_D24S8:
982 case PVR_TRANSFER_PBE_PIXEL_SRC_S8D24:
983 case PVR_TRANSFER_PBE_PIXEL_SRC_D32S8:
984
985 case PVR_TRANSFER_PBE_PIXEL_SRC_CONV_D24_D32:
986 case PVR_TRANSFER_PBE_PIXEL_SRC_CONV_D32U_D32F:
987 case PVR_TRANSFER_PBE_PIXEL_SRC_CONV_D32_D24S8:
988 case PVR_TRANSFER_PBE_PIXEL_SRC_CONV_S8D24_D24S8:
989 case PVR_TRANSFER_PBE_PIXEL_SRC_SMRG_S8_D32S8:
990
991 case PVR_TRANSFER_PBE_PIXEL_SRC_SMRG_D24S8_D32S8:
992 case PVR_TRANSFER_PBE_PIXEL_SRC_SMRG_D32S8_D32S8:
993 case PVR_TRANSFER_PBE_PIXEL_SRC_DMRG_D32S8_D32S8:
994 case PVR_TRANSFER_PBE_PIXEL_SRC_SMRG_S8_D24S8:
995 case PVR_TRANSFER_PBE_PIXEL_SRC_SMRG_D24S8_D24S8:
996 case PVR_TRANSFER_PBE_PIXEL_SRC_DMRG_D24S8_D24S8:
997 case PVR_TRANSFER_PBE_PIXEL_SRC_DMRG_D32_D24S8:
998 case PVR_TRANSFER_PBE_PIXEL_SRC_DMRG_D32U_D24S8:
999 case PVR_TRANSFER_PBE_PIXEL_SRC_Y_UV_INTERLEAVED:
1000 case PVR_TRANSFER_PBE_PIXEL_SRC_Y_U_V:
1001 case PVR_TRANSFER_PBE_PIXEL_SRC_YUV_PACKED:
1002 case PVR_TRANSFER_PBE_PIXEL_SRC_YVU_PACKED:
1003 return 1U;
1004
1005 case PVR_TRANSFER_PBE_PIXEL_SRC_NUM:
1006 default:
1007 return 0U;
1008 }
1009 }
1010
1011 bool pvr_pbe_pixel_is_norm(enum pvr_transfer_pbe_pixel_src pbe_format)
1012 {
1013 switch (pbe_format) {
1014 case PVR_TRANSFER_PBE_PIXEL_SRC_Y_U_V:
1015 case PVR_TRANSFER_PBE_PIXEL_SRC_YUV_PACKED:
1016
1017 case PVR_TRANSFER_PBE_PIXEL_SRC_Y_UV_INTERLEAVED:
1018 case PVR_TRANSFER_PBE_PIXEL_SRC_YVU_PACKED:
1019
1020 case PVR_TRANSFER_PBE_PIXEL_SRC_F16F16:
1021 case PVR_TRANSFER_PBE_PIXEL_SRC_U16NORM:
1022 case PVR_TRANSFER_PBE_PIXEL_SRC_S16NORM:
1023 case PVR_TRANSFER_PBE_PIXEL_SRC_F32:
1024 case PVR_TRANSFER_PBE_PIXEL_SRC_F32X2:
1025 case PVR_TRANSFER_PBE_PIXEL_SRC_F32X4:
1026 case PVR_TRANSFER_PBE_PIXEL_SRC_F16_U8:
1027 case PVR_TRANSFER_PBE_PIXEL_SRC_CONV_D32_D24S8:
1028 return true;
1029
1030 case PVR_TRANSFER_PBE_PIXEL_SRC_UU8888:
1031 case PVR_TRANSFER_PBE_PIXEL_SRC_US8888:
1032 case PVR_TRANSFER_PBE_PIXEL_SRC_UU16U16:
1033 case PVR_TRANSFER_PBE_PIXEL_SRC_US16S16:
1034 case PVR_TRANSFER_PBE_PIXEL_SRC_SU8888:
1035 case PVR_TRANSFER_PBE_PIXEL_SRC_SS8888:
1036 case PVR_TRANSFER_PBE_PIXEL_SRC_SU16U16:
1037 case PVR_TRANSFER_PBE_PIXEL_SRC_SS16S16:
1038 case PVR_TRANSFER_PBE_PIXEL_SRC_UU1010102:
1039 case PVR_TRANSFER_PBE_PIXEL_SRC_SU1010102:
1040 case PVR_TRANSFER_PBE_PIXEL_SRC_RBSWAP_UU1010102:
1041 case PVR_TRANSFER_PBE_PIXEL_SRC_RBSWAP_SU1010102:
1042 case PVR_TRANSFER_PBE_PIXEL_SRC_SU32U32:
1043 case PVR_TRANSFER_PBE_PIXEL_SRC_S4XU32:
1044 case PVR_TRANSFER_PBE_PIXEL_SRC_US32S32:
1045 case PVR_TRANSFER_PBE_PIXEL_SRC_U4XS32:
1046 case PVR_TRANSFER_PBE_PIXEL_SRC_RAW32:
1047 case PVR_TRANSFER_PBE_PIXEL_SRC_RAW64:
1048 case PVR_TRANSFER_PBE_PIXEL_SRC_RAW128:
1049 case PVR_TRANSFER_PBE_PIXEL_SRC_SWAP_LMSB:
1050 case PVR_TRANSFER_PBE_PIXEL_SRC_MOV_BY45:
1051 case PVR_TRANSFER_PBE_PIXEL_SRC_D24S8:
1052 case PVR_TRANSFER_PBE_PIXEL_SRC_S8D24:
1053 case PVR_TRANSFER_PBE_PIXEL_SRC_D32S8:
1054 case PVR_TRANSFER_PBE_PIXEL_SRC_SMRG_S8_D32S8:
1055 case PVR_TRANSFER_PBE_PIXEL_SRC_SMRG_D24S8_D32S8:
1056 case PVR_TRANSFER_PBE_PIXEL_SRC_SMRG_D32S8_D32S8:
1057 case PVR_TRANSFER_PBE_PIXEL_SRC_DMRG_D32S8_D32S8:
1058 case PVR_TRANSFER_PBE_PIXEL_SRC_CONV_D24_D32:
1059 case PVR_TRANSFER_PBE_PIXEL_SRC_CONV_D32U_D32F:
1060 case PVR_TRANSFER_PBE_PIXEL_SRC_SMRG_S8_D24S8:
1061 case PVR_TRANSFER_PBE_PIXEL_SRC_SMRG_D24S8_D24S8:
1062 case PVR_TRANSFER_PBE_PIXEL_SRC_DMRG_D24S8_D24S8:
1063 case PVR_TRANSFER_PBE_PIXEL_SRC_MASK16:
1064 case PVR_TRANSFER_PBE_PIXEL_SRC_MASK32:
1065 case PVR_TRANSFER_PBE_PIXEL_SRC_MASK48:
1066 case PVR_TRANSFER_PBE_PIXEL_SRC_MASK64:
1067 case PVR_TRANSFER_PBE_PIXEL_SRC_MASK96:
1068 case PVR_TRANSFER_PBE_PIXEL_SRC_MASK128:
1069 case PVR_TRANSFER_PBE_PIXEL_SRC_CONV_S8D24_D24S8:
1070 case PVR_TRANSFER_PBE_PIXEL_SRC_DMRG_D32_D24S8:
1071 case PVR_TRANSFER_PBE_PIXEL_SRC_DMRG_D32U_D24S8:
1072 return false;
1073
1074 default:
1075 UNREACHABLE("Invalid pvr_transfer_pbe_pixel_src");
1076 }
1077
1078 return false;
1079 }
1080
1081 uint32_t pvr_pbe_pixel_size(enum pvr_transfer_pbe_pixel_src pbe_format)
1082 {
1083 switch (pbe_format) {
1084 case PVR_TRANSFER_PBE_PIXEL_SRC_UU8888:
1085 case PVR_TRANSFER_PBE_PIXEL_SRC_US8888:
1086 case PVR_TRANSFER_PBE_PIXEL_SRC_SU8888:
1087 case PVR_TRANSFER_PBE_PIXEL_SRC_SS8888:
1088 case PVR_TRANSFER_PBE_PIXEL_SRC_UU1010102:
1089 case PVR_TRANSFER_PBE_PIXEL_SRC_SU1010102:
1090 case PVR_TRANSFER_PBE_PIXEL_SRC_RBSWAP_UU1010102:
1091 case PVR_TRANSFER_PBE_PIXEL_SRC_RBSWAP_SU1010102:
1092
1093 case PVR_TRANSFER_PBE_PIXEL_SRC_F16_U8:
1094
1095 case PVR_TRANSFER_PBE_PIXEL_SRC_SWAP_LMSB:
1096
1097 case PVR_TRANSFER_PBE_PIXEL_SRC_F32:
1098 case PVR_TRANSFER_PBE_PIXEL_SRC_RAW32:
1099
1100 case PVR_TRANSFER_PBE_PIXEL_SRC_D24S8:
1101 case PVR_TRANSFER_PBE_PIXEL_SRC_S8D24:
1102
1103 case PVR_TRANSFER_PBE_PIXEL_SRC_CONV_D24_D32:
1104 case PVR_TRANSFER_PBE_PIXEL_SRC_CONV_D32U_D32F:
1105 case PVR_TRANSFER_PBE_PIXEL_SRC_SMRG_S8_D24S8:
1106 case PVR_TRANSFER_PBE_PIXEL_SRC_SMRG_D24S8_D24S8:
1107 case PVR_TRANSFER_PBE_PIXEL_SRC_DMRG_D24S8_D24S8:
1108 case PVR_TRANSFER_PBE_PIXEL_SRC_CONV_D32_D24S8:
1109 case PVR_TRANSFER_PBE_PIXEL_SRC_DMRG_D32_D24S8:
1110 case PVR_TRANSFER_PBE_PIXEL_SRC_DMRG_D32U_D24S8:
1111 case PVR_TRANSFER_PBE_PIXEL_SRC_CONV_S8D24_D24S8:
1112
1113 case PVR_TRANSFER_PBE_PIXEL_SRC_YUV_PACKED:
1114 case PVR_TRANSFER_PBE_PIXEL_SRC_YVU_PACKED:
1115
1116 case PVR_TRANSFER_PBE_PIXEL_SRC_MASK16:
1117 case PVR_TRANSFER_PBE_PIXEL_SRC_MASK32:
1118 return 1;
1119
1120 case PVR_TRANSFER_PBE_PIXEL_SRC_UU16U16:
1121 case PVR_TRANSFER_PBE_PIXEL_SRC_US16S16:
1122 case PVR_TRANSFER_PBE_PIXEL_SRC_SU16U16:
1123 case PVR_TRANSFER_PBE_PIXEL_SRC_SS16S16:
1124 case PVR_TRANSFER_PBE_PIXEL_SRC_SU32U32:
1125 case PVR_TRANSFER_PBE_PIXEL_SRC_US32S32:
1126
1127 case PVR_TRANSFER_PBE_PIXEL_SRC_F16F16:
1128 case PVR_TRANSFER_PBE_PIXEL_SRC_U16NORM:
1129 case PVR_TRANSFER_PBE_PIXEL_SRC_S16NORM:
1130
1131 case PVR_TRANSFER_PBE_PIXEL_SRC_MOV_BY45:
1132
1133 case PVR_TRANSFER_PBE_PIXEL_SRC_F32X2:
1134 case PVR_TRANSFER_PBE_PIXEL_SRC_RAW64:
1135
1136 case PVR_TRANSFER_PBE_PIXEL_SRC_D32S8:
1137 case PVR_TRANSFER_PBE_PIXEL_SRC_SMRG_S8_D32S8:
1138 case PVR_TRANSFER_PBE_PIXEL_SRC_SMRG_D24S8_D32S8:
1139 case PVR_TRANSFER_PBE_PIXEL_SRC_SMRG_D32S8_D32S8:
1140 case PVR_TRANSFER_PBE_PIXEL_SRC_DMRG_D32S8_D32S8:
1141
1142 case PVR_TRANSFER_PBE_PIXEL_SRC_Y_U_V:
1143 case PVR_TRANSFER_PBE_PIXEL_SRC_Y_UV_INTERLEAVED:
1144
1145 case PVR_TRANSFER_PBE_PIXEL_SRC_MASK48:
1146 case PVR_TRANSFER_PBE_PIXEL_SRC_MASK64:
1147 return 2;
1148
1149 case PVR_TRANSFER_PBE_PIXEL_SRC_MASK96:
1150 return 3;
1151
1152 case PVR_TRANSFER_PBE_PIXEL_SRC_U4XS32:
1153 case PVR_TRANSFER_PBE_PIXEL_SRC_S4XU32:
1154
1155 case PVR_TRANSFER_PBE_PIXEL_SRC_F32X4:
1156 case PVR_TRANSFER_PBE_PIXEL_SRC_RAW128:
1157
1158 case PVR_TRANSFER_PBE_PIXEL_SRC_MASK128:
1159 return 4;
1160
1161 default:
1162 UNREACHABLE("Invalid pvr_transfer_pbe_pixel_src");
1163 }
1164
1165 return 0;
1166 }