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 | |
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 | |
36 | #define FIXED31_32_BITS_PER_FRACTIONAL_PART 32 |
37 | #ifndef LLONG_MIN |
38 | #define LLONG_MIN (1LL<<63) |
39 | #endif |
40 | #ifndef LLONG_MAX |
41 | #define LLONG_MAX (-1LL>>1) |
42 | #endif |
43 | |
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 { |
58 | long long value; |
59 | }; |
60 | |
61 | |
62 | /* |
63 | * @brief |
64 | * Useful constants |
65 | */ |
66 | |
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 }; |
71 | |
72 | /* |
73 | * @brief |
74 | * Initialization routines |
75 | */ |
76 | |
77 | /* |
78 | * @brief |
79 | * result = numerator / denominator |
80 | */ |
81 | struct fixed31_32 dc_fixpt_from_fraction(long long numerator, long long denominator); |
82 | |
83 | /* |
84 | * @brief |
85 | * result = arg |
86 | */ |
87 | static inline struct fixed31_32 dc_fixpt_from_int(int arg) |
88 | { |
89 | struct fixed31_32 res; |
90 | |
91 | res.value = (long long) arg << FIXED31_32_BITS_PER_FRACTIONAL_PART; |
92 | |
93 | return res; |
94 | } |
95 | |
96 | /* |
97 | * @brief |
98 | * Unary operators |
99 | */ |
100 | |
101 | /* |
102 | * @brief |
103 | * result = -arg |
104 | */ |
105 | static inline struct fixed31_32 dc_fixpt_neg(struct fixed31_32 arg) |
106 | { |
107 | struct fixed31_32 res; |
108 | |
109 | res.value = -arg.value; |
110 | |
111 | return res; |
112 | } |
113 | |
114 | /* |
115 | * @brief |
116 | * result = abs(arg) := (arg >= 0) ? arg : -arg |
117 | */ |
118 | static inline struct fixed31_32 dc_fixpt_abs(struct fixed31_32 arg) |
119 | { |
120 | if (arg.value < 0) |
121 | return dc_fixpt_neg(arg); |
122 | else |
123 | return arg; |
124 | } |
125 | |
126 | /* |
127 | * @brief |
128 | * Binary relational operators |
129 | */ |
130 | |
131 | /* |
132 | * @brief |
133 | * result = arg1 < arg2 |
134 | */ |
135 | static inline bool dc_fixpt_lt(struct fixed31_32 arg1, struct fixed31_32 arg2) |
136 | { |
137 | return arg1.value < arg2.value; |
138 | } |
139 | |
140 | /* |
141 | * @brief |
142 | * result = arg1 <= arg2 |
143 | */ |
144 | static inline bool dc_fixpt_le(struct fixed31_32 arg1, struct fixed31_32 arg2) |
145 | { |
146 | return arg1.value <= arg2.value; |
147 | } |
148 | |
149 | /* |
150 | * @brief |
151 | * result = arg1 == arg2 |
152 | */ |
153 | static inline bool dc_fixpt_eq(struct fixed31_32 arg1, struct fixed31_32 arg2) |
154 | { |
155 | return arg1.value == arg2.value; |
156 | } |
157 | |
158 | /* |
159 | * @brief |
160 | * result = min(arg1, arg2) := (arg1 <= arg2) ? arg1 : arg2 |
161 | */ |
162 | static inline struct fixed31_32 dc_fixpt_min(struct fixed31_32 arg1, struct fixed31_32 arg2) |
163 | { |
164 | if (arg1.value <= arg2.value) |
165 | return arg1; |
166 | else |
167 | return arg2; |
168 | } |
169 | |
170 | /* |
171 | * @brief |
172 | * result = max(arg1, arg2) := (arg1 <= arg2) ? arg2 : arg1 |
173 | */ |
174 | static inline struct fixed31_32 dc_fixpt_max(struct fixed31_32 arg1, struct fixed31_32 arg2) |
175 | { |
176 | if (arg1.value <= arg2.value) |
177 | return arg2; |
178 | else |
179 | return arg1; |
180 | } |
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 | */ |
188 | static inline struct fixed31_32 dc_fixpt_clamp( |
189 | struct fixed31_32 arg, |
190 | struct fixed31_32 min_value, |
191 | struct fixed31_32 max_value) |
192 | { |
193 | if (dc_fixpt_le(arg1: arg, arg2: min_value)) |
194 | return min_value; |
195 | else if (dc_fixpt_le(arg1: max_value, arg2: arg)) |
196 | return max_value; |
197 | else |
198 | return arg; |
199 | } |
200 | |
201 | /* |
202 | * @brief |
203 | * Binary shift operators |
204 | */ |
205 | |
206 | /* |
207 | * @brief |
208 | * result = arg << shift |
209 | */ |
210 | static inline struct fixed31_32 dc_fixpt_shl(struct fixed31_32 arg, unsigned char shift) |
211 | { |
212 | ASSERT(((arg.value >= 0) && (arg.value <= LLONG_MAX >> shift)) || |
213 | ((arg.value < 0) && (arg.value >= ~(LLONG_MAX >> shift)))); |
214 | |
215 | arg.value = arg.value << shift; |
216 | |
217 | return arg; |
218 | } |
219 | |
220 | /* |
221 | * @brief |
222 | * result = arg >> shift |
223 | */ |
224 | static inline struct fixed31_32 dc_fixpt_shr(struct fixed31_32 arg, unsigned char shift) |
225 | { |
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; |
234 | } |
235 | |
236 | /* |
237 | * @brief |
238 | * Binary additive operators |
239 | */ |
240 | |
241 | /* |
242 | * @brief |
243 | * result = arg1 + arg2 |
244 | */ |
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 | } |
256 | |
257 | /* |
258 | * @brief |
259 | * result = arg1 + arg2 |
260 | */ |
261 | static inline struct fixed31_32 dc_fixpt_add_int(struct fixed31_32 arg1, int arg2) |
262 | { |
263 | return dc_fixpt_add(arg1, arg2: dc_fixpt_from_int(arg: arg2)); |
264 | } |
265 | |
266 | /* |
267 | * @brief |
268 | * result = arg1 - arg2 |
269 | */ |
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 | } |
281 | |
282 | /* |
283 | * @brief |
284 | * result = arg1 - arg2 |
285 | */ |
286 | static inline struct fixed31_32 dc_fixpt_sub_int(struct fixed31_32 arg1, int arg2) |
287 | { |
288 | return dc_fixpt_sub(arg1, arg2: dc_fixpt_from_int(arg: arg2)); |
289 | } |
290 | |
291 | |
292 | /* |
293 | * @brief |
294 | * Binary multiplicative operators |
295 | */ |
296 | |
297 | /* |
298 | * @brief |
299 | * result = arg1 * arg2 |
300 | */ |
301 | struct fixed31_32 dc_fixpt_mul(struct fixed31_32 arg1, struct fixed31_32 arg2); |
302 | |
303 | |
304 | /* |
305 | * @brief |
306 | * result = arg1 * arg2 |
307 | */ |
308 | static inline struct fixed31_32 dc_fixpt_mul_int(struct fixed31_32 arg1, int arg2) |
309 | { |
310 | return dc_fixpt_mul(arg1, arg2: dc_fixpt_from_int(arg: arg2)); |
311 | } |
312 | |
313 | /* |
314 | * @brief |
315 | * result = square(arg) := arg * arg |
316 | */ |
317 | struct fixed31_32 dc_fixpt_sqr(struct fixed31_32 arg); |
318 | |
319 | /* |
320 | * @brief |
321 | * result = arg1 / arg2 |
322 | */ |
323 | static inline struct fixed31_32 dc_fixpt_div_int(struct fixed31_32 arg1, long long arg2) |
324 | { |
325 | return dc_fixpt_from_fraction(numerator: arg1.value, denominator: dc_fixpt_from_int(arg: (int)arg2).value); |
326 | } |
327 | |
328 | /* |
329 | * @brief |
330 | * result = arg1 / arg2 |
331 | */ |
332 | static inline struct fixed31_32 dc_fixpt_div(struct fixed31_32 arg1, struct fixed31_32 arg2) |
333 | { |
334 | return dc_fixpt_from_fraction(numerator: arg1.value, denominator: arg2.value); |
335 | } |
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 | */ |
349 | struct fixed31_32 dc_fixpt_recip(struct fixed31_32 arg); |
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 | */ |
364 | struct fixed31_32 dc_fixpt_sinc(struct fixed31_32 arg); |
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 | */ |
374 | struct fixed31_32 dc_fixpt_sin(struct fixed31_32 arg); |
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 | */ |
386 | struct fixed31_32 dc_fixpt_cos(struct fixed31_32 arg); |
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 | */ |
400 | struct fixed31_32 dc_fixpt_exp(struct fixed31_32 arg); |
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 | */ |
412 | struct fixed31_32 dc_fixpt_log(struct fixed31_32 arg); |
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 | */ |
426 | static inline struct fixed31_32 dc_fixpt_pow(struct fixed31_32 arg1, struct fixed31_32 arg2) |
427 | { |
428 | if (arg1.value == 0) |
429 | return arg2.value == 0 ? dc_fixpt_one : dc_fixpt_zero; |
430 | |
431 | return dc_fixpt_exp( |
432 | arg: dc_fixpt_mul( |
433 | arg1: dc_fixpt_log(arg: arg1), |
434 | arg2)); |
435 | } |
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 | */ |
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 | } |
455 | |
456 | /* |
457 | * @brief |
458 | * result = round(arg) := integer nearest to arg |
459 | */ |
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 | } |
475 | |
476 | /* |
477 | * @brief |
478 | * result = ceil(arg) := lowest integer greater than or equal to arg |
479 | */ |
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 | } |
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 | |
503 | unsigned int dc_fixpt_u4d19(struct fixed31_32 arg); |
504 | |
505 | unsigned int dc_fixpt_u3d19(struct fixed31_32 arg); |
506 | |
507 | unsigned int dc_fixpt_u2d19(struct fixed31_32 arg); |
508 | |
509 | unsigned int dc_fixpt_u0d19(struct fixed31_32 arg); |
510 | |
511 | unsigned int dc_fixpt_clamp_u0d14(struct fixed31_32 arg); |
512 | |
513 | unsigned int dc_fixpt_clamp_u0d10(struct fixed31_32 arg); |
514 | |
515 | int dc_fixpt_s4d19(struct fixed31_32 arg); |
516 | |
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; |
528 | arg.value &= (~0ULL) << (FIXED31_32_BITS_PER_FRACTIONAL_PART - frac_bits); |
529 | if (negative) |
530 | arg.value = -arg.value; |
531 | return arg; |
532 | } |
533 | |
534 | #endif |
535 | |