[libdrm] improvements to userspace exynos component

[libdrm] improvements to userspace exynos component

[Tobias Jakobi]

Hello,

here are some miscellaneous improvements (small features, bugfixes, spelling fixes, etc.) for the exynos component of libdrm. The general idea is to let userspace use the G2D engine functionality more 
efficiently.

If someone is interested in an application that actually makes use of this, the RetroArch frontend has a custom video backend:
https://github.com/libretro/RetroArch/blob/master/gfx/drivers/exynos_gfx.c


Please review and let me know what I can improve.

With best wishes,
Tobias

[PATCH 01/15] tests/exynos: fimg2d: add a checkerboard test

[Tobias Jakobi]

This makes it easier to spot memory corruptions which don't become
visible when using a plain buffer filled with a solid color (so
corruptions that are just a permutation of the bytes in the buffer).

Signed-off-by: Tobias Jakobi <tjakobi@math.uni-bielefeld.de>
---
 tests/exynos/exynos_fimg2d_test.c | 117 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 117 insertions(+)

diff --git a/tests/exynos/exynos_fimg2d_test.c b/tests/exynos/exynos_fimg2d_test.c
index c6bd558..41fb869 100644
--- a/tests/exynos/exynos_fimg2d_test.c
+++ b/tests/exynos/exynos_fimg2d_test.c
@@ -55,6 +55,9 @@ struct fimg2d_test_case {
 	int (*blend)(struct exynos_device *dev,
 				struct exynos_bo *src, struct exynos_bo *dst,
 				enum e_g2d_buf_type);
+	int (*checkerboard)(struct exynos_device *dev,
+				struct exynos_bo *src, struct exynos_bo *dst,
+				enum e_g2d_buf_type);
 };
 
 struct connector {
@@ -207,6 +210,33 @@ static struct exynos_bo *exynos_create_buffer(struct exynos_device *dev,
 	return bo;
 }
 
+/* Allocate buffer and fill it with checkerboard pattern, where the tiles *
+ * have a random color. The caller has to free the buffer.                */
+void *create_checkerboard_pattern(unsigned int num_tiles_x,
+						unsigned int num_tiles_y, unsigned int tile_size)
+{
+	unsigned int *buf;
+	unsigned int x, y, i, j;
+	const unsigned int stride = num_tiles_x * tile_size;
+
+	if (posix_memalign((void*)&buf, 64, num_tiles_y * tile_size * stride * 4) != 0)
+		return NULL;
+
+	for (x = 0; x < num_tiles_x; ++x) {
+		for (y = 0; y < num_tiles_y; ++y) {
+			const unsigned int color = 0xff000000 + (random() & 0xffffff);
+
+			for (i = 0; i < tile_size; ++i) {
+				for (j = 0; j < tile_size; ++j) {
+					buf[x * tile_size + y * stride * tile_size + i + j * stride] = color;
+				}
+			}
+		}
+	}
+
+	return buf;
+}
+
 static void exynos_destroy_buffer(struct exynos_bo *bo)
 {
 	exynos_bo_destroy(bo);
@@ -533,11 +563,90 @@ err_free_userptr:
 	return 0;
 }
 
+static int g2d_checkerboard_test(struct exynos_device *dev,
+					struct exynos_bo *src,
+					struct exynos_bo *dst,
+					enum e_g2d_buf_type type)
+{
+	struct g2d_context *ctx;
+	struct g2d_image src_img = {0}, dst_img = {0};
+	unsigned int src_x, src_y, dst_x, dst_y, img_w, img_h;
+	void *checkerboard = NULL;
+	int ret;
+
+	ctx = g2d_init(dev->fd);
+	if (!ctx)
+		return -EFAULT;
+
+	dst_img.bo[0] = dst->handle;
+
+	src_x = 0;
+	src_y = 0;
+	dst_x = 0;
+	dst_y = 0;
+
+	checkerboard = create_checkerboard_pattern(screen_width / 32, screen_height / 32, 32);
+	if (checkerboard == NULL) {
+		ret = -1;
+		goto fail;
+	}
+
+	img_w = screen_width - (screen_width % 32);
+	img_h = screen_height - (screen_height % 32);
+
+	switch (type) {
+	case G2D_IMGBUF_GEM:
+		memcpy(src->vaddr, checkerboard, img_w * img_h * 4);
+		src_img.bo[0] = src->handle;
+		break;
+	case G2D_IMGBUF_USERPTR:
+		src_img.user_ptr[0].userptr = (unsigned long)checkerboard;
+		src_img.user_ptr[0].size = img_w * img_h * 4;
+		break;
+	default:
+		ret = -EFAULT;
+		goto fail;
+	}
+
+	printf("checkerboard test with %s.\n",
+			type == G2D_IMGBUF_GEM ? "gem" : "userptr");
+
+	src_img.width = img_w;
+	src_img.height = img_h;
+	src_img.stride = src_img.width * 4;
+	src_img.buf_type = type;
+	src_img.color_mode = G2D_COLOR_FMT_ARGB8888 | G2D_ORDER_AXRGB;
+
+	dst_img.width = screen_width;
+	dst_img.height = screen_height;
+	dst_img.stride = dst_img.width * 4;
+	dst_img.buf_type = G2D_IMGBUF_GEM;
+	dst_img.color_mode = G2D_COLOR_FMT_ARGB8888 | G2D_ORDER_AXRGB;
+	src_img.color = 0xff000000;
+	ret = g2d_solid_fill(ctx, &dst_img, src_x, src_y, screen_width, screen_height);
+	if (ret < 0)
+		goto fail;
+
+	ret = g2d_copy(ctx, &src_img, &dst_img, src_x, src_y, dst_x, dst_y,
+			img_w, img_h);
+	if (ret < 0)
+		goto fail;
+
+	g2d_exec(ctx);
+
+fail:
+	free(checkerboard);
+	g2d_fini(ctx);
+
+	return ret;
+}
+
 static struct fimg2d_test_case test_case = {
 	.solid_fill = &g2d_solid_fill_test,
 	.copy = &g2d_copy_test,
 	.copy_with_scale = &g2d_copy_with_scale_test,
 	.blend = &g2d_blend_test,
+	.checkerboard = &g2d_checkerboard_test,
 };
 
 static void usage(char *name)
@@ -671,6 +780,14 @@ int main(int argc, char **argv)
 
 	getchar();
 
+	ret = test_case.checkerboard(dev, src, bo, G2D_IMGBUF_GEM);
+	if (ret < 0) {
+		fprintf(stderr, "failed to issue checkerboard test.\n");
+		goto err_free_src;
+	}
+
+	getchar();
+
 	ret  = test_case.blend(dev, src, bo, G2D_IMGBUF_USERPTR);
 	if (ret < 0)
 		fprintf(stderr, "failed to test blend operation.\n");
-- 
2.0.5

[PATCH 02/15] exynos: replace G2D_DOUBLE_TO_FIXED macro with function

[Tobias Jakobi]

This also avoids the floating point conversion steps and just
uses pure integer arithmetic.
Since the G2D hardware scaling approach is a bit unintuitive,
document it in the function as well.

Signed-off-by: Tobias Jakobi <tjakobi@math.uni-bielefeld.de>
---
 exynos/exynos_fimg2d.c | 19 ++++++++++++++-----
 exynos/fimg2d.h        |  2 --
 2 files changed, 14 insertions(+), 7 deletions(-)

diff --git a/exynos/exynos_fimg2d.c b/exynos/exynos_fimg2d.c
index ce1ba1e..d22c893 100644
--- a/exynos/exynos_fimg2d.c
+++ b/exynos/exynos_fimg2d.c
@@ -41,6 +41,15 @@
 
 #define MIN(a, b)	((a) < (b) ? (a) : (b))
 
+static unsigned int g2d_get_scaling(unsigned int src, unsigned int dst)
+{
+	/* The G2D hw scaling factor is a normalized inverse of the scaling factor. *
+	 * For example: When source width is 100 and destination width is 200       *
+	 * (scaling of 2x), then the hw factor is NORMALIZE_CONSTANT * 100 / 200.   */
+
+	return ((src << 16) / dst);
+}
+
 static unsigned int g2d_get_blend_op(enum e_g2d_op op)
 {
 	union g2d_blend_func_val val;
@@ -428,7 +437,7 @@ g2d_copy_with_scale(struct g2d_context *ctx, struct g2d_image *src,
 	union g2d_rop4_val rop4;
 	union g2d_point_val pt;
 	unsigned int scale;
-	double scale_x = 0.0f, scale_y = 0.0f;
+	unsigned int scale_x, scale_y;
 
 	g2d_add_cmd(ctx, DST_SELECT_REG, G2D_SELECT_MODE_BGCOLOR);
 	g2d_add_cmd(ctx, DST_COLOR_MODE_REG, dst->color_mode);
@@ -454,8 +463,8 @@ g2d_copy_with_scale(struct g2d_context *ctx, struct g2d_image *src,
 		scale = 0;
 	else {
 		scale = 1;
-		scale_x = (double)src_w / (double)dst_w;
-		scale_y = (double)src_h / (double)dst_h;
+		scale_x = g2d_get_scaling(src_w, dst_w);
+		scale_y = g2d_get_scaling(src_h, dst_h);
 	}
 
 	if (src_x + src_w > src->width)
@@ -487,8 +496,8 @@ g2d_copy_with_scale(struct g2d_context *ctx, struct g2d_image *src,
 
 	if (scale) {
 		g2d_add_cmd(ctx, SRC_SCALE_CTRL_REG, G2D_SCALE_MODE_BILINEAR);
-		g2d_add_cmd(ctx, SRC_XSCALE_REG, G2D_DOUBLE_TO_FIXED(scale_x));
-		g2d_add_cmd(ctx, SRC_YSCALE_REG, G2D_DOUBLE_TO_FIXED(scale_y));
+		g2d_add_cmd(ctx, SRC_XSCALE_REG, scale_x);
+		g2d_add_cmd(ctx, SRC_YSCALE_REG, scale_y);
 	}
 
 	pt.val = 0;
diff --git a/exynos/fimg2d.h b/exynos/fimg2d.h
index 4785e2f..8e0321c 100644
--- a/exynos/fimg2d.h
+++ b/exynos/fimg2d.h
@@ -25,8 +25,6 @@
 #define G2D_MAX_CMD_LIST_NR	64
 #define G2D_PLANE_MAX_NR	2
 
-#define G2D_DOUBLE_TO_FIXED(d)		((unsigned int)((d) * 65536.0))
-
 enum e_g2d_color_mode {
 	/* COLOR FORMAT */
 	G2D_COLOR_FMT_XRGB8888,
-- 
2.0.5

[PATCH 03/15] tests/exynos: fix typos and change wording

[Tobias Jakobi]

No functional changes.

Signed-off-by: Tobias Jakobi <tjakobi@math.uni-bielefeld.de>
---
 exynos/exynos_fimg2d.c            | 8 ++++----
 tests/exynos/exynos_fimg2d_test.c | 4 ++--
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/exynos/exynos_fimg2d.c b/exynos/exynos_fimg2d.c
index d22c893..e7b00b1 100644
--- a/exynos/exynos_fimg2d.c
+++ b/exynos/exynos_fimg2d.c
@@ -145,13 +145,13 @@ static void g2d_reset(struct g2d_context *ctx)
 }
 
 /*
- * g2d_flush - summit all commands and values in user side command buffer
+ * g2d_flush - submit all commands and values in user side command buffer
  *		to command queue aware of fimg2d dma.
  *
  * @ctx: a pointer to g2d_context structure.
  *
  * This function should be called after all commands and values to user
- * side command buffer is set to summit that buffer to kernel side driver.
+ * side command buffer are set. It submits that buffer to the kernel side driver.
  */
 static int g2d_flush(struct g2d_context *ctx)
 {
@@ -192,7 +192,7 @@ static int g2d_flush(struct g2d_context *ctx)
 /**
  * g2d_init - create a new g2d context and get hardware version.
  *
- * fd: a file descriptor to drm device driver opened.
+ * fd: a file descriptor to an opened drm device.
  */
 drm_public struct g2d_context *g2d_init(int fd)
 {
@@ -524,7 +524,7 @@ g2d_copy_with_scale(struct g2d_context *ctx, struct g2d_image *src,
 }
 
 /**
- * g2d_blend - blend image data in source and destion buffers
+ * g2d_blend - blend image data in source and destination buffers.
  *
  * @ctx: a pointer to g2d_context structure.
  * @src: a pointer to g2d_image structure including image and buffer
diff --git a/tests/exynos/exynos_fimg2d_test.c b/tests/exynos/exynos_fimg2d_test.c
index 41fb869..aa140e5 100644
--- a/tests/exynos/exynos_fimg2d_test.c
+++ b/tests/exynos/exynos_fimg2d_test.c
@@ -39,7 +39,7 @@ static unsigned int screen_width, screen_height;
 /*
  * A structure to test fimg2d hw.
  *
- * @solid_fild: fill given color data to source buffer.
+ * @solid_fill: fill given color data to source buffer.
  * @copy: copy source to destination buffer.
  * @copy_with_scale: copy source to destination buffer scaling up or
  *	down properly.
@@ -256,7 +256,7 @@ static int g2d_solid_fill_test(struct exynos_device *dev, struct exynos_bo *dst)
 	memset(&img, 0, sizeof(struct g2d_image));
 	img.bo[0] = dst->handle;
 
-	printf("soild fill test.\n");
+	printf("solid fill test.\n");
 
 	srand(time(NULL));
 	img_w = screen_width;
-- 
2.0.5

[PATCH 04/15] tests/exynos: disable the G2D userptr/blend test

[Tobias Jakobi]

The blend test uses the userptr functionality of exynos-drm, which
is currently not safe to use. If the kernel hasn't been build with
exynos-iommu support, then the blend test is going to produce (kernel)
memory corruption, eventually leading to a system crash.

Disable the test for now, until the kernel code has been sanitized.

Signed-off-by: Tobias Jakobi <tjakobi@math.uni-bielefeld.de>
---
 tests/exynos/exynos_fimg2d_test.c | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tests/exynos/exynos_fimg2d_test.c b/tests/exynos/exynos_fimg2d_test.c
index aa140e5..48dfe97 100644
--- a/tests/exynos/exynos_fimg2d_test.c
+++ b/tests/exynos/exynos_fimg2d_test.c
@@ -788,11 +788,13 @@ int main(int argc, char **argv)
 
 	getchar();
 
+#if 0
 	ret  = test_case.blend(dev, src, bo, G2D_IMGBUF_USERPTR);
 	if (ret < 0)
 		fprintf(stderr, "failed to test blend operation.\n");
 
 	getchar();
+#endif
 
 err_free_src:
 	if (src)
-- 
2.0.5

[PATCH 05/15] exynos: add g2d_scale_and_blend

[Tobias Jakobi]

This is a combination of g2d_copy_with_scale and g2d_scale.
It is a pretty common operation to scale one buffer and then
blend it on top of another, so provide a direct way to that
operation.

Signed-off-by: Tobias Jakobi <tjakobi@math.uni-bielefeld.de>
---
 exynos/exynos_fimg2d.c | 129 +++++++++++++++++++++++++++++++++++++++++++++++++
 exynos/fimg2d.h        |   5 ++
 2 files changed, 134 insertions(+)

diff --git a/exynos/exynos_fimg2d.c b/exynos/exynos_fimg2d.c
index e7b00b1..d6ad9a7 100644
--- a/exynos/exynos_fimg2d.c
+++ b/exynos/exynos_fimg2d.c
@@ -642,3 +642,132 @@ g2d_blend(struct g2d_context *ctx, struct g2d_image *src,
 	return 0;
 }
 
+/**
+ * g2d_scale_and_blend - apply scaling to source buffer and then blend to destination buffer
+ *
+ * @ctx: a pointer to g2d_context structure.
+ * @src: a pointer to g2d_image structure including image and buffer
+ *	information to source.
+ * @dst: a pointer to g2d_image structure including image and buffer
+ *	information to destination.
+ * @src_x: x start position to source buffer.
+ * @src_y: y start position to source buffer.
+ * @src_w: width value to source buffer.
+ * @src_h: height value to source buffer.
+ * @dst_x: x start position to destination buffer.
+ * @dst_y: y start position to destination buffer.
+ * @dst_w: width value to destination buffer.
+ * @dst_h: height value to destination buffer.
+ * @op: blend operation type.
+ */
+drm_public int
+g2d_scale_and_blend(struct g2d_context *ctx, struct g2d_image *src,
+		struct g2d_image *dst, unsigned int src_x, unsigned int src_y,
+		unsigned int src_w, unsigned int src_h, unsigned int dst_x,
+		unsigned int dst_y, unsigned int dst_w, unsigned int dst_h,
+		enum e_g2d_op op)
+{
+	union g2d_point_val pt;
+	union g2d_bitblt_cmd_val bitblt;
+	union g2d_blend_func_val blend;
+	unsigned int scale;
+	unsigned int scale_x, scale_y;
+
+	bitblt.val = 0;
+	blend.val = 0;
+
+	if (op == G2D_OP_SRC || op == G2D_OP_CLEAR)
+		g2d_add_cmd(ctx, DST_SELECT_REG, G2D_SELECT_MODE_BGCOLOR);
+	else
+		g2d_add_cmd(ctx, DST_SELECT_REG, G2D_SELECT_MODE_NORMAL);
+
+	g2d_add_cmd(ctx, DST_COLOR_MODE_REG, dst->color_mode);
+	if (dst->buf_type == G2D_IMGBUF_USERPTR)
+		g2d_add_cmd(ctx, DST_BASE_ADDR_REG | G2D_BUF_USERPTR,
+				(unsigned long)&dst->user_ptr[0]);
+	else
+		g2d_add_cmd(ctx, DST_BASE_ADDR_REG, dst->bo[0]);
+
+	g2d_add_cmd(ctx, DST_STRIDE_REG, dst->stride);
+
+	g2d_add_cmd(ctx, SRC_SELECT_REG, src->select_mode);
+	g2d_add_cmd(ctx, SRC_COLOR_MODE_REG, src->color_mode);
+
+	switch (src->select_mode) {
+	case G2D_SELECT_MODE_NORMAL:
+		if (src->buf_type == G2D_IMGBUF_USERPTR)
+			g2d_add_cmd(ctx, SRC_BASE_ADDR_REG | G2D_BUF_USERPTR,
+					(unsigned long)&src->user_ptr[0]);
+		else
+			g2d_add_cmd(ctx, SRC_BASE_ADDR_REG, src->bo[0]);
+
+		g2d_add_cmd(ctx, SRC_STRIDE_REG, src->stride);
+		break;
+	case G2D_SELECT_MODE_FGCOLOR:
+		g2d_add_cmd(ctx, FG_COLOR_REG, src->color);
+		break;
+	case G2D_SELECT_MODE_BGCOLOR:
+		g2d_add_cmd(ctx, BG_COLOR_REG, src->color);
+		break;
+	default:
+		fprintf(stderr , "failed to set src.\n");
+		return -EINVAL;
+	}
+
+	if (src_w == dst_w && src_h == dst_h)
+		scale = 0;
+	else {
+		scale = 1;
+		scale_x = g2d_get_scaling(src_w, dst_w);
+		scale_y = g2d_get_scaling(src_h, dst_h);
+	}
+
+	if (src_x + src_w > src->width)
+		src_w = src->width - src_x;
+	if (src_y + src_h > src->height)
+		src_h = src->height - src_y;
+
+	if (dst_x + dst_w > dst->width)
+		dst_w = dst->width - dst_x;
+	if (dst_y + dst_h > dst->height)
+		dst_h = dst->height - dst_y;
+
+	if (src_w <= 0 || src_h <= 0 || dst_w <= 0 || dst_h <= 0) {
+		fprintf(stderr, "invalid width or height.\n");
+		g2d_reset(ctx);
+		return -EINVAL;
+	}
+
+	if (scale) {
+		g2d_add_cmd(ctx, SRC_SCALE_CTRL_REG, G2D_SCALE_MODE_BILINEAR);
+		g2d_add_cmd(ctx, SRC_XSCALE_REG, scale_x);
+		g2d_add_cmd(ctx, SRC_YSCALE_REG, scale_y);
+	}
+
+	bitblt.data.alpha_blend_mode = G2D_ALPHA_BLEND_MODE_ENABLE;
+	blend.val = g2d_get_blend_op(op);
+	g2d_add_cmd(ctx, BITBLT_COMMAND_REG, bitblt.val);
+	g2d_add_cmd(ctx, BLEND_FUNCTION_REG, blend.val);
+
+	pt.val = 0;
+	pt.data.x = src_x;
+	pt.data.y = src_y;
+	g2d_add_cmd(ctx, SRC_LEFT_TOP_REG, pt.val);
+	pt.val = 0;
+	pt.data.x = src_x + src_w;
+	pt.data.y = src_y + src_h;
+	g2d_add_cmd(ctx, SRC_RIGHT_BOTTOM_REG, pt.val);
+
+	pt.val = 0;
+	pt.data.x = dst_x;
+	pt.data.y = dst_y;
+	g2d_add_cmd(ctx, DST_LEFT_TOP_REG, pt.val);
+	pt.val = 0;
+	pt.data.x = dst_x + dst_w;
+	pt.data.y = dst_y + dst_h;
+	g2d_add_cmd(ctx, DST_RIGHT_BOTTOM_REG, pt.val);
+
+	g2d_flush(ctx);
+
+	return 0;
+}
diff --git a/exynos/fimg2d.h b/exynos/fimg2d.h
index 8e0321c..bd116cf 100644
--- a/exynos/fimg2d.h
+++ b/exynos/fimg2d.h
@@ -320,4 +320,9 @@ int g2d_blend(struct g2d_context *ctx, struct g2d_image *src,
 		struct g2d_image *dst, unsigned int src_x,
 		unsigned int src_y, unsigned int dst_x, unsigned int dst_y,
 		unsigned int w, unsigned int h, enum e_g2d_op op);
+int g2d_scale_and_blend(struct g2d_context *ctx, struct g2d_image *src,
+		struct g2d_image *dst, unsigned int src_x, unsigned int src_y,
+		unsigned int src_w, unsigned int src_h, unsigned int dst_x,
+		unsigned int dst_y, unsigned int dst_w, unsigned int dst_h,
+		enum e_g2d_op op);
 #endif /* _FIMG2D_H_ */
-- 
2.0.5

[PATCH 06/15] tests/exynos: introduce wait_for_user_input

[Tobias Jakobi]

Currently getchar() is used to pause execution after each test.
The user isn't informed if one is supposed to do anything for
the tests to continue, so print a simple message to make this
more clear.

Signed-off-by: Tobias Jakobi <tjakobi@math.uni-bielefeld.de>
---
 tests/exynos/exynos_fimg2d_test.c | 20 ++++++++++++++++----
 1 file changed, 16 insertions(+), 4 deletions(-)

diff --git a/tests/exynos/exynos_fimg2d_test.c b/tests/exynos/exynos_fimg2d_test.c
index 48dfe97..20b8e9d 100644
--- a/tests/exynos/exynos_fimg2d_test.c
+++ b/tests/exynos/exynos_fimg2d_test.c
@@ -237,6 +237,18 @@ void *create_checkerboard_pattern(unsigned int num_tiles_x,
 	return buf;
 }
 
+static void wait_for_user_input(int last)
+{
+	printf("press <ENTER> to ");
+
+	if (last)
+		printf("exit test application\n");
+	else
+		printf("skip to next test\n");
+
+	getchar();
+}
+
 static void exynos_destroy_buffer(struct exynos_bo *bo)
 {
 	exynos_bo_destroy(bo);
@@ -756,7 +768,7 @@ int main(int argc, char **argv)
 		goto err_rm_fb;
 	}
 
-	getchar();
+	wait_for_user_input(0);
 
 	src = exynos_create_buffer(dev, screen_width * screen_height * 4, 0);
 	if (!src) {
@@ -770,7 +782,7 @@ int main(int argc, char **argv)
 		goto err_free_src;
 	}
 
-	getchar();
+	wait_for_user_input(0);
 
 	ret = test_case.copy_with_scale(dev, src, bo, G2D_IMGBUF_GEM);
 	if (ret < 0) {
@@ -778,7 +790,7 @@ int main(int argc, char **argv)
 		goto err_free_src;
 	}
 
-	getchar();
+	wait_for_user_input(0);
 
 	ret = test_case.checkerboard(dev, src, bo, G2D_IMGBUF_GEM);
 	if (ret < 0) {
@@ -786,7 +798,7 @@ int main(int argc, char **argv)
 		goto err_free_src;
 	}
 
-	getchar();
+	wait_for_user_input(1);
 
 #if 0
 	ret  = test_case.blend(dev, src, bo, G2D_IMGBUF_USERPTR);
-- 
2.0.5

[PATCH 07/15] exynos: honor the repeat mode in g2d_copy_with_scale

[Tobias Jakobi]

This is useful when the default repeat mode, which is 'repeat'
produces artifacts at the borders of the copied image.
Choose the 'pad' mode to make use of the color of the destination
image.

In my usage case the destination is the framebuffer, which is
solid filled with a background color. Scaling with 'pad' mode
would then just do the right thing and also produces nice
borders on the output.

Signed-off-by: Tobias Jakobi <tjakobi@math.uni-bielefeld.de>
---
 exynos/exynos_fimg2d.c | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/exynos/exynos_fimg2d.c b/exynos/exynos_fimg2d.c
index d6ad9a7..eae6223 100644
--- a/exynos/exynos_fimg2d.c
+++ b/exynos/exynos_fimg2d.c
@@ -451,6 +451,11 @@ g2d_copy_with_scale(struct g2d_context *ctx, struct g2d_image *src,
 
 	g2d_add_cmd(ctx, SRC_SELECT_REG, G2D_SELECT_MODE_NORMAL);
 	g2d_add_cmd(ctx, SRC_COLOR_MODE_REG, src->color_mode);
+
+	g2d_add_cmd(ctx, SRC_REPEAT_MODE_REG, src->repeat_mode);
+	if (src->repeat_mode == G2D_REPEAT_MODE_PAD)
+		g2d_add_cmd(ctx, SRC_PAD_VALUE_REG, dst->color);
+
 	if (src->buf_type == G2D_IMGBUF_USERPTR)
 		g2d_add_cmd(ctx, SRC_BASE_ADDR_REG | G2D_BUF_USERPTR,
 				(unsigned long)&src->user_ptr[0]);
-- 
2.0.5

[PATCH 08/15] exynos: introduce g2d_add_base_addr helper function

[Tobias Jakobi]

In almost all functions the base address register is written, so it
makes sense to have a helper function for this.

Signed-off-by: Tobias Jakobi <tjakobi@math.uni-bielefeld.de>
---
 exynos/exynos_fimg2d.c | 87 +++++++++++++++++++-------------------------------
 1 file changed, 33 insertions(+), 54 deletions(-)

diff --git a/exynos/exynos_fimg2d.c b/exynos/exynos_fimg2d.c
index eae6223..7b76eb6 100644
--- a/exynos/exynos_fimg2d.c
+++ b/exynos/exynos_fimg2d.c
@@ -41,6 +41,11 @@
 
 #define MIN(a, b)	((a) < (b) ? (a) : (b))
 
+enum g2d_base_addr_reg {
+	g2d_dst = 0,
+	g2d_src
+};
+
 static unsigned int g2d_get_scaling(unsigned int src, unsigned int dst)
 {
 	/* The G2D hw scaling factor is a normalized inverse of the scaling factor. *
@@ -131,6 +136,25 @@ static int g2d_add_cmd(struct g2d_context *ctx, unsigned long cmd,
 }
 
 /*
+ * g2d_add_base_addr - helper function to set dst/src base address register.
+ *
+ * @ctx: a pointer to g2d_context structure.
+ * @img: a pointer to the dst/src g2d_image structure.
+ * @reg: the register that should be set.
+ */
+static void g2d_add_base_addr(struct g2d_context *ctx, struct g2d_image *img,
+			enum g2d_base_addr_reg reg)
+{
+	const unsigned long cmd = (reg == g2d_dst) ? DST_BASE_ADDR_REG : SRC_BASE_ADDR_REG;
+
+	if (img->buf_type == G2D_IMGBUF_USERPTR)
+		g2d_add_cmd(ctx, cmd | G2D_BUF_USERPTR,
+				(unsigned long)&img->user_ptr[0]);
+	else
+		g2d_add_cmd(ctx, cmd, img->bo[0]);
+}
+
+/*
  * g2d_reset - reset fimg2d hardware.
  *
  * @ctx: a pointer to g2d_context structure.
@@ -275,13 +299,7 @@ g2d_solid_fill(struct g2d_context *ctx, struct g2d_image *img,
 
 	g2d_add_cmd(ctx, DST_SELECT_REG, G2D_SELECT_MODE_NORMAL);
 	g2d_add_cmd(ctx, DST_COLOR_MODE_REG, img->color_mode);
-
-	if (img->buf_type == G2D_IMGBUF_USERPTR)
-		g2d_add_cmd(ctx, DST_BASE_ADDR_REG | G2D_BUF_USERPTR,
-				(unsigned long)&img->user_ptr[0]);
-	else
-		g2d_add_cmd(ctx, DST_BASE_ADDR_REG, img->bo[0]);
-
+	g2d_add_base_addr(ctx, img, g2d_dst);
 	g2d_add_cmd(ctx, DST_STRIDE_REG, img->stride);
 
 	if (x + w > img->width)
@@ -338,22 +356,12 @@ g2d_copy(struct g2d_context *ctx, struct g2d_image *src,
 
 	g2d_add_cmd(ctx, DST_SELECT_REG, G2D_SELECT_MODE_BGCOLOR);
 	g2d_add_cmd(ctx, DST_COLOR_MODE_REG, dst->color_mode);
-	if (dst->buf_type == G2D_IMGBUF_USERPTR)
-		g2d_add_cmd(ctx, DST_BASE_ADDR_REG | G2D_BUF_USERPTR,
-				(unsigned long)&dst->user_ptr[0]);
-	else
-		g2d_add_cmd(ctx, DST_BASE_ADDR_REG, dst->bo[0]);
-
+	g2d_add_base_addr(ctx, dst, g2d_dst);
 	g2d_add_cmd(ctx, DST_STRIDE_REG, dst->stride);
 
 	g2d_add_cmd(ctx, SRC_SELECT_REG, G2D_SELECT_MODE_NORMAL);
 	g2d_add_cmd(ctx, SRC_COLOR_MODE_REG, src->color_mode);
-	if (src->buf_type == G2D_IMGBUF_USERPTR)
-		g2d_add_cmd(ctx, SRC_BASE_ADDR_REG | G2D_BUF_USERPTR,
-				(unsigned long)&src->user_ptr[0]);
-	else
-		g2d_add_cmd(ctx, SRC_BASE_ADDR_REG, src->bo[0]);
-
+	g2d_add_base_addr(ctx, src, g2d_src);
 	g2d_add_cmd(ctx, SRC_STRIDE_REG, src->stride);
 
 	src_w = w;
@@ -441,12 +449,7 @@ g2d_copy_with_scale(struct g2d_context *ctx, struct g2d_image *src,
 
 	g2d_add_cmd(ctx, DST_SELECT_REG, G2D_SELECT_MODE_BGCOLOR);
 	g2d_add_cmd(ctx, DST_COLOR_MODE_REG, dst->color_mode);
-	if (dst->buf_type == G2D_IMGBUF_USERPTR)
-		g2d_add_cmd(ctx, DST_BASE_ADDR_REG | G2D_BUF_USERPTR,
-				(unsigned long)&dst->user_ptr[0]);
-	else
-		g2d_add_cmd(ctx, DST_BASE_ADDR_REG, dst->bo[0]);
-
+	g2d_add_base_addr(ctx, dst, g2d_dst);
 	g2d_add_cmd(ctx, DST_STRIDE_REG, dst->stride);
 
 	g2d_add_cmd(ctx, SRC_SELECT_REG, G2D_SELECT_MODE_NORMAL);
@@ -456,11 +459,7 @@ g2d_copy_with_scale(struct g2d_context *ctx, struct g2d_image *src,
 	if (src->repeat_mode == G2D_REPEAT_MODE_PAD)
 		g2d_add_cmd(ctx, SRC_PAD_VALUE_REG, dst->color);
 
-	if (src->buf_type == G2D_IMGBUF_USERPTR)
-		g2d_add_cmd(ctx, SRC_BASE_ADDR_REG | G2D_BUF_USERPTR,
-				(unsigned long)&src->user_ptr[0]);
-	else
-		g2d_add_cmd(ctx, SRC_BASE_ADDR_REG, src->bo[0]);
+	g2d_add_base_addr(ctx, src, g2d_src);
 
 	g2d_add_cmd(ctx, SRC_STRIDE_REG, src->stride);
 
@@ -564,12 +563,7 @@ g2d_blend(struct g2d_context *ctx, struct g2d_image *src,
 		g2d_add_cmd(ctx, DST_SELECT_REG, G2D_SELECT_MODE_NORMAL);
 
 	g2d_add_cmd(ctx, DST_COLOR_MODE_REG, dst->color_mode);
-	if (dst->buf_type == G2D_IMGBUF_USERPTR)
-		g2d_add_cmd(ctx, DST_BASE_ADDR_REG | G2D_BUF_USERPTR,
-				(unsigned long)&dst->user_ptr[0]);
-	else
-		g2d_add_cmd(ctx, DST_BASE_ADDR_REG, dst->bo[0]);
-
+	g2d_add_base_addr(ctx, dst, g2d_dst);
 	g2d_add_cmd(ctx, DST_STRIDE_REG, dst->stride);
 
 	g2d_add_cmd(ctx, SRC_SELECT_REG, src->select_mode);
@@ -577,12 +571,7 @@ g2d_blend(struct g2d_context *ctx, struct g2d_image *src,
 
 	switch (src->select_mode) {
 	case G2D_SELECT_MODE_NORMAL:
-		if (src->buf_type == G2D_IMGBUF_USERPTR)
-			g2d_add_cmd(ctx, SRC_BASE_ADDR_REG | G2D_BUF_USERPTR,
-					(unsigned long)&src->user_ptr[0]);
-		else
-			g2d_add_cmd(ctx, SRC_BASE_ADDR_REG, src->bo[0]);
-
+		g2d_add_base_addr(ctx, src, g2d_src);
 		g2d_add_cmd(ctx, SRC_STRIDE_REG, src->stride);
 		break;
 	case G2D_SELECT_MODE_FGCOLOR:
@@ -687,12 +676,7 @@ g2d_scale_and_blend(struct g2d_context *ctx, struct g2d_image *src,
 		g2d_add_cmd(ctx, DST_SELECT_REG, G2D_SELECT_MODE_NORMAL);
 
 	g2d_add_cmd(ctx, DST_COLOR_MODE_REG, dst->color_mode);
-	if (dst->buf_type == G2D_IMGBUF_USERPTR)
-		g2d_add_cmd(ctx, DST_BASE_ADDR_REG | G2D_BUF_USERPTR,
-				(unsigned long)&dst->user_ptr[0]);
-	else
-		g2d_add_cmd(ctx, DST_BASE_ADDR_REG, dst->bo[0]);
-
+	g2d_add_base_addr(ctx, dst, g2d_dst);
 	g2d_add_cmd(ctx, DST_STRIDE_REG, dst->stride);
 
 	g2d_add_cmd(ctx, SRC_SELECT_REG, src->select_mode);
@@ -700,12 +684,7 @@ g2d_scale_and_blend(struct g2d_context *ctx, struct g2d_image *src,
 
 	switch (src->select_mode) {
 	case G2D_SELECT_MODE_NORMAL:
-		if (src->buf_type == G2D_IMGBUF_USERPTR)
-			g2d_add_cmd(ctx, SRC_BASE_ADDR_REG | G2D_BUF_USERPTR,
-					(unsigned long)&src->user_ptr[0]);
-		else
-			g2d_add_cmd(ctx, SRC_BASE_ADDR_REG, src->bo[0]);
-
+		g2d_add_base_addr(ctx, src, g2d_src);
 		g2d_add_cmd(ctx, SRC_STRIDE_REG, src->stride);
 		break;
 	case G2D_SELECT_MODE_FGCOLOR:
-- 
2.0.5

[PATCH 09/15] exynos: use structure initialization instead of memset

[Tobias Jakobi]

Keeps the code cleaner, since the structs have to be initialized
once anyway.

Signed-off-by: Tobias Jakobi <tjakobi@math.uni-bielefeld.de>
---
 exynos/exynos_fimg2d.c            |  4 +---
 tests/exynos/exynos_fimg2d_test.c | 15 ++++-----------
 2 files changed, 5 insertions(+), 14 deletions(-)

diff --git a/exynos/exynos_fimg2d.c b/exynos/exynos_fimg2d.c
index 7b76eb6..c609053 100644
--- a/exynos/exynos_fimg2d.c
+++ b/exynos/exynos_fimg2d.c
@@ -180,7 +180,7 @@ static void g2d_reset(struct g2d_context *ctx)
 static int g2d_flush(struct g2d_context *ctx)
 {
 	int ret;
-	struct drm_exynos_g2d_set_cmdlist cmdlist;
+	struct drm_exynos_g2d_set_cmdlist cmdlist = {0};
 
 	if (ctx->cmd_nr  == 0 && ctx->cmd_buf_nr == 0)
 		return FALSE;
@@ -190,8 +190,6 @@ static int g2d_flush(struct g2d_context *ctx)
 		return -EINVAL;
 	}
 
-	memset(&cmdlist, 0, sizeof(struct drm_exynos_g2d_set_cmdlist));
-
 	cmdlist.cmd = (uint64_t)(uintptr_t)&ctx->cmd[0];
 	cmdlist.cmd_buf = (uint64_t)(uintptr_t)&ctx->cmd_buf[0];
 	cmdlist.cmd_nr = ctx->cmd_nr;
diff --git a/tests/exynos/exynos_fimg2d_test.c b/tests/exynos/exynos_fimg2d_test.c
index 20b8e9d..cb021ac 100644
--- a/tests/exynos/exynos_fimg2d_test.c
+++ b/tests/exynos/exynos_fimg2d_test.c
@@ -257,7 +257,7 @@ static void exynos_destroy_buffer(struct exynos_bo *bo)
 static int g2d_solid_fill_test(struct exynos_device *dev, struct exynos_bo *dst)
 {
 	struct g2d_context *ctx;
-	struct g2d_image img;
+	struct g2d_image img = {0};
 	unsigned int count, img_w, img_h;
 	int ret = 0;
 
@@ -265,7 +265,6 @@ static int g2d_solid_fill_test(struct exynos_device *dev, struct exynos_bo *dst)
 	if (!ctx)
 		return -EFAULT;
 
-	memset(&img, 0, sizeof(struct g2d_image));
 	img.bo[0] = dst->handle;
 
 	printf("solid fill test.\n");
@@ -308,7 +307,7 @@ static int g2d_copy_test(struct exynos_device *dev, struct exynos_bo *src,
 				enum e_g2d_buf_type type)
 {
 	struct g2d_context *ctx;
-	struct g2d_image src_img, dst_img;
+	struct g2d_image src_img = {0}, dst_img = {0};
 	unsigned int count;
 	unsigned int src_x, src_y, dst_x, dst_y, img_w, img_h;
 	unsigned long userptr, size;
@@ -318,8 +317,6 @@ static int g2d_copy_test(struct exynos_device *dev, struct exynos_bo *src,
 	if (!ctx)
 		return -EFAULT;
 
-	memset(&src_img, 0, sizeof(struct g2d_image));
-	memset(&dst_img, 0, sizeof(struct g2d_image));
 	dst_img.bo[0] = dst->handle;
 
 	src_x = 0;
@@ -392,7 +389,7 @@ static int g2d_copy_with_scale_test(struct exynos_device *dev,
 					enum e_g2d_buf_type type)
 {
 	struct g2d_context *ctx;
-	struct g2d_image src_img, dst_img;
+	struct g2d_image src_img = {0}, dst_img = {0};
 	unsigned int count;
 	unsigned int src_x, src_y, dst_x, dst_y, img_w, img_h;
 	unsigned long userptr, size;
@@ -402,8 +399,6 @@ static int g2d_copy_with_scale_test(struct exynos_device *dev,
 	if (!ctx)
 		return -EFAULT;
 
-	memset(&src_img, 0, sizeof(struct g2d_image));
-	memset(&dst_img, 0, sizeof(struct g2d_image));
 	dst_img.bo[0] = dst->handle;
 
 	src_x = 0;
@@ -481,7 +476,7 @@ static int g2d_blend_test(struct exynos_device *dev,
 					enum e_g2d_buf_type type)
 {
 	struct g2d_context *ctx;
-	struct g2d_image src_img, dst_img;
+	struct g2d_image src_img = {0}, dst_img = {0};
 	unsigned int count;
 	unsigned int src_x, src_y, dst_x, dst_y, img_w, img_h;
 	unsigned long userptr, size;
@@ -491,8 +486,6 @@ static int g2d_blend_test(struct exynos_device *dev,
 	if (!ctx)
 		return -EFAULT;
 
-	memset(&src_img, 0, sizeof(struct g2d_image));
-	memset(&dst_img, 0, sizeof(struct g2d_image));
 	dst_img.bo[0] = dst->handle;
 
 	src_x = 0;
-- 
2.0.5

[PATCH 10/15] tests/exynos: improve error handling

[Tobias Jakobi]

Check for a useable connector and also if the resolution is sane
(width and height are both non-zero).

Signed-off-by: Tobias Jakobi <tjakobi@math.uni-bielefeld.de>
---
 tests/exynos/exynos_fimg2d_test.c | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/tests/exynos/exynos_fimg2d_test.c b/tests/exynos/exynos_fimg2d_test.c
index cb021ac..d68f3d1 100644
--- a/tests/exynos/exynos_fimg2d_test.c
+++ b/tests/exynos/exynos_fimg2d_test.c
@@ -725,10 +725,22 @@ int main(int argc, char **argv)
 	connector_find_mode(dev->fd, &con, resources);
 	drmModeFreeResources(resources);
 
+	if (!con.mode) {
+		fprintf(stderr, "failed to find usable connector\n");
+		ret = -EFAULT;
+		goto err_drm_close;
+	}
+
 	screen_width = con.mode->hdisplay;
 	screen_height = con.mode->vdisplay;
 
-	printf("screen width  = %d, screen height = %d\n", screen_width,
+	if (screen_width == 0 || screen_height == 0) {
+		fprintf(stderr, "failed to find sane resolution on connector\n");
+		ret = -EFAULT;
+		goto err_drm_close;
+	}
+
+	printf("screen width = %d, screen height = %d\n", screen_width,
 			screen_height);
 
 	bo = exynos_create_buffer(dev, screen_width * screen_height * 4, 0);
-- 
2.0.5

[PATCH 11/15] exynos: add exynos prefix to fimg2d header

[Tobias Jakobi]

Signed-off-by: Tobias Jakobi <tjakobi@math.uni-bielefeld.de>
---
 exynos/Makefile.am                |   2 +-
 exynos/exynos_fimg2d.c            |   2 +-
 exynos/exynos_fimg2d.h            | 328 ++++++++++++++++++++++++++++++++++++++
 exynos/fimg2d.h                   | 328 --------------------------------------
 tests/exynos/exynos_fimg2d_test.c |   2 +-
 5 files changed, 331 insertions(+), 331 deletions(-)
 create mode 100644 exynos/exynos_fimg2d.h
 delete mode 100644 exynos/fimg2d.h

diff --git a/exynos/Makefile.am b/exynos/Makefile.am
index 06bee00..1715a85 100644
--- a/exynos/Makefile.am
+++ b/exynos/Makefile.am
@@ -14,7 +14,7 @@ libdrm_exynos_la_LIBADD = ../libdrm.la @PTHREADSTUBS_LIBS@
 libdrm_exynos_la_SOURCES = \
 	exynos_drm.c \
 	exynos_fimg2d.c \
-	fimg2d.h \
+	exynos_fimg2d.h \
 	fimg2d_reg.h
 
 libdrm_exynoscommonincludedir = ${includedir}/exynos
diff --git a/exynos/exynos_fimg2d.c b/exynos/exynos_fimg2d.c
index c609053..1b0bfdf 100644
--- a/exynos/exynos_fimg2d.c
+++ b/exynos/exynos_fimg2d.c
@@ -27,7 +27,7 @@
 #include "libdrm.h"
 #include "exynos_drm.h"
 #include "fimg2d_reg.h"
-#include "fimg2d.h"
+#include "exynos_fimg2d.h"
 
 #define		SET_BF(val, sc, si, scsa, scda, dc, di, dcsa, dcda) \
 			val.data.src_coeff = sc;		\
diff --git a/exynos/exynos_fimg2d.h b/exynos/exynos_fimg2d.h
new file mode 100644
index 0000000..bd116cf
--- /dev/null
+++ b/exynos/exynos_fimg2d.h
@@ -0,0 +1,328 @@
+/*
+ * Copyright (C) 2013 Samsung Electronics Co.Ltd
+ * Authors:
+ *	Inki Dae <inki.dae@samsung.com>
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ *
+ */
+
+#ifndef _FIMG2D_H_
+#define _FIMG2D_H_
+
+#ifndef TRUE
+#define TRUE 0
+#endif
+#ifndef FALSE
+#define FALSE -1
+#endif
+
+#define G2D_MAX_CMD_NR		64
+#define G2D_MAX_GEM_CMD_NR	64
+#define G2D_MAX_CMD_LIST_NR	64
+#define G2D_PLANE_MAX_NR	2
+
+enum e_g2d_color_mode {
+	/* COLOR FORMAT */
+	G2D_COLOR_FMT_XRGB8888,
+	G2D_COLOR_FMT_ARGB8888,
+	G2D_COLOR_FMT_RGB565,
+	G2D_COLOR_FMT_XRGB1555,
+	G2D_COLOR_FMT_ARGB1555,
+	G2D_COLOR_FMT_XRGB4444,
+	G2D_COLOR_FMT_ARGB4444,
+	G2D_COLOR_FMT_PRGB888,
+	G2D_COLOR_FMT_YCbCr444,
+	G2D_COLOR_FMT_YCbCr422,
+	G2D_COLOR_FMT_YCbCr420,
+	/* alpha 8bit */
+	G2D_COLOR_FMT_A8,
+	/* Luminance 8bit: gray color */
+	G2D_COLOR_FMT_L8,
+	/* alpha 1bit */
+	G2D_COLOR_FMT_A1,
+	/* alpha 4bit */
+	G2D_COLOR_FMT_A4,
+	G2D_COLOR_FMT_MASK,				/* VER4.1 */
+
+	/* COLOR ORDER */
+	G2D_ORDER_AXRGB		= (0 << 4),		/* VER4.1 */
+	G2D_ORDER_RGBAX		= (1 << 4),		/* VER4.1 */
+	G2D_ORDER_AXBGR		= (2 << 4),		/* VER4.1 */
+	G2D_ORDER_BGRAX		= (3 << 4),		/* VER4.1 */
+	G2D_ORDER_MASK		= (3 << 4),		/* VER4.1 */
+
+	/* Number of YCbCr plane */
+	G2D_YCbCr_1PLANE	= (0 << 8),		/* VER4.1 */
+	G2D_YCbCr_2PLANE	= (1 << 8),		/* VER4.1 */
+	G2D_YCbCr_PLANE_MASK	= (3 << 8),		/* VER4.1 */
+
+	/* Order in YCbCr */
+	G2D_YCbCr_ORDER_CrY1CbY0 = (0 << 12),			/* VER4.1 */
+	G2D_YCbCr_ORDER_CbY1CrY0 = (1 << 12),			/* VER4.1 */
+	G2D_YCbCr_ORDER_Y1CrY0Cb = (2 << 12),			/* VER4.1 */
+	G2D_YCbCr_ORDER_Y1CbY0Cr = (3 << 12),			/* VER4.1 */
+	G2D_YCbCr_ORDER_CrCb = G2D_YCbCr_ORDER_CrY1CbY0,	/* VER4.1 */
+	G2D_YCbCr_ORDER_CbCr = G2D_YCbCr_ORDER_CbY1CrY0,	/* VER4.1 */
+	G2D_YCbCr_ORDER_MASK = (3 < 12),			/* VER4.1 */
+
+	/* CSC */
+	G2D_CSC_601 = (0 << 16),		/* VER4.1 */
+	G2D_CSC_709 = (1 << 16),		/* VER4.1 */
+	G2D_CSC_MASK = (1 << 16),		/* VER4.1 */
+
+	/* Valid value range of YCbCr */
+	G2D_YCbCr_RANGE_NARROW = (0 << 17),	/* VER4.1 */
+	G2D_YCbCr_RANGE_WIDE = (1 << 17),	/* VER4.1 */
+	G2D_YCbCr_RANGE_MASK = (1 << 17),	/* VER4.1 */
+
+	G2D_COLOR_MODE_MASK = 0xFFFFFFFF,
+};
+
+enum e_g2d_select_mode {
+	G2D_SELECT_MODE_NORMAL	= (0 << 0),
+	G2D_SELECT_MODE_FGCOLOR = (1 << 0),
+	G2D_SELECT_MODE_BGCOLOR = (2 << 0),
+};
+
+enum e_g2d_repeat_mode {
+	G2D_REPEAT_MODE_REPEAT,
+	G2D_REPEAT_MODE_PAD,
+	G2D_REPEAT_MODE_REFLECT,
+	G2D_REPEAT_MODE_CLAMP,
+	G2D_REPEAT_MODE_NONE,
+};
+
+enum e_g2d_scale_mode {
+	G2D_SCALE_MODE_NONE = 0,
+	G2D_SCALE_MODE_NEAREST,
+	G2D_SCALE_MODE_BILINEAR,
+	G2D_SCALE_MODE_MAX,
+};
+
+enum e_g2d_buf_type {
+	G2D_IMGBUF_COLOR,
+	G2D_IMGBUF_GEM,
+	G2D_IMGBUF_USERPTR,
+};
+
+enum e_g2d_rop3_type {
+	G2D_ROP3_DST = 0xAA,
+	G2D_ROP3_SRC = 0xCC,
+	G2D_ROP3_3RD = 0xF0,
+	G2D_ROP3_MASK = 0xFF,
+};
+
+enum e_g2d_select_alpha_src {
+	G2D_SELECT_SRC_FOR_ALPHA_BLEND,	/* VER4.1 */
+	G2D_SELECT_ROP_FOR_ALPHA_BLEND,	/* VER4.1 */
+};
+
+enum e_g2d_transparent_mode {
+	G2D_TRANSPARENT_MODE_OPAQUE,
+	G2D_TRANSPARENT_MODE_TRANSPARENT,
+	G2D_TRANSPARENT_MODE_BLUESCREEN,
+	G2D_TRANSPARENT_MODE_MAX,
+};
+
+enum e_g2d_color_key_mode {
+	G2D_COLORKEY_MODE_DISABLE	= 0,
+	G2D_COLORKEY_MODE_SRC_RGBA	= (1<<0),
+	G2D_COLORKEY_MODE_DST_RGBA	= (1<<1),
+	G2D_COLORKEY_MODE_SRC_YCbCr	= (1<<2),		/* VER4.1 */
+	G2D_COLORKEY_MODE_DST_YCbCr	= (1<<3),		/* VER4.1 */
+	G2D_COLORKEY_MODE_MASK		= 15,
+};
+
+enum e_g2d_alpha_blend_mode {
+	G2D_ALPHA_BLEND_MODE_DISABLE,
+	G2D_ALPHA_BLEND_MODE_ENABLE,
+	G2D_ALPHA_BLEND_MODE_FADING,				/* VER3.0 */
+	G2D_ALPHA_BLEND_MODE_MAX,
+};
+
+enum e_g2d_op {
+	G2D_OP_CLEAR			= 0x00,
+	G2D_OP_SRC			= 0x01,
+	G2D_OP_DST			= 0x02,
+	G2D_OP_OVER			= 0x03,
+	G2D_OP_DISJOINT_CLEAR		= 0x10,
+	G2D_OP_DISJOINT_SRC		= 0x11,
+	G2D_OP_DISJOINT_DST		= 0x12,
+	G2D_OP_CONJOINT_CLEAR		= 0x20,
+	G2D_OP_CONJOINT_SRC		= 0x21,
+	G2D_OP_CONJOINT_DST		= 0x22,
+};
+
+enum e_g2d_coeff_mode {
+	G2D_COEFF_MODE_ONE,
+	G2D_COEFF_MODE_ZERO,
+	G2D_COEFF_MODE_SRC_ALPHA,
+	G2D_COEFF_MODE_SRC_COLOR,
+	G2D_COEFF_MODE_DST_ALPHA,
+	G2D_COEFF_MODE_DST_COLOR,
+	/* Global Alpha : Set by ALPHA_REG(0x618) */
+	G2D_COEFF_MODE_GB_ALPHA,
+	/* Global Alpha : Set by ALPHA_REG(0x618) */
+	G2D_COEFF_MODE_GB_COLOR,
+	/* (1-SRC alpha)/DST Alpha */
+	G2D_COEFF_MODE_DISJOINT_S,
+	/* (1-DST alpha)/SRC Alpha */
+	G2D_COEFF_MODE_DISJOINT_D,
+	/* SRC alpha/DST alpha */
+	G2D_COEFF_MODE_CONJOINT_S,
+	/* DST alpha/SRC alpha */
+	G2D_COEFF_MODE_CONJOINT_D,
+	/* DST alpha/SRC alpha */
+	G2D_COEFF_MODE_MASK
+};
+
+enum e_g2d_acoeff_mode {
+	G2D_ACOEFF_MODE_A,          /* alpha */
+	G2D_ACOEFF_MODE_APGA,	/* alpha + global alpha */
+	G2D_ACOEFF_MODE_AMGA,	/* alpha * global alpha */
+	G2D_ACOEFF_MODE_MASK
+};
+
+union g2d_point_val {
+	unsigned int val;
+	struct {
+		/*
+		 * Coordinate of Source Image
+		 * Range: 0 ~ 8000 (Requirement: SrcLeftX < SrcRightX)
+		 * In YCbCr 422 and YCbCr 420 format with even number.
+		 */
+		unsigned int x:16;
+		/*
+		 * Y Coordinate of Source Image
+		 * Range: 0 ~ 8000 (Requirement: SrcTopY < SrcBottomY)
+		 * In YCbCr 420 format with even number.
+		 */
+		unsigned int y:16;
+	} data;
+};
+
+union g2d_rop4_val {
+	unsigned int val;
+	struct {
+		enum e_g2d_rop3_type	unmasked_rop3:8;
+		enum e_g2d_rop3_type	masked_rop3:8;
+		unsigned int		reserved:16;
+	} data;
+};
+
+union g2d_bitblt_cmd_val {
+	unsigned int val;
+	struct {
+		/* [0:3] */
+		unsigned int			mask_rop4_en:1;
+		unsigned int			masking_en:1;
+		enum e_g2d_select_alpha_src	rop4_alpha_en:1;
+		unsigned int			dither_en:1;
+		/* [4:7] */
+		unsigned int			resolved1:4;
+		/* [8:11] */
+		unsigned int			cw_en:4;
+		/* [12:15] */
+		enum e_g2d_transparent_mode	transparent_mode:4;
+		/* [16:19] */
+		enum e_g2d_color_key_mode	color_key_mode:4;
+		/* [20:23] */
+		enum e_g2d_alpha_blend_mode	alpha_blend_mode:4;
+		/* [24:27] */
+		unsigned int src_pre_multiply:1;
+		unsigned int pat_pre_multiply:1;
+		unsigned int dst_pre_multiply:1;
+		unsigned int dst_depre_multiply:1;
+		/* [28:31] */
+		unsigned int fast_solid_color_fill_en:1;
+		unsigned int reserved:3;
+	} data;
+};
+
+union g2d_blend_func_val {
+	unsigned int val;
+	struct {
+		/* [0:15] */
+		enum e_g2d_coeff_mode src_coeff:4;
+		enum e_g2d_acoeff_mode src_coeff_src_a:2;
+		enum e_g2d_acoeff_mode src_coeff_dst_a:2;
+		enum e_g2d_coeff_mode dst_coeff:4;
+		enum e_g2d_acoeff_mode dst_coeff_src_a:2;
+		enum e_g2d_acoeff_mode dst_coeff_dst_a:2;
+		/* [16:19] */
+		unsigned int inv_src_color_coeff:1;
+		unsigned int resoled1:1;
+		unsigned int inv_dst_color_coeff:1;
+		unsigned int resoled2:1;
+		/* [20:23] */
+		unsigned int lighten_en:1;
+		unsigned int darken_en:1;
+		unsigned int win_ce_src_over_en:2;
+		/* [24:31] */
+		unsigned int reserved:8;
+	} data;
+};
+
+struct g2d_image {
+	enum e_g2d_select_mode		select_mode;
+	enum e_g2d_color_mode		color_mode;
+	enum e_g2d_repeat_mode		repeat_mode;
+	enum e_g2d_scale_mode		scale_mode;
+	unsigned int			xscale;
+	unsigned int			yscale;
+	unsigned char			rotate_90;
+	unsigned char			x_dir;
+	unsigned char			y_dir;
+	unsigned char			component_alpha;
+	unsigned int			width;
+	unsigned int			height;
+	unsigned int			stride;
+	unsigned int			need_free;
+	unsigned int			color;
+	enum e_g2d_buf_type		buf_type;
+	unsigned int			bo[G2D_PLANE_MAX_NR];
+	struct drm_exynos_g2d_userptr	user_ptr[G2D_PLANE_MAX_NR];
+	void				*mapped_ptr[G2D_PLANE_MAX_NR];
+};
+
+struct g2d_context {
+	int				fd;
+	unsigned int			major;
+	unsigned int			minor;
+	struct drm_exynos_g2d_cmd	cmd[G2D_MAX_CMD_NR];
+	struct drm_exynos_g2d_cmd	cmd_buf[G2D_MAX_GEM_CMD_NR];
+	unsigned int			cmd_nr;
+	unsigned int			cmd_buf_nr;
+	unsigned int			cmdlist_nr;
+};
+
+struct g2d_context *g2d_init(int fd);
+void g2d_fini(struct g2d_context *ctx);
+int g2d_exec(struct g2d_context *ctx);
+int g2d_solid_fill(struct g2d_context *ctx, struct g2d_image *img,
+			unsigned int x, unsigned int y, unsigned int w,
+			unsigned int h);
+int g2d_copy(struct g2d_context *ctx, struct g2d_image *src,
+		struct g2d_image *dst, unsigned int src_x,
+		unsigned int src_y, unsigned int dst_x, unsigned int dst_y,
+		unsigned int w, unsigned int h);
+int g2d_copy_with_scale(struct g2d_context *ctx, struct g2d_image *src,
+				struct g2d_image *dst, unsigned int src_x,
+				unsigned int src_y, unsigned int src_w,
+				unsigned int src_h, unsigned int dst_x,
+				unsigned int dst_y, unsigned int dst_w,
+				unsigned int dst_h, unsigned int negative);
+int g2d_blend(struct g2d_context *ctx, struct g2d_image *src,
+		struct g2d_image *dst, unsigned int src_x,
+		unsigned int src_y, unsigned int dst_x, unsigned int dst_y,
+		unsigned int w, unsigned int h, enum e_g2d_op op);
+int g2d_scale_and_blend(struct g2d_context *ctx, struct g2d_image *src,
+		struct g2d_image *dst, unsigned int src_x, unsigned int src_y,
+		unsigned int src_w, unsigned int src_h, unsigned int dst_x,
+		unsigned int dst_y, unsigned int dst_w, unsigned int dst_h,
+		enum e_g2d_op op);
+#endif /* _FIMG2D_H_ */
diff --git a/exynos/fimg2d.h b/exynos/fimg2d.h
deleted file mode 100644
index bd116cf..0000000
--- a/exynos/fimg2d.h
+++ /dev/null
@@ -1,328 +0,0 @@
-/*
- * Copyright (C) 2013 Samsung Electronics Co.Ltd
- * Authors:
- *	Inki Dae <inki.dae@samsung.com>
- *
- * This program is free software; you can redistribute  it and/or modify it
- * under  the terms of  the GNU General  Public License as published by the
- * Free Software Foundation;  either version 2 of the  License, or (at your
- * option) any later version.
- *
- */
-
-#ifndef _FIMG2D_H_
-#define _FIMG2D_H_
-
-#ifndef TRUE
-#define TRUE 0
-#endif
-#ifndef FALSE
-#define FALSE -1
-#endif
-
-#define G2D_MAX_CMD_NR		64
-#define G2D_MAX_GEM_CMD_NR	64
-#define G2D_MAX_CMD_LIST_NR	64
-#define G2D_PLANE_MAX_NR	2
-
-enum e_g2d_color_mode {
-	/* COLOR FORMAT */
-	G2D_COLOR_FMT_XRGB8888,
-	G2D_COLOR_FMT_ARGB8888,
-	G2D_COLOR_FMT_RGB565,
-	G2D_COLOR_FMT_XRGB1555,
-	G2D_COLOR_FMT_ARGB1555,
-	G2D_COLOR_FMT_XRGB4444,
-	G2D_COLOR_FMT_ARGB4444,
-	G2D_COLOR_FMT_PRGB888,
-	G2D_COLOR_FMT_YCbCr444,
-	G2D_COLOR_FMT_YCbCr422,
-	G2D_COLOR_FMT_YCbCr420,
-	/* alpha 8bit */
-	G2D_COLOR_FMT_A8,
-	/* Luminance 8bit: gray color */
-	G2D_COLOR_FMT_L8,
-	/* alpha 1bit */
-	G2D_COLOR_FMT_A1,
-	/* alpha 4bit */
-	G2D_COLOR_FMT_A4,
-	G2D_COLOR_FMT_MASK,				/* VER4.1 */
-
-	/* COLOR ORDER */
-	G2D_ORDER_AXRGB		= (0 << 4),		/* VER4.1 */
-	G2D_ORDER_RGBAX		= (1 << 4),		/* VER4.1 */
-	G2D_ORDER_AXBGR		= (2 << 4),		/* VER4.1 */
-	G2D_ORDER_BGRAX		= (3 << 4),		/* VER4.1 */
-	G2D_ORDER_MASK		= (3 << 4),		/* VER4.1 */
-
-	/* Number of YCbCr plane */
-	G2D_YCbCr_1PLANE	= (0 << 8),		/* VER4.1 */
-	G2D_YCbCr_2PLANE	= (1 << 8),		/* VER4.1 */
-	G2D_YCbCr_PLANE_MASK	= (3 << 8),		/* VER4.1 */
-
-	/* Order in YCbCr */
-	G2D_YCbCr_ORDER_CrY1CbY0 = (0 << 12),			/* VER4.1 */
-	G2D_YCbCr_ORDER_CbY1CrY0 = (1 << 12),			/* VER4.1 */
-	G2D_YCbCr_ORDER_Y1CrY0Cb = (2 << 12),			/* VER4.1 */
-	G2D_YCbCr_ORDER_Y1CbY0Cr = (3 << 12),			/* VER4.1 */
-	G2D_YCbCr_ORDER_CrCb = G2D_YCbCr_ORDER_CrY1CbY0,	/* VER4.1 */
-	G2D_YCbCr_ORDER_CbCr = G2D_YCbCr_ORDER_CbY1CrY0,	/* VER4.1 */
-	G2D_YCbCr_ORDER_MASK = (3 < 12),			/* VER4.1 */
-
-	/* CSC */
-	G2D_CSC_601 = (0 << 16),		/* VER4.1 */
-	G2D_CSC_709 = (1 << 16),		/* VER4.1 */
-	G2D_CSC_MASK = (1 << 16),		/* VER4.1 */
-
-	/* Valid value range of YCbCr */
-	G2D_YCbCr_RANGE_NARROW = (0 << 17),	/* VER4.1 */
-	G2D_YCbCr_RANGE_WIDE = (1 << 17),	/* VER4.1 */
-	G2D_YCbCr_RANGE_MASK = (1 << 17),	/* VER4.1 */
-
-	G2D_COLOR_MODE_MASK = 0xFFFFFFFF,
-};
-
-enum e_g2d_select_mode {
-	G2D_SELECT_MODE_NORMAL	= (0 << 0),
-	G2D_SELECT_MODE_FGCOLOR = (1 << 0),
-	G2D_SELECT_MODE_BGCOLOR = (2 << 0),
-};
-
-enum e_g2d_repeat_mode {
-	G2D_REPEAT_MODE_REPEAT,
-	G2D_REPEAT_MODE_PAD,
-	G2D_REPEAT_MODE_REFLECT,
-	G2D_REPEAT_MODE_CLAMP,
-	G2D_REPEAT_MODE_NONE,
-};
-
-enum e_g2d_scale_mode {
-	G2D_SCALE_MODE_NONE = 0,
-	G2D_SCALE_MODE_NEAREST,
-	G2D_SCALE_MODE_BILINEAR,
-	G2D_SCALE_MODE_MAX,
-};
-
-enum e_g2d_buf_type {
-	G2D_IMGBUF_COLOR,
-	G2D_IMGBUF_GEM,
-	G2D_IMGBUF_USERPTR,
-};
-
-enum e_g2d_rop3_type {
-	G2D_ROP3_DST = 0xAA,
-	G2D_ROP3_SRC = 0xCC,
-	G2D_ROP3_3RD = 0xF0,
-	G2D_ROP3_MASK = 0xFF,
-};
-
-enum e_g2d_select_alpha_src {
-	G2D_SELECT_SRC_FOR_ALPHA_BLEND,	/* VER4.1 */
-	G2D_SELECT_ROP_FOR_ALPHA_BLEND,	/* VER4.1 */
-};
-
-enum e_g2d_transparent_mode {
-	G2D_TRANSPARENT_MODE_OPAQUE,
-	G2D_TRANSPARENT_MODE_TRANSPARENT,
-	G2D_TRANSPARENT_MODE_BLUESCREEN,
-	G2D_TRANSPARENT_MODE_MAX,
-};
-
-enum e_g2d_color_key_mode {
-	G2D_COLORKEY_MODE_DISABLE	= 0,
-	G2D_COLORKEY_MODE_SRC_RGBA	= (1<<0),
-	G2D_COLORKEY_MODE_DST_RGBA	= (1<<1),
-	G2D_COLORKEY_MODE_SRC_YCbCr	= (1<<2),		/* VER4.1 */
-	G2D_COLORKEY_MODE_DST_YCbCr	= (1<<3),		/* VER4.1 */
-	G2D_COLORKEY_MODE_MASK		= 15,
-};
-
-enum e_g2d_alpha_blend_mode {
-	G2D_ALPHA_BLEND_MODE_DISABLE,
-	G2D_ALPHA_BLEND_MODE_ENABLE,
-	G2D_ALPHA_BLEND_MODE_FADING,				/* VER3.0 */
-	G2D_ALPHA_BLEND_MODE_MAX,
-};
-
-enum e_g2d_op {
-	G2D_OP_CLEAR			= 0x00,
-	G2D_OP_SRC			= 0x01,
-	G2D_OP_DST			= 0x02,
-	G2D_OP_OVER			= 0x03,
-	G2D_OP_DISJOINT_CLEAR		= 0x10,
-	G2D_OP_DISJOINT_SRC		= 0x11,
-	G2D_OP_DISJOINT_DST		= 0x12,
-	G2D_OP_CONJOINT_CLEAR		= 0x20,
-	G2D_OP_CONJOINT_SRC		= 0x21,
-	G2D_OP_CONJOINT_DST		= 0x22,
-};
-
-enum e_g2d_coeff_mode {
-	G2D_COEFF_MODE_ONE,
-	G2D_COEFF_MODE_ZERO,
-	G2D_COEFF_MODE_SRC_ALPHA,
-	G2D_COEFF_MODE_SRC_COLOR,
-	G2D_COEFF_MODE_DST_ALPHA,
-	G2D_COEFF_MODE_DST_COLOR,
-	/* Global Alpha : Set by ALPHA_REG(0x618) */
-	G2D_COEFF_MODE_GB_ALPHA,
-	/* Global Alpha : Set by ALPHA_REG(0x618) */
-	G2D_COEFF_MODE_GB_COLOR,
-	/* (1-SRC alpha)/DST Alpha */
-	G2D_COEFF_MODE_DISJOINT_S,
-	/* (1-DST alpha)/SRC Alpha */
-	G2D_COEFF_MODE_DISJOINT_D,
-	/* SRC alpha/DST alpha */
-	G2D_COEFF_MODE_CONJOINT_S,
-	/* DST alpha/SRC alpha */
-	G2D_COEFF_MODE_CONJOINT_D,
-	/* DST alpha/SRC alpha */
-	G2D_COEFF_MODE_MASK
-};
-
-enum e_g2d_acoeff_mode {
-	G2D_ACOEFF_MODE_A,          /* alpha */
-	G2D_ACOEFF_MODE_APGA,	/* alpha + global alpha */
-	G2D_ACOEFF_MODE_AMGA,	/* alpha * global alpha */
-	G2D_ACOEFF_MODE_MASK
-};
-
-union g2d_point_val {
-	unsigned int val;
-	struct {
-		/*
-		 * Coordinate of Source Image
-		 * Range: 0 ~ 8000 (Requirement: SrcLeftX < SrcRightX)
-		 * In YCbCr 422 and YCbCr 420 format with even number.
-		 */
-		unsigned int x:16;
-		/*
-		 * Y Coordinate of Source Image
-		 * Range: 0 ~ 8000 (Requirement: SrcTopY < SrcBottomY)
-		 * In YCbCr 420 format with even number.
-		 */
-		unsigned int y:16;
-	} data;
-};
-
-union g2d_rop4_val {
-	unsigned int val;
-	struct {
-		enum e_g2d_rop3_type	unmasked_rop3:8;
-		enum e_g2d_rop3_type	masked_rop3:8;
-		unsigned int		reserved:16;
-	} data;
-};
-
-union g2d_bitblt_cmd_val {
-	unsigned int val;
-	struct {
-		/* [0:3] */
-		unsigned int			mask_rop4_en:1;
-		unsigned int			masking_en:1;
-		enum e_g2d_select_alpha_src	rop4_alpha_en:1;
-		unsigned int			dither_en:1;
-		/* [4:7] */
-		unsigned int			resolved1:4;
-		/* [8:11] */
-		unsigned int			cw_en:4;
-		/* [12:15] */
-		enum e_g2d_transparent_mode	transparent_mode:4;
-		/* [16:19] */
-		enum e_g2d_color_key_mode	color_key_mode:4;
-		/* [20:23] */
-		enum e_g2d_alpha_blend_mode	alpha_blend_mode:4;
-		/* [24:27] */
-		unsigned int src_pre_multiply:1;
-		unsigned int pat_pre_multiply:1;
-		unsigned int dst_pre_multiply:1;
-		unsigned int dst_depre_multiply:1;
-		/* [28:31] */
-		unsigned int fast_solid_color_fill_en:1;
-		unsigned int reserved:3;
-	} data;
-};
-
-union g2d_blend_func_val {
-	unsigned int val;
-	struct {
-		/* [0:15] */
-		enum e_g2d_coeff_mode src_coeff:4;
-		enum e_g2d_acoeff_mode src_coeff_src_a:2;
-		enum e_g2d_acoeff_mode src_coeff_dst_a:2;
-		enum e_g2d_coeff_mode dst_coeff:4;
-		enum e_g2d_acoeff_mode dst_coeff_src_a:2;
-		enum e_g2d_acoeff_mode dst_coeff_dst_a:2;
-		/* [16:19] */
-		unsigned int inv_src_color_coeff:1;
-		unsigned int resoled1:1;
-		unsigned int inv_dst_color_coeff:1;
-		unsigned int resoled2:1;
-		/* [20:23] */
-		unsigned int lighten_en:1;
-		unsigned int darken_en:1;
-		unsigned int win_ce_src_over_en:2;
-		/* [24:31] */
-		unsigned int reserved:8;
-	} data;
-};
-
-struct g2d_image {
-	enum e_g2d_select_mode		select_mode;
-	enum e_g2d_color_mode		color_mode;
-	enum e_g2d_repeat_mode		repeat_mode;
-	enum e_g2d_scale_mode		scale_mode;
-	unsigned int			xscale;
-	unsigned int			yscale;
-	unsigned char			rotate_90;
-	unsigned char			x_dir;
-	unsigned char			y_dir;
-	unsigned char			component_alpha;
-	unsigned int			width;
-	unsigned int			height;
-	unsigned int			stride;
-	unsigned int			need_free;
-	unsigned int			color;
-	enum e_g2d_buf_type		buf_type;
-	unsigned int			bo[G2D_PLANE_MAX_NR];
-	struct drm_exynos_g2d_userptr	user_ptr[G2D_PLANE_MAX_NR];
-	void				*mapped_ptr[G2D_PLANE_MAX_NR];
-};
-
-struct g2d_context {
-	int				fd;
-	unsigned int			major;
-	unsigned int			minor;
-	struct drm_exynos_g2d_cmd	cmd[G2D_MAX_CMD_NR];
-	struct drm_exynos_g2d_cmd	cmd_buf[G2D_MAX_GEM_CMD_NR];
-	unsigned int			cmd_nr;
-	unsigned int			cmd_buf_nr;
-	unsigned int			cmdlist_nr;
-};
-
-struct g2d_context *g2d_init(int fd);
-void g2d_fini(struct g2d_context *ctx);
-int g2d_exec(struct g2d_context *ctx);
-int g2d_solid_fill(struct g2d_context *ctx, struct g2d_image *img,
-			unsigned int x, unsigned int y, unsigned int w,
-			unsigned int h);
-int g2d_copy(struct g2d_context *ctx, struct g2d_image *src,
-		struct g2d_image *dst, unsigned int src_x,
-		unsigned int src_y, unsigned int dst_x, unsigned int dst_y,
-		unsigned int w, unsigned int h);
-int g2d_copy_with_scale(struct g2d_context *ctx, struct g2d_image *src,
-				struct g2d_image *dst, unsigned int src_x,
-				unsigned int src_y, unsigned int src_w,
-				unsigned int src_h, unsigned int dst_x,
-				unsigned int dst_y, unsigned int dst_w,
-				unsigned int dst_h, unsigned int negative);
-int g2d_blend(struct g2d_context *ctx, struct g2d_image *src,
-		struct g2d_image *dst, unsigned int src_x,
-		unsigned int src_y, unsigned int dst_x, unsigned int dst_y,
-		unsigned int w, unsigned int h, enum e_g2d_op op);
-int g2d_scale_and_blend(struct g2d_context *ctx, struct g2d_image *src,
-		struct g2d_image *dst, unsigned int src_x, unsigned int src_y,
-		unsigned int src_w, unsigned int src_h, unsigned int dst_x,
-		unsigned int dst_y, unsigned int dst_w, unsigned int dst_h,
-		enum e_g2d_op op);
-#endif /* _FIMG2D_H_ */
diff --git a/tests/exynos/exynos_fimg2d_test.c b/tests/exynos/exynos_fimg2d_test.c
index d68f3d1..43a47b1 100644
--- a/tests/exynos/exynos_fimg2d_test.c
+++ b/tests/exynos/exynos_fimg2d_test.c
@@ -29,7 +29,7 @@
 
 #include "exynos_drm.h"
 #include "exynos_drmif.h"
-#include "fimg2d.h"
+#include "exynos_fimg2d.h"
 
 #define DRM_MODULE_NAME		"exynos"
 #define MAX_TEST_CASE		8
-- 
2.0.5

[PATCH 12/15] exynos: add fimg2d header to common includes

[Tobias Jakobi]

The reason for this change is to let userspace use the header.
Currently 'make install' does not install it.

Signed-off-by: Tobias Jakobi <tjakobi@math.uni-bielefeld.de>
---
 exynos/Makefile.am | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/exynos/Makefile.am b/exynos/Makefile.am
index 1715a85..35bc71f 100644
--- a/exynos/Makefile.am
+++ b/exynos/Makefile.am
@@ -14,11 +14,10 @@ libdrm_exynos_la_LIBADD = ../libdrm.la @PTHREADSTUBS_LIBS@
 libdrm_exynos_la_SOURCES = \
 	exynos_drm.c \
 	exynos_fimg2d.c \
-	exynos_fimg2d.h \
 	fimg2d_reg.h
 
 libdrm_exynoscommonincludedir = ${includedir}/exynos
-libdrm_exynoscommoninclude_HEADERS = exynos_drm.h
+libdrm_exynoscommoninclude_HEADERS = exynos_drm.h exynos_fimg2d.h
 
 libdrm_exynosincludedir = ${includedir}/libdrm
 libdrm_exynosinclude_HEADERS = exynos_drmif.h
-- 
2.0.5

[PATCH 13/15] exynos: fimg2d: fix comment for G2D_COEFF_MODE_GB_COLOR

[Tobias Jakobi]

The coefficient mode enables use of global color, not alpha.

Signed-off-by: Tobias Jakobi <tjakobi@math.uni-bielefeld.de>
---
 exynos/exynos_fimg2d.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/exynos/exynos_fimg2d.h b/exynos/exynos_fimg2d.h
index bd116cf..78cff47 100644
--- a/exynos/exynos_fimg2d.h
+++ b/exynos/exynos_fimg2d.h
@@ -166,7 +166,7 @@ enum e_g2d_coeff_mode {
 	G2D_COEFF_MODE_DST_COLOR,
 	/* Global Alpha : Set by ALPHA_REG(0x618) */
 	G2D_COEFF_MODE_GB_ALPHA,
-	/* Global Alpha : Set by ALPHA_REG(0x618) */
+	/* Global Color : Set by ALPHA_REG(0x618) */
 	G2D_COEFF_MODE_GB_COLOR,
 	/* (1-SRC alpha)/DST Alpha */
 	G2D_COEFF_MODE_DISJOINT_S,
-- 
2.0.5

[PATCH 14/15] exynos: fimg2d: unify register style

[Tobias Jakobi]

Register defines all use uppercase hex codes.

Signed-off-by: Tobias Jakobi <tjakobi@math.uni-bielefeld.de>
---
 exynos/fimg2d_reg.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/exynos/fimg2d_reg.h b/exynos/fimg2d_reg.h
index 5782488..07dd634 100644
--- a/exynos/fimg2d_reg.h
+++ b/exynos/fimg2d_reg.h
@@ -15,7 +15,7 @@
 
 #define SOFT_RESET_REG			(0x0000)
 #define INTEN_REG			(0x0004)
-#define INTC_PEND_REG			(0x000c)
+#define INTC_PEND_REG			(0x000C)
 #define FIFO_STAT_REG			(0x0010)
 #define AXI_MODE_REG			(0x001C)
 #define DMA_SFR_BASE_ADDR_REG		(0x0080)
-- 
2.0.5

[PATCH 15/15] exynos: fimg2d: introduce G2D_OP_INTERPOLATE

[Tobias Jakobi]

This sets up the blending equation in the following way:
out = src * src_alpha + dst * (1 - src_alpha)

Signed-off-by: Tobias Jakobi <tjakobi@math.uni-bielefeld.de>
---
 exynos/exynos_fimg2d.c | 4 ++++
 exynos/exynos_fimg2d.h | 1 +
 2 files changed, 5 insertions(+)

diff --git a/exynos/exynos_fimg2d.c b/exynos/exynos_fimg2d.c
index 1b0bfdf..5829f14 100644
--- a/exynos/exynos_fimg2d.c
+++ b/exynos/exynos_fimg2d.c
@@ -84,6 +84,10 @@ static unsigned int g2d_get_blend_op(enum e_g2d_op op)
 		SET_BF(val, G2D_COEFF_MODE_ONE, 0, 0, 0,
 				G2D_COEFF_MODE_SRC_ALPHA, 1, 0, 0);
 		break;
+	case G2D_OP_INTERPOLATE:
+		SET_BF(val, G2D_COEFF_MODE_SRC_ALPHA, 0, 0, 0,
+				G2D_COEFF_MODE_SRC_ALPHA, 1, 0, 0);
+		break;
 	default:
 		fprintf(stderr, "Not support operation(%d).\n", op);
 		SET_BF(val, G2D_COEFF_MODE_ONE, 0, 0, 0, G2D_COEFF_MODE_ZERO,
diff --git a/exynos/exynos_fimg2d.h b/exynos/exynos_fimg2d.h
index 78cff47..79e6907 100644
--- a/exynos/exynos_fimg2d.h
+++ b/exynos/exynos_fimg2d.h
@@ -149,6 +149,7 @@ enum e_g2d_op {
 	G2D_OP_SRC			= 0x01,
 	G2D_OP_DST			= 0x02,
 	G2D_OP_OVER			= 0x03,
+	G2D_OP_INTERPOLATE		= 0x04,
 	G2D_OP_DISJOINT_CLEAR		= 0x10,
 	G2D_OP_DISJOINT_SRC		= 0x11,
 	G2D_OP_DISJOINT_DST		= 0x12,
-- 
2.0.5

Re: [libdrm] improvements to userspace exynos component

[Joonyoung Shim]

Hi,

On 02/03/2015 10:53 PM, Tobias Jakobi wrote:
> Hello,
> 
> here are some miscellaneous improvements (small features, bugfixes, spelling fixes, etc.) for the exynos component of libdrm. The general idea is to let userspace use the G2D engine functionality more 
> efficiently.
> 
> If someone is interested in an application that actually makes use of this, the RetroArch frontend has a custom video backend:
> https://github.com/libretro/RetroArch/blob/master/gfx/drivers/exynos_gfx.c
> 
> 
> Please review and let me know what I can improve.
> 

Working well on odroid u3 board.

Tested-by: Joonyoung Shim <jy0922.shim@samsung.com>

Re: [PATCH 04/15] tests/exynos: disable the G2D userptr/blend test

[Joonyoung Shim]

Hi,

On 02/03/2015 10:53 PM, Tobias Jakobi wrote:
> The blend test uses the userptr functionality of exynos-drm, which
> is currently not safe to use. If the kernel hasn't been build with
> exynos-iommu support, then the blend test is going to produce (kernel)
> memory corruption, eventually leading to a system crash.
> 
> Disable the test for now, until the kernel code has been sanitized.
> 
> Signed-off-by: Tobias Jakobi <tjakobi@math.uni-bielefeld.de>
> ---
>  tests/exynos/exynos_fimg2d_test.c | 2 ++
>  1 file changed, 2 insertions(+)
> 
> diff --git a/tests/exynos/exynos_fimg2d_test.c b/tests/exynos/exynos_fimg2d_test.c
> index aa140e5..48dfe97 100644
> --- a/tests/exynos/exynos_fimg2d_test.c
> +++ b/tests/exynos/exynos_fimg2d_test.c
> @@ -788,11 +788,13 @@ int main(int argc, char **argv)
>  
>  	getchar();
>  
> +#if 0

How about add some comments about why need disable?

Thanks.

>  	ret  = test_case.blend(dev, src, bo, G2D_IMGBUF_USERPTR);
>  	if (ret < 0)
>  		fprintf(stderr, "failed to test blend operation.\n");
>  
>  	getchar();
> +#endif
>  
>  err_free_src:
>  	if (src)
> 

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

Re: [PATCH 04/15] tests/exynos: disable the G2D userptr/blend test

[Tobias Jakobi]

Hello Joonyoung!

Joonyoung Shim wrote:
> Hi,
> 
> On 02/03/2015 10:53 PM, Tobias Jakobi wrote:
>> The blend test uses the userptr functionality of exynos-drm, which
>> is currently not safe to use. If the kernel hasn't been build with
>> exynos-iommu support, then the blend test is going to produce (kernel)
>> memory corruption, eventually leading to a system crash.
>>
>> Disable the test for now, until the kernel code has been sanitized.
>>
>> Signed-off-by: Tobias Jakobi <tjakobi@math.uni-bielefeld.de>
>> ---
>>  tests/exynos/exynos_fimg2d_test.c | 2 ++
>>  1 file changed, 2 insertions(+)
>>
>> diff --git a/tests/exynos/exynos_fimg2d_test.c b/tests/exynos/exynos_fimg2d_test.c
>> index aa140e5..48dfe97 100644
>> --- a/tests/exynos/exynos_fimg2d_test.c
>> +++ b/tests/exynos/exynos_fimg2d_test.c
>> @@ -788,11 +788,13 @@ int main(int argc, char **argv)
>>  
>>  	getchar();
>>  
>> +#if 0
> 
> How about add some comments about why need disable?
You mean the current patch description is not enough, or that I should
put that description also in the sourcecode?


With best wishes,
Tobias

Re: [PATCH 04/15] tests/exynos: disable the G2D userptr/blend test

[Joonyoung Shim]

Hi,

On 02/11/2015 10:39 AM, Tobias Jakobi wrote:
> Hello Joonyoung!
> 
> Joonyoung Shim wrote:
>> Hi,
>>
>> On 02/03/2015 10:53 PM, Tobias Jakobi wrote:
>>> The blend test uses the userptr functionality of exynos-drm, which
>>> is currently not safe to use. If the kernel hasn't been build with
>>> exynos-iommu support, then the blend test is going to produce (kernel)
>>> memory corruption, eventually leading to a system crash.
>>>
>>> Disable the test for now, until the kernel code has been sanitized.
>>>
>>> Signed-off-by: Tobias Jakobi <tjakobi@math.uni-bielefeld.de>
>>> ---
>>>  tests/exynos/exynos_fimg2d_test.c | 2 ++
>>>  1 file changed, 2 insertions(+)
>>>
>>> diff --git a/tests/exynos/exynos_fimg2d_test.c b/tests/exynos/exynos_fimg2d_test.c
>>> index aa140e5..48dfe97 100644
>>> --- a/tests/exynos/exynos_fimg2d_test.c
>>> +++ b/tests/exynos/exynos_fimg2d_test.c
>>> @@ -788,11 +788,13 @@ int main(int argc, char **argv)
>>>  
>>>  	getchar();
>>>  
>>> +#if 0
>>
>> How about add some comments about why need disable?
> You mean the current patch description is not enough, or that I should
> put that description also in the sourcecode?
> 

I mean just to add on source code, if anyone meets #if 0 without any
comments, he will have question.

Thanks.