xref: /aosp_15_r20/external/mesa3d/src/intel/isl/isl_priv.h (revision 6104692788411f58d303aa86923a9ff6ecaded22)

/*
 * Copyright 2015 Intel Corporation
 *
 *  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 (including the next
 *  paragraph) 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 ISL_PRIV_H
#define ISL_PRIV_H

#include <assert.h>
#include <stddef.h>
#include <strings.h>

#include "dev/intel_device_info.h"
#include "util/macros.h"

#include "isl.h"

typedef void (*isl_surf_fill_state_s_func)(
   const struct isl_device *dev, void *state,
   const struct isl_surf_fill_state_info *restrict info);

typedef void (*isl_buffer_fill_state_s_func)(
   const struct isl_device *dev, void *state,
   const struct isl_buffer_fill_state_info *restrict info);

typedef void (*isl_emit_depth_stencil_hiz_s_func)(
   const struct isl_device *dev, void *state,
   const struct isl_depth_stencil_hiz_emit_info *restrict info);

typedef void (*isl_null_fill_state_s_func)(const struct isl_device *dev, void *state,
                                           const struct isl_null_fill_state_info *restrict info);

typedef void (*isl_emit_cpb_control_s_func)(const struct isl_device *dev, void *batch,
                                            const struct isl_cpb_emit_info *restrict info);

#define isl_genX_declare_get_func(func)                                 \
   static inline isl_##func##_func                                      \
   isl_##func##_get_func(const struct isl_device *dev) {                \
      switch (ISL_GFX_VERX10(dev)) {                                    \
      case 40:                                                          \
         return isl_gfx4_##func;                                        \
      case 45:                                                          \
         /* G45 surface state is the same as gfx5 */                    \
      case 50:                                                          \
         return isl_gfx5_##func;                                        \
      case 60:                                                          \
         return isl_gfx6_##func;                                        \
      case 70:                                                          \
         return isl_gfx7_##func;                                        \
      case 75:                                                          \
         return isl_gfx75_##func;                                       \
      case 80:                                                          \
         return isl_gfx8_##func;                                        \
      case 90:                                                          \
         return isl_gfx9_##func;                                        \
      case 110:                                                         \
         return isl_gfx11_##func;                                       \
      case 120:                                                         \
         return isl_gfx12_##func;                                       \
      case 125:                                                         \
         return isl_gfx125_##func;                                      \
      case 200:                                                         \
         return isl_gfx20_##func;                                       \
      default:                                                          \
         assert(!"Unknown hardware generation");                        \
         return NULL;                                                   \
      }                                                                 \
   }

#define isl_finishme(format, ...) \
   do { \
      static bool reported = false; \
      if (!reported) { \
         __isl_finishme(__FILE__, __LINE__, format, ##__VA_ARGS__); \
         reported = true; \
      } \
   } while (0)

void PRINTFLIKE(3, 4) UNUSED
__isl_finishme(const char *file, int line, const char *fmt, ...);

#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define MAX(a, b) ((a) > (b) ? (a) : (b))

typedef void *(*isl_mem_copy_fn)(void *dest, const void *src, size_t n);

static inline bool
isl_is_pow2(uintmax_t n)
{
   return !(n & (n - 1));
}

/**
 * Alignment must be a power of 2.
 */
static inline bool
isl_is_aligned(uintmax_t n, uintmax_t a)
{
   assert(isl_is_pow2(a));
   return (n & (a - 1)) == 0;
}

/**
 * Alignment must be a power of 2.
 */
static inline uintmax_t
isl_align(uintmax_t n, uintmax_t a)
{
   assert(a != 0 && isl_is_pow2(a));
   return (n + a - 1) & ~(a - 1);
}

static inline uintmax_t
isl_align_npot(uintmax_t n, uintmax_t a)
{
   assert(a > 0);
   return ((n + a - 1) / a) * a;
}

static inline uintmax_t
isl_assert_div(uintmax_t n, uintmax_t a)
{
   assert(n % a == 0);
   return n / a;
}

/**
 * Alignment must be a power of 2.
 */
static inline uintmax_t
isl_align_div(uintmax_t n, uintmax_t a)
{
   return isl_align(n, a) / a;
}

static inline uintmax_t
isl_align_div_npot(uintmax_t n, uintmax_t a)
{
   return isl_align_npot(n, a) / a;
}

/**
 * Log base 2, rounding towards zero.
 */
static inline uint32_t
isl_log2u(uint32_t n)
{
   assert(n != 0);
   return 31 - __builtin_clz(n);
}

static inline uint32_t
isl_round_up_to_power_of_two(uint32_t value)
{
   if (value <= 1)
      return value;

   return 1 << (32 - __builtin_clz(value - 1));
}

static inline uint32_t
isl_minify(uint32_t n, uint32_t levels)
{
   if (unlikely(n == 0))
      return 0;
   else
      return MAX(n >> levels, 1);
}

static inline struct isl_extent3d
isl_extent3d_sa_to_el(enum isl_format fmt, struct isl_extent3d extent_sa)
{
   const struct isl_format_layout *fmtl = isl_format_get_layout(fmt);

   assert(extent_sa.w % fmtl->bw == 0);
   assert(extent_sa.h % fmtl->bh == 0);
   assert(extent_sa.d % fmtl->bd == 0);

   return (struct isl_extent3d) {
      .w = extent_sa.w / fmtl->bw,
      .h = extent_sa.h / fmtl->bh,
      .d = extent_sa.d / fmtl->bd,
   };
}

static inline struct isl_extent3d
isl_extent3d_el_to_sa(enum isl_format fmt, struct isl_extent3d extent_el)
{
   const struct isl_format_layout *fmtl = isl_format_get_layout(fmt);

   return (struct isl_extent3d) {
      .w = extent_el.w * fmtl->bw,
      .h = extent_el.h * fmtl->bh,
      .d = extent_el.d * fmtl->bd,
   };
}

bool
_isl_surf_info_supports_ccs(const struct isl_device *dev,
                            enum isl_format format,
                            isl_surf_usage_flags_t usage);

void
_isl_memcpy_linear_to_tiled(uint32_t xt1, uint32_t xt2,
                            uint32_t yt1, uint32_t yt2,
                            char *dst, const char *src,
                            uint32_t dst_pitch, int32_t src_pitch,
                            bool has_swizzling,
                            enum isl_tiling tiling,
                            isl_memcpy_type copy_type);

void
_isl_memcpy_tiled_to_linear(uint32_t xt1, uint32_t xt2,
                            uint32_t yt1, uint32_t yt2,
                            char *dst, const char *src,
                            int32_t dst_pitch, uint32_t src_pitch,
                            bool has_swizzling,
                            enum isl_tiling tiling,
                            isl_memcpy_type copy_type);

void
_isl_memcpy_linear_to_tiled_sse41(uint32_t xt1, uint32_t xt2,
                                  uint32_t yt1, uint32_t yt2,
                                  char *dst, const char *src,
                                  uint32_t dst_pitch, int32_t src_pitch,
                                  bool has_swizzling,
                                  enum isl_tiling tiling,
                                  isl_memcpy_type copy_type);

void
_isl_memcpy_tiled_to_linear_sse41(uint32_t xt1, uint32_t xt2,
                                  uint32_t yt1, uint32_t yt2,
                                  char *dst, const char *src,
                                  int32_t dst_pitch, uint32_t src_pitch,
                                  bool has_swizzling,
                                  enum isl_tiling tiling,
                                  isl_memcpy_type copy_type);

void PRINTFLIKE(4, 5)
_isl_notify_failure(const struct isl_surf_init_info *surf_info,
                    const char *file, int line, const char *fmt, ...);

#define notify_failure(surf_info, ...) \
   (_isl_notify_failure(surf_info, __FILE__, __LINE__, __VA_ARGS__), false)


/* This is useful for adding the isl_prefix to genX functions */
#define isl_genX(x) CONCAT2(isl_, genX(x))

#ifdef genX
#  include "isl_genX_priv.h"
#else
#  define genX(x) gfx4_##x
#  include "isl_genX_priv.h"
#  undef genX
#  define genX(x) gfx5_##x
#  include "isl_genX_priv.h"
#  undef genX
#  define genX(x) gfx6_##x
#  include "isl_genX_priv.h"
#  undef genX
#  define genX(x) gfx7_##x
#  include "isl_genX_priv.h"
#  undef genX
#  define genX(x) gfx75_##x
#  include "isl_genX_priv.h"
#  undef genX
#  define genX(x) gfx8_##x
#  include "isl_genX_priv.h"
#  undef genX
#  define genX(x) gfx9_##x
#  include "isl_genX_priv.h"
#  undef genX
#  define genX(x) gfx11_##x
#  include "isl_genX_priv.h"
#  undef genX
#  define genX(x) gfx12_##x
#  include "isl_genX_priv.h"
#  undef genX
#  define genX(x) gfx125_##x
#  include "isl_genX_priv.h"
#  undef genX
#  define genX(x) gfx20_##x
#  include "isl_genX_priv.h"
#  undef genX
#endif

#endif /* ISL_PRIV_H */