All of lore.kernel.org
 help / color / mirror / Atom feed
* [PATCH] drm/amd/display: Use kvzalloc for potentially large allocations
@ 2018-04-24 15:03 Michel Dänzer
       [not found] ` <20180424150315.6176-1-michel-otUistvHUpPR7s880joybQ@public.gmane.org>
  0 siblings, 1 reply; 2+ messages in thread
From: Michel Dänzer @ 2018-04-24 15:03 UTC (permalink / raw)
  To: amd-gfx-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW

From: Michel Dänzer <michel.daenzer@amd.com>

Allocating up to 32 physically contiguous pages can easily fail (and has
failed for me), and isn't necessary anyway.

Signed-off-by: Michel Dänzer <michel.daenzer@amd.com>
---
 .../gpu/drm/amd/display/dc/core/dc_surface.c  | 14 ++--
 .../amd/display/modules/color/color_gamma.c   | 72 ++++++++++---------
 2 files changed, 45 insertions(+), 41 deletions(-)

diff --git a/drivers/gpu/drm/amd/display/dc/core/dc_surface.c b/drivers/gpu/drm/amd/display/dc/core/dc_surface.c
index 959387705965..68a71adeb12e 100644
--- a/drivers/gpu/drm/amd/display/dc/core/dc_surface.c
+++ b/drivers/gpu/drm/amd/display/dc/core/dc_surface.c
@@ -72,8 +72,8 @@ struct dc_plane_state *dc_create_plane_state(struct dc *dc)
 {
 	struct dc *core_dc = dc;
 
-	struct dc_plane_state *plane_state = kzalloc(sizeof(*plane_state),
-						     GFP_KERNEL);
+	struct dc_plane_state *plane_state = kvzalloc(sizeof(*plane_state),
+						      GFP_KERNEL);
 
 	if (NULL == plane_state)
 		return NULL;
@@ -126,7 +126,7 @@ static void dc_plane_state_free(struct kref *kref)
 {
 	struct dc_plane_state *plane_state = container_of(kref, struct dc_plane_state, refcount);
 	destruct(plane_state);
-	kfree(plane_state);
+	kvfree(plane_state);
 }
 
 void dc_plane_state_release(struct dc_plane_state *plane_state)
@@ -142,7 +142,7 @@ void dc_gamma_retain(struct dc_gamma *gamma)
 static void dc_gamma_free(struct kref *kref)
 {
 	struct dc_gamma *gamma = container_of(kref, struct dc_gamma, refcount);
-	kfree(gamma);
+	kvfree(gamma);
 }
 
 void dc_gamma_release(struct dc_gamma **gamma)
@@ -153,7 +153,7 @@ void dc_gamma_release(struct dc_gamma **gamma)
 
 struct dc_gamma *dc_create_gamma(void)
 {
-	struct dc_gamma *gamma = kzalloc(sizeof(*gamma), GFP_KERNEL);
+	struct dc_gamma *gamma = kvzalloc(sizeof(*gamma), GFP_KERNEL);
 
 	if (gamma == NULL)
 		goto alloc_fail;
@@ -173,7 +173,7 @@ void dc_transfer_func_retain(struct dc_transfer_func *tf)
 static void dc_transfer_func_free(struct kref *kref)
 {
 	struct dc_transfer_func *tf = container_of(kref, struct dc_transfer_func, refcount);
-	kfree(tf);
+	kvfree(tf);
 }
 
 void dc_transfer_func_release(struct dc_transfer_func *tf)
@@ -183,7 +183,7 @@ void dc_transfer_func_release(struct dc_transfer_func *tf)
 
 struct dc_transfer_func *dc_create_transfer_func()
 {
-	struct dc_transfer_func *tf = kzalloc(sizeof(*tf), GFP_KERNEL);
+	struct dc_transfer_func *tf = kvzalloc(sizeof(*tf), GFP_KERNEL);
 
 	if (tf == NULL)
 		goto alloc_fail;
diff --git a/drivers/gpu/drm/amd/display/modules/color/color_gamma.c b/drivers/gpu/drm/amd/display/modules/color/color_gamma.c
index e7e374f56864..b3747a019deb 100644
--- a/drivers/gpu/drm/amd/display/modules/color/color_gamma.c
+++ b/drivers/gpu/drm/amd/display/modules/color/color_gamma.c
@@ -1093,19 +1093,19 @@ bool mod_color_calculate_regamma_params(struct dc_transfer_func *output_tf,
 
 	output_tf->type = TF_TYPE_DISTRIBUTED_POINTS;
 
-	rgb_user = kzalloc(sizeof(*rgb_user) * (ramp->num_entries + _EXTRA_POINTS),
-			   GFP_KERNEL);
+	rgb_user = kvzalloc(sizeof(*rgb_user) * (ramp->num_entries + _EXTRA_POINTS),
+			    GFP_KERNEL);
 	if (!rgb_user)
 		goto rgb_user_alloc_fail;
-	rgb_regamma = kzalloc(sizeof(*rgb_regamma) * (MAX_HW_POINTS + _EXTRA_POINTS),
-			GFP_KERNEL);
+	rgb_regamma = kvzalloc(sizeof(*rgb_regamma) * (MAX_HW_POINTS + _EXTRA_POINTS),
+			       GFP_KERNEL);
 	if (!rgb_regamma)
 		goto rgb_regamma_alloc_fail;
-	axix_x = kzalloc(sizeof(*axix_x) * (ramp->num_entries + 3),
-			 GFP_KERNEL);
+	axix_x = kvzalloc(sizeof(*axix_x) * (ramp->num_entries + 3),
+			  GFP_KERNEL);
 	if (!axix_x)
 		goto axix_x_alloc_fail;
-	coeff = kzalloc(sizeof(*coeff) * (MAX_HW_POINTS + _EXTRA_POINTS), GFP_KERNEL);
+	coeff = kvzalloc(sizeof(*coeff) * (MAX_HW_POINTS + _EXTRA_POINTS), GFP_KERNEL);
 	if (!coeff)
 		goto coeff_alloc_fail;
 
@@ -1157,13 +1157,13 @@ bool mod_color_calculate_regamma_params(struct dc_transfer_func *output_tf,
 
 	ret = true;
 
-	kfree(coeff);
+	kvfree(coeff);
 coeff_alloc_fail:
-	kfree(axix_x);
+	kvfree(axix_x);
 axix_x_alloc_fail:
-	kfree(rgb_regamma);
+	kvfree(rgb_regamma);
 rgb_regamma_alloc_fail:
-	kfree(rgb_user);
+	kvfree(rgb_user);
 rgb_user_alloc_fail:
 	return ret;
 }
@@ -1192,19 +1192,19 @@ bool mod_color_calculate_degamma_params(struct dc_transfer_func *input_tf,
 
 	input_tf->type = TF_TYPE_DISTRIBUTED_POINTS;
 
-	rgb_user = kzalloc(sizeof(*rgb_user) * (ramp->num_entries + _EXTRA_POINTS),
-			   GFP_KERNEL);
+	rgb_user = kvzalloc(sizeof(*rgb_user) * (ramp->num_entries + _EXTRA_POINTS),
+			    GFP_KERNEL);
 	if (!rgb_user)
 		goto rgb_user_alloc_fail;
-	curve = kzalloc(sizeof(*curve) * (MAX_HW_POINTS + _EXTRA_POINTS),
-			GFP_KERNEL);
+	curve = kvzalloc(sizeof(*curve) * (MAX_HW_POINTS + _EXTRA_POINTS),
+			 GFP_KERNEL);
 	if (!curve)
 		goto curve_alloc_fail;
-	axix_x = kzalloc(sizeof(*axix_x) * (ramp->num_entries + _EXTRA_POINTS),
-			 GFP_KERNEL);
+	axix_x = kvzalloc(sizeof(*axix_x) * (ramp->num_entries + _EXTRA_POINTS),
+			  GFP_KERNEL);
 	if (!axix_x)
 		goto axix_x_alloc_fail;
-	coeff = kzalloc(sizeof(*coeff) * (MAX_HW_POINTS + _EXTRA_POINTS), GFP_KERNEL);
+	coeff = kvzalloc(sizeof(*coeff) * (MAX_HW_POINTS + _EXTRA_POINTS), GFP_KERNEL);
 	if (!coeff)
 		goto coeff_alloc_fail;
 
@@ -1246,13 +1246,13 @@ bool mod_color_calculate_degamma_params(struct dc_transfer_func *input_tf,
 
 	ret = true;
 
-	kfree(coeff);
+	kvfree(coeff);
 coeff_alloc_fail:
-	kfree(axix_x);
+	kvfree(axix_x);
 axix_x_alloc_fail:
-	kfree(curve);
+	kvfree(curve);
 curve_alloc_fail:
-	kfree(rgb_user);
+	kvfree(rgb_user);
 rgb_user_alloc_fail:
 
 	return ret;
@@ -1281,8 +1281,9 @@ bool  mod_color_calculate_curve(enum dc_transfer_func_predefined trans,
 		}
 		ret = true;
 	} else if (trans == TRANSFER_FUNCTION_PQ) {
-		rgb_regamma = kzalloc(sizeof(*rgb_regamma) * (MAX_HW_POINTS +
-						_EXTRA_POINTS), GFP_KERNEL);
+		rgb_regamma = kvzalloc(sizeof(*rgb_regamma) *
+				       (MAX_HW_POINTS + _EXTRA_POINTS),
+				       GFP_KERNEL);
 		if (!rgb_regamma)
 			goto rgb_regamma_alloc_fail;
 		points->end_exponent = 7;
@@ -1302,11 +1303,12 @@ bool  mod_color_calculate_curve(enum dc_transfer_func_predefined trans,
 		}
 		ret = true;
 
-		kfree(rgb_regamma);
+		kvfree(rgb_regamma);
 	} else if (trans == TRANSFER_FUNCTION_SRGB ||
 			  trans == TRANSFER_FUNCTION_BT709) {
-		rgb_regamma = kzalloc(sizeof(*rgb_regamma) * (MAX_HW_POINTS +
-						_EXTRA_POINTS), GFP_KERNEL);
+		rgb_regamma = kvzalloc(sizeof(*rgb_regamma) *
+				       (MAX_HW_POINTS + _EXTRA_POINTS),
+				       GFP_KERNEL);
 		if (!rgb_regamma)
 			goto rgb_regamma_alloc_fail;
 		points->end_exponent = 0;
@@ -1324,7 +1326,7 @@ bool  mod_color_calculate_curve(enum dc_transfer_func_predefined trans,
 		}
 		ret = true;
 
-		kfree(rgb_regamma);
+		kvfree(rgb_regamma);
 	}
 rgb_regamma_alloc_fail:
 	return ret;
@@ -1348,8 +1350,9 @@ bool  mod_color_calculate_degamma_curve(enum dc_transfer_func_predefined trans,
 		}
 		ret = true;
 	} else if (trans == TRANSFER_FUNCTION_PQ) {
-		rgb_degamma = kzalloc(sizeof(*rgb_degamma) * (MAX_HW_POINTS +
-						_EXTRA_POINTS), GFP_KERNEL);
+		rgb_degamma = kvzalloc(sizeof(*rgb_degamma) *
+				       (MAX_HW_POINTS +	_EXTRA_POINTS),
+				       GFP_KERNEL);
 		if (!rgb_degamma)
 			goto rgb_degamma_alloc_fail;
 
@@ -1364,11 +1367,12 @@ bool  mod_color_calculate_degamma_curve(enum dc_transfer_func_predefined trans,
 		}
 		ret = true;
 
-		kfree(rgb_degamma);
+		kvfree(rgb_degamma);
 	} else if (trans == TRANSFER_FUNCTION_SRGB ||
 			  trans == TRANSFER_FUNCTION_BT709) {
-		rgb_degamma = kzalloc(sizeof(*rgb_degamma) * (MAX_HW_POINTS +
-						_EXTRA_POINTS), GFP_KERNEL);
+		rgb_degamma = kvzalloc(sizeof(*rgb_degamma) *
+				       (MAX_HW_POINTS + _EXTRA_POINTS),
+				       GFP_KERNEL);
 		if (!rgb_degamma)
 			goto rgb_degamma_alloc_fail;
 
@@ -1382,7 +1386,7 @@ bool  mod_color_calculate_degamma_curve(enum dc_transfer_func_predefined trans,
 		}
 		ret = true;
 
-		kfree(rgb_degamma);
+		kvfree(rgb_degamma);
 	}
 	points->end_exponent = 0;
 	points->x_point_at_y1_red = 1;
-- 
2.17.0

_______________________________________________
amd-gfx mailing list
amd-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/amd-gfx

^ permalink raw reply related	[flat|nested] 2+ messages in thread
* Re: [PATCH] drm/amd/display: Use kvzalloc for potentially large allocations
       [not found] ` <20180424150315.6176-1-michel-otUistvHUpPR7s880joybQ@public.gmane.org>
@ 2018-04-26 18:20   ` Harry Wentland
  0 siblings, 0 replies; 2+ messages in thread
From: Harry Wentland @ 2018-04-26 18:20 UTC (permalink / raw)
  To: Michel Dänzer, amd-gfx-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW

On 2018-04-24 11:03 AM, Michel Dänzer wrote:
> From: Michel Dänzer <michel.daenzer@amd.com>
> 
> Allocating up to 32 physically contiguous pages can easily fail (and has
> failed for me), and isn't necessary anyway.
> 
> Signed-off-by: Michel Dänzer <michel.daenzer@amd.com>

Reviewed-by: Harry Wentland <harry.wentland@amd.com>

Harry

> ---
>  .../gpu/drm/amd/display/dc/core/dc_surface.c  | 14 ++--
>  .../amd/display/modules/color/color_gamma.c   | 72 ++++++++++---------
>  2 files changed, 45 insertions(+), 41 deletions(-)
> 
> diff --git a/drivers/gpu/drm/amd/display/dc/core/dc_surface.c b/drivers/gpu/drm/amd/display/dc/core/dc_surface.c
> index 959387705965..68a71adeb12e 100644
> --- a/drivers/gpu/drm/amd/display/dc/core/dc_surface.c
> +++ b/drivers/gpu/drm/amd/display/dc/core/dc_surface.c
> @@ -72,8 +72,8 @@ struct dc_plane_state *dc_create_plane_state(struct dc *dc)
>  {
>  	struct dc *core_dc = dc;
>  
> -	struct dc_plane_state *plane_state = kzalloc(sizeof(*plane_state),
> -						     GFP_KERNEL);
> +	struct dc_plane_state *plane_state = kvzalloc(sizeof(*plane_state),
> +						      GFP_KERNEL);
>  
>  	if (NULL == plane_state)
>  		return NULL;
> @@ -126,7 +126,7 @@ static void dc_plane_state_free(struct kref *kref)
>  {
>  	struct dc_plane_state *plane_state = container_of(kref, struct dc_plane_state, refcount);
>  	destruct(plane_state);
> -	kfree(plane_state);
> +	kvfree(plane_state);
>  }
>  
>  void dc_plane_state_release(struct dc_plane_state *plane_state)
> @@ -142,7 +142,7 @@ void dc_gamma_retain(struct dc_gamma *gamma)
>  static void dc_gamma_free(struct kref *kref)
>  {
>  	struct dc_gamma *gamma = container_of(kref, struct dc_gamma, refcount);
> -	kfree(gamma);
> +	kvfree(gamma);
>  }
>  
>  void dc_gamma_release(struct dc_gamma **gamma)
> @@ -153,7 +153,7 @@ void dc_gamma_release(struct dc_gamma **gamma)
>  
>  struct dc_gamma *dc_create_gamma(void)
>  {
> -	struct dc_gamma *gamma = kzalloc(sizeof(*gamma), GFP_KERNEL);
> +	struct dc_gamma *gamma = kvzalloc(sizeof(*gamma), GFP_KERNEL);
>  
>  	if (gamma == NULL)
>  		goto alloc_fail;
> @@ -173,7 +173,7 @@ void dc_transfer_func_retain(struct dc_transfer_func *tf)
>  static void dc_transfer_func_free(struct kref *kref)
>  {
>  	struct dc_transfer_func *tf = container_of(kref, struct dc_transfer_func, refcount);
> -	kfree(tf);
> +	kvfree(tf);
>  }
>  
>  void dc_transfer_func_release(struct dc_transfer_func *tf)
> @@ -183,7 +183,7 @@ void dc_transfer_func_release(struct dc_transfer_func *tf)
>  
>  struct dc_transfer_func *dc_create_transfer_func()
>  {
> -	struct dc_transfer_func *tf = kzalloc(sizeof(*tf), GFP_KERNEL);
> +	struct dc_transfer_func *tf = kvzalloc(sizeof(*tf), GFP_KERNEL);
>  
>  	if (tf == NULL)
>  		goto alloc_fail;
> diff --git a/drivers/gpu/drm/amd/display/modules/color/color_gamma.c b/drivers/gpu/drm/amd/display/modules/color/color_gamma.c
> index e7e374f56864..b3747a019deb 100644
> --- a/drivers/gpu/drm/amd/display/modules/color/color_gamma.c
> +++ b/drivers/gpu/drm/amd/display/modules/color/color_gamma.c
> @@ -1093,19 +1093,19 @@ bool mod_color_calculate_regamma_params(struct dc_transfer_func *output_tf,
>  
>  	output_tf->type = TF_TYPE_DISTRIBUTED_POINTS;
>  
> -	rgb_user = kzalloc(sizeof(*rgb_user) * (ramp->num_entries + _EXTRA_POINTS),
> -			   GFP_KERNEL);
> +	rgb_user = kvzalloc(sizeof(*rgb_user) * (ramp->num_entries + _EXTRA_POINTS),
> +			    GFP_KERNEL);
>  	if (!rgb_user)
>  		goto rgb_user_alloc_fail;
> -	rgb_regamma = kzalloc(sizeof(*rgb_regamma) * (MAX_HW_POINTS + _EXTRA_POINTS),
> -			GFP_KERNEL);
> +	rgb_regamma = kvzalloc(sizeof(*rgb_regamma) * (MAX_HW_POINTS + _EXTRA_POINTS),
> +			       GFP_KERNEL);
>  	if (!rgb_regamma)
>  		goto rgb_regamma_alloc_fail;
> -	axix_x = kzalloc(sizeof(*axix_x) * (ramp->num_entries + 3),
> -			 GFP_KERNEL);
> +	axix_x = kvzalloc(sizeof(*axix_x) * (ramp->num_entries + 3),
> +			  GFP_KERNEL);
>  	if (!axix_x)
>  		goto axix_x_alloc_fail;
> -	coeff = kzalloc(sizeof(*coeff) * (MAX_HW_POINTS + _EXTRA_POINTS), GFP_KERNEL);
> +	coeff = kvzalloc(sizeof(*coeff) * (MAX_HW_POINTS + _EXTRA_POINTS), GFP_KERNEL);
>  	if (!coeff)
>  		goto coeff_alloc_fail;
>  
> @@ -1157,13 +1157,13 @@ bool mod_color_calculate_regamma_params(struct dc_transfer_func *output_tf,
>  
>  	ret = true;
>  
> -	kfree(coeff);
> +	kvfree(coeff);
>  coeff_alloc_fail:
> -	kfree(axix_x);
> +	kvfree(axix_x);
>  axix_x_alloc_fail:
> -	kfree(rgb_regamma);
> +	kvfree(rgb_regamma);
>  rgb_regamma_alloc_fail:
> -	kfree(rgb_user);
> +	kvfree(rgb_user);
>  rgb_user_alloc_fail:
>  	return ret;
>  }
> @@ -1192,19 +1192,19 @@ bool mod_color_calculate_degamma_params(struct dc_transfer_func *input_tf,
>  
>  	input_tf->type = TF_TYPE_DISTRIBUTED_POINTS;
>  
> -	rgb_user = kzalloc(sizeof(*rgb_user) * (ramp->num_entries + _EXTRA_POINTS),
> -			   GFP_KERNEL);
> +	rgb_user = kvzalloc(sizeof(*rgb_user) * (ramp->num_entries + _EXTRA_POINTS),
> +			    GFP_KERNEL);
>  	if (!rgb_user)
>  		goto rgb_user_alloc_fail;
> -	curve = kzalloc(sizeof(*curve) * (MAX_HW_POINTS + _EXTRA_POINTS),
> -			GFP_KERNEL);
> +	curve = kvzalloc(sizeof(*curve) * (MAX_HW_POINTS + _EXTRA_POINTS),
> +			 GFP_KERNEL);
>  	if (!curve)
>  		goto curve_alloc_fail;
> -	axix_x = kzalloc(sizeof(*axix_x) * (ramp->num_entries + _EXTRA_POINTS),
> -			 GFP_KERNEL);
> +	axix_x = kvzalloc(sizeof(*axix_x) * (ramp->num_entries + _EXTRA_POINTS),
> +			  GFP_KERNEL);
>  	if (!axix_x)
>  		goto axix_x_alloc_fail;
> -	coeff = kzalloc(sizeof(*coeff) * (MAX_HW_POINTS + _EXTRA_POINTS), GFP_KERNEL);
> +	coeff = kvzalloc(sizeof(*coeff) * (MAX_HW_POINTS + _EXTRA_POINTS), GFP_KERNEL);
>  	if (!coeff)
>  		goto coeff_alloc_fail;
>  
> @@ -1246,13 +1246,13 @@ bool mod_color_calculate_degamma_params(struct dc_transfer_func *input_tf,
>  
>  	ret = true;
>  
> -	kfree(coeff);
> +	kvfree(coeff);
>  coeff_alloc_fail:
> -	kfree(axix_x);
> +	kvfree(axix_x);
>  axix_x_alloc_fail:
> -	kfree(curve);
> +	kvfree(curve);
>  curve_alloc_fail:
> -	kfree(rgb_user);
> +	kvfree(rgb_user);
>  rgb_user_alloc_fail:
>  
>  	return ret;
> @@ -1281,8 +1281,9 @@ bool  mod_color_calculate_curve(enum dc_transfer_func_predefined trans,
>  		}
>  		ret = true;
>  	} else if (trans == TRANSFER_FUNCTION_PQ) {
> -		rgb_regamma = kzalloc(sizeof(*rgb_regamma) * (MAX_HW_POINTS +
> -						_EXTRA_POINTS), GFP_KERNEL);
> +		rgb_regamma = kvzalloc(sizeof(*rgb_regamma) *
> +				       (MAX_HW_POINTS + _EXTRA_POINTS),
> +				       GFP_KERNEL);
>  		if (!rgb_regamma)
>  			goto rgb_regamma_alloc_fail;
>  		points->end_exponent = 7;
> @@ -1302,11 +1303,12 @@ bool  mod_color_calculate_curve(enum dc_transfer_func_predefined trans,
>  		}
>  		ret = true;
>  
> -		kfree(rgb_regamma);
> +		kvfree(rgb_regamma);
>  	} else if (trans == TRANSFER_FUNCTION_SRGB ||
>  			  trans == TRANSFER_FUNCTION_BT709) {
> -		rgb_regamma = kzalloc(sizeof(*rgb_regamma) * (MAX_HW_POINTS +
> -						_EXTRA_POINTS), GFP_KERNEL);
> +		rgb_regamma = kvzalloc(sizeof(*rgb_regamma) *
> +				       (MAX_HW_POINTS + _EXTRA_POINTS),
> +				       GFP_KERNEL);
>  		if (!rgb_regamma)
>  			goto rgb_regamma_alloc_fail;
>  		points->end_exponent = 0;
> @@ -1324,7 +1326,7 @@ bool  mod_color_calculate_curve(enum dc_transfer_func_predefined trans,
>  		}
>  		ret = true;
>  
> -		kfree(rgb_regamma);
> +		kvfree(rgb_regamma);
>  	}
>  rgb_regamma_alloc_fail:
>  	return ret;
> @@ -1348,8 +1350,9 @@ bool  mod_color_calculate_degamma_curve(enum dc_transfer_func_predefined trans,
>  		}
>  		ret = true;
>  	} else if (trans == TRANSFER_FUNCTION_PQ) {
> -		rgb_degamma = kzalloc(sizeof(*rgb_degamma) * (MAX_HW_POINTS +
> -						_EXTRA_POINTS), GFP_KERNEL);
> +		rgb_degamma = kvzalloc(sizeof(*rgb_degamma) *
> +				       (MAX_HW_POINTS +	_EXTRA_POINTS),
> +				       GFP_KERNEL);
>  		if (!rgb_degamma)
>  			goto rgb_degamma_alloc_fail;
>  
> @@ -1364,11 +1367,12 @@ bool  mod_color_calculate_degamma_curve(enum dc_transfer_func_predefined trans,
>  		}
>  		ret = true;
>  
> -		kfree(rgb_degamma);
> +		kvfree(rgb_degamma);
>  	} else if (trans == TRANSFER_FUNCTION_SRGB ||
>  			  trans == TRANSFER_FUNCTION_BT709) {
> -		rgb_degamma = kzalloc(sizeof(*rgb_degamma) * (MAX_HW_POINTS +
> -						_EXTRA_POINTS), GFP_KERNEL);
> +		rgb_degamma = kvzalloc(sizeof(*rgb_degamma) *
> +				       (MAX_HW_POINTS + _EXTRA_POINTS),
> +				       GFP_KERNEL);
>  		if (!rgb_degamma)
>  			goto rgb_degamma_alloc_fail;
>  
> @@ -1382,7 +1386,7 @@ bool  mod_color_calculate_degamma_curve(enum dc_transfer_func_predefined trans,
>  		}
>  		ret = true;
>  
> -		kfree(rgb_degamma);
> +		kvfree(rgb_degamma);
>  	}
>  	points->end_exponent = 0;
>  	points->x_point_at_y1_red = 1;
> 
_______________________________________________
amd-gfx mailing list
amd-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/amd-gfx

^ permalink raw reply	[flat|nested] 2+ messages in thread
end of thread, other threads:[~2018-04-26 18:20 UTC | newest]

Thread overview: 2+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2018-04-24 15:03 [PATCH] drm/amd/display: Use kvzalloc for potentially large allocations Michel Dänzer
     [not found] ` <20180424150315.6176-1-michel-otUistvHUpPR7s880joybQ@public.gmane.org>
2018-04-26 18:20   ` Harry Wentland

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.