Line data    Source code

       1             : /*
       2             :  * Copyright 2017 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             : #include "dcn_calc_math.h"
      27             : 
      28             : #define isNaN(number) ((number) != (number))
      29             : 
      30             : /*
      31             :  * NOTE:
      32             :  *   This file is gcc-parseable HW gospel, coming straight from HW engineers.
      33             :  *
      34             :  * It doesn't adhere to Linux kernel style and sometimes will do things in odd
      35             :  * ways. Unless there is something clearly wrong with it the code should
      36             :  * remain as-is as it provides us with a guarantee from HW that it is correct.
      37             :  */
      38             : 
      39           0 : float dcn_bw_mod(const float arg1, const float arg2)
      40             : {
      41           0 :         if (isNaN(arg1))
      42             :                 return arg2;
      43           0 :         if (isNaN(arg2))
      44             :                 return arg1;
      45           0 :         return arg1 - arg1 * ((int) (arg1 / arg2));
      46             : }
      47             : 
      48           0 : float dcn_bw_min2(const float arg1, const float arg2)
      49             : {
      50           0 :         if (isNaN(arg1))
      51             :                 return arg2;
      52           0 :         if (isNaN(arg2))
      53             :                 return arg1;
      54           0 :         return arg1 < arg2 ? arg1 : arg2;
      55             : }
      56             : 
      57           0 : unsigned int dcn_bw_max(const unsigned int arg1, const unsigned int arg2)
      58             : {
      59           0 :         return arg1 > arg2 ? arg1 : arg2;
      60             : }
      61          87 : float dcn_bw_max2(const float arg1, const float arg2)
      62             : {
      63          87 :         if (isNaN(arg1))
      64             :                 return arg2;
      65          87 :         if (isNaN(arg2))
      66             :                 return arg1;
      67          87 :         return arg1 > arg2 ? arg1 : arg2;
      68             : }
      69             : 
      70          57 : float dcn_bw_floor2(const float arg, const float significance)
      71             : {
      72         309 :         if (significance == 0)
      73             :                 return 0;
      74         309 :         return ((int) (arg / significance)) * significance;
      75             : }
      76           0 : float dcn_bw_floor(const float arg)
      77             : {
      78           0 :         return ((int) (arg));
      79             : }
      80             : 
      81           0 : float dcn_bw_ceil(const float arg)
      82             : {
      83           0 :         float flr = dcn_bw_floor2(arg, 1);
      84             : 
      85           0 :         return flr + 0.00001 >= arg ? arg : flr + 1;
      86             : }
      87             : 
      88         252 : float dcn_bw_ceil2(const float arg, const float significance)
      89             : {
      90         252 :         float flr = dcn_bw_floor2(arg, significance);
      91         252 :         if (significance == 0)
      92             :                 return 0;
      93         252 :         return flr + 0.00001 >= arg ? arg : flr + significance;
      94             : }
      95             : 
      96           0 : float dcn_bw_max3(float v1, float v2, float v3)
      97             : {
      98           0 :         return v3 > dcn_bw_max2(v1, v2) ? v3 : dcn_bw_max2(v1, v2);
      99             : }
     100             : 
     101           0 : float dcn_bw_max5(float v1, float v2, float v3, float v4, float v5)
     102             : {
     103           0 :         return dcn_bw_max3(v1, v2, v3) > dcn_bw_max2(v4, v5) ? dcn_bw_max3(v1, v2, v3) : dcn_bw_max2(v4, v5);
     104             : }
     105             : 
     106           0 : float dcn_bw_pow(float a, float exp)
     107             : {
     108             :         float temp;
     109             :         /*ASSERT(exp == (int)exp);*/
     110           0 :         if ((int)exp == 0)
     111             :                 return 1;
     112           0 :         temp = dcn_bw_pow(a, (int)(exp / 2));
     113           0 :         if (((int)exp % 2) == 0) {
     114           0 :                 return temp * temp;
     115             :         } else {
     116           0 :                 if ((int)exp > 0)
     117           0 :                         return a * temp * temp;
     118             :                 else
     119           0 :                         return (temp * temp) / a;
     120             :         }
     121             : }
     122             : 
     123           0 : double dcn_bw_fabs(double a)
     124             : {
     125           0 :         if (a > 0)
     126             :                 return (a);
     127             :         else
     128           0 :                 return (-a);
     129             : }
     130             : 
     131             : 
     132           0 : float dcn_bw_log(float a, float b)
     133             : {
     134           0 :         int * const exp_ptr = (int *)(&a);
     135           0 :         int x = *exp_ptr;
     136           0 :         const int log_2 = ((x >> 23) & 255) - 128;
     137           0 :         x &= ~(255 << 23);
     138           0 :         x += 127 << 23;
     139             :         *exp_ptr = x;
     140             : 
     141           0 :         a = ((-1.0f / 3) * a + 2) * a - 2.0f / 3;
     142             : 
     143           0 :         if (b > 2.00001 || b < 1.99999)
     144           0 :                 return (a + log_2) / dcn_bw_log(b, 2);
     145             :         else
     146           0 :                 return (a + log_2);
     147             : }