[linux-2.6-block.git] / drivers / gpu / drm / amd / display / include / fixed31_32.h

/*
 * Copyright 2012-15 Advanced Micro Devices, Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 *
 * Authors: AMD
 *
 */

#ifndef __DAL_FIXED31_32_H__
#define __DAL_FIXED31_32_H__

#include "os_types.h"

#define FIXED31_32_BITS_PER_FRACTIONAL_PART 32

/*
 * @brief
 * Arithmetic operations on real numbers
 * represented as fixed-point numbers.
 * There are: 1 bit for sign,
 * 31 bit for integer part,
 * 32 bits for fractional part.
 *
 * @note
 * Currently, overflows and underflows are asserted;
 * no special result returned.
 */

struct fixed31_32 {
	int64_t value;
};

/*
 * @brief
 * Useful constants
 */

static const struct fixed31_32 dal_fixed31_32_zero = { 0 };
static const struct fixed31_32 dal_fixed31_32_epsilon = { 1LL };
static const struct fixed31_32 dal_fixed31_32_half = { 0x80000000LL };
static const struct fixed31_32 dal_fixed31_32_one = { 0x100000000LL };

static const struct fixed31_32 dal_fixed31_32_pi = { 13493037705LL };
static const struct fixed31_32 dal_fixed31_32_two_pi = { 26986075409LL };
static const struct fixed31_32 dal_fixed31_32_e = { 11674931555LL };
static const struct fixed31_32 dal_fixed31_32_ln2 = { 2977044471LL };
static const struct fixed31_32 dal_fixed31_32_ln2_div_2 = { 1488522236LL };

/*
 * @brief
 * Initialization routines
 */

/*
 * @brief
 * result = numerator / denominator
 */
struct fixed31_32 dal_fixed31_32_from_fraction(
	int64_t numerator,
	int64_t denominator);

/*
 * @brief
 * result = arg
 */
struct fixed31_32 dal_fixed31_32_from_int_nonconst(int64_t arg);
static inline struct fixed31_32 dal_fixed31_32_from_int(int64_t arg)
{
	if (__builtin_constant_p(arg)) {
		struct fixed31_32 res;
		BUILD_BUG_ON((LONG_MIN > arg) || (arg > LONG_MAX));
		res.value = arg << FIXED31_32_BITS_PER_FRACTIONAL_PART;
		return res;
	} else
		return dal_fixed31_32_from_int_nonconst(arg);
}

/*
 * @brief
 * Unary operators
 */

/*
 * @brief
 * result = -arg
 */
static inline struct fixed31_32 dal_fixed31_32_neg(struct fixed31_32 arg)
{
	struct fixed31_32 res;

	res.value = -arg.value;

	return res;
}

/*
 * @brief
 * result = abs(arg) := (arg >= 0) ? arg : -arg
 */
static inline struct fixed31_32 dal_fixed31_32_abs(struct fixed31_32 arg)
{
	if (arg.value < 0)
		return dal_fixed31_32_neg(arg);
	else
		return arg;
}

/*
 * @brief
 * Binary relational operators
 */

/*
 * @brief
 * result = arg1 < arg2
 */
static inline bool dal_fixed31_32_lt(struct fixed31_32 arg1,
				     struct fixed31_32 arg2)
{
	return arg1.value < arg2.value;
}

/*
 * @brief
 * result = arg1 <= arg2
 */
static inline bool dal_fixed31_32_le(struct fixed31_32 arg1,
				     struct fixed31_32 arg2)
{
	return arg1.value <= arg2.value;
}

/*
 * @brief
 * result = arg1 == arg2
 */
static inline bool dal_fixed31_32_eq(struct fixed31_32 arg1,
				     struct fixed31_32 arg2)
{
	return arg1.value == arg2.value;
}

/*
 * @brief
 * result = min(arg1, arg2) := (arg1 <= arg2) ? arg1 : arg2
 */
static inline struct fixed31_32 dal_fixed31_32_min(struct fixed31_32 arg1,
						   struct fixed31_32 arg2)
{
	if (arg1.value <= arg2.value)
		return arg1;
	else
		return arg2;
}

/*
 * @brief
 * result = max(arg1, arg2) := (arg1 <= arg2) ? arg2 : arg1
 */
static inline struct fixed31_32 dal_fixed31_32_max(struct fixed31_32 arg1,
						   struct fixed31_32 arg2)
{
	if (arg1.value <= arg2.value)
		return arg2;
	else
		return arg1;
}

/*
 * @brief
 *          | min_value, when arg <= min_value
 * result = | arg, when min_value < arg < max_value
 *          | max_value, when arg >= max_value
 */
static inline struct fixed31_32 dal_fixed31_32_clamp(
	struct fixed31_32 arg,
	struct fixed31_32 min_value,
	struct fixed31_32 max_value)
{
	if (dal_fixed31_32_le(arg, min_value))
		return min_value;
	else if (dal_fixed31_32_le(max_value, arg))
		return max_value;
	else
		return arg;
}

/*
 * @brief
 * Binary shift operators
 */

/*
 * @brief
 * result = arg << shift
 */
struct fixed31_32 dal_fixed31_32_shl(
	struct fixed31_32 arg,
	uint8_t shift);

/*
 * @brief
 * result = arg >> shift
 */
static inline struct fixed31_32 dal_fixed31_32_shr(
	struct fixed31_32 arg,
	uint8_t shift)
{
	struct fixed31_32 res;
	res.value = arg.value >> shift;
	return res;
}

/*
 * @brief
 * Binary additive operators
 */

/*
 * @brief
 * result = arg1 + arg2
 */
struct fixed31_32 dal_fixed31_32_add(
	struct fixed31_32 arg1,
	struct fixed31_32 arg2);

/*
 * @brief
 * result = arg1 + arg2
 */
static inline struct fixed31_32 dal_fixed31_32_add_int(struct fixed31_32 arg1,
						       int32_t arg2)
{
	return dal_fixed31_32_add(arg1,
				  dal_fixed31_32_from_int(arg2));
}

/*
 * @brief
 * result = arg1 - arg2
 */
struct fixed31_32 dal_fixed31_32_sub(
	struct fixed31_32 arg1,
	struct fixed31_32 arg2);

/*
 * @brief
 * result = arg1 - arg2
 */
static inline struct fixed31_32 dal_fixed31_32_sub_int(struct fixed31_32 arg1,
						       int32_t arg2)
{
	return dal_fixed31_32_sub(arg1,
				  dal_fixed31_32_from_int(arg2));
}


/*
 * @brief
 * Binary multiplicative operators
 */

/*
 * @brief
 * result = arg1 * arg2
 */
struct fixed31_32 dal_fixed31_32_mul(
	struct fixed31_32 arg1,
	struct fixed31_32 arg2);


/*
 * @brief
 * result = arg1 * arg2
 */
static inline struct fixed31_32 dal_fixed31_32_mul_int(struct fixed31_32 arg1,
						       int32_t arg2)
{
	return dal_fixed31_32_mul(arg1,
				  dal_fixed31_32_from_int(arg2));
}

/*
 * @brief
 * result = square(arg) := arg * arg
 */
struct fixed31_32 dal_fixed31_32_sqr(
	struct fixed31_32 arg);

/*
 * @brief
 * result = arg1 / arg2
 */
static inline struct fixed31_32 dal_fixed31_32_div_int(struct fixed31_32 arg1,
						       int64_t arg2)
{
	return dal_fixed31_32_from_fraction(arg1.value,
					    dal_fixed31_32_from_int(arg2).value);
}

/*
 * @brief
 * result = arg1 / arg2
 */
static inline struct fixed31_32 dal_fixed31_32_div(struct fixed31_32 arg1,
						   struct fixed31_32 arg2)
{
	return dal_fixed31_32_from_fraction(arg1.value,
					    arg2.value);
}

/*
 * @brief
 * Reciprocal function
 */

/*
 * @brief
 * result = reciprocal(arg) := 1 / arg
 *
 * @note
 * No special actions taken in case argument is zero.
 */
struct fixed31_32 dal_fixed31_32_recip(
	struct fixed31_32 arg);

/*
 * @brief
 * Trigonometric functions
 */

/*
 * @brief
 * result = sinc(arg) := sin(arg) / arg
 *
 * @note
 * Argument specified in radians,
 * internally it's normalized to [-2pi...2pi] range.
 */
struct fixed31_32 dal_fixed31_32_sinc(
	struct fixed31_32 arg);

/*
 * @brief
 * result = sin(arg)
 *
 * @note
 * Argument specified in radians,
 * internally it's normalized to [-2pi...2pi] range.
 */
struct fixed31_32 dal_fixed31_32_sin(
	struct fixed31_32 arg);

/*
 * @brief
 * result = cos(arg)
 *
 * @note
 * Argument specified in radians
 * and should be in [-2pi...2pi] range -
 * passing arguments outside that range
 * will cause incorrect result!
 */
struct fixed31_32 dal_fixed31_32_cos(
	struct fixed31_32 arg);

/*
 * @brief
 * Transcendent functions
 */

/*
 * @brief
 * result = exp(arg)
 *
 * @note
 * Currently, function is verified for abs(arg) <= 1.
 */
struct fixed31_32 dal_fixed31_32_exp(
	struct fixed31_32 arg);

/*
 * @brief
 * result = log(arg)
 *
 * @note
 * Currently, abs(arg) should be less than 1.
 * No normalization is done.
 * Currently, no special actions taken
 * in case of invalid argument(s). Take care!
 */
struct fixed31_32 dal_fixed31_32_log(
	struct fixed31_32 arg);

/*
 * @brief
 * Power function
 */

/*
 * @brief
 * result = pow(arg1, arg2)
 *
 * @note
 * Currently, abs(arg1) should be less than 1. Take care!
 */
struct fixed31_32 dal_fixed31_32_pow(
	struct fixed31_32 arg1,
	struct fixed31_32 arg2);

/*
 * @brief
 * Rounding functions
 */

/*
 * @brief
 * result = floor(arg) := greatest integer lower than or equal to arg
 */
int32_t dal_fixed31_32_floor(
	struct fixed31_32 arg);

/*
 * @brief
 * result = round(arg) := integer nearest to arg
 */
int32_t dal_fixed31_32_round(
	struct fixed31_32 arg);

/*
 * @brief
 * result = ceil(arg) := lowest integer greater than or equal to arg
 */
int32_t dal_fixed31_32_ceil(
	struct fixed31_32 arg);

/* the following two function are used in scaler hw programming to convert fixed
 * point value to format 2 bits from integer part and 19 bits from fractional
 * part. The same applies for u0d19, 0 bits from integer part and 19 bits from
 * fractional
 */

uint32_t dal_fixed31_32_u2d19(
	struct fixed31_32 arg);

uint32_t dal_fixed31_32_u0d19(
	struct fixed31_32 arg);


uint32_t dal_fixed31_32_clamp_u0d14(
	struct fixed31_32 arg);

uint32_t dal_fixed31_32_clamp_u0d10(
	struct fixed31_32 arg);

#endif
Commit	Line	Data
4562236b HW	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
c233e91b DA	31	#define FIXED31_32_BITS_PER_FRACTIONAL_PART 32
c233e91b DA	32
4562236b HW	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
	46	struct fixed31_32 {
	47	int64_t value;
	48	};
	49
	50	/*
	51	* @brief
	52	* Useful constants
	53	*/
	54
	55	static const struct fixed31_32 dal_fixed31_32_zero = { 0 };
	56	static const struct fixed31_32 dal_fixed31_32_epsilon = { 1LL };
	57	static const struct fixed31_32 dal_fixed31_32_half = { 0x80000000LL };
	58	static const struct fixed31_32 dal_fixed31_32_one = { 0x100000000LL };
	59
	60	static const struct fixed31_32 dal_fixed31_32_pi = { 13493037705LL };
	61	static const struct fixed31_32 dal_fixed31_32_two_pi = { 26986075409LL };
	62	static const struct fixed31_32 dal_fixed31_32_e = { 11674931555LL };
	63	static const struct fixed31_32 dal_fixed31_32_ln2 = { 2977044471LL };
	64	static 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	*/
	75	struct fixed31_32 dal_fixed31_32_from_fraction(
	76	int64_t numerator,
	77	int64_t denominator);
	78
	79	/*
	80	* @brief
	81	* result = arg
	82	*/
c233e91b DA	83	struct fixed31_32 dal_fixed31_32_from_int_nonconst(int64_t arg);
	84	static 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	}
4562236b HW	94
	95	/*
	96	* @brief
	97	* Unary operators
	98	*/
	99
	100	/*
	101	* @brief
	102	* result = -arg
	103	*/
204de25f DA	104	static 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	}
4562236b HW	112
	113	/*
	114	* @brief
	115	* result = abs(arg) := (arg >= 0) ? arg : -arg
	116	*/
204de25f DA	117	static 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	}
4562236b HW	124
	125	/*
	126	* @brief
	127	* Binary relational operators
	128	*/
	129
	130	/*
	131	* @brief
	132	* result = arg1 < arg2
	133	*/
204de25f DA	134	static inline bool dal_fixed31_32_lt(struct fixed31_32 arg1,
	135	struct fixed31_32 arg2)
	136	{
	137	return arg1.value < arg2.value;
	138	}
4562236b HW	139
	140	/*
	141	* @brief
	142	* result = arg1 <= arg2
	143	*/
204de25f DA	144	static inline bool dal_fixed31_32_le(struct fixed31_32 arg1,
	145	struct fixed31_32 arg2)
	146	{
	147	return arg1.value <= arg2.value;
	148	}
4562236b HW	149
	150	/*
	151	* @brief
	152	* result = arg1 == arg2
	153	*/
204de25f DA	154	static inline bool dal_fixed31_32_eq(struct fixed31_32 arg1,
	155	struct fixed31_32 arg2)
	156	{
	157	return arg1.value == arg2.value;
	158	}
4562236b HW	159
	160	/*
	161	* @brief
	162	* result = min(arg1, arg2) := (arg1 <= arg2) ? arg1 : arg2
	163	*/
204de25f DA	164	static 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	}
4562236b HW	172
	173	/*
	174	* @brief
	175	* result = max(arg1, arg2) := (arg1 <= arg2) ? arg2 : arg1
	176	*/
204de25f DA	177	static 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	}
4562236b HW	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	*/
204de25f	192	static inline struct fixed31_32 dal_fixed31_32_clamp(
4562236b HW	193	struct fixed31_32 arg,
4562236b HW	194	struct fixed31_32 min_value,
204de25f DA	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	}
4562236b HW	204
	205	/*
	206	* @brief
	207	* Binary shift operators
	208	*/
	209
	210	/*
	211	* @brief
	212	* result = arg << shift
	213	*/
	214	struct fixed31_32 dal_fixed31_32_shl(
	215	struct fixed31_32 arg,
	216	uint8_t shift);
	217
	218	/*
	219	* @brief
	220	* result = arg >> shift
	221	*/
204de25f	222	static inline struct fixed31_32 dal_fixed31_32_shr(
4562236b	223	struct fixed31_32 arg,
204de25f DA	224	uint8_t shift)
	225	{
	226	struct fixed31_32 res;
	227	res.value = arg.value >> shift;
	228	return res;
	229	}
4562236b HW	230
	231	/*
	232	* @brief
	233	* Binary additive operators
	234	*/
	235
	236	/*
	237	* @brief
	238	* result = arg1 + arg2
	239	*/
	240	struct fixed31_32 dal_fixed31_32_add(
	241	struct fixed31_32 arg1,
	242	struct fixed31_32 arg2);
	243
fcd2f4bf AZ	244	/*
	245	* @brief
	246	* result = arg1 + arg2
	247	*/
204de25f DA	248	static 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	}
fcd2f4bf	254
4562236b HW	255	/*
	256	* @brief
	257	* result = arg1 - arg2
	258	*/
204de25f	259	struct fixed31_32 dal_fixed31_32_sub(
4562236b	260	struct fixed31_32 arg1,
204de25f	261	struct fixed31_32 arg2);
4562236b HW	262
	263	/*
	264	* @brief
	265	* result = arg1 - arg2
	266	*/
204de25f DA	267	static 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
4562236b HW	274
	275	/*
	276	* @brief
	277	* Binary multiplicative operators
	278	*/
	279
	280	/*
	281	* @brief
	282	* result = arg1 * arg2
	283	*/
204de25f	284	struct fixed31_32 dal_fixed31_32_mul(
4562236b	285	struct fixed31_32 arg1,
204de25f DA	286	struct fixed31_32 arg2);
204de25f DA	287
4562236b HW	288
	289	/*
	290	* @brief
	291	* result = arg1 * arg2
	292	*/
204de25f DA	293	static 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	}
4562236b HW	299
	300	/*
	301	* @brief
	302	* result = square(arg) := arg * arg
	303	*/
	304	struct fixed31_32 dal_fixed31_32_sqr(
	305	struct fixed31_32 arg);
	306
	307	/*
	308	* @brief
	309	* result = arg1 / arg2
	310	*/
bd6d1576 DA	311	static 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	}
4562236b HW	317
	318	/*
	319	* @brief
	320	* result = arg1 / arg2
	321	*/
204de25f DA	322	static 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	}
4562236b HW	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	*/
	341	struct 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	*/
	357	struct 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	*/
	368	struct 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	*/
	381	struct 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	*/
396	struct 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	*/
409	struct 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	*/
424	struct 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	*/
437	int32_t dal_fixed31_32_floor(
438	struct fixed31_32 arg);
439
440	/*
441	* @brief
442	* result = round(arg) := integer nearest to arg
443	*/
444	int32_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	*/
451	int32_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
460	uint32_t dal_fixed31_32_u2d19(
461	struct fixed31_32 arg);
462
463	uint32_t dal_fixed31_32_u0d19(
464	struct fixed31_32 arg);
465
b6295960	466
78b56c52	467	uint32_t dal_fixed31_32_clamp_u0d14(
b6295960 VP	468	struct fixed31_32 arg);
b6295960 VP	469
78b56c52	470	uint32_t dal_fixed31_32_clamp_u0d10(
b6295960 VP	471	struct fixed31_32 arg);
b6295960 VP	472
4562236b	473	#endif