Commit | Line | Data |
---|---|---|
4562236b HW |
1 | /* |
2 | * Copyright 2012-15 Advanced Micro Devices, Inc. | |
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 shall be included in | |
12 | * all copies or substantial portions of the Software. | |
13 | * | |
14 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
15 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
16 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
17 | * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR | |
18 | * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, | |
19 | * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR | |
20 | * OTHER DEALINGS IN THE SOFTWARE. | |
21 | * | |
22 | * Authors: AMD | |
23 | * | |
24 | */ | |
25 | ||
26 | #ifndef __DAL_FIXED31_32_H__ | |
27 | #define __DAL_FIXED31_32_H__ | |
28 | ||
8de94233 RA |
29 | #ifndef LLONG_MAX |
30 | #define LLONG_MAX 9223372036854775807ll | |
31 | #endif | |
32 | #ifndef LLONG_MIN | |
33 | #define LLONG_MIN (-LLONG_MAX - 1ll) | |
34 | #endif | |
35 | ||
c233e91b | 36 | #define FIXED31_32_BITS_PER_FRACTIONAL_PART 32 |
a21ddec6 DL |
37 | #ifndef LLONG_MIN |
38 | #define LLONG_MIN (1LL<<63) | |
39 | #endif | |
40 | #ifndef LLONG_MAX | |
41 | #define LLONG_MAX (-1LL>>1) | |
42 | #endif | |
c233e91b | 43 | |
4562236b HW |
44 | /* |
45 | * @brief | |
46 | * Arithmetic operations on real numbers | |
47 | * represented as fixed-point numbers. | |
48 | * There are: 1 bit for sign, | |
49 | * 31 bit for integer part, | |
50 | * 32 bits for fractional part. | |
51 | * | |
52 | * @note | |
53 | * Currently, overflows and underflows are asserted; | |
54 | * no special result returned. | |
55 | */ | |
56 | ||
57 | struct fixed31_32 { | |
5c616116 | 58 | long long value; |
4562236b HW |
59 | }; |
60 | ||
a21ddec6 | 61 | |
4562236b HW |
62 | /* |
63 | * @brief | |
64 | * Useful constants | |
65 | */ | |
66 | ||
eb0e5154 DL |
67 | static const struct fixed31_32 dc_fixpt_zero = { 0 }; |
68 | static const struct fixed31_32 dc_fixpt_epsilon = { 1LL }; | |
69 | static const struct fixed31_32 dc_fixpt_half = { 0x80000000LL }; | |
70 | static const struct fixed31_32 dc_fixpt_one = { 0x100000000LL }; | |
4562236b HW |
71 | |
72 | /* | |
73 | * @brief | |
74 | * Initialization routines | |
75 | */ | |
76 | ||
77 | /* | |
78 | * @brief | |
79 | * result = numerator / denominator | |
80 | */ | |
f3ba7a2f | 81 | struct fixed31_32 dc_fixpt_from_fraction(long long numerator, long long denominator); |
4562236b HW |
82 | |
83 | /* | |
84 | * @brief | |
85 | * result = arg | |
86 | */ | |
f3ba7a2f | 87 | static inline struct fixed31_32 dc_fixpt_from_int(int arg) |
c233e91b | 88 | { |
f3ba7a2f DL |
89 | struct fixed31_32 res; |
90 | ||
91 | res.value = (long long) arg << FIXED31_32_BITS_PER_FRACTIONAL_PART; | |
92 | ||
93 | return res; | |
c233e91b | 94 | } |
4562236b HW |
95 | |
96 | /* | |
97 | * @brief | |
98 | * Unary operators | |
99 | */ | |
100 | ||
101 | /* | |
102 | * @brief | |
103 | * result = -arg | |
104 | */ | |
eb0e5154 | 105 | static inline struct fixed31_32 dc_fixpt_neg(struct fixed31_32 arg) |
204de25f DA |
106 | { |
107 | struct fixed31_32 res; | |
108 | ||
109 | res.value = -arg.value; | |
110 | ||
111 | return res; | |
112 | } | |
4562236b HW |
113 | |
114 | /* | |
115 | * @brief | |
116 | * result = abs(arg) := (arg >= 0) ? arg : -arg | |
117 | */ | |
eb0e5154 | 118 | static inline struct fixed31_32 dc_fixpt_abs(struct fixed31_32 arg) |
204de25f DA |
119 | { |
120 | if (arg.value < 0) | |
eb0e5154 | 121 | return dc_fixpt_neg(arg); |
204de25f DA |
122 | else |
123 | return arg; | |
124 | } | |
4562236b HW |
125 | |
126 | /* | |
127 | * @brief | |
128 | * Binary relational operators | |
129 | */ | |
130 | ||
131 | /* | |
132 | * @brief | |
133 | * result = arg1 < arg2 | |
134 | */ | |
f3ba7a2f | 135 | static inline bool dc_fixpt_lt(struct fixed31_32 arg1, struct fixed31_32 arg2) |
204de25f DA |
136 | { |
137 | return arg1.value < arg2.value; | |
138 | } | |
4562236b HW |
139 | |
140 | /* | |
141 | * @brief | |
142 | * result = arg1 <= arg2 | |
143 | */ | |
f3ba7a2f | 144 | static inline bool dc_fixpt_le(struct fixed31_32 arg1, struct fixed31_32 arg2) |
204de25f DA |
145 | { |
146 | return arg1.value <= arg2.value; | |
147 | } | |
4562236b HW |
148 | |
149 | /* | |
150 | * @brief | |
151 | * result = arg1 == arg2 | |
152 | */ | |
f3ba7a2f | 153 | static inline bool dc_fixpt_eq(struct fixed31_32 arg1, struct fixed31_32 arg2) |
204de25f DA |
154 | { |
155 | return arg1.value == arg2.value; | |
156 | } | |
4562236b HW |
157 | |
158 | /* | |
159 | * @brief | |
160 | * result = min(arg1, arg2) := (arg1 <= arg2) ? arg1 : arg2 | |
161 | */ | |
f3ba7a2f | 162 | static inline struct fixed31_32 dc_fixpt_min(struct fixed31_32 arg1, struct fixed31_32 arg2) |
204de25f DA |
163 | { |
164 | if (arg1.value <= arg2.value) | |
165 | return arg1; | |
166 | else | |
167 | return arg2; | |
168 | } | |
4562236b HW |
169 | |
170 | /* | |
171 | * @brief | |
172 | * result = max(arg1, arg2) := (arg1 <= arg2) ? arg2 : arg1 | |
173 | */ | |
f3ba7a2f | 174 | static inline struct fixed31_32 dc_fixpt_max(struct fixed31_32 arg1, struct fixed31_32 arg2) |
204de25f DA |
175 | { |
176 | if (arg1.value <= arg2.value) | |
177 | return arg2; | |
178 | else | |
179 | return arg1; | |
180 | } | |
4562236b HW |
181 | |
182 | /* | |
183 | * @brief | |
184 | * | min_value, when arg <= min_value | |
185 | * result = | arg, when min_value < arg < max_value | |
186 | * | max_value, when arg >= max_value | |
187 | */ | |
eb0e5154 | 188 | static inline struct fixed31_32 dc_fixpt_clamp( |
4562236b HW |
189 | struct fixed31_32 arg, |
190 | struct fixed31_32 min_value, | |
204de25f DA |
191 | struct fixed31_32 max_value) |
192 | { | |
eb0e5154 | 193 | if (dc_fixpt_le(arg, min_value)) |
204de25f | 194 | return min_value; |
eb0e5154 | 195 | else if (dc_fixpt_le(max_value, arg)) |
204de25f DA |
196 | return max_value; |
197 | else | |
198 | return arg; | |
199 | } | |
4562236b HW |
200 | |
201 | /* | |
202 | * @brief | |
203 | * Binary shift operators | |
204 | */ | |
205 | ||
206 | /* | |
207 | * @brief | |
208 | * result = arg << shift | |
209 | */ | |
f3ba7a2f DL |
210 | static inline struct fixed31_32 dc_fixpt_shl(struct fixed31_32 arg, unsigned char shift) |
211 | { | |
f3ba7a2f | 212 | ASSERT(((arg.value >= 0) && (arg.value <= LLONG_MAX >> shift)) || |
b8f3439f | 213 | ((arg.value < 0) && (arg.value >= ~(LLONG_MAX >> shift)))); |
f3ba7a2f | 214 | |
a21ddec6 | 215 | arg.value = arg.value << shift; |
f3ba7a2f | 216 | |
a21ddec6 | 217 | return arg; |
f3ba7a2f | 218 | } |
4562236b HW |
219 | |
220 | /* | |
221 | * @brief | |
222 | * result = arg >> shift | |
223 | */ | |
f3ba7a2f | 224 | static inline struct fixed31_32 dc_fixpt_shr(struct fixed31_32 arg, unsigned char shift) |
204de25f | 225 | { |
a21ddec6 DL |
226 | bool negative = arg.value < 0; |
227 | ||
228 | if (negative) | |
229 | arg.value = -arg.value; | |
230 | arg.value = arg.value >> shift; | |
231 | if (negative) | |
232 | arg.value = -arg.value; | |
233 | return arg; | |
204de25f | 234 | } |
4562236b HW |
235 | |
236 | /* | |
237 | * @brief | |
238 | * Binary additive operators | |
239 | */ | |
240 | ||
241 | /* | |
242 | * @brief | |
243 | * result = arg1 + arg2 | |
244 | */ | |
f3ba7a2f DL |
245 | static inline struct fixed31_32 dc_fixpt_add(struct fixed31_32 arg1, struct fixed31_32 arg2) |
246 | { | |
247 | struct fixed31_32 res; | |
248 | ||
249 | ASSERT(((arg1.value >= 0) && (LLONG_MAX - arg1.value >= arg2.value)) || | |
250 | ((arg1.value < 0) && (LLONG_MIN - arg1.value <= arg2.value))); | |
251 | ||
252 | res.value = arg1.value + arg2.value; | |
253 | ||
254 | return res; | |
255 | } | |
4562236b | 256 | |
fcd2f4bf AZ |
257 | /* |
258 | * @brief | |
259 | * result = arg1 + arg2 | |
260 | */ | |
f3ba7a2f | 261 | static inline struct fixed31_32 dc_fixpt_add_int(struct fixed31_32 arg1, int arg2) |
204de25f | 262 | { |
f3ba7a2f | 263 | return dc_fixpt_add(arg1, dc_fixpt_from_int(arg2)); |
204de25f | 264 | } |
fcd2f4bf | 265 | |
4562236b HW |
266 | /* |
267 | * @brief | |
268 | * result = arg1 - arg2 | |
269 | */ | |
f3ba7a2f DL |
270 | static inline struct fixed31_32 dc_fixpt_sub(struct fixed31_32 arg1, struct fixed31_32 arg2) |
271 | { | |
272 | struct fixed31_32 res; | |
273 | ||
274 | ASSERT(((arg2.value >= 0) && (LLONG_MIN + arg2.value <= arg1.value)) || | |
275 | ((arg2.value < 0) && (LLONG_MAX + arg2.value >= arg1.value))); | |
276 | ||
277 | res.value = arg1.value - arg2.value; | |
278 | ||
279 | return res; | |
280 | } | |
4562236b HW |
281 | |
282 | /* | |
283 | * @brief | |
284 | * result = arg1 - arg2 | |
285 | */ | |
f3ba7a2f | 286 | static inline struct fixed31_32 dc_fixpt_sub_int(struct fixed31_32 arg1, int arg2) |
204de25f | 287 | { |
f3ba7a2f | 288 | return dc_fixpt_sub(arg1, dc_fixpt_from_int(arg2)); |
204de25f DA |
289 | } |
290 | ||
4562236b HW |
291 | |
292 | /* | |
293 | * @brief | |
294 | * Binary multiplicative operators | |
295 | */ | |
296 | ||
297 | /* | |
298 | * @brief | |
299 | * result = arg1 * arg2 | |
300 | */ | |
f3ba7a2f | 301 | struct fixed31_32 dc_fixpt_mul(struct fixed31_32 arg1, struct fixed31_32 arg2); |
204de25f | 302 | |
4562236b HW |
303 | |
304 | /* | |
305 | * @brief | |
306 | * result = arg1 * arg2 | |
307 | */ | |
f3ba7a2f | 308 | static inline struct fixed31_32 dc_fixpt_mul_int(struct fixed31_32 arg1, int arg2) |
204de25f | 309 | { |
f3ba7a2f | 310 | return dc_fixpt_mul(arg1, dc_fixpt_from_int(arg2)); |
204de25f | 311 | } |
4562236b HW |
312 | |
313 | /* | |
314 | * @brief | |
315 | * result = square(arg) := arg * arg | |
316 | */ | |
f3ba7a2f | 317 | struct fixed31_32 dc_fixpt_sqr(struct fixed31_32 arg); |
4562236b HW |
318 | |
319 | /* | |
320 | * @brief | |
321 | * result = arg1 / arg2 | |
322 | */ | |
f3ba7a2f | 323 | static inline struct fixed31_32 dc_fixpt_div_int(struct fixed31_32 arg1, long long arg2) |
bd6d1576 | 324 | { |
5d763a99 | 325 | return dc_fixpt_from_fraction(arg1.value, dc_fixpt_from_int((int)arg2).value); |
bd6d1576 | 326 | } |
4562236b HW |
327 | |
328 | /* | |
329 | * @brief | |
330 | * result = arg1 / arg2 | |
331 | */ | |
f3ba7a2f | 332 | static inline struct fixed31_32 dc_fixpt_div(struct fixed31_32 arg1, struct fixed31_32 arg2) |
204de25f | 333 | { |
f3ba7a2f | 334 | return dc_fixpt_from_fraction(arg1.value, arg2.value); |
204de25f | 335 | } |
4562236b HW |
336 | |
337 | /* | |
338 | * @brief | |
339 | * Reciprocal function | |
340 | */ | |
341 | ||
342 | /* | |
343 | * @brief | |
344 | * result = reciprocal(arg) := 1 / arg | |
345 | * | |
346 | * @note | |
347 | * No special actions taken in case argument is zero. | |
348 | */ | |
f3ba7a2f | 349 | struct fixed31_32 dc_fixpt_recip(struct fixed31_32 arg); |
4562236b HW |
350 | |
351 | /* | |
352 | * @brief | |
353 | * Trigonometric functions | |
354 | */ | |
355 | ||
356 | /* | |
357 | * @brief | |
358 | * result = sinc(arg) := sin(arg) / arg | |
359 | * | |
360 | * @note | |
361 | * Argument specified in radians, | |
362 | * internally it's normalized to [-2pi...2pi] range. | |
363 | */ | |
f3ba7a2f | 364 | struct fixed31_32 dc_fixpt_sinc(struct fixed31_32 arg); |
4562236b HW |
365 | |
366 | /* | |
367 | * @brief | |
368 | * result = sin(arg) | |
369 | * | |
370 | * @note | |
371 | * Argument specified in radians, | |
372 | * internally it's normalized to [-2pi...2pi] range. | |
373 | */ | |
f3ba7a2f | 374 | struct fixed31_32 dc_fixpt_sin(struct fixed31_32 arg); |
4562236b HW |
375 | |
376 | /* | |
377 | * @brief | |
378 | * result = cos(arg) | |
379 | * | |
380 | * @note | |
381 | * Argument specified in radians | |
382 | * and should be in [-2pi...2pi] range - | |
383 | * passing arguments outside that range | |
384 | * will cause incorrect result! | |
385 | */ | |
f3ba7a2f | 386 | struct fixed31_32 dc_fixpt_cos(struct fixed31_32 arg); |
4562236b HW |
387 | |
388 | /* | |
389 | * @brief | |
390 | * Transcendent functions | |
391 | */ | |
392 | ||
393 | /* | |
394 | * @brief | |
395 | * result = exp(arg) | |
396 | * | |
397 | * @note | |
398 | * Currently, function is verified for abs(arg) <= 1. | |
399 | */ | |
f3ba7a2f | 400 | struct fixed31_32 dc_fixpt_exp(struct fixed31_32 arg); |
4562236b HW |
401 | |
402 | /* | |
403 | * @brief | |
404 | * result = log(arg) | |
405 | * | |
406 | * @note | |
407 | * Currently, abs(arg) should be less than 1. | |
408 | * No normalization is done. | |
409 | * Currently, no special actions taken | |
410 | * in case of invalid argument(s). Take care! | |
411 | */ | |
f3ba7a2f | 412 | struct fixed31_32 dc_fixpt_log(struct fixed31_32 arg); |
4562236b HW |
413 | |
414 | /* | |
415 | * @brief | |
416 | * Power function | |
417 | */ | |
418 | ||
419 | /* | |
420 | * @brief | |
421 | * result = pow(arg1, arg2) | |
422 | * | |
423 | * @note | |
424 | * Currently, abs(arg1) should be less than 1. Take care! | |
425 | */ | |
f3ba7a2f DL |
426 | static inline struct fixed31_32 dc_fixpt_pow(struct fixed31_32 arg1, struct fixed31_32 arg2) |
427 | { | |
d2e59d0f KK |
428 | if (arg1.value == 0) |
429 | return arg2.value == 0 ? dc_fixpt_one : dc_fixpt_zero; | |
430 | ||
f3ba7a2f DL |
431 | return dc_fixpt_exp( |
432 | dc_fixpt_mul( | |
433 | dc_fixpt_log(arg1), | |
434 | arg2)); | |
435 | } | |
4562236b HW |
436 | |
437 | /* | |
438 | * @brief | |
439 | * Rounding functions | |
440 | */ | |
441 | ||
442 | /* | |
443 | * @brief | |
444 | * result = floor(arg) := greatest integer lower than or equal to arg | |
445 | */ | |
f3ba7a2f DL |
446 | static inline int dc_fixpt_floor(struct fixed31_32 arg) |
447 | { | |
448 | unsigned long long arg_value = arg.value > 0 ? arg.value : -arg.value; | |
449 | ||
450 | if (arg.value >= 0) | |
451 | return (int)(arg_value >> FIXED31_32_BITS_PER_FRACTIONAL_PART); | |
452 | else | |
453 | return -(int)(arg_value >> FIXED31_32_BITS_PER_FRACTIONAL_PART); | |
454 | } | |
4562236b HW |
455 | |
456 | /* | |
457 | * @brief | |
458 | * result = round(arg) := integer nearest to arg | |
459 | */ | |
f3ba7a2f DL |
460 | static inline int dc_fixpt_round(struct fixed31_32 arg) |
461 | { | |
462 | unsigned long long arg_value = arg.value > 0 ? arg.value : -arg.value; | |
463 | ||
464 | const long long summand = dc_fixpt_half.value; | |
465 | ||
466 | ASSERT(LLONG_MAX - (long long)arg_value >= summand); | |
467 | ||
468 | arg_value += summand; | |
469 | ||
470 | if (arg.value >= 0) | |
471 | return (int)(arg_value >> FIXED31_32_BITS_PER_FRACTIONAL_PART); | |
472 | else | |
473 | return -(int)(arg_value >> FIXED31_32_BITS_PER_FRACTIONAL_PART); | |
474 | } | |
4562236b HW |
475 | |
476 | /* | |
477 | * @brief | |
478 | * result = ceil(arg) := lowest integer greater than or equal to arg | |
479 | */ | |
f3ba7a2f DL |
480 | static inline int dc_fixpt_ceil(struct fixed31_32 arg) |
481 | { | |
482 | unsigned long long arg_value = arg.value > 0 ? arg.value : -arg.value; | |
483 | ||
484 | const long long summand = dc_fixpt_one.value - | |
485 | dc_fixpt_epsilon.value; | |
486 | ||
487 | ASSERT(LLONG_MAX - (long long)arg_value >= summand); | |
488 | ||
489 | arg_value += summand; | |
490 | ||
491 | if (arg.value >= 0) | |
492 | return (int)(arg_value >> FIXED31_32_BITS_PER_FRACTIONAL_PART); | |
493 | else | |
494 | return -(int)(arg_value >> FIXED31_32_BITS_PER_FRACTIONAL_PART); | |
495 | } | |
4562236b HW |
496 | |
497 | /* the following two function are used in scaler hw programming to convert fixed | |
498 | * point value to format 2 bits from integer part and 19 bits from fractional | |
499 | * part. The same applies for u0d19, 0 bits from integer part and 19 bits from | |
500 | * fractional | |
501 | */ | |
502 | ||
7cef6a12 TD |
503 | unsigned int dc_fixpt_u4d19(struct fixed31_32 arg); |
504 | ||
0b19fdc4 DL |
505 | unsigned int dc_fixpt_u3d19(struct fixed31_32 arg); |
506 | ||
f3ba7a2f | 507 | unsigned int dc_fixpt_u2d19(struct fixed31_32 arg); |
4562236b | 508 | |
f3ba7a2f | 509 | unsigned int dc_fixpt_u0d19(struct fixed31_32 arg); |
b6295960 | 510 | |
f3ba7a2f | 511 | unsigned int dc_fixpt_clamp_u0d14(struct fixed31_32 arg); |
b6295960 | 512 | |
f3ba7a2f | 513 | unsigned int dc_fixpt_clamp_u0d10(struct fixed31_32 arg); |
b6295960 | 514 | |
f3ba7a2f | 515 | int dc_fixpt_s4d19(struct fixed31_32 arg); |
a6e59fa8 | 516 | |
ab9c2062 DL |
517 | static inline struct fixed31_32 dc_fixpt_truncate(struct fixed31_32 arg, unsigned int frac_bits) |
518 | { | |
519 | bool negative = arg.value < 0; | |
520 | ||
521 | if (frac_bits >= FIXED31_32_BITS_PER_FRACTIONAL_PART) { | |
522 | ASSERT(frac_bits == FIXED31_32_BITS_PER_FRACTIONAL_PART); | |
523 | return arg; | |
524 | } | |
525 | ||
526 | if (negative) | |
527 | arg.value = -arg.value; | |
28906628 | 528 | arg.value &= (~0ULL) << (FIXED31_32_BITS_PER_FRACTIONAL_PART - frac_bits); |
ab9c2062 DL |
529 | if (negative) |
530 | arg.value = -arg.value; | |
531 | return arg; | |
532 | } | |
533 | ||
4562236b | 534 | #endif |