/* SPDX-License-Identifier: GPL-2.0 OR MIT */ /********************************************************** * * Copyright (c) 2021-2024 Broadcom. All Rights Reserved. The term * “Broadcom” refers to Broadcom Inc. and/or its subsidiaries. * * Permission is hereby granted, free of charge, to any person * obtaining a copy of this software and associated documentation * files (the "Software"), to deal in the Software without * restriction, including without limitation the rights to use, copy, * modify, merge, publish, distribute, sublicense, and/or sell copies * of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be * included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. * **********************************************************/ #ifndef VMW_SURFACE_CACHE_H #define VMW_SURFACE_CACHE_H #include "device_include/svga3d_surfacedefs.h" #include <drm/vmwgfx_drm.h> #define SVGA3D_FLAGS_UPPER_32(svga3d_flags) … #define SVGA3D_FLAGS_LOWER_32(svga3d_flags) … static inline u32 clamped_umul32(u32 a, u32 b) { … } /** * vmw_surface_get_desc - Look up the appropriate SVGA3dSurfaceDesc for the * given format. */ static inline const SVGA3dSurfaceDesc * vmw_surface_get_desc(SVGA3dSurfaceFormat format) { … } /** * vmw_surface_get_mip_size - Given a base level size and the mip level, * compute the size of the mip level. */ static inline struct drm_vmw_size vmw_surface_get_mip_size(struct drm_vmw_size base_level, u32 mip_level) { … } static inline void vmw_surface_get_size_in_blocks(const SVGA3dSurfaceDesc *desc, const struct drm_vmw_size *pixel_size, SVGA3dSize *block_size) { … } static inline bool vmw_surface_is_planar_surface(const SVGA3dSurfaceDesc *desc) { … } static inline u32 vmw_surface_calculate_pitch(const SVGA3dSurfaceDesc *desc, const struct drm_vmw_size *size) { … } /** * vmw_surface_get_image_buffer_size - Calculates image buffer size. * * Return the number of bytes of buffer space required to store one image of a * surface, optionally using the specified pitch. * * If pitch is zero, it is assumed that rows are tightly packed. * * This function is overflow-safe. If the result would have overflowed, instead * we return MAX_UINT32. */ static inline u32 vmw_surface_get_image_buffer_size(const SVGA3dSurfaceDesc *desc, const struct drm_vmw_size *size, u32 pitch) { … } /** * vmw_surface_get_serialized_size - Get the serialized size for the image. */ static inline u32 vmw_surface_get_serialized_size(SVGA3dSurfaceFormat format, struct drm_vmw_size base_level_size, u32 num_mip_levels, u32 num_layers) { … } /** * vmw_surface_get_serialized_size_extended - Returns the number of bytes * required for a surface with given parameters. Support for sample count. */ static inline u32 vmw_surface_get_serialized_size_extended(SVGA3dSurfaceFormat format, struct drm_vmw_size base_level_size, u32 num_mip_levels, u32 num_layers, u32 num_samples) { … } /** * vmw_surface_get_pixel_offset - Compute the offset (in bytes) to a pixel * in an image (or volume). * * @width: The image width in pixels. * @height: The image height in pixels */ static inline u32 vmw_surface_get_pixel_offset(SVGA3dSurfaceFormat format, u32 width, u32 height, u32 x, u32 y, u32 z) { … } static inline u32 vmw_surface_get_image_offset(SVGA3dSurfaceFormat format, struct drm_vmw_size baseLevelSize, u32 numMipLevels, u32 face, u32 mip) { … } /** * vmw_surface_is_gb_screen_target_format - Is the specified format usable as * a ScreenTarget? * (with just the GBObjects cap-bit * set) * @format: format to queried * * RETURNS: * true if queried format is valid for screen targets */ static inline bool vmw_surface_is_gb_screen_target_format(SVGA3dSurfaceFormat format) { … } /** * vmw_surface_is_dx_screen_target_format - Is the specified format usable as * a ScreenTarget? * (with DX10 enabled) * * @format: format to queried * * Results: * true if queried format is valid for screen targets */ static inline bool vmw_surface_is_dx_screen_target_format(SVGA3dSurfaceFormat format) { … } /** * vmw_surface_is_screen_target_format - Is the specified format usable as a * ScreenTarget? * (for some combination of caps) * * @format: format to queried * * Results: * true if queried format is valid for screen targets */ static inline bool vmw_surface_is_screen_target_format(SVGA3dSurfaceFormat format) { … } /** * struct vmw_surface_mip - Mimpmap level information * @bytes: Bytes required in the backing store of this mipmap level. * @img_stride: Byte stride per image. * @row_stride: Byte stride per block row. * @size: The size of the mipmap. */ struct vmw_surface_mip { … }; /** * struct vmw_surface_cache - Cached surface information * @desc: Pointer to the surface descriptor * @mip: Array of mipmap level information. Valid size is @num_mip_levels. * @mip_chain_bytes: Bytes required in the backing store for the whole chain * of mip levels. * @sheet_bytes: Bytes required in the backing store for a sheet * representing a single sample. * @num_mip_levels: Valid size of the @mip array. Number of mipmap levels in * a chain. * @num_layers: Number of slices in an array texture or number of faces in * a cubemap texture. */ struct vmw_surface_cache { … }; /** * struct vmw_surface_loc - Surface location * @sheet: The multisample sheet. * @sub_resource: Surface subresource. Defined as layer * num_mip_levels + * mip_level. * @x: X coordinate. * @y: Y coordinate. * @z: Z coordinate. */ struct vmw_surface_loc { … }; /** * vmw_surface_subres - Compute the subresource from layer and mipmap. * @cache: Surface layout data. * @mip_level: The mipmap level. * @layer: The surface layer (face or array slice). * * Return: The subresource. */ static inline u32 vmw_surface_subres(const struct vmw_surface_cache *cache, u32 mip_level, u32 layer) { … } /** * vmw_surface_setup_cache - Build a surface cache entry * @size: The surface base level dimensions. * @format: The surface format. * @num_mip_levels: Number of mipmap levels. * @num_layers: Number of layers. * @cache: Pointer to a struct vmw_surface_cach object to be filled in. * * Return: Zero on success, -EINVAL on invalid surface layout. */ static inline int vmw_surface_setup_cache(const struct drm_vmw_size *size, SVGA3dSurfaceFormat format, u32 num_mip_levels, u32 num_layers, u32 num_samples, struct vmw_surface_cache *cache) { … } /** * vmw_surface_get_loc - Get a surface location from an offset into the * backing store * @cache: Surface layout data. * @loc: Pointer to a struct vmw_surface_loc to be filled in. * @offset: Offset into the surface backing store. */ static inline void vmw_surface_get_loc(const struct vmw_surface_cache *cache, struct vmw_surface_loc *loc, size_t offset) { … } /** * vmw_surface_inc_loc - Clamp increment a surface location with one block * size * in each dimension. * @loc: Pointer to a struct vmw_surface_loc to be incremented. * * When computing the size of a range as size = end - start, the range does not * include the end element. However a location representing the last byte * of a touched region in the backing store *is* included in the range. * This function modifies such a location to match the end definition * given as start + size which is the one used in a SVGA3dBox. */ static inline void vmw_surface_inc_loc(const struct vmw_surface_cache *cache, struct vmw_surface_loc *loc) { … } /** * vmw_surface_min_loc - The start location in a subresource * @cache: Surface layout data. * @sub_resource: The subresource. * @loc: Pointer to a struct vmw_surface_loc to be filled in. */ static inline void vmw_surface_min_loc(const struct vmw_surface_cache *cache, u32 sub_resource, struct vmw_surface_loc *loc) { … } /** * vmw_surface_min_loc - The end location in a subresource * @cache: Surface layout data. * @sub_resource: The subresource. * @loc: Pointer to a struct vmw_surface_loc to be filled in. * * Following the end definition given in vmw_surface_inc_loc(), * Compute the end location of a surface subresource. */ static inline void vmw_surface_max_loc(const struct vmw_surface_cache *cache, u32 sub_resource, struct vmw_surface_loc *loc) { … } #endif /* VMW_SURFACE_CACHE_H */
Codebase Browser
linux