drm/sti: rename files and functions
authorVincent Abriou <vincent.abriou@st.com>
Fri, 31 Jul 2015 09:32:34 +0000 (11:32 +0200)
committerBenjamin Gaignard <benjamin.gaignard@linaro.org>
Mon, 3 Aug 2015 12:25:06 +0000 (14:25 +0200)
replace all "sti_drm_" occurences by "sti_"

Signed-off-by: Vincent Abriou <vincent.abriou@st.com>
Reviewed-by: Benjamin Gaignard <benjamin.gaignard@linaro.org>
16 files changed:
drivers/gpu/drm/sti/Makefile
drivers/gpu/drm/sti/sti_compositor.c
drivers/gpu/drm/sti/sti_compositor.h
drivers/gpu/drm/sti/sti_crtc.c [moved from drivers/gpu/drm/sti/sti_drm_crtc.c with 75% similarity]
drivers/gpu/drm/sti/sti_crtc.h [new file with mode: 0644]
drivers/gpu/drm/sti/sti_cursor.c
drivers/gpu/drm/sti/sti_drm_crtc.h [deleted file]
drivers/gpu/drm/sti/sti_drv.c [moved from drivers/gpu/drm/sti/sti_drm_drv.c with 68% similarity]
drivers/gpu/drm/sti/sti_drv.h [moved from drivers/gpu/drm/sti/sti_drm_drv.h with 90% similarity]
drivers/gpu/drm/sti/sti_gdp.c
drivers/gpu/drm/sti/sti_hqvdp.c
drivers/gpu/drm/sti/sti_mixer.h
drivers/gpu/drm/sti/sti_plane.c [moved from drivers/gpu/drm/sti/sti_drm_plane.c with 83% similarity]
drivers/gpu/drm/sti/sti_plane.h [moved from drivers/gpu/drm/sti/sti_drm_plane.h with 93% similarity]
drivers/gpu/drm/sti/sti_tvout.c
drivers/gpu/drm/sti/sti_vid.c

index 505b3ba..e27490b 100644 (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
index 68c5c95..d62ed7f 100644 (file)
 #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);
index 77f9978..1a4a73d 100644 (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*/
 
similarity index 75%
rename from drivers/gpu/drm/sti/sti_drm_crtc.c
rename to drivers/gpu/drm/sti/sti_crtc.c
index a489b04..27b3ef2 100644 (file)
 #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;
diff --git a/drivers/gpu/drm/sti/sti_crtc.h b/drivers/gpu/drm/sti/sti_crtc.h
new file mode 100644 (file)
index 0000000..51963e6
--- /dev/null
@@ -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
index cd12403..2868909 100644 (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 */
diff --git a/drivers/gpu/drm/sti/sti_drm_crtc.h b/drivers/gpu/drm/sti/sti_drm_crtc.h
deleted file mode 100644 (file)
index caca8b1..0000000
+++ /dev/null
@@ -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
similarity index 68%
rename from drivers/gpu/drm/sti/sti_drm_drv.c
rename to drivers/gpu/drm/sti/sti_drv.c
index 8ad9fe6..6f4af6a 100644 (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"
 #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");
similarity index 90%
rename from drivers/gpu/drm/sti/sti_drm_drv.h
rename to drivers/gpu/drm/sti/sti_drv.h
index c413aa3..9372f69 100644 (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;
index e94d0be..e323310 100644 (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)
index 54e8c2f..b91a009 100644 (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");
 
index 9d51eac..2f69b00 100644 (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)
 
similarity index 83%
rename from drivers/gpu/drm/sti/sti_drm_plane.c
rename to drivers/gpu/drm/sti/sti_plane.c
index 0d16722..6a38521 100644 (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);
similarity index 93%
rename from drivers/gpu/drm/sti/sti_drm_plane.h
rename to drivers/gpu/drm/sti/sti_plane.h
index e547366..bd52754 100644 (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
index 576b5be..c1aac8e 100644 (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)
index b82a34f..1e7e1d7 100644 (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"