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 */
dc_fixpt_from_int(int arg)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 */
dc_fixpt_neg(struct fixed31_32 arg)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 */
dc_fixpt_abs(struct fixed31_32 arg)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 */
dc_fixpt_lt(struct fixed31_32 arg1,struct fixed31_32 arg2)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 */
dc_fixpt_le(struct fixed31_32 arg1,struct fixed31_32 arg2)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 */
dc_fixpt_eq(struct fixed31_32 arg1,struct fixed31_32 arg2)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 */
dc_fixpt_min(struct fixed31_32 arg1,struct fixed31_32 arg2)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 */
dc_fixpt_max(struct fixed31_32 arg1,struct fixed31_32 arg2)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 */
dc_fixpt_clamp(struct fixed31_32 arg,struct fixed31_32 min_value,struct fixed31_32 max_value)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 */
dc_fixpt_shl(struct fixed31_32 arg,unsigned char shift)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 */
dc_fixpt_shr(struct fixed31_32 arg,unsigned char shift)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 */
dc_fixpt_add(struct fixed31_32 arg1,struct fixed31_32 arg2)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 */
dc_fixpt_add_int(struct fixed31_32 arg1,int arg2)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 */
dc_fixpt_sub(struct fixed31_32 arg1,struct fixed31_32 arg2)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 */
dc_fixpt_sub_int(struct fixed31_32 arg1,int arg2)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 */
dc_fixpt_mul_int(struct fixed31_32 arg1,int arg2)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 */
dc_fixpt_div_int(struct fixed31_32 arg1,long long arg2)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((int)arg2).value);
326 }
327
328 /*
329 * @brief
330 * result = arg1 / arg2
331 */
dc_fixpt_div(struct fixed31_32 arg1,struct fixed31_32 arg2)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 */
dc_fixpt_pow(struct fixed31_32 arg1,struct fixed31_32 arg2)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 */
dc_fixpt_floor(struct fixed31_32 arg)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 */
dc_fixpt_round(struct fixed31_32 arg)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 */
dc_fixpt_ceil(struct fixed31_32 arg)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
dc_fixpt_truncate(struct fixed31_32 arg,unsigned int frac_bits)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