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#include "os_types.h"
 30
 31#define FIXED31_32_BITS_PER_FRACTIONAL_PART 32
 32
 33/*
 34 * @brief
 35 * Arithmetic operations on real numbers
 36 * represented as fixed-point numbers.
 37 * There are: 1 bit for sign,
 38 * 31 bit for integer part,
 39 * 32 bits for fractional part.
 40 *
 41 * @note
 42 * Currently, overflows and underflows are asserted;
 43 * no special result returned.
 44 */
 45
 46struct fixed31_32 {
 47	int64_t value;
 48};
 49
 50/*
 51 * @brief
 52 * Useful constants
 53 */
 54
 55static const struct fixed31_32 dal_fixed31_32_zero = { 0 };
 56static const struct fixed31_32 dal_fixed31_32_epsilon = { 1LL };
 57static const struct fixed31_32 dal_fixed31_32_half = { 0x80000000LL };
 58static const struct fixed31_32 dal_fixed31_32_one = { 0x100000000LL };
 59
 60static const struct fixed31_32 dal_fixed31_32_pi = { 13493037705LL };
 61static const struct fixed31_32 dal_fixed31_32_two_pi = { 26986075409LL };
 62static const struct fixed31_32 dal_fixed31_32_e = { 11674931555LL };
 63static const struct fixed31_32 dal_fixed31_32_ln2 = { 2977044471LL };
 64static const struct fixed31_32 dal_fixed31_32_ln2_div_2 = { 1488522236LL };
 65
 66/*
 67 * @brief
 68 * Initialization routines
 69 */
 70
 71/*
 72 * @brief
 73 * result = numerator / denominator
 74 */
 75struct fixed31_32 dal_fixed31_32_from_fraction(
 76	int64_t numerator,
 77	int64_t denominator);
 78
 79/*
 80 * @brief
 81 * result = arg
 82 */
 83struct fixed31_32 dal_fixed31_32_from_int_nonconst(int64_t arg);
 84static inline struct fixed31_32 dal_fixed31_32_from_int(int64_t arg)
 85{
 86	if (__builtin_constant_p(arg)) {
 87		struct fixed31_32 res;
 88		BUILD_BUG_ON((LONG_MIN > arg) || (arg > LONG_MAX));
 89		res.value = arg << FIXED31_32_BITS_PER_FRACTIONAL_PART;
 90		return res;
 91	} else
 92		return dal_fixed31_32_from_int_nonconst(arg);
 93}
 94
 95/*
 96 * @brief
 97 * Unary operators
 98 */
 99
100/*
101 * @brief
102 * result = -arg
103 */
104static inline struct fixed31_32 dal_fixed31_32_neg(struct fixed31_32 arg)
105{
106	struct fixed31_32 res;
107
108	res.value = -arg.value;
109
110	return res;
111}
112
113/*
114 * @brief
115 * result = abs(arg) := (arg >= 0) ? arg : -arg
116 */
117static inline struct fixed31_32 dal_fixed31_32_abs(struct fixed31_32 arg)
118{
119	if (arg.value < 0)
120		return dal_fixed31_32_neg(arg);
121	else
122		return arg;
123}
124
125/*
126 * @brief
127 * Binary relational operators
128 */
129
130/*
131 * @brief
132 * result = arg1 < arg2
133 */
134static inline bool dal_fixed31_32_lt(struct fixed31_32 arg1,
135				     struct fixed31_32 arg2)
136{
137	return arg1.value < arg2.value;
138}
139
140/*
141 * @brief
142 * result = arg1 <= arg2
143 */
144static inline bool dal_fixed31_32_le(struct fixed31_32 arg1,
145				     struct fixed31_32 arg2)
146{
147	return arg1.value <= arg2.value;
148}
149
150/*
151 * @brief
152 * result = arg1 == arg2
153 */
154static inline bool dal_fixed31_32_eq(struct fixed31_32 arg1,
155				     struct fixed31_32 arg2)
156{
157	return arg1.value == arg2.value;
158}
159
160/*
161 * @brief
162 * result = min(arg1, arg2) := (arg1 <= arg2) ? arg1 : arg2
163 */
164static inline struct fixed31_32 dal_fixed31_32_min(struct fixed31_32 arg1,
165						   struct fixed31_32 arg2)
166{
167	if (arg1.value <= arg2.value)
168		return arg1;
169	else
170		return arg2;
171}
172
173/*
174 * @brief
175 * result = max(arg1, arg2) := (arg1 <= arg2) ? arg2 : arg1
176 */
177static inline struct fixed31_32 dal_fixed31_32_max(struct fixed31_32 arg1,
178						   struct fixed31_32 arg2)
179{
180	if (arg1.value <= arg2.value)
181		return arg2;
182	else
183		return arg1;
184}
185
186/*
187 * @brief
188 *          | min_value, when arg <= min_value
189 * result = | arg, when min_value < arg < max_value
190 *          | max_value, when arg >= max_value
191 */
192static inline struct fixed31_32 dal_fixed31_32_clamp(
193	struct fixed31_32 arg,
194	struct fixed31_32 min_value,
195	struct fixed31_32 max_value)
196{
197	if (dal_fixed31_32_le(arg, min_value))
198		return min_value;
199	else if (dal_fixed31_32_le(max_value, arg))
200		return max_value;
201	else
202		return arg;
203}
204
205/*
206 * @brief
207 * Binary shift operators
208 */
209
210/*
211 * @brief
212 * result = arg << shift
213 */
214struct fixed31_32 dal_fixed31_32_shl(
215	struct fixed31_32 arg,
216	uint8_t shift);
217
218/*
219 * @brief
220 * result = arg >> shift
221 */
222static inline struct fixed31_32 dal_fixed31_32_shr(
223	struct fixed31_32 arg,
224	uint8_t shift)
225{
226	struct fixed31_32 res;
227	res.value = arg.value >> shift;
228	return res;
229}
230
231/*
232 * @brief
233 * Binary additive operators
234 */
235
236/*
237 * @brief
238 * result = arg1 + arg2
239 */
240struct fixed31_32 dal_fixed31_32_add(
241	struct fixed31_32 arg1,
242	struct fixed31_32 arg2);
243
244/*
245 * @brief
246 * result = arg1 + arg2
247 */
248static inline struct fixed31_32 dal_fixed31_32_add_int(struct fixed31_32 arg1,
249						       int32_t arg2)
250{
251	return dal_fixed31_32_add(arg1,
252				  dal_fixed31_32_from_int(arg2));
253}
254
255/*
256 * @brief
257 * result = arg1 - arg2
258 */
259struct fixed31_32 dal_fixed31_32_sub(
260	struct fixed31_32 arg1,
261	struct fixed31_32 arg2);
262
263/*
264 * @brief
265 * result = arg1 - arg2
266 */
267static inline struct fixed31_32 dal_fixed31_32_sub_int(struct fixed31_32 arg1,
268						       int32_t arg2)
269{
270	return dal_fixed31_32_sub(arg1,
271				  dal_fixed31_32_from_int(arg2));
272}
273
274
275/*
276 * @brief
277 * Binary multiplicative operators
278 */
279
280/*
281 * @brief
282 * result = arg1 * arg2
283 */
284struct fixed31_32 dal_fixed31_32_mul(
285	struct fixed31_32 arg1,
286	struct fixed31_32 arg2);
287
288
289/*
290 * @brief
291 * result = arg1 * arg2
292 */
293static inline struct fixed31_32 dal_fixed31_32_mul_int(struct fixed31_32 arg1,
294						       int32_t arg2)
295{
296	return dal_fixed31_32_mul(arg1,
297				  dal_fixed31_32_from_int(arg2));
298}
299
300/*
301 * @brief
302 * result = square(arg) := arg * arg
303 */
304struct fixed31_32 dal_fixed31_32_sqr(
305	struct fixed31_32 arg);
306
307/*
308 * @brief
309 * result = arg1 / arg2
310 */
311static inline struct fixed31_32 dal_fixed31_32_div_int(struct fixed31_32 arg1,
312						       int64_t arg2)
313{
314	return dal_fixed31_32_from_fraction(arg1.value,
315					    dal_fixed31_32_from_int(arg2).value);
316}
317
318/*
319 * @brief
320 * result = arg1 / arg2
321 */
322static inline struct fixed31_32 dal_fixed31_32_div(struct fixed31_32 arg1,
323						   struct fixed31_32 arg2)
324{
325	return dal_fixed31_32_from_fraction(arg1.value,
326					    arg2.value);
327}
328
329/*
330 * @brief
331 * Reciprocal function
332 */
333
334/*
335 * @brief
336 * result = reciprocal(arg) := 1 / arg
337 *
338 * @note
339 * No special actions taken in case argument is zero.
340 */
341struct fixed31_32 dal_fixed31_32_recip(
342	struct fixed31_32 arg);
343
344/*
345 * @brief
346 * Trigonometric functions
347 */
348
349/*
350 * @brief
351 * result = sinc(arg) := sin(arg) / arg
352 *
353 * @note
354 * Argument specified in radians,
355 * internally it's normalized to [-2pi...2pi] range.
356 */
357struct fixed31_32 dal_fixed31_32_sinc(
358	struct fixed31_32 arg);
359
360/*
361 * @brief
362 * result = sin(arg)
363 *
364 * @note
365 * Argument specified in radians,
366 * internally it's normalized to [-2pi...2pi] range.
367 */
368struct fixed31_32 dal_fixed31_32_sin(
369	struct fixed31_32 arg);
370
371/*
372 * @brief
373 * result = cos(arg)
374 *
375 * @note
376 * Argument specified in radians
377 * and should be in [-2pi...2pi] range -
378 * passing arguments outside that range
379 * will cause incorrect result!
380 */
381struct fixed31_32 dal_fixed31_32_cos(
382	struct fixed31_32 arg);
383
384/*
385 * @brief
386 * Transcendent functions
387 */
388
389/*
390 * @brief
391 * result = exp(arg)
392 *
393 * @note
394 * Currently, function is verified for abs(arg) <= 1.
395 */
396struct fixed31_32 dal_fixed31_32_exp(
397	struct fixed31_32 arg);
398
399/*
400 * @brief
401 * result = log(arg)
402 *
403 * @note
404 * Currently, abs(arg) should be less than 1.
405 * No normalization is done.
406 * Currently, no special actions taken
407 * in case of invalid argument(s). Take care!
408 */
409struct fixed31_32 dal_fixed31_32_log(
410	struct fixed31_32 arg);
411
412/*
413 * @brief
414 * Power function
415 */
416
417/*
418 * @brief
419 * result = pow(arg1, arg2)
420 *
421 * @note
422 * Currently, abs(arg1) should be less than 1. Take care!
423 */
424struct fixed31_32 dal_fixed31_32_pow(
425	struct fixed31_32 arg1,
426	struct fixed31_32 arg2);
427
428/*
429 * @brief
430 * Rounding functions
431 */
432
433/*
434 * @brief
435 * result = floor(arg) := greatest integer lower than or equal to arg
436 */
437int32_t dal_fixed31_32_floor(
438	struct fixed31_32 arg);
439
440/*
441 * @brief
442 * result = round(arg) := integer nearest to arg
443 */
444int32_t dal_fixed31_32_round(
445	struct fixed31_32 arg);
446
447/*
448 * @brief
449 * result = ceil(arg) := lowest integer greater than or equal to arg
450 */
451int32_t dal_fixed31_32_ceil(
452	struct fixed31_32 arg);
453
454/* the following two function are used in scaler hw programming to convert fixed
455 * point value to format 2 bits from integer part and 19 bits from fractional
456 * part. The same applies for u0d19, 0 bits from integer part and 19 bits from
457 * fractional
458 */
459
460uint32_t dal_fixed31_32_u2d19(
461	struct fixed31_32 arg);
462
463uint32_t dal_fixed31_32_u0d19(
464	struct fixed31_32 arg);
465
466
467uint32_t dal_fixed31_32_clamp_u0d14(
468	struct fixed31_32 arg);
469
470uint32_t dal_fixed31_32_clamp_u0d10(
471	struct fixed31_32 arg);
472
473int32_t dal_fixed31_32_s4d19(
474	struct fixed31_32 arg);
475
476#endif