This patch adds new rotator driver which is a device for
rotation on EXYNOS SoCs.
This rotator device supports the belows as key feature.
1) Image format
: RGB565/888, YUV422 1p, YUV420 2p/3p
2) rotation
: 0/90/180/270 and X/Y Flip
Signed-off-by: Sunyoung Kang <sy0816.k...@samsung.com>
Signed-off-by: Ayoung Sim <a....@samsung.com>
---NOTE:
This patch has been created based on following
- media: media-dev: Add media devices for EXYNOS5 by Sungchun Kang
- media: fimc-lite: Add new driver for camera interface by Sungchun Kang
Changes since v1:
- address comments from Sylwester Nawrocki
drivers/media/video/exynos/Kconfig | 1 +
drivers/media/video/exynos/Makefile | 1 +
drivers/media/video/exynos/rotator/Kconfig | 7 +
drivers/media/video/exynos/rotator/Makefile | 9 +
drivers/media/video/exynos/rotator/rotator-core.c | 1344 +++++++++++++++++++++
drivers/media/video/exynos/rotator/rotator-regs.c | 215 ++++
drivers/media/video/exynos/rotator/rotator-regs.h | 70 ++
drivers/media/video/exynos/rotator/rotator.h | 286 +++++
8 files changed, 1933 insertions(+), 0 deletions(-)
create mode 100644 drivers/media/video/exynos/rotator/Kconfig
create mode 100644 drivers/media/video/exynos/rotator/Makefile
create mode 100644 drivers/media/video/exynos/rotator/rotator-core.c
create mode 100644 drivers/media/video/exynos/rotator/rotator-regs.c
create mode 100644 drivers/media/video/exynos/rotator/rotator-regs.h
create mode 100644 drivers/media/video/exynos/rotator/rotator.h
diff --git a/drivers/media/video/exynos/Kconfig
b/drivers/media/video/exynos/Kconfig
index a84097d..38a885d 100644
--- a/drivers/media/video/exynos/Kconfig
+++ b/drivers/media/video/exynos/Kconfig
@@ -12,6 +12,7 @@ config VIDEO_EXYNOS
if VIDEO_EXYNOS
source "drivers/media/video/exynos/mdev/Kconfig"
source "drivers/media/video/exynos/fimc-lite/Kconfig"
+ source "drivers/media/video/exynos/rotator/Kconfig"
endif
config MEDIA_EXYNOS
diff --git a/drivers/media/video/exynos/Makefile
b/drivers/media/video/exynos/Makefile
index 56cb7b2..24f19c5 100644
--- a/drivers/media/video/exynos/Makefile
+++ b/drivers/media/video/exynos/Makefile
@@ -1,4 +1,5 @@
obj-$(CONFIG_EXYNOS_MEDIA_DEVICE) += mdev/
obj-$(CONFIG_VIDEO_EXYNOS_FIMC_LITE) += fimc-lite/
+obj-$(CONFIG_VIDEO_EXYNOS_ROTATOR) += rotator/
EXTRA_CLAGS += -Idrivers/media/video
diff --git a/drivers/media/video/exynos/rotator/Kconfig
b/drivers/media/video/exynos/rotator/Kconfig
new file mode 100644
index 0000000..977423a
--- /dev/null
+++ b/drivers/media/video/exynos/rotator/Kconfig
@@ -0,0 +1,7 @@
+config VIDEO_EXYNOS_ROTATOR
+ bool "EXYNOS Image Rotator Driver"
+ select V4L2_MEM2MEM_DEV
+ select VIDEOBUF2_DMA_CONTIG
+ default n
+ ---help---
+ Support for Image Rotator Driver with v4l2 on EXYNOS SoCs
diff --git a/drivers/media/video/exynos/rotator/Makefile
b/drivers/media/video/exynos/rotator/Makefile
new file mode 100644
index 0000000..6f74403
--- /dev/null
+++ b/drivers/media/video/exynos/rotator/Makefile
@@ -0,0 +1,9 @@
+#
+# Copyright (c) 2012 Samsung Electronics Co., Ltd.
+# http://www.samsung.com
+#
+# Licensed under GPLv2
+#
+
+rotator-objs := rotator-core.o rotator-regs.o
+obj-$(CONFIG_VIDEO_EXYNOS_ROTATOR) += rotator.o
diff --git a/drivers/media/video/exynos/rotator/rotator-core.c
b/drivers/media/video/exynos/rotator/rotator-core.c
new file mode 100644
index 0000000..75d28f2
--- /dev/null
+++ b/drivers/media/video/exynos/rotator/rotator-core.c
@@ -0,0 +1,1344 @@
+/*
+ * Copyright (c) 2012 Samsung Electronics Co., Ltd.
+ * http://www.samsung.com
+ *
+ * Core file for Samsung EXYNOS Image Rotator driver
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+*/
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/version.h>
+#include <linux/platform_device.h>
+#include <linux/interrupt.h>
+#include <linux/clk.h>
+#include <linux/slab.h>
+
+#include <media/v4l2-ioctl.h>
+#include <media/videobuf2-dma-contig.h>
+
+#include "rotator.h"
+
+int log_level;
+module_param_named(log_level, log_level, uint, 0644);
+
+static struct rot_fmt rot_formats[] = {
+ {
+ .name = "RGB565",
+ .pixelformat = V4L2_PIX_FMT_RGB565,
+ .num_planes = 1,
+ .num_comp = 1,
+ .bitperpixel = { 16 },
+ }, {
+ .name = "XRGB-8888, 32 bps",
+ .pixelformat = V4L2_PIX_FMT_RGB32,
+ .num_planes = 1,
+ .num_comp = 1,
+ .bitperpixel = { 32 },
+ }, {
+ .name = "YUV 4:2:2 packed, YCbYCr",
+ .pixelformat = V4L2_PIX_FMT_YUYV,
+ .num_planes = 1,
+ .num_comp = 1,
+ .bitperpixel = { 16 },
+ }, {
+ .name = "YUV 4:2:0 non-contiguous 2-planar, Y/CbCr",
+ .pixelformat = V4L2_PIX_FMT_NV12M,
+ .num_planes = 2,
+ .num_comp = 2,
+ .bitperpixel = { 8, 4 },
+ }, {
+ .name = "YUV 4:2:0 non-contiguous 3-planar, Y/Cb/Cr",
+ .pixelformat = V4L2_PIX_FMT_YUV420M,
+ .num_planes = 3,
+ .num_comp = 3,
+ .bitperpixel = { 8, 2, 2 },
+ },
+};
+
+/* Find the matches format */
+static struct rot_fmt *rot_find_format(struct v4l2_format *f)
+{
+ struct rot_fmt *rot_fmt;
+ unsigned int i;
+
+ for (i = 0; i < ARRAY_SIZE(rot_formats); ++i) {
+ rot_fmt = &rot_formats[i];
+ if (rot_fmt->pixelformat == f->fmt.pix_mp.pixelformat)
+ return &rot_formats[i];
+ }
+
+ return NULL;
+}
+
+static void rot_bound_align_image(struct rot_ctx *ctx, struct rot_fmt *rot_fmt,
+ u32 *width, u32 *height)
+{
+ struct exynos_rot_variant *variant = ctx->rot_dev->variant;
+ struct exynos_rot_size_limit *limit = NULL;
+
+ switch (rot_fmt->pixelformat) {
+ case V4L2_PIX_FMT_YUV420M:
+ limit = &variant->limit_yuv420_3p;
+ break;
+ case V4L2_PIX_FMT_NV12M:
+ limit = &variant->limit_yuv420_2p;
+ break;
+ case V4L2_PIX_FMT_YUYV:
+ limit = &variant->limit_yuv422;
+ break;
+ case V4L2_PIX_FMT_RGB565:
+ limit = &variant->limit_rgb565;
+ break;
+ case V4L2_PIX_FMT_RGB32:
+ limit = &variant->limit_rgb888;
+ break;
+ default:
+ v4l2_err(&ctx->rot_dev->m2m.v4l2_dev,
+ "not supported format values\n");
+ return;
+ }
+
+ /* Bound an image to have width and height in limit */
+ v4l_bound_align_image(width, limit->min_x, limit->max_x,
+ limit->align, height, limit->min_y,
+ limit->max_y, limit->align, 0);
+}
+
+static void rot_adjust_pixminfo(struct rot_ctx *ctx, struct rot_frame *frame,
+ struct v4l2_pix_format_mplane *pixm)
+{
+ struct rot_frame *rot_frame;
+
+ if (frame == &ctx->s_frame) {
+ if (test_bit(CTX_DST, &ctx->flags)) {
+ rot_frame = &ctx->d_frame;
+ pixm->pixelformat = rot_frame->rot_fmt->pixelformat;
+ }
+ set_bit(CTX_SRC, &ctx->flags);
+ } else if (frame == &ctx->d_frame) {
+ if (test_bit(CTX_SRC, &ctx->flags)) {
+ rot_frame = &ctx->s_frame;
+ pixm->pixelformat = rot_frame->rot_fmt->pixelformat;
+ }
+ set_bit(CTX_DST, &ctx->flags);
+ }
+}
+
+static void rot_adjust_cropinfo(struct rot_ctx *ctx, struct rot_frame *frame,
+ struct v4l2_rect *crop)
+{
+ struct rot_frame *rot_frame;
+
+ if (frame == &ctx->s_frame) {
+ if (test_bit(CTX_DST, &ctx->flags)) {
+ rot_frame = &ctx->d_frame;
+ crop->width = rot_frame->crop.height;
+ crop->height = rot_frame->crop.width;
+ }
+ set_bit(CTX_SRC, &ctx->flags);
+ } else if (frame == &ctx->d_frame) {
+ if (test_bit(CTX_SRC, &ctx->flags)) {
+ rot_frame = &ctx->s_frame;
+ crop->width = rot_frame->crop.height;
+ crop->height = rot_frame->crop.width;
+ }
+ set_bit(CTX_DST, &ctx->flags);
+ }
+}
+
+static int rot_v4l2_querycap(struct file *file, void *fh,
+ struct v4l2_capability *cap)
+{
+ strncpy(cap->driver, MODULE_NAME, sizeof(cap->driver) - 1);
+ strncpy(cap->card, MODULE_NAME, sizeof(cap->card) - 1);
+
+ cap->bus_info[0] = 0;
+ cap->capabilities = V4L2_CAP_STREAMING |
+ V4L2_CAP_VIDEO_CAPTURE_MPLANE | V4L2_CAP_VIDEO_OUTPUT_MPLANE;
+
+ return 0;
+}
+
+static int rot_v4l2_enum_fmt_mplane(struct file *file, void *fh,
+ struct v4l2_fmtdesc *f)
+{
+ struct rot_fmt *rot_fmt;
+
+ if (f->index >= ARRAY_SIZE(rot_formats))
+ return -EINVAL;
+
+ rot_fmt = &rot_formats[f->index];
+ strncpy(f->description, rot_fmt->name, sizeof(f->description) - 1);
+ f->pixelformat = rot_fmt->pixelformat;
+
+ return 0;
+}
+
+static int rot_v4l2_g_fmt_mplane(struct file *file, void *fh,
+ struct v4l2_format *f)
+{
+ struct rot_ctx *ctx = fh_to_rot_ctx(fh);
+ struct rot_fmt *rot_fmt;
+ struct rot_frame *frame;
+ struct v4l2_pix_format_mplane *pixm = &f->fmt.pix_mp;
+ int i;
+
+ frame = ctx_get_frame(ctx, f->type);
+ if (IS_ERR(frame))
+ return PTR_ERR(frame);
+
+ rot_fmt = frame->rot_fmt;
+
+ pixm->width = frame->pix_mp.width;
+ pixm->height = frame->pix_mp.height;
+ pixm->pixelformat = frame->pix_mp.pixelformat;
+ pixm->field = V4L2_FIELD_NONE;
+ pixm->num_planes = frame->rot_fmt->num_planes;
+ pixm->colorspace = 0;
+
+ for (i = 0; i < pixm->num_planes; ++i) {
+ pixm->plane_fmt[i].bytesperline = (pixm->width *
+ rot_fmt->bitperpixel[i]) >> 3;
+ pixm->plane_fmt[i].sizeimage = pixm->plane_fmt[i].bytesperline
+ * pixm->height;
+
+ v4l2_dbg(1, log_level, &ctx->rot_dev->m2m.v4l2_dev,
+ "[%d] plane: bytesperline %d, sizeimage %d\n",
+ i, pixm->plane_fmt[i].bytesperline,
+ pixm->plane_fmt[i].sizeimage);
+ }
+
+ return 0;
+}
+
+static int rot_v4l2_try_fmt_mplane(struct file *file, void *fh,
+ struct v4l2_format *f)
+{
+ struct rot_ctx *ctx = fh_to_rot_ctx(fh);
+ struct rot_fmt *rot_fmt;
+ struct v4l2_pix_format_mplane *pixm = &f->fmt.pix_mp;
+ int i;
+
+ if (!V4L2_TYPE_IS_MULTIPLANAR(f->type)) {
+ v4l2_err(&ctx->rot_dev->m2m.v4l2_dev,
+ "not supported v4l2 type\n");
+ return -EINVAL;
+ }
+
+ rot_fmt = rot_find_format(f);
+ if (!rot_fmt) {
+ v4l2_err(&ctx->rot_dev->m2m.v4l2_dev,
+ "not supported format type\n");
+ return -EINVAL;
+ }
+
+ rot_bound_align_image(ctx, rot_fmt, &pixm->width, &pixm->height);
+
+ pixm->num_planes = rot_fmt->num_planes;
+ pixm->colorspace = 0;
+
+ for (i = 0; i < pixm->num_planes; ++i) {
+ pixm->plane_fmt[i].bytesperline = (pixm->width *
+ rot_fmt->bitperpixel[i]) >> 3;
+ pixm->plane_fmt[i].sizeimage = pixm->plane_fmt[i].bytesperline
+ * pixm->height;
+
+ v4l2_dbg(1, log_level, &ctx->rot_dev->m2m.v4l2_dev,
+ "[%d] plane: bytesperline %d, sizeimage %d\n",
+ i, pixm->plane_fmt[i].bytesperline,
+ pixm->plane_fmt[i].sizeimage);
+ }
+
+ return 0;
+}
+
+static int rot_v4l2_s_fmt_mplane(struct file *file, void *fh,
+ struct v4l2_format *f)
+{
+ struct rot_ctx *ctx = fh_to_rot_ctx(fh);
+ struct vb2_queue *vq = v4l2_m2m_get_vq(ctx->m2m_ctx, f->type);
+ struct rot_frame *frame;
+ struct v4l2_pix_format_mplane *pixm = &f->fmt.pix_mp;
+ int i, ret = 0;
+
+ if (vb2_is_streaming(vq)) {
+ v4l2_err(&ctx->rot_dev->m2m.v4l2_dev, "device is busy\n");
+ return -EBUSY;
+ }
+
+ ret = rot_v4l2_try_fmt_mplane(file, fh, f);
+ if (ret < 0)
+ return ret;
+
+ frame = ctx_get_frame(ctx, f->type);
+ if (IS_ERR(frame))
+ return PTR_ERR(frame);
+
+ set_bit(CTX_PARAMS, &ctx->flags);
+
+ frame->rot_fmt = rot_find_format(f);
+ if (!frame->rot_fmt) {
+ v4l2_err(&ctx->rot_dev->m2m.v4l2_dev,
+ "not supported format values\n");
+ return -EINVAL;
+ }
+
+ rot_adjust_pixminfo(ctx, frame, pixm);
+
+ frame->pix_mp.pixelformat = pixm->pixelformat;
+ frame->pix_mp.width = pixm->width;
+ frame->pix_mp.height = pixm->height;
+
+ /*
+ * Shouldn't call s_crop or g_crop before called g_fmt or s_fmt.
+ * Let's assume that we can keep the order.
+ */
+ frame->crop.width = pixm->width;
+ frame->crop.height = pixm->height;
+
+ for (i = 0; i < frame->rot_fmt->num_planes; ++i)
+ frame->bytesused[i] = (pixm->width * pixm->height *
+ frame->rot_fmt->bitperpixel[i]) >> 3;
+
+ return 0;
+}
+
+static int rot_v4l2_reqbufs(struct file *file, void *fh,
+ struct v4l2_requestbuffers *reqbufs)
+{
+ struct rot_ctx *ctx = fh_to_rot_ctx(fh);
+ struct rot_frame *frame;
+
+ frame = ctx_get_frame(ctx, reqbufs->type);
+ if (IS_ERR(frame))
+ return PTR_ERR(frame);
+
+ if (frame == &ctx->s_frame)
+ clear_bit(CTX_SRC, &ctx->flags);
+ else if (frame == &ctx->d_frame)
+ clear_bit(CTX_DST, &ctx->flags);
+
+ return v4l2_m2m_reqbufs(file, ctx->m2m_ctx, reqbufs);
+}
+
+static int rot_v4l2_querybuf(struct file *file, void *fh,
+ struct v4l2_buffer *buf)
+{
+ struct rot_ctx *ctx = fh_to_rot_ctx(fh);
+ return v4l2_m2m_querybuf(file, ctx->m2m_ctx, buf);
+}
+
+static int rot_v4l2_qbuf(struct file *file, void *fh,
+ struct v4l2_buffer *buf)
+{
+ struct rot_ctx *ctx = fh_to_rot_ctx(fh);
+ return v4l2_m2m_qbuf(file, ctx->m2m_ctx, buf);
+}
+
+static int rot_v4l2_dqbuf(struct file *file, void *fh,
+ struct v4l2_buffer *buf)
+{
+ struct rot_ctx *ctx = fh_to_rot_ctx(fh);
+ return v4l2_m2m_dqbuf(file, ctx->m2m_ctx, buf);
+}
+
+static int rot_v4l2_streamon(struct file *file, void *fh,
+ enum v4l2_buf_type type)
+{
+ struct rot_ctx *ctx = fh_to_rot_ctx(fh);
+ return v4l2_m2m_streamon(file, ctx->m2m_ctx, type);
+}
+
+static int rot_v4l2_streamoff(struct file *file, void *fh,
+ enum v4l2_buf_type type)
+{
+ struct rot_ctx *ctx = fh_to_rot_ctx(fh);
+ return v4l2_m2m_streamoff(file, ctx->m2m_ctx, type);
+}
+
+static int rot_v4l2_cropcap(struct file *file, void *fh,
+ struct v4l2_cropcap *cr)
+{
+ struct rot_ctx *ctx = fh_to_rot_ctx(fh);
+ struct rot_frame *frame;
+
+ frame = ctx_get_frame(ctx, cr->type);
+ if (IS_ERR(frame))
+ return PTR_ERR(frame);
+
+ cr->bounds.left = 0;
+ cr->bounds.top = 0;
+ cr->bounds.width = frame->pix_mp.width;
+ cr->bounds.height = frame->pix_mp.height;
+ cr->defrect = cr->bounds;
+
+ return 0;
+}
+
+static int rot_v4l2_g_crop(struct file *file, void *fh, struct v4l2_crop *cr)
+{
+ struct rot_ctx *ctx = fh_to_rot_ctx(fh);
+ struct rot_frame *frame;
+
+ frame = ctx_get_frame(ctx, cr->type);
+ if (IS_ERR(frame))
+ return PTR_ERR(frame);
+
+ cr->c = frame->crop;
+
+ return 0;
+}
+
+static int rot_v4l2_s_crop(struct file *file, void *fh, struct v4l2_crop *cr)
+{
+ struct rot_ctx *ctx = fh_to_rot_ctx(fh);
+ struct rot_frame *frame;
+ struct v4l2_pix_format_mplane *pixm;
+ int i;
+
+ frame = ctx_get_frame(ctx, cr->type);
+ if (IS_ERR(frame))
+ return PTR_ERR(frame);
+
+ if (!test_bit(CTX_PARAMS, &ctx->flags)) {
+ v4l2_err(&ctx->rot_dev->m2m.v4l2_dev,
+ "color format is not set\n");
+ return -EINVAL;
+ }
+
+ if (cr->c.left < 0 || cr->c.top < 0 ||
+ cr->c.width < 0 || cr->c.height < 0) {
+ v4l2_err(&ctx->rot_dev->m2m.v4l2_dev,
+ "crop value is negative\n");
+ return -EINVAL;
+ }
+
+ pixm = &frame->pix_mp;
+ rot_adjust_cropinfo(ctx, frame, &cr->c);
+ rot_bound_align_image(ctx, frame->rot_fmt, &cr->c.width, &cr->c.height);
+
+ /* Adjust left/top if cropping rectangle is out of bounds */
+ if (cr->c.left + cr->c.width > pixm->width) {
+ dev_warn(ctx->rot_dev->dev,
+ "out of bound left cropping size:left %d, width %d\n",
+ cr->c.left, cr->c.width);
+ cr->c.left = pixm->width - cr->c.width;
+ }
+ if (cr->c.top + cr->c.height > pixm->height) {
+ dev_warn(ctx->rot_dev->dev,
+ "out of bound top cropping size:top %d, height %d\n",
+ cr->c.top, cr->c.height);
+ cr->c.top = pixm->height - cr->c.height;
+ }
+
+ frame->crop = cr->c;
+
+ for (i = 0; i < frame->rot_fmt->num_planes; ++i)
+ frame->bytesused[i] = (cr->c.width * cr->c.height *
+ frame->rot_fmt->bitperpixel[i]) >> 3;
+
+ return 0;
+}
+
+static const struct v4l2_ioctl_ops rot_v4l2_ioctl_ops = {
+ .vidioc_querycap = rot_v4l2_querycap,
+
+ .vidioc_enum_fmt_vid_cap_mplane = rot_v4l2_enum_fmt_mplane,
+ .vidioc_enum_fmt_vid_out_mplane = rot_v4l2_enum_fmt_mplane,
+
+ .vidioc_g_fmt_vid_cap_mplane = rot_v4l2_g_fmt_mplane,
+ .vidioc_g_fmt_vid_out_mplane = rot_v4l2_g_fmt_mplane,
+
+ .vidioc_try_fmt_vid_cap_mplane = rot_v4l2_try_fmt_mplane,
+ .vidioc_try_fmt_vid_out_mplane = rot_v4l2_try_fmt_mplane,
+
+ .vidioc_s_fmt_vid_cap_mplane = rot_v4l2_s_fmt_mplane,
+ .vidioc_s_fmt_vid_out_mplane = rot_v4l2_s_fmt_mplane,
+
+ .vidioc_reqbufs = rot_v4l2_reqbufs,
+ .vidioc_querybuf = rot_v4l2_querybuf,
+
+ .vidioc_qbuf = rot_v4l2_qbuf,
+ .vidioc_dqbuf = rot_v4l2_dqbuf,
+
+ .vidioc_streamon = rot_v4l2_streamon,
+ .vidioc_streamoff = rot_v4l2_streamoff,
+
+ .vidioc_g_crop = rot_v4l2_g_crop,
+ .vidioc_s_crop = rot_v4l2_s_crop,
+ .vidioc_cropcap = rot_v4l2_cropcap
+};
+
+static int rot_ctx_stop_req(struct rot_ctx *ctx)
+{
+ struct rot_ctx *curr_ctx;
+ struct rot_dev *rot = ctx->rot_dev;
+ int ret = 0;
+
+ curr_ctx = v4l2_m2m_get_curr_priv(rot->m2m.m2m_dev);
+ if (!test_bit(CTX_RUN, &ctx->flags) || (curr_ctx != ctx))
+ return 0;
+
+ set_bit(CTX_ABORT, &ctx->flags);
+
+ ret = wait_event_timeout(rot->irq.wait,
+ !test_bit(CTX_RUN, &ctx->flags), ROT_TIMEOUT);
+
+ /* TODO: How to handle case of timeout event */
+ if (ret == 0) {
+ dev_err(rot->dev, "device failed to stop request\n");
+ ret = -EBUSY;
+ }
+
+ return ret;
+}
+
+static int rot_vb2_queue_setup(struct vb2_queue *vq,
+ const struct v4l2_format *fmt, unsigned int *num_buffers,
+ unsigned int *num_planes, unsigned int sizes[],
+ void *allocators[])
+{
+ struct rot_ctx *ctx = vb2_get_drv_priv(vq);
+ struct rot_frame *frame;
+ int i;
+
+ frame = ctx_get_frame(ctx, vq->type);
+ if (IS_ERR(frame))
+ return PTR_ERR(frame);
+
+ /* Get number of planes from format_list in driver */
+ *num_planes = frame->rot_fmt->num_planes;
+ for (i = 0; i < frame->rot_fmt->num_planes; i++) {
+ sizes[i] = (frame->pix_mp.width * frame->pix_mp.height *
+ frame->rot_fmt->bitperpixel[i]) >> 3;
+ allocators[i] = ctx->rot_dev->alloc_ctx;
+ }
+
+ return 0;
+}
+
+static int rot_vb2_buf_prepare(struct vb2_buffer *vb)
+{
+ struct rot_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
+ struct rot_frame *frame;
+ int i;
+
+ frame = ctx_get_frame(ctx, vb->vb2_queue->type);
+ if (IS_ERR(frame))
+ return PTR_ERR(frame);
+
+ if (!V4L2_TYPE_IS_OUTPUT(vb->vb2_queue->type)) {
+ for (i = 0; i < frame->rot_fmt->num_planes; i++)
+ vb2_set_plane_payload(vb, i, frame->bytesused[i]);
+ }
+
+ return 0;
+}
+
+static void rot_vb2_buf_queue(struct vb2_buffer *vb)
+{
+ struct rot_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
+
+ if (ctx->m2m_ctx)
+ v4l2_m2m_buf_queue(ctx->m2m_ctx, vb);
+}
+
+static void rot_vb2_lock(struct vb2_queue *vq)
+{
+ struct rot_ctx *ctx = vb2_get_drv_priv(vq);
+ mutex_lock(&ctx->rot_dev->lock);
+}
+
+static void rot_vb2_unlock(struct vb2_queue *vq)
+{
+ struct rot_ctx *ctx = vb2_get_drv_priv(vq);
+ mutex_unlock(&ctx->rot_dev->lock);
+}
+
+static int rot_vb2_start_streaming(struct vb2_queue *vq, unsigned int count)
+{
+ struct rot_ctx *ctx = vb2_get_drv_priv(vq);
+ set_bit(CTX_STREAMING, &ctx->flags);
+
+ return 0;
+}
+
+static int rot_vb2_stop_streaming(struct vb2_queue *vq)
+{
+ struct rot_ctx *ctx = vb2_get_drv_priv(vq);
+ int ret;
+
+ ret = rot_ctx_stop_req(ctx);
+ if (ret < 0)
+ dev_err(ctx->rot_dev->dev, "wait timeout\n");
+
+ clear_bit(CTX_STREAMING, &ctx->flags);
+
+ return ret;
+}
+
+static struct vb2_ops rot_vb2_ops = {
+ .queue_setup = rot_vb2_queue_setup,
+ .buf_prepare = rot_vb2_buf_prepare,
+ .buf_queue = rot_vb2_buf_queue,
+ .wait_finish = rot_vb2_lock,
+ .wait_prepare = rot_vb2_unlock,
+ .start_streaming = rot_vb2_start_streaming,
+ .stop_streaming = rot_vb2_stop_streaming,
+};
+
+static int queue_init(void *priv, struct vb2_queue *src_vq,
+ struct vb2_queue *dst_vq)
+{
+ struct rot_ctx *ctx = priv;
+ int ret;
+
+ memset(src_vq, 0, sizeof(*src_vq));
+ src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
+ src_vq->io_modes = VB2_MMAP | VB2_USERPTR;
+ src_vq->ops = &rot_vb2_ops;
+ src_vq->mem_ops = &vb2_dma_contig_memops;
+ src_vq->drv_priv = ctx;
+ src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);
+
+ ret = vb2_queue_init(src_vq);
+ if (ret)
+ return ret;
+
+ memset(dst_vq, 0, sizeof(*dst_vq));
+ dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+ dst_vq->io_modes = VB2_MMAP | VB2_USERPTR;
+ dst_vq->ops = &rot_vb2_ops;
+ dst_vq->mem_ops = &vb2_dma_contig_memops;
+ dst_vq->drv_priv = ctx;
+ dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);
+
+ return vb2_queue_init(dst_vq);
+}
+
+static int rot_s_ctrl(struct v4l2_ctrl *ctrl)
+{
+ struct rot_ctx *ctx;
+ unsigned long flags;
+ int ret = 0;
+
+ ctx = container_of(ctrl->handler, struct rot_ctx, ctrl_handler);
+ spin_lock_irqsave(&ctx->slock, flags);
+
+ rot_dbg("ctrl ID:%d, value:%d\n", ctrl->id, ctrl->val);
+ switch (ctrl->id) {
+ case V4L2_CID_VFLIP:
+ if (ctrl->val)
+ ctx->flip |= ROT_VFLIP;
+ else
+ ctx->flip &= ~ROT_VFLIP;
+ break;
+ case V4L2_CID_HFLIP:
+ if (ctrl->val)
+ ctx->flip |= ROT_HFLIP;
+ else
+ ctx->flip &= ~ROT_HFLIP;
+ break;
+ case V4L2_CID_ROTATE:
+ ctx->rotation = ctrl->val;
+ break;
+ default:
+ v4l2_err(&ctx->rot_dev->m2m.v4l2_dev, "invalid control id\n");
+ ret = -EINVAL;
+ }
+
+ spin_unlock_irqrestore(&ctx->slock, flags);
+
+ return ret;
+}
+
+static const struct v4l2_ctrl_ops rot_ctrl_ops = {
+ .s_ctrl = rot_s_ctrl,
+};
+
+static int rot_add_ctrls(struct rot_ctx *ctx)
+{
+ v4l2_ctrl_handler_init(&ctx->ctrl_handler, 4);
+ v4l2_ctrl_new_std(&ctx->ctrl_handler, &rot_ctrl_ops,
+ V4L2_CID_VFLIP, 0, 1, 1, 0);
+ v4l2_ctrl_new_std(&ctx->ctrl_handler, &rot_ctrl_ops,
+ V4L2_CID_HFLIP, 0, 1, 1, 0);
+ v4l2_ctrl_new_std(&ctx->ctrl_handler, &rot_ctrl_ops,
+ V4L2_CID_ROTATE, 0, 270, 90, 0);
+
+ if (ctx->ctrl_handler.error) {
+ int err = ctx->ctrl_handler.error;
+ v4l2_err(&ctx->rot_dev->m2m.v4l2_dev,
+ "v4l2_ctrl_handler_init failed\n");
+ v4l2_ctrl_handler_free(&ctx->ctrl_handler);
+ return err;
+ }
+
+ return 0;
+}
+
+static int rot_open(struct file *file)
+{
+ struct rot_dev *rot = video_drvdata(file);
+ struct rot_ctx *ctx = NULL;
+ int ret;
+
+ ctx = kzalloc(sizeof *ctx, GFP_KERNEL);
+ if (!ctx) {
+ dev_err(rot->dev, "no memory for open context\n");
+ return -ENOMEM;
+ }
+
+ atomic_inc(&rot->m2m.in_use);
+ ctx->rot_dev = rot;
+
+ v4l2_fh_init(&ctx->fh, rot->m2m.vfd);
+ ret = rot_add_ctrls(ctx);
+ if (ret)
+ goto err_fh;
+
+ ctx->fh.ctrl_handler = &ctx->ctrl_handler;
+ file->private_data = &ctx->fh;
+ v4l2_fh_add(&ctx->fh);
+
+ /* Default color format */
+ ctx->s_frame.rot_fmt = &rot_formats[0];
+ ctx->d_frame.rot_fmt = &rot_formats[0];
+ init_waitqueue_head(&rot->irq.wait);
+ spin_lock_init(&ctx->slock);
+
+ /* Setup the device context for mem2mem mode. */
+ ctx->m2m_ctx = v4l2_m2m_ctx_init(rot->m2m.m2m_dev, ctx, queue_init);
+ if (IS_ERR(ctx->m2m_ctx)) {
+ ret = -EINVAL;
+ goto err_ctx;
+ }
+
+ return 0;
+
+err_ctx:
+ v4l2_fh_del(&ctx->fh);
+err_fh:
+ v4l2_ctrl_handler_free(&ctx->ctrl_handler);
+ v4l2_fh_exit(&ctx->fh);
+ atomic_dec(&rot->m2m.in_use);
+ kfree(ctx);
+
+ return ret;
+}
+
+static int rot_release(struct file *file)
+{
+ struct rot_ctx *ctx = fh_to_rot_ctx(file->private_data);
+ struct rot_dev *rot = ctx->rot_dev;
+
+ rot_dbg("refcnt= %d", atomic_read(&rot->m2m.in_use));
+
+ v4l2_m2m_ctx_release(ctx->m2m_ctx);
+ v4l2_ctrl_handler_free(&ctx->ctrl_handler);
+ v4l2_fh_del(&ctx->fh);
+ v4l2_fh_exit(&ctx->fh);
+ atomic_dec(&rot->m2m.in_use);
+ kfree(ctx);
+
+ return 0;
+}
+
+static unsigned int rot_poll(struct file *file,
+ struct poll_table_struct *wait)
+{
+ struct rot_ctx *ctx = fh_to_rot_ctx(file->private_data);
+
+ return v4l2_m2m_poll(file, ctx->m2m_ctx, wait);
+}
+
+static int rot_mmap(struct file *file, struct vm_area_struct *vma)
+{
+ struct rot_ctx *ctx = fh_to_rot_ctx(file->private_data);
+
+ return v4l2_m2m_mmap(file, ctx->m2m_ctx, vma);
+}
+
+static const struct v4l2_file_operations rot_v4l2_fops = {
+ .owner = THIS_MODULE,
+ .open = rot_open,
+ .release = rot_release,
+ .poll = rot_poll,
+ .unlocked_ioctl = video_ioctl2,
+ .mmap = rot_mmap,
+};
+
+static void rot_watchdog(unsigned long arg)
+{
+ struct rot_dev *rot = (struct rot_dev *)arg;
+ struct rot_ctx *ctx;
+ unsigned long flags;
+ struct vb2_buffer *src_vb, *dst_vb;
+
+ rot_dbg("timeout watchdog\n");
+ if (atomic_read(&rot->wdt.cnt) >= ROT_WDT_CNT) {
+ pm_runtime_put(rot->dev);
+
+ rot_dbg("wakeup blocked process\n");
+ atomic_set(&rot->wdt.cnt, 0);
+ clear_bit(DEV_RUN, &rot->state);
+
+ ctx = v4l2_m2m_get_curr_priv(rot->m2m.m2m_dev);
+ if (!ctx || !ctx->m2m_ctx) {
+ dev_err(rot->dev, "current ctx is NULL\n");
+ return;
+ }
+ spin_lock_irqsave(&rot->slock, flags);
+ clear_bit(CTX_RUN, &ctx->flags);
+ src_vb = v4l2_m2m_src_buf_remove(ctx->m2m_ctx);
+ dst_vb = v4l2_m2m_dst_buf_remove(ctx->m2m_ctx);
+
+ if (src_vb && dst_vb) {
+ v4l2_m2m_buf_done(src_vb, VB2_BUF_STATE_ERROR);
+ v4l2_m2m_buf_done(dst_vb, VB2_BUF_STATE_ERROR);
+
+ v4l2_m2m_job_finish(rot->m2m.m2m_dev, ctx->m2m_ctx);
+ }
+ spin_unlock_irqrestore(&rot->slock, flags);
+ return;
+ }
+
+ if (test_bit(DEV_RUN, &rot->state)) {
+ atomic_inc(&rot->wdt.cnt);
+ dev_err(rot->dev, "rotator is still running\n");
+ rot->wdt.timer.expires = jiffies + ROT_TIMEOUT;
+ add_timer(&rot->wdt.timer);
+ } else {
+ rot_dbg("rotator finished job\n");
+ }
+}
+
+static irqreturn_t rot_irq_handler(int irq, void *priv)
+{
+ struct rot_dev *rot = priv;
+ struct rot_ctx *ctx;
+ struct vb2_buffer *src_vb, *dst_vb;
+ unsigned int irq_src;
+
+ spin_lock(&rot->slock);
+
+ clear_bit(DEV_RUN, &rot->state);
+ if (timer_pending(&rot->wdt.timer))
+ del_timer(&rot->wdt.timer);
+
+ rot_hwget_irq_src(rot, &irq_src);
+ rot_hwset_irq_clear(rot, &irq_src);
+
+ if (irq_src != ISR_PEND_DONE) {
+ dev_err(rot->dev, "####################\n");
+ dev_err(rot->dev, "set SFR illegally\n");
+ dev_err(rot->dev, "maybe the result is wrong\n");
+ dev_err(rot->dev, "####################\n");
+ rot_dump_register(rot);
+ }
+
+ ctx = v4l2_m2m_get_curr_priv(rot->m2m.m2m_dev);
+ if (!ctx || !ctx->m2m_ctx) {
+ dev_err(rot->dev, "current ctx is NULL\n");
+ goto isr_unlock;
+ }
+
+ clear_bit(CTX_RUN, &ctx->flags);
+
+ src_vb = v4l2_m2m_src_buf_remove(ctx->m2m_ctx);
+ dst_vb = v4l2_m2m_dst_buf_remove(ctx->m2m_ctx);
+
+ if (src_vb && dst_vb) {
+ v4l2_m2m_buf_done(src_vb, VB2_BUF_STATE_DONE);
+ v4l2_m2m_buf_done(dst_vb, VB2_BUF_STATE_DONE);
+
+ if (test_bit(DEV_SUSPEND, &rot->state)) {
+ rot_dbg("wake up blocked process by suspend\n");
+ wake_up(&rot->irq.wait);
+ } else {
+ v4l2_m2m_job_finish(rot->m2m.m2m_dev, ctx->m2m_ctx);
+ }
+
+ /* Wake up from CTX_ABORT state */
+ if (test_and_clear_bit(CTX_ABORT, &ctx->flags))
+ wake_up(&rot->irq.wait);
+
+ pm_runtime_put(rot->dev);
+ } else {
+ dev_err(rot->dev, "failed to get the buffer done\n");
+ }
+
+isr_unlock:
+ spin_unlock(&rot->slock);
+
+ return IRQ_HANDLED;
+}
+
+static void rot_get_bufaddr(struct rot_dev *rot, struct vb2_buffer *vb,
+ struct rot_frame *frame, struct rot_addr *addr)
+{
+ unsigned int pix_size;
+
+ pix_size = frame->pix_mp.width * frame->pix_mp.height;
+
+ addr->y = vb2_dma_contig_plane_dma_addr(vb, 0);
+ addr->cb = 0;
+ addr->cr = 0;
+
+ switch (frame->rot_fmt->num_comp) {
+ case 2:
+ if (frame->rot_fmt->num_planes == 1)
+ addr->cb = addr->y + pix_size;
+ else if (frame->rot_fmt->num_planes == 2)
+ addr->cb = vb2_dma_contig_plane_dma_addr(vb, 1);
+ break;
+ case 3:
+ if (frame->rot_fmt->num_planes == 3) {
+ addr->cb = vb2_dma_contig_plane_dma_addr(vb, 1);
+ addr->cr = vb2_dma_contig_plane_dma_addr(vb, 2);
+ }
+ break;
+ default:
+ break;
+ }
+}
+
+static void rot_set_frame_addr(struct rot_ctx *ctx)
+{
+ struct vb2_buffer *vb;
+ struct rot_frame *s_frame, *d_frame;
+ struct rot_dev *rot = ctx->rot_dev;
+
+ s_frame = &ctx->s_frame;
+ d_frame = &ctx->d_frame;
+
+ /* set source buffer address */
+ vb = v4l2_m2m_next_src_buf(ctx->m2m_ctx);
+ rot_get_bufaddr(rot, vb, s_frame, &s_frame->addr);
+
+ rot_hwset_src_addr(rot, s_frame->addr.y, ROT_ADDR_Y);
+ rot_hwset_src_addr(rot, s_frame->addr.cb, ROT_ADDR_CB);
+ rot_hwset_src_addr(rot, s_frame->addr.cr, ROT_ADDR_CR);
+
+ /* set destination buffer address */
+ vb = v4l2_m2m_next_dst_buf(ctx->m2m_ctx);
+ rot_get_bufaddr(rot, vb, d_frame, &d_frame->addr);
+
+ rot_hwset_dst_addr(rot, d_frame->addr.y, ROT_ADDR_Y);
+ rot_hwset_dst_addr(rot, d_frame->addr.cb, ROT_ADDR_CB);
+ rot_hwset_dst_addr(rot, d_frame->addr.cr, ROT_ADDR_CR);
+}
+
+static void rot_mapping_flip(struct rot_ctx *ctx, u32 *degree, u32 *flip)
+{
+ *degree = ctx->rotation;
+ *flip = ctx->flip;
+
+ if (ctx->flip == (ROT_VFLIP | ROT_HFLIP)) {
+ *flip = ROT_NOFLIP;
+ switch (ctx->rotation) {
+ case 0:
+ *degree = 180;
+ break;
+ case 90:
+ *degree = 270;
+ break;
+ case 180:
+ *degree = 0;
+ break;
+ case 270:
+ *degree = 90;
+ break;
+ }
+ }
+}
+
+static void rot_m2m_device_run(void *priv)
+{
+ struct rot_ctx *ctx = priv;
+ struct rot_frame *s_frame, *d_frame;
+ struct rot_dev *rot;
+ unsigned long flags, tmp;
+ u32 degree = 0, flip = 0;
+
+ spin_lock_irqsave(&ctx->slock, flags);
+
+ rot = ctx->rot_dev;
+
+ if (test_bit(DEV_RUN, &rot->state)) {
+ dev_err(rot->dev, "Rotator is already in progress\n");
+ goto run_unlock;
+ }
+
+ if (test_bit(DEV_SUSPEND, &rot->state)) {
+ dev_err(rot->dev, "Rotator is in suspend state\n");
+ goto run_unlock;
+ }
+
+ if (test_bit(CTX_ABORT, &ctx->flags)) {
+ rot_dbg("aborted rot device run\n");
+ goto run_unlock;
+ }
+
+ pm_runtime_get_sync(ctx->rot_dev->dev);
+
+ s_frame = &ctx->s_frame;
+ d_frame = &ctx->d_frame;
+
+ /* Configuration rotator registers */
+ rot_hwset_image_format(rot, s_frame->rot_fmt->pixelformat);
+ rot_mapping_flip(ctx, °ree, &flip);
+ rot_hwset_flip(rot, flip);
+ rot_hwset_rotation(rot, degree);
+
+ if (ctx->rotation == 90 || ctx->rotation == 270) {
+ tmp = d_frame->pix_mp.height;
+ d_frame->pix_mp.height = d_frame->pix_mp.width;
+ d_frame->pix_mp.width = tmp;
+ }
+
+ rot_hwset_src_imgsize(rot, s_frame);
+ rot_hwset_dst_imgsize(rot, d_frame);
+
+ rot_hwset_src_crop(rot, &s_frame->crop);
+ rot_hwset_dst_crop(rot, &d_frame->crop);
+
+ rot_set_frame_addr(ctx);
+
+ /* Enable rotator interrupt */
+ rot_hwset_irq_frame_done(rot, 1);
+ rot_hwset_irq_illegal_config(rot, 1);
+
+ set_bit(DEV_RUN, &rot->state);
+ set_bit(CTX_RUN, &ctx->flags);
+
+ /* Start rotate operation */
+ rot_hwset_start(rot);
+
+ /* Start watchdog timer */
+ rot->wdt.timer.expires = jiffies + ROT_TIMEOUT;
+ if (timer_pending(&rot->wdt.timer) == 0)
+ add_timer(&rot->wdt.timer);
+ else
+ mod_timer(&rot->wdt.timer, rot->wdt.timer.expires);
+
+run_unlock:
+ spin_unlock_irqrestore(&ctx->slock, flags);
+}
+
+static void rot_m2m_job_abort(void *priv)
+{
+ struct rot_ctx *ctx = priv;
+ int ret;
+
+ ret = rot_ctx_stop_req(ctx);
+ if (ret < 0)
+ dev_err(ctx->rot_dev->dev, "wait timeout\n");
+}
+
+static struct v4l2_m2m_ops rot_m2m_ops = {
+ .device_run = rot_m2m_device_run,
+ .job_abort = rot_m2m_job_abort,
+};
+
+static int rot_register_m2m_device(struct rot_dev *rot)
+{
+ struct v4l2_device *v4l2_dev;
+ struct device *dev;
+ struct video_device *vfd;
+ int ret = 0;
+
+ if (!rot)
+ return -ENODEV;
+
+ dev = rot->dev;
+ v4l2_dev = &rot->m2m.v4l2_dev;
+
+ snprintf(v4l2_dev->name, sizeof(v4l2_dev->name), "%s.m2m",
+ MODULE_NAME);
+
+ ret = v4l2_device_register(dev, v4l2_dev);
+ if (ret) {
+ dev_err(rot->dev, "failed to register v4l2 device\n");
+ return ret;
+ }
+
+ vfd = video_device_alloc();
+ if (!vfd) {
+ dev_err(rot->dev, "failed to allocate video device\n");
+ goto err_v4l2_dev;
+ }
+
+ vfd->fops = &rot_v4l2_fops;
+ vfd->ioctl_ops = &rot_v4l2_ioctl_ops;
+ vfd->release = video_device_release;
+ snprintf(vfd->name, sizeof(vfd->name), "%s:m2m", MODULE_NAME);
+
+ video_set_drvdata(vfd, rot);
+
+ rot->m2m.vfd = vfd;
+ rot->m2m.m2m_dev = v4l2_m2m_init(&rot_m2m_ops);
+ if (IS_ERR(rot->m2m.m2m_dev)) {
+ dev_err(rot->dev, "failed to initialize v4l2-m2m device\n");
+ ret = PTR_ERR(rot->m2m.m2m_dev);
+ goto err_dev_alloc;
+ }
+
+ ret = video_register_device(vfd, VFL_TYPE_GRABBER, -1);
+ if (ret) {
+ dev_err(rot->dev, "failed to register video device\n");
+ goto err_m2m_dev;
+ }
+
+ return 0;
+
+err_m2m_dev:
+ v4l2_m2m_release(rot->m2m.m2m_dev);
+err_dev_alloc:
+ video_device_release(rot->m2m.vfd);
+err_v4l2_dev:
+ v4l2_device_unregister(v4l2_dev);
+
+ return ret;
+}
+
+static int rot_suspend(struct device *dev)
+{
+ struct rot_dev *rot;
+ int ret = 0;
+
+ rot = dev_get_drvdata(dev);
+ set_bit(DEV_SUSPEND, &rot->state);
+
+ ret = wait_event_timeout(rot->irq.wait,
+ !test_bit(DEV_RUN, &rot->state), ROT_TIMEOUT);
+ if (ret == 0)
+ dev_err(rot->dev, "wait timeout\n");
+
+ return 0;
+}
+
+static int rot_resume(struct device *dev)
+{
+ struct rot_dev *rot;
+
+ rot = dev_get_drvdata(dev);
+ clear_bit(DEV_SUSPEND, &rot->state);
+
+ return 0;
+}
+
+static int rot_runtime_suspend(struct device *dev)
+{
+ struct rot_dev *rot;
+ struct platform_device *pdev;
+
+ pdev = to_platform_device(dev);
+ rot = (struct rot_dev *)platform_get_drvdata(pdev);
+
+ clk_disable(rot->clock);
+
+ return 0;
+}
+
+static int rot_runtime_resume(struct device *dev)
+{
+ struct rot_dev *rot;
+ struct platform_device *pdev;
+
+ pdev = to_platform_device(dev);
+ rot = (struct rot_dev *)platform_get_drvdata(pdev);
+
+ clk_enable(rot->clock);
+
+ return 0;
+}
+
+static const struct dev_pm_ops rot_pm_ops = {
+ .suspend = rot_suspend,
+ .resume = rot_resume,
+ .runtime_suspend = rot_runtime_suspend,
+ .runtime_resume = rot_runtime_resume,
+};
+
+static int rot_probe(struct platform_device *pdev)
+{
+ struct exynos_rot_driverdata *drv_data;
+ struct rot_dev *rot;
+ struct resource *res;
+ int variant_num, ret = 0;
+
+ dev_info(&pdev->dev, "++%s\n", __func__);
+ drv_data = (struct exynos_rot_driverdata *)
+ platform_get_device_id(pdev)->driver_data;
+
+ if (pdev->id >= drv_data->nr_dev) {
+ dev_err(&pdev->dev, "Invalid platform device id\n");
+ return -EINVAL;
+ }
+
+ rot = devm_kzalloc(&pdev->dev, sizeof(struct rot_dev), GFP_KERNEL);
+ if (!rot) {
+ dev_err(&pdev->dev, "no memory for rotator device\n");
+ return -ENOMEM;
+ }
+
+ rot->dev = &pdev->dev;
+ rot->id = pdev->id;
+ variant_num = (rot->id < 0) ? 0 : rot->id;
+ rot->variant = drv_data->variant[variant_num];
+
+ spin_lock_init(&rot->slock);
+
+ /* Get memory resource and map SFR region. */
+ res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+ rot->regs = devm_request_and_ioremap(&pdev->dev, res);
+ if (rot->regs == NULL) {
+ dev_err(&pdev->dev, "failed to claim register region\n");
+ return -ENOENT;
+ }
+
+ /* Get IRQ resource and register IRQ handler. */
+ res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+ if (res == NULL) {
+ dev_err(&pdev->dev, "failed to get IRQ resource\n");
+ return -ENXIO;
+ }
+ rot->irq.num = res->start;
+
+ ret = devm_request_irq(&pdev->dev, rot->irq.num, rot_irq_handler, 0,
+ pdev->name, rot);
+ if (ret) {
+ dev_err(&pdev->dev, "failed to install irq\n");
+ return ret;
+ }
+
+ atomic_set(&rot->wdt.cnt, 0);
+ setup_timer(&rot->wdt.timer, rot_watchdog, (unsigned long)rot);
+
+ rot->clock = clk_get(rot->dev, "rotator");
+ if (IS_ERR(rot->clock)) {
+ dev_err(&pdev->dev, "failed to get clock for rotator\n");
+ return -ENXIO;
+ }
+
+ rot->alloc_ctx = vb2_dma_contig_init_ctx(&pdev->dev);
+ if (IS_ERR(rot->alloc_ctx)) {
+ dev_err(&pdev->dev, "failed to get alloc_ctx\n");
+ ret = -EPERM;
+ goto err;
+ }
+
+ ret = rot_register_m2m_device(rot);
+ if (ret) {
+ dev_err(&pdev->dev, "failed to register m2m device\n");
+ ret = -EPERM;
+ goto err;
+ }
+
+#ifdef CONFIG_PM_RUNTIME
+ pm_runtime_enable(&pdev->dev);
+#else
+ rot_runtime_resume(&pdev->dev);
+#endif
+
+ dev_info(&pdev->dev, "rotator registered successfully\n");
+
+ return 0;
+
+err:
+ clk_put(rot->clock);
+ return ret;
+}
+
+static int rot_remove(struct platform_device *pdev)
+{
+ struct rot_dev *rot = (struct rot_dev *)platform_get_drvdata(pdev);
+
+ clk_put(rot->clock);
+#ifdef CONFIG_PM_RUNTIME
+ pm_runtime_disable(&pdev->dev);
+#else
+ rot_runtime_suspend(&pdev->dev);
+#endif
+
+ if (timer_pending(&rot->wdt.timer))
+ del_timer(&rot->wdt.timer);
+
+ return 0;
+}
+
+static struct exynos_rot_variant rot_variant_exynos = {
+ .limit_rgb565 = {
+ .min_x = 16,
+ .min_y = 16,
+ .max_x = SZ_16K,
+ .max_y = SZ_16K,
+ .align = 2,
+ },
+ .limit_rgb888 = {
+ .min_x = 8,
+ .min_y = 8,
+ .max_x = SZ_8K,
+ .max_y = SZ_8K,
+ .align = 2,
+ },
+ .limit_yuv422 = {
+ .min_x = 16,
+ .min_y = 16,
+ .max_x = SZ_16K,
+ .max_y = SZ_16K,
+ .align = 2,
+ },
+ .limit_yuv420_2p = {
+ .min_x = 32,
+ .min_y = 32,
+ .max_x = SZ_32K,
+ .max_y = SZ_32K,
+ .align = 3,
+ },
+ .limit_yuv420_3p = {
+ .min_x = 64,
+ .min_y = 32,
+ .max_x = SZ_32K,
+ .max_y = SZ_32K,
+ .align = 4,
+ },
+};
+
+static struct exynos_rot_driverdata rot_drvdata_exynos = {
+ .variant = {
+ [0] = &rot_variant_exynos,
+ },
+ .nr_dev = 1,
+};
+
+static struct platform_device_id rot_driver_ids[] = {
+ {
+ .name = MODULE_NAME,
+ .driver_data = (unsigned long)&rot_drvdata_exynos,
+ },
+ {},
+};
+
+static struct platform_driver rot_driver = {
+ .probe = rot_probe,
+ .remove = rot_remove,
+ .id_table = rot_driver_ids,
+ .driver = {
+ .name = MODULE_NAME,
+ .owner = THIS_MODULE,
+ .pm = &rot_pm_ops,
+ }
+};
+
+module_platform_driver(rot_driver);
+
+MODULE_AUTHOR("Sunyoung, Kang <sy0816.k...@samsung.com>");
+MODULE_AUTHOR("Ayoung, Sim <a....@samsung.com>");
+MODULE_DESCRIPTION("Exynos Image Rotator driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/video/exynos/rotator/rotator-regs.c
b/drivers/media/video/exynos/rotator/rotator-regs.c
new file mode 100644
index 0000000..dcb71cf
--- /dev/null
+++ b/drivers/media/video/exynos/rotator/rotator-regs.c
@@ -0,0 +1,215 @@
+/*
+ * Copyright (c) 2012 Samsung Electronics Co., Ltd.
+ * http://www.samsung.com
+ *
+ * Register interface file for Exynos Rotator driver
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+*/
+
+#include "rotator.h"
+
+void rot_hwset_irq_frame_done(struct rot_dev *rot, u32 enable)
+{
+ unsigned long cfg = readl(rot->regs + ROTATOR_CONFIG);
+
+ if (enable)
+ cfg |= ROTATOR_CONFIG_IRQ_DONE;
+ else
+ cfg &= ~ROTATOR_CONFIG_IRQ_DONE;
+
+ writel(cfg, rot->regs + ROTATOR_CONFIG);
+}
+
+void rot_hwset_irq_illegal_config(struct rot_dev *rot, u32 enable)
+{
+ unsigned long cfg = readl(rot->regs + ROTATOR_CONFIG);
+
+ if (enable)
+ cfg |= ROTATOR_CONFIG_IRQ_ILLEGAL;
+ else
+ cfg &= ~ROTATOR_CONFIG_IRQ_ILLEGAL;
+
+ writel(cfg, rot->regs + ROTATOR_CONFIG);
+}
+
+int rot_hwset_image_format(struct rot_dev *rot, u32 pixelformat)
+{
+ unsigned long cfg = readl(rot->regs + ROTATOR_CONTROL);
+ cfg &= ~ROTATOR_CONTROL_FMT_MASK;
+
+ switch (pixelformat) {
+ case V4L2_PIX_FMT_YUV420M:
+ cfg |= ROTATOR_CONTROL_FMT_YCBCR420_3P;
+ break;
+ case V4L2_PIX_FMT_NV12M:
+ cfg |= ROTATOR_CONTROL_FMT_YCBCR420_2P;
+ break;
+ case V4L2_PIX_FMT_YUYV:
+ cfg |= ROTATOR_CONTROL_FMT_YCBCR422;
+ break;
+ case V4L2_PIX_FMT_RGB565:
+ cfg |= ROTATOR_CONTROL_FMT_RGB565;
+ break;
+ case V4L2_PIX_FMT_RGB32:
+ cfg |= ROTATOR_CONTROL_FMT_RGB888;
+ break;
+ default:
+ dev_err(rot->dev, "invalid pixelformat type\n");
+ return -EINVAL;
+ }
+ writel(cfg, rot->regs + ROTATOR_CONTROL);
+ return 0;
+}
+
+void rot_hwset_flip(struct rot_dev *rot, u32 direction)
+{
+ unsigned long cfg = readl(rot->regs + ROTATOR_CONTROL);
+ cfg &= ~ROTATOR_CONTROL_FLIP_MASK;
+
+ if (direction == ROT_VFLIP)
+ cfg |= ROTATOR_CONTROL_FLIP_V;
+ else if (direction == ROT_HFLIP)
+ cfg |= ROTATOR_CONTROL_FLIP_H;
+
+ writel(cfg, rot->regs + ROTATOR_CONTROL);
+}
+
+void rot_hwset_rotation(struct rot_dev *rot, int degree)
+{
+ unsigned long cfg = readl(rot->regs + ROTATOR_CONTROL);
+ cfg &= ~ROTATOR_CONTROL_ROT_MASK;
+
+ if (degree == 90)
+ cfg |= ROTATOR_CONTROL_ROT_90;
+ else if (degree == 180)
+ cfg |= ROTATOR_CONTROL_ROT_180;
+ else if (degree == 270)
+ cfg |= ROTATOR_CONTROL_ROT_270;
+
+ writel(cfg, rot->regs + ROTATOR_CONTROL);
+}
+
+void rot_hwset_start(struct rot_dev *rot)
+{
+ unsigned long cfg = readl(rot->regs + ROTATOR_CONTROL);
+
+ cfg |= ROTATOR_CONTROL_START;
+
+ writel(cfg, rot->regs + ROTATOR_CONTROL);
+}
+
+void rot_hwset_src_addr(struct rot_dev *rot, dma_addr_t addr, u32 comp)
+{
+ writel(addr, rot->regs + ROTATOR_SRC_IMG_ADDR(comp));
+}
+
+void rot_hwset_dst_addr(struct rot_dev *rot, dma_addr_t addr, u32 comp)
+{
+ writel(addr, rot->regs + ROTATOR_DST_IMG_ADDR(comp));
+}
+
+void rot_hwset_src_imgsize(struct rot_dev *rot, struct rot_frame *frame)
+{
+ unsigned long cfg;
+
+ cfg = ROTATOR_SRCIMG_YSIZE(frame->pix_mp.height) |
+ ROTATOR_SRCIMG_XSIZE(frame->pix_mp.width);
+
+ writel(cfg, rot->regs + ROTATOR_SRCIMG);
+
+ cfg = ROTATOR_SRCROT_YSIZE(frame->pix_mp.height) |
+ ROTATOR_SRCROT_XSIZE(frame->pix_mp.width);
+
+ writel(cfg, rot->regs + ROTATOR_SRCROT);
+}
+
+void rot_hwset_src_crop(struct rot_dev *rot, struct v4l2_rect *rect)
+{
+ unsigned long cfg;
+
+ cfg = ROTATOR_SRC_Y(rect->top) |
+ ROTATOR_SRC_X(rect->left);
+
+ writel(cfg, rot->regs + ROTATOR_SRC);
+
+ cfg = ROTATOR_SRCROT_YSIZE(rect->height) |
+ ROTATOR_SRCROT_XSIZE(rect->width);
+
+ writel(cfg, rot->regs + ROTATOR_SRCROT);
+}
+
+void rot_hwset_dst_imgsize(struct rot_dev *rot, struct rot_frame *frame)
+{
+ unsigned long cfg;
+
+ cfg = ROTATOR_DSTIMG_YSIZE(frame->pix_mp.height) |
+ ROTATOR_DSTIMG_XSIZE(frame->pix_mp.width);
+
+ writel(cfg, rot->regs + ROTATOR_DSTIMG);
+}
+
+void rot_hwset_dst_crop(struct rot_dev *rot, struct v4l2_rect *rect)
+{
+ unsigned long cfg;
+
+ cfg = ROTATOR_DST_Y(rect->top) |
+ ROTATOR_DST_X(rect->left);
+
+ writel(cfg, rot->regs + ROTATOR_DST);
+}
+
+void rot_hwget_irq_src(struct rot_dev *rot, enum rot_irq_src *irq)
+{
+ unsigned long cfg = readl(rot->regs + ROTATOR_STATUS);
+ cfg = ROTATOR_STATUS_IRQ(cfg);
+
+ if (cfg == 1)
+ *irq = ISR_PEND_DONE;
+ else if (cfg == 2)
+ *irq = ISR_PEND_ILLEGAL;
+}
+
+void rot_hwset_irq_clear(struct rot_dev *rot, enum rot_irq_src *irq)
+{
+ unsigned long cfg = readl(rot->regs + ROTATOR_STATUS);
+ cfg |= ROTATOR_STATUS_IRQ_PENDING((u32)irq);
+
+ writel(cfg, rot->regs + ROTATOR_STATUS);
+}
+
+void rot_hwget_status(struct rot_dev *rot, enum rot_status *state)
+{
+ unsigned long cfg;
+
+ cfg = readl(rot->regs + ROTATOR_STATUS);
+ cfg &= ROTATOR_STATUS_MASK;
+
+ switch (cfg) {
+ case 0:
+ *state = ROT_IDLE;
+ break;
+ case 1:
+ *state = ROT_RESERVED;
+ break;
+ case 2:
+ *state = ROT_RUNNING;
+ break;
+ case 3:
+ *state = ROT_RUNNING_REMAIN;
+ break;
+ };
+}
+
+void rot_dump_register(struct rot_dev *rot)
+{
+ unsigned int tmp, i;
+
+ rot_dbg("dump rotator registers\n");
+ for (i = 0; i <= ROTATOR_DST; i += 0x4) {
+ tmp = readl(rot->regs + i);
+ rot_dbg("0x%08x: 0x%08x", i, tmp);
+ }
+}
diff --git a/drivers/media/video/exynos/rotator/rotator-regs.h
b/drivers/media/video/exynos/rotator/rotator-regs.h
new file mode 100644
index 0000000..a603417
--- /dev/null
+++ b/drivers/media/video/exynos/rotator/rotator-regs.h
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2012 Samsung Electronics Co., Ltd.
+ * http://www.samsung.com
+ *
+ * Register header file for Exynos Rotator driver
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+*/
+
+/* Configuration */
+#define ROTATOR_CONFIG 0x00
+#define ROTATOR_CONFIG_IRQ_ILLEGAL (1 << 9)
+#define ROTATOR_CONFIG_IRQ_DONE (1 << 8)
+
+/* Image0 Control */
+#define ROTATOR_CONTROL 0x10
+#define ROTATOR_CONTROL_PATTERN_WRITE (1 << 16)
+#define ROTATOR_CONTROL_FMT_YCBCR420_3P (0 << 8)
+#define ROTATOR_CONTROL_FMT_YCBCR420_2P (1 << 8)
+#define ROTATOR_CONTROL_FMT_YCBCR422 (3 << 8)
+#define ROTATOR_CONTROL_FMT_RGB565 (4 << 8)
+#define ROTATOR_CONTROL_FMT_RGB888 (6 << 8)
+#define ROTATOR_CONTROL_FMT_MASK (7 << 8)
+#define ROTATOR_CONTROL_FLIP_V (2 << 6)
+#define ROTATOR_CONTROL_FLIP_H (3 << 6)
+#define ROTATOR_CONTROL_FLIP_MASK (3 << 6)
+#define ROTATOR_CONTROL_ROT_90 (1 << 4)
+#define ROTATOR_CONTROL_ROT_180 (2 << 4)
+#define ROTATOR_CONTROL_ROT_270 (3 << 4)
+#define ROTATOR_CONTROL_ROT_MASK (3 << 4)
+#define ROTATOR_CONTROL_START (1 << 0)
+
+/* Status */
+#define ROTATOR_STATUS 0x20
+#define ROTATOR_STATUS_IRQ_PENDING(x) (1 << (x))
+#define ROTATOR_STATUS_IRQ(x) (((x) >> 8) & 0x3)
+#define ROTATOR_STATUS_MASK (3 << 0)
+
+/* Sourc Image Base Address */
+#define ROTATOR_SRC_IMG_ADDR(n) (0x30 + ((n) << 2))
+
+/* Source Image X,Y Size */
+#define ROTATOR_SRCIMG 0x3c
+#define ROTATOR_SRCIMG_YSIZE(x) ((x) << 16)
+#define ROTATOR_SRCIMG_XSIZE(x) ((x) << 0)
+
+/* Source Image X,Y Coordinates */
+#define ROTATOR_SRC 0x40
+#define ROTATOR_SRC_Y(x) ((x) << 16)
+#define ROTATOR_SRC_X(x) ((x) << 0)
+
+/* Source Image Rotation Size */
+#define ROTATOR_SRCROT 0x44
+#define ROTATOR_SRCROT_YSIZE(x) ((x) << 16)
+#define ROTATOR_SRCROT_XSIZE(x) ((x) << 0)
+
+/* Destination Image Base Address */
+#define ROTATOR_DST_IMG_ADDR(n) (0x50 + ((n) << 2))
+
+/* Destination Image X,Y Size */
+#define ROTATOR_DSTIMG 0x5c
+#define ROTATOR_DSTIMG_YSIZE(x) ((x) << 16)
+#define ROTATOR_DSTIMG_XSIZE(x) ((x) << 0)
+
+/* Destination Image X,Y Coordinates */
+#define ROTATOR_DST 0x60
+#define ROTATOR_DST_Y(x) ((x) << 16)
+#define ROTATOR_DST_X(x) ((x) << 0)
diff --git a/drivers/media/video/exynos/rotator/rotator.h
b/drivers/media/video/exynos/rotator/rotator.h
new file mode 100644
index 0000000..4034383
--- /dev/null
+++ b/drivers/media/video/exynos/rotator/rotator.h
@@ -0,0 +1,286 @@
+/*
+ * Copyright (c) 2012 Samsung Electronics Co., Ltd.
+ * http://www.samsung.com
+ *
+ * Header file for Exynos Rotator driver
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+*/
+
+#ifndef ROTATOR__H_
+#define ROTATOR__H_
+
+#include <linux/delay.h>
+#include <linux/sched.h>
+#include <linux/spinlock.h>
+#include <linux/types.h>
+#include <linux/videodev2.h>
+#include <linux/io.h>
+#include <linux/pm_runtime.h>
+#include <media/videobuf2-core.h>
+#include <media/v4l2-ctrls.h>
+#include <media/v4l2-device.h>
+#include <media/v4l2-mem2mem.h>
+
+#include "rotator-regs.h"
+
+extern int log_level;
+
+#define rot_dbg(fmt, args...) \
+ do { \
+ if (log_level) \
+ printk(KERN_DEBUG "[%s:%d] " \
+ fmt, __func__, __LINE__, ##args); \
+ } while (0)
+
+/* Time to wait for frame done interrupt */
+#define ROT_TIMEOUT (2 * HZ)
+#define ROT_WDT_CNT 5
+#define MODULE_NAME "exynos-rot"
+#define ROT_MAX_DEVS 1
+
+/* Address index */
+#define ROT_ADDR_RGB 0
+#define ROT_ADDR_Y 0
+#define ROT_ADDR_CB 1
+#define ROT_ADDR_CBCR 1
+#define ROT_ADDR_CR 2
+
+/* Rotator flip direction */
+#define ROT_NOFLIP (1 << 0)
+#define ROT_VFLIP (1 << 1)
+#define ROT_HFLIP (1 << 2)
+
+/* Rotator hardware device state */
+#define DEV_RUN (1 << 0)
+#define DEV_SUSPEND (1 << 1)
+
+/* Rotator m2m context state */
+#define CTX_PARAMS (1 << 0)
+#define CTX_STREAMING (1 << 1)
+#define CTX_RUN (1 << 2)
+#define CTX_ABORT (1 << 3)
+#define CTX_SRC (1 << 4)
+#define CTX_DST (1 << 5)
+
+enum rot_irq_src {
+ ISR_PEND_DONE = 8,
+ ISR_PEND_ILLEGAL = 9,
+};
+
+enum rot_status {
+ ROT_IDLE,
+ ROT_RESERVED,
+ ROT_RUNNING,
+ ROT_RUNNING_REMAIN,
+};
+
+/*
+ * struct exynos_rot_size_limit - Rotator variant size information
+ *
+ * @min_x: minimum pixel x size
+ * @min_y: minimum pixel y size
+ * @max_x: maximum pixel x size
+ * @max_y: maximum pixel y size
+ */
+struct exynos_rot_size_limit {
+ u32 min_x;
+ u32 min_y;
+ u32 max_x;
+ u32 max_y;
+ u32 align;
+};
+
+struct exynos_rot_variant {
+ struct exynos_rot_size_limit limit_rgb565;
+ struct exynos_rot_size_limit limit_rgb888;
+ struct exynos_rot_size_limit limit_yuv422;
+ struct exynos_rot_size_limit limit_yuv420_2p;
+ struct exynos_rot_size_limit limit_yuv420_3p;
+};
+
+/*
+ * struct exynos_rot_driverdata - per device type driver data for init time.
+ *
+ * @variant: the variant information for this driver.
+ * @nr_dev: number of devices available in SoC
+ */
+struct exynos_rot_driverdata {
+ struct exynos_rot_variant *variant[ROT_MAX_DEVS];
+ int nr_dev;
+};
+
+/**
+ * struct rot_fmt - the driver's internal color format data
+ * @name: format description
+ * @pixelformat: the fourcc code for this format, 0 if not applicable
+ * @num_planes: number of physically non-contiguous data planes
+ * @num_comp: number of color components(ex. RGB, Y, Cb, Cr)
+ * @bitperpixel: bits per pixel
+ */
+struct rot_fmt {
+ char *name;
+ u32 pixelformat;
+ u16 num_planes;
+ u16 num_comp;
+ u32 bitperpixel[VIDEO_MAX_PLANES];
+};
+
+struct rot_addr {
+ dma_addr_t y;
+ dma_addr_t cb;
+ dma_addr_t cr;
+};
+
+/*
+ * struct rot_frame - source/target frame properties
+ * @fmt: buffer format(like virtual screen)
+ * @crop: image size / position
+ * @addr: buffer start address(access using ROT_ADDR_XXX)
+ * @bytesused: image size in bytes (w x h x bpp)
+ * @cacheable: cache property for image address
+ */
+struct rot_frame {
+ struct rot_fmt *rot_fmt;
+ struct v4l2_pix_format_mplane pix_mp;
+ struct v4l2_rect crop;
+ struct rot_addr addr;
+ unsigned long bytesused[VIDEO_MAX_PLANES];
+ bool cacheable;
+};
+
+/*
+ * struct rot_m2m_device - v4l2 memory-to-memory device data
+ * @v4l2_dev: v4l2 device
+ * @vfd: the video device node
+ * @m2m_dev: v4l2 memory-to-memory device data
+ * @in_use: the open count
+ */
+struct rot_m2m_device {
+ struct v4l2_device v4l2_dev;
+ struct video_device *vfd;
+ struct v4l2_m2m_dev *m2m_dev;
+ atomic_t in_use;
+};
+
+/*
+ * struct rot_irq - Rotator irq information
+ * @num: Rotator interrupt number
+ * @wait: interrupt handler waitqueue
+ */
+struct rot_irq {
+ int num;
+ wait_queue_head_t wait;
+};
+
+struct rot_wdt {
+ struct timer_list timer;
+ atomic_t cnt;
+};
+
+struct rot_ctx;
+struct rot_vb2;
+
+/*
+ * struct rot_dev - the abstraction for Rotator device
+ * @dev: pointer to the Rotator device
+ * @pdata: pointer to the device platform data
+ * @variant: the IP variant information
+ * @m2m: memory-to-memory V4L2 device information
+ * @id: Rotator device index (0..ROT_MAX_DEVS)
+ * @clock: clock required for Rotator operation
+ * @regs: the mapped hardware registers
+ * @regs_res: the resource claimed for IO registers
+ * @irq: irq information
+ * @ws: work struct
+ * @state: device state flags
+ * @alloc_ctx: videobuf2 memory allocator context
+ * @rot_vb2: videobuf2 memory allocator callbacks
+ * @slock: the spinlock protecting this data structure
+ * @lock: the mutex protecting this data structure
+ * @wdt: watchdog timer information
+ */
+struct rot_dev {
+ struct device *dev;
+ struct exynos_platform_rot *pdata;
+ struct exynos_rot_variant *variant;
+ struct rot_m2m_device m2m;
+ int id;
+ struct clk *clock;
+ void __iomem *regs;
+ struct rot_irq irq;
+ struct work_struct ws;
+ unsigned long state;
+ struct vb2_alloc_ctx *alloc_ctx;
+ const struct rot_vb2 *vb2;
+ spinlock_t slock;
+ struct mutex lock;
+ struct rot_wdt wdt;
+};
+
+/*
+ * rot_ctx - the abstration for Rotator open context
+ * @rot_dev: the Rotator device this context applies to
+ * @m2m_ctx: memory-to-memory device context
+ * @frame: source frame properties
+ * @ctrl_handler: v4l2 controls handler
+ * @fh: v4l2 file handle
+ * @rotation: image clockwise rotation in degrees
+ * @flip: image flip mode
+ * @state: context state flags
+ * @slock: spinlock protecting this data structure
+ */
+struct rot_ctx {
+ struct rot_dev *rot_dev;
+ struct v4l2_m2m_ctx *m2m_ctx;
+ struct rot_frame s_frame;
+ struct rot_frame d_frame;
+ struct v4l2_ctrl_handler ctrl_handler;
+ struct v4l2_fh fh;
+ int rotation;
+ u32 flip;
+ unsigned long flags;
+ spinlock_t slock;
+};
+
+static inline struct rot_frame *ctx_get_frame(struct rot_ctx *ctx,
+ enum v4l2_buf_type type)
+{
+ struct rot_frame *frame;
+
+ if (V4L2_TYPE_IS_MULTIPLANAR(type)) {
+ if (type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
+ frame = &ctx->s_frame;
+ else
+ frame = &ctx->d_frame;
+ } else {
+ dev_err(ctx->rot_dev->dev,
+ "Wrong V4L2 buffer type %d\n", type);
+ return ERR_PTR(-EINVAL);
+ }
+
+ return frame;
+}
+
+#define fh_to_rot_ctx(__fh) container_of(__fh, struct rot_ctx, fh)
+
+void rot_hwset_irq_frame_done(struct rot_dev *rot, u32 enable);
+void rot_hwset_irq_illegal_config(struct rot_dev *rot, u32 enable);
+int rot_hwset_image_format(struct rot_dev *rot, u32 pixelformat);
+void rot_hwset_flip(struct rot_dev *rot, u32 direction);
+void rot_hwset_rotation(struct rot_dev *rot, int degree);
+void rot_hwset_start(struct rot_dev *rot);
+void rot_hwset_src_addr(struct rot_dev *rot, dma_addr_t addr, u32 comp);
+void rot_hwset_dst_addr(struct rot_dev *rot, dma_addr_t addr, u32 comp);
+void rot_hwset_src_imgsize(struct rot_dev *rot, struct rot_frame *frame);
+void rot_hwset_src_crop(struct rot_dev *rot, struct v4l2_rect *rect);
+void rot_hwset_dst_imgsize(struct rot_dev *rot, struct rot_frame *frame);
+void rot_hwset_dst_crop(struct rot_dev *rot, struct v4l2_rect *rect);
+void rot_hwget_irq_src(struct rot_dev *rot, enum rot_irq_src *irq);
+void rot_hwset_irq_clear(struct rot_dev *rot, enum rot_irq_src *irq);
+void rot_hwget_status(struct rot_dev *rot, enum rot_status *state);
+void rot_dump_register(struct rot_dev *rot);
+
+#endif /* ROTATOR__H_ */
--
1.7.1
--
To unsubscribe from this list: send the line "unsubscribe linux-media" in
the body of a message to majord...@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
