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