UbiquitousOS
/
OpenCloudOS-Kernel
mirror of https://gitee.com/OpenCloudOS/OpenCloudOS-Kernel.git
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

drm/sti: rename files and functions 

replace all "sti_drm_" occurences by "sti_"

Signed-off-by: Vincent Abriou <vincent.abriou@st.com>
Reviewed-by: Benjamin Gaignard <benjamin.gaignard@linaro.org>
This commit is contained in:
Vincent Abriou 2015-07-31 11:32:34 +02:00 committed by Benjamin Gaignard
parent 871bcdfea6
commit 9e1f05b280
16 changed files with 182 additions and 183 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
drivers/gpu/drm/sti/Makefile
View File

@ -4,8 +4,8 @@ sticompositor-y := \
sti_vid.o \
sti_cursor.o \
sti_compositor.o \
sti_drm_crtc.o \
sti_drm_plane.o
sti_crtc.o \
sti_plane.o
stihdmi-y := sti_hdmi.o \
sti_hdmi_tx3g0c55phy.o \
@ -23,4 +23,4 @@ obj-$(CONFIG_DRM_STI) = \
sticompositor.o \
sti_hqvdp.o \
stidvo.o \
sti_drm_drv.o
sti_drv.o

24
drivers/gpu/drm/sti/sti_compositor.c
View File

@ -14,11 +14,11 @@
#include <drm/drmP.h>
#include "sti_compositor.h"
#include "sti_crtc.h"
#include "sti_cursor.h"
#include "sti_drm_crtc.h"
#include "sti_drm_drv.h"
#include "sti_drm_plane.h"
#include "sti_drv.h"
#include "sti_gdp.h"
#include "sti_plane.h"
#include "sti_vid.h"
#include "sti_vtg.h"
@ -62,7 +62,7 @@ static int sti_compositor_bind(struct device *dev,
struct sti_compositor *compo = dev_get_drvdata(dev);
struct drm_device *drm_dev = data;
unsigned int i, mixer_id = 0, vid_id = 0, crtc_id = 0, plane_id = 0;
struct sti_drm_private *dev_priv = drm_dev->dev_private;
struct sti_private *dev_priv = drm_dev->dev_private;
struct drm_plane *cursor = NULL;
struct drm_plane *primary = NULL;
struct sti_compositor_subdev_descriptor *desc = compo->data.subdev_desc;
@ -116,8 +116,8 @@ static int sti_compositor_bind(struct device *dev,
DRM_ERROR("Can't create CURSOR plane\n");
break;
}
cursor = sti_drm_plane_init(drm_dev, plane, 1,
DRM_PLANE_TYPE_CURSOR);
cursor = sti_plane_init(drm_dev, plane, 1,
DRM_PLANE_TYPE_CURSOR);
plane_id++;
break;
case STI_GPD_SUBDEV:
@ -127,9 +127,9 @@ static int sti_compositor_bind(struct device *dev,
DRM_ERROR("Can't create GDP plane\n");
break;
}
primary = sti_drm_plane_init(drm_dev, plane,
(1 << mixer_id) - 1,
plane_type);
primary = sti_plane_init(drm_dev, plane,
(1 << mixer_id) - 1,
plane_type);
plane_id++;
break;
default:
@ -139,8 +139,8 @@ static int sti_compositor_bind(struct device *dev,
/* The first planes are reserved for primary planes*/
if (crtc_id < mixer_id && primary) {
sti_drm_crtc_init(drm_dev, compo->mixer[crtc_id],
primary, cursor);
sti_crtc_init(drm_dev, compo->mixer[crtc_id],
primary, cursor);
crtc_id++;
cursor = NULL;
primary = NULL;
@ -196,7 +196,7 @@ static int sti_compositor_probe(struct platform_device *pdev)
return -ENOMEM;
}
compo->dev = dev;
compo->vtg_vblank_nb.notifier_call = sti_drm_crtc_vblank_cb;
compo->vtg_vblank_nb.notifier_call = sti_crtc_vblank_cb;
/* populate data structure depending on compatibility */
BUG_ON(!of_match_node(compositor_of_match, np)->data);

2
drivers/gpu/drm/sti/sti_compositor.h
View File

@ -12,8 +12,8 @@
#include <linux/clk.h>
#include <linux/kernel.h>
#include "sti_drm_plane.h"
#include "sti_mixer.h"
#include "sti_plane.h"
#define WAIT_NEXT_VSYNC_MS 50 /*ms*/

88
drivers/gpu/drm/sti/sti_drm_crtc.c → drivers/gpu/drm/sti/sti_crtc.c
View File

@ -15,16 +15,16 @@
#include <drm/drm_plane_helper.h>
#include "sti_compositor.h"
#include "sti_drm_drv.h"
#include "sti_drm_crtc.h"
#include "sti_crtc.h"
#include "sti_drv.h"
#include "sti_vtg.h"
static void sti_drm_crtc_dpms(struct drm_crtc *crtc, int mode)
static void sti_crtc_dpms(struct drm_crtc *crtc, int mode)
{
DRM_DEBUG_KMS("\n");
}
static void sti_drm_crtc_prepare(struct drm_crtc *crtc)
static void sti_crtc_prepare(struct drm_crtc *crtc)
{
struct sti_mixer *mixer = to_sti_mixer(crtc);
struct device *dev = mixer->dev;
@ -44,7 +44,7 @@ static void sti_drm_crtc_prepare(struct drm_crtc *crtc)
sti_mixer_clear_all_planes(mixer);
}
static void sti_drm_crtc_commit(struct drm_crtc *crtc)
static void sti_crtc_commit(struct drm_crtc *crtc)
{
struct sti_mixer *mixer = to_sti_mixer(crtc);
struct device *dev = mixer->dev;
@ -68,16 +68,16 @@ static void sti_drm_crtc_commit(struct drm_crtc *crtc)
drm_crtc_vblank_on(crtc);
}
static bool sti_drm_crtc_mode_fixup(struct drm_crtc *crtc,
const struct drm_display_mode *mode,
struct drm_display_mode *adjusted_mode)
static bool sti_crtc_mode_fixup(struct drm_crtc *crtc,
const struct drm_display_mode *mode,
struct drm_display_mode *adjusted_mode)
{
/* accept the provided drm_display_mode, do not fix it up */
return true;
}
static int
sti_drm_crtc_mode_set(struct drm_crtc *crtc, struct drm_display_mode *mode)
sti_crtc_mode_set(struct drm_crtc *crtc, struct drm_display_mode *mode)
{
struct sti_mixer *mixer = to_sti_mixer(crtc);
struct device *dev = mixer->dev;
@ -127,7 +127,7 @@ sti_drm_crtc_mode_set(struct drm_crtc *crtc, struct drm_display_mode *mode)
return res;
}
static void sti_drm_crtc_disable(struct drm_crtc *crtc)
static void sti_crtc_disable(struct drm_crtc *crtc)
{
struct sti_mixer *mixer = to_sti_mixer(crtc);
struct device *dev = mixer->dev;
@ -156,13 +156,13 @@ static void sti_drm_crtc_disable(struct drm_crtc *crtc)
}
static void
sti_drm_crtc_mode_set_nofb(struct drm_crtc *crtc)
sti_crtc_mode_set_nofb(struct drm_crtc *crtc)
{
sti_drm_crtc_prepare(crtc);
sti_drm_crtc_mode_set(crtc, &crtc->state->adjusted_mode);
sti_crtc_prepare(crtc);
sti_crtc_mode_set(crtc, &crtc->state->adjusted_mode);
}
static void sti_drm_crtc_atomic_begin(struct drm_crtc *crtc)
static void sti_crtc_atomic_begin(struct drm_crtc *crtc)
{
struct sti_mixer *mixer = to_sti_mixer(crtc);
@ -176,46 +176,46 @@ static void sti_drm_crtc_atomic_begin(struct drm_crtc *crtc)
}
}
static void sti_drm_crtc_atomic_flush(struct drm_crtc *crtc)
static void sti_crtc_atomic_flush(struct drm_crtc *crtc)
{
}
static struct drm_crtc_helper_funcs sti_crtc_helper_funcs = {
.dpms = sti_drm_crtc_dpms,
.prepare = sti_drm_crtc_prepare,
.commit = sti_drm_crtc_commit,
.mode_fixup = sti_drm_crtc_mode_fixup,
.dpms = sti_crtc_dpms,
.prepare = sti_crtc_prepare,
.commit = sti_crtc_commit,
.mode_fixup = sti_crtc_mode_fixup,
.mode_set = drm_helper_crtc_mode_set,
.mode_set_nofb = sti_drm_crtc_mode_set_nofb,
.mode_set_nofb = sti_crtc_mode_set_nofb,
.mode_set_base = drm_helper_crtc_mode_set_base,
.disable = sti_drm_crtc_disable,
.atomic_begin = sti_drm_crtc_atomic_begin,
.atomic_flush = sti_drm_crtc_atomic_flush,
.disable = sti_crtc_disable,
.atomic_begin = sti_crtc_atomic_begin,
.atomic_flush = sti_crtc_atomic_flush,
};
static void sti_drm_crtc_destroy(struct drm_crtc *crtc)
static void sti_crtc_destroy(struct drm_crtc *crtc)
{
DRM_DEBUG_KMS("\n");
drm_crtc_cleanup(crtc);
}
static int sti_drm_crtc_set_property(struct drm_crtc *crtc,
struct drm_property *property,
uint64_t val)
static int sti_crtc_set_property(struct drm_crtc *crtc,
struct drm_property *property,
uint64_t val)
{
DRM_DEBUG_KMS("\n");
return 0;
}
int sti_drm_crtc_vblank_cb(struct notifier_block *nb,
unsigned long event, void *data)
int sti_crtc_vblank_cb(struct notifier_block *nb,
unsigned long event, void *data)
{
struct drm_device *drm_dev;
struct sti_compositor *compo =
container_of(nb, struct sti_compositor, vtg_vblank_nb);
int *crtc = data;
unsigned long flags;
struct sti_drm_private *priv;
struct sti_private *priv;
drm_dev = compo->mixer[*crtc]->drm_crtc.dev;
priv = drm_dev->dev_private;
@ -231,7 +231,7 @@ int sti_drm_crtc_vblank_cb(struct notifier_block *nb,
spin_lock_irqsave(&drm_dev->event_lock, flags);
if (compo->mixer[*crtc]->pending_event) {
drm_send_vblank_event(drm_dev, -1,
compo->mixer[*crtc]->pending_event);
compo->mixer[*crtc]->pending_event);
drm_vblank_put(drm_dev, *crtc);
compo->mixer[*crtc]->pending_event = NULL;
}
@ -240,9 +240,9 @@ int sti_drm_crtc_vblank_cb(struct notifier_block *nb,
return 0;
}
int sti_drm_crtc_enable_vblank(struct drm_device *dev, int crtc)
int sti_crtc_enable_vblank(struct drm_device *dev, int crtc)
{
struct sti_drm_private *dev_priv = dev->dev_private;
struct sti_private *dev_priv = dev->dev_private;
struct sti_compositor *compo = dev_priv->compo;
struct notifier_block *vtg_vblank_nb = &compo->vtg_vblank_nb;
@ -257,11 +257,11 @@ int sti_drm_crtc_enable_vblank(struct drm_device *dev, int crtc)
return 0;
}
EXPORT_SYMBOL(sti_drm_crtc_enable_vblank);
EXPORT_SYMBOL(sti_crtc_enable_vblank);
void sti_drm_crtc_disable_vblank(struct drm_device *dev, int crtc)
void sti_crtc_disable_vblank(struct drm_device *dev, int crtc)
{
struct sti_drm_private *priv = dev->dev_private;
struct sti_private *priv = dev->dev_private;
struct sti_compositor *compo = priv->compo;
struct notifier_block *vtg_vblank_nb = &compo->vtg_vblank_nb;
@ -277,19 +277,19 @@ void sti_drm_crtc_disable_vblank(struct drm_device *dev, int crtc)
compo->mixer[crtc]->pending_event = NULL;
}
}
EXPORT_SYMBOL(sti_drm_crtc_disable_vblank);
EXPORT_SYMBOL(sti_crtc_disable_vblank);
static struct drm_crtc_funcs sti_crtc_funcs = {
.set_config = drm_atomic_helper_set_config,
.page_flip = drm_atomic_helper_page_flip,
.destroy = sti_drm_crtc_destroy,
.set_property = sti_drm_crtc_set_property,
.destroy = sti_crtc_destroy,
.set_property = sti_crtc_set_property,
.reset = drm_atomic_helper_crtc_reset,
.atomic_duplicate_state = drm_atomic_helper_crtc_duplicate_state,
.atomic_destroy_state = drm_atomic_helper_crtc_destroy_state,
};
bool sti_drm_crtc_is_main(struct drm_crtc *crtc)
bool sti_crtc_is_main(struct drm_crtc *crtc)
{
struct sti_mixer *mixer = to_sti_mixer(crtc);
@ -298,16 +298,16 @@ bool sti_drm_crtc_is_main(struct drm_crtc *crtc)
return false;
}
EXPORT_SYMBOL(sti_drm_crtc_is_main);
EXPORT_SYMBOL(sti_crtc_is_main);
int sti_drm_crtc_init(struct drm_device *drm_dev, struct sti_mixer *mixer,
struct drm_plane *primary, struct drm_plane *cursor)
int sti_crtc_init(struct drm_device *drm_dev, struct sti_mixer *mixer,
struct drm_plane *primary, struct drm_plane *cursor)
{
struct drm_crtc *crtc = &mixer->drm_crtc;
int res;
res = drm_crtc_init_with_planes(drm_dev, crtc, primary, cursor,
&sti_crtc_funcs);
&sti_crtc_funcs);
if (res) {
DRM_ERROR("Can't initialze CRTC\n");
return -EINVAL;

22
drivers/gpu/drm/sti/sti_crtc.h Normal file
View File

@ -0,0 +1,22 @@
/*
* Copyright (C) STMicroelectronics SA 2014
* Author: Benjamin Gaignard <benjamin.gaignard@st.com> for STMicroelectronics.
* License terms: GNU General Public License (GPL), version 2
*/
#ifndef _STI_CRTC_H_
#define _STI_CRTC_H_
#include <drm/drmP.h>
struct sti_mixer;
int sti_crtc_init(struct drm_device *drm_dev, struct sti_mixer *mixer,
struct drm_plane *primary, struct drm_plane *cursor);
int sti_crtc_enable_vblank(struct drm_device *dev, int crtc);
void sti_crtc_disable_vblank(struct drm_device *dev, int crtc);
int sti_crtc_vblank_cb(struct notifier_block *nb,
unsigned long event, void *data);
bool sti_crtc_is_main(struct drm_crtc *drm_crtc);
#endif

2
drivers/gpu/drm/sti/sti_cursor.c
View File

@ -8,7 +8,7 @@
#include <drm/drmP.h>
#include "sti_cursor.h"
#include "sti_drm_plane.h"
#include "sti_plane.h"
#include "sti_vtg.h"
/* Registers */

22
drivers/gpu/drm/sti/sti_drm_crtc.h
View File

@ -1,22 +0,0 @@
/*
* Copyright (C) STMicroelectronics SA 2014
* Author: Benjamin Gaignard <benjamin.gaignard@st.com> for STMicroelectronics.
* License terms: GNU General Public License (GPL), version 2
*/
#ifndef _STI_DRM_CRTC_H_
#define _STI_DRM_CRTC_H_
#include <drm/drmP.h>
struct sti_mixer;
int sti_drm_crtc_init(struct drm_device *drm_dev, struct sti_mixer *mixer,
struct drm_plane *primary, struct drm_plane *cursor);
int sti_drm_crtc_enable_vblank(struct drm_device *dev, int crtc);
void sti_drm_crtc_disable_vblank(struct drm_device *dev, int crtc);
int sti_drm_crtc_vblank_cb(struct notifier_block *nb,
unsigned long event, void *data);
bool sti_drm_crtc_is_main(struct drm_crtc *drm_crtc);
#endif

106
drivers/gpu/drm/sti/sti_drm_drv.c → drivers/gpu/drm/sti/sti_drv.c
View File

@ -18,8 +18,8 @@
#include <drm/drm_gem_cma_helper.h>
#include <drm/drm_fb_cma_helper.h>
#include "sti_drm_drv.h"
#include "sti_drm_crtc.h"
#include "sti_crtc.h"
#include "sti_drv.h"
#define DRIVER_NAME "sti"
#define DRIVER_DESC "STMicroelectronics SoC DRM"
@ -30,15 +30,15 @@
#define STI_MAX_FB_HEIGHT 4096
#define STI_MAX_FB_WIDTH 4096
static void sti_drm_atomic_schedule(struct sti_drm_private *private,
struct drm_atomic_state *state)
static void sti_atomic_schedule(struct sti_private *private,
struct drm_atomic_state *state)
{
private->commit.state = state;
schedule_work(&private->commit.work);
}
static void sti_drm_atomic_complete(struct sti_drm_private *private,
struct drm_atomic_state *state)
static void sti_atomic_complete(struct sti_private *private,
struct drm_atomic_state *state)
{
struct drm_device *drm = private->drm_dev;
@ -68,18 +68,18 @@ static void sti_drm_atomic_complete(struct sti_drm_private *private,
drm_atomic_state_free(state);
}
static void sti_drm_atomic_work(struct work_struct *work)
static void sti_atomic_work(struct work_struct *work)
{
struct sti_drm_private *private = container_of(work,
struct sti_drm_private, commit.work);
struct sti_private *private = container_of(work,
struct sti_private, commit.work);
sti_drm_atomic_complete(private, private->commit.state);
sti_atomic_complete(private, private->commit.state);
}
static int sti_drm_atomic_commit(struct drm_device *drm,
struct drm_atomic_state *state, bool async)
static int sti_atomic_commit(struct drm_device *drm,
struct drm_atomic_state *state, bool async)
{
struct sti_drm_private *private = drm->dev_private;
struct sti_private *private = drm->dev_private;
int err;
err = drm_atomic_helper_prepare_planes(drm, state);
@ -99,21 +99,21 @@ static int sti_drm_atomic_commit(struct drm_device *drm,
drm_atomic_helper_swap_state(drm, state);
if (async)
sti_drm_atomic_schedule(private, state);
sti_atomic_schedule(private, state);
else
sti_drm_atomic_complete(private, state);
sti_atomic_complete(private, state);
mutex_unlock(&private->commit.lock);
return 0;
}
static struct drm_mode_config_funcs sti_drm_mode_config_funcs = {
static struct drm_mode_config_funcs sti_mode_config_funcs = {
.fb_create = drm_fb_cma_create,
.atomic_check = drm_atomic_helper_check,
.atomic_commit = sti_drm_atomic_commit,
.atomic_commit = sti_atomic_commit,
};
static void sti_drm_mode_config_init(struct drm_device *dev)
static void sti_mode_config_init(struct drm_device *dev)
{
dev->mode_config.min_width = 0;
dev->mode_config.min_height = 0;
@ -126,15 +126,15 @@ static void sti_drm_mode_config_init(struct drm_device *dev)
dev->mode_config.max_width = STI_MAX_FB_HEIGHT;
dev->mode_config.max_height = STI_MAX_FB_WIDTH;
dev->mode_config.funcs = &sti_drm_mode_config_funcs;
dev->mode_config.funcs = &sti_mode_config_funcs;
}
static int sti_drm_load(struct drm_device *dev, unsigned long flags)
static int sti_load(struct drm_device *dev, unsigned long flags)
{
struct sti_drm_private *private;
struct sti_private *private;
int ret;
private = kzalloc(sizeof(struct sti_drm_private), GFP_KERNEL);
private = kzalloc(sizeof(*private), GFP_KERNEL);
if (!private) {
DRM_ERROR("Failed to allocate private\n");
return -ENOMEM;
@ -143,12 +143,12 @@ static int sti_drm_load(struct drm_device *dev, unsigned long flags)
private->drm_dev = dev;
mutex_init(&private->commit.lock);
INIT_WORK(&private->commit.work, sti_drm_atomic_work);
INIT_WORK(&private->commit.work, sti_atomic_work);
drm_mode_config_init(dev);
drm_kms_helper_poll_init(dev);
sti_drm_mode_config_init(dev);
sti_mode_config_init(dev);
ret = component_bind_all(dev->dev, dev);
if (ret) {
@ -162,13 +162,13 @@ static int sti_drm_load(struct drm_device *dev, unsigned long flags)
#ifdef CONFIG_DRM_STI_FBDEV
drm_fbdev_cma_init(dev, 32,
dev->mode_config.num_crtc,
dev->mode_config.num_connector);
dev->mode_config.num_crtc,
dev->mode_config.num_connector);
#endif
return 0;
}
static const struct file_operations sti_drm_driver_fops = {
static const struct file_operations sti_driver_fops = {
.owner = THIS_MODULE,
.open = drm_open,
.mmap = drm_gem_cma_mmap,
@ -181,33 +181,33 @@ static const struct file_operations sti_drm_driver_fops = {
.release = drm_release,
};
static struct dma_buf *sti_drm_gem_prime_export(struct drm_device *dev,
struct drm_gem_object *obj,
int flags)
static struct dma_buf *sti_gem_prime_export(struct drm_device *dev,
struct drm_gem_object *obj,
int flags)
{
/* we want to be able to write in mmapped buffer */
flags |= O_RDWR;
return drm_gem_prime_export(dev, obj, flags);
}
static struct drm_driver sti_drm_driver = {
static struct drm_driver sti_driver = {
.driver_features = DRIVER_HAVE_IRQ | DRIVER_MODESET |
DRIVER_GEM | DRIVER_PRIME,
.load = sti_drm_load,
.load = sti_load,
.gem_free_object = drm_gem_cma_free_object,
.gem_vm_ops = &drm_gem_cma_vm_ops,
.dumb_create = drm_gem_cma_dumb_create,
.dumb_map_offset = drm_gem_cma_dumb_map_offset,
.dumb_destroy = drm_gem_dumb_destroy,
.fops = &sti_drm_driver_fops,
.fops = &sti_driver_fops,
.get_vblank_counter = drm_vblank_count,
.enable_vblank = sti_drm_crtc_enable_vblank,
.disable_vblank = sti_drm_crtc_disable_vblank,
.enable_vblank = sti_crtc_enable_vblank,
.disable_vblank = sti_crtc_disable_vblank,
.prime_handle_to_fd = drm_gem_prime_handle_to_fd,
.prime_fd_to_handle = drm_gem_prime_fd_to_handle,
.gem_prime_export = sti_drm_gem_prime_export,
.gem_prime_export = sti_gem_prime_export,
.gem_prime_import = drm_gem_prime_import,
.gem_prime_get_sg_table = drm_gem_cma_prime_get_sg_table,
.gem_prime_import_sg_table = drm_gem_cma_prime_import_sg_table,
@ -227,22 +227,22 @@ static int compare_of(struct device *dev, void *data)
return dev->of_node == data;
}
static int sti_drm_bind(struct device *dev)
static int sti_bind(struct device *dev)
{
return drm_platform_init(&sti_drm_driver, to_platform_device(dev));
return drm_platform_init(&sti_driver, to_platform_device(dev));
}
static void sti_drm_unbind(struct device *dev)
static void sti_unbind(struct device *dev)
{
drm_put_dev(dev_get_drvdata(dev));
}
static const struct component_master_ops sti_drm_ops = {
.bind = sti_drm_bind,
.unbind = sti_drm_unbind,
static const struct component_master_ops sti_ops = {
.bind = sti_bind,
.unbind = sti_unbind,
};
static int sti_drm_platform_probe(struct platform_device *pdev)
static int sti_platform_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct device_node *node = dev->of_node;
@ -261,33 +261,33 @@ static int sti_drm_platform_probe(struct platform_device *pdev)
child_np = of_get_next_available_child(node, child_np);
}
return component_master_add_with_match(dev, &sti_drm_ops, match);
return component_master_add_with_match(dev, &sti_ops, match);
}
static int sti_drm_platform_remove(struct platform_device *pdev)
static int sti_platform_remove(struct platform_device *pdev)
{
component_master_del(&pdev->dev, &sti_drm_ops);
component_master_del(&pdev->dev, &sti_ops);
of_platform_depopulate(&pdev->dev);
return 0;
}
static const struct of_device_id sti_drm_dt_ids[] = {
static const struct of_device_id sti_dt_ids[] = {
{ .compatible = "st,sti-display-subsystem", },
{ /* end node */ },
};
MODULE_DEVICE_TABLE(of, sti_drm_dt_ids);
MODULE_DEVICE_TABLE(of, sti_dt_ids);
static struct platform_driver sti_drm_platform_driver = {
.probe = sti_drm_platform_probe,
.remove = sti_drm_platform_remove,
static struct platform_driver sti_platform_driver = {
.probe = sti_platform_probe,
.remove = sti_platform_remove,
.driver = {
.name = DRIVER_NAME,
.of_match_table = sti_drm_dt_ids,
.of_match_table = sti_dt_ids,
},
};
module_platform_driver(sti_drm_platform_driver);
module_platform_driver(sti_platform_driver);
MODULE_AUTHOR("Benjamin Gaignard <benjamin.gaignard@st.com>");
MODULE_DESCRIPTION("STMicroelectronics SoC DRM driver");

6
drivers/gpu/drm/sti/sti_drm_drv.h → drivers/gpu/drm/sti/sti_drv.h
View File

@ -4,8 +4,8 @@
* License terms: GNU General Public License (GPL), version 2
*/
#ifndef _STI_DRM_DRV_H_
#define _STI_DRM_DRV_H_
#ifndef _STI_DRV_H_
#define _STI_DRV_H_
#include <drm/drmP.h>
@ -20,7 +20,7 @@ struct sti_tvout;
* @plane_zorder_property: z-order property for CRTC planes
* @drm_dev: drm device
*/
struct sti_drm_private {
struct sti_private {
struct sti_compositor *compo;
struct drm_property *plane_zorder_property;
struct drm_device *drm_dev;

2
drivers/gpu/drm/sti/sti_gdp.c
View File

@ -10,8 +10,8 @@
#include <linux/dma-mapping.h>
#include "sti_compositor.h"
#include "sti_drm_plane.h"
#include "sti_gdp.h"
#include "sti_plane.h"
#include "sti_vtg.h"
#define ALPHASWITCH BIT(6)

6
drivers/gpu/drm/sti/sti_hqvdp.c
View File

@ -13,8 +13,8 @@
#include <drm/drmP.h>
#include "sti_drm_plane.h"
#include "sti_hqvdp_lut.h"
#include "sti_plane.h"
#include "sti_vtg.h"
/* Firmware name */
@ -967,8 +967,8 @@ int sti_hqvdp_bind(struct device *dev, struct device *master, void *data)
/* Create HQVDP plane once xp70 is initialized */
plane = sti_hqvdp_create(hqvdp->dev, STI_HQVDP_0);
if (plane)
sti_drm_plane_init(hqvdp->drm_dev, plane, 1,
DRM_PLANE_TYPE_OVERLAY);
sti_plane_init(hqvdp->drm_dev, plane, 1,
DRM_PLANE_TYPE_OVERLAY);
else
DRM_ERROR("Can't create HQVDP plane\n");

2
drivers/gpu/drm/sti/sti_mixer.h
View File

@ -11,7 +11,7 @@
#include <drm/drmP.h>
#include "sti_drm_plane.h"
#include "sti_plane.h"
#define to_sti_mixer(x) container_of(x, struct sti_mixer, drm_crtc)

55
drivers/gpu/drm/sti/sti_drm_plane.c → drivers/gpu/drm/sti/sti_plane.c
View File

@ -13,8 +13,8 @@
#include <drm/drm_plane_helper.h>
#include "sti_compositor.h"
#include "sti_drm_drv.h"
#include "sti_drm_plane.h"
#include "sti_drv.h"
#include "sti_plane.h"
#include "sti_vtg.h"
/* (Background) < GDP0 < GDP1 < HQVDP0 < GDP2 < GDP3 < (ForeGround) */
@ -156,7 +156,7 @@ static int sti_plane_disable(struct sti_plane *plane)
return 0;
}
static void sti_drm_plane_destroy(struct drm_plane *drm_plane)
static void sti_plane_destroy(struct drm_plane *drm_plane)
{
DRM_DEBUG_DRIVER("\n");
@ -164,12 +164,12 @@ static void sti_drm_plane_destroy(struct drm_plane *drm_plane)
drm_plane_cleanup(drm_plane);
}
static int sti_drm_plane_set_property(struct drm_plane *drm_plane,
struct drm_property *property,
uint64_t val)
static int sti_plane_set_property(struct drm_plane *drm_plane,
struct drm_property *property,
uint64_t val)
{
struct drm_device *dev = drm_plane->dev;
struct sti_drm_private *private = dev->dev_private;
struct sti_private *private = dev->dev_private;
struct sti_plane *plane = to_sti_plane(drm_plane);
DRM_DEBUG_DRIVER("\n");
@ -182,24 +182,24 @@ static int sti_drm_plane_set_property(struct drm_plane *drm_plane,
return -EINVAL;
}
static struct drm_plane_funcs sti_drm_plane_funcs = {
static struct drm_plane_funcs sti_plane_funcs = {
.update_plane = drm_atomic_helper_update_plane,
.disable_plane = drm_atomic_helper_disable_plane,
.destroy = sti_drm_plane_destroy,
.set_property = sti_drm_plane_set_property,
.destroy = sti_plane_destroy,
.set_property = sti_plane_set_property,
.reset = drm_atomic_helper_plane_reset,
.atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state,
.atomic_destroy_state = drm_atomic_helper_plane_destroy_state,
};
static int sti_drm_plane_atomic_check(struct drm_plane *drm_plane,
struct drm_plane_state *state)
static int sti_plane_atomic_check(struct drm_plane *drm_plane,
struct drm_plane_state *state)
{
return 0;
}
static void sti_drm_plane_atomic_update(struct drm_plane *drm_plane,
struct drm_plane_state *oldstate)
static void sti_plane_atomic_update(struct drm_plane *drm_plane,
struct drm_plane_state *oldstate)
{
struct drm_plane_state *state = drm_plane->state;
struct sti_plane *plane = to_sti_plane(drm_plane);
@ -244,8 +244,8 @@ static void sti_drm_plane_atomic_update(struct drm_plane *drm_plane,
}
}
static void sti_drm_plane_atomic_disable(struct drm_plane *drm_plane,
struct drm_plane_state *oldstate)
static void sti_plane_atomic_disable(struct drm_plane *drm_plane,
struct drm_plane_state *oldstate)
{
struct sti_plane *plane = to_sti_plane(drm_plane);
struct sti_mixer *mixer = to_sti_mixer(drm_plane->crtc);
@ -279,16 +279,16 @@ static void sti_drm_plane_atomic_disable(struct drm_plane *drm_plane,
}
}
static const struct drm_plane_helper_funcs sti_drm_plane_helpers_funcs = {
.atomic_check = sti_drm_plane_atomic_check,
.atomic_update = sti_drm_plane_atomic_update,
.atomic_disable = sti_drm_plane_atomic_disable,
static const struct drm_plane_helper_funcs sti_plane_helpers_funcs = {
.atomic_check = sti_plane_atomic_check,
.atomic_update = sti_plane_atomic_update,
.atomic_disable = sti_plane_atomic_disable,
};
static void sti_drm_plane_attach_zorder_property(struct drm_plane *drm_plane)
static void sti_plane_attach_zorder_property(struct drm_plane *drm_plane)
{
struct drm_device *dev = drm_plane->dev;
struct sti_drm_private *private = dev->dev_private;
struct sti_private *private = dev->dev_private;
struct sti_plane *plane = to_sti_plane(drm_plane);
struct drm_property *prop;
@ -305,7 +305,7 @@ static void sti_drm_plane_attach_zorder_property(struct drm_plane *drm_plane)
drm_object_attach_property(&drm_plane->base, prop, plane->zorder);
}
struct drm_plane *sti_drm_plane_init(struct drm_device *dev,
struct drm_plane *sti_plane_init(struct drm_device *dev,
struct sti_plane *plane,
unsigned int possible_crtcs,
enum drm_plane_type type)
@ -314,7 +314,7 @@ struct drm_plane *sti_drm_plane_init(struct drm_device *dev,
err = drm_universal_plane_init(dev, &plane->drm_plane,
possible_crtcs,
&sti_drm_plane_funcs,
&sti_plane_funcs,
plane->ops->get_formats(plane),
plane->ops->get_nb_formats(plane),
type);
@ -323,8 +323,7 @@ struct drm_plane *sti_drm_plane_init(struct drm_device *dev,
return NULL;
}
drm_plane_helper_add(&plane->drm_plane,
&sti_drm_plane_helpers_funcs);
drm_plane_helper_add(&plane->drm_plane, &sti_plane_helpers_funcs);
for (i = 0; i < ARRAY_SIZE(sti_plane_default_zorder); i++)
if (sti_plane_default_zorder[i] == plane->desc)
@ -333,7 +332,7 @@ struct drm_plane *sti_drm_plane_init(struct drm_device *dev,
plane->zorder = i + 1;
if (type == DRM_PLANE_TYPE_OVERLAY)
sti_drm_plane_attach_zorder_property(&plane->drm_plane);
sti_plane_attach_zorder_property(&plane->drm_plane);
DRM_DEBUG_DRIVER("drm plane:%d mapped to %s with zorder:%d\n",
plane->drm_plane.base.id,
@ -341,4 +340,4 @@ struct drm_plane *sti_drm_plane_init(struct drm_device *dev,
return &plane->drm_plane;
}
EXPORT_SYMBOL(sti_drm_plane_init);
EXPORT_SYMBOL(sti_plane_init);

12
drivers/gpu/drm/sti/sti_drm_plane.h → drivers/gpu/drm/sti/sti_plane.h
View File

@ -4,8 +4,8 @@
* License terms: GNU General Public License (GPL), version 2
*/
#ifndef _STI_DRM_PLANE_H_
#define _STI_DRM_PLANE_H_
#ifndef _STI_PLANE_H_
#define _STI_PLANE_H_
#include <drm/drmP.h>
@ -96,10 +96,10 @@ struct sti_plane_funcs {
int (*disable)(struct sti_plane *plane);
};
struct drm_plane *sti_drm_plane_init(struct drm_device *dev,
struct sti_plane *sti_plane,
unsigned int possible_crtcs,
enum drm_plane_type type);
struct drm_plane *sti_plane_init(struct drm_device *dev,
struct sti_plane *sti_plane,
unsigned int possible_crtcs,
enum drm_plane_type type);
const char *sti_plane_to_str(struct sti_plane *plane);
#endif

8
drivers/gpu/drm/sti/sti_tvout.c
View File

@ -16,7 +16,7 @@
#include <drm/drmP.h>
#include <drm/drm_crtc_helper.h>
#include "sti_drm_crtc.h"
#include "sti_crtc.h"
/* glue registers */
#define TVO_CSC_MAIN_M0 0x000
@ -473,7 +473,7 @@ static void sti_dvo_encoder_commit(struct drm_encoder *encoder)
{
struct sti_tvout *tvout = to_sti_tvout(encoder);
tvout_dvo_start(tvout, sti_drm_crtc_is_main(encoder->crtc));
tvout_dvo_start(tvout, sti_crtc_is_main(encoder->crtc));
}
static void sti_dvo_encoder_disable(struct drm_encoder *encoder)
@ -523,7 +523,7 @@ static void sti_hda_encoder_commit(struct drm_encoder *encoder)
{
struct sti_tvout *tvout = to_sti_tvout(encoder);
tvout_hda_start(tvout, sti_drm_crtc_is_main(encoder->crtc));
tvout_hda_start(tvout, sti_crtc_is_main(encoder->crtc));
}
static void sti_hda_encoder_disable(struct drm_encoder *encoder)
@ -575,7 +575,7 @@ static void sti_hdmi_encoder_commit(struct drm_encoder *encoder)
{
struct sti_tvout *tvout = to_sti_tvout(encoder);
tvout_hdmi_start(tvout, sti_drm_crtc_is_main(encoder->crtc));
tvout_hdmi_start(tvout, sti_crtc_is_main(encoder->crtc));
}
static void sti_hdmi_encoder_disable(struct drm_encoder *encoder)

2
drivers/gpu/drm/sti/sti_vid.c
View File

@ -6,7 +6,7 @@
#include <drm/drmP.h>
#include "sti_drm_plane.h"
#include "sti_plane.h"
#include "sti_vid.h"
#include "sti_vtg.h"