* [PATCH 1/2] drm/amd/powerplay: Mark functions of ppevvmath.h static
@ 2016-04-24 11:22 Nils Wallménius
2016-04-24 11:22 ` [PATCH 2/2] drm/amd/powerplay: Delete unused functions in ppevvmath.h Nils Wallménius
0 siblings, 1 reply; 9+ messages in thread
From: Nils Wallménius @ 2016-04-24 11:22 UTC (permalink / raw)
To: dri-devel; +Cc: Nils Wallménius
This introduces some warnings due to unused functions, that are
deleted in the following commit.
Signed-off-by: Nils Wallménius <nils.wallmenius@gmail.com>
---
drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h | 128 ++++++++++++------------
1 file changed, 64 insertions(+), 64 deletions(-)
diff --git a/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h b/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h
index 009bd59..a9b40eb 100644
--- a/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h
+++ b/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h
@@ -50,55 +50,55 @@ typedef union _fInt {
* Function Declarations
* -------------------------------------------------------------------------------
*/
-fInt ConvertToFraction(int); /* Use this to convert an INT to a FINT */
-fInt Convert_ULONG_ToFraction(uint32_t); /* Use this to convert an uint32_t to a FINT */
-fInt GetScaledFraction(int, int); /* Use this to convert an INT to a FINT after scaling it by a factor */
-int ConvertBackToInteger(fInt); /* Convert a FINT back to an INT that is scaled by 1000 (i.e. last 3 digits are the decimal digits) */
-
-fInt fNegate(fInt); /* Returns -1 * input fInt value */
-fInt fAdd (fInt, fInt); /* Returns the sum of two fInt numbers */
-fInt fSubtract (fInt A, fInt B); /* Returns A-B - Sometimes easier than Adding negative numbers */
-fInt fMultiply (fInt, fInt); /* Returns the product of two fInt numbers */
-fInt fDivide (fInt A, fInt B); /* Returns A/B */
-fInt fGetSquare(fInt); /* Returns the square of a fInt number */
-fInt fSqrt(fInt); /* Returns the Square Root of a fInt number */
-
-int uAbs(int); /* Returns the Absolute value of the Int */
-fInt fAbs(fInt); /* Returns the Absolute value of the fInt */
-int uPow(int base, int exponent); /* Returns base^exponent an INT */
-
-void SolveQuadracticEqn(fInt, fInt, fInt, fInt[]); /* Returns the 2 roots via the array */
-bool Equal(fInt, fInt); /* Returns true if two fInts are equal to each other */
-bool GreaterThan(fInt A, fInt B); /* Returns true if A > B */
-
-fInt fExponential(fInt exponent); /* Can be used to calculate e^exponent */
-fInt fNaturalLog(fInt value); /* Can be used to calculate ln(value) */
+static fInt ConvertToFraction(int); /* Use this to convert an INT to a FINT */
+static fInt Convert_ULONG_ToFraction(uint32_t); /* Use this to convert an uint32_t to a FINT */
+static fInt GetScaledFraction(int, int); /* Use this to convert an INT to a FINT after scaling it by a factor */
+static int ConvertBackToInteger(fInt); /* Convert a FINT back to an INT that is scaled by 1000 (i.e. last 3 digits are the decimal digits) */
+
+static fInt fNegate(fInt); /* Returns -1 * input fInt value */
+static fInt fAdd (fInt, fInt); /* Returns the sum of two fInt numbers */
+static fInt fSubtract (fInt A, fInt B); /* Returns A-B - Sometimes easier than Adding negative numbers */
+static fInt fMultiply (fInt, fInt); /* Returns the product of two fInt numbers */
+static fInt fDivide (fInt A, fInt B); /* Returns A/B */
+static fInt fGetSquare(fInt); /* Returns the square of a fInt number */
+static fInt fSqrt(fInt); /* Returns the Square Root of a fInt number */
+
+static int uAbs(int); /* Returns the Absolute value of the Int */
+static fInt fAbs(fInt); /* Returns the Absolute value of the fInt */
+static int uPow(int base, int exponent); /* Returns base^exponent an INT */
+
+static void SolveQuadracticEqn(fInt, fInt, fInt, fInt[]); /* Returns the 2 roots via the array */
+static bool Equal(fInt, fInt); /* Returns true if two fInts are equal to each other */
+static bool GreaterThan(fInt A, fInt B); /* Returns true if A > B */
+
+static fInt fExponential(fInt exponent); /* Can be used to calculate e^exponent */
+static fInt fNaturalLog(fInt value); /* Can be used to calculate ln(value) */
/* Fuse decoding functions
* -------------------------------------------------------------------------------------
*/
-fInt fDecodeLinearFuse(uint32_t fuse_value, fInt f_min, fInt f_range, uint32_t bitlength);
-fInt fDecodeLogisticFuse(uint32_t fuse_value, fInt f_average, fInt f_range, uint32_t bitlength);
-fInt fDecodeLeakageID (uint32_t leakageID_fuse, fInt ln_max_div_min, fInt f_min, uint32_t bitlength);
+static fInt fDecodeLinearFuse(uint32_t fuse_value, fInt f_min, fInt f_range, uint32_t bitlength);
+static fInt fDecodeLogisticFuse(uint32_t fuse_value, fInt f_average, fInt f_range, uint32_t bitlength);
+static fInt fDecodeLeakageID (uint32_t leakageID_fuse, fInt ln_max_div_min, fInt f_min, uint32_t bitlength);
/* Internal Support Functions - Use these ONLY for testing or adding to internal functions
* -------------------------------------------------------------------------------------
* Some of the following functions take two INTs as their input - This is unsafe for a variety of reasons.
*/
-fInt Add (int, int); /* Add two INTs and return Sum as FINT */
-fInt Multiply (int, int); /* Multiply two INTs and return Product as FINT */
-fInt Divide (int, int); /* You get the idea... */
-fInt fNegate(fInt);
+static fInt Add (int, int); /* Add two INTs and return Sum as FINT */
+static fInt Multiply (int, int); /* Multiply two INTs and return Product as FINT */
+static fInt Divide (int, int); /* You get the idea... */
+static fInt fNegate(fInt);
-int uGetScaledDecimal (fInt); /* Internal function */
-int GetReal (fInt A); /* Internal function */
+static int uGetScaledDecimal (fInt); /* Internal function */
+static int GetReal (fInt A); /* Internal function */
/* Future Additions and Incomplete Functions
* -------------------------------------------------------------------------------------
*/
-int GetRoundedValue(fInt); /* Incomplete function - Useful only when Precision is lacking */
- /* Let us say we have 2.126 but can only handle 2 decimal points. We could */
- /* either chop of 6 and keep 2.12 or use this function to get 2.13, which is more accurate */
+static int GetRoundedValue(fInt); /* Incomplete function - Useful only when Precision is lacking */
+ /* Let us say we have 2.126 but can only handle 2 decimal points. We could */
+ /* either chop of 6 and keep 2.12 or use this function to get 2.13, which is more accurate */
/* -------------------------------------------------------------------------------------
* TROUBLESHOOTING INFORMATION
@@ -115,7 +115,7 @@ int GetRoundedValue(fInt); /* Incomplete function - Usef
* START OF CODE
* -------------------------------------------------------------------------------------
*/
-fInt fExponential(fInt exponent) /*Can be used to calculate e^exponent*/
+static fInt fExponential(fInt exponent) /*Can be used to calculate e^exponent*/
{
uint32_t i;
bool bNegated = false;
@@ -154,7 +154,7 @@ fInt fExponential(fInt exponent) /*Can be used to calculate e^exponent*/
return solution;
}
-fInt fNaturalLog(fInt value)
+static fInt fNaturalLog(fInt value)
{
uint32_t i;
fInt upper_bound = Divide(8, 1000);
@@ -179,7 +179,7 @@ fInt fNaturalLog(fInt value)
return (fAdd(solution, error_term));
}
-fInt fDecodeLinearFuse(uint32_t fuse_value, fInt f_min, fInt f_range, uint32_t bitlength)
+static fInt fDecodeLinearFuse(uint32_t fuse_value, fInt f_min, fInt f_range, uint32_t bitlength)
{
fInt f_fuse_value = Convert_ULONG_ToFraction(fuse_value);
fInt f_bit_max_value = Convert_ULONG_ToFraction((uPow(2, bitlength)) - 1);
@@ -194,7 +194,7 @@ fInt fDecodeLinearFuse(uint32_t fuse_value, fInt f_min, fInt f_range, uint32_t b
}
-fInt fDecodeLogisticFuse(uint32_t fuse_value, fInt f_average, fInt f_range, uint32_t bitlength)
+static fInt fDecodeLogisticFuse(uint32_t fuse_value, fInt f_average, fInt f_range, uint32_t bitlength)
{
fInt f_fuse_value = Convert_ULONG_ToFraction(fuse_value);
fInt f_bit_max_value = Convert_ULONG_ToFraction((uPow(2, bitlength)) - 1);
@@ -212,7 +212,7 @@ fInt fDecodeLogisticFuse(uint32_t fuse_value, fInt f_average, fInt f_range, uint
return f_decoded_value;
}
-fInt fDecodeLeakageID (uint32_t leakageID_fuse, fInt ln_max_div_min, fInt f_min, uint32_t bitlength)
+static fInt fDecodeLeakageID (uint32_t leakageID_fuse, fInt ln_max_div_min, fInt f_min, uint32_t bitlength)
{
fInt fLeakage;
fInt f_bit_max_value = Convert_ULONG_ToFraction((uPow(2, bitlength)) - 1);
@@ -225,7 +225,7 @@ fInt fDecodeLeakageID (uint32_t leakageID_fuse, fInt ln_max_div_min, fInt f_min,
return fLeakage;
}
-fInt ConvertToFraction(int X) /*Add all range checking here. Is it possible to make fInt a private declaration? */
+static fInt ConvertToFraction(int X) /*Add all range checking here. Is it possible to make fInt a private declaration? */
{
fInt temp;
@@ -237,13 +237,13 @@ fInt ConvertToFraction(int X) /*Add all range checking here. Is it possible to m
return temp;
}
-fInt fNegate(fInt X)
+static fInt fNegate(fInt X)
{
fInt CONSTANT_NEGONE = ConvertToFraction(-1);
return (fMultiply(X, CONSTANT_NEGONE));
}
-fInt Convert_ULONG_ToFraction(uint32_t X)
+static fInt Convert_ULONG_ToFraction(uint32_t X)
{
fInt temp;
@@ -255,7 +255,7 @@ fInt Convert_ULONG_ToFraction(uint32_t X)
return temp;
}
-fInt GetScaledFraction(int X, int factor)
+static fInt GetScaledFraction(int X, int factor)
{
int times_shifted, factor_shifted;
bool bNEGATED;
@@ -304,7 +304,7 @@ fInt GetScaledFraction(int X, int factor)
}
/* Addition using two fInts */
-fInt fAdd (fInt X, fInt Y)
+static fInt fAdd (fInt X, fInt Y)
{
fInt Sum;
@@ -314,7 +314,7 @@ fInt fAdd (fInt X, fInt Y)
}
/* Addition using two fInts */
-fInt fSubtract (fInt X, fInt Y)
+static fInt fSubtract (fInt X, fInt Y)
{
fInt Difference;
@@ -323,7 +323,7 @@ fInt fSubtract (fInt X, fInt Y)
return Difference;
}
-bool Equal(fInt A, fInt B)
+static bool Equal(fInt A, fInt B)
{
if (A.full == B.full)
return true;
@@ -331,7 +331,7 @@ bool Equal(fInt A, fInt B)
return false;
}
-bool GreaterThan(fInt A, fInt B)
+static bool GreaterThan(fInt A, fInt B)
{
if (A.full > B.full)
return true;
@@ -339,7 +339,7 @@ bool GreaterThan(fInt A, fInt B)
return false;
}
-fInt fMultiply (fInt X, fInt Y) /* Uses 64-bit integers (int64_t) */
+static fInt fMultiply (fInt X, fInt Y) /* Uses 64-bit integers (int64_t) */
{
fInt Product;
int64_t tempProduct;
@@ -363,7 +363,7 @@ fInt fMultiply (fInt X, fInt Y) /* Uses 64-bit integers (int64_t) */
return Product;
}
-fInt fDivide (fInt X, fInt Y)
+static fInt fDivide (fInt X, fInt Y)
{
fInt fZERO, fQuotient;
int64_t longlongX, longlongY;
@@ -384,7 +384,7 @@ fInt fDivide (fInt X, fInt Y)
return fQuotient;
}
-int ConvertBackToInteger (fInt A) /*THIS is the function that will be used to check with the Golden settings table*/
+static int ConvertBackToInteger (fInt A) /*THIS is the function that will be used to check with the Golden settings table*/
{
fInt fullNumber, scaledDecimal, scaledReal;
@@ -397,13 +397,13 @@ int ConvertBackToInteger (fInt A) /*THIS is the function that will be used to ch
return fullNumber.full;
}
-fInt fGetSquare(fInt A)
+static fInt fGetSquare(fInt A)
{
return fMultiply(A,A);
}
/* x_new = x_old - (x_old^2 - C) / (2 * x_old) */
-fInt fSqrt(fInt num)
+static fInt fSqrt(fInt num)
{
fInt F_divide_Fprime, Fprime;
fInt test;
@@ -460,7 +460,7 @@ fInt fSqrt(fInt num)
return (x_new);
}
-void SolveQuadracticEqn(fInt A, fInt B, fInt C, fInt Roots[])
+static void SolveQuadracticEqn(fInt A, fInt B, fInt C, fInt Roots[])
{
fInt *pRoots = &Roots[0];
fInt temp, root_first, root_second;
@@ -499,7 +499,7 @@ void SolveQuadracticEqn(fInt A, fInt B, fInt C, fInt Roots[])
*/
/* Addition using two normal ints - Temporary - Use only for testing purposes?. */
-fInt Add (int X, int Y)
+static fInt Add (int X, int Y)
{
fInt A, B, Sum;
@@ -512,13 +512,13 @@ fInt Add (int X, int Y)
}
/* Conversion Functions */
-int GetReal (fInt A)
+static int GetReal (fInt A)
{
return (A.full >> SHIFT_AMOUNT);
}
/* Temporarily Disabled */
-int GetRoundedValue(fInt A) /*For now, round the 3rd decimal place */
+static int GetRoundedValue(fInt A) /*For now, round the 3rd decimal place */
{
/* ROUNDING TEMPORARLY DISABLED
int temp = A.full;
@@ -531,7 +531,7 @@ int GetRoundedValue(fInt A) /*For now, round the 3rd decimal place */
return ConvertBackToInteger(A)/10000; /*Temporary - in case this was used somewhere else */
}
-fInt Multiply (int X, int Y)
+static fInt Multiply (int X, int Y)
{
fInt A, B, Product;
@@ -543,7 +543,7 @@ fInt Multiply (int X, int Y)
return Product;
}
-fInt Divide (int X, int Y)
+static fInt Divide (int X, int Y)
{
fInt A, B, Quotient;
@@ -555,7 +555,7 @@ fInt Divide (int X, int Y)
return Quotient;
}
-int uGetScaledDecimal (fInt A) /*Converts the fractional portion to whole integers - Costly function */
+static int uGetScaledDecimal (fInt A) /*Converts the fractional portion to whole integers - Costly function */
{
int dec[PRECISION];
int i, scaledDecimal = 0, tmp = A.partial.decimal;
@@ -570,7 +570,7 @@ int uGetScaledDecimal (fInt A) /*Converts the fractional portion to whole intege
return scaledDecimal;
}
-int uPow(int base, int power)
+static int uPow(int base, int power)
{
if (power == 0)
return 1;
@@ -578,7 +578,7 @@ int uPow(int base, int power)
return (base)*uPow(base, power - 1);
}
-fInt fAbs(fInt A)
+static fInt fAbs(fInt A)
{
if (A.partial.real < 0)
return (fMultiply(A, ConvertToFraction(-1)));
@@ -586,7 +586,7 @@ fInt fAbs(fInt A)
return A;
}
-int uAbs(int X)
+static int uAbs(int X)
{
if (X < 0)
return (X * -1);
@@ -594,7 +594,7 @@ int uAbs(int X)
return X;
}
-fInt fRoundUpByStepSize(fInt A, fInt fStepSize, bool error_term)
+static fInt fRoundUpByStepSize(fInt A, fInt fStepSize, bool error_term)
{
fInt solution;
--
2.8.0.rc3
_______________________________________________
dri-devel mailing list
dri-devel@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/dri-devel
^ permalink raw reply related [flat|nested] 9+ messages in thread* [PATCH 2/2] drm/amd/powerplay: Delete unused functions in ppevvmath.h
2016-04-24 11:22 [PATCH 1/2] drm/amd/powerplay: Mark functions of ppevvmath.h static Nils Wallménius
@ 2016-04-24 11:22 ` Nils Wallménius
2016-04-25 20:08 ` Alex Deucher
0 siblings, 1 reply; 9+ messages in thread
From: Nils Wallménius @ 2016-04-24 11:22 UTC (permalink / raw)
To: dri-devel; +Cc: Nils Wallménius
Signed-off-by: Nils Wallménius <nils.wallmenius@gmail.com>
---
drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h | 59 +------------------------
1 file changed, 1 insertion(+), 58 deletions(-)
diff --git a/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h b/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h
index a9b40eb..8f50a03 100644
--- a/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h
+++ b/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h
@@ -64,7 +64,6 @@ static fInt fGetSquare(fInt); /* Returns the square
static fInt fSqrt(fInt); /* Returns the Square Root of a fInt number */
static int uAbs(int); /* Returns the Absolute value of the Int */
-static fInt fAbs(fInt); /* Returns the Absolute value of the fInt */
static int uPow(int base, int exponent); /* Returns base^exponent an INT */
static void SolveQuadracticEqn(fInt, fInt, fInt, fInt[]); /* Returns the 2 roots via the array */
@@ -85,21 +84,12 @@ static fInt fDecodeLeakageID (uint32_t leakageID_fuse, fInt ln_max_div_min, fInt
* -------------------------------------------------------------------------------------
* Some of the following functions take two INTs as their input - This is unsafe for a variety of reasons.
*/
-static fInt Add (int, int); /* Add two INTs and return Sum as FINT */
-static fInt Multiply (int, int); /* Multiply two INTs and return Product as FINT */
-static fInt Divide (int, int); /* You get the idea... */
+static fInt Divide (int, int); /* Divide two INTs and return result as FINT */
static fInt fNegate(fInt);
static int uGetScaledDecimal (fInt); /* Internal function */
static int GetReal (fInt A); /* Internal function */
-/* Future Additions and Incomplete Functions
- * -------------------------------------------------------------------------------------
- */
-static int GetRoundedValue(fInt); /* Incomplete function - Useful only when Precision is lacking */
- /* Let us say we have 2.126 but can only handle 2 decimal points. We could */
- /* either chop of 6 and keep 2.12 or use this function to get 2.13, which is more accurate */
-
/* -------------------------------------------------------------------------------------
* TROUBLESHOOTING INFORMATION
* -------------------------------------------------------------------------------------
@@ -498,51 +488,12 @@ static void SolveQuadracticEqn(fInt A, fInt B, fInt C, fInt Roots[])
* -----------------------------------------------------------------------------
*/
-/* Addition using two normal ints - Temporary - Use only for testing purposes?. */
-static fInt Add (int X, int Y)
-{
- fInt A, B, Sum;
-
- A.full = (X << SHIFT_AMOUNT);
- B.full = (Y << SHIFT_AMOUNT);
-
- Sum.full = A.full + B.full;
-
- return Sum;
-}
-
/* Conversion Functions */
static int GetReal (fInt A)
{
return (A.full >> SHIFT_AMOUNT);
}
-/* Temporarily Disabled */
-static int GetRoundedValue(fInt A) /*For now, round the 3rd decimal place */
-{
- /* ROUNDING TEMPORARLY DISABLED
- int temp = A.full;
- int decimal_cutoff, decimal_mask = 0x000001FF;
- decimal_cutoff = temp & decimal_mask;
- if (decimal_cutoff > 0x147) {
- temp += 673;
- }*/
-
- return ConvertBackToInteger(A)/10000; /*Temporary - in case this was used somewhere else */
-}
-
-static fInt Multiply (int X, int Y)
-{
- fInt A, B, Product;
-
- A.full = X << SHIFT_AMOUNT;
- B.full = Y << SHIFT_AMOUNT;
-
- Product = fMultiply(A, B);
-
- return Product;
-}
-
static fInt Divide (int X, int Y)
{
fInt A, B, Quotient;
@@ -578,14 +529,6 @@ static int uPow(int base, int power)
return (base)*uPow(base, power - 1);
}
-static fInt fAbs(fInt A)
-{
- if (A.partial.real < 0)
- return (fMultiply(A, ConvertToFraction(-1)));
- else
- return A;
-}
-
static int uAbs(int X)
{
if (X < 0)
--
2.8.0.rc3
_______________________________________________
dri-devel mailing list
dri-devel@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/dri-devel
^ permalink raw reply related [flat|nested] 9+ messages in thread* Re: [PATCH 2/2] drm/amd/powerplay: Delete unused functions in ppevvmath.h
2016-04-24 11:22 ` [PATCH 2/2] drm/amd/powerplay: Delete unused functions in ppevvmath.h Nils Wallménius
@ 2016-04-25 20:08 ` Alex Deucher
2016-06-06 19:32 ` Nils Wallménius
0 siblings, 1 reply; 9+ messages in thread
From: Alex Deucher @ 2016-04-25 20:08 UTC (permalink / raw)
To: Nils Wallménius; +Cc: Maling list - DRI developers
On Sun, Apr 24, 2016 at 7:22 AM, Nils Wallménius
<nils.wallmenius@gmail.com> wrote:
> Signed-off-by: Nils Wallménius <nils.wallmenius@gmail.com>
Let me check with the powerplay team and make sure they are planning
to use these in the near future.
Alex
> ---
> drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h | 59 +------------------------
> 1 file changed, 1 insertion(+), 58 deletions(-)
>
> diff --git a/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h b/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h
> index a9b40eb..8f50a03 100644
> --- a/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h
> +++ b/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h
> @@ -64,7 +64,6 @@ static fInt fGetSquare(fInt); /* Returns the square
> static fInt fSqrt(fInt); /* Returns the Square Root of a fInt number */
>
> static int uAbs(int); /* Returns the Absolute value of the Int */
> -static fInt fAbs(fInt); /* Returns the Absolute value of the fInt */
> static int uPow(int base, int exponent); /* Returns base^exponent an INT */
>
> static void SolveQuadracticEqn(fInt, fInt, fInt, fInt[]); /* Returns the 2 roots via the array */
> @@ -85,21 +84,12 @@ static fInt fDecodeLeakageID (uint32_t leakageID_fuse, fInt ln_max_div_min, fInt
> * -------------------------------------------------------------------------------------
> * Some of the following functions take two INTs as their input - This is unsafe for a variety of reasons.
> */
> -static fInt Add (int, int); /* Add two INTs and return Sum as FINT */
> -static fInt Multiply (int, int); /* Multiply two INTs and return Product as FINT */
> -static fInt Divide (int, int); /* You get the idea... */
> +static fInt Divide (int, int); /* Divide two INTs and return result as FINT */
> static fInt fNegate(fInt);
>
> static int uGetScaledDecimal (fInt); /* Internal function */
> static int GetReal (fInt A); /* Internal function */
>
> -/* Future Additions and Incomplete Functions
> - * -------------------------------------------------------------------------------------
> - */
> -static int GetRoundedValue(fInt); /* Incomplete function - Useful only when Precision is lacking */
> - /* Let us say we have 2.126 but can only handle 2 decimal points. We could */
> - /* either chop of 6 and keep 2.12 or use this function to get 2.13, which is more accurate */
> -
> /* -------------------------------------------------------------------------------------
> * TROUBLESHOOTING INFORMATION
> * -------------------------------------------------------------------------------------
> @@ -498,51 +488,12 @@ static void SolveQuadracticEqn(fInt A, fInt B, fInt C, fInt Roots[])
> * -----------------------------------------------------------------------------
> */
>
> -/* Addition using two normal ints - Temporary - Use only for testing purposes?. */
> -static fInt Add (int X, int Y)
> -{
> - fInt A, B, Sum;
> -
> - A.full = (X << SHIFT_AMOUNT);
> - B.full = (Y << SHIFT_AMOUNT);
> -
> - Sum.full = A.full + B.full;
> -
> - return Sum;
> -}
> -
> /* Conversion Functions */
> static int GetReal (fInt A)
> {
> return (A.full >> SHIFT_AMOUNT);
> }
>
> -/* Temporarily Disabled */
> -static int GetRoundedValue(fInt A) /*For now, round the 3rd decimal place */
> -{
> - /* ROUNDING TEMPORARLY DISABLED
> - int temp = A.full;
> - int decimal_cutoff, decimal_mask = 0x000001FF;
> - decimal_cutoff = temp & decimal_mask;
> - if (decimal_cutoff > 0x147) {
> - temp += 673;
> - }*/
> -
> - return ConvertBackToInteger(A)/10000; /*Temporary - in case this was used somewhere else */
> -}
> -
> -static fInt Multiply (int X, int Y)
> -{
> - fInt A, B, Product;
> -
> - A.full = X << SHIFT_AMOUNT;
> - B.full = Y << SHIFT_AMOUNT;
> -
> - Product = fMultiply(A, B);
> -
> - return Product;
> -}
> -
> static fInt Divide (int X, int Y)
> {
> fInt A, B, Quotient;
> @@ -578,14 +529,6 @@ static int uPow(int base, int power)
> return (base)*uPow(base, power - 1);
> }
>
> -static fInt fAbs(fInt A)
> -{
> - if (A.partial.real < 0)
> - return (fMultiply(A, ConvertToFraction(-1)));
> - else
> - return A;
> -}
> -
> static int uAbs(int X)
> {
> if (X < 0)
> --
> 2.8.0.rc3
>
> _______________________________________________
> dri-devel mailing list
> dri-devel@lists.freedesktop.org
> https://lists.freedesktop.org/mailman/listinfo/dri-devel
_______________________________________________
dri-devel mailing list
dri-devel@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/dri-devel
^ permalink raw reply [flat|nested] 9+ messages in thread* Re: [PATCH 2/2] drm/amd/powerplay: Delete unused functions in ppevvmath.h
2016-04-25 20:08 ` Alex Deucher
@ 2016-06-06 19:32 ` Nils Wallménius
2016-07-15 20:09 ` Nils Wallménius
0 siblings, 1 reply; 9+ messages in thread
From: Nils Wallménius @ 2016-06-06 19:32 UTC (permalink / raw)
To: Alex Deucher; +Cc: Maling list - DRI developers
[-- Attachment #1.1: Type: text/plain, Size: 5617 bytes --]
Hi Alex,
Any response from the powerplay team?
If they are unresponsive, would you prefer to #IF 0 the code instead of
deleting?
Regards
Nils
On Mon, Apr 25, 2016 at 10:08 PM, Alex Deucher <alexdeucher@gmail.com>
wrote:
> On Sun, Apr 24, 2016 at 7:22 AM, Nils Wallménius
> <nils.wallmenius@gmail.com> wrote:
> > Signed-off-by: Nils Wallménius <nils.wallmenius@gmail.com>
>
> Let me check with the powerplay team and make sure they are planning
> to use these in the near future.
>
> Alex
>
>
> > ---
> > drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h | 59
> +------------------------
> > 1 file changed, 1 insertion(+), 58 deletions(-)
> >
> > diff --git a/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h
> b/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h
> > index a9b40eb..8f50a03 100644
> > --- a/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h
> > +++ b/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h
> > @@ -64,7 +64,6 @@ static fInt fGetSquare(fInt);
> /* Returns the square
> > static fInt fSqrt(fInt); /* Returns
> the Square Root of a fInt number */
> >
> > static int uAbs(int); /* Returns
> the Absolute value of the Int */
> > -static fInt fAbs(fInt); /* Returns
> the Absolute value of the fInt */
> > static int uPow(int base, int exponent); /* Returns
> base^exponent an INT */
> >
> > static void SolveQuadracticEqn(fInt, fInt, fInt, fInt[]); /* Returns
> the 2 roots via the array */
> > @@ -85,21 +84,12 @@ static fInt fDecodeLeakageID (uint32_t
> leakageID_fuse, fInt ln_max_div_min, fInt
> > *
> -------------------------------------------------------------------------------------
> > * Some of the following functions take two INTs as their input - This
> is unsafe for a variety of reasons.
> > */
> > -static fInt Add (int, int); /* Add two
> INTs and return Sum as FINT */
> > -static fInt Multiply (int, int); /* Multiply
> two INTs and return Product as FINT */
> > -static fInt Divide (int, int); /* You get
> the idea... */
> > +static fInt Divide (int, int); /* Divide two
> INTs and return result as FINT */
> > static fInt fNegate(fInt);
> >
> > static int uGetScaledDecimal (fInt); /* Internal
> function */
> > static int GetReal (fInt A); /* Internal
> function */
> >
> > -/* Future Additions and Incomplete Functions
> > - *
> -------------------------------------------------------------------------------------
> > - */
> > -static int GetRoundedValue(fInt); /* Incomplete
> function - Useful only when Precision is lacking */
> > - /* Let us say
> we have 2.126 but can only handle 2 decimal points. We could */
> > - /* either
> chop of 6 and keep 2.12 or use this function to get 2.13, which is more
> accurate */
> > -
> > /*
> -------------------------------------------------------------------------------------
> > * TROUBLESHOOTING INFORMATION
> > *
> -------------------------------------------------------------------------------------
> > @@ -498,51 +488,12 @@ static void SolveQuadracticEqn(fInt A, fInt B,
> fInt C, fInt Roots[])
> > *
> -----------------------------------------------------------------------------
> > */
> >
> > -/* Addition using two normal ints - Temporary - Use only for testing
> purposes?. */
> > -static fInt Add (int X, int Y)
> > -{
> > - fInt A, B, Sum;
> > -
> > - A.full = (X << SHIFT_AMOUNT);
> > - B.full = (Y << SHIFT_AMOUNT);
> > -
> > - Sum.full = A.full + B.full;
> > -
> > - return Sum;
> > -}
> > -
> > /* Conversion Functions */
> > static int GetReal (fInt A)
> > {
> > return (A.full >> SHIFT_AMOUNT);
> > }
> >
> > -/* Temporarily Disabled */
> > -static int GetRoundedValue(fInt A) /*For now, round the 3rd decimal
> place */
> > -{
> > - /* ROUNDING TEMPORARLY DISABLED
> > - int temp = A.full;
> > - int decimal_cutoff, decimal_mask = 0x000001FF;
> > - decimal_cutoff = temp & decimal_mask;
> > - if (decimal_cutoff > 0x147) {
> > - temp += 673;
> > - }*/
> > -
> > - return ConvertBackToInteger(A)/10000; /*Temporary - in case this
> was used somewhere else */
> > -}
> > -
> > -static fInt Multiply (int X, int Y)
> > -{
> > - fInt A, B, Product;
> > -
> > - A.full = X << SHIFT_AMOUNT;
> > - B.full = Y << SHIFT_AMOUNT;
> > -
> > - Product = fMultiply(A, B);
> > -
> > - return Product;
> > -}
> > -
> > static fInt Divide (int X, int Y)
> > {
> > fInt A, B, Quotient;
> > @@ -578,14 +529,6 @@ static int uPow(int base, int power)
> > return (base)*uPow(base, power - 1);
> > }
> >
> > -static fInt fAbs(fInt A)
> > -{
> > - if (A.partial.real < 0)
> > - return (fMultiply(A, ConvertToFraction(-1)));
> > - else
> > - return A;
> > -}
> > -
> > static int uAbs(int X)
> > {
> > if (X < 0)
> > --
> > 2.8.0.rc3
> >
> > _______________________________________________
> > dri-devel mailing list
> > dri-devel@lists.freedesktop.org
> > https://lists.freedesktop.org/mailman/listinfo/dri-devel
>
[-- Attachment #1.2: Type: text/html, Size: 7237 bytes --]
[-- Attachment #2: Type: text/plain, Size: 160 bytes --]
_______________________________________________
dri-devel mailing list
dri-devel@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/dri-devel
^ permalink raw reply [flat|nested] 9+ messages in thread* Re: [PATCH 2/2] drm/amd/powerplay: Delete unused functions in ppevvmath.h
2016-06-06 19:32 ` Nils Wallménius
@ 2016-07-15 20:09 ` Nils Wallménius
2016-07-15 21:06 ` Alex Deucher
0 siblings, 1 reply; 9+ messages in thread
From: Nils Wallménius @ 2016-07-15 20:09 UTC (permalink / raw)
To: Alex Deucher; +Cc: Maling list - DRI developers
[-- Attachment #1.1: Type: text/plain, Size: 5887 bytes --]
Ping?
Den 6 juni 2016 21:32 skrev "Nils Wallménius" <nils.wallmenius@gmail.com>:
> Hi Alex,
>
> Any response from the powerplay team?
>
> If they are unresponsive, would you prefer to #IF 0 the code instead of
> deleting?
>
> Regards
> Nils
>
> On Mon, Apr 25, 2016 at 10:08 PM, Alex Deucher <alexdeucher@gmail.com>
> wrote:
>
>> On Sun, Apr 24, 2016 at 7:22 AM, Nils Wallménius
>> <nils.wallmenius@gmail.com> wrote:
>> > Signed-off-by: Nils Wallménius <nils.wallmenius@gmail.com>
>>
>> Let me check with the powerplay team and make sure they are planning
>> to use these in the near future.
>>
>> Alex
>>
>>
>> > ---
>> > drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h | 59
>> +------------------------
>> > 1 file changed, 1 insertion(+), 58 deletions(-)
>> >
>> > diff --git a/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h
>> b/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h
>> > index a9b40eb..8f50a03 100644
>> > --- a/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h
>> > +++ b/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h
>> > @@ -64,7 +64,6 @@ static fInt fGetSquare(fInt);
>> /* Returns the square
>> > static fInt fSqrt(fInt); /* Returns
>> the Square Root of a fInt number */
>> >
>> > static int uAbs(int); /* Returns
>> the Absolute value of the Int */
>> > -static fInt fAbs(fInt); /* Returns
>> the Absolute value of the fInt */
>> > static int uPow(int base, int exponent); /* Returns
>> base^exponent an INT */
>> >
>> > static void SolveQuadracticEqn(fInt, fInt, fInt, fInt[]); /* Returns
>> the 2 roots via the array */
>> > @@ -85,21 +84,12 @@ static fInt fDecodeLeakageID (uint32_t
>> leakageID_fuse, fInt ln_max_div_min, fInt
>> > *
>> -------------------------------------------------------------------------------------
>> > * Some of the following functions take two INTs as their input - This
>> is unsafe for a variety of reasons.
>> > */
>> > -static fInt Add (int, int); /* Add two
>> INTs and return Sum as FINT */
>> > -static fInt Multiply (int, int); /* Multiply
>> two INTs and return Product as FINT */
>> > -static fInt Divide (int, int); /* You get
>> the idea... */
>> > +static fInt Divide (int, int); /* Divide
>> two INTs and return result as FINT */
>> > static fInt fNegate(fInt);
>> >
>> > static int uGetScaledDecimal (fInt); /* Internal
>> function */
>> > static int GetReal (fInt A); /* Internal
>> function */
>> >
>> > -/* Future Additions and Incomplete Functions
>> > - *
>> -------------------------------------------------------------------------------------
>> > - */
>> > -static int GetRoundedValue(fInt); /*
>> Incomplete function - Useful only when Precision is lacking */
>> > - /* Let us
>> say we have 2.126 but can only handle 2 decimal points. We could */
>> > - /* either
>> chop of 6 and keep 2.12 or use this function to get 2.13, which is more
>> accurate */
>> > -
>> > /*
>> -------------------------------------------------------------------------------------
>> > * TROUBLESHOOTING INFORMATION
>> > *
>> -------------------------------------------------------------------------------------
>> > @@ -498,51 +488,12 @@ static void SolveQuadracticEqn(fInt A, fInt B,
>> fInt C, fInt Roots[])
>> > *
>> -----------------------------------------------------------------------------
>> > */
>> >
>> > -/* Addition using two normal ints - Temporary - Use only for testing
>> purposes?. */
>> > -static fInt Add (int X, int Y)
>> > -{
>> > - fInt A, B, Sum;
>> > -
>> > - A.full = (X << SHIFT_AMOUNT);
>> > - B.full = (Y << SHIFT_AMOUNT);
>> > -
>> > - Sum.full = A.full + B.full;
>> > -
>> > - return Sum;
>> > -}
>> > -
>> > /* Conversion Functions */
>> > static int GetReal (fInt A)
>> > {
>> > return (A.full >> SHIFT_AMOUNT);
>> > }
>> >
>> > -/* Temporarily Disabled */
>> > -static int GetRoundedValue(fInt A) /*For now, round the 3rd decimal
>> place */
>> > -{
>> > - /* ROUNDING TEMPORARLY DISABLED
>> > - int temp = A.full;
>> > - int decimal_cutoff, decimal_mask = 0x000001FF;
>> > - decimal_cutoff = temp & decimal_mask;
>> > - if (decimal_cutoff > 0x147) {
>> > - temp += 673;
>> > - }*/
>> > -
>> > - return ConvertBackToInteger(A)/10000; /*Temporary - in case
>> this was used somewhere else */
>> > -}
>> > -
>> > -static fInt Multiply (int X, int Y)
>> > -{
>> > - fInt A, B, Product;
>> > -
>> > - A.full = X << SHIFT_AMOUNT;
>> > - B.full = Y << SHIFT_AMOUNT;
>> > -
>> > - Product = fMultiply(A, B);
>> > -
>> > - return Product;
>> > -}
>> > -
>> > static fInt Divide (int X, int Y)
>> > {
>> > fInt A, B, Quotient;
>> > @@ -578,14 +529,6 @@ static int uPow(int base, int power)
>> > return (base)*uPow(base, power - 1);
>> > }
>> >
>> > -static fInt fAbs(fInt A)
>> > -{
>> > - if (A.partial.real < 0)
>> > - return (fMultiply(A, ConvertToFraction(-1)));
>> > - else
>> > - return A;
>> > -}
>> > -
>> > static int uAbs(int X)
>> > {
>> > if (X < 0)
>> > --
>> > 2.8.0.rc3
>> >
>> > _______________________________________________
>> > dri-devel mailing list
>> > dri-devel@lists.freedesktop.org
>> > https://lists.freedesktop.org/mailman/listinfo/dri-devel
>>
>
>
[-- Attachment #1.2: Type: text/html, Size: 7642 bytes --]
[-- Attachment #2: Type: text/plain, Size: 160 bytes --]
_______________________________________________
dri-devel mailing list
dri-devel@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/dri-devel
^ permalink raw reply [flat|nested] 9+ messages in thread* Re: [PATCH 2/2] drm/amd/powerplay: Delete unused functions in ppevvmath.h
2016-07-15 20:09 ` Nils Wallménius
@ 2016-07-15 21:06 ` Alex Deucher
2016-07-16 3:51 ` Nils Wallménius
0 siblings, 1 reply; 9+ messages in thread
From: Alex Deucher @ 2016-07-15 21:06 UTC (permalink / raw)
To: Nils Wallménius; +Cc: Maling list - DRI developers
On Fri, Jul 15, 2016 at 4:09 PM, Nils Wallménius
<nils.wallmenius@gmail.com> wrote:
> Ping?
We don't seem to be using them. Can you respin? It doesn't seem to
apply any longer.
Alex
>
>
> Den 6 juni 2016 21:32 skrev "Nils Wallménius" <nils.wallmenius@gmail.com>:
>>
>> Hi Alex,
>>
>> Any response from the powerplay team?
>>
>> If they are unresponsive, would you prefer to #IF 0 the code instead of
>> deleting?
>>
>> Regards
>> Nils
>>
>> On Mon, Apr 25, 2016 at 10:08 PM, Alex Deucher <alexdeucher@gmail.com>
>> wrote:
>>>
>>> On Sun, Apr 24, 2016 at 7:22 AM, Nils Wallménius
>>> <nils.wallmenius@gmail.com> wrote:
>>> > Signed-off-by: Nils Wallménius <nils.wallmenius@gmail.com>
>>>
>>> Let me check with the powerplay team and make sure they are planning
>>> to use these in the near future.
>>>
>>> Alex
>>>
>>>
>>> > ---
>>> > drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h | 59
>>> > +------------------------
>>> > 1 file changed, 1 insertion(+), 58 deletions(-)
>>> >
>>> > diff --git a/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h
>>> > b/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h
>>> > index a9b40eb..8f50a03 100644
>>> > --- a/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h
>>> > +++ b/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h
>>> > @@ -64,7 +64,6 @@ static fInt fGetSquare(fInt);
>>> > /* Returns the square
>>> > static fInt fSqrt(fInt); /* Returns
>>> > the Square Root of a fInt number */
>>> >
>>> > static int uAbs(int); /* Returns
>>> > the Absolute value of the Int */
>>> > -static fInt fAbs(fInt); /* Returns
>>> > the Absolute value of the fInt */
>>> > static int uPow(int base, int exponent); /* Returns
>>> > base^exponent an INT */
>>> >
>>> > static void SolveQuadracticEqn(fInt, fInt, fInt, fInt[]); /* Returns
>>> > the 2 roots via the array */
>>> > @@ -85,21 +84,12 @@ static fInt fDecodeLeakageID (uint32_t
>>> > leakageID_fuse, fInt ln_max_div_min, fInt
>>> > *
>>> > -------------------------------------------------------------------------------------
>>> > * Some of the following functions take two INTs as their input - This
>>> > is unsafe for a variety of reasons.
>>> > */
>>> > -static fInt Add (int, int); /* Add two
>>> > INTs and return Sum as FINT */
>>> > -static fInt Multiply (int, int); /* Multiply
>>> > two INTs and return Product as FINT */
>>> > -static fInt Divide (int, int); /* You get
>>> > the idea... */
>>> > +static fInt Divide (int, int); /* Divide
>>> > two INTs and return result as FINT */
>>> > static fInt fNegate(fInt);
>>> >
>>> > static int uGetScaledDecimal (fInt); /* Internal
>>> > function */
>>> > static int GetReal (fInt A); /* Internal
>>> > function */
>>> >
>>> > -/* Future Additions and Incomplete Functions
>>> > - *
>>> > -------------------------------------------------------------------------------------
>>> > - */
>>> > -static int GetRoundedValue(fInt); /*
>>> > Incomplete function - Useful only when Precision is lacking */
>>> > - /* Let us
>>> > say we have 2.126 but can only handle 2 decimal points. We could */
>>> > - /* either
>>> > chop of 6 and keep 2.12 or use this function to get 2.13, which is more
>>> > accurate */
>>> > -
>>> > /*
>>> > -------------------------------------------------------------------------------------
>>> > * TROUBLESHOOTING INFORMATION
>>> > *
>>> > -------------------------------------------------------------------------------------
>>> > @@ -498,51 +488,12 @@ static void SolveQuadracticEqn(fInt A, fInt B,
>>> > fInt C, fInt Roots[])
>>> > *
>>> > -----------------------------------------------------------------------------
>>> > */
>>> >
>>> > -/* Addition using two normal ints - Temporary - Use only for testing
>>> > purposes?. */
>>> > -static fInt Add (int X, int Y)
>>> > -{
>>> > - fInt A, B, Sum;
>>> > -
>>> > - A.full = (X << SHIFT_AMOUNT);
>>> > - B.full = (Y << SHIFT_AMOUNT);
>>> > -
>>> > - Sum.full = A.full + B.full;
>>> > -
>>> > - return Sum;
>>> > -}
>>> > -
>>> > /* Conversion Functions */
>>> > static int GetReal (fInt A)
>>> > {
>>> > return (A.full >> SHIFT_AMOUNT);
>>> > }
>>> >
>>> > -/* Temporarily Disabled */
>>> > -static int GetRoundedValue(fInt A) /*For now, round the 3rd decimal
>>> > place */
>>> > -{
>>> > - /* ROUNDING TEMPORARLY DISABLED
>>> > - int temp = A.full;
>>> > - int decimal_cutoff, decimal_mask = 0x000001FF;
>>> > - decimal_cutoff = temp & decimal_mask;
>>> > - if (decimal_cutoff > 0x147) {
>>> > - temp += 673;
>>> > - }*/
>>> > -
>>> > - return ConvertBackToInteger(A)/10000; /*Temporary - in case
>>> > this was used somewhere else */
>>> > -}
>>> > -
>>> > -static fInt Multiply (int X, int Y)
>>> > -{
>>> > - fInt A, B, Product;
>>> > -
>>> > - A.full = X << SHIFT_AMOUNT;
>>> > - B.full = Y << SHIFT_AMOUNT;
>>> > -
>>> > - Product = fMultiply(A, B);
>>> > -
>>> > - return Product;
>>> > -}
>>> > -
>>> > static fInt Divide (int X, int Y)
>>> > {
>>> > fInt A, B, Quotient;
>>> > @@ -578,14 +529,6 @@ static int uPow(int base, int power)
>>> > return (base)*uPow(base, power - 1);
>>> > }
>>> >
>>> > -static fInt fAbs(fInt A)
>>> > -{
>>> > - if (A.partial.real < 0)
>>> > - return (fMultiply(A, ConvertToFraction(-1)));
>>> > - else
>>> > - return A;
>>> > -}
>>> > -
>>> > static int uAbs(int X)
>>> > {
>>> > if (X < 0)
>>> > --
>>> > 2.8.0.rc3
>>> >
>>> > _______________________________________________
>>> > dri-devel mailing list
>>> > dri-devel@lists.freedesktop.org
>>> > https://lists.freedesktop.org/mailman/listinfo/dri-devel
>>
>>
>
_______________________________________________
dri-devel mailing list
dri-devel@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/dri-devel
^ permalink raw reply [flat|nested] 9+ messages in thread* Re: [PATCH 2/2] drm/amd/powerplay: Delete unused functions in ppevvmath.h
2016-07-15 21:06 ` Alex Deucher
@ 2016-07-16 3:51 ` Nils Wallménius
2016-07-19 16:22 ` Nils Wallménius
0 siblings, 1 reply; 9+ messages in thread
From: Nils Wallménius @ 2016-07-16 3:51 UTC (permalink / raw)
To: Alex Deucher; +Cc: Maling list - DRI developers
[-- Attachment #1.1: Type: text/plain, Size: 6846 bytes --]
Ok, cool. I will probably be able to do that on monday.
Nils
Den 15 juli 2016 11:06 em skrev "Alex Deucher" <alexdeucher@gmail.com>:
> On Fri, Jul 15, 2016 at 4:09 PM, Nils Wallménius
> <nils.wallmenius@gmail.com> wrote:
> > Ping?
>
> We don't seem to be using them. Can you respin? It doesn't seem to
> apply any longer.
>
> Alex
>
>
> >
> >
> > Den 6 juni 2016 21:32 skrev "Nils Wallménius" <nils.wallmenius@gmail.com
> >:
> >>
> >> Hi Alex,
> >>
> >> Any response from the powerplay team?
> >>
> >> If they are unresponsive, would you prefer to #IF 0 the code instead of
> >> deleting?
> >>
> >> Regards
> >> Nils
> >>
> >> On Mon, Apr 25, 2016 at 10:08 PM, Alex Deucher <alexdeucher@gmail.com>
> >> wrote:
> >>>
> >>> On Sun, Apr 24, 2016 at 7:22 AM, Nils Wallménius
> >>> <nils.wallmenius@gmail.com> wrote:
> >>> > Signed-off-by: Nils Wallménius <nils.wallmenius@gmail.com>
> >>>
> >>> Let me check with the powerplay team and make sure they are planning
> >>> to use these in the near future.
> >>>
> >>> Alex
> >>>
> >>>
> >>> > ---
> >>> > drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h | 59
> >>> > +------------------------
> >>> > 1 file changed, 1 insertion(+), 58 deletions(-)
> >>> >
> >>> > diff --git a/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h
> >>> > b/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h
> >>> > index a9b40eb..8f50a03 100644
> >>> > --- a/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h
> >>> > +++ b/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h
> >>> > @@ -64,7 +64,6 @@ static fInt fGetSquare(fInt);
> >>> > /* Returns the square
> >>> > static fInt fSqrt(fInt); /* Returns
> >>> > the Square Root of a fInt number */
> >>> >
> >>> > static int uAbs(int); /* Returns
> >>> > the Absolute value of the Int */
> >>> > -static fInt fAbs(fInt); /* Returns
> >>> > the Absolute value of the fInt */
> >>> > static int uPow(int base, int exponent); /* Returns
> >>> > base^exponent an INT */
> >>> >
> >>> > static void SolveQuadracticEqn(fInt, fInt, fInt, fInt[]); /* Returns
> >>> > the 2 roots via the array */
> >>> > @@ -85,21 +84,12 @@ static fInt fDecodeLeakageID (uint32_t
> >>> > leakageID_fuse, fInt ln_max_div_min, fInt
> >>> > *
> >>> >
> -------------------------------------------------------------------------------------
> >>> > * Some of the following functions take two INTs as their input -
> This
> >>> > is unsafe for a variety of reasons.
> >>> > */
> >>> > -static fInt Add (int, int); /* Add two
> >>> > INTs and return Sum as FINT */
> >>> > -static fInt Multiply (int, int); /*
> Multiply
> >>> > two INTs and return Product as FINT */
> >>> > -static fInt Divide (int, int); /* You get
> >>> > the idea... */
> >>> > +static fInt Divide (int, int); /* Divide
> >>> > two INTs and return result as FINT */
> >>> > static fInt fNegate(fInt);
> >>> >
> >>> > static int uGetScaledDecimal (fInt); /*
> Internal
> >>> > function */
> >>> > static int GetReal (fInt A); /*
> Internal
> >>> > function */
> >>> >
> >>> > -/* Future Additions and Incomplete Functions
> >>> > - *
> >>> >
> -------------------------------------------------------------------------------------
> >>> > - */
> >>> > -static int GetRoundedValue(fInt); /*
> >>> > Incomplete function - Useful only when Precision is lacking */
> >>> > - /* Let us
> >>> > say we have 2.126 but can only handle 2 decimal points. We could */
> >>> > - /* either
> >>> > chop of 6 and keep 2.12 or use this function to get 2.13, which is
> more
> >>> > accurate */
> >>> > -
> >>> > /*
> >>> >
> -------------------------------------------------------------------------------------
> >>> > * TROUBLESHOOTING INFORMATION
> >>> > *
> >>> >
> -------------------------------------------------------------------------------------
> >>> > @@ -498,51 +488,12 @@ static void SolveQuadracticEqn(fInt A, fInt B,
> >>> > fInt C, fInt Roots[])
> >>> > *
> >>> >
> -----------------------------------------------------------------------------
> >>> > */
> >>> >
> >>> > -/* Addition using two normal ints - Temporary - Use only for testing
> >>> > purposes?. */
> >>> > -static fInt Add (int X, int Y)
> >>> > -{
> >>> > - fInt A, B, Sum;
> >>> > -
> >>> > - A.full = (X << SHIFT_AMOUNT);
> >>> > - B.full = (Y << SHIFT_AMOUNT);
> >>> > -
> >>> > - Sum.full = A.full + B.full;
> >>> > -
> >>> > - return Sum;
> >>> > -}
> >>> > -
> >>> > /* Conversion Functions */
> >>> > static int GetReal (fInt A)
> >>> > {
> >>> > return (A.full >> SHIFT_AMOUNT);
> >>> > }
> >>> >
> >>> > -/* Temporarily Disabled */
> >>> > -static int GetRoundedValue(fInt A) /*For now, round the 3rd decimal
> >>> > place */
> >>> > -{
> >>> > - /* ROUNDING TEMPORARLY DISABLED
> >>> > - int temp = A.full;
> >>> > - int decimal_cutoff, decimal_mask = 0x000001FF;
> >>> > - decimal_cutoff = temp & decimal_mask;
> >>> > - if (decimal_cutoff > 0x147) {
> >>> > - temp += 673;
> >>> > - }*/
> >>> > -
> >>> > - return ConvertBackToInteger(A)/10000; /*Temporary - in case
> >>> > this was used somewhere else */
> >>> > -}
> >>> > -
> >>> > -static fInt Multiply (int X, int Y)
> >>> > -{
> >>> > - fInt A, B, Product;
> >>> > -
> >>> > - A.full = X << SHIFT_AMOUNT;
> >>> > - B.full = Y << SHIFT_AMOUNT;
> >>> > -
> >>> > - Product = fMultiply(A, B);
> >>> > -
> >>> > - return Product;
> >>> > -}
> >>> > -
> >>> > static fInt Divide (int X, int Y)
> >>> > {
> >>> > fInt A, B, Quotient;
> >>> > @@ -578,14 +529,6 @@ static int uPow(int base, int power)
> >>> > return (base)*uPow(base, power - 1);
> >>> > }
> >>> >
> >>> > -static fInt fAbs(fInt A)
> >>> > -{
> >>> > - if (A.partial.real < 0)
> >>> > - return (fMultiply(A, ConvertToFraction(-1)));
> >>> > - else
> >>> > - return A;
> >>> > -}
> >>> > -
> >>> > static int uAbs(int X)
> >>> > {
> >>> > if (X < 0)
> >>> > --
> >>> > 2.8.0.rc3
> >>> >
> >>> > _______________________________________________
> >>> > dri-devel mailing list
> >>> > dri-devel@lists.freedesktop.org
> >>> > https://lists.freedesktop.org/mailman/listinfo/dri-devel
> >>
> >>
> >
>
[-- Attachment #1.2: Type: text/html, Size: 10234 bytes --]
[-- Attachment #2: Type: text/plain, Size: 160 bytes --]
_______________________________________________
dri-devel mailing list
dri-devel@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/dri-devel
^ permalink raw reply [flat|nested] 9+ messages in thread* Re: [PATCH 2/2] drm/amd/powerplay: Delete unused functions in ppevvmath.h
2016-07-16 3:51 ` Nils Wallménius
@ 2016-07-19 16:22 ` Nils Wallménius
2016-07-28 16:19 ` Alex Deucher
0 siblings, 1 reply; 9+ messages in thread
From: Nils Wallménius @ 2016-07-19 16:22 UTC (permalink / raw)
To: Alex Deucher; +Cc: Maling list - DRI developers
[-- Attachment #1.1: Type: text/plain, Size: 7632 bytes --]
Hi,
This patch applies cleanly for me on top of the first patch in this series
[1] on top of your drm-next-4.8 tree.
The series was held up to figure out what to do about the unused functions
as patch 1 introduced warnings. I can still respin if you'd like as now
that i know the functions should be removed, doing that first makes a bit
more sense I guess.
Nils
[1]: https://lists.freedesktop.org/archives/dri-devel/2016-April/105648.html
On Sat, Jul 16, 2016 at 5:51 AM, Nils Wallménius <nils.wallmenius@gmail.com>
wrote:
> Ok, cool. I will probably be able to do that on monday.
>
> Nils
>
> Den 15 juli 2016 11:06 em skrev "Alex Deucher" <alexdeucher@gmail.com>:
>
>> On Fri, Jul 15, 2016 at 4:09 PM, Nils Wallménius
>> <nils.wallmenius@gmail.com> wrote:
>> > Ping?
>>
>> We don't seem to be using them. Can you respin? It doesn't seem to
>> apply any longer.
>>
>> Alex
>>
>>
>> >
>> >
>> > Den 6 juni 2016 21:32 skrev "Nils Wallménius" <
>> nils.wallmenius@gmail.com>:
>> >>
>> >> Hi Alex,
>> >>
>> >> Any response from the powerplay team?
>> >>
>> >> If they are unresponsive, would you prefer to #IF 0 the code instead of
>> >> deleting?
>> >>
>> >> Regards
>> >> Nils
>> >>
>> >> On Mon, Apr 25, 2016 at 10:08 PM, Alex Deucher <alexdeucher@gmail.com>
>> >> wrote:
>> >>>
>> >>> On Sun, Apr 24, 2016 at 7:22 AM, Nils Wallménius
>> >>> <nils.wallmenius@gmail.com> wrote:
>> >>> > Signed-off-by: Nils Wallménius <nils.wallmenius@gmail.com>
>> >>>
>> >>> Let me check with the powerplay team and make sure they are planning
>> >>> to use these in the near future.
>> >>>
>> >>> Alex
>> >>>
>> >>>
>> >>> > ---
>> >>> > drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h | 59
>> >>> > +------------------------
>> >>> > 1 file changed, 1 insertion(+), 58 deletions(-)
>> >>> >
>> >>> > diff --git a/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h
>> >>> > b/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h
>> >>> > index a9b40eb..8f50a03 100644
>> >>> > --- a/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h
>> >>> > +++ b/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h
>> >>> > @@ -64,7 +64,6 @@ static fInt fGetSquare(fInt);
>> >>> > /* Returns the square
>> >>> > static fInt fSqrt(fInt); /*
>> Returns
>> >>> > the Square Root of a fInt number */
>> >>> >
>> >>> > static int uAbs(int); /*
>> Returns
>> >>> > the Absolute value of the Int */
>> >>> > -static fInt fAbs(fInt); /*
>> Returns
>> >>> > the Absolute value of the fInt */
>> >>> > static int uPow(int base, int exponent); /*
>> Returns
>> >>> > base^exponent an INT */
>> >>> >
>> >>> > static void SolveQuadracticEqn(fInt, fInt, fInt, fInt[]); /*
>> Returns
>> >>> > the 2 roots via the array */
>> >>> > @@ -85,21 +84,12 @@ static fInt fDecodeLeakageID (uint32_t
>> >>> > leakageID_fuse, fInt ln_max_div_min, fInt
>> >>> > *
>> >>> >
>> -------------------------------------------------------------------------------------
>> >>> > * Some of the following functions take two INTs as their input -
>> This
>> >>> > is unsafe for a variety of reasons.
>> >>> > */
>> >>> > -static fInt Add (int, int); /* Add
>> two
>> >>> > INTs and return Sum as FINT */
>> >>> > -static fInt Multiply (int, int); /*
>> Multiply
>> >>> > two INTs and return Product as FINT */
>> >>> > -static fInt Divide (int, int); /* You
>> get
>> >>> > the idea... */
>> >>> > +static fInt Divide (int, int); /* Divide
>> >>> > two INTs and return result as FINT */
>> >>> > static fInt fNegate(fInt);
>> >>> >
>> >>> > static int uGetScaledDecimal (fInt); /*
>> Internal
>> >>> > function */
>> >>> > static int GetReal (fInt A); /*
>> Internal
>> >>> > function */
>> >>> >
>> >>> > -/* Future Additions and Incomplete Functions
>> >>> > - *
>> >>> >
>> -------------------------------------------------------------------------------------
>> >>> > - */
>> >>> > -static int GetRoundedValue(fInt); /*
>> >>> > Incomplete function - Useful only when Precision is lacking */
>> >>> > - /* Let us
>> >>> > say we have 2.126 but can only handle 2 decimal points. We could */
>> >>> > - /* either
>> >>> > chop of 6 and keep 2.12 or use this function to get 2.13, which is
>> more
>> >>> > accurate */
>> >>> > -
>> >>> > /*
>> >>> >
>> -------------------------------------------------------------------------------------
>> >>> > * TROUBLESHOOTING INFORMATION
>> >>> > *
>> >>> >
>> -------------------------------------------------------------------------------------
>> >>> > @@ -498,51 +488,12 @@ static void SolveQuadracticEqn(fInt A, fInt B,
>> >>> > fInt C, fInt Roots[])
>> >>> > *
>> >>> >
>> -----------------------------------------------------------------------------
>> >>> > */
>> >>> >
>> >>> > -/* Addition using two normal ints - Temporary - Use only for
>> testing
>> >>> > purposes?. */
>> >>> > -static fInt Add (int X, int Y)
>> >>> > -{
>> >>> > - fInt A, B, Sum;
>> >>> > -
>> >>> > - A.full = (X << SHIFT_AMOUNT);
>> >>> > - B.full = (Y << SHIFT_AMOUNT);
>> >>> > -
>> >>> > - Sum.full = A.full + B.full;
>> >>> > -
>> >>> > - return Sum;
>> >>> > -}
>> >>> > -
>> >>> > /* Conversion Functions */
>> >>> > static int GetReal (fInt A)
>> >>> > {
>> >>> > return (A.full >> SHIFT_AMOUNT);
>> >>> > }
>> >>> >
>> >>> > -/* Temporarily Disabled */
>> >>> > -static int GetRoundedValue(fInt A) /*For now, round the 3rd decimal
>> >>> > place */
>> >>> > -{
>> >>> > - /* ROUNDING TEMPORARLY DISABLED
>> >>> > - int temp = A.full;
>> >>> > - int decimal_cutoff, decimal_mask = 0x000001FF;
>> >>> > - decimal_cutoff = temp & decimal_mask;
>> >>> > - if (decimal_cutoff > 0x147) {
>> >>> > - temp += 673;
>> >>> > - }*/
>> >>> > -
>> >>> > - return ConvertBackToInteger(A)/10000; /*Temporary - in case
>> >>> > this was used somewhere else */
>> >>> > -}
>> >>> > -
>> >>> > -static fInt Multiply (int X, int Y)
>> >>> > -{
>> >>> > - fInt A, B, Product;
>> >>> > -
>> >>> > - A.full = X << SHIFT_AMOUNT;
>> >>> > - B.full = Y << SHIFT_AMOUNT;
>> >>> > -
>> >>> > - Product = fMultiply(A, B);
>> >>> > -
>> >>> > - return Product;
>> >>> > -}
>> >>> > -
>> >>> > static fInt Divide (int X, int Y)
>> >>> > {
>> >>> > fInt A, B, Quotient;
>> >>> > @@ -578,14 +529,6 @@ static int uPow(int base, int power)
>> >>> > return (base)*uPow(base, power - 1);
>> >>> > }
>> >>> >
>> >>> > -static fInt fAbs(fInt A)
>> >>> > -{
>> >>> > - if (A.partial.real < 0)
>> >>> > - return (fMultiply(A, ConvertToFraction(-1)));
>> >>> > - else
>> >>> > - return A;
>> >>> > -}
>> >>> > -
>> >>> > static int uAbs(int X)
>> >>> > {
>> >>> > if (X < 0)
>> >>> > --
>> >>> > 2.8.0.rc3
>> >>> >
>> >>> > _______________________________________________
>> >>> > dri-devel mailing list
>> >>> > dri-devel@lists.freedesktop.org
>> >>> > https://lists.freedesktop.org/mailman/listinfo/dri-devel
>> >>
>> >>
>> >
>>
>
[-- Attachment #1.2: Type: text/html, Size: 11468 bytes --]
[-- Attachment #2: Type: text/plain, Size: 160 bytes --]
_______________________________________________
dri-devel mailing list
dri-devel@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/dri-devel
^ permalink raw reply [flat|nested] 9+ messages in thread* Re: [PATCH 2/2] drm/amd/powerplay: Delete unused functions in ppevvmath.h
2016-07-19 16:22 ` Nils Wallménius
@ 2016-07-28 16:19 ` Alex Deucher
0 siblings, 0 replies; 9+ messages in thread
From: Alex Deucher @ 2016-07-28 16:19 UTC (permalink / raw)
To: Nils Wallménius; +Cc: Maling list - DRI developers
On Tue, Jul 19, 2016 at 12:22 PM, Nils Wallménius
<nils.wallmenius@gmail.com> wrote:
> Hi,
>
> This patch applies cleanly for me on top of the first patch in this series
> [1] on top of your drm-next-4.8 tree.
>
> The series was held up to figure out what to do about the unused functions
> as patch 1 introduced warnings. I can still respin if you'd like as now that
> i know the functions should be removed, doing that first makes a bit more
> sense I guess.
Sorry, I missed the first patch. Applied the series. Sorry for the delay.
Alex
>
> Nils
>
> [1]: https://lists.freedesktop.org/archives/dri-devel/2016-April/105648.html
>
> On Sat, Jul 16, 2016 at 5:51 AM, Nils Wallménius <nils.wallmenius@gmail.com>
> wrote:
>>
>> Ok, cool. I will probably be able to do that on monday.
>>
>> Nils
>>
>>
>> Den 15 juli 2016 11:06 em skrev "Alex Deucher" <alexdeucher@gmail.com>:
>>>
>>> On Fri, Jul 15, 2016 at 4:09 PM, Nils Wallménius
>>> <nils.wallmenius@gmail.com> wrote:
>>> > Ping?
>>>
>>> We don't seem to be using them. Can you respin? It doesn't seem to
>>> apply any longer.
>>>
>>> Alex
>>>
>>>
>>> >
>>> >
>>> > Den 6 juni 2016 21:32 skrev "Nils Wallménius"
>>> > <nils.wallmenius@gmail.com>:
>>> >>
>>> >> Hi Alex,
>>> >>
>>> >> Any response from the powerplay team?
>>> >>
>>> >> If they are unresponsive, would you prefer to #IF 0 the code instead
>>> >> of
>>> >> deleting?
>>> >>
>>> >> Regards
>>> >> Nils
>>> >>
>>> >> On Mon, Apr 25, 2016 at 10:08 PM, Alex Deucher <alexdeucher@gmail.com>
>>> >> wrote:
>>> >>>
>>> >>> On Sun, Apr 24, 2016 at 7:22 AM, Nils Wallménius
>>> >>> <nils.wallmenius@gmail.com> wrote:
>>> >>> > Signed-off-by: Nils Wallménius <nils.wallmenius@gmail.com>
>>> >>>
>>> >>> Let me check with the powerplay team and make sure they are planning
>>> >>> to use these in the near future.
>>> >>>
>>> >>> Alex
>>> >>>
>>> >>>
>>> >>> > ---
>>> >>> > drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h | 59
>>> >>> > +------------------------
>>> >>> > 1 file changed, 1 insertion(+), 58 deletions(-)
>>> >>> >
>>> >>> > diff --git a/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h
>>> >>> > b/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h
>>> >>> > index a9b40eb..8f50a03 100644
>>> >>> > --- a/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h
>>> >>> > +++ b/drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h
>>> >>> > @@ -64,7 +64,6 @@ static fInt fGetSquare(fInt);
>>> >>> > /* Returns the square
>>> >>> > static fInt fSqrt(fInt); /*
>>> >>> > Returns
>>> >>> > the Square Root of a fInt number */
>>> >>> >
>>> >>> > static int uAbs(int); /*
>>> >>> > Returns
>>> >>> > the Absolute value of the Int */
>>> >>> > -static fInt fAbs(fInt); /*
>>> >>> > Returns
>>> >>> > the Absolute value of the fInt */
>>> >>> > static int uPow(int base, int exponent); /*
>>> >>> > Returns
>>> >>> > base^exponent an INT */
>>> >>> >
>>> >>> > static void SolveQuadracticEqn(fInt, fInt, fInt, fInt[]); /*
>>> >>> > Returns
>>> >>> > the 2 roots via the array */
>>> >>> > @@ -85,21 +84,12 @@ static fInt fDecodeLeakageID (uint32_t
>>> >>> > leakageID_fuse, fInt ln_max_div_min, fInt
>>> >>> > *
>>> >>> >
>>> >>> > -------------------------------------------------------------------------------------
>>> >>> > * Some of the following functions take two INTs as their input -
>>> >>> > This
>>> >>> > is unsafe for a variety of reasons.
>>> >>> > */
>>> >>> > -static fInt Add (int, int); /* Add
>>> >>> > two
>>> >>> > INTs and return Sum as FINT */
>>> >>> > -static fInt Multiply (int, int); /*
>>> >>> > Multiply
>>> >>> > two INTs and return Product as FINT */
>>> >>> > -static fInt Divide (int, int); /* You
>>> >>> > get
>>> >>> > the idea... */
>>> >>> > +static fInt Divide (int, int); /*
>>> >>> > Divide
>>> >>> > two INTs and return result as FINT */
>>> >>> > static fInt fNegate(fInt);
>>> >>> >
>>> >>> > static int uGetScaledDecimal (fInt); /*
>>> >>> > Internal
>>> >>> > function */
>>> >>> > static int GetReal (fInt A); /*
>>> >>> > Internal
>>> >>> > function */
>>> >>> >
>>> >>> > -/* Future Additions and Incomplete Functions
>>> >>> > - *
>>> >>> >
>>> >>> > -------------------------------------------------------------------------------------
>>> >>> > - */
>>> >>> > -static int GetRoundedValue(fInt); /*
>>> >>> > Incomplete function - Useful only when Precision is lacking */
>>> >>> > - /* Let
>>> >>> > us
>>> >>> > say we have 2.126 but can only handle 2 decimal points. We could */
>>> >>> > - /*
>>> >>> > either
>>> >>> > chop of 6 and keep 2.12 or use this function to get 2.13, which is
>>> >>> > more
>>> >>> > accurate */
>>> >>> > -
>>> >>> > /*
>>> >>> >
>>> >>> > -------------------------------------------------------------------------------------
>>> >>> > * TROUBLESHOOTING INFORMATION
>>> >>> > *
>>> >>> >
>>> >>> > -------------------------------------------------------------------------------------
>>> >>> > @@ -498,51 +488,12 @@ static void SolveQuadracticEqn(fInt A, fInt
>>> >>> > B,
>>> >>> > fInt C, fInt Roots[])
>>> >>> > *
>>> >>> >
>>> >>> > -----------------------------------------------------------------------------
>>> >>> > */
>>> >>> >
>>> >>> > -/* Addition using two normal ints - Temporary - Use only for
>>> >>> > testing
>>> >>> > purposes?. */
>>> >>> > -static fInt Add (int X, int Y)
>>> >>> > -{
>>> >>> > - fInt A, B, Sum;
>>> >>> > -
>>> >>> > - A.full = (X << SHIFT_AMOUNT);
>>> >>> > - B.full = (Y << SHIFT_AMOUNT);
>>> >>> > -
>>> >>> > - Sum.full = A.full + B.full;
>>> >>> > -
>>> >>> > - return Sum;
>>> >>> > -}
>>> >>> > -
>>> >>> > /* Conversion Functions */
>>> >>> > static int GetReal (fInt A)
>>> >>> > {
>>> >>> > return (A.full >> SHIFT_AMOUNT);
>>> >>> > }
>>> >>> >
>>> >>> > -/* Temporarily Disabled */
>>> >>> > -static int GetRoundedValue(fInt A) /*For now, round the 3rd
>>> >>> > decimal
>>> >>> > place */
>>> >>> > -{
>>> >>> > - /* ROUNDING TEMPORARLY DISABLED
>>> >>> > - int temp = A.full;
>>> >>> > - int decimal_cutoff, decimal_mask = 0x000001FF;
>>> >>> > - decimal_cutoff = temp & decimal_mask;
>>> >>> > - if (decimal_cutoff > 0x147) {
>>> >>> > - temp += 673;
>>> >>> > - }*/
>>> >>> > -
>>> >>> > - return ConvertBackToInteger(A)/10000; /*Temporary - in case
>>> >>> > this was used somewhere else */
>>> >>> > -}
>>> >>> > -
>>> >>> > -static fInt Multiply (int X, int Y)
>>> >>> > -{
>>> >>> > - fInt A, B, Product;
>>> >>> > -
>>> >>> > - A.full = X << SHIFT_AMOUNT;
>>> >>> > - B.full = Y << SHIFT_AMOUNT;
>>> >>> > -
>>> >>> > - Product = fMultiply(A, B);
>>> >>> > -
>>> >>> > - return Product;
>>> >>> > -}
>>> >>> > -
>>> >>> > static fInt Divide (int X, int Y)
>>> >>> > {
>>> >>> > fInt A, B, Quotient;
>>> >>> > @@ -578,14 +529,6 @@ static int uPow(int base, int power)
>>> >>> > return (base)*uPow(base, power - 1);
>>> >>> > }
>>> >>> >
>>> >>> > -static fInt fAbs(fInt A)
>>> >>> > -{
>>> >>> > - if (A.partial.real < 0)
>>> >>> > - return (fMultiply(A, ConvertToFraction(-1)));
>>> >>> > - else
>>> >>> > - return A;
>>> >>> > -}
>>> >>> > -
>>> >>> > static int uAbs(int X)
>>> >>> > {
>>> >>> > if (X < 0)
>>> >>> > --
>>> >>> > 2.8.0.rc3
>>> >>> >
>>> >>> > _______________________________________________
>>> >>> > dri-devel mailing list
>>> >>> > dri-devel@lists.freedesktop.org
>>> >>> > https://lists.freedesktop.org/mailman/listinfo/dri-devel
>>> >>
>>> >>
>>> >
>
>
_______________________________________________
dri-devel mailing list
dri-devel@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/dri-devel
^ permalink raw reply [flat|nested] 9+ messages in thread
end of thread, other threads:[~2016-07-28 16:19 UTC | newest]
Thread overview: 9+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2016-04-24 11:22 [PATCH 1/2] drm/amd/powerplay: Mark functions of ppevvmath.h static Nils Wallménius
2016-04-24 11:22 ` [PATCH 2/2] drm/amd/powerplay: Delete unused functions in ppevvmath.h Nils Wallménius
2016-04-25 20:08 ` Alex Deucher
2016-06-06 19:32 ` Nils Wallménius
2016-07-15 20:09 ` Nils Wallménius
2016-07-15 21:06 ` Alex Deucher
2016-07-16 3:51 ` Nils Wallménius
2016-07-19 16:22 ` Nils Wallménius
2016-07-28 16:19 ` Alex Deucher
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.