[PATCH v2 10/29] drm/sun4i: Rename DE2 registers related macros

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



In preparation to introduce DE3 support, change prefix from "SUN8I_" to
"DE2_". Current prefix suggest that it's valid only for one family,
whereas in reality, DE2 unit is used also on sun50i family.
Additionally, it will be easier to distinguish DE3 specific macros by
using "DE3_" prefix.

No functional change in this commit.

Signed-off-by: Jernej Skrabec <jernej.skrabec@xxxxxxxx>
---
 drivers/gpu/drm/sun4i/sun8i_csc.c       |   6 +-
 drivers/gpu/drm/sun4i/sun8i_csc.h       |   6 +-
 drivers/gpu/drm/sun4i/sun8i_mixer.c     | 100 ++++++++--------
 drivers/gpu/drm/sun4i/sun8i_mixer.h     | 146 ++++++++++++------------
 drivers/gpu/drm/sun4i/sun8i_ui_layer.c  |  62 +++++-----
 drivers/gpu/drm/sun4i/sun8i_ui_layer.h  |  30 ++---
 drivers/gpu/drm/sun4i/sun8i_ui_scaler.c |  38 +++---
 drivers/gpu/drm/sun4i/sun8i_ui_scaler.h |  38 +++---
 drivers/gpu/drm/sun4i/sun8i_vi_layer.c  |  62 +++++-----
 drivers/gpu/drm/sun4i/sun8i_vi_layer.h  |  20 ++--
 drivers/gpu/drm/sun4i/sun8i_vi_scaler.c |  67 ++++++-----
 drivers/gpu/drm/sun4i/sun8i_vi_scaler.h |  58 +++++-----
 12 files changed, 316 insertions(+), 317 deletions(-)

diff --git a/drivers/gpu/drm/sun4i/sun8i_csc.c b/drivers/gpu/drm/sun4i/sun8i_csc.c
index b14925b40ccf..755b60bae408 100644
--- a/drivers/gpu/drm/sun4i/sun8i_csc.c
+++ b/drivers/gpu/drm/sun4i/sun8i_csc.c
@@ -57,7 +57,7 @@ static void sun8i_csc_set_coefficients(struct regmap *map, u32 base,
 		/* For some reason, 0x200 must be added to constant parts */
 		if (((i + 1) & 3) == 0)
 			data += 0x200;
-		regmap_write(map, SUN8I_CSC_COEFF(base, i), data);
+		regmap_write(map, DE2_CSC_COEFF(base, i), data);
 	}
 }
 
@@ -66,11 +66,11 @@ static void sun8i_csc_enable(struct regmap *map, u32 base, bool enable)
 	u32 val;
 
 	if (enable)
-		val = SUN8I_CSC_CTRL_EN;
+		val = DE2_CSC_CTRL_EN;
 	else
 		val = 0;
 
-	regmap_update_bits(map, SUN8I_CSC_CTRL(base), SUN8I_CSC_CTRL_EN, val);
+	regmap_update_bits(map, DE2_CSC_CTRL(base), DE2_CSC_CTRL_EN, val);
 }
 
 void sun8i_csc_set_ccsc_coefficients(struct sun8i_mixer *mixer, int layer,
diff --git a/drivers/gpu/drm/sun4i/sun8i_csc.h b/drivers/gpu/drm/sun4i/sun8i_csc.h
index 880e8fbb0855..08ae38761280 100644
--- a/drivers/gpu/drm/sun4i/sun8i_csc.h
+++ b/drivers/gpu/drm/sun4i/sun8i_csc.h
@@ -18,10 +18,10 @@ struct sun8i_mixer;
 #define CCSC10_OFFSET 0xA0000
 #define CCSC11_OFFSET 0xF0000
 
-#define SUN8I_CSC_CTRL(base)		(base + 0x0)
-#define SUN8I_CSC_COEFF(base, i)	(base + 0x10 + 4 * i)
+#define DE2_CSC_CTRL(base)	(base + 0x0)
+#define DE2_CSC_COEFF(base, i)	(base + 0x10 + 4 * i)
 
-#define SUN8I_CSC_CTRL_EN		BIT(0)
+#define DE2_CSC_CTRL_EN		BIT(0)
 
 enum sun8i_csc_mode {
 	SUN8I_CSC_MODE_OFF,
diff --git a/drivers/gpu/drm/sun4i/sun8i_mixer.c b/drivers/gpu/drm/sun4i/sun8i_mixer.c
index 6129c350f7bd..71c0f6dc8a49 100644
--- a/drivers/gpu/drm/sun4i/sun8i_mixer.c
+++ b/drivers/gpu/drm/sun4i/sun8i_mixer.c
@@ -34,217 +34,217 @@
 static const struct de2_fmt_info de2_formats[] = {
 	{
 		.drm_fmt = DRM_FORMAT_ARGB8888,
-		.de2_fmt = SUN8I_MIXER_FBFMT_ARGB8888,
+		.de2_fmt = DE2_MIXER_FBFMT_ARGB8888,
 		.rgb = true,
 		.csc = SUN8I_CSC_MODE_OFF,
 	},
 	{
 		.drm_fmt = DRM_FORMAT_ABGR8888,
-		.de2_fmt = SUN8I_MIXER_FBFMT_ABGR8888,
+		.de2_fmt = DE2_MIXER_FBFMT_ABGR8888,
 		.rgb = true,
 		.csc = SUN8I_CSC_MODE_OFF,
 	},
 	{
 		.drm_fmt = DRM_FORMAT_RGBA8888,
-		.de2_fmt = SUN8I_MIXER_FBFMT_RGBA8888,
+		.de2_fmt = DE2_MIXER_FBFMT_RGBA8888,
 		.rgb = true,
 		.csc = SUN8I_CSC_MODE_OFF,
 	},
 	{
 		.drm_fmt = DRM_FORMAT_BGRA8888,
-		.de2_fmt = SUN8I_MIXER_FBFMT_BGRA8888,
+		.de2_fmt = DE2_MIXER_FBFMT_BGRA8888,
 		.rgb = true,
 		.csc = SUN8I_CSC_MODE_OFF,
 	},
 	{
 		.drm_fmt = DRM_FORMAT_XRGB8888,
-		.de2_fmt = SUN8I_MIXER_FBFMT_XRGB8888,
+		.de2_fmt = DE2_MIXER_FBFMT_XRGB8888,
 		.rgb = true,
 		.csc = SUN8I_CSC_MODE_OFF,
 	},
 	{
 		.drm_fmt = DRM_FORMAT_XBGR8888,
-		.de2_fmt = SUN8I_MIXER_FBFMT_XBGR8888,
+		.de2_fmt = DE2_MIXER_FBFMT_XBGR8888,
 		.rgb = true,
 		.csc = SUN8I_CSC_MODE_OFF,
 	},
 	{
 		.drm_fmt = DRM_FORMAT_RGBX8888,
-		.de2_fmt = SUN8I_MIXER_FBFMT_RGBX8888,
+		.de2_fmt = DE2_MIXER_FBFMT_RGBX8888,
 		.rgb = true,
 		.csc = SUN8I_CSC_MODE_OFF,
 	},
 	{
 		.drm_fmt = DRM_FORMAT_BGRX8888,
-		.de2_fmt = SUN8I_MIXER_FBFMT_BGRX8888,
+		.de2_fmt = DE2_MIXER_FBFMT_BGRX8888,
 		.rgb = true,
 		.csc = SUN8I_CSC_MODE_OFF,
 	},
 	{
 		.drm_fmt = DRM_FORMAT_RGB888,
-		.de2_fmt = SUN8I_MIXER_FBFMT_RGB888,
+		.de2_fmt = DE2_MIXER_FBFMT_RGB888,
 		.rgb = true,
 		.csc = SUN8I_CSC_MODE_OFF,
 	},
 	{
 		.drm_fmt = DRM_FORMAT_BGR888,
-		.de2_fmt = SUN8I_MIXER_FBFMT_BGR888,
+		.de2_fmt = DE2_MIXER_FBFMT_BGR888,
 		.rgb = true,
 		.csc = SUN8I_CSC_MODE_OFF,
 	},
 	{
 		.drm_fmt = DRM_FORMAT_RGB565,
-		.de2_fmt = SUN8I_MIXER_FBFMT_RGB565,
+		.de2_fmt = DE2_MIXER_FBFMT_RGB565,
 		.rgb = true,
 		.csc = SUN8I_CSC_MODE_OFF,
 	},
 	{
 		.drm_fmt = DRM_FORMAT_BGR565,
-		.de2_fmt = SUN8I_MIXER_FBFMT_BGR565,
+		.de2_fmt = DE2_MIXER_FBFMT_BGR565,
 		.rgb = true,
 		.csc = SUN8I_CSC_MODE_OFF,
 	},
 	{
 		.drm_fmt = DRM_FORMAT_ARGB4444,
-		.de2_fmt = SUN8I_MIXER_FBFMT_ARGB4444,
+		.de2_fmt = DE2_MIXER_FBFMT_ARGB4444,
 		.rgb = true,
 		.csc = SUN8I_CSC_MODE_OFF,
 	},
 	{
 		.drm_fmt = DRM_FORMAT_ABGR4444,
-		.de2_fmt = SUN8I_MIXER_FBFMT_ABGR4444,
+		.de2_fmt = DE2_MIXER_FBFMT_ABGR4444,
 		.rgb = true,
 		.csc = SUN8I_CSC_MODE_OFF,
 	},
 	{
 		.drm_fmt = DRM_FORMAT_RGBA4444,
-		.de2_fmt = SUN8I_MIXER_FBFMT_RGBA4444,
+		.de2_fmt = DE2_MIXER_FBFMT_RGBA4444,
 		.rgb = true,
 		.csc = SUN8I_CSC_MODE_OFF,
 	},
 	{
 		.drm_fmt = DRM_FORMAT_BGRA4444,
-		.de2_fmt = SUN8I_MIXER_FBFMT_BGRA4444,
+		.de2_fmt = DE2_MIXER_FBFMT_BGRA4444,
 		.rgb = true,
 		.csc = SUN8I_CSC_MODE_OFF,
 	},
 	{
 		.drm_fmt = DRM_FORMAT_ARGB1555,
-		.de2_fmt = SUN8I_MIXER_FBFMT_ARGB1555,
+		.de2_fmt = DE2_MIXER_FBFMT_ARGB1555,
 		.rgb = true,
 		.csc = SUN8I_CSC_MODE_OFF,
 	},
 	{
 		.drm_fmt = DRM_FORMAT_ABGR1555,
-		.de2_fmt = SUN8I_MIXER_FBFMT_ABGR1555,
+		.de2_fmt = DE2_MIXER_FBFMT_ABGR1555,
 		.rgb = true,
 		.csc = SUN8I_CSC_MODE_OFF,
 	},
 	{
 		.drm_fmt = DRM_FORMAT_RGBA5551,
-		.de2_fmt = SUN8I_MIXER_FBFMT_RGBA5551,
+		.de2_fmt = DE2_MIXER_FBFMT_RGBA5551,
 		.rgb = true,
 		.csc = SUN8I_CSC_MODE_OFF,
 	},
 	{
 		.drm_fmt = DRM_FORMAT_BGRA5551,
-		.de2_fmt = SUN8I_MIXER_FBFMT_BGRA5551,
+		.de2_fmt = DE2_MIXER_FBFMT_BGRA5551,
 		.rgb = true,
 		.csc = SUN8I_CSC_MODE_OFF,
 	},
 	{
 		.drm_fmt = DRM_FORMAT_UYVY,
-		.de2_fmt = SUN8I_MIXER_FBFMT_UYVY,
+		.de2_fmt = DE2_MIXER_FBFMT_UYVY,
 		.rgb = false,
 		.csc = SUN8I_CSC_MODE_YUV2RGB,
 	},
 	{
 		.drm_fmt = DRM_FORMAT_VYUY,
-		.de2_fmt = SUN8I_MIXER_FBFMT_VYUY,
+		.de2_fmt = DE2_MIXER_FBFMT_VYUY,
 		.rgb = false,
 		.csc = SUN8I_CSC_MODE_YUV2RGB,
 	},
 	{
 		.drm_fmt = DRM_FORMAT_YUYV,
-		.de2_fmt = SUN8I_MIXER_FBFMT_YUYV,
+		.de2_fmt = DE2_MIXER_FBFMT_YUYV,
 		.rgb = false,
 		.csc = SUN8I_CSC_MODE_YUV2RGB,
 	},
 	{
 		.drm_fmt = DRM_FORMAT_YVYU,
-		.de2_fmt = SUN8I_MIXER_FBFMT_YVYU,
+		.de2_fmt = DE2_MIXER_FBFMT_YVYU,
 		.rgb = false,
 		.csc = SUN8I_CSC_MODE_YUV2RGB,
 	},
 	{
 		.drm_fmt = DRM_FORMAT_NV16,
-		.de2_fmt = SUN8I_MIXER_FBFMT_NV16,
+		.de2_fmt = DE2_MIXER_FBFMT_NV16,
 		.rgb = false,
 		.csc = SUN8I_CSC_MODE_YUV2RGB,
 	},
 	{
 		.drm_fmt = DRM_FORMAT_NV61,
-		.de2_fmt = SUN8I_MIXER_FBFMT_NV61,
+		.de2_fmt = DE2_MIXER_FBFMT_NV61,
 		.rgb = false,
 		.csc = SUN8I_CSC_MODE_YUV2RGB,
 	},
 	{
 		.drm_fmt = DRM_FORMAT_NV12,
-		.de2_fmt = SUN8I_MIXER_FBFMT_NV12,
+		.de2_fmt = DE2_MIXER_FBFMT_NV12,
 		.rgb = false,
 		.csc = SUN8I_CSC_MODE_YUV2RGB,
 	},
 	{
 		.drm_fmt = DRM_FORMAT_NV21,
-		.de2_fmt = SUN8I_MIXER_FBFMT_NV21,
+		.de2_fmt = DE2_MIXER_FBFMT_NV21,
 		.rgb = false,
 		.csc = SUN8I_CSC_MODE_YUV2RGB,
 	},
 	{
 		.drm_fmt = DRM_FORMAT_YUV444,
-		.de2_fmt = SUN8I_MIXER_FBFMT_RGB888,
+		.de2_fmt = DE2_MIXER_FBFMT_RGB888,
 		.rgb = true,
 		.csc = SUN8I_CSC_MODE_YUV2RGB,
 	},
 	{
 		.drm_fmt = DRM_FORMAT_YUV422,
-		.de2_fmt = SUN8I_MIXER_FBFMT_YUV422,
+		.de2_fmt = DE2_MIXER_FBFMT_YUV422,
 		.rgb = false,
 		.csc = SUN8I_CSC_MODE_YUV2RGB,
 	},
 	{
 		.drm_fmt = DRM_FORMAT_YUV420,
-		.de2_fmt = SUN8I_MIXER_FBFMT_YUV420,
+		.de2_fmt = DE2_MIXER_FBFMT_YUV420,
 		.rgb = false,
 		.csc = SUN8I_CSC_MODE_YUV2RGB,
 	},
 	{
 		.drm_fmt = DRM_FORMAT_YUV411,
-		.de2_fmt = SUN8I_MIXER_FBFMT_YUV411,
+		.de2_fmt = DE2_MIXER_FBFMT_YUV411,
 		.rgb = false,
 		.csc = SUN8I_CSC_MODE_YUV2RGB,
 	},
 	{
 		.drm_fmt = DRM_FORMAT_YVU444,
-		.de2_fmt = SUN8I_MIXER_FBFMT_RGB888,
+		.de2_fmt = DE2_MIXER_FBFMT_RGB888,
 		.rgb = true,
 		.csc = SUN8I_CSC_MODE_YVU2RGB,
 	},
 	{
 		.drm_fmt = DRM_FORMAT_YVU422,
-		.de2_fmt = SUN8I_MIXER_FBFMT_YUV422,
+		.de2_fmt = DE2_MIXER_FBFMT_YUV422,
 		.rgb = false,
 		.csc = SUN8I_CSC_MODE_YVU2RGB,
 	},
 	{
 		.drm_fmt = DRM_FORMAT_YVU420,
-		.de2_fmt = SUN8I_MIXER_FBFMT_YUV420,
+		.de2_fmt = DE2_MIXER_FBFMT_YUV420,
 		.rgb = false,
 		.csc = SUN8I_CSC_MODE_YVU2RGB,
 	},
 	{
 		.drm_fmt = DRM_FORMAT_YVU411,
-		.de2_fmt = SUN8I_MIXER_FBFMT_YUV411,
+		.de2_fmt = DE2_MIXER_FBFMT_YUV411,
 		.rgb = false,
 		.csc = SUN8I_CSC_MODE_YVU2RGB,
 	},
@@ -265,8 +265,8 @@ static void sun8i_mixer_commit(struct sunxi_engine *engine)
 {
 	DRM_DEBUG_DRIVER("Committing changes\n");
 
-	regmap_write(engine->regs, SUN8I_MIXER_GLOBAL_DBUFF,
-		     SUN8I_MIXER_GLOBAL_DBUFF_ENABLE);
+	regmap_write(engine->regs, DE2_MIXER_GLOBAL_DBUFF,
+		     DE2_MIXER_GLOBAL_DBUFF_ENABLE);
 }
 
 static struct drm_plane **sun8i_layers_init(struct drm_device *drm,
@@ -464,30 +464,30 @@ static int sun8i_mixer_bind(struct device *dev, struct device *master,
 		regmap_write(mixer->engine.regs, i, 0);
 
 	/* Enable the mixer */
-	regmap_write(mixer->engine.regs, SUN8I_MIXER_GLOBAL_CTL,
-		     SUN8I_MIXER_GLOBAL_CTL_RT_EN);
+	regmap_write(mixer->engine.regs, DE2_MIXER_GLOBAL_CTL,
+		     DE2_MIXER_GLOBAL_CTL_RT_EN);
 
 	/* Set background color to black */
-	regmap_write(mixer->engine.regs, SUN8I_MIXER_BLEND_BKCOLOR(base),
-		     SUN8I_MIXER_BLEND_COLOR_BLACK);
+	regmap_write(mixer->engine.regs, DE2_MIXER_BLEND_BKCOLOR(base),
+		     DE2_MIXER_BLEND_COLOR_BLACK);
 
 	/*
 	 * Set fill color of bottom plane to black. Generally not needed
 	 * except when VI plane is at bottom (zpos = 0) and enabled.
 	 */
-	regmap_write(mixer->engine.regs, SUN8I_MIXER_BLEND_PIPE_CTL(base),
-		     SUN8I_MIXER_BLEND_PIPE_CTL_FC_EN(0));
-	regmap_write(mixer->engine.regs, SUN8I_MIXER_BLEND_ATTR_FCOLOR(base, 0),
-		     SUN8I_MIXER_BLEND_COLOR_BLACK);
+	regmap_write(mixer->engine.regs, DE2_MIXER_BLEND_PIPE_CTL(base),
+		     DE2_MIXER_BLEND_PIPE_CTL_FC_EN(0));
+	regmap_write(mixer->engine.regs, DE2_MIXER_BLEND_ATTR_FCOLOR(base, 0),
+		     DE2_MIXER_BLEND_COLOR_BLACK);
 
 	plane_cnt = mixer->cfg->vi_num + mixer->cfg->ui_num;
 	for (i = 0; i < plane_cnt; i++)
 		regmap_write(mixer->engine.regs,
-			     SUN8I_MIXER_BLEND_MODE(base, i),
-			     SUN8I_MIXER_BLEND_MODE_DEF);
+			     DE2_MIXER_BLEND_MODE(base, i),
+			     DE2_MIXER_BLEND_MODE_DEF);
 
-	regmap_update_bits(mixer->engine.regs, SUN8I_MIXER_BLEND_PIPE_CTL(base),
-			   SUN8I_MIXER_BLEND_PIPE_CTL_EN_MSK, 0);
+	regmap_update_bits(mixer->engine.regs, DE2_MIXER_BLEND_PIPE_CTL(base),
+			   DE2_MIXER_BLEND_PIPE_CTL_EN_MSK, 0);
 
 	return 0;
 
diff --git a/drivers/gpu/drm/sun4i/sun8i_mixer.h b/drivers/gpu/drm/sun4i/sun8i_mixer.h
index 025550a1f539..208e8219d2be 100644
--- a/drivers/gpu/drm/sun4i/sun8i_mixer.h
+++ b/drivers/gpu/drm/sun4i/sun8i_mixer.h
@@ -17,98 +17,98 @@
 #include "sun8i_csc.h"
 #include "sunxi_engine.h"
 
-#define SUN8I_MIXER_SIZE(w, h)			(((h) - 1) << 16 | ((w) - 1))
-#define SUN8I_MIXER_COORD(x, y)			((y) << 16 | (x))
+#define DE2_MIXER_SIZE(w, h)			(((h) - 1) << 16 | ((w) - 1))
+#define DE2_MIXER_COORD(x, y)			((y) << 16 | (x))
 
-#define SUN8I_MIXER_GLOBAL_CTL			0x0
-#define SUN8I_MIXER_GLOBAL_STATUS		0x4
-#define SUN8I_MIXER_GLOBAL_DBUFF		0x8
-#define SUN8I_MIXER_GLOBAL_SIZE			0xc
+#define DE2_MIXER_GLOBAL_CTL			0x0
+#define DE2_MIXER_GLOBAL_STATUS			0x4
+#define DE2_MIXER_GLOBAL_DBUFF			0x8
+#define DE2_MIXER_GLOBAL_SIZE			0xc
 
-#define SUN8I_MIXER_GLOBAL_CTL_RT_EN		BIT(0)
+#define DE2_MIXER_GLOBAL_CTL_RT_EN		BIT(0)
 
-#define SUN8I_MIXER_GLOBAL_DBUFF_ENABLE		BIT(0)
+#define DE2_MIXER_GLOBAL_DBUFF_ENABLE		BIT(0)
 
 #define DE2_BLD_BASE				0x1000
 #define DE2_CH_BASE				0x2000
 #define DE2_CH_SIZE				0x1000
 
-#define SUN8I_MIXER_BLEND_PIPE_CTL(base)	((base) + 0)
-#define SUN8I_MIXER_BLEND_ATTR_FCOLOR(base, x)	((base) + 0x4 + 0x10 * (x))
-#define SUN8I_MIXER_BLEND_ATTR_INSIZE(base, x)	((base) + 0x8 + 0x10 * (x))
-#define SUN8I_MIXER_BLEND_ATTR_COORD(base, x)	((base) + 0xc + 0x10 * (x))
-#define SUN8I_MIXER_BLEND_ROUTE(base)		((base) + 0x80)
-#define SUN8I_MIXER_BLEND_PREMULTIPLY(base)	((base) + 0x84)
-#define SUN8I_MIXER_BLEND_BKCOLOR(base)		((base) + 0x88)
-#define SUN8I_MIXER_BLEND_OUTSIZE(base)		((base) + 0x8c)
-#define SUN8I_MIXER_BLEND_MODE(base, x)		((base) + 0x90 + 0x04 * (x))
-#define SUN8I_MIXER_BLEND_CK_CTL(base)		((base) + 0xb0)
-#define SUN8I_MIXER_BLEND_CK_CFG(base)		((base) + 0xb4)
-#define SUN8I_MIXER_BLEND_CK_MAX(base, x)	((base) + 0xc0 + 0x04 * (x))
-#define SUN8I_MIXER_BLEND_CK_MIN(base, x)	((base) + 0xe0 + 0x04 * (x))
-#define SUN8I_MIXER_BLEND_OUTCTL(base)		((base) + 0xfc)
-
-#define SUN8I_MIXER_BLEND_PIPE_CTL_EN_MSK	GENMASK(12, 8)
-#define SUN8I_MIXER_BLEND_PIPE_CTL_EN(pipe)	BIT(8 + pipe)
-#define SUN8I_MIXER_BLEND_PIPE_CTL_FC_EN(pipe)	BIT(pipe)
+#define DE2_MIXER_BLEND_PIPE_CTL(base)		((base) + 0)
+#define DE2_MIXER_BLEND_ATTR_FCOLOR(base, x)	((base) + 0x4 + 0x10 * (x))
+#define DE2_MIXER_BLEND_ATTR_INSIZE(base, x)	((base) + 0x8 + 0x10 * (x))
+#define DE2_MIXER_BLEND_ATTR_COORD(base, x)	((base) + 0xc + 0x10 * (x))
+#define DE2_MIXER_BLEND_ROUTE(base)		((base) + 0x80)
+#define DE2_MIXER_BLEND_PREMULTIPLY(base)	((base) + 0x84)
+#define DE2_MIXER_BLEND_BKCOLOR(base)		((base) + 0x88)
+#define DE2_MIXER_BLEND_OUTSIZE(base)		((base) + 0x8c)
+#define DE2_MIXER_BLEND_MODE(base, x)		((base) + 0x90 + 0x04 * (x))
+#define DE2_MIXER_BLEND_CK_CTL(base)		((base) + 0xb0)
+#define DE2_MIXER_BLEND_CK_CFG(base)		((base) + 0xb4)
+#define DE2_MIXER_BLEND_CK_MAX(base, x)		((base) + 0xc0 + 0x04 * (x))
+#define DE2_MIXER_BLEND_CK_MIN(base, x)		((base) + 0xe0 + 0x04 * (x))
+#define DE2_MIXER_BLEND_OUTCTL(base)		((base) + 0xfc)
+
+#define DE2_MIXER_BLEND_PIPE_CTL_EN_MSK		GENMASK(12, 8)
+#define DE2_MIXER_BLEND_PIPE_CTL_EN(pipe)	BIT(8 + pipe)
+#define DE2_MIXER_BLEND_PIPE_CTL_FC_EN(pipe)	BIT(pipe)
 /* colors are always in AARRGGBB format */
-#define SUN8I_MIXER_BLEND_COLOR_BLACK		0xff000000
+#define DE2_MIXER_BLEND_COLOR_BLACK		0xff000000
 /* The following numbers are some still unknown magic numbers */
-#define SUN8I_MIXER_BLEND_MODE_DEF		0x03010301
-
-#define SUN8I_MIXER_BLEND_ROUTE_PIPE_MSK(n)	(0xf << ((n) << 2))
-#define SUN8I_MIXER_BLEND_ROUTE_PIPE_SHIFT(n)	((n) << 2)
-
-#define SUN8I_MIXER_BLEND_OUTCTL_INTERLACED	BIT(1)
-
-#define SUN8I_MIXER_FBFMT_ARGB8888	0
-#define SUN8I_MIXER_FBFMT_ABGR8888	1
-#define SUN8I_MIXER_FBFMT_RGBA8888	2
-#define SUN8I_MIXER_FBFMT_BGRA8888	3
-#define SUN8I_MIXER_FBFMT_XRGB8888	4
-#define SUN8I_MIXER_FBFMT_XBGR8888	5
-#define SUN8I_MIXER_FBFMT_RGBX8888	6
-#define SUN8I_MIXER_FBFMT_BGRX8888	7
-#define SUN8I_MIXER_FBFMT_RGB888	8
-#define SUN8I_MIXER_FBFMT_BGR888	9
-#define SUN8I_MIXER_FBFMT_RGB565	10
-#define SUN8I_MIXER_FBFMT_BGR565	11
-#define SUN8I_MIXER_FBFMT_ARGB4444	12
-#define SUN8I_MIXER_FBFMT_ABGR4444	13
-#define SUN8I_MIXER_FBFMT_RGBA4444	14
-#define SUN8I_MIXER_FBFMT_BGRA4444	15
-#define SUN8I_MIXER_FBFMT_ARGB1555	16
-#define SUN8I_MIXER_FBFMT_ABGR1555	17
-#define SUN8I_MIXER_FBFMT_RGBA5551	18
-#define SUN8I_MIXER_FBFMT_BGRA5551	19
-
-#define SUN8I_MIXER_FBFMT_YUYV		0
-#define SUN8I_MIXER_FBFMT_UYVY		1
-#define SUN8I_MIXER_FBFMT_YVYU		2
-#define SUN8I_MIXER_FBFMT_VYUY		3
-#define SUN8I_MIXER_FBFMT_NV16		4
-#define SUN8I_MIXER_FBFMT_NV61		5
-#define SUN8I_MIXER_FBFMT_YUV422	6
+#define DE2_MIXER_BLEND_MODE_DEF		0x03010301
+
+#define DE2_MIXER_BLEND_ROUTE_PIPE_MSK(n)	(0xf << ((n) << 2))
+#define DE2_MIXER_BLEND_ROUTE_PIPE_SHIFT(n)	((n) << 2)
+
+#define DE2_MIXER_BLEND_OUTCTL_INTERLACED	BIT(1)
+
+#define DE2_MIXER_FBFMT_ARGB8888	0
+#define DE2_MIXER_FBFMT_ABGR8888	1
+#define DE2_MIXER_FBFMT_RGBA8888	2
+#define DE2_MIXER_FBFMT_BGRA8888	3
+#define DE2_MIXER_FBFMT_XRGB8888	4
+#define DE2_MIXER_FBFMT_XBGR8888	5
+#define DE2_MIXER_FBFMT_RGBX8888	6
+#define DE2_MIXER_FBFMT_BGRX8888	7
+#define DE2_MIXER_FBFMT_RGB888		8
+#define DE2_MIXER_FBFMT_BGR888		9
+#define DE2_MIXER_FBFMT_RGB565		10
+#define DE2_MIXER_FBFMT_BGR565		11
+#define DE2_MIXER_FBFMT_ARGB4444	12
+#define DE2_MIXER_FBFMT_ABGR4444	13
+#define DE2_MIXER_FBFMT_RGBA4444	14
+#define DE2_MIXER_FBFMT_BGRA4444	15
+#define DE2_MIXER_FBFMT_ARGB1555	16
+#define DE2_MIXER_FBFMT_ABGR1555	17
+#define DE2_MIXER_FBFMT_RGBA5551	18
+#define DE2_MIXER_FBFMT_BGRA5551	19
+
+#define DE2_MIXER_FBFMT_YUYV		0
+#define DE2_MIXER_FBFMT_UYVY		1
+#define DE2_MIXER_FBFMT_YVYU		2
+#define DE2_MIXER_FBFMT_VYUY		3
+#define DE2_MIXER_FBFMT_NV16		4
+#define DE2_MIXER_FBFMT_NV61		5
+#define DE2_MIXER_FBFMT_YUV422		6
 /* format 7 doesn't exist */
-#define SUN8I_MIXER_FBFMT_NV12		8
-#define SUN8I_MIXER_FBFMT_NV21		9
-#define SUN8I_MIXER_FBFMT_YUV420	10
+#define DE2_MIXER_FBFMT_NV12		8
+#define DE2_MIXER_FBFMT_NV21		9
+#define DE2_MIXER_FBFMT_YUV420		10
 /* format 11 doesn't exist */
 /* format 12 is semi-planar YUV411 UVUV */
 /* format 13 is semi-planar YUV411 VUVU */
-#define SUN8I_MIXER_FBFMT_YUV411	14
+#define DE2_MIXER_FBFMT_YUV411		14
 
 /*
  * These sub-engines are still unknown now, the EN registers are here only to
  * be used to disable these sub-engines.
  */
-#define SUN8I_MIXER_FCE_EN			0xa0000
-#define SUN8I_MIXER_BWS_EN			0xa2000
-#define SUN8I_MIXER_LTI_EN			0xa4000
-#define SUN8I_MIXER_PEAK_EN			0xa6000
-#define SUN8I_MIXER_ASE_EN			0xa8000
-#define SUN8I_MIXER_FCC_EN			0xaa000
-#define SUN8I_MIXER_DCSC_EN			0xb0000
+#define DE2_MIXER_FCE_EN			0xa0000
+#define DE2_MIXER_BWS_EN			0xa2000
+#define DE2_MIXER_LTI_EN			0xa4000
+#define DE2_MIXER_PEAK_EN			0xa6000
+#define DE2_MIXER_ASE_EN			0xa8000
+#define DE2_MIXER_FCC_EN			0xaa000
+#define DE2_MIXER_DCSC_EN			0xb0000
 
 struct de2_fmt_info {
 	u32			drm_fmt;
diff --git a/drivers/gpu/drm/sun4i/sun8i_ui_layer.c b/drivers/gpu/drm/sun4i/sun8i_ui_layer.c
index e3fc8fa920fb..e4a3109d373c 100644
--- a/drivers/gpu/drm/sun4i/sun8i_ui_layer.c
+++ b/drivers/gpu/drm/sun4i/sun8i_ui_layer.c
@@ -39,38 +39,38 @@ static void sun8i_ui_layer_enable(struct sun8i_mixer *mixer, int channel,
 			 enable ? "En" : "Dis", channel, overlay);
 
 	if (enable)
-		val = SUN8I_MIXER_CHAN_UI_LAYER_ATTR_EN;
+		val = DE2_MIXER_CHAN_UI_LAYER_ATTR_EN;
 	else
 		val = 0;
 
 	regmap_update_bits(mixer->engine.regs,
-			   SUN8I_MIXER_CHAN_UI_LAYER_ATTR(ch_base, overlay),
-			   SUN8I_MIXER_CHAN_UI_LAYER_ATTR_EN, val);
+			   DE2_MIXER_CHAN_UI_LAYER_ATTR(ch_base, overlay),
+			   DE2_MIXER_CHAN_UI_LAYER_ATTR_EN, val);
 
 	if (!enable || zpos != old_zpos) {
 		regmap_update_bits(mixer->engine.regs,
-				   SUN8I_MIXER_BLEND_PIPE_CTL(bld_base),
-				   SUN8I_MIXER_BLEND_PIPE_CTL_EN(old_zpos),
+				   DE2_MIXER_BLEND_PIPE_CTL(bld_base),
+				   DE2_MIXER_BLEND_PIPE_CTL_EN(old_zpos),
 				   0);
 
 		regmap_update_bits(mixer->engine.regs,
-				   SUN8I_MIXER_BLEND_ROUTE(bld_base),
-				   SUN8I_MIXER_BLEND_ROUTE_PIPE_MSK(old_zpos),
+				   DE2_MIXER_BLEND_ROUTE(bld_base),
+				   DE2_MIXER_BLEND_ROUTE_PIPE_MSK(old_zpos),
 				   0);
 	}
 
 	if (enable) {
-		val = SUN8I_MIXER_BLEND_PIPE_CTL_EN(zpos);
+		val = DE2_MIXER_BLEND_PIPE_CTL_EN(zpos);
 
 		regmap_update_bits(mixer->engine.regs,
-				   SUN8I_MIXER_BLEND_PIPE_CTL(bld_base),
+				   DE2_MIXER_BLEND_PIPE_CTL(bld_base),
 				   val, val);
 
-		val = channel << SUN8I_MIXER_BLEND_ROUTE_PIPE_SHIFT(zpos);
+		val = channel << DE2_MIXER_BLEND_ROUTE_PIPE_SHIFT(zpos);
 
 		regmap_update_bits(mixer->engine.regs,
-				   SUN8I_MIXER_BLEND_ROUTE(bld_base),
-				   SUN8I_MIXER_BLEND_ROUTE_PIPE_MSK(zpos),
+				   DE2_MIXER_BLEND_ROUTE(bld_base),
+				   DE2_MIXER_BLEND_ROUTE_PIPE_MSK(zpos),
 				   val);
 	}
 }
@@ -99,8 +99,8 @@ static int sun8i_ui_layer_update_coord(struct sun8i_mixer *mixer, int channel,
 	hphase = state->src.x1 & 0xffff;
 	vphase = state->src.y1 & 0xffff;
 
-	insize = SUN8I_MIXER_SIZE(src_w, src_h);
-	outsize = SUN8I_MIXER_SIZE(dst_w, dst_h);
+	insize = DE2_MIXER_SIZE(src_w, src_h);
+	outsize = DE2_MIXER_SIZE(dst_w, dst_h);
 
 	if (plane->type == DRM_PLANE_TYPE_PRIMARY) {
 		bool interlaced = false;
@@ -109,23 +109,23 @@ static int sun8i_ui_layer_update_coord(struct sun8i_mixer *mixer, int channel,
 		DRM_DEBUG_DRIVER("Primary layer, updating global size W: %u H: %u\n",
 				 dst_w, dst_h);
 		regmap_write(mixer->engine.regs,
-			     SUN8I_MIXER_GLOBAL_SIZE,
+			     DE2_MIXER_GLOBAL_SIZE,
 			     outsize);
 		regmap_write(mixer->engine.regs,
-			     SUN8I_MIXER_BLEND_OUTSIZE(bld_base), outsize);
+			     DE2_MIXER_BLEND_OUTSIZE(bld_base), outsize);
 
 		if (state->crtc)
 			interlaced = state->crtc->state->adjusted_mode.flags
 				& DRM_MODE_FLAG_INTERLACE;
 
 		if (interlaced)
-			val = SUN8I_MIXER_BLEND_OUTCTL_INTERLACED;
+			val = DE2_MIXER_BLEND_OUTCTL_INTERLACED;
 		else
 			val = 0;
 
 		regmap_update_bits(mixer->engine.regs,
-				   SUN8I_MIXER_BLEND_OUTCTL(bld_base),
-				   SUN8I_MIXER_BLEND_OUTCTL_INTERLACED,
+				   DE2_MIXER_BLEND_OUTCTL(bld_base),
+				   DE2_MIXER_BLEND_OUTCTL_INTERLACED,
 				   val);
 
 		DRM_DEBUG_DRIVER("Switching display mixer interlaced mode %s\n",
@@ -137,10 +137,10 @@ static int sun8i_ui_layer_update_coord(struct sun8i_mixer *mixer, int channel,
 			 state->src.x1 >> 16, state->src.y1 >> 16);
 	DRM_DEBUG_DRIVER("Layer source size W: %d H: %d\n", src_w, src_h);
 	regmap_write(mixer->engine.regs,
-		     SUN8I_MIXER_CHAN_UI_LAYER_SIZE(ch_base, overlay),
+		     DE2_MIXER_CHAN_UI_LAYER_SIZE(ch_base, overlay),
 		     insize);
 	regmap_write(mixer->engine.regs,
-		     SUN8I_MIXER_CHAN_UI_OVL_SIZE(ch_base),
+		     DE2_MIXER_CHAN_UI_OVL_SIZE(ch_base),
 		     insize);
 
 	if (insize != outsize || hphase || vphase) {
@@ -164,10 +164,10 @@ static int sun8i_ui_layer_update_coord(struct sun8i_mixer *mixer, int channel,
 			 state->dst.x1, state->dst.y1);
 	DRM_DEBUG_DRIVER("Layer destination size W: %d H: %d\n", dst_w, dst_h);
 	regmap_write(mixer->engine.regs,
-		     SUN8I_MIXER_BLEND_ATTR_COORD(bld_base, zpos),
-		     SUN8I_MIXER_COORD(state->dst.x1, state->dst.y1));
+		     DE2_MIXER_BLEND_ATTR_COORD(bld_base, zpos),
+		     DE2_MIXER_COORD(state->dst.x1, state->dst.y1));
 	regmap_write(mixer->engine.regs,
-		     SUN8I_MIXER_BLEND_ATTR_INSIZE(bld_base, zpos),
+		     DE2_MIXER_BLEND_ATTR_INSIZE(bld_base, zpos),
 		     outsize);
 
 	return 0;
@@ -188,10 +188,10 @@ static int sun8i_ui_layer_update_formats(struct sun8i_mixer *mixer, int channel,
 		return -EINVAL;
 	}
 
-	val = fmt_info->de2_fmt << SUN8I_MIXER_CHAN_UI_LAYER_ATTR_FBFMT_OFFSET;
+	val = fmt_info->de2_fmt << DE2_MIXER_CHAN_UI_LAYER_ATTR_FBFMT_OFFSET;
 	regmap_update_bits(mixer->engine.regs,
-			   SUN8I_MIXER_CHAN_UI_LAYER_ATTR(ch_base, overlay),
-			   SUN8I_MIXER_CHAN_UI_LAYER_ATTR_FBFMT_MASK, val);
+			   DE2_MIXER_CHAN_UI_LAYER_ATTR(ch_base, overlay),
+			   DE2_MIXER_CHAN_UI_LAYER_ATTR_FBFMT_MASK, val);
 
 	return 0;
 }
@@ -224,13 +224,13 @@ static int sun8i_ui_layer_update_buffer(struct sun8i_mixer *mixer, int channel,
 	/* Set the line width */
 	DRM_DEBUG_DRIVER("Layer line width: %d bytes\n", fb->pitches[0]);
 	regmap_write(mixer->engine.regs,
-		     SUN8I_MIXER_CHAN_UI_LAYER_PITCH(ch_base, overlay),
+		     DE2_MIXER_CHAN_UI_LAYER_PITCH(ch_base, overlay),
 		     fb->pitches[0]);
 
 	DRM_DEBUG_DRIVER("Setting buffer address to %pad\n", &paddr);
 
 	regmap_write(mixer->engine.regs,
-		     SUN8I_MIXER_CHAN_UI_LAYER_TOP_LADDR(ch_base, overlay),
+		     DE2_MIXER_CHAN_UI_LAYER_TOP_LADDR(ch_base, overlay),
 		     lower_32_bits(paddr));
 
 	return 0;
@@ -255,8 +255,8 @@ static int sun8i_ui_layer_atomic_check(struct drm_plane *plane,
 	max_scale = DRM_PLANE_HELPER_NO_SCALING;
 
 	if (layer->mixer->cfg->scaler_mask & BIT(layer->channel)) {
-		min_scale = SUN8I_UI_SCALER_SCALE_MIN;
-		max_scale = SUN8I_UI_SCALER_SCALE_MAX;
+		min_scale = DE2_UI_SCALER_SCALE_MIN;
+		max_scale = DE2_UI_SCALER_SCALE_MAX;
 	}
 
 	return drm_atomic_helper_check_plane_state(state, crtc_state,
diff --git a/drivers/gpu/drm/sun4i/sun8i_ui_layer.h b/drivers/gpu/drm/sun4i/sun8i_ui_layer.h
index f4389cf0ba20..df9e648a5de6 100644
--- a/drivers/gpu/drm/sun4i/sun8i_ui_layer.h
+++ b/drivers/gpu/drm/sun4i/sun8i_ui_layer.h
@@ -18,32 +18,32 @@
 
 #include <drm/drm_plane.h>
 
-#define SUN8I_MIXER_CHAN_UI_LAYER_ATTR(base, layer) \
+#define DE2_MIXER_CHAN_UI_LAYER_ATTR(base, layer) \
 			((base) + 0x20 * (layer) + 0x0)
-#define SUN8I_MIXER_CHAN_UI_LAYER_SIZE(base, layer) \
+#define DE2_MIXER_CHAN_UI_LAYER_SIZE(base, layer) \
 			((base) + 0x20 * (layer) + 0x4)
-#define SUN8I_MIXER_CHAN_UI_LAYER_COORD(base, layer) \
+#define DE2_MIXER_CHAN_UI_LAYER_COORD(base, layer) \
 			((base) + 0x20 * (layer) + 0x8)
-#define SUN8I_MIXER_CHAN_UI_LAYER_PITCH(base, layer) \
+#define DE2_MIXER_CHAN_UI_LAYER_PITCH(base, layer) \
 			((base) + 0x20 * (layer) + 0xc)
-#define SUN8I_MIXER_CHAN_UI_LAYER_TOP_LADDR(base, layer) \
+#define DE2_MIXER_CHAN_UI_LAYER_TOP_LADDR(base, layer) \
 			((base) + 0x20 * (layer) + 0x10)
-#define SUN8I_MIXER_CHAN_UI_LAYER_BOT_LADDR(base, layer) \
+#define DE2_MIXER_CHAN_UI_LAYER_BOT_LADDR(base, layer) \
 			((base) + 0x20 * (layer) + 0x14)
-#define SUN8I_MIXER_CHAN_UI_LAYER_FCOLOR(base, layer) \
+#define DE2_MIXER_CHAN_UI_LAYER_FCOLOR(base, layer) \
 			((base) + 0x20 * (layer) + 0x18)
-#define SUN8I_MIXER_CHAN_UI_TOP_HADDR(base) \
+#define DE2_MIXER_CHAN_UI_TOP_HADDR(base) \
 			((base) + 0x80)
-#define SUN8I_MIXER_CHAN_UI_BOT_HADDR(base) \
+#define DE2_MIXER_CHAN_UI_BOT_HADDR(base) \
 			((base) + 0x84)
-#define SUN8I_MIXER_CHAN_UI_OVL_SIZE(base) \
+#define DE2_MIXER_CHAN_UI_OVL_SIZE(base) \
 			((base) + 0x88)
 
-#define SUN8I_MIXER_CHAN_UI_LAYER_ATTR_EN		BIT(0)
-#define SUN8I_MIXER_CHAN_UI_LAYER_ATTR_ALPHA_MODE_MASK	GENMASK(2, 1)
-#define SUN8I_MIXER_CHAN_UI_LAYER_ATTR_FBFMT_MASK	GENMASK(12, 8)
-#define SUN8I_MIXER_CHAN_UI_LAYER_ATTR_FBFMT_OFFSET	8
-#define SUN8I_MIXER_CHAN_UI_LAYER_ATTR_ALPHA_MASK	GENMASK(31, 24)
+#define DE2_MIXER_CHAN_UI_LAYER_ATTR_EN			BIT(0)
+#define DE2_MIXER_CHAN_UI_LAYER_ATTR_ALPHA_MODE_MASK	GENMASK(2, 1)
+#define DE2_MIXER_CHAN_UI_LAYER_ATTR_FBFMT_MASK		GENMASK(12, 8)
+#define DE2_MIXER_CHAN_UI_LAYER_ATTR_FBFMT_OFFSET	8
+#define DE2_MIXER_CHAN_UI_LAYER_ATTR_ALPHA_MASK		GENMASK(31, 24)
 
 struct sun8i_mixer;
 
diff --git a/drivers/gpu/drm/sun4i/sun8i_ui_scaler.c b/drivers/gpu/drm/sun4i/sun8i_ui_scaler.c
index 698401ecb53d..59dfe2deae8f 100644
--- a/drivers/gpu/drm/sun4i/sun8i_ui_scaler.c
+++ b/drivers/gpu/drm/sun4i/sun8i_ui_scaler.c
@@ -101,7 +101,7 @@ static int sun8i_ui_scaler_coef_index(unsigned int step)
 {
 	unsigned int scale, int_part, float_part;
 
-	scale = step >> (SUN8I_UI_SCALER_SCALE_FRAC - 3);
+	scale = step >> (DE2_UI_SCALER_SCALE_FRAC - 3);
 	int_part = scale >> 3;
 	float_part = scale & 0x7;
 
@@ -131,12 +131,12 @@ void sun8i_ui_scaler_enable(struct sun8i_mixer *mixer, int layer, bool enable)
 	base = sun8i_ui_scaler_base(mixer, layer);
 
 	if (enable)
-		val = SUN8I_SCALER_GSU_CTRL_EN |
-		      SUN8I_SCALER_GSU_CTRL_COEFF_RDY;
+		val = DE2_SCALER_GSU_CTRL_EN |
+		      DE2_SCALER_GSU_CTRL_COEFF_RDY;
 	else
 		val = 0;
 
-	regmap_write(mixer->engine.regs, SUN8I_SCALER_GSU_CTRL(base), val);
+	regmap_write(mixer->engine.regs, DE2_SCALER_GSU_CTRL(base), val);
 }
 
 void sun8i_ui_scaler_setup(struct sun8i_mixer *mixer, int layer,
@@ -152,30 +152,30 @@ void sun8i_ui_scaler_setup(struct sun8i_mixer *mixer, int layer,
 
 	base = sun8i_ui_scaler_base(mixer, layer);
 
-	hphase <<= SUN8I_UI_SCALER_PHASE_FRAC - 16;
-	vphase <<= SUN8I_UI_SCALER_PHASE_FRAC - 16;
-	hscale <<= SUN8I_UI_SCALER_SCALE_FRAC - 16;
-	vscale <<= SUN8I_UI_SCALER_SCALE_FRAC - 16;
+	hphase <<= DE2_UI_SCALER_PHASE_FRAC - 16;
+	vphase <<= DE2_UI_SCALER_PHASE_FRAC - 16;
+	hscale <<= DE2_UI_SCALER_SCALE_FRAC - 16;
+	vscale <<= DE2_UI_SCALER_SCALE_FRAC - 16;
 
-	insize = SUN8I_UI_SCALER_SIZE(src_w, src_h);
-	outsize = SUN8I_UI_SCALER_SIZE(dst_w, dst_h);
+	insize = DE2_UI_SCALER_SIZE(src_w, src_h);
+	outsize = DE2_UI_SCALER_SIZE(dst_w, dst_h);
 
 	regmap_write(mixer->engine.regs,
-		     SUN8I_SCALER_GSU_OUTSIZE(base), outsize);
+		     DE2_SCALER_GSU_OUTSIZE(base), outsize);
 	regmap_write(mixer->engine.regs,
-		     SUN8I_SCALER_GSU_INSIZE(base), insize);
+		     DE2_SCALER_GSU_INSIZE(base), insize);
 	regmap_write(mixer->engine.regs,
-		     SUN8I_SCALER_GSU_HSTEP(base), hscale);
+		     DE2_SCALER_GSU_HSTEP(base), hscale);
 	regmap_write(mixer->engine.regs,
-		     SUN8I_SCALER_GSU_VSTEP(base), vscale);
+		     DE2_SCALER_GSU_VSTEP(base), vscale);
 	regmap_write(mixer->engine.regs,
-		     SUN8I_SCALER_GSU_HPHASE(base), hphase);
+		     DE2_SCALER_GSU_HPHASE(base), hphase);
 	regmap_write(mixer->engine.regs,
-		     SUN8I_SCALER_GSU_VPHASE(base), vphase);
+		     DE2_SCALER_GSU_VPHASE(base), vphase);
 	offset = sun8i_ui_scaler_coef_index(hscale) *
-			SUN8I_UI_SCALER_COEFF_COUNT;
-	for (i = 0; i < SUN8I_UI_SCALER_COEFF_COUNT; i++)
+			DE2_UI_SCALER_COEFF_COUNT;
+	for (i = 0; i < DE2_UI_SCALER_COEFF_COUNT; i++)
 		regmap_write(mixer->engine.regs,
-			     SUN8I_SCALER_GSU_HCOEFF(base, i),
+			     DE2_SCALER_GSU_HCOEFF(base, i),
 			     lan2coefftab16[offset + i]);
 }
diff --git a/drivers/gpu/drm/sun4i/sun8i_ui_scaler.h b/drivers/gpu/drm/sun4i/sun8i_ui_scaler.h
index 6b4bc1ff3e2c..8db18053e6ee 100644
--- a/drivers/gpu/drm/sun4i/sun8i_ui_scaler.h
+++ b/drivers/gpu/drm/sun4i/sun8i_ui_scaler.h
@@ -14,25 +14,25 @@
 #define DE2_UI_SCALER_UNIT_SIZE 0x10000
 
 /* this two macros assumes 16 fractional bits which is standard in DRM */
-#define SUN8I_UI_SCALER_SCALE_MIN		1
-#define SUN8I_UI_SCALER_SCALE_MAX		((1UL << 20) - 1)
-
-#define SUN8I_UI_SCALER_SCALE_FRAC		20
-#define SUN8I_UI_SCALER_PHASE_FRAC		20
-#define SUN8I_UI_SCALER_COEFF_COUNT		16
-#define SUN8I_UI_SCALER_SIZE(w, h)		(((h) - 1) << 16 | ((w) - 1))
-
-#define SUN8I_SCALER_GSU_CTRL(base)		((base) + 0x0)
-#define SUN8I_SCALER_GSU_OUTSIZE(base)		((base) + 0x40)
-#define SUN8I_SCALER_GSU_INSIZE(base)		((base) + 0x80)
-#define SUN8I_SCALER_GSU_HSTEP(base)		((base) + 0x88)
-#define SUN8I_SCALER_GSU_VSTEP(base)		((base) + 0x8c)
-#define SUN8I_SCALER_GSU_HPHASE(base)		((base) + 0x90)
-#define SUN8I_SCALER_GSU_VPHASE(base)		((base) + 0x98)
-#define SUN8I_SCALER_GSU_HCOEFF(base, index)	((base) + 0x200 + 0x4 * (index))
-
-#define SUN8I_SCALER_GSU_CTRL_EN		BIT(0)
-#define SUN8I_SCALER_GSU_CTRL_COEFF_RDY		BIT(4)
+#define DE2_UI_SCALER_SCALE_MIN			1
+#define DE2_UI_SCALER_SCALE_MAX			((1UL << 20) - 1)
+
+#define DE2_UI_SCALER_SCALE_FRAC		20
+#define DE2_UI_SCALER_PHASE_FRAC		20
+#define DE2_UI_SCALER_COEFF_COUNT		16
+#define DE2_UI_SCALER_SIZE(w, h)		(((h) - 1) << 16 | ((w) - 1))
+
+#define DE2_SCALER_GSU_CTRL(base)		((base) + 0x0)
+#define DE2_SCALER_GSU_OUTSIZE(base)		((base) + 0x40)
+#define DE2_SCALER_GSU_INSIZE(base)		((base) + 0x80)
+#define DE2_SCALER_GSU_HSTEP(base)		((base) + 0x88)
+#define DE2_SCALER_GSU_VSTEP(base)		((base) + 0x8c)
+#define DE2_SCALER_GSU_HPHASE(base)		((base) + 0x90)
+#define DE2_SCALER_GSU_VPHASE(base)		((base) + 0x98)
+#define DE2_SCALER_GSU_HCOEFF(base, index)	((base) + 0x200 + 0x4 * (index))
+
+#define DE2_SCALER_GSU_CTRL_EN			BIT(0)
+#define DE2_SCALER_GSU_CTRL_COEFF_RDY		BIT(4)
 
 void sun8i_ui_scaler_enable(struct sun8i_mixer *mixer, int layer, bool enable);
 void sun8i_ui_scaler_setup(struct sun8i_mixer *mixer, int layer,
diff --git a/drivers/gpu/drm/sun4i/sun8i_vi_layer.c b/drivers/gpu/drm/sun4i/sun8i_vi_layer.c
index 79811eae3735..8ea07f34ad5b 100644
--- a/drivers/gpu/drm/sun4i/sun8i_vi_layer.c
+++ b/drivers/gpu/drm/sun4i/sun8i_vi_layer.c
@@ -33,38 +33,38 @@ static void sun8i_vi_layer_enable(struct sun8i_mixer *mixer, int channel,
 			 enable ? "En" : "Dis", channel, overlay);
 
 	if (enable)
-		val = SUN8I_MIXER_CHAN_VI_LAYER_ATTR_EN;
+		val = DE2_MIXER_CHAN_VI_LAYER_ATTR_EN;
 	else
 		val = 0;
 
 	regmap_update_bits(mixer->engine.regs,
-			   SUN8I_MIXER_CHAN_VI_LAYER_ATTR(ch_base, overlay),
-			   SUN8I_MIXER_CHAN_VI_LAYER_ATTR_EN, val);
+			   DE2_MIXER_CHAN_VI_LAYER_ATTR(ch_base, overlay),
+			   DE2_MIXER_CHAN_VI_LAYER_ATTR_EN, val);
 
 	if (!enable || zpos != old_zpos) {
 		regmap_update_bits(mixer->engine.regs,
-				   SUN8I_MIXER_BLEND_PIPE_CTL(bld_base),
-				   SUN8I_MIXER_BLEND_PIPE_CTL_EN(old_zpos),
+				   DE2_MIXER_BLEND_PIPE_CTL(bld_base),
+				   DE2_MIXER_BLEND_PIPE_CTL_EN(old_zpos),
 				   0);
 
 		regmap_update_bits(mixer->engine.regs,
-				   SUN8I_MIXER_BLEND_ROUTE(bld_base),
-				   SUN8I_MIXER_BLEND_ROUTE_PIPE_MSK(old_zpos),
+				   DE2_MIXER_BLEND_ROUTE(bld_base),
+				   DE2_MIXER_BLEND_ROUTE_PIPE_MSK(old_zpos),
 				   0);
 	}
 
 	if (enable) {
-		val = SUN8I_MIXER_BLEND_PIPE_CTL_EN(zpos);
+		val = DE2_MIXER_BLEND_PIPE_CTL_EN(zpos);
 
 		regmap_update_bits(mixer->engine.regs,
-				   SUN8I_MIXER_BLEND_PIPE_CTL(bld_base),
+				   DE2_MIXER_BLEND_PIPE_CTL(bld_base),
 				   val, val);
 
-		val = channel << SUN8I_MIXER_BLEND_ROUTE_PIPE_SHIFT(zpos);
+		val = channel << DE2_MIXER_BLEND_ROUTE_PIPE_SHIFT(zpos);
 
 		regmap_update_bits(mixer->engine.regs,
-				   SUN8I_MIXER_BLEND_ROUTE(bld_base),
-				   SUN8I_MIXER_BLEND_ROUTE_PIPE_MSK(zpos),
+				   DE2_MIXER_BLEND_ROUTE(bld_base),
+				   DE2_MIXER_BLEND_ROUTE_PIPE_MSK(zpos),
 				   val);
 	}
 }
@@ -114,8 +114,8 @@ static int sun8i_vi_layer_update_coord(struct sun8i_mixer *mixer, int channel,
 		vphase += remainder << 16;
 	}
 
-	insize = SUN8I_MIXER_SIZE(src_w, src_h);
-	outsize = SUN8I_MIXER_SIZE(dst_w, dst_h);
+	insize = DE2_MIXER_SIZE(src_w, src_h);
+	outsize = DE2_MIXER_SIZE(dst_w, dst_h);
 
 	/* Set height and width */
 	DRM_DEBUG_DRIVER("Layer source offset X: %d Y: %d\n",
@@ -123,10 +123,10 @@ static int sun8i_vi_layer_update_coord(struct sun8i_mixer *mixer, int channel,
 			 (state->src.y1 >> 16) & ~(format->vsub - 1));
 	DRM_DEBUG_DRIVER("Layer source size W: %d H: %d\n", src_w, src_h);
 	regmap_write(mixer->engine.regs,
-		     SUN8I_MIXER_CHAN_VI_LAYER_SIZE(ch_base, overlay),
+		     DE2_MIXER_CHAN_VI_LAYER_SIZE(ch_base, overlay),
 		     insize);
 	regmap_write(mixer->engine.regs,
-		     SUN8I_MIXER_CHAN_VI_OVL_SIZE(ch_base),
+		     DE2_MIXER_CHAN_VI_OVL_SIZE(ch_base),
 		     insize);
 
 	/*
@@ -157,10 +157,10 @@ static int sun8i_vi_layer_update_coord(struct sun8i_mixer *mixer, int channel,
 			 state->dst.x1, state->dst.y1);
 	DRM_DEBUG_DRIVER("Layer destination size W: %d H: %d\n", dst_w, dst_h);
 	regmap_write(mixer->engine.regs,
-		     SUN8I_MIXER_BLEND_ATTR_COORD(bld_base, zpos),
-		     SUN8I_MIXER_COORD(state->dst.x1, state->dst.y1));
+		     DE2_MIXER_BLEND_ATTR_COORD(bld_base, zpos),
+		     DE2_MIXER_COORD(state->dst.x1, state->dst.y1));
 	regmap_write(mixer->engine.regs,
-		     SUN8I_MIXER_BLEND_ATTR_INSIZE(bld_base, zpos),
+		     DE2_MIXER_BLEND_ATTR_INSIZE(bld_base, zpos),
 		     outsize);
 
 	return 0;
@@ -181,10 +181,10 @@ static int sun8i_vi_layer_update_formats(struct sun8i_mixer *mixer, int channel,
 		return -EINVAL;
 	}
 
-	val = fmt_info->de2_fmt << SUN8I_MIXER_CHAN_VI_LAYER_ATTR_FBFMT_OFFSET;
+	val = fmt_info->de2_fmt << DE2_MIXER_CHAN_VI_LAYER_ATTR_FBFMT_OFFSET;
 	regmap_update_bits(mixer->engine.regs,
-			   SUN8I_MIXER_CHAN_VI_LAYER_ATTR(ch_base, overlay),
-			   SUN8I_MIXER_CHAN_VI_LAYER_ATTR_FBFMT_MASK, val);
+			   DE2_MIXER_CHAN_VI_LAYER_ATTR(ch_base, overlay),
+			   DE2_MIXER_CHAN_VI_LAYER_ATTR_FBFMT_MASK, val);
 
 	if (fmt_info->csc != SUN8I_CSC_MODE_OFF) {
 		sun8i_csc_set_ccsc_coefficients(mixer, channel, fmt_info->csc);
@@ -194,13 +194,13 @@ static int sun8i_vi_layer_update_formats(struct sun8i_mixer *mixer, int channel,
 	}
 
 	if (fmt_info->rgb)
-		val = SUN8I_MIXER_CHAN_VI_LAYER_ATTR_RGB_MODE;
+		val = DE2_MIXER_CHAN_VI_LAYER_ATTR_RGB_MODE;
 	else
 		val = 0;
 
 	regmap_update_bits(mixer->engine.regs,
-			   SUN8I_MIXER_CHAN_VI_LAYER_ATTR(ch_base, overlay),
-			   SUN8I_MIXER_CHAN_VI_LAYER_ATTR_RGB_MODE, val);
+			   DE2_MIXER_CHAN_VI_LAYER_ATTR(ch_base, overlay),
+			   DE2_MIXER_CHAN_VI_LAYER_ATTR_RGB_MODE, val);
 
 	return 0;
 }
@@ -248,16 +248,16 @@ static int sun8i_vi_layer_update_buffer(struct sun8i_mixer *mixer, int channel,
 		DRM_DEBUG_DRIVER("Layer %d. line width: %d bytes\n",
 				 i + 1, fb->pitches[i]);
 		regmap_write(mixer->engine.regs,
-			     SUN8I_MIXER_CHAN_VI_LAYER_PITCH(ch_base,
-							     overlay, i),
+			     DE2_MIXER_CHAN_VI_LAYER_PITCH(ch_base,
+							   overlay, i),
 			     fb->pitches[i]);
 
 		DRM_DEBUG_DRIVER("Setting %d. buffer address to %pad\n",
 				 i + 1, &paddr);
 
 		regmap_write(mixer->engine.regs,
-			     SUN8I_MIXER_CHAN_VI_LAYER_TOP_LADDR(ch_base,
-								 overlay, i),
+			     DE2_MIXER_CHAN_VI_LAYER_TOP_LADDR(ch_base,
+							       overlay, i),
 			     lower_32_bits(paddr));
 	}
 
@@ -283,8 +283,8 @@ static int sun8i_vi_layer_atomic_check(struct drm_plane *plane,
 	max_scale = DRM_PLANE_HELPER_NO_SCALING;
 
 	if (layer->mixer->cfg->scaler_mask & BIT(layer->channel)) {
-		min_scale = SUN8I_VI_SCALER_SCALE_MIN;
-		max_scale = SUN8I_VI_SCALER_SCALE_MAX;
+		min_scale = DE2_VI_SCALER_SCALE_MIN;
+		max_scale = DE2_VI_SCALER_SCALE_MAX;
 	}
 
 	return drm_atomic_helper_check_plane_state(state, crtc_state,
diff --git a/drivers/gpu/drm/sun4i/sun8i_vi_layer.h b/drivers/gpu/drm/sun4i/sun8i_vi_layer.h
index 46f0237c17bb..dfda659e309c 100644
--- a/drivers/gpu/drm/sun4i/sun8i_vi_layer.h
+++ b/drivers/gpu/drm/sun4i/sun8i_vi_layer.h
@@ -12,24 +12,24 @@
 
 #include <drm/drm_plane.h>
 
-#define SUN8I_MIXER_CHAN_VI_LAYER_ATTR(base, layer) \
+#define DE2_MIXER_CHAN_VI_LAYER_ATTR(base, layer) \
 		((base) + 0x30 * (layer) + 0x0)
-#define SUN8I_MIXER_CHAN_VI_LAYER_SIZE(base, layer) \
+#define DE2_MIXER_CHAN_VI_LAYER_SIZE(base, layer) \
 		((base) + 0x30 * (layer) + 0x4)
-#define SUN8I_MIXER_CHAN_VI_LAYER_COORD(base, layer) \
+#define DE2_MIXER_CHAN_VI_LAYER_COORD(base, layer) \
 		((base) + 0x30 * (layer) + 0x8)
-#define SUN8I_MIXER_CHAN_VI_LAYER_PITCH(base, layer, plane) \
+#define DE2_MIXER_CHAN_VI_LAYER_PITCH(base, layer, plane) \
 		((base) + 0x30 * (layer) + 0xc + 4 * (plane))
-#define SUN8I_MIXER_CHAN_VI_LAYER_TOP_LADDR(base, layer, plane) \
+#define DE2_MIXER_CHAN_VI_LAYER_TOP_LADDR(base, layer, plane) \
 		((base) + 0x30 * (layer) + 0x18 + 4 * (plane))
-#define SUN8I_MIXER_CHAN_VI_OVL_SIZE(base) \
+#define DE2_MIXER_CHAN_VI_OVL_SIZE(base) \
 		((base) + 0xe8)
 
-#define SUN8I_MIXER_CHAN_VI_LAYER_ATTR_EN		BIT(0)
+#define DE2_MIXER_CHAN_VI_LAYER_ATTR_EN			BIT(0)
 /* RGB mode should be set for RGB formats and cleared for YCbCr */
-#define SUN8I_MIXER_CHAN_VI_LAYER_ATTR_RGB_MODE		BIT(15)
-#define SUN8I_MIXER_CHAN_VI_LAYER_ATTR_FBFMT_OFFSET	8
-#define SUN8I_MIXER_CHAN_VI_LAYER_ATTR_FBFMT_MASK	GENMASK(12, 8)
+#define DE2_MIXER_CHAN_VI_LAYER_ATTR_RGB_MODE		BIT(15)
+#define DE2_MIXER_CHAN_VI_LAYER_ATTR_FBFMT_OFFSET	8
+#define DE2_MIXER_CHAN_VI_LAYER_ATTR_FBFMT_MASK		GENMASK(12, 8)
 
 struct sun8i_mixer;
 
diff --git a/drivers/gpu/drm/sun4i/sun8i_vi_scaler.c b/drivers/gpu/drm/sun4i/sun8i_vi_scaler.c
index 9f6834c143d7..b69ebca221c3 100644
--- a/drivers/gpu/drm/sun4i/sun8i_vi_scaler.c
+++ b/drivers/gpu/drm/sun4i/sun8i_vi_scaler.c
@@ -842,7 +842,7 @@ static int sun8i_vi_scaler_coef_index(unsigned int step)
 {
 	unsigned int scale, int_part, float_part;
 
-	scale = step >> (SUN8I_VI_SCALER_SCALE_FRAC - 3);
+	scale = step >> (DE2_VI_SCALER_SCALE_FRAC - 3);
 	int_part = scale >> 3;
 	float_part = scale & 0x7;
 
@@ -880,24 +880,24 @@ static void sun8i_vi_scaler_set_coeff(struct regmap *map, u32 base,
 	}
 
 	offset = sun8i_vi_scaler_coef_index(hstep) *
-			SUN8I_VI_SCALER_COEFF_COUNT;
-	for (i = 0; i < SUN8I_VI_SCALER_COEFF_COUNT; i++) {
-		regmap_write(map, SUN8I_SCALER_VSU_YHCOEFF0(base, i),
+			DE2_VI_SCALER_COEFF_COUNT;
+	for (i = 0; i < DE2_VI_SCALER_COEFF_COUNT; i++) {
+		regmap_write(map, DE2_SCALER_VSU_YHCOEFF0(base, i),
 			     lan3coefftab32_left[offset + i]);
-		regmap_write(map, SUN8I_SCALER_VSU_YHCOEFF1(base, i),
+		regmap_write(map, DE2_SCALER_VSU_YHCOEFF1(base, i),
 			     lan3coefftab32_right[offset + i]);
-		regmap_write(map, SUN8I_SCALER_VSU_CHCOEFF0(base, i),
+		regmap_write(map, DE2_SCALER_VSU_CHCOEFF0(base, i),
 			     ch_left[offset + i]);
-		regmap_write(map, SUN8I_SCALER_VSU_CHCOEFF1(base, i),
+		regmap_write(map, DE2_SCALER_VSU_CHCOEFF1(base, i),
 			     ch_right[offset + i]);
 	}
 
 	offset = sun8i_vi_scaler_coef_index(hstep) *
-			SUN8I_VI_SCALER_COEFF_COUNT;
-	for (i = 0; i < SUN8I_VI_SCALER_COEFF_COUNT; i++) {
-		regmap_write(map, SUN8I_SCALER_VSU_YVCOEFF(base, i),
+			DE2_VI_SCALER_COEFF_COUNT;
+	for (i = 0; i < DE2_VI_SCALER_COEFF_COUNT; i++) {
+		regmap_write(map, DE2_SCALER_VSU_YVCOEFF(base, i),
 			     lan2coefftab32[offset + i]);
-		regmap_write(map, SUN8I_SCALER_VSU_CVCOEFF(base, i),
+		regmap_write(map, DE2_SCALER_VSU_CVCOEFF(base, i),
 			     cy[offset + i]);
 	}
 }
@@ -909,13 +909,12 @@ void sun8i_vi_scaler_enable(struct sun8i_mixer *mixer, int layer, bool enable)
 	base = sun8i_vi_scaler_base(mixer, layer);
 
 	if (enable)
-		val = SUN8I_SCALER_VSU_CTRL_EN |
-		      SUN8I_SCALER_VSU_CTRL_COEFF_RDY;
+		val = DE2_SCALER_VSU_CTRL_EN | DE2_SCALER_VSU_CTRL_COEFF_RDY;
 	else
 		val = 0;
 
 	regmap_write(mixer->engine.regs,
-		     SUN8I_SCALER_VSU_CTRL(base), val);
+		     DE2_SCALER_VSU_CTRL(base), val);
 }
 
 void sun8i_vi_scaler_setup(struct sun8i_mixer *mixer, int layer,
@@ -929,13 +928,13 @@ void sun8i_vi_scaler_setup(struct sun8i_mixer *mixer, int layer,
 
 	base = sun8i_vi_scaler_base(mixer, layer);
 
-	hphase <<= SUN8I_VI_SCALER_PHASE_FRAC - 16;
-	vphase <<= SUN8I_VI_SCALER_PHASE_FRAC - 16;
-	hscale <<= SUN8I_VI_SCALER_SCALE_FRAC - 16;
-	vscale <<= SUN8I_VI_SCALER_SCALE_FRAC - 16;
+	hphase <<= DE2_VI_SCALER_PHASE_FRAC - 16;
+	vphase <<= DE2_VI_SCALER_PHASE_FRAC - 16;
+	hscale <<= DE2_VI_SCALER_SCALE_FRAC - 16;
+	vscale <<= DE2_VI_SCALER_SCALE_FRAC - 16;
 
-	insize = SUN8I_VI_SCALER_SIZE(src_w, src_h);
-	outsize = SUN8I_VI_SCALER_SIZE(dst_w, dst_h);
+	insize = DE2_VI_SCALER_SIZE(src_w, src_h);
+	outsize = DE2_VI_SCALER_SIZE(dst_w, dst_h);
 
 	/*
 	 * This is chroma V/H phase calculation as it appears in
@@ -945,38 +944,38 @@ void sun8i_vi_scaler_setup(struct sun8i_mixer *mixer, int layer,
 	if (format->hsub == 2 && format->vsub == 2) {
 		chphase = hphase >> 1;
 		cvphase = (vphase >> 1) -
-			(1UL << (SUN8I_VI_SCALER_SCALE_FRAC - 2));
+			(1UL << (DE2_VI_SCALER_SCALE_FRAC - 2));
 	} else {
 		chphase = hphase;
 		cvphase = vphase;
 	}
 
 	regmap_write(mixer->engine.regs,
-		     SUN8I_SCALER_VSU_OUTSIZE(base), outsize);
+		     DE2_SCALER_VSU_OUTSIZE(base), outsize);
 	regmap_write(mixer->engine.regs,
-		     SUN8I_SCALER_VSU_YINSIZE(base), insize);
+		     DE2_SCALER_VSU_YINSIZE(base), insize);
 	regmap_write(mixer->engine.regs,
-		     SUN8I_SCALER_VSU_YHSTEP(base), hscale);
+		     DE2_SCALER_VSU_YHSTEP(base), hscale);
 	regmap_write(mixer->engine.regs,
-		     SUN8I_SCALER_VSU_YVSTEP(base), vscale);
+		     DE2_SCALER_VSU_YVSTEP(base), vscale);
 	regmap_write(mixer->engine.regs,
-		     SUN8I_SCALER_VSU_YHPHASE(base), hphase);
+		     DE2_SCALER_VSU_YHPHASE(base), hphase);
 	regmap_write(mixer->engine.regs,
-		     SUN8I_SCALER_VSU_YVPHASE(base), vphase);
+		     DE2_SCALER_VSU_YVPHASE(base), vphase);
 	regmap_write(mixer->engine.regs,
-		     SUN8I_SCALER_VSU_CINSIZE(base),
-		     SUN8I_VI_SCALER_SIZE(src_w / format->hsub,
-					  src_h / format->vsub));
+		     DE2_SCALER_VSU_CINSIZE(base),
+		     DE2_VI_SCALER_SIZE(src_w / format->hsub,
+					src_h / format->vsub));
 	regmap_write(mixer->engine.regs,
-		     SUN8I_SCALER_VSU_CHSTEP(base),
+		     DE2_SCALER_VSU_CHSTEP(base),
 		     hscale / format->hsub);
 	regmap_write(mixer->engine.regs,
-		     SUN8I_SCALER_VSU_CVSTEP(base),
+		     DE2_SCALER_VSU_CVSTEP(base),
 		     vscale / format->vsub);
 	regmap_write(mixer->engine.regs,
-		     SUN8I_SCALER_VSU_CHPHASE(base), chphase);
+		     DE2_SCALER_VSU_CHPHASE(base), chphase);
 	regmap_write(mixer->engine.regs,
-		     SUN8I_SCALER_VSU_CVPHASE(base), cvphase);
+		     DE2_SCALER_VSU_CVPHASE(base), cvphase);
 	sun8i_vi_scaler_set_coeff(mixer->engine.regs, base,
 				  hscale, vscale, format);
 }
diff --git a/drivers/gpu/drm/sun4i/sun8i_vi_scaler.h b/drivers/gpu/drm/sun4i/sun8i_vi_scaler.h
index f3de87122f07..b3168cae59b8 100644
--- a/drivers/gpu/drm/sun4i/sun8i_vi_scaler.h
+++ b/drivers/gpu/drm/sun4i/sun8i_vi_scaler.h
@@ -16,35 +16,35 @@
 #define DE2_VI_SCALER_UNIT_SIZE 0x20000
 
 /* this two macros assumes 16 fractional bits which is standard in DRM */
-#define SUN8I_VI_SCALER_SCALE_MIN		1
-#define SUN8I_VI_SCALER_SCALE_MAX		((1UL << 20) - 1)
-
-#define SUN8I_VI_SCALER_SCALE_FRAC		20
-#define SUN8I_VI_SCALER_PHASE_FRAC		20
-#define SUN8I_VI_SCALER_COEFF_COUNT		32
-#define SUN8I_VI_SCALER_SIZE(w, h)		(((h) - 1) << 16 | ((w) - 1))
-
-#define SUN8I_SCALER_VSU_CTRL(base)		((base) + 0x0)
-#define SUN8I_SCALER_VSU_OUTSIZE(base)		((base) + 0x40)
-#define SUN8I_SCALER_VSU_YINSIZE(base)		((base) + 0x80)
-#define SUN8I_SCALER_VSU_YHSTEP(base)		((base) + 0x88)
-#define SUN8I_SCALER_VSU_YVSTEP(base)		((base) + 0x8c)
-#define SUN8I_SCALER_VSU_YHPHASE(base)		((base) + 0x90)
-#define SUN8I_SCALER_VSU_YVPHASE(base)		((base) + 0x98)
-#define SUN8I_SCALER_VSU_CINSIZE(base)		((base) + 0xc0)
-#define SUN8I_SCALER_VSU_CHSTEP(base)		((base) + 0xc8)
-#define SUN8I_SCALER_VSU_CVSTEP(base)		((base) + 0xcc)
-#define SUN8I_SCALER_VSU_CHPHASE(base)		((base) + 0xd0)
-#define SUN8I_SCALER_VSU_CVPHASE(base)		((base) + 0xd8)
-#define SUN8I_SCALER_VSU_YHCOEFF0(base, i)	((base) + 0x200 + 0x4 * (i))
-#define SUN8I_SCALER_VSU_YHCOEFF1(base, i)	((base) + 0x300 + 0x4 * (i))
-#define SUN8I_SCALER_VSU_YVCOEFF(base, i)	((base) + 0x400 + 0x4 * (i))
-#define SUN8I_SCALER_VSU_CHCOEFF0(base, i)	((base) + 0x600 + 0x4 * (i))
-#define SUN8I_SCALER_VSU_CHCOEFF1(base, i)	((base) + 0x700 + 0x4 * (i))
-#define SUN8I_SCALER_VSU_CVCOEFF(base, i)	((base) + 0x800 + 0x4 * (i))
-
-#define SUN8I_SCALER_VSU_CTRL_EN		BIT(0)
-#define SUN8I_SCALER_VSU_CTRL_COEFF_RDY		BIT(4)
+#define DE2_VI_SCALER_SCALE_MIN			1
+#define DE2_VI_SCALER_SCALE_MAX			((1UL << 20) - 1)
+
+#define DE2_VI_SCALER_SCALE_FRAC		20
+#define DE2_VI_SCALER_PHASE_FRAC		20
+#define DE2_VI_SCALER_COEFF_COUNT		32
+#define DE2_VI_SCALER_SIZE(w, h)		(((h) - 1) << 16 | ((w) - 1))
+
+#define DE2_SCALER_VSU_CTRL(base)		((base) + 0x0)
+#define DE2_SCALER_VSU_OUTSIZE(base)		((base) + 0x40)
+#define DE2_SCALER_VSU_YINSIZE(base)		((base) + 0x80)
+#define DE2_SCALER_VSU_YHSTEP(base)		((base) + 0x88)
+#define DE2_SCALER_VSU_YVSTEP(base)		((base) + 0x8c)
+#define DE2_SCALER_VSU_YHPHASE(base)		((base) + 0x90)
+#define DE2_SCALER_VSU_YVPHASE(base)		((base) + 0x98)
+#define DE2_SCALER_VSU_CINSIZE(base)		((base) + 0xc0)
+#define DE2_SCALER_VSU_CHSTEP(base)		((base) + 0xc8)
+#define DE2_SCALER_VSU_CVSTEP(base)		((base) + 0xcc)
+#define DE2_SCALER_VSU_CHPHASE(base)		((base) + 0xd0)
+#define DE2_SCALER_VSU_CVPHASE(base)		((base) + 0xd8)
+#define DE2_SCALER_VSU_YHCOEFF0(base, i)	((base) + 0x200 + 0x4 * (i))
+#define DE2_SCALER_VSU_YHCOEFF1(base, i)	((base) + 0x300 + 0x4 * (i))
+#define DE2_SCALER_VSU_YVCOEFF(base, i)		((base) + 0x400 + 0x4 * (i))
+#define DE2_SCALER_VSU_CHCOEFF0(base, i)	((base) + 0x600 + 0x4 * (i))
+#define DE2_SCALER_VSU_CHCOEFF1(base, i)	((base) + 0x700 + 0x4 * (i))
+#define DE2_SCALER_VSU_CVCOEFF(base, i)		((base) + 0x800 + 0x4 * (i))
+
+#define DE2_SCALER_VSU_CTRL_EN			BIT(0)
+#define DE2_SCALER_VSU_CTRL_COEFF_RDY		BIT(4)
 
 void sun8i_vi_scaler_enable(struct sun8i_mixer *mixer, int layer, bool enable);
 void sun8i_vi_scaler_setup(struct sun8i_mixer *mixer, int layer,
-- 
2.19.0


_______________________________________________
dri-devel mailing list
dri-devel@xxxxxxxxxxxxxxxxxxxxx
https://lists.freedesktop.org/mailman/listinfo/dri-devel





[Index of Archives]     [Linux DRI Users]     [Linux Intel Graphics]     [Linux USB Devel]     [Video for Linux]     [Linux Audio Users]     [Yosemite News]     [Linux Kernel]     [Linux SCSI]     [XFree86]     [Linux USB Devel]     [Video for Linux]     [Linux Audio Users]     [Linux Kernel]     [Linux SCSI]     [XFree86]
  Powered by Linux