Abstractions are frowned upon.
cocci script:
virtual context
virtual patch
virtual org
virtual report
@@
expression ptr;
@@
- dm_alloc(ptr)
+ kzalloc(ptr, GFP_KERNEL)
@@
expression ptr, size;
@@
- dm_realloc(ptr, size)
+ krealloc(ptr, size, GFP_KERNEL)
@@
expression ptr;
@@
- dm_free(ptr)
+ kfree(ptr)
v2: use GFP_KERNEL, not GFP_ATOMIC. add cocci script
Reviewed-by: Alex Deucher <alexander.deucher@amd.com>
Signed-off-by: Harry Wentland <harry.wentland@amd.com>
Signed-off-by: Alex Deucher <alexander.deucher@amd.com>
if (WARN_ON(!crtc->state))
return NULL;
- state = dm_alloc(sizeof(*state));
+ state = kzalloc(sizeof(*state), GFP_KERNEL);
__drm_atomic_helper_crtc_duplicate_state(crtc, &state->base);
{
/* malloc buffer and init offsets */
logger->log_buffer_size = DAL_LOGGER_BUFFER_MAX_SIZE;
- logger->log_buffer = (char *)dm_alloc(logger->log_buffer_size *
- sizeof(char));
+ logger->log_buffer = (char *)kzalloc(logger->log_buffer_size * sizeof(char),
+ GFP_KERNEL);
if (!logger->log_buffer)
return false;
static void destruct(struct dal_logger *logger)
{
if (logger->log_buffer) {
- dm_free(logger->log_buffer);
+ kfree(logger->log_buffer);
logger->log_buffer = NULL;
}
}
struct dal_logger *dal_logger_create(struct dc_context *ctx, uint32_t log_mask)
{
/* malloc struct */
- struct dal_logger *logger = dm_alloc(sizeof(struct dal_logger));
+ struct dal_logger *logger = kzalloc(sizeof(struct dal_logger),
+ GFP_KERNEL);
if (!logger)
return NULL;
if (!construct(ctx, logger, log_mask)) {
- dm_free(logger);
+ kfree(logger);
return NULL;
}
if (logger == NULL || *logger == NULL)
return 1;
destruct(*logger);
- dm_free(*logger);
+ kfree(*logger);
*logger = NULL;
return 0;
entry->type = log_type;
entry->logger = logger;
- entry->buf = dm_alloc(DAL_LOGGER_BUFFER_MAX_SIZE * sizeof(char));
+ entry->buf = kzalloc(DAL_LOGGER_BUFFER_MAX_SIZE * sizeof(char),
+ GFP_KERNEL);
entry->buf_offset = 0;
entry->max_buf_bytes = DAL_LOGGER_BUFFER_MAX_SIZE * sizeof(char);
cleanup:
if (entry->buf) {
- dm_free(entry->buf);
+ kfree(entry->buf);
entry->buf = NULL;
entry->buf_offset = 0;
entry->max_buf_bytes = 0;
return false;
}
- vector->container = dm_alloc(struct_size * capacity);
+ vector->container = kzalloc(struct_size * capacity, GFP_KERNEL);
if (vector->container == NULL)
return false;
vector->capacity = capacity;
return false;
}
- vector->container = dm_alloc(struct_size * count);
+ vector->container = kzalloc(struct_size * count, GFP_KERNEL);
if (vector->container == NULL)
return false;
void *initial_value,
uint32_t struct_size)
{
- struct vector *vector = dm_alloc(sizeof(struct vector));
+ struct vector *vector = kzalloc(sizeof(struct vector), GFP_KERNEL);
if (vector == NULL)
return NULL;
return vector;
BREAK_TO_DEBUGGER();
- dm_free(vector);
+ kfree(vector);
return NULL;
}
uint32_t capacity,
uint32_t struct_size)
{
- struct vector *vector = dm_alloc(sizeof(struct vector));
+ struct vector *vector = kzalloc(sizeof(struct vector), GFP_KERNEL);
if (vector == NULL)
return NULL;
return vector;
BREAK_TO_DEBUGGER();
- dm_free(vector);
+ kfree(vector);
return NULL;
}
struct vector *vector)
{
if (vector->container != NULL)
- dm_free(vector->container);
+ kfree(vector->container);
vector->count = 0;
vector->capacity = 0;
}
if (vector == NULL || *vector == NULL)
return;
dal_vector_destruct(*vector);
- dm_free(*vector);
+ kfree(*vector);
*vector = NULL;
}
if (capacity <= vector->capacity)
return true;
- new_container = dm_realloc(vector->container, capacity * vector->struct_size);
+ new_container = krealloc(vector->container,
+ capacity * vector->struct_size, GFP_KERNEL);
if (new_container) {
vector->container = new_container;
{
struct bios_parser *bp = NULL;
- bp = dm_alloc(sizeof(struct bios_parser));
+ bp = kzalloc(sizeof(struct bios_parser), GFP_KERNEL);
if (!bp)
return NULL;
if (bios_parser_construct(bp, init, dce_version))
return &bp->base;
- dm_free(bp);
+ kfree(bp);
BREAK_TO_DEBUGGER();
return NULL;
}
static void destruct(struct bios_parser *bp)
{
if (bp->base.bios_local_image)
- dm_free(bp->base.bios_local_image);
+ kfree(bp->base.bios_local_image);
if (bp->base.integrated_info)
- dm_free(bp->base.integrated_info);
+ kfree(bp->base.integrated_info);
}
static void bios_parser_destroy(struct dc_bios **dcb)
destruct(bp);
- dm_free(bp);
+ kfree(bp);
*dcb = NULL;
}
uint8_t *original_bios;
/* Step 1: Replace bios image with the new copy which will be
* patched */
- bp->base.bios_local_image = dm_alloc(bp->base.bios_size);
+ bp->base.bios_local_image = kzalloc(bp->base.bios_size,
+ GFP_KERNEL);
if (bp->base.bios_local_image == NULL) {
BREAK_TO_DEBUGGER();
/* Failed to alloc bp->base.bios_local_image */
struct bios_parser *bp = BP_FROM_DCB(dcb);
struct integrated_info *info = NULL;
- info = dm_alloc(sizeof(struct integrated_info));
+ info = kzalloc(sizeof(struct integrated_info), GFP_KERNEL);
if (info == NULL) {
ASSERT_CRITICAL(0);
if (construct_integrated_info(bp, info) == BP_RESULT_OK)
return info;
- dm_free(info);
+ kfree(info);
return NULL;
}
static void destruct(struct bios_parser *bp)
{
if (bp->base.bios_local_image)
- dm_free(bp->base.bios_local_image);
+ kfree(bp->base.bios_local_image);
if (bp->base.integrated_info)
- dm_free(bp->base.integrated_info);
+ kfree(bp->base.integrated_info);
}
static void firmware_parser_destroy(struct dc_bios **dcb)
destruct(bp);
- dm_free(bp);
+ kfree(bp);
*dcb = NULL;
}
struct bios_parser *bp = BP_FROM_DCB(dcb);
struct integrated_info *info = NULL;
- info = dm_alloc(sizeof(struct integrated_info));
+ info = kzalloc(sizeof(struct integrated_info), GFP_KERNEL);
if (info == NULL) {
ASSERT_CRITICAL(0);
if (construct_integrated_info(bp, info) == BP_RESULT_OK)
return info;
- dm_free(info);
+ kfree(info);
return NULL;
}
{
struct bios_parser *bp = NULL;
- bp = dm_alloc(sizeof(struct bios_parser));
+ bp = kzalloc(sizeof(struct bios_parser), GFP_KERNEL);
if (!bp)
return NULL;
if (bios_parser_construct(bp, init, dce_version))
return &bp->base;
- dm_free(bp);
+ kfree(bp);
return NULL;
}
int pipe_count,
struct dce_bw_output *calcs_output)
{
- struct bw_calcs_data *data = dm_alloc(sizeof(struct bw_calcs_data));
+ struct bw_calcs_data *data = kzalloc(sizeof(struct bw_calcs_data),
+ GFP_KERNEL);
populate_initial_data(pipe, pipe_count, data);
calcs_output->sclk_khz = 0;
}
- dm_free(data);
+ kfree(data);
return is_display_configuration_supported(vbios, calcs_output);
}
{
int i, in_idx, active_count;
- struct _vcs_dpi_display_e2e_pipe_params_st *input = dm_alloc(pool->pipe_count *
- sizeof(struct _vcs_dpi_display_e2e_pipe_params_st));
+ struct _vcs_dpi_display_e2e_pipe_params_st *input = kzalloc(pool->pipe_count * sizeof(struct _vcs_dpi_display_e2e_pipe_params_st),
+ GFP_KERNEL);
struct wm {
double urgent;
struct _vcs_dpi_cstate_pstate_watermarks_st cpstate;
pipe->plane_state->flip_immediate);
in_idx++;
}
- dm_free(input);
+ kfree(input);
}
static void split_stream_across_pipes(
}
for (i = 0; i < num_virtual_links; i++) {
- struct dc_link *link = dm_alloc(sizeof(*link));
+ struct dc_link *link = kzalloc(sizeof(*link), GFP_KERNEL);
struct encoder_init_data enc_init = {0};
if (link == NULL) {
link->link_id.type = OBJECT_TYPE_CONNECTOR;
link->link_id.id = CONNECTOR_ID_VIRTUAL;
link->link_id.enum_id = ENUM_ID_1;
- link->link_enc = dm_alloc(sizeof(*link->link_enc));
+ link->link_enc = kzalloc(sizeof(*link->link_enc), GFP_KERNEL);
enc_init.ctx = dc->ctx;
enc_init.channel = CHANNEL_ID_UNKNOWN;
if (dc->ctx->logger)
dal_logger_destroy(&dc->ctx->logger);
- dm_free(dc->ctx);
+ kfree(dc->ctx);
dc->ctx = NULL;
- dm_free(dc->bw_vbios);
+ kfree(dc->bw_vbios);
dc->bw_vbios = NULL;
- dm_free(dc->bw_dceip);
+ kfree(dc->bw_dceip);
dc->bw_dceip = NULL;
#ifdef CONFIG_DRM_AMD_DC_DCN1_0
- dm_free(dc->dcn_soc);
+ kfree(dc->dcn_soc);
dc->dcn_soc = NULL;
- dm_free(dc->dcn_ip);
+ kfree(dc->dcn_ip);
dc->dcn_ip = NULL;
#endif
const struct dc_init_data *init_params)
{
struct dal_logger *logger;
- struct dc_context *dc_ctx = dm_alloc(sizeof(*dc_ctx));
- struct bw_calcs_dceip *dc_dceip = dm_alloc(sizeof(*dc_dceip));
- struct bw_calcs_vbios *dc_vbios = dm_alloc(sizeof(*dc_vbios));
+ struct dc_context *dc_ctx = kzalloc(sizeof(*dc_ctx), GFP_KERNEL);
+ struct bw_calcs_dceip *dc_dceip = kzalloc(sizeof(*dc_dceip),
+ GFP_KERNEL);
+ struct bw_calcs_vbios *dc_vbios = kzalloc(sizeof(*dc_vbios),
+ GFP_KERNEL);
#ifdef CONFIG_DRM_AMD_DC_DCN1_0
- struct dcn_soc_bounding_box *dcn_soc = dm_alloc(sizeof(*dcn_soc));
- struct dcn_ip_params *dcn_ip = dm_alloc(sizeof(*dcn_ip));
+ struct dcn_soc_bounding_box *dcn_soc = kzalloc(sizeof(*dcn_soc),
+ GFP_KERNEL);
+ struct dcn_ip_params *dcn_ip = kzalloc(sizeof(*dcn_ip), GFP_KERNEL);
#endif
enum dce_version dc_version = DCE_VERSION_UNKNOWN;
struct dc *dc_create(const struct dc_init_data *init_params)
{
- struct dc *dc = dm_alloc(sizeof(*dc));
+ struct dc *dc = kzalloc(sizeof(*dc), GFP_KERNEL);
unsigned int full_pipe_count;
if (NULL == dc)
return dc;
construct_fail:
- dm_free(dc);
+ kfree(dc);
alloc_fail:
return NULL;
void dc_destroy(struct dc **dc)
{
destruct(*dc);
- dm_free(*dc);
+ kfree(*dc);
*dc = NULL;
}
struct dc_scaling_info scaling_info[MAX_SURFACES];
int i;
struct dc_stream_update *stream_update =
- dm_alloc(sizeof(struct dc_stream_update));
+ kzalloc(sizeof(struct dc_stream_update), GFP_KERNEL);
if (!stream_update) {
BREAK_TO_DEBUGGER();
dc_post_update_surfaces_to_stream(dc);
- dm_free(stream_update);
+ kfree(stream_update);
return true;
}
struct dc_state *dc_create_state(void)
{
- struct dc_state *context = dm_alloc(sizeof(struct dc_state));
+ struct dc_state *context = kzalloc(sizeof(struct dc_state),
+ GFP_KERNEL);
if (!context)
return NULL;
if (atomic_read(&context->ref_count) == 0) {
dc_resource_state_destruct(context);
- dm_free(context);
+ kfree(context);
}
}
struct dc_link *link_create(const struct link_init_data *init_params)
{
struct dc_link *link =
- dm_alloc(sizeof(*link));
+ kzalloc(sizeof(*link), GFP_KERNEL);
if (NULL == link)
goto alloc_fail;
return link;
construct_fail:
- dm_free(link);
+ kfree(link);
alloc_fail:
return NULL;
void link_destroy(struct dc_link **link)
{
destruct(*link);
- dm_free(*link);
+ kfree(*link);
*link = NULL;
}
{
struct i2c_payloads *payloads;
- payloads = dm_alloc(sizeof(struct i2c_payloads));
+ payloads = kzalloc(sizeof(struct i2c_payloads), GFP_KERNEL);
if (!payloads)
return NULL;
&payloads->payloads, ctx, count, sizeof(struct i2c_payload)))
return payloads;
- dm_free(payloads);
+ kfree(payloads);
return NULL;
}
if (!p || !*p)
return;
dal_vector_destruct(&(*p)->payloads);
- dm_free(*p);
+ kfree(*p);
*p = NULL;
}
{
struct aux_payloads *payloads;
- payloads = dm_alloc(sizeof(struct aux_payloads));
+ payloads = kzalloc(sizeof(struct aux_payloads), GFP_KERNEL);
if (!payloads)
return NULL;
&payloads->payloads, ctx, count, sizeof(struct aux_payload)))
return payloads;
- dm_free(payloads);
+ kfree(payloads);
return NULL;
}
return;
dal_vector_destruct(&(*p)->payloads);
- dm_free(*p);
+ kfree(*p);
*p = NULL;
}
{
struct ddc_service *ddc_service;
- ddc_service = dm_alloc(sizeof(struct ddc_service));
+ ddc_service = kzalloc(sizeof(struct ddc_service), GFP_KERNEL);
if (!ddc_service)
return NULL;
if (construct(ddc_service, init_data))
return ddc_service;
- dm_free(ddc_service);
+ kfree(ddc_service);
return NULL;
}
return;
}
destruct(*ddc);
- dm_free(*ddc);
+ kfree(*ddc);
*ddc = NULL;
}
dc->res_pool->funcs->destroy(&dc->res_pool);
if (dc->hwseq)
- dm_free(dc->hwseq);
+ kfree(dc->hwseq);
}
}
static void destruct(struct dc_sink *sink)
{
if (sink->dc_container_id) {
- dm_free(sink->dc_container_id);
+ kfree(sink->dc_container_id);
sink->dc_container_id = NULL;
}
}
if (atomic_read(&sink->ref_count) == 0) {
destruct(sink);
- dm_free(sink);
+ kfree(sink);
}
}
struct dc_sink *dc_sink_create(const struct dc_sink_init_data *init_params)
{
- struct dc_sink *sink = dm_alloc(sizeof(*sink));
+ struct dc_sink *sink = kzalloc(sizeof(*sink), GFP_KERNEL);
if (NULL == sink)
goto alloc_fail;
return sink;
construct_fail:
- dm_free(sink);
+ kfree(sink);
alloc_fail:
return NULL;
{
if (dc_sink && container_id) {
if (!dc_sink->dc_container_id)
- dc_sink->dc_container_id = dm_alloc(sizeof(*dc_sink->dc_container_id));
+ dc_sink->dc_container_id = kzalloc(sizeof(*dc_sink->dc_container_id),
+ GFP_KERNEL);
if (dc_sink->dc_container_id) {
memmove(&dc_sink->dc_container_id->guid, &container_id->guid,
if (atomic_read(&stream->ref_count) == 0) {
destruct(stream);
- dm_free(stream);
+ kfree(stream);
}
}
}
if (sink == NULL)
goto alloc_fail;
- stream = dm_alloc(sizeof(struct dc_stream_state));
+ stream = kzalloc(sizeof(struct dc_stream_state), GFP_KERNEL);
if (NULL == stream)
goto alloc_fail;
return stream;
construct_fail:
- dm_free(stream);
+ kfree(stream);
alloc_fail:
return NULL;
{
struct dc *core_dc = dc;
- struct dc_plane_state *plane_state = dm_alloc(sizeof(*plane_state));
+ struct dc_plane_state *plane_state = kzalloc(sizeof(*plane_state),
+ GFP_KERNEL);
if (NULL == plane_state)
goto alloc_fail;
return plane_state;
construct_fail:
- dm_free(plane_state);
+ kfree(plane_state);
alloc_fail:
return NULL;
if (atomic_read(&plane_state->ref_count) == 0) {
destruct(plane_state);
- dm_free(plane_state);
+ kfree(plane_state);
}
}
atomic_dec(&(*gamma)->ref_count);
if (atomic_read(&(*gamma)->ref_count) == 0)
- dm_free((*gamma));
+ kfree((*gamma));
*gamma = NULL;
}
struct dc_gamma *dc_create_gamma()
{
- struct dc_gamma *gamma = dm_alloc(sizeof(*gamma));
+ struct dc_gamma *gamma = kzalloc(sizeof(*gamma), GFP_KERNEL);
if (gamma == NULL)
goto alloc_fail;
atomic_dec(&tf->ref_count);
if (atomic_read(&tf->ref_count) == 0)
- dm_free(tf);
+ kfree(tf);
}
struct dc_transfer_func *dc_create_transfer_func()
{
- struct dc_transfer_func *tf = dm_alloc(sizeof(*tf));
+ struct dc_transfer_func *tf = kzalloc(sizeof(*tf), GFP_KERNEL);
if (tf == NULL)
goto alloc_fail;
const struct dce_abm_shift *abm_shift,
const struct dce_abm_mask *abm_mask)
{
- struct dce_abm *abm_dce = dm_alloc(sizeof(*abm_dce));
+ struct dce_abm *abm_dce = kzalloc(sizeof(*abm_dce), GFP_KERNEL);
if (abm_dce == NULL) {
BREAK_TO_DEBUGGER();
{
struct dce_abm *abm_dce = TO_DCE_ABM(*abm);
- dm_free(abm_dce);
+ kfree(abm_dce);
*abm = NULL;
}
{
struct dce_audio *aud = DCE_AUD(*audio);
- dm_free(aud);
+ kfree(aud);
*audio = NULL;
}
const struct dce_aduio_mask *masks
)
{
- struct dce_audio *audio = dm_alloc(sizeof(*audio));
+ struct dce_audio *audio = kzalloc(sizeof(*audio), GFP_KERNEL);
if (audio == NULL) {
ASSERT_CRITICAL(audio);
if (*ss_entries_num == 0)
return;
- ss_info = dm_alloc(sizeof(struct spread_spectrum_info) * (*ss_entries_num));
+ ss_info = kzalloc(sizeof(struct spread_spectrum_info) * (*ss_entries_num),
+ GFP_KERNEL);
ss_info_cur = ss_info;
if (ss_info == NULL)
return;
- ss_data = dm_alloc(sizeof(struct spread_spectrum_data) * (*ss_entries_num));
+ ss_data = kzalloc(sizeof(struct spread_spectrum_data) * (*ss_entries_num),
+ GFP_KERNEL);
if (ss_data == NULL)
goto out_free_info;
}
*spread_spectrum_data = ss_data;
- dm_free(ss_info);
+ kfree(ss_info);
return;
out_free_data:
- dm_free(ss_data);
+ kfree(ss_data);
*ss_entries_num = 0;
out_free_info:
- dm_free(ss_info);
+ kfree(ss_info);
}
static void ss_info_from_atombios_create(
const struct dce_disp_clk_shift *clk_shift,
const struct dce_disp_clk_mask *clk_mask)
{
- struct dce_disp_clk *clk_dce = dm_alloc(sizeof(*clk_dce));
+ struct dce_disp_clk *clk_dce = kzalloc(sizeof(*clk_dce), GFP_KERNEL);
if (clk_dce == NULL) {
BREAK_TO_DEBUGGER();
const struct dce_disp_clk_shift *clk_shift,
const struct dce_disp_clk_mask *clk_mask)
{
- struct dce_disp_clk *clk_dce = dm_alloc(sizeof(*clk_dce));
+ struct dce_disp_clk *clk_dce = kzalloc(sizeof(*clk_dce), GFP_KERNEL);
if (clk_dce == NULL) {
BREAK_TO_DEBUGGER();
const struct dce_disp_clk_shift *clk_shift,
const struct dce_disp_clk_mask *clk_mask)
{
- struct dce_disp_clk *clk_dce = dm_alloc(sizeof(*clk_dce));
+ struct dce_disp_clk *clk_dce = kzalloc(sizeof(*clk_dce), GFP_KERNEL);
if (clk_dce == NULL) {
BREAK_TO_DEBUGGER();
struct display_clock *dce120_disp_clk_create(struct dc_context *ctx)
{
- struct dce_disp_clk *clk_dce = dm_alloc(sizeof(*clk_dce));
+ struct dce_disp_clk *clk_dce = kzalloc(sizeof(*clk_dce), GFP_KERNEL);
struct dm_pp_clock_levels_with_voltage clk_level_info = {0};
if (clk_dce == NULL) {
{
struct dce_disp_clk *clk_dce = TO_DCE_CLOCKS(*disp_clk);
- dm_free(clk_dce);
+ kfree(clk_dce);
*disp_clk = NULL;
}
const struct dce_dmcu_shift *dmcu_shift,
const struct dce_dmcu_mask *dmcu_mask)
{
- struct dce_dmcu *dmcu_dce = dm_alloc(sizeof(*dmcu_dce));
+ struct dce_dmcu *dmcu_dce = kzalloc(sizeof(*dmcu_dce), GFP_KERNEL);
if (dmcu_dce == NULL) {
BREAK_TO_DEBUGGER();
const struct dce_dmcu_shift *dmcu_shift,
const struct dce_dmcu_mask *dmcu_mask)
{
- struct dce_dmcu *dmcu_dce = dm_alloc(sizeof(*dmcu_dce));
+ struct dce_dmcu *dmcu_dce = kzalloc(sizeof(*dmcu_dce), GFP_KERNEL);
if (dmcu_dce == NULL) {
BREAK_TO_DEBUGGER();
{
struct dce_dmcu *dmcu_dce = TO_DCE_DMCU(*dmcu);
- dm_free(dmcu_dce);
+ kfree(dmcu_dce);
*dmcu = NULL;
}
void dce_ipp_destroy(struct input_pixel_processor **ipp)
{
- dm_free(TO_DCE_IPP(*ipp));
+ kfree(TO_DCE_IPP(*ipp));
*ipp = NULL;
}
void dce110_link_encoder_destroy(struct link_encoder **enc)
{
- dm_free(TO_DCE110_LINK_ENC(*enc));
+ kfree(TO_DCE110_LINK_ENC(*enc));
*enc = NULL;
}
void dce110_opp_destroy(struct output_pixel_processor **opp)
{
if (*opp)
- dm_free(FROM_DCE11_OPP(*opp));
+ kfree(FROM_DCE11_OPP(*opp));
*opp = NULL;
}
const struct dce110_timing_generator_offsets *offsets)
{
struct dce110_timing_generator *tg110 =
- dm_alloc(sizeof(struct dce110_timing_generator));
+ kzalloc(sizeof(struct dce110_timing_generator), GFP_KERNEL);
if (!tg110)
return NULL;
return &tg110->base;
BREAK_TO_DEBUGGER();
- dm_free(tg110);
+ kfree(tg110);
return NULL;
}
struct dc_context *ctx)
{
struct dce110_stream_encoder *enc110 =
- dm_alloc(sizeof(struct dce110_stream_encoder));
+ kzalloc(sizeof(struct dce110_stream_encoder), GFP_KERNEL);
if (!enc110)
return NULL;
return &enc110->base;
BREAK_TO_DEBUGGER();
- dm_free(enc110);
+ kfree(enc110);
return NULL;
}
static struct dce_hwseq *dce100_hwseq_create(
struct dc_context *ctx)
{
- struct dce_hwseq *hws = dm_alloc(sizeof(struct dce_hwseq));
+ struct dce_hwseq *hws = kzalloc(sizeof(struct dce_hwseq), GFP_KERNEL);
if (hws) {
hws->ctx = ctx;
struct dc_context *ctx,
uint32_t inst)
{
- struct dce_mem_input *dce_mi = dm_alloc(sizeof(struct dce_mem_input));
+ struct dce_mem_input *dce_mi = kzalloc(sizeof(struct dce_mem_input),
+ GFP_KERNEL);
if (!dce_mi) {
BREAK_TO_DEBUGGER();
static void dce100_transform_destroy(struct transform **xfm)
{
- dm_free(TO_DCE_TRANSFORM(*xfm));
+ kfree(TO_DCE_TRANSFORM(*xfm));
*xfm = NULL;
}
uint32_t inst)
{
struct dce_transform *transform =
- dm_alloc(sizeof(struct dce_transform));
+ kzalloc(sizeof(struct dce_transform), GFP_KERNEL);
if (!transform)
return NULL;
}
BREAK_TO_DEBUGGER();
- dm_free(transform);
+ kfree(transform);
return NULL;
}
static struct input_pixel_processor *dce100_ipp_create(
struct dc_context *ctx, uint32_t inst)
{
- struct dce_ipp *ipp = dm_alloc(sizeof(struct dce_ipp));
+ struct dce_ipp *ipp = kzalloc(sizeof(struct dce_ipp), GFP_KERNEL);
if (!ipp) {
BREAK_TO_DEBUGGER();
const struct encoder_init_data *enc_init_data)
{
struct dce110_link_encoder *enc110 =
- dm_alloc(sizeof(struct dce110_link_encoder));
+ kzalloc(sizeof(struct dce110_link_encoder), GFP_KERNEL);
if (!enc110)
return NULL;
}
BREAK_TO_DEBUGGER();
- dm_free(enc110);
+ kfree(enc110);
return NULL;
}
uint32_t inst)
{
struct dce110_opp *opp =
- dm_alloc(sizeof(struct dce110_opp));
+ kzalloc(sizeof(struct dce110_opp), GFP_KERNEL);
if (!opp)
return NULL;
return &opp->base;
BREAK_TO_DEBUGGER();
- dm_free(opp);
+ kfree(opp);
return NULL;
}
bool dp_clk_src)
{
struct dce110_clk_src *clk_src =
- dm_alloc(sizeof(struct dce110_clk_src));
+ kzalloc(sizeof(struct dce110_clk_src), GFP_KERNEL);
if (!clk_src)
return NULL;
void dce100_clock_source_destroy(struct clock_source **clk_src)
{
- dm_free(TO_DCE110_CLK_SRC(*clk_src));
+ kfree(TO_DCE110_CLK_SRC(*clk_src));
*clk_src = NULL;
}
dce_ipp_destroy(&pool->base.ipps[i]);
if (pool->base.mis[i] != NULL) {
- dm_free(TO_DCE_MEM_INPUT(pool->base.mis[i]));
+ kfree(TO_DCE_MEM_INPUT(pool->base.mis[i]));
pool->base.mis[i] = NULL;
}
if (pool->base.timing_generators[i] != NULL) {
- dm_free(DCE110TG_FROM_TG(pool->base.timing_generators[i]));
+ kfree(DCE110TG_FROM_TG(pool->base.timing_generators[i]));
pool->base.timing_generators[i] = NULL;
}
}
for (i = 0; i < pool->base.stream_enc_count; i++) {
if (pool->base.stream_enc[i] != NULL)
- dm_free(DCE110STRENC_FROM_STRENC(pool->base.stream_enc[i]));
+ kfree(DCE110STRENC_FROM_STRENC(pool->base.stream_enc[i]));
}
for (i = 0; i < pool->base.clk_src_count; i++) {
struct dce110_resource_pool *dce110_pool = TO_DCE110_RES_POOL(*pool);
destruct(dce110_pool);
- dm_free(dce110_pool);
+ kfree(dce110_pool);
*pool = NULL;
}
struct dc *dc)
{
struct dce110_resource_pool *pool =
- dm_alloc(sizeof(struct dce110_resource_pool));
+ kzalloc(sizeof(struct dce110_resource_pool), GFP_KERNEL);
if (!pool)
return NULL;
struct compressor *dce110_compressor_create(struct dc_context *ctx)
{
struct dce110_compressor *cp110 =
- dm_alloc(sizeof(struct dce110_compressor));
+ kzalloc(sizeof(struct dce110_compressor), GFP_KERNEL);
if (!cp110)
return NULL;
return &cp110->base;
BREAK_TO_DEBUGGER();
- dm_free(cp110);
+ kfree(cp110);
return NULL;
}
void dce110_compressor_destroy(struct compressor **compressor)
{
- dm_free(TO_DCE110_COMPRESSOR(*compressor));
+ kfree(TO_DCE110_COMPRESSOR(*compressor));
*compressor = NULL;
}
const struct dce110_timing_generator_offsets *offsets)
{
struct dce110_timing_generator *tg110 =
- dm_alloc(sizeof(struct dce110_timing_generator));
+ kzalloc(sizeof(struct dce110_timing_generator), GFP_KERNEL);
if (!tg110)
return NULL;
return &tg110->base;
BREAK_TO_DEBUGGER();
- dm_free(tg110);
+ kfree(tg110);
return NULL;
}
struct dc_context *ctx)
{
struct dce110_stream_encoder *enc110 =
- dm_alloc(sizeof(struct dce110_stream_encoder));
+ kzalloc(sizeof(struct dce110_stream_encoder), GFP_KERNEL);
if (!enc110)
return NULL;
return &enc110->base;
BREAK_TO_DEBUGGER();
- dm_free(enc110);
+ kfree(enc110);
return NULL;
}
static struct dce_hwseq *dce110_hwseq_create(
struct dc_context *ctx)
{
- struct dce_hwseq *hws = dm_alloc(sizeof(struct dce_hwseq));
+ struct dce_hwseq *hws = kzalloc(sizeof(struct dce_hwseq), GFP_KERNEL);
if (hws) {
hws->ctx = ctx;
struct dc_context *ctx,
uint32_t inst)
{
- struct dce_mem_input *dce_mi = dm_alloc(sizeof(struct dce_mem_input));
+ struct dce_mem_input *dce_mi = kzalloc(sizeof(struct dce_mem_input),
+ GFP_KERNEL);
if (!dce_mi) {
BREAK_TO_DEBUGGER();
static void dce110_transform_destroy(struct transform **xfm)
{
- dm_free(TO_DCE_TRANSFORM(*xfm));
+ kfree(TO_DCE_TRANSFORM(*xfm));
*xfm = NULL;
}
uint32_t inst)
{
struct dce_transform *transform =
- dm_alloc(sizeof(struct dce_transform));
+ kzalloc(sizeof(struct dce_transform), GFP_KERNEL);
if (!transform)
return NULL;
return &transform->base;
BREAK_TO_DEBUGGER();
- dm_free(transform);
+ kfree(transform);
return NULL;
}
static struct input_pixel_processor *dce110_ipp_create(
struct dc_context *ctx, uint32_t inst)
{
- struct dce_ipp *ipp = dm_alloc(sizeof(struct dce_ipp));
+ struct dce_ipp *ipp = kzalloc(sizeof(struct dce_ipp), GFP_KERNEL);
if (!ipp) {
BREAK_TO_DEBUGGER();
const struct encoder_init_data *enc_init_data)
{
struct dce110_link_encoder *enc110 =
- dm_alloc(sizeof(struct dce110_link_encoder));
+ kzalloc(sizeof(struct dce110_link_encoder), GFP_KERNEL);
if (!enc110)
return NULL;
}
BREAK_TO_DEBUGGER();
- dm_free(enc110);
+ kfree(enc110);
return NULL;
}
uint32_t inst)
{
struct dce110_opp *opp =
- dm_alloc(sizeof(struct dce110_opp));
+ kzalloc(sizeof(struct dce110_opp), GFP_KERNEL);
if (!opp)
return NULL;
return &opp->base;
BREAK_TO_DEBUGGER();
- dm_free(opp);
+ kfree(opp);
return NULL;
}
bool dp_clk_src)
{
struct dce110_clk_src *clk_src =
- dm_alloc(sizeof(struct dce110_clk_src));
+ kzalloc(sizeof(struct dce110_clk_src), GFP_KERNEL);
if (!clk_src)
return NULL;
dce110_clk_src = TO_DCE110_CLK_SRC(*clk_src);
if (dce110_clk_src->dp_ss_params)
- dm_free(dce110_clk_src->dp_ss_params);
+ kfree(dce110_clk_src->dp_ss_params);
if (dce110_clk_src->hdmi_ss_params)
- dm_free(dce110_clk_src->hdmi_ss_params);
+ kfree(dce110_clk_src->hdmi_ss_params);
if (dce110_clk_src->dvi_ss_params)
- dm_free(dce110_clk_src->dvi_ss_params);
+ kfree(dce110_clk_src->dvi_ss_params);
- dm_free(dce110_clk_src);
+ kfree(dce110_clk_src);
*clk_src = NULL;
}
dce_ipp_destroy(&pool->base.ipps[i]);
if (pool->base.mis[i] != NULL) {
- dm_free(TO_DCE_MEM_INPUT(pool->base.mis[i]));
+ kfree(TO_DCE_MEM_INPUT(pool->base.mis[i]));
pool->base.mis[i] = NULL;
}
if (pool->base.timing_generators[i] != NULL) {
- dm_free(DCE110TG_FROM_TG(pool->base.timing_generators[i]));
+ kfree(DCE110TG_FROM_TG(pool->base.timing_generators[i]));
pool->base.timing_generators[i] = NULL;
}
}
for (i = 0; i < pool->base.stream_enc_count; i++) {
if (pool->base.stream_enc[i] != NULL)
- dm_free(DCE110STRENC_FROM_STRENC(pool->base.stream_enc[i]));
+ kfree(DCE110STRENC_FROM_STRENC(pool->base.stream_enc[i]));
}
for (i = 0; i < pool->base.clk_src_count; i++) {
struct dce110_resource_pool *dce110_pool = TO_DCE110_RES_POOL(*pool);
destruct(dce110_pool);
- dm_free(dce110_pool);
+ kfree(dce110_pool);
*pool = NULL;
}
static bool underlay_create(struct dc_context *ctx, struct resource_pool *pool)
{
- struct dce110_timing_generator *dce110_tgv = dm_alloc(sizeof (*dce110_tgv));
- struct dce_transform *dce110_xfmv = dm_alloc(sizeof (*dce110_xfmv));
- struct dce_mem_input *dce110_miv = dm_alloc(sizeof (*dce110_miv));
- struct dce110_opp *dce110_oppv = dm_alloc(sizeof (*dce110_oppv));
+ struct dce110_timing_generator *dce110_tgv = kzalloc(sizeof(*dce110_tgv),
+ GFP_KERNEL);
+ struct dce_transform *dce110_xfmv = kzalloc(sizeof(*dce110_xfmv),
+ GFP_KERNEL);
+ struct dce_mem_input *dce110_miv = kzalloc(sizeof(*dce110_miv),
+ GFP_KERNEL);
+ struct dce110_opp *dce110_oppv = kzalloc(sizeof(*dce110_oppv),
+ GFP_KERNEL);
if ((dce110_tgv == NULL) ||
(dce110_xfmv == NULL) ||
struct hw_asic_id asic_id)
{
struct dce110_resource_pool *pool =
- dm_alloc(sizeof(struct dce110_resource_pool));
+ kzalloc(sizeof(struct dce110_resource_pool), GFP_KERNEL);
if (!pool)
return NULL;
struct compressor *dce112_compressor_create(struct dc_context *ctx)
{
struct dce112_compressor *cp110 =
- dm_alloc(sizeof(struct dce112_compressor));
+ kzalloc(sizeof(struct dce112_compressor), GFP_KERNEL);
if (!cp110)
return NULL;
return &cp110->base;
BREAK_TO_DEBUGGER();
- dm_free(cp110);
+ kfree(cp110);
return NULL;
}
void dce112_compressor_destroy(struct compressor **compressor)
{
- dm_free(TO_DCE112_COMPRESSOR(*compressor));
+ kfree(TO_DCE112_COMPRESSOR(*compressor));
*compressor = NULL;
}
const struct dce110_timing_generator_offsets *offsets)
{
struct dce110_timing_generator *tg110 =
- dm_alloc(sizeof(struct dce110_timing_generator));
+ kzalloc(sizeof(struct dce110_timing_generator), GFP_KERNEL);
if (!tg110)
return NULL;
return &tg110->base;
BREAK_TO_DEBUGGER();
- dm_free(tg110);
+ kfree(tg110);
return NULL;
}
struct dc_context *ctx)
{
struct dce110_stream_encoder *enc110 =
- dm_alloc(sizeof(struct dce110_stream_encoder));
+ kzalloc(sizeof(struct dce110_stream_encoder), GFP_KERNEL);
if (!enc110)
return NULL;
return &enc110->base;
BREAK_TO_DEBUGGER();
- dm_free(enc110);
+ kfree(enc110);
return NULL;
}
static struct dce_hwseq *dce112_hwseq_create(
struct dc_context *ctx)
{
- struct dce_hwseq *hws = dm_alloc(sizeof(struct dce_hwseq));
+ struct dce_hwseq *hws = kzalloc(sizeof(struct dce_hwseq), GFP_KERNEL);
if (hws) {
hws->ctx = ctx;
struct dc_context *ctx,
uint32_t inst)
{
- struct dce_mem_input *dce_mi = dm_alloc(sizeof(struct dce_mem_input));
+ struct dce_mem_input *dce_mi = kzalloc(sizeof(struct dce_mem_input),
+ GFP_KERNEL);
if (!dce_mi) {
BREAK_TO_DEBUGGER();
static void dce112_transform_destroy(struct transform **xfm)
{
- dm_free(TO_DCE_TRANSFORM(*xfm));
+ kfree(TO_DCE_TRANSFORM(*xfm));
*xfm = NULL;
}
uint32_t inst)
{
struct dce_transform *transform =
- dm_alloc(sizeof(struct dce_transform));
+ kzalloc(sizeof(struct dce_transform), GFP_KERNEL);
if (!transform)
return NULL;
}
BREAK_TO_DEBUGGER();
- dm_free(transform);
+ kfree(transform);
return NULL;
}
const struct encoder_init_data *enc_init_data)
{
struct dce110_link_encoder *enc110 =
- dm_alloc(sizeof(struct dce110_link_encoder));
+ kzalloc(sizeof(struct dce110_link_encoder), GFP_KERNEL);
if (!enc110)
return NULL;
}
BREAK_TO_DEBUGGER();
- dm_free(enc110);
+ kfree(enc110);
return NULL;
}
static struct input_pixel_processor *dce112_ipp_create(
struct dc_context *ctx, uint32_t inst)
{
- struct dce_ipp *ipp = dm_alloc(sizeof(struct dce_ipp));
+ struct dce_ipp *ipp = kzalloc(sizeof(struct dce_ipp), GFP_KERNEL);
if (!ipp) {
BREAK_TO_DEBUGGER();
uint32_t inst)
{
struct dce110_opp *opp =
- dm_alloc(sizeof(struct dce110_opp));
+ kzalloc(sizeof(struct dce110_opp), GFP_KERNEL);
if (!opp)
return NULL;
return &opp->base;
BREAK_TO_DEBUGGER();
- dm_free(opp);
+ kfree(opp);
return NULL;
}
bool dp_clk_src)
{
struct dce110_clk_src *clk_src =
- dm_alloc(sizeof(struct dce110_clk_src));
+ kzalloc(sizeof(struct dce110_clk_src), GFP_KERNEL);
if (!clk_src)
return NULL;
void dce112_clock_source_destroy(struct clock_source **clk_src)
{
- dm_free(TO_DCE110_CLK_SRC(*clk_src));
+ kfree(TO_DCE110_CLK_SRC(*clk_src));
*clk_src = NULL;
}
dce_ipp_destroy(&pool->base.ipps[i]);
if (pool->base.mis[i] != NULL) {
- dm_free(TO_DCE_MEM_INPUT(pool->base.mis[i]));
+ kfree(TO_DCE_MEM_INPUT(pool->base.mis[i]));
pool->base.mis[i] = NULL;
}
if (pool->base.timing_generators[i] != NULL) {
- dm_free(DCE110TG_FROM_TG(pool->base.timing_generators[i]));
+ kfree(DCE110TG_FROM_TG(pool->base.timing_generators[i]));
pool->base.timing_generators[i] = NULL;
}
}
for (i = 0; i < pool->base.stream_enc_count; i++) {
if (pool->base.stream_enc[i] != NULL)
- dm_free(DCE110STRENC_FROM_STRENC(pool->base.stream_enc[i]));
+ kfree(DCE110STRENC_FROM_STRENC(pool->base.stream_enc[i]));
}
for (i = 0; i < pool->base.clk_src_count; i++) {
struct dce110_resource_pool *dce110_pool = TO_DCE110_RES_POOL(*pool);
destruct(dce110_pool);
- dm_free(dce110_pool);
+ kfree(dce110_pool);
*pool = NULL;
}
struct dc *dc)
{
struct dce110_resource_pool *pool =
- dm_alloc(sizeof(struct dce110_resource_pool));
+ kzalloc(sizeof(struct dce110_resource_pool), GFP_KERNEL);
if (!pool)
return NULL;
uint32_t inst)
{
struct dce110_opp *opp =
- dm_alloc(sizeof(struct dce110_opp));
+ kzalloc(sizeof(struct dce110_opp), GFP_KERNEL);
if (!opp)
return NULL;
return &opp->base;
BREAK_TO_DEBUGGER();
- dm_free(opp);
+ kfree(opp);
return NULL;
}
bool dp_clk_src)
{
struct dce110_clk_src *clk_src =
- dm_alloc(sizeof(*clk_src));
+ kzalloc(sizeof(*clk_src), GFP_KERNEL);
if (!clk_src)
return NULL;
void dce120_clock_source_destroy(struct clock_source **clk_src)
{
- dm_free(TO_DCE110_CLK_SRC(*clk_src));
+ kfree(TO_DCE110_CLK_SRC(*clk_src));
*clk_src = NULL;
}
const struct dce110_timing_generator_offsets *offsets)
{
struct dce110_timing_generator *tg110 =
- dm_alloc(sizeof(struct dce110_timing_generator));
+ kzalloc(sizeof(struct dce110_timing_generator), GFP_KERNEL);
if (!tg110)
return NULL;
return &tg110->base;
BREAK_TO_DEBUGGER();
- dm_free(tg110);
+ kfree(tg110);
return NULL;
}
static void dce120_transform_destroy(struct transform **xfm)
{
- dm_free(TO_DCE_TRANSFORM(*xfm));
+ kfree(TO_DCE_TRANSFORM(*xfm));
*xfm = NULL;
}
dce_ipp_destroy(&pool->base.ipps[i]);
if (pool->base.mis[i] != NULL) {
- dm_free(TO_DCE_MEM_INPUT(pool->base.mis[i]));
+ kfree(TO_DCE_MEM_INPUT(pool->base.mis[i]));
pool->base.mis[i] = NULL;
}
}
if (pool->base.timing_generators[i] != NULL) {
- dm_free(DCE110TG_FROM_TG(pool->base.timing_generators[i]));
+ kfree(DCE110TG_FROM_TG(pool->base.timing_generators[i]));
pool->base.timing_generators[i] = NULL;
}
}
for (i = 0; i < pool->base.stream_enc_count; i++) {
if (pool->base.stream_enc[i] != NULL)
- dm_free(DCE110STRENC_FROM_STRENC(pool->base.stream_enc[i]));
+ kfree(DCE110STRENC_FROM_STRENC(pool->base.stream_enc[i]));
}
for (i = 0; i < pool->base.clk_src_count; i++) {
const struct encoder_init_data *enc_init_data)
{
struct dce110_link_encoder *enc110 =
- dm_alloc(sizeof(struct dce110_link_encoder));
+ kzalloc(sizeof(struct dce110_link_encoder), GFP_KERNEL);
if (!enc110)
return NULL;
}
BREAK_TO_DEBUGGER();
- dm_free(enc110);
+ kfree(enc110);
return NULL;
}
static struct input_pixel_processor *dce120_ipp_create(
struct dc_context *ctx, uint32_t inst)
{
- struct dce_ipp *ipp = dm_alloc(sizeof(struct dce_ipp));
+ struct dce_ipp *ipp = kzalloc(sizeof(struct dce_ipp), GFP_KERNEL);
if (!ipp) {
BREAK_TO_DEBUGGER();
struct dc_context *ctx)
{
struct dce110_stream_encoder *enc110 =
- dm_alloc(sizeof(struct dce110_stream_encoder));
+ kzalloc(sizeof(struct dce110_stream_encoder), GFP_KERNEL);
if (!enc110)
return NULL;
return &enc110->base;
BREAK_TO_DEBUGGER();
- dm_free(enc110);
+ kfree(enc110);
return NULL;
}
static struct dce_hwseq *dce120_hwseq_create(
struct dc_context *ctx)
{
- struct dce_hwseq *hws = dm_alloc(sizeof(struct dce_hwseq));
+ struct dce_hwseq *hws = kzalloc(sizeof(struct dce_hwseq), GFP_KERNEL);
if (hws) {
hws->ctx = ctx;
struct dc_context *ctx,
uint32_t inst)
{
- struct dce_mem_input *dce_mi = dm_alloc(sizeof(struct dce_mem_input));
+ struct dce_mem_input *dce_mi = kzalloc(sizeof(struct dce_mem_input),
+ GFP_KERNEL);
if (!dce_mi) {
BREAK_TO_DEBUGGER();
uint32_t inst)
{
struct dce_transform *transform =
- dm_alloc(sizeof(struct dce_transform));
+ kzalloc(sizeof(struct dce_transform), GFP_KERNEL);
if (!transform)
return NULL;
}
BREAK_TO_DEBUGGER();
- dm_free(transform);
+ kfree(transform);
return NULL;
}
struct dce110_resource_pool *dce110_pool = TO_DCE110_RES_POOL(*pool);
destruct(dce110_pool);
- dm_free(dce110_pool);
+ kfree(dce110_pool);
*pool = NULL;
}
struct dc *dc)
{
struct dce110_resource_pool *pool =
- dm_alloc(sizeof(struct dce110_resource_pool));
+ kzalloc(sizeof(struct dce110_resource_pool), GFP_KERNEL);
if (!pool)
return NULL;
struct compressor *dce80_compressor_create(struct dc_context *ctx)
{
struct dce80_compressor *cp80 =
- dm_alloc(sizeof(struct dce80_compressor));
+ kzalloc(sizeof(struct dce80_compressor), GFP_KERNEL);
if (!cp80)
return NULL;
return &cp80->base;
BREAK_TO_DEBUGGER();
- dm_free(cp80);
+ kfree(cp80);
return NULL;
}
void dce80_compressor_destroy(struct compressor **compressor)
{
- dm_free(TO_DCE80_COMPRESSOR(*compressor));
+ kfree(TO_DCE80_COMPRESSOR(*compressor));
*compressor = NULL;
}
const struct dce110_timing_generator_offsets *offsets)
{
struct dce110_timing_generator *tg110 =
- dm_alloc(sizeof(struct dce110_timing_generator));
+ kzalloc(sizeof(struct dce110_timing_generator), GFP_KERNEL);
if (!tg110)
return NULL;
return &tg110->base;
BREAK_TO_DEBUGGER();
- dm_free(tg110);
+ kfree(tg110);
return NULL;
}
uint32_t inst)
{
struct dce110_opp *opp =
- dm_alloc(sizeof(struct dce110_opp));
+ kzalloc(sizeof(struct dce110_opp), GFP_KERNEL);
if (!opp)
return NULL;
return &opp->base;
BREAK_TO_DEBUGGER();
- dm_free(opp);
+ kfree(opp);
return NULL;
}
struct dc_context *ctx)
{
struct dce110_stream_encoder *enc110 =
- dm_alloc(sizeof(struct dce110_stream_encoder));
+ kzalloc(sizeof(struct dce110_stream_encoder), GFP_KERNEL);
if (!enc110)
return NULL;
return &enc110->base;
BREAK_TO_DEBUGGER();
- dm_free(enc110);
+ kfree(enc110);
return NULL;
}
static struct dce_hwseq *dce80_hwseq_create(
struct dc_context *ctx)
{
- struct dce_hwseq *hws = dm_alloc(sizeof(struct dce_hwseq));
+ struct dce_hwseq *hws = kzalloc(sizeof(struct dce_hwseq), GFP_KERNEL);
if (hws) {
hws->ctx = ctx;
struct dc_context *ctx,
uint32_t inst)
{
- struct dce_mem_input *dce_mi = dm_alloc(sizeof(struct dce_mem_input));
+ struct dce_mem_input *dce_mi = kzalloc(sizeof(struct dce_mem_input),
+ GFP_KERNEL);
if (!dce_mi) {
BREAK_TO_DEBUGGER();
static void dce80_transform_destroy(struct transform **xfm)
{
- dm_free(TO_DCE_TRANSFORM(*xfm));
+ kfree(TO_DCE_TRANSFORM(*xfm));
*xfm = NULL;
}
uint32_t inst)
{
struct dce_transform *transform =
- dm_alloc(sizeof(struct dce_transform));
+ kzalloc(sizeof(struct dce_transform), GFP_KERNEL);
if (!transform)
return NULL;
}
BREAK_TO_DEBUGGER();
- dm_free(transform);
+ kfree(transform);
return NULL;
}
const struct encoder_init_data *enc_init_data)
{
struct dce110_link_encoder *enc110 =
- dm_alloc(sizeof(struct dce110_link_encoder));
+ kzalloc(sizeof(struct dce110_link_encoder), GFP_KERNEL);
if (!enc110)
return NULL;
}
BREAK_TO_DEBUGGER();
- dm_free(enc110);
+ kfree(enc110);
return NULL;
}
bool dp_clk_src)
{
struct dce110_clk_src *clk_src =
- dm_alloc(sizeof(struct dce110_clk_src));
+ kzalloc(sizeof(struct dce110_clk_src), GFP_KERNEL);
if (!clk_src)
return NULL;
void dce80_clock_source_destroy(struct clock_source **clk_src)
{
- dm_free(TO_DCE110_CLK_SRC(*clk_src));
+ kfree(TO_DCE110_CLK_SRC(*clk_src));
*clk_src = NULL;
}
static struct input_pixel_processor *dce80_ipp_create(
struct dc_context *ctx, uint32_t inst)
{
- struct dce_ipp *ipp = dm_alloc(sizeof(struct dce_ipp));
+ struct dce_ipp *ipp = kzalloc(sizeof(struct dce_ipp), GFP_KERNEL);
if (!ipp) {
BREAK_TO_DEBUGGER();
dce_ipp_destroy(&pool->base.ipps[i]);
if (pool->base.mis[i] != NULL) {
- dm_free(TO_DCE_MEM_INPUT(pool->base.mis[i]));
+ kfree(TO_DCE_MEM_INPUT(pool->base.mis[i]));
pool->base.mis[i] = NULL;
}
if (pool->base.timing_generators[i] != NULL) {
- dm_free(DCE110TG_FROM_TG(pool->base.timing_generators[i]));
+ kfree(DCE110TG_FROM_TG(pool->base.timing_generators[i]));
pool->base.timing_generators[i] = NULL;
}
}
for (i = 0; i < pool->base.stream_enc_count; i++) {
if (pool->base.stream_enc[i] != NULL)
- dm_free(DCE110STRENC_FROM_STRENC(pool->base.stream_enc[i]));
+ kfree(DCE110STRENC_FROM_STRENC(pool->base.stream_enc[i]));
}
for (i = 0; i < pool->base.clk_src_count; i++) {
struct dce110_resource_pool *dce110_pool = TO_DCE110_RES_POOL(*pool);
destruct(dce110_pool);
- dm_free(dce110_pool);
+ kfree(dce110_pool);
*pool = NULL;
}
struct dc *dc)
{
struct dce110_resource_pool *pool =
- dm_alloc(sizeof(struct dce110_resource_pool));
+ kzalloc(sizeof(struct dce110_resource_pool), GFP_KERNEL);
if (!pool)
return NULL;
struct dc *dc)
{
struct dce110_resource_pool *pool =
- dm_alloc(sizeof(struct dce110_resource_pool));
+ kzalloc(sizeof(struct dce110_resource_pool), GFP_KERNEL);
if (!pool)
return NULL;
struct dc *dc)
{
struct dce110_resource_pool *pool =
- dm_alloc(sizeof(struct dce110_resource_pool));
+ kzalloc(sizeof(struct dce110_resource_pool), GFP_KERNEL);
if (!pool)
return NULL;
static void dcn10_ipp_destroy(struct input_pixel_processor **ipp)
{
- dm_free(TO_DCN10_IPP(*ipp));
+ kfree(TO_DCN10_IPP(*ipp));
*ipp = NULL;
}
static void dcn10_opp_destroy(struct output_pixel_processor **opp)
{
- dm_free(TO_DCN10_OPP(*opp));
+ kfree(TO_DCN10_OPP(*opp));
*opp = NULL;
}
static void dcn10_dpp_destroy(struct transform **xfm)
{
- dm_free(TO_DCN10_DPP(*xfm));
+ kfree(TO_DCN10_DPP(*xfm));
*xfm = NULL;
}
uint32_t inst)
{
struct dcn10_dpp *dpp =
- dm_alloc(sizeof(struct dcn10_dpp));
+ kzalloc(sizeof(struct dcn10_dpp), GFP_KERNEL);
if (!dpp)
return NULL;
return &dpp->base;
BREAK_TO_DEBUGGER();
- dm_free(dpp);
+ kfree(dpp);
return NULL;
}
struct dc_context *ctx, uint32_t inst)
{
struct dcn10_ipp *ipp =
- dm_alloc(sizeof(struct dcn10_ipp));
+ kzalloc(sizeof(struct dcn10_ipp), GFP_KERNEL);
if (!ipp) {
BREAK_TO_DEBUGGER();
struct dc_context *ctx, uint32_t inst)
{
struct dcn10_opp *opp =
- dm_alloc(sizeof(struct dcn10_opp));
+ kzalloc(sizeof(struct dcn10_opp), GFP_KERNEL);
if (!opp) {
BREAK_TO_DEBUGGER();
static struct mpc *dcn10_mpc_create(struct dc_context *ctx)
{
- struct dcn10_mpc *mpc10 = dm_alloc(sizeof(struct dcn10_mpc));
+ struct dcn10_mpc *mpc10 = kzalloc(sizeof(struct dcn10_mpc),
+ GFP_KERNEL);
if (!mpc10)
return NULL;
uint32_t instance)
{
struct dcn10_timing_generator *tgn10 =
- dm_alloc(sizeof(struct dcn10_timing_generator));
+ kzalloc(sizeof(struct dcn10_timing_generator), GFP_KERNEL);
if (!tgn10)
return NULL;
const struct encoder_init_data *enc_init_data)
{
struct dce110_link_encoder *enc110 =
- dm_alloc(sizeof(struct dce110_link_encoder));
+ kzalloc(sizeof(struct dce110_link_encoder), GFP_KERNEL);
if (!enc110)
return NULL;
}
BREAK_TO_DEBUGGER();
- dm_free(enc110);
+ kfree(enc110);
return NULL;
}
bool dp_clk_src)
{
struct dce110_clk_src *clk_src =
- dm_alloc(sizeof(struct dce110_clk_src));
+ kzalloc(sizeof(struct dce110_clk_src), GFP_KERNEL);
if (!clk_src)
return NULL;
struct dc_context *ctx)
{
struct dce110_stream_encoder *enc110 =
- dm_alloc(sizeof(struct dce110_stream_encoder));
+ kzalloc(sizeof(struct dce110_stream_encoder), GFP_KERNEL);
if (!enc110)
return NULL;
return &enc110->base;
BREAK_TO_DEBUGGER();
- dm_free(enc110);
+ kfree(enc110);
return NULL;
}
static struct dce_hwseq *dcn10_hwseq_create(
struct dc_context *ctx)
{
- struct dce_hwseq *hws = dm_alloc(sizeof(struct dce_hwseq));
+ struct dce_hwseq *hws = kzalloc(sizeof(struct dce_hwseq), GFP_KERNEL);
if (hws) {
hws->ctx = ctx;
void dcn10_clock_source_destroy(struct clock_source **clk_src)
{
- dm_free(TO_DCE110_CLK_SRC(*clk_src));
+ kfree(TO_DCE110_CLK_SRC(*clk_src));
*clk_src = NULL;
}
static struct pp_smu_funcs_rv *dcn10_pp_smu_create(struct dc_context *ctx)
{
- struct pp_smu_funcs_rv *pp_smu = dm_alloc(sizeof(*pp_smu));
+ struct pp_smu_funcs_rv *pp_smu = kzalloc(sizeof(*pp_smu), GFP_KERNEL);
if (!pp_smu)
return pp_smu;
/* TODO: free dcn version of stream encoder once implemented
* rather than using virtual stream encoder
*/
- dm_free(pool->base.stream_enc[i]);
+ kfree(pool->base.stream_enc[i]);
pool->base.stream_enc[i] = NULL;
}
}
if (pool->base.mpc != NULL) {
- dm_free(TO_DCN10_MPC(pool->base.mpc));
+ kfree(TO_DCN10_MPC(pool->base.mpc));
pool->base.mpc = NULL;
}
for (i = 0; i < pool->base.pipe_count; i++) {
pool->base.ipps[i]->funcs->ipp_destroy(&pool->base.ipps[i]);
if (pool->base.mis[i] != NULL) {
- dm_free(TO_DCN10_MEM_INPUT(pool->base.mis[i]));
+ kfree(TO_DCN10_MEM_INPUT(pool->base.mis[i]));
pool->base.mis[i] = NULL;
}
}
if (pool->base.timing_generators[i] != NULL) {
- dm_free(DCN10TG_FROM_TG(pool->base.timing_generators[i]));
+ kfree(DCN10TG_FROM_TG(pool->base.timing_generators[i]));
pool->base.timing_generators[i] = NULL;
}
}
for (i = 0; i < pool->base.stream_enc_count; i++) {
if (pool->base.stream_enc[i] != NULL)
- dm_free(DCE110STRENC_FROM_STRENC(pool->base.stream_enc[i]));
+ kfree(DCE110STRENC_FROM_STRENC(pool->base.stream_enc[i]));
}
for (i = 0; i < pool->base.audio_count; i++) {
}
for (i = 0; i < pool->base.res_cap->num_dwb; i++) {
- dm_free(pool->base.dwbc[i]);
+ kfree(pool->base.dwbc[i]);
pool->base.dwbc[i] = NULL;
}
if (pool->base.display_clock != NULL)
dce_disp_clk_destroy(&pool->base.display_clock);
- dm_free(pool->base.pp_smu);
+ kfree(pool->base.pp_smu);
}
static struct mem_input *dcn10_mem_input_create(
uint32_t inst)
{
struct dcn10_mem_input *mem_inputn10 =
- dm_alloc(sizeof(struct dcn10_mem_input));
+ kzalloc(sizeof(struct dcn10_mem_input), GFP_KERNEL);
if (!mem_inputn10)
return NULL;
return &mem_inputn10->base;
BREAK_TO_DEBUGGER();
- dm_free(mem_inputn10);
+ kfree(mem_inputn10);
return NULL;
}
struct dcn10_resource_pool *dcn10_pool = TO_DCN10_RES_POOL(*pool);
destruct(dcn10_pool);
- dm_free(dcn10_pool);
+ kfree(dcn10_pool);
*pool = NULL;
}
uint32_t dwb_count = pool->res_cap->num_dwb;
for (i = 0; i < dwb_count; i++) {
- struct dcn10_dwbc *dwbc10 = dm_alloc(sizeof(struct dcn10_dwbc));
+ struct dcn10_dwbc *dwbc10 = kzalloc(sizeof(struct dcn10_dwbc),
+ GFP_KERNEL);
if (!dwbc10) {
dm_error("DC: failed to create dwbc10!\n");
struct dc *dc)
{
struct dcn10_resource_pool *pool =
- dm_alloc(sizeof(struct dcn10_resource_pool));
+ kzalloc(sizeof(struct dcn10_resource_pool), GFP_KERNEL);
if (!pool)
return NULL;
uint32_t en,
enum gpio_pin_output_state output_state)
{
- struct gpio *gpio = dm_alloc(sizeof(struct gpio));
+ struct gpio *gpio = kzalloc(sizeof(struct gpio), GFP_KERNEL);
if (!gpio) {
ASSERT_CRITICAL(false);
dal_gpio_close(*gpio);
- dm_free(*gpio);
+ kfree(*gpio);
*gpio = NULL;
}
uint32_t index_of_id;
- service = dm_alloc(sizeof(struct gpio_service));
+ service = kzalloc(sizeof(struct gpio_service), GFP_KERNEL);
if (!service) {
BREAK_TO_DEBUGGER();
if (number_of_bits) {
uint32_t index_of_uint = 0;
- slot = dm_alloc(number_of_uints * sizeof(uint32_t));
+ slot = kzalloc(number_of_uints * sizeof(uint32_t),
+ GFP_KERNEL);
if (!slot) {
BREAK_TO_DEBUGGER();
slot = service->busyness[index_of_id];
if (slot)
- dm_free(slot);
+ kfree(slot);
};
failure_1:
- dm_free(service);
+ kfree(service);
return NULL;
}
uint32_t *slot = (*ptr)->busyness[index_of_id];
if (slot)
- dm_free(slot);
+ kfree(slot);
++index_of_id;
} while (index_of_id < GPIO_ID_COUNT);
}
- dm_free(*ptr);
+ kfree(*ptr);
*ptr = NULL;
}
dal_gpio_close(*irq);
dal_gpio_destroy(irq);
- dm_free(*irq);
+ kfree(*irq);
*irq = NULL;
}
if (!service->translate.funcs->offset_to_id(offset, mask, &id, &en))
return NULL;
- ddc = dm_alloc(sizeof(struct ddc));
+ ddc = kzalloc(sizeof(struct ddc), GFP_KERNEL);
if (!ddc) {
BREAK_TO_DEBUGGER();
dal_gpio_destroy(&ddc->pin_data);
failure_1:
- dm_free(ddc);
+ kfree(ddc);
return NULL;
}
dal_ddc_close(*ddc);
dal_gpio_destroy(&(*ddc)->pin_data);
dal_gpio_destroy(&(*ddc)->pin_clock);
- dm_free(*ddc);
+ kfree(*ddc);
*ddc = NULL;
}
destruct(pin);
- dm_free(pin);
+ kfree(pin);
*ptr = NULL;
}
enum gpio_id id,
uint32_t en)
{
- struct hw_ddc *pin = dm_alloc(sizeof(struct hw_ddc));
+ struct hw_ddc *pin = kzalloc(sizeof(struct hw_ddc), GFP_KERNEL);
if (!pin) {
ASSERT_CRITICAL(false);
ASSERT_CRITICAL(false);
- dm_free(pin);
+ kfree(pin);
return NULL;
}
return;
}
- dm_free(*factory);
+ kfree(*factory);
*factory = NULL;
}
destruct(hpd);
- dm_free(hpd);
+ kfree(hpd);
*ptr = NULL;
}
enum gpio_id id,
uint32_t en)
{
- struct hw_hpd *hpd = dm_alloc(sizeof(struct hw_hpd));
+ struct hw_hpd *hpd = kzalloc(sizeof(struct hw_hpd), GFP_KERNEL);
if (!hpd) {
ASSERT_CRITICAL(false);
ASSERT_CRITICAL(false);
- dm_free(hpd);
+ kfree(hpd);
return NULL;
}
struct dc_context *ctx)
{
struct i2caux_dce110 *i2caux_dce110 =
- dm_alloc(sizeof(struct i2caux_dce110));
+ kzalloc(sizeof(struct i2caux_dce110), GFP_KERNEL);
if (!i2caux_dce110) {
ASSERT_CRITICAL(false);
ASSERT_CRITICAL(false);
- dm_free(i2caux_dce110);
+ kfree(i2caux_dce110);
return NULL;
}
destruct(engine);
- dm_free(engine);
+ kfree(engine);
*aux_engine = NULL;
}
return NULL;
}
- engine = dm_alloc(sizeof(*engine));
+ engine = kzalloc(sizeof(*engine), GFP_KERNEL);
if (!engine) {
ASSERT_CRITICAL(false);
ASSERT_CRITICAL(false);
- dm_free(engine);
+ kfree(engine);
return NULL;
}
dal_i2c_hw_engine_destruct(&engine_dce110->base);
- dm_free(engine_dce110);
+ kfree(engine_dce110);
*i2c_engine = NULL;
}
return NULL;
}
- engine_dce10 = dm_alloc(sizeof(struct i2c_hw_engine_dce110));
+ engine_dce10 = kzalloc(sizeof(struct i2c_hw_engine_dce110),
+ GFP_KERNEL);
if (!engine_dce10) {
ASSERT_CRITICAL(false);
ASSERT_CRITICAL(false);
- dm_free(engine_dce10);
+ kfree(engine_dce10);
return NULL;
}
destruct(sw_engine);
- dm_free(sw_engine);
+ kfree(sw_engine);
*engine = NULL;
}
return NULL;
}
- engine_dce110 = dm_alloc(sizeof(struct i2c_sw_engine_dce110));
+ engine_dce110 = kzalloc(sizeof(struct i2c_sw_engine_dce110),
+ GFP_KERNEL);
if (!engine_dce110) {
ASSERT_CRITICAL(false);
ASSERT_CRITICAL(false);
- dm_free(engine_dce110);
+ kfree(engine_dce110);
return NULL;
}
destruct(i2caux_dce110);
- dm_free(i2caux_dce110);
+ kfree(i2caux_dce110);
*i2c_engine = NULL;
}
struct dc_context *ctx)
{
struct i2caux_dce110 *i2caux_dce110 =
- dm_alloc(sizeof(struct i2caux_dce110));
+ kzalloc(sizeof(struct i2caux_dce110), GFP_KERNEL);
if (!i2caux_dce110) {
ASSERT_CRITICAL(false);
ASSERT_CRITICAL(false);
- dm_free(i2caux_dce110);
+ kfree(i2caux_dce110);
return NULL;
}
struct dc_context *ctx)
{
struct i2caux_dce110 *i2caux_dce110 =
- dm_alloc(sizeof(struct i2caux_dce110));
+ kzalloc(sizeof(struct i2caux_dce110), GFP_KERNEL);
if (!i2caux_dce110) {
ASSERT_CRITICAL(false);
ASSERT_CRITICAL(false);
- dm_free(i2caux_dce110);
+ kfree(i2caux_dce110);
return NULL;
}
struct dc_context *ctx)
{
struct i2caux_dce110 *i2caux_dce110 =
- dm_alloc(sizeof(struct i2caux_dce110));
+ kzalloc(sizeof(struct i2caux_dce110), GFP_KERNEL);
if (!i2caux_dce110) {
ASSERT_CRITICAL(false);
ASSERT_CRITICAL(false);
- dm_free(i2caux_dce110);
+ kfree(i2caux_dce110);
return NULL;
}
destruct(engine);
- dm_free(engine);
+ kfree(engine);
*i2c_engine = NULL;
}
return NULL;
}
- engine = dm_alloc(sizeof(struct i2c_hw_engine_dce80));
+ engine = kzalloc(sizeof(struct i2c_hw_engine_dce80), GFP_KERNEL);
if (!engine) {
BREAK_TO_DEBUGGER();
BREAK_TO_DEBUGGER();
- dm_free(engine);
+ kfree(engine);
return NULL;
}
destruct(sw_engine);
- dm_free(sw_engine);
+ kfree(sw_engine);
*engine = NULL;
}
return NULL;
}
- engine = dm_alloc(sizeof(struct i2c_sw_engine_dce80));
+ engine = kzalloc(sizeof(struct i2c_sw_engine_dce80), GFP_KERNEL);
if (!engine) {
BREAK_TO_DEBUGGER();
BREAK_TO_DEBUGGER();
- dm_free(engine);
+ kfree(engine);
return NULL;
}
destruct(i2caux_dce80);
- dm_free(i2caux_dce80);
+ kfree(i2caux_dce80);
*i2c_engine = NULL;
}
struct dc_context *ctx)
{
struct i2caux_dce80 *i2caux_dce80 =
- dm_alloc(sizeof(struct i2caux_dce80));
+ kzalloc(sizeof(struct i2caux_dce80), GFP_KERNEL);
if (!i2caux_dce80) {
BREAK_TO_DEBUGGER();
BREAK_TO_DEBUGGER();
- dm_free(i2caux_dce80);
+ kfree(i2caux_dce80);
return NULL;
}
struct dc_context *ctx)
{
struct i2caux_dce110 *i2caux_dce110 =
- dm_alloc(sizeof(struct i2caux_dce110));
+ kzalloc(sizeof(struct i2caux_dce110), GFP_KERNEL);
if (!i2caux_dce110) {
ASSERT_CRITICAL(false);
ASSERT_CRITICAL(false);
- dm_free(i2caux_dce110);
+ kfree(i2caux_dce110);
return NULL;
}
{
destruct(*i2c_engine);
- dm_free(*i2c_engine);
+ kfree(*i2c_engine);
*i2c_engine = NULL;
}
struct i2caux *dal_i2caux_diag_fpga_create(
struct dc_context *ctx)
{
- struct i2caux *i2caux = dm_alloc(sizeof(struct i2caux));
+ struct i2caux *i2caux = kzalloc(sizeof(struct i2caux),
+ GFP_KERNEL);
if (!i2caux) {
ASSERT_CRITICAL(false);
ASSERT_CRITICAL(false);
- dm_free(i2caux);
+ kfree(i2caux);
return NULL;
}
{
dal_i2c_sw_engine_destruct(FROM_I2C_ENGINE(*ptr));
- dm_free(*ptr);
+ kfree(*ptr);
*ptr = NULL;
}
return NULL;
}
- engine = dm_alloc(sizeof(struct i2c_sw_engine));
+ engine = kzalloc(sizeof(struct i2c_sw_engine), GFP_KERNEL);
if (!engine) {
BREAK_TO_DEBUGGER();
BREAK_TO_DEBUGGER();
- dm_free(engine);
+ kfree(engine);
return NULL;
}
struct irq_service *dal_irq_service_dce110_create(
struct irq_service_init_data *init_data)
{
- struct irq_service *irq_service = dm_alloc(sizeof(*irq_service));
+ struct irq_service *irq_service = kzalloc(sizeof(*irq_service),
+ GFP_KERNEL);
if (!irq_service)
return NULL;
if (construct(irq_service, init_data))
return irq_service;
- dm_free(irq_service);
+ kfree(irq_service);
return NULL;
}
struct irq_service *dal_irq_service_dce120_create(
struct irq_service_init_data *init_data)
{
- struct irq_service *irq_service = dm_alloc(sizeof(*irq_service));
+ struct irq_service *irq_service = kzalloc(sizeof(*irq_service),
+ GFP_KERNEL);
if (!irq_service)
return NULL;
if (construct(irq_service, init_data))
return irq_service;
- dm_free(irq_service);
+ kfree(irq_service);
return NULL;
}
struct irq_service *dal_irq_service_dce80_create(
struct irq_service_init_data *init_data)
{
- struct irq_service *irq_service = dm_alloc(sizeof(*irq_service));
+ struct irq_service *irq_service = kzalloc(sizeof(*irq_service),
+ GFP_KERNEL);
if (!irq_service)
return NULL;
if (construct(irq_service, init_data))
return irq_service;
- dm_free(irq_service);
+ kfree(irq_service);
return NULL;
}
struct irq_service *dal_irq_service_dcn10_create(
struct irq_service_init_data *init_data)
{
- struct irq_service *irq_service = dm_alloc(sizeof(*irq_service));
+ struct irq_service *irq_service = kzalloc(sizeof(*irq_service),
+ GFP_KERNEL);
if (!irq_service)
return NULL;
if (construct(irq_service, init_data))
return irq_service;
- dm_free(irq_service);
+ kfree(irq_service);
return NULL;
}
return;
}
- dm_free(*irq_service);
+ kfree(*irq_service);
*irq_service = NULL;
}
static void virtual_link_encoder_destroy(struct link_encoder **enc)
{
- dm_free(*enc);
+ kfree(*enc);
*enc = NULL;
}
struct stream_encoder *virtual_stream_encoder_create(
struct dc_context *ctx, struct dc_bios *bp)
{
- struct stream_encoder *enc = dm_alloc(sizeof(*enc));
+ struct stream_encoder *enc = kzalloc(sizeof(*enc), GFP_KERNEL);
if (!enc)
return NULL;
return enc;
BREAK_TO_DEBUGGER();
- dm_free(enc);
+ kfree(enc);
return NULL;
}
struct mod_freesync *mod_freesync_create(struct dc *dc)
{
struct core_freesync *core_freesync =
- dm_alloc(sizeof(struct core_freesync));
+ kzalloc(sizeof(struct core_freesync), GFP_KERNEL);
struct persistent_data_flag flag;
if (core_freesync == NULL)
goto fail_alloc_context;
- core_freesync->map = dm_alloc(sizeof(struct freesync_entity) *
- MOD_FREESYNC_MAX_CONCURRENT_STREAMS);
+ core_freesync->map = kzalloc(sizeof(struct freesync_entity) * MOD_FREESYNC_MAX_CONCURRENT_STREAMS,
+ GFP_KERNEL);
if (core_freesync->map == NULL)
goto fail_alloc_map;
return &core_freesync->public;
fail_construct:
- dm_free(core_freesync->map);
+ kfree(core_freesync->map);
fail_alloc_map:
- dm_free(core_freesync);
+ kfree(core_freesync);
fail_alloc_context:
return NULL;
if (core_freesync->map[i].stream)
dc_stream_release(core_freesync->map[i].stream);
- dm_free(core_freesync->map);
+ kfree(core_freesync->map);
- dm_free(core_freesync);
+ kfree(core_freesync);
}
}
OSDN Git Service
