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 DEALINGS
21  *  IN THE SOFTWARE.
22  */
23 
24 #ifndef ISL_PRIV_H
25 #define ISL_PRIV_H
26 
27 #include <assert.h>
28 #include <stddef.h>
29 #include <strings.h>
30 
31 #include "dev/intel_device_info.h"
32 #include "util/macros.h"
33 
34 #include "isl.h"
35 
36 #define isl_finishme(format, ...) \
37    do { \
38       static bool reported = false; \
39       if (!reported) { \
40          __isl_finishme(__FILE__, __LINE__, format, ##__VA_ARGS__); \
41          reported = true; \
42       } \
43    } while (0)
44 
45 void PRINTFLIKE(3, 4) UNUSED
46 __isl_finishme(const char *file, int line, const char *fmt, ...);
47 
48 #define MIN(a, b) ((a) < (b) ? (a) : (b))
49 #define MAX(a, b) ((a) > (b) ? (a) : (b))
50 
51 typedef void *(*isl_mem_copy_fn)(void *dest, const void *src, size_t n);
52 
53 static inline bool
isl_is_pow2(uintmax_t n)54 isl_is_pow2(uintmax_t n)
55 {
56    return !(n & (n - 1));
57 }
58 
59 /**
60  * Alignment must be a power of 2.
61  */
62 static inline bool
isl_is_aligned(uintmax_t n,uintmax_t a)63 isl_is_aligned(uintmax_t n, uintmax_t a)
64 {
65    assert(isl_is_pow2(a));
66    return (n & (a - 1)) == 0;
67 }
68 
69 /**
70  * Alignment must be a power of 2.
71  */
72 static inline uintmax_t
isl_align(uintmax_t n,uintmax_t a)73 isl_align(uintmax_t n, uintmax_t a)
74 {
75    assert(a != 0 && isl_is_pow2(a));
76    return (n + a - 1) & ~(a - 1);
77 }
78 
79 static inline uintmax_t
isl_align_npot(uintmax_t n,uintmax_t a)80 isl_align_npot(uintmax_t n, uintmax_t a)
81 {
82    assert(a > 0);
83    return ((n + a - 1) / a) * a;
84 }
85 
86 static inline uintmax_t
isl_assert_div(uintmax_t n,uintmax_t a)87 isl_assert_div(uintmax_t n, uintmax_t a)
88 {
89    assert(n % a == 0);
90    return n / a;
91 }
92 
93 /**
94  * Alignment must be a power of 2.
95  */
96 static inline uintmax_t
isl_align_div(uintmax_t n,uintmax_t a)97 isl_align_div(uintmax_t n, uintmax_t a)
98 {
99    return isl_align(n, a) / a;
100 }
101 
102 static inline uintmax_t
isl_align_div_npot(uintmax_t n,uintmax_t a)103 isl_align_div_npot(uintmax_t n, uintmax_t a)
104 {
105    return isl_align_npot(n, a) / a;
106 }
107 
108 /**
109  * Log base 2, rounding towards zero.
110  */
111 static inline uint32_t
isl_log2u(uint32_t n)112 isl_log2u(uint32_t n)
113 {
114    assert(n != 0);
115    return 31 - __builtin_clz(n);
116 }
117 
118 static inline uint32_t
isl_round_up_to_power_of_two(uint32_t value)119 isl_round_up_to_power_of_two(uint32_t value)
120 {
121    if (value <= 1)
122       return value;
123 
124    return 1 << (32 - __builtin_clz(value - 1));
125 }
126 
127 static inline uint32_t
isl_minify(uint32_t n,uint32_t levels)128 isl_minify(uint32_t n, uint32_t levels)
129 {
130    if (unlikely(n == 0))
131       return 0;
132    else
133       return MAX(n >> levels, 1);
134 }
135 
136 static inline struct isl_extent3d
isl_extent3d_sa_to_el(enum isl_format fmt,struct isl_extent3d extent_sa)137 isl_extent3d_sa_to_el(enum isl_format fmt, struct isl_extent3d extent_sa)
138 {
139    const struct isl_format_layout *fmtl = isl_format_get_layout(fmt);
140 
141    assert(extent_sa.w % fmtl->bw == 0);
142    assert(extent_sa.h % fmtl->bh == 0);
143    assert(extent_sa.d % fmtl->bd == 0);
144 
145    return (struct isl_extent3d) {
146       .w = extent_sa.w / fmtl->bw,
147       .h = extent_sa.h / fmtl->bh,
148       .d = extent_sa.d / fmtl->bd,
149    };
150 }
151 
152 static inline struct isl_extent3d
isl_extent3d_el_to_sa(enum isl_format fmt,struct isl_extent3d extent_el)153 isl_extent3d_el_to_sa(enum isl_format fmt, struct isl_extent3d extent_el)
154 {
155    const struct isl_format_layout *fmtl = isl_format_get_layout(fmt);
156 
157    return (struct isl_extent3d) {
158       .w = extent_el.w * fmtl->bw,
159       .h = extent_el.h * fmtl->bh,
160       .d = extent_el.d * fmtl->bd,
161    };
162 }
163 
164 void
165 _isl_memcpy_linear_to_tiled(uint32_t xt1, uint32_t xt2,
166                             uint32_t yt1, uint32_t yt2,
167                             char *dst, const char *src,
168                             uint32_t dst_pitch, int32_t src_pitch,
169                             bool has_swizzling,
170                             enum isl_tiling tiling,
171                             isl_memcpy_type copy_type);
172 
173 void
174 _isl_memcpy_tiled_to_linear(uint32_t xt1, uint32_t xt2,
175                             uint32_t yt1, uint32_t yt2,
176                             char *dst, const char *src,
177                             int32_t dst_pitch, uint32_t src_pitch,
178                             bool has_swizzling,
179                             enum isl_tiling tiling,
180                             isl_memcpy_type copy_type);
181 
182 void
183 _isl_memcpy_linear_to_tiled_sse41(uint32_t xt1, uint32_t xt2,
184                                   uint32_t yt1, uint32_t yt2,
185                                   char *dst, const char *src,
186                                   uint32_t dst_pitch, int32_t src_pitch,
187                                   bool has_swizzling,
188                                   enum isl_tiling tiling,
189                                   isl_memcpy_type copy_type);
190 
191 void
192 _isl_memcpy_tiled_to_linear_sse41(uint32_t xt1, uint32_t xt2,
193                                   uint32_t yt1, uint32_t yt2,
194                                   char *dst, const char *src,
195                                   int32_t dst_pitch, uint32_t src_pitch,
196                                   bool has_swizzling,
197                                   enum isl_tiling tiling,
198                                   isl_memcpy_type copy_type);
199 
200 /* This is useful for adding the isl_prefix to genX functions */
201 #define __PASTE2(x, y) x ## y
202 #define __PASTE(x, y) __PASTE2(x, y)
203 #define isl_genX(x) __PASTE(isl_, genX(x))
204 
205 #ifdef genX
206 #  include "isl_genX_priv.h"
207 #else
208 #  define genX(x) gfx4_##x
209 #  include "isl_genX_priv.h"
210 #  undef genX
211 #  define genX(x) gfx5_##x
212 #  include "isl_genX_priv.h"
213 #  undef genX
214 #  define genX(x) gfx6_##x
215 #  include "isl_genX_priv.h"
216 #  undef genX
217 #  define genX(x) gfx7_##x
218 #  include "isl_genX_priv.h"
219 #  undef genX
220 #  define genX(x) gfx75_##x
221 #  include "isl_genX_priv.h"
222 #  undef genX
223 #  define genX(x) gfx8_##x
224 #  include "isl_genX_priv.h"
225 #  undef genX
226 #  define genX(x) gfx9_##x
227 #  include "isl_genX_priv.h"
228 #  undef genX
229 #  define genX(x) gfx11_##x
230 #  include "isl_genX_priv.h"
231 #  undef genX
232 #  define genX(x) gfx12_##x
233 #  include "isl_genX_priv.h"
234 #  undef genX
235 #  define genX(x) gfx125_##x
236 #  include "isl_genX_priv.h"
237 #  undef genX
238 #endif
239 
240 #endif /* ISL_PRIV_H */
241