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 static const struct fixed31_32 dc_fixpt_pi = { 13493037705LL };
73 static const struct fixed31_32 dc_fixpt_two_pi = { 26986075409LL };
74 static const struct fixed31_32 dc_fixpt_e = { 11674931555LL };
75 static const struct fixed31_32 dc_fixpt_ln2 = { 2977044471LL };
76 static const struct fixed31_32 dc_fixpt_ln2_div_2 = { 1488522236LL };
77 
78 /*
79  * @brief
80  * Initialization routines
81  */
82 
83 /*
84  * @brief
85  * result = numerator / denominator
86  */
87 struct fixed31_32 dc_fixpt_from_fraction(long long numerator, long long denominator);
88 
89 /*
90  * @brief
91  * result = arg
92  */
93 static inline struct fixed31_32 dc_fixpt_from_int(int arg)
94 {
95 	struct fixed31_32 res;
96 
97 	res.value = (long long) arg << FIXED31_32_BITS_PER_FRACTIONAL_PART;
98 
99 	return res;
100 }
101 
102 /*
103  * @brief
104  * Unary operators
105  */
106 
107 /*
108  * @brief
109  * result = -arg
110  */
111 static inline struct fixed31_32 dc_fixpt_neg(struct fixed31_32 arg)
112 {
113 	struct fixed31_32 res;
114 
115 	res.value = -arg.value;
116 
117 	return res;
118 }
119 
120 /*
121  * @brief
122  * result = abs(arg) := (arg >= 0) ? arg : -arg
123  */
124 static inline struct fixed31_32 dc_fixpt_abs(struct fixed31_32 arg)
125 {
126 	if (arg.value < 0)
127 		return dc_fixpt_neg(arg);
128 	else
129 		return arg;
130 }
131 
132 /*
133  * @brief
134  * Binary relational operators
135  */
136 
137 /*
138  * @brief
139  * result = arg1 < arg2
140  */
141 static inline bool dc_fixpt_lt(struct fixed31_32 arg1, struct fixed31_32 arg2)
142 {
143 	return arg1.value < arg2.value;
144 }
145 
146 /*
147  * @brief
148  * result = arg1 <= arg2
149  */
150 static inline bool dc_fixpt_le(struct fixed31_32 arg1, struct fixed31_32 arg2)
151 {
152 	return arg1.value <= arg2.value;
153 }
154 
155 /*
156  * @brief
157  * result = arg1 == arg2
158  */
159 static inline bool dc_fixpt_eq(struct fixed31_32 arg1, struct fixed31_32 arg2)
160 {
161 	return arg1.value == arg2.value;
162 }
163 
164 /*
165  * @brief
166  * result = min(arg1, arg2) := (arg1 <= arg2) ? arg1 : arg2
167  */
168 static inline struct fixed31_32 dc_fixpt_min(struct fixed31_32 arg1, struct fixed31_32 arg2)
169 {
170 	if (arg1.value <= arg2.value)
171 		return arg1;
172 	else
173 		return arg2;
174 }
175 
176 /*
177  * @brief
178  * result = max(arg1, arg2) := (arg1 <= arg2) ? arg2 : arg1
179  */
180 static inline struct fixed31_32 dc_fixpt_max(struct fixed31_32 arg1, struct fixed31_32 arg2)
181 {
182 	if (arg1.value <= arg2.value)
183 		return arg2;
184 	else
185 		return arg1;
186 }
187 
188 /*
189  * @brief
190  *          | min_value, when arg <= min_value
191  * result = | arg, when min_value < arg < max_value
192  *          | max_value, when arg >= max_value
193  */
194 static inline struct fixed31_32 dc_fixpt_clamp(
195 	struct fixed31_32 arg,
196 	struct fixed31_32 min_value,
197 	struct fixed31_32 max_value)
198 {
199 	if (dc_fixpt_le(arg, min_value))
200 		return min_value;
201 	else if (dc_fixpt_le(max_value, arg))
202 		return max_value;
203 	else
204 		return arg;
205 }
206 
207 /*
208  * @brief
209  * Binary shift operators
210  */
211 
212 /*
213  * @brief
214  * result = arg << shift
215  */
216 static inline struct fixed31_32 dc_fixpt_shl(struct fixed31_32 arg, unsigned char shift)
217 {
218 	ASSERT(((arg.value >= 0) && (arg.value <= LLONG_MAX >> shift)) ||
219 		((arg.value < 0) && (arg.value >= ~(LLONG_MAX >> shift))));
220 
221 	arg.value = arg.value << shift;
222 
223 	return arg;
224 }
225 
226 /*
227  * @brief
228  * result = arg >> shift
229  */
230 static inline struct fixed31_32 dc_fixpt_shr(struct fixed31_32 arg, unsigned char shift)
231 {
232 	bool negative = arg.value < 0;
233 
234 	if (negative)
235 		arg.value = -arg.value;
236 	arg.value = arg.value >> shift;
237 	if (negative)
238 		arg.value = -arg.value;
239 	return arg;
240 }
241 
242 /*
243  * @brief
244  * Binary additive operators
245  */
246 
247 /*
248  * @brief
249  * result = arg1 + arg2
250  */
251 static inline struct fixed31_32 dc_fixpt_add(struct fixed31_32 arg1, struct fixed31_32 arg2)
252 {
253 	struct fixed31_32 res;
254 
255 	ASSERT(((arg1.value >= 0) && (LLONG_MAX - arg1.value >= arg2.value)) ||
256 		((arg1.value < 0) && (LLONG_MIN - arg1.value <= arg2.value)));
257 
258 	res.value = arg1.value + arg2.value;
259 
260 	return res;
261 }
262 
263 /*
264  * @brief
265  * result = arg1 + arg2
266  */
267 static inline struct fixed31_32 dc_fixpt_add_int(struct fixed31_32 arg1, int arg2)
268 {
269 	return dc_fixpt_add(arg1, dc_fixpt_from_int(arg2));
270 }
271 
272 /*
273  * @brief
274  * result = arg1 - arg2
275  */
276 static inline struct fixed31_32 dc_fixpt_sub(struct fixed31_32 arg1, struct fixed31_32 arg2)
277 {
278 	struct fixed31_32 res;
279 
280 	ASSERT(((arg2.value >= 0) && (LLONG_MIN + arg2.value <= arg1.value)) ||
281 		((arg2.value < 0) && (LLONG_MAX + arg2.value >= arg1.value)));
282 
283 	res.value = arg1.value - arg2.value;
284 
285 	return res;
286 }
287 
288 /*
289  * @brief
290  * result = arg1 - arg2
291  */
292 static inline struct fixed31_32 dc_fixpt_sub_int(struct fixed31_32 arg1, int arg2)
293 {
294 	return dc_fixpt_sub(arg1, dc_fixpt_from_int(arg2));
295 }
296 
297 
298 /*
299  * @brief
300  * Binary multiplicative operators
301  */
302 
303 /*
304  * @brief
305  * result = arg1 * arg2
306  */
307 struct fixed31_32 dc_fixpt_mul(struct fixed31_32 arg1, struct fixed31_32 arg2);
308 
309 
310 /*
311  * @brief
312  * result = arg1 * arg2
313  */
314 static inline struct fixed31_32 dc_fixpt_mul_int(struct fixed31_32 arg1, int arg2)
315 {
316 	return dc_fixpt_mul(arg1, dc_fixpt_from_int(arg2));
317 }
318 
319 /*
320  * @brief
321  * result = square(arg) := arg * arg
322  */
323 struct fixed31_32 dc_fixpt_sqr(struct fixed31_32 arg);
324 
325 /*
326  * @brief
327  * result = arg1 / arg2
328  */
329 static inline struct fixed31_32 dc_fixpt_div_int(struct fixed31_32 arg1, long long arg2)
330 {
331 	return dc_fixpt_from_fraction(arg1.value, dc_fixpt_from_int(arg2).value);
332 }
333 
334 /*
335  * @brief
336  * result = arg1 / arg2
337  */
338 static inline struct fixed31_32 dc_fixpt_div(struct fixed31_32 arg1, struct fixed31_32 arg2)
339 {
340 	return dc_fixpt_from_fraction(arg1.value, arg2.value);
341 }
342 
343 /*
344  * @brief
345  * Reciprocal function
346  */
347 
348 /*
349  * @brief
350  * result = reciprocal(arg) := 1 / arg
351  *
352  * @note
353  * No special actions taken in case argument is zero.
354  */
355 struct fixed31_32 dc_fixpt_recip(struct fixed31_32 arg);
356 
357 /*
358  * @brief
359  * Trigonometric functions
360  */
361 
362 /*
363  * @brief
364  * result = sinc(arg) := sin(arg) / arg
365  *
366  * @note
367  * Argument specified in radians,
368  * internally it's normalized to [-2pi...2pi] range.
369  */
370 struct fixed31_32 dc_fixpt_sinc(struct fixed31_32 arg);
371 
372 /*
373  * @brief
374  * result = sin(arg)
375  *
376  * @note
377  * Argument specified in radians,
378  * internally it's normalized to [-2pi...2pi] range.
379  */
380 struct fixed31_32 dc_fixpt_sin(struct fixed31_32 arg);
381 
382 /*
383  * @brief
384  * result = cos(arg)
385  *
386  * @note
387  * Argument specified in radians
388  * and should be in [-2pi...2pi] range -
389  * passing arguments outside that range
390  * will cause incorrect result!
391  */
392 struct fixed31_32 dc_fixpt_cos(struct fixed31_32 arg);
393 
394 /*
395  * @brief
396  * Transcendent functions
397  */
398 
399 /*
400  * @brief
401  * result = exp(arg)
402  *
403  * @note
404  * Currently, function is verified for abs(arg) <= 1.
405  */
406 struct fixed31_32 dc_fixpt_exp(struct fixed31_32 arg);
407 
408 /*
409  * @brief
410  * result = log(arg)
411  *
412  * @note
413  * Currently, abs(arg) should be less than 1.
414  * No normalization is done.
415  * Currently, no special actions taken
416  * in case of invalid argument(s). Take care!
417  */
418 struct fixed31_32 dc_fixpt_log(struct fixed31_32 arg);
419 
420 /*
421  * @brief
422  * Power function
423  */
424 
425 /*
426  * @brief
427  * result = pow(arg1, arg2)
428  *
429  * @note
430  * Currently, abs(arg1) should be less than 1. Take care!
431  */
432 static inline struct fixed31_32 dc_fixpt_pow(struct fixed31_32 arg1, struct fixed31_32 arg2)
433 {
434 	return dc_fixpt_exp(
435 		dc_fixpt_mul(
436 			dc_fixpt_log(arg1),
437 			arg2));
438 }
439 
440 /*
441  * @brief
442  * Rounding functions
443  */
444 
445 /*
446  * @brief
447  * result = floor(arg) := greatest integer lower than or equal to arg
448  */
449 static inline int dc_fixpt_floor(struct fixed31_32 arg)
450 {
451 	unsigned long long arg_value = arg.value > 0 ? arg.value : -arg.value;
452 
453 	if (arg.value >= 0)
454 		return (int)(arg_value >> FIXED31_32_BITS_PER_FRACTIONAL_PART);
455 	else
456 		return -(int)(arg_value >> FIXED31_32_BITS_PER_FRACTIONAL_PART);
457 }
458 
459 /*
460  * @brief
461  * result = round(arg) := integer nearest to arg
462  */
463 static inline int dc_fixpt_round(struct fixed31_32 arg)
464 {
465 	unsigned long long arg_value = arg.value > 0 ? arg.value : -arg.value;
466 
467 	const long long summand = dc_fixpt_half.value;
468 
469 	ASSERT(LLONG_MAX - (long long)arg_value >= summand);
470 
471 	arg_value += summand;
472 
473 	if (arg.value >= 0)
474 		return (int)(arg_value >> FIXED31_32_BITS_PER_FRACTIONAL_PART);
475 	else
476 		return -(int)(arg_value >> FIXED31_32_BITS_PER_FRACTIONAL_PART);
477 }
478 
479 /*
480  * @brief
481  * result = ceil(arg) := lowest integer greater than or equal to arg
482  */
483 static inline int dc_fixpt_ceil(struct fixed31_32 arg)
484 {
485 	unsigned long long arg_value = arg.value > 0 ? arg.value : -arg.value;
486 
487 	const long long summand = dc_fixpt_one.value -
488 		dc_fixpt_epsilon.value;
489 
490 	ASSERT(LLONG_MAX - (long long)arg_value >= summand);
491 
492 	arg_value += summand;
493 
494 	if (arg.value >= 0)
495 		return (int)(arg_value >> FIXED31_32_BITS_PER_FRACTIONAL_PART);
496 	else
497 		return -(int)(arg_value >> FIXED31_32_BITS_PER_FRACTIONAL_PART);
498 }
499 
500 /* the following two function are used in scaler hw programming to convert fixed
501  * point value to format 2 bits from integer part and 19 bits from fractional
502  * part. The same applies for u0d19, 0 bits from integer part and 19 bits from
503  * fractional
504  */
505 
506 unsigned int dc_fixpt_u4d19(struct fixed31_32 arg);
507 
508 unsigned int dc_fixpt_u3d19(struct fixed31_32 arg);
509 
510 unsigned int dc_fixpt_u2d19(struct fixed31_32 arg);
511 
512 unsigned int dc_fixpt_u0d19(struct fixed31_32 arg);
513 
514 unsigned int dc_fixpt_clamp_u0d14(struct fixed31_32 arg);
515 
516 unsigned int dc_fixpt_clamp_u0d10(struct fixed31_32 arg);
517 
518 int dc_fixpt_s4d19(struct fixed31_32 arg);
519 
520 static inline struct fixed31_32 dc_fixpt_truncate(struct fixed31_32 arg, unsigned int frac_bits)
521 {
522 	bool negative = arg.value < 0;
523 
524 	if (frac_bits >= FIXED31_32_BITS_PER_FRACTIONAL_PART) {
525 		ASSERT(frac_bits == FIXED31_32_BITS_PER_FRACTIONAL_PART);
526 		return arg;
527 	}
528 
529 	if (negative)
530 		arg.value = -arg.value;
531 	arg.value &= (~0LL) << (FIXED31_32_BITS_PER_FRACTIONAL_PART - frac_bits);
532 	if (negative)
533 		arg.value = -arg.value;
534 	return arg;
535 }
536 
537 #endif
538