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(arg, min_value))
194 		return min_value;
195 	else if (dc_fixpt_le(max_value, 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, dc_fixpt_from_int(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, dc_fixpt_from_int(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, dc_fixpt_from_int(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(arg1.value, dc_fixpt_from_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(arg1.value, 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 		dc_fixpt_mul(
433 			dc_fixpt_log(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 &= (~0LL) << (FIXED31_32_BITS_PER_FRACTIONAL_PART - frac_bits);
529 	if (negative)
530 		arg.value = -arg.value;
531 	return arg;
532 }
533 
534 #endif
535