iv/linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

atomisp: remove sh_css_malloc indirections where we can

Browse Source 
Where we know the buffer size is reasonably constrained we can just use kmalloc,
and where it will be large vmalloc. This still leaves a pile in the middle.

Signed-off-by: Alan Cox <alan@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
This commit is contained in:
Alan Cox 2017-04-12 19:21:44 +01:00 committed by Greg Kroah-Hartman
parent da22013f7d
commit 94853b658a
4 changed files with 72 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

92
drivers/staging/media/atomisp/pci/atomisp2/css2400/sh_css.c
View File

@ -2492,19 +2492,19 @@ create_pipe(enum ia_css_pipe_mode mode,
return IA_CSS_ERR_INVALID_ARGUMENTS;
}
me = sh_css_malloc(sizeof(*me));
me = kmalloc(sizeof(*me), GFP_KERNEL);
if (!me)
return IA_CSS_ERR_CANNOT_ALLOCATE_MEMORY;
err = init_pipe_defaults(mode, me, copy_pipe);
if (err != IA_CSS_SUCCESS) {
sh_css_free(me);
kfree(me);
return err;
}
err = pipe_generate_pipe_num(me, &(me->pipe_num));
if (err != IA_CSS_SUCCESS) {
sh_css_free(me);
kfree(me);
return err;
}
@ -2631,7 +2631,7 @@ ia_css_pipe_destroy(struct ia_css_pipe *pipe)
if (pipe->config.acc_extension) {
ia_css_pipe_unload_extension(pipe, pipe->config.acc_extension);
}
sh_css_free(pipe);
kfree(pipe);
IA_CSS_LEAVE("err = %d", err);
return err;
}
@ -5764,14 +5764,14 @@ static enum ia_css_err load_video_binaries(struct ia_css_pipe *pipe)
if (err != IA_CSS_SUCCESS)
return err;
mycs->num_yuv_scaler = cas_scaler_descr.num_stage;
mycs->yuv_scaler_binary = sh_css_calloc(cas_scaler_descr.num_stage,
sizeof(struct ia_css_binary));
mycs->yuv_scaler_binary = kzalloc(cas_scaler_descr.num_stage *
sizeof(struct ia_css_binary), GFP_KERNEL);
if (mycs->yuv_scaler_binary == NULL) {
err = IA_CSS_ERR_CANNOT_ALLOCATE_MEMORY;
return err;
}
mycs->is_output_stage = sh_css_calloc(cas_scaler_descr.num_stage,
sizeof(bool));
mycs->is_output_stage = kzalloc(cas_scaler_descr.num_stage
* sizeof(bool), GFP_KERNEL);
if (mycs->is_output_stage == NULL) {
err = IA_CSS_ERR_CANNOT_ALLOCATE_MEMORY;
return err;
@ -5787,7 +5787,7 @@ static enum ia_css_err load_video_binaries(struct ia_css_pipe *pipe)
err = ia_css_binary_find(&yuv_scaler_descr,
&mycs->yuv_scaler_binary[i]);
if (err != IA_CSS_SUCCESS) {
sh_css_free(mycs->is_output_stage);
kfree(mycs->is_output_stage);
mycs->is_output_stage = NULL;
return err;
}
@ -6008,9 +6008,9 @@ unload_video_binaries(struct ia_css_pipe *pipe)
for (i = 0; i < pipe->pipe_settings.video.num_yuv_scaler; i++)
ia_css_binary_unload(&pipe->pipe_settings.video.yuv_scaler_binary[i]);
sh_css_free(pipe->pipe_settings.video.is_output_stage);
kfree(pipe->pipe_settings.video.is_output_stage);
pipe->pipe_settings.video.is_output_stage = NULL;
sh_css_free(pipe->pipe_settings.video.yuv_scaler_binary);
kfree(pipe->pipe_settings.video.yuv_scaler_binary);
pipe->pipe_settings.video.yuv_scaler_binary = NULL;
IA_CSS_LEAVE_ERR_PRIVATE(IA_CSS_SUCCESS);
@ -6418,15 +6418,15 @@ static enum ia_css_err load_primary_binaries(
return err;
}
mycs->num_yuv_scaler = cas_scaler_descr.num_stage;
mycs->yuv_scaler_binary = sh_css_calloc(cas_scaler_descr.num_stage,
sizeof(struct ia_css_binary));
mycs->yuv_scaler_binary = kzalloc(cas_scaler_descr.num_stage *
sizeof(struct ia_css_binary), GFP_KERNEL);
if (mycs->yuv_scaler_binary == NULL) {
err = IA_CSS_ERR_CANNOT_ALLOCATE_MEMORY;
IA_CSS_LEAVE_ERR_PRIVATE(err);
return err;
}
mycs->is_output_stage = sh_css_calloc(cas_scaler_descr.num_stage,
sizeof(bool));
mycs->is_output_stage = kzalloc(cas_scaler_descr.num_stage *
sizeof(bool), GFP_KERNEL);
if (mycs->is_output_stage == NULL) {
err = IA_CSS_ERR_CANNOT_ALLOCATE_MEMORY;
IA_CSS_LEAVE_ERR_PRIVATE(err);
@ -7068,9 +7068,9 @@ unload_capture_binaries(struct ia_css_pipe *pipe)
for (i = 0; i < pipe->pipe_settings.capture.num_yuv_scaler; i++)
ia_css_binary_unload(&pipe->pipe_settings.capture.yuv_scaler_binary[i]);
sh_css_free(pipe->pipe_settings.capture.is_output_stage);
kfree(pipe->pipe_settings.capture.is_output_stage);
pipe->pipe_settings.capture.is_output_stage = NULL;
sh_css_free(pipe->pipe_settings.capture.yuv_scaler_binary);
kfree(pipe->pipe_settings.capture.yuv_scaler_binary);
pipe->pipe_settings.capture.yuv_scaler_binary = NULL;
IA_CSS_LEAVE_ERR_PRIVATE(IA_CSS_SUCCESS);
@ -7159,27 +7159,27 @@ static enum ia_css_err ia_css_pipe_create_cas_scaler_desc_single_output(
i *= max_scale_factor_per_stage;
}
descr->in_info = sh_css_malloc(descr->num_stage * sizeof(struct ia_css_frame_info));
descr->in_info = kmalloc(descr->num_stage * sizeof(struct ia_css_frame_info), GFP_KERNEL);
if (descr->in_info == NULL) {
err = IA_CSS_ERR_CANNOT_ALLOCATE_MEMORY;
goto ERR;
}
descr->internal_out_info = sh_css_malloc(descr->num_stage * sizeof(struct ia_css_frame_info));
descr->internal_out_info = kmalloc(descr->num_stage * sizeof(struct ia_css_frame_info), GFP_KERNEL);
if (descr->internal_out_info == NULL) {
err = IA_CSS_ERR_CANNOT_ALLOCATE_MEMORY;
goto ERR;
}
descr->out_info = sh_css_malloc(descr->num_stage * sizeof(struct ia_css_frame_info));
descr->out_info = kmalloc(descr->num_stage * sizeof(struct ia_css_frame_info), GFP_KERNEL);
if (descr->out_info == NULL) {
err = IA_CSS_ERR_CANNOT_ALLOCATE_MEMORY;
goto ERR;
}
descr->vf_info = sh_css_malloc(descr->num_stage * sizeof(struct ia_css_frame_info));
descr->vf_info = kmalloc(descr->num_stage * sizeof(struct ia_css_frame_info), GFP_KERNEL);
if (descr->vf_info == NULL) {
err = IA_CSS_ERR_CANNOT_ALLOCATE_MEMORY;
goto ERR;
}
descr->is_output_stage = sh_css_malloc(descr->num_stage * sizeof(bool));
descr->is_output_stage = kmalloc(descr->num_stage * sizeof(bool), GFP_KERNEL);
if (descr->is_output_stage == NULL) {
err = IA_CSS_ERR_CANNOT_ALLOCATE_MEMORY;
goto ERR;
@ -7237,6 +7237,7 @@ ERR:
return err;
}
/* FIXME: merge most of this and single output version */
static enum ia_css_err ia_css_pipe_create_cas_scaler_desc(struct ia_css_pipe *pipe,
struct ia_css_cas_binary_descr *descr)
{
@ -7294,27 +7295,27 @@ static enum ia_css_err ia_css_pipe_create_cas_scaler_desc(struct ia_css_pipe *pi
descr->num_stage = num_stages;
descr->in_info = sh_css_malloc(descr->num_stage * sizeof(struct ia_css_frame_info));
descr->in_info = kmalloc(descr->num_stage * sizeof(struct ia_css_frame_info), GFP_KERNEL);
if (descr->in_info == NULL) {
err = IA_CSS_ERR_CANNOT_ALLOCATE_MEMORY;
goto ERR;
}
descr->internal_out_info = sh_css_malloc(descr->num_stage * sizeof(struct ia_css_frame_info));
descr->internal_out_info = kmalloc(descr->num_stage * sizeof(struct ia_css_frame_info), GFP_KERNEL);
if (descr->internal_out_info == NULL) {
err = IA_CSS_ERR_CANNOT_ALLOCATE_MEMORY;
goto ERR;
}
descr->out_info = sh_css_malloc(descr->num_stage * sizeof(struct ia_css_frame_info));
descr->out_info = kmalloc(descr->num_stage * sizeof(struct ia_css_frame_info), GFP_KERNEL);
if (descr->out_info == NULL) {
err = IA_CSS_ERR_CANNOT_ALLOCATE_MEMORY;
goto ERR;
}
descr->vf_info = sh_css_malloc(descr->num_stage * sizeof(struct ia_css_frame_info));
descr->vf_info = kmalloc(descr->num_stage * sizeof(struct ia_css_frame_info), GFP_KERNEL);
if (descr->vf_info == NULL) {
err = IA_CSS_ERR_CANNOT_ALLOCATE_MEMORY;
goto ERR;
}
descr->is_output_stage = sh_css_malloc(descr->num_stage * sizeof(bool));
descr->is_output_stage = kmalloc(descr->num_stage * sizeof(bool), GFP_KERNEL);
if (descr->is_output_stage == NULL) {
err = IA_CSS_ERR_CANNOT_ALLOCATE_MEMORY;
goto ERR;
@ -7388,15 +7389,15 @@ ERR:
static void ia_css_pipe_destroy_cas_scaler_desc(struct ia_css_cas_binary_descr *descr)
{
ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE_PRIVATE, "ia_css_pipe_destroy_cas_scaler_desc() enter:\n");
sh_css_free(descr->in_info);
kfree(descr->in_info);
descr->in_info = NULL;
sh_css_free(descr->internal_out_info);
kfree(descr->internal_out_info);
descr->internal_out_info = NULL;
sh_css_free(descr->out_info);
kfree(descr->out_info);
descr->out_info = NULL;
sh_css_free(descr->vf_info);
kfree(descr->vf_info);
descr->vf_info = NULL;
sh_css_free(descr->is_output_stage);
kfree(descr->is_output_stage);
descr->is_output_stage = NULL;
ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE_PRIVATE, "ia_css_pipe_destroy_cas_scaler_desc() leave\n");
}
@ -7451,14 +7452,14 @@ load_yuvpp_binaries(struct ia_css_pipe *pipe)
goto ERR;
mycs->num_output = cas_scaler_descr.num_output_stage;
mycs->num_yuv_scaler = cas_scaler_descr.num_stage;
mycs->yuv_scaler_binary = sh_css_calloc(cas_scaler_descr.num_stage,
sizeof(struct ia_css_binary));
mycs->yuv_scaler_binary = kzalloc(cas_scaler_descr.num_stage *
sizeof(struct ia_css_binary), GFP_KERNEL);
if (mycs->yuv_scaler_binary == NULL) {
err = IA_CSS_ERR_CANNOT_ALLOCATE_MEMORY;
goto ERR;
}
mycs->is_output_stage = sh_css_calloc(cas_scaler_descr.num_stage,
sizeof(bool));
mycs->is_output_stage = kzalloc(cas_scaler_descr.num_stage *
sizeof(bool), GFP_KERNEL);
if (mycs->is_output_stage == NULL) {
err = IA_CSS_ERR_CANNOT_ALLOCATE_MEMORY;
goto ERR;
@ -7558,7 +7559,8 @@ load_yuvpp_binaries(struct ia_css_pipe *pipe)
}
mycs->num_vf_pp = 1;
}
mycs->vf_pp_binary = sh_css_calloc(mycs->num_vf_pp, sizeof(struct ia_css_binary));
mycs->vf_pp_binary = kzalloc(mycs->num_vf_pp * sizeof(struct ia_css_binary),
GFP_KERNEL);
if (mycs->vf_pp_binary == NULL) {
err = IA_CSS_ERR_CANNOT_ALLOCATE_MEMORY;
goto ERR;
@ -7607,11 +7609,11 @@ unload_yuvpp_binaries(struct ia_css_pipe *pipe)
for (i = 0; i < pipe->pipe_settings.yuvpp.num_vf_pp; i++) {
ia_css_binary_unload(&pipe->pipe_settings.yuvpp.vf_pp_binary[i]);
}
sh_css_free(pipe->pipe_settings.yuvpp.is_output_stage);
kfree(pipe->pipe_settings.yuvpp.is_output_stage);
pipe->pipe_settings.yuvpp.is_output_stage = NULL;
sh_css_free(pipe->pipe_settings.yuvpp.yuv_scaler_binary);
kfree(pipe->pipe_settings.yuvpp.yuv_scaler_binary);
pipe->pipe_settings.yuvpp.yuv_scaler_binary = NULL;
sh_css_free(pipe->pipe_settings.yuvpp.vf_pp_binary);
kfree(pipe->pipe_settings.yuvpp.vf_pp_binary);
pipe->pipe_settings.yuvpp.vf_pp_binary = NULL;
IA_CSS_LEAVE_ERR_PRIVATE(IA_CSS_SUCCESS);
@ -9625,7 +9627,7 @@ ia_css_stream_create(const struct ia_css_stream_config *stream_config,
}
/* allocate the stream instance */
curr_stream = sh_css_malloc(sizeof(struct ia_css_stream));
curr_stream = kmalloc(sizeof(struct ia_css_stream), GFP_KERNEL);
if (curr_stream == NULL) {
err = IA_CSS_ERR_CANNOT_ALLOCATE_MEMORY;
IA_CSS_LEAVE_ERR(err);
@ -9637,10 +9639,10 @@ ia_css_stream_create(const struct ia_css_stream_config *stream_config,
/* allocate pipes */
curr_stream->num_pipes = num_pipes;
curr_stream->pipes = sh_css_malloc(num_pipes * sizeof(struct ia_css_pipe *));
curr_stream->pipes = kzalloc(num_pipes * sizeof(struct ia_css_pipe *), GFP_KERNEL);
if (curr_stream->pipes == NULL) {
curr_stream->num_pipes = 0;
sh_css_free(curr_stream);
kfree(curr_stream);
curr_stream = NULL;
err = IA_CSS_ERR_CANNOT_ALLOCATE_MEMORY;
IA_CSS_LEAVE_ERR(err);
@ -10103,7 +10105,7 @@ ia_css_stream_destroy(struct ia_css_stream *stream)
}
}
/* free associated memory of stream struct */
sh_css_free(stream->pipes);
kfree(stream->pipes);
stream->pipes = NULL;
stream->num_pipes = 0;
#ifndef ISP2401
@ -10121,7 +10123,7 @@ ia_css_stream_destroy(struct ia_css_stream *stream)
err1 = (err != IA_CSS_SUCCESS) ? err : err2;
#endif
sh_css_free(stream);
kfree(stream);
#ifndef ISP2401
IA_CSS_LEAVE_ERR(err);
#else

29
drivers/staging/media/atomisp/pci/atomisp2/css2400/sh_css_firmware.c
View File

@ -12,6 +12,9 @@
* more details.
*/
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <math_support.h>
#include "platform_support.h"
#include "sh_css_firmware.h"
@ -93,9 +96,9 @@ setup_binary(struct ia_css_fw_info *fw, const char *fw_data, struct ia_css_fw_in
*sh_css_fw = *fw;
#if defined(HRT_UNSCHED)
sh_css_fw->blob.code = sh_css_malloc(1);
sh_css_fw->blob.code = vmalloc(1);
#else
sh_css_fw->blob.code = sh_css_malloc(fw->blob.size);
sh_css_fw->blob.code = vmalloc(fw->blob.size);
#endif
if (sh_css_fw->blob.code == NULL)
@ -143,11 +146,11 @@ sh_css_load_blob_info(const char *fw, const struct ia_css_fw_info *bi, struct ia
char *namebuffer;
int namelength = (int)strlen(name);
namebuffer = (char *) sh_css_malloc(namelength+1);
namebuffer = (char *) kmalloc(namelength + 1, GFP_KERNEL);
if (namebuffer == NULL)
return IA_CSS_ERR_CANNOT_ALLOCATE_MEMORY;
memcpy(namebuffer, name, namelength+1);
memcpy(namebuffer, name, namelength + 1);
bd->name = fw_minibuffer[index].name = namebuffer;
} else {
@ -159,7 +162,8 @@ sh_css_load_blob_info(const char *fw, const struct ia_css_fw_info *bi, struct ia
size_t configstruct_size = sizeof(struct ia_css_config_memory_offsets);
size_t statestruct_size = sizeof(struct ia_css_state_memory_offsets);
char *parambuf = (char *) sh_css_malloc(paramstruct_size + configstruct_size + statestruct_size);
char *parambuf = (char *)kmalloc(paramstruct_size + configstruct_size + statestruct_size,
GFP_KERNEL);
if (parambuf == NULL)
return IA_CSS_ERR_CANNOT_ALLOCATE_MEMORY;
@ -239,19 +243,18 @@ sh_css_load_firmware(const char *fw_data,
sh_css_num_binaries = file_header->binary_nr;
/* Only allocate memory for ISP blob info */
if (sh_css_num_binaries > (NUM_OF_SPS + NUM_OF_BLS)) {
sh_css_blob_info = sh_css_malloc(
sh_css_blob_info = kmalloc(
(sh_css_num_binaries - (NUM_OF_SPS + NUM_OF_BLS)) *
sizeof(*sh_css_blob_info));
sizeof(*sh_css_blob_info), GFP_KERNEL);
if (sh_css_blob_info == NULL)
return IA_CSS_ERR_CANNOT_ALLOCATE_MEMORY;
} else {
sh_css_blob_info = NULL;
}
fw_minibuffer = sh_css_malloc(sh_css_num_binaries * sizeof(struct fw_param));
fw_minibuffer = kzalloc(sh_css_num_binaries * sizeof(struct fw_param), GFP_KERNEL);
if (fw_minibuffer == NULL)
return IA_CSS_ERR_CANNOT_ALLOCATE_MEMORY;
memset(fw_minibuffer, 0, sh_css_num_binaries * sizeof(struct fw_param));
for (i = 0; i < sh_css_num_binaries; i++) {
struct ia_css_fw_info *bi = &binaries[i];
@ -309,17 +312,17 @@ void sh_css_unload_firmware(void)
unsigned int i = 0;
for (i = 0; i < sh_css_num_binaries; i++) {
if (fw_minibuffer[i].name)
sh_css_free((void *)fw_minibuffer[i].name);
kfree((void *)fw_minibuffer[i].name);
if (fw_minibuffer[i].buffer)
sh_css_free((void *)fw_minibuffer[i].buffer);
vfree((void *)fw_minibuffer[i].buffer);
}
sh_css_free(fw_minibuffer);
kfree(fw_minibuffer);
fw_minibuffer = NULL;
}
memset(&sh_css_sp_fw, 0, sizeof(sh_css_sp_fw));
if (sh_css_blob_info) {
sh_css_free(sh_css_blob_info);
kfree(sh_css_blob_info);
sh_css_blob_info = NULL;
}
sh_css_num_binaries = 0;

8
drivers/staging/media/atomisp/pci/atomisp2/css2400/sh_css_host_data.c
View File

@ -12,7 +12,7 @@
* more details.
*/
#include <stddef.h>
#include <linux/slab.h>
#include <ia_css_host_data.h>
#include <sh_css_internal.h>
@ -20,13 +20,13 @@ struct ia_css_host_data *ia_css_host_data_allocate(size_t size)
{
struct ia_css_host_data *me;
me = sh_css_malloc(sizeof(struct ia_css_host_data));
me = kmalloc(sizeof(struct ia_css_host_data), GFP_KERNEL);
if (!me)
return NULL;
me->size = (uint32_t)size;
me->address = sh_css_malloc(size);
if (!me->address) {
sh_css_free(me);
kfree(me);
return NULL;
}
return me;
@ -37,6 +37,6 @@ void ia_css_host_data_free(struct ia_css_host_data *me)
if (me) {
sh_css_free(me->address);
me->address = NULL;
sh_css_free(me);
kfree(me);
}
}

8
drivers/staging/media/atomisp/pci/atomisp2/css2400/sh_css_param_shading.c
View File

@ -12,6 +12,8 @@
* more details.
*/
#include <linux/slab.h>
#include <math_support.h>
#include "sh_css_param_shading.h"
#include "ia_css_shading.h"
@ -362,7 +364,7 @@ ia_css_shading_table_alloc(
IA_CSS_ENTER("");
me = sh_css_malloc(sizeof(*me));
me = kmalloc(sizeof(*me), GFP_KERNEL);
if (me == NULL) {
IA_CSS_ERROR("out of memory");
return me;
@ -382,7 +384,7 @@ ia_css_shading_table_alloc(
sh_css_free(me->data[j]);
me->data[j] = NULL;
}
sh_css_free(me);
kfree(me);
return NULL;
}
}
@ -410,7 +412,7 @@ ia_css_shading_table_free(struct ia_css_shading_table *table)
table->data[i] = NULL;
}
}
sh_css_free(table);
kfree(table);
IA_CSS_LEAVE("");
}