mirror of
https://github.com/torvalds/linux.git
synced 2026-05-01 13:02:35 -04:00
bf4afc53b7
This was done entirely with mindless brute force, using
git grep -l '\<k[vmz]*alloc_objs*(.*, GFP_KERNEL)' |
xargs sed -i 's/\(alloc_objs*(.*\), GFP_KERNEL)/\1)/'
to convert the new alloc_obj() users that had a simple GFP_KERNEL
argument to just drop that argument.
Note that due to the extreme simplicity of the scripting, any slightly
more complex cases spread over multiple lines would not be triggered:
they definitely exist, but this covers the vast bulk of the cases, and
the resulting diff is also then easier to check automatically.
For the same reason the 'flex' versions will be done as a separate
conversion.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
433 lines
10 KiB
C
433 lines
10 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* (C) COPYRIGHT 2018 ARM Limited. All rights reserved.
|
|
* Author: James.Qian.Wang <james.qian.wang@arm.com>
|
|
*
|
|
*/
|
|
#include "komeda_dev.h"
|
|
#include "komeda_kms.h"
|
|
|
|
static void
|
|
komeda_component_state_reset(struct komeda_component_state *st)
|
|
{
|
|
st->binding_user = NULL;
|
|
st->affected_inputs = st->active_inputs;
|
|
st->active_inputs = 0;
|
|
st->changed_active_inputs = 0;
|
|
}
|
|
|
|
static struct drm_private_state *
|
|
komeda_layer_atomic_duplicate_state(struct drm_private_obj *obj)
|
|
{
|
|
struct komeda_layer_state *st;
|
|
|
|
st = kmemdup(obj->state, sizeof(*st), GFP_KERNEL);
|
|
if (!st)
|
|
return NULL;
|
|
|
|
komeda_component_state_reset(&st->base);
|
|
__drm_atomic_helper_private_obj_duplicate_state(obj, &st->base.obj);
|
|
|
|
return &st->base.obj;
|
|
}
|
|
|
|
static void
|
|
komeda_layer_atomic_destroy_state(struct drm_private_obj *obj,
|
|
struct drm_private_state *state)
|
|
{
|
|
struct komeda_layer_state *st = to_layer_st(priv_to_comp_st(state));
|
|
|
|
kfree(st);
|
|
}
|
|
|
|
static const struct drm_private_state_funcs komeda_layer_obj_funcs = {
|
|
.atomic_duplicate_state = komeda_layer_atomic_duplicate_state,
|
|
.atomic_destroy_state = komeda_layer_atomic_destroy_state,
|
|
};
|
|
|
|
static int komeda_layer_obj_add(struct komeda_kms_dev *kms,
|
|
struct komeda_layer *layer)
|
|
{
|
|
struct komeda_layer_state *st;
|
|
|
|
st = kzalloc_obj(*st);
|
|
if (!st)
|
|
return -ENOMEM;
|
|
|
|
st->base.component = &layer->base;
|
|
drm_atomic_private_obj_init(&kms->base, &layer->base.obj, &st->base.obj,
|
|
&komeda_layer_obj_funcs);
|
|
return 0;
|
|
}
|
|
|
|
static struct drm_private_state *
|
|
komeda_scaler_atomic_duplicate_state(struct drm_private_obj *obj)
|
|
{
|
|
struct komeda_scaler_state *st;
|
|
|
|
st = kmemdup(obj->state, sizeof(*st), GFP_KERNEL);
|
|
if (!st)
|
|
return NULL;
|
|
|
|
komeda_component_state_reset(&st->base);
|
|
__drm_atomic_helper_private_obj_duplicate_state(obj, &st->base.obj);
|
|
|
|
return &st->base.obj;
|
|
}
|
|
|
|
static void
|
|
komeda_scaler_atomic_destroy_state(struct drm_private_obj *obj,
|
|
struct drm_private_state *state)
|
|
{
|
|
kfree(to_scaler_st(priv_to_comp_st(state)));
|
|
}
|
|
|
|
static const struct drm_private_state_funcs komeda_scaler_obj_funcs = {
|
|
.atomic_duplicate_state = komeda_scaler_atomic_duplicate_state,
|
|
.atomic_destroy_state = komeda_scaler_atomic_destroy_state,
|
|
};
|
|
|
|
static int komeda_scaler_obj_add(struct komeda_kms_dev *kms,
|
|
struct komeda_scaler *scaler)
|
|
{
|
|
struct komeda_scaler_state *st;
|
|
|
|
st = kzalloc_obj(*st);
|
|
if (!st)
|
|
return -ENOMEM;
|
|
|
|
st->base.component = &scaler->base;
|
|
drm_atomic_private_obj_init(&kms->base,
|
|
&scaler->base.obj, &st->base.obj,
|
|
&komeda_scaler_obj_funcs);
|
|
return 0;
|
|
}
|
|
|
|
static struct drm_private_state *
|
|
komeda_compiz_atomic_duplicate_state(struct drm_private_obj *obj)
|
|
{
|
|
struct komeda_compiz_state *st;
|
|
|
|
st = kmemdup(obj->state, sizeof(*st), GFP_KERNEL);
|
|
if (!st)
|
|
return NULL;
|
|
|
|
komeda_component_state_reset(&st->base);
|
|
__drm_atomic_helper_private_obj_duplicate_state(obj, &st->base.obj);
|
|
|
|
return &st->base.obj;
|
|
}
|
|
|
|
static void
|
|
komeda_compiz_atomic_destroy_state(struct drm_private_obj *obj,
|
|
struct drm_private_state *state)
|
|
{
|
|
kfree(to_compiz_st(priv_to_comp_st(state)));
|
|
}
|
|
|
|
static const struct drm_private_state_funcs komeda_compiz_obj_funcs = {
|
|
.atomic_duplicate_state = komeda_compiz_atomic_duplicate_state,
|
|
.atomic_destroy_state = komeda_compiz_atomic_destroy_state,
|
|
};
|
|
|
|
static int komeda_compiz_obj_add(struct komeda_kms_dev *kms,
|
|
struct komeda_compiz *compiz)
|
|
{
|
|
struct komeda_compiz_state *st;
|
|
|
|
st = kzalloc_obj(*st);
|
|
if (!st)
|
|
return -ENOMEM;
|
|
|
|
st->base.component = &compiz->base;
|
|
drm_atomic_private_obj_init(&kms->base, &compiz->base.obj, &st->base.obj,
|
|
&komeda_compiz_obj_funcs);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct drm_private_state *
|
|
komeda_splitter_atomic_duplicate_state(struct drm_private_obj *obj)
|
|
{
|
|
struct komeda_splitter_state *st;
|
|
|
|
st = kmemdup(obj->state, sizeof(*st), GFP_KERNEL);
|
|
if (!st)
|
|
return NULL;
|
|
|
|
komeda_component_state_reset(&st->base);
|
|
__drm_atomic_helper_private_obj_duplicate_state(obj, &st->base.obj);
|
|
|
|
return &st->base.obj;
|
|
}
|
|
|
|
static void
|
|
komeda_splitter_atomic_destroy_state(struct drm_private_obj *obj,
|
|
struct drm_private_state *state)
|
|
{
|
|
kfree(to_splitter_st(priv_to_comp_st(state)));
|
|
}
|
|
|
|
static const struct drm_private_state_funcs komeda_splitter_obj_funcs = {
|
|
.atomic_duplicate_state = komeda_splitter_atomic_duplicate_state,
|
|
.atomic_destroy_state = komeda_splitter_atomic_destroy_state,
|
|
};
|
|
|
|
static int komeda_splitter_obj_add(struct komeda_kms_dev *kms,
|
|
struct komeda_splitter *splitter)
|
|
{
|
|
struct komeda_splitter_state *st;
|
|
|
|
st = kzalloc_obj(*st);
|
|
if (!st)
|
|
return -ENOMEM;
|
|
|
|
st->base.component = &splitter->base;
|
|
drm_atomic_private_obj_init(&kms->base,
|
|
&splitter->base.obj, &st->base.obj,
|
|
&komeda_splitter_obj_funcs);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct drm_private_state *
|
|
komeda_merger_atomic_duplicate_state(struct drm_private_obj *obj)
|
|
{
|
|
struct komeda_merger_state *st;
|
|
|
|
st = kmemdup(obj->state, sizeof(*st), GFP_KERNEL);
|
|
if (!st)
|
|
return NULL;
|
|
|
|
komeda_component_state_reset(&st->base);
|
|
__drm_atomic_helper_private_obj_duplicate_state(obj, &st->base.obj);
|
|
|
|
return &st->base.obj;
|
|
}
|
|
|
|
static void komeda_merger_atomic_destroy_state(struct drm_private_obj *obj,
|
|
struct drm_private_state *state)
|
|
{
|
|
kfree(to_merger_st(priv_to_comp_st(state)));
|
|
}
|
|
|
|
static const struct drm_private_state_funcs komeda_merger_obj_funcs = {
|
|
.atomic_duplicate_state = komeda_merger_atomic_duplicate_state,
|
|
.atomic_destroy_state = komeda_merger_atomic_destroy_state,
|
|
};
|
|
|
|
static int komeda_merger_obj_add(struct komeda_kms_dev *kms,
|
|
struct komeda_merger *merger)
|
|
{
|
|
struct komeda_merger_state *st;
|
|
|
|
st = kzalloc_obj(*st);
|
|
if (!st)
|
|
return -ENOMEM;
|
|
|
|
st->base.component = &merger->base;
|
|
drm_atomic_private_obj_init(&kms->base,
|
|
&merger->base.obj, &st->base.obj,
|
|
&komeda_merger_obj_funcs);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct drm_private_state *
|
|
komeda_improc_atomic_duplicate_state(struct drm_private_obj *obj)
|
|
{
|
|
struct komeda_improc_state *st;
|
|
|
|
st = kmemdup(obj->state, sizeof(*st), GFP_KERNEL);
|
|
if (!st)
|
|
return NULL;
|
|
|
|
komeda_component_state_reset(&st->base);
|
|
__drm_atomic_helper_private_obj_duplicate_state(obj, &st->base.obj);
|
|
|
|
return &st->base.obj;
|
|
}
|
|
|
|
static void
|
|
komeda_improc_atomic_destroy_state(struct drm_private_obj *obj,
|
|
struct drm_private_state *state)
|
|
{
|
|
kfree(to_improc_st(priv_to_comp_st(state)));
|
|
}
|
|
|
|
static const struct drm_private_state_funcs komeda_improc_obj_funcs = {
|
|
.atomic_duplicate_state = komeda_improc_atomic_duplicate_state,
|
|
.atomic_destroy_state = komeda_improc_atomic_destroy_state,
|
|
};
|
|
|
|
static int komeda_improc_obj_add(struct komeda_kms_dev *kms,
|
|
struct komeda_improc *improc)
|
|
{
|
|
struct komeda_improc_state *st;
|
|
|
|
st = kzalloc_obj(*st);
|
|
if (!st)
|
|
return -ENOMEM;
|
|
|
|
st->base.component = &improc->base;
|
|
drm_atomic_private_obj_init(&kms->base, &improc->base.obj, &st->base.obj,
|
|
&komeda_improc_obj_funcs);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct drm_private_state *
|
|
komeda_timing_ctrlr_atomic_duplicate_state(struct drm_private_obj *obj)
|
|
{
|
|
struct komeda_timing_ctrlr_state *st;
|
|
|
|
st = kmemdup(obj->state, sizeof(*st), GFP_KERNEL);
|
|
if (!st)
|
|
return NULL;
|
|
|
|
komeda_component_state_reset(&st->base);
|
|
__drm_atomic_helper_private_obj_duplicate_state(obj, &st->base.obj);
|
|
|
|
return &st->base.obj;
|
|
}
|
|
|
|
static void
|
|
komeda_timing_ctrlr_atomic_destroy_state(struct drm_private_obj *obj,
|
|
struct drm_private_state *state)
|
|
{
|
|
kfree(to_ctrlr_st(priv_to_comp_st(state)));
|
|
}
|
|
|
|
static const struct drm_private_state_funcs komeda_timing_ctrlr_obj_funcs = {
|
|
.atomic_duplicate_state = komeda_timing_ctrlr_atomic_duplicate_state,
|
|
.atomic_destroy_state = komeda_timing_ctrlr_atomic_destroy_state,
|
|
};
|
|
|
|
static int komeda_timing_ctrlr_obj_add(struct komeda_kms_dev *kms,
|
|
struct komeda_timing_ctrlr *ctrlr)
|
|
{
|
|
struct komeda_compiz_state *st;
|
|
|
|
st = kzalloc_obj(*st);
|
|
if (!st)
|
|
return -ENOMEM;
|
|
|
|
st->base.component = &ctrlr->base;
|
|
drm_atomic_private_obj_init(&kms->base, &ctrlr->base.obj, &st->base.obj,
|
|
&komeda_timing_ctrlr_obj_funcs);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct drm_private_state *
|
|
komeda_pipeline_atomic_duplicate_state(struct drm_private_obj *obj)
|
|
{
|
|
struct komeda_pipeline_state *st;
|
|
|
|
st = kmemdup(obj->state, sizeof(*st), GFP_KERNEL);
|
|
if (!st)
|
|
return NULL;
|
|
|
|
st->active_comps = 0;
|
|
|
|
__drm_atomic_helper_private_obj_duplicate_state(obj, &st->obj);
|
|
|
|
return &st->obj;
|
|
}
|
|
|
|
static void
|
|
komeda_pipeline_atomic_destroy_state(struct drm_private_obj *obj,
|
|
struct drm_private_state *state)
|
|
{
|
|
kfree(priv_to_pipe_st(state));
|
|
}
|
|
|
|
static const struct drm_private_state_funcs komeda_pipeline_obj_funcs = {
|
|
.atomic_duplicate_state = komeda_pipeline_atomic_duplicate_state,
|
|
.atomic_destroy_state = komeda_pipeline_atomic_destroy_state,
|
|
};
|
|
|
|
static int komeda_pipeline_obj_add(struct komeda_kms_dev *kms,
|
|
struct komeda_pipeline *pipe)
|
|
{
|
|
struct komeda_pipeline_state *st;
|
|
|
|
st = kzalloc_obj(*st);
|
|
if (!st)
|
|
return -ENOMEM;
|
|
|
|
st->pipe = pipe;
|
|
drm_atomic_private_obj_init(&kms->base, &pipe->obj, &st->obj,
|
|
&komeda_pipeline_obj_funcs);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int komeda_kms_add_private_objs(struct komeda_kms_dev *kms,
|
|
struct komeda_dev *mdev)
|
|
{
|
|
struct komeda_pipeline *pipe;
|
|
int i, j, err;
|
|
|
|
for (i = 0; i < mdev->n_pipelines; i++) {
|
|
pipe = mdev->pipelines[i];
|
|
|
|
err = komeda_pipeline_obj_add(kms, pipe);
|
|
if (err)
|
|
return err;
|
|
|
|
for (j = 0; j < pipe->n_layers; j++) {
|
|
err = komeda_layer_obj_add(kms, pipe->layers[j]);
|
|
if (err)
|
|
return err;
|
|
}
|
|
|
|
if (pipe->wb_layer) {
|
|
err = komeda_layer_obj_add(kms, pipe->wb_layer);
|
|
if (err)
|
|
return err;
|
|
}
|
|
|
|
for (j = 0; j < pipe->n_scalers; j++) {
|
|
err = komeda_scaler_obj_add(kms, pipe->scalers[j]);
|
|
if (err)
|
|
return err;
|
|
}
|
|
|
|
err = komeda_compiz_obj_add(kms, pipe->compiz);
|
|
if (err)
|
|
return err;
|
|
|
|
if (pipe->splitter) {
|
|
err = komeda_splitter_obj_add(kms, pipe->splitter);
|
|
if (err)
|
|
return err;
|
|
}
|
|
|
|
if (pipe->merger) {
|
|
err = komeda_merger_obj_add(kms, pipe->merger);
|
|
if (err)
|
|
return err;
|
|
}
|
|
|
|
err = komeda_improc_obj_add(kms, pipe->improc);
|
|
if (err)
|
|
return err;
|
|
|
|
err = komeda_timing_ctrlr_obj_add(kms, pipe->ctrlr);
|
|
if (err)
|
|
return err;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void komeda_kms_cleanup_private_objs(struct komeda_kms_dev *kms)
|
|
{
|
|
struct drm_mode_config *config = &kms->base.mode_config;
|
|
struct drm_private_obj *obj, *next;
|
|
|
|
list_for_each_entry_safe(obj, next, &config->privobj_list, head)
|
|
drm_atomic_private_obj_fini(obj);
|
|
}
|