samsung update 1

1 files changed, 742 insertions, 0 deletions

diff --git a/drivers/media/video/samsung/tvout/s5p_vp_ctrl.c b/drivers/media/video/samsung/tvout/s5p_vp_ctrl.c
new file mode 100644
index 0000000..d074da3
--- /dev/null
+++ b/drivers/media/video/samsung/tvout/s5p_vp_ctrl.c
@@ -0,0 +1,742 @@
+/* linux/drivers/media/video/samsung/tvout/s5p_vp_ctrl.c
+ *
+ * Copyright (c) 2009 Samsung Electronics
+ *		http://www.samsung.com/
+ *
+ * Control class functions for S5P video processor
+ *
+ * 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/delay.h>
+#include <linux/clk.h>
+#include <linux/err.h>
+#include <linux/io.h>
+#include <linux/slab.h>
+
+#include "hw_if/hw_if.h"
+#include "s5p_tvout_ctrl.h"
+
+#if defined(CONFIG_BUSFREQ)
+#include <mach/cpufreq.h>
+#endif
+
+#define INTERLACED	0
+#define PROGRESSIVE	1
+
+struct s5p_vp_ctrl_op_mode {
+	bool	ipc;
+	bool	line_skip;
+	bool	auto_toggling;
+};
+
+struct s5p_vp_ctrl_bc_line_eq {
+	enum s5p_vp_line_eq	eq_num;
+	u32			intc;
+	u32			slope;
+};
+
+struct s5p_vp_ctrl_rect {
+	u32 x;
+	u32 y;
+	u32 w;
+	u32 h;
+};
+
+struct s5p_vp_ctrl_plane {
+	u32			top_y_addr;
+	u32			top_c_addr;
+	u32			w;
+	u32			h;
+
+	enum s5p_vp_src_color	color_t;
+	enum s5p_vp_field	field_id;
+	enum s5p_vp_mem_type	mem_type;
+	enum s5p_vp_mem_mode	mem_mode;
+};
+
+struct s5p_vp_ctrl_pp_param {
+	bool				bypass;
+
+	bool csc_en;
+	enum s5p_vp_csc_type		csc_t;
+	bool				csc_default_coef;
+	bool				csc_sub_y_offset_en;
+
+	u32				saturation;
+	u8				contrast;
+	bool				brightness;
+	u32				bright_offset;
+	struct s5p_vp_ctrl_bc_line_eq	bc_line_eq[8];
+
+	/* sharpness */
+	u32				th_hnoise;
+	enum s5p_vp_sharpness_control	sharpness;
+
+
+	bool				default_poly_filter;
+
+	enum s5p_vp_chroma_expansion	chroma_exp;
+};
+
+struct s5p_vp_ctrl_mixer_param {
+	bool	blend;
+	u32	alpha;
+	u32	prio;
+};
+
+struct s5p_vp_ctrl_private_data {
+	struct s5p_vp_ctrl_plane	src_plane;
+	struct s5p_vp_ctrl_rect		src_win;
+
+	struct s5p_vp_ctrl_rect		dst_win;
+	struct s5p_vp_ctrl_op_mode	op_mode;
+
+	struct s5p_vp_ctrl_pp_param	pp_param;
+	struct s5p_vp_ctrl_mixer_param	mixer_param;
+
+	bool				running;
+
+	struct reg_mem_info		reg_mem;
+
+	struct s5p_tvout_clk_info	clk;
+	char				*pow_name;
+
+	struct device *dev;
+};
+
+static struct s5p_vp_ctrl_private_data s5p_vp_ctrl_private = {
+	.reg_mem = {
+		.name			= "s5p-vp",
+		.res			= NULL,
+		.base			= NULL
+	},
+
+	.clk = {
+		.name			= "vp",
+		.ptr			= NULL
+	},
+
+	.pow_name			= "vp_pd",
+
+	.src_plane = {
+		.field_id		= VP_TOP_FIELD,
+	},
+
+	.pp_param = {
+		.default_poly_filter	= true,
+		.bypass			= false,
+
+		.saturation		= 0x80,
+		.brightness		= 0x00,
+		.bright_offset		= 0x00,
+		.contrast		= 0x80,
+
+		.th_hnoise		= 0,
+		.sharpness		= VP_SHARPNESS_NO,
+
+		.chroma_exp		= 0,
+
+		.csc_en			= false,
+		.csc_default_coef	= true,
+		.csc_sub_y_offset_en	= false,
+	},
+
+	.running			= false
+};
+
+extern int s5p_vp_get_top_field_address(u32* top_y_addr, u32* top_c_addr);
+
+static u8 s5p_vp_ctrl_get_src_scan_mode(void)
+{
+	struct s5p_vp_ctrl_plane *src_plane = &s5p_vp_ctrl_private.src_plane;
+	u8 ret = PROGRESSIVE;
+
+	if (src_plane->color_t == VP_SRC_COLOR_NV12IW ||
+		src_plane->color_t == VP_SRC_COLOR_TILE_NV12IW ||
+		src_plane->color_t == VP_SRC_COLOR_NV21IW ||
+		src_plane->color_t == VP_SRC_COLOR_TILE_NV21IW)
+		ret = INTERLACED;
+
+	return ret;
+}
+
+static u8 s5p_vp_ctrl_get_dest_scan_mode(
+		enum s5p_tvout_disp_mode display, enum s5p_tvout_o_mode out)
+{
+	u8 ret = PROGRESSIVE;
+
+	switch (out) {
+	case TVOUT_COMPOSITE:
+		ret = INTERLACED;
+		break;
+
+	case TVOUT_HDMI_RGB:
+	case TVOUT_HDMI:
+	case TVOUT_DVI:
+		if (display == TVOUT_1080I_60 ||
+		   display == TVOUT_1080I_59 ||
+		   display == TVOUT_1080I_50)
+			ret = INTERLACED;
+		break;
+
+	default:
+		break;
+	}
+
+	return ret;
+}
+
+static void s5p_vp_ctrl_set_src_dst_win(
+		struct s5p_vp_ctrl_rect	src_win,
+		struct s5p_vp_ctrl_rect	dst_win,
+		enum s5p_tvout_disp_mode	disp,
+		enum s5p_tvout_o_mode	out,
+		enum s5p_vp_src_color	color_t,
+		bool ipc)
+{
+	struct s5p_vp_ctrl_op_mode *op_mode = &s5p_vp_ctrl_private.op_mode;
+
+	if (s5p_vp_ctrl_get_dest_scan_mode(disp, out) == INTERLACED) {
+		if (op_mode->line_skip) {
+			src_win.y /= 2;
+			src_win.h /= 2;
+		}
+
+		dst_win.y /= 2;
+		dst_win.h /= 2;
+	} else if (s5p_vp_ctrl_get_src_scan_mode() == INTERLACED) {
+		src_win.y /= 2;
+		src_win.h /= 2;
+	}
+
+	s5p_vp_set_src_position(src_win.x, 0, src_win.y);
+	s5p_vp_set_dest_position(dst_win.x, dst_win.y);
+	s5p_vp_set_src_dest_size(
+		src_win.w, src_win.h, dst_win.w, dst_win.h, ipc);
+}
+
+int s5p_vp_ctrl_get_src_addr(u32* top_y_addr, u32* top_c_addr)
+{
+	if (s5p_vp_ctrl_private.running)
+		s5p_vp_get_top_field_address(top_y_addr, top_c_addr);
+	else {
+		*top_y_addr = 0;
+		*top_c_addr = 0;
+	}
+
+	return 0;
+}
+
+static int s5p_vp_ctrl_set_src_addr(
+		u32 top_y_addr, u32 top_c_addr,
+		u32 img_w, enum s5p_vp_src_color color_t)
+{
+	if (s5p_vp_set_top_field_address(top_y_addr, top_c_addr))
+		return -1;
+
+	if (s5p_vp_ctrl_get_src_scan_mode() == INTERLACED) {
+		u32	bot_y = 0;
+		u32	bot_c = 0;
+
+		if (color_t == VP_SRC_COLOR_NV12IW ||
+				color_t == VP_SRC_COLOR_NV21IW) {
+			bot_y = top_y_addr + img_w;
+			bot_c = top_c_addr + img_w;
+		} else if (color_t == VP_SRC_COLOR_TILE_NV12IW ||
+				color_t == VP_SRC_COLOR_TILE_NV21IW) {
+			bot_y = top_y_addr + 0x40;
+			bot_c = top_c_addr + 0x40;
+		}
+
+		if (s5p_vp_set_bottom_field_address(bot_y, bot_c))
+			return -1;
+	}
+
+	return 0;
+}
+
+static void s5p_vp_ctrl_init_private(void)
+{
+	int i;
+	struct s5p_vp_ctrl_pp_param *pp_param = &s5p_vp_ctrl_private.pp_param;
+
+	for (i = 0; i < 8; i++)
+		pp_param->bc_line_eq[i].eq_num = VP_LINE_EQ_DEFAULT;
+}
+
+static int s5p_vp_ctrl_set_reg(void)
+{
+	int i;
+	int ret = 0;
+
+	enum s5p_tvout_disp_mode	tv_std;
+	enum s5p_tvout_o_mode		tv_if;
+
+	struct s5p_vp_ctrl_plane *src_plane = &s5p_vp_ctrl_private.src_plane;
+	struct s5p_vp_ctrl_pp_param *pp_param = &s5p_vp_ctrl_private.pp_param;
+	struct s5p_vp_ctrl_op_mode *op_mode = &s5p_vp_ctrl_private.op_mode;
+
+#ifdef CONFIG_HAS_EARLYSUSPEND
+	if (suspend_status) {
+		tvout_dbg("driver is suspend_status\n");
+	} else
+#endif
+	{
+		s5p_tvif_ctrl_get_std_if(&tv_std, &tv_if);
+
+		s5p_vp_sw_reset();
+
+		s5p_vp_set_endian(TVOUT_BIG_ENDIAN);
+
+		s5p_vp_set_op_mode(
+			op_mode->line_skip, src_plane->mem_type,
+			src_plane->mem_mode, pp_param->chroma_exp,
+			op_mode->auto_toggling);
+
+		s5p_vp_set_field_id(src_plane->field_id);
+
+		s5p_vp_set_img_size(src_plane->w, src_plane->h);
+
+		s5p_vp_ctrl_set_src_addr(
+			src_plane->top_y_addr, src_plane->top_c_addr,
+			src_plane->w, src_plane->color_t);
+
+		s5p_vp_ctrl_set_src_dst_win(
+			s5p_vp_ctrl_private.src_win,
+			s5p_vp_ctrl_private.dst_win,
+			tv_std,
+			tv_if,
+			s5p_vp_ctrl_private.src_plane.color_t,
+			op_mode->ipc);
+
+		if (pp_param->default_poly_filter)
+			s5p_vp_set_poly_filter_coef_default(
+				s5p_vp_ctrl_private.src_win.w,
+				s5p_vp_ctrl_private.src_win.h,
+				s5p_vp_ctrl_private.dst_win.w,
+				s5p_vp_ctrl_private.dst_win.h,
+				op_mode->ipc);
+
+		s5p_vp_set_bypass_post_process(pp_param->bypass);
+		s5p_vp_set_sharpness(pp_param->th_hnoise, pp_param->sharpness);
+		s5p_vp_set_saturation(pp_param->saturation);
+		s5p_vp_set_brightness_contrast(
+				pp_param->brightness, pp_param->contrast);
+
+		for (i = VP_LINE_EQ_0; i <= VP_LINE_EQ_7; i++) {
+			if (pp_param->bc_line_eq[i].eq_num == i)
+				ret = s5p_vp_set_brightness_contrast_control(
+					pp_param->bc_line_eq[i].eq_num,
+					pp_param->bc_line_eq[i].intc,
+					pp_param->bc_line_eq[i].slope);
+
+			if (ret != 0)
+				return -1;
+		}
+
+		s5p_vp_set_brightness_offset(pp_param->bright_offset);
+
+		s5p_vp_set_csc_control(
+				pp_param->csc_sub_y_offset_en,
+				pp_param->csc_en);
+
+		if (pp_param->csc_en && pp_param->csc_default_coef) {
+			if (s5p_vp_set_csc_coef_default(pp_param->csc_t))
+				return -1;
+		}
+
+		if (s5p_vp_start())
+			return -1;
+
+	}
+
+	s5p_mixer_ctrl_enable_layer(MIXER_VIDEO_LAYER);
+
+	mdelay(50);
+
+	return 0;
+}
+
+static void s5p_vp_ctrl_internal_stop(void)
+{
+#ifdef CONFIG_HAS_EARLYSUSPEND
+	if (suspend_status) {
+		tvout_dbg("driver is suspend_status\n");
+	} else
+#endif
+		s5p_vp_stop();
+
+	s5p_mixer_ctrl_disable_layer(MIXER_VIDEO_LAYER);
+}
+
+static void s5p_vp_ctrl_clock(bool on)
+{
+	if (on) {
+#ifdef CONFIG_ARCH_EXYNOS4
+		s5p_tvout_pm_runtime_get();
+#endif
+		clk_enable(s5p_vp_ctrl_private.clk.ptr);
+		// Restore vp_base address
+		s5p_vp_init(s5p_vp_ctrl_private.reg_mem.base);
+
+	} else {
+		clk_disable(s5p_vp_ctrl_private.clk.ptr);
+#ifdef CONFIG_ARCH_EXYNOS4
+		s5p_tvout_pm_runtime_put();
+#endif
+		// Set vp_base to NULL
+		s5p_vp_init(NULL);
+	}
+}
+
+
+
+void s5p_vp_ctrl_set_src_plane(
+		u32 base_y, u32 base_c,	u32 width, u32 height,
+		enum s5p_vp_src_color color, enum s5p_vp_field field)
+{
+	struct s5p_vp_ctrl_plane *src_plane = &s5p_vp_ctrl_private.src_plane;
+
+	src_plane->color_t	= color;
+	src_plane->field_id	= field;
+
+	src_plane->top_y_addr	= base_y;
+	src_plane->top_c_addr	= base_c;
+
+	src_plane->w		= width;
+	src_plane->h		= height;
+
+#ifdef CONFIG_HAS_EARLYSUSPEND
+	if (suspend_status) {
+		tvout_dbg("driver is suspend_status\n");
+		return;
+	}
+#endif
+	if (s5p_vp_ctrl_private.running) {
+		s5p_vp_set_img_size(width, height);
+
+		s5p_vp_set_field_id(field);
+		s5p_vp_ctrl_set_src_addr(base_y, base_c, width, color);
+
+		s5p_vp_update();
+	}
+}
+
+void s5p_vp_ctrl_set_src_win(u32 left, u32 top, u32 width, u32 height)
+{
+	struct s5p_vp_ctrl_rect *src_win = &s5p_vp_ctrl_private.src_win;
+
+	src_win->x = left;
+	src_win->y = top;
+	src_win->w = width;
+	src_win->h = height;
+
+#ifdef CONFIG_HAS_EARLYSUSPEND
+	if (suspend_status) {
+		tvout_dbg("driver is suspend_status\n");
+		return;
+	}
+#endif
+	if (s5p_vp_ctrl_private.running) {
+		enum s5p_tvout_disp_mode	tv_std;
+		enum s5p_tvout_o_mode		tv_if;
+
+		s5p_tvif_ctrl_get_std_if(&tv_std, &tv_if);
+
+		s5p_vp_ctrl_set_src_dst_win(
+			*src_win,
+			s5p_vp_ctrl_private.dst_win,
+			tv_std,
+			tv_if,
+			s5p_vp_ctrl_private.src_plane.color_t,
+			s5p_vp_ctrl_private.op_mode.ipc);
+
+		s5p_vp_update();
+	}
+}
+
+void s5p_vp_ctrl_set_dest_win(u32 left, u32 top, u32 width, u32 height)
+{
+	struct s5p_vp_ctrl_rect *dst_win = &s5p_vp_ctrl_private.dst_win;
+
+	dst_win->x = left;
+	dst_win->y = top;
+	dst_win->w = width;
+	dst_win->h = height;
+#ifdef CONFIG_HAS_EARLYSUSPEND
+	if (suspend_status) {
+		tvout_dbg("driver is suspend_status\n");
+		return;
+	}
+#endif
+	if (s5p_vp_ctrl_private.running) {
+		enum s5p_tvout_disp_mode	tv_std;
+		enum s5p_tvout_o_mode		tv_if;
+
+		s5p_tvif_ctrl_get_std_if(&tv_std, &tv_if);
+
+		s5p_vp_ctrl_set_src_dst_win(
+			s5p_vp_ctrl_private.src_win,
+			*dst_win,
+			tv_std,
+			tv_if,
+			s5p_vp_ctrl_private.src_plane.color_t,
+			s5p_vp_ctrl_private.op_mode.ipc);
+
+		s5p_vp_update();
+	}
+}
+
+void s5p_vp_ctrl_set_dest_win_alpha_val(u32 alpha)
+{
+	s5p_vp_ctrl_private.mixer_param.alpha = alpha;
+#ifdef CONFIG_HAS_EARLYSUSPEND
+	if (suspend_status) {
+		tvout_dbg("driver is suspend_status\n");
+		return;
+	}
+#endif
+	s5p_mixer_ctrl_set_alpha(MIXER_VIDEO_LAYER, alpha);
+}
+
+void s5p_vp_ctrl_set_dest_win_blend(bool enable)
+{
+	s5p_vp_ctrl_private.mixer_param.blend = enable;
+#ifdef CONFIG_HAS_EARLYSUSPEND
+	if (suspend_status) {
+		tvout_dbg("driver is suspend_status\n");
+		return;
+	}
+#endif
+	s5p_mixer_ctrl_set_blend_mode(MIXER_VIDEO_LAYER,
+			LAYER_BLENDING);
+}
+
+void s5p_vp_ctrl_set_dest_win_priority(u32 prio)
+{
+	s5p_vp_ctrl_private.mixer_param.prio = prio;
+#ifdef CONFIG_HAS_EARLYSUSPEND
+	if (suspend_status) {
+		tvout_dbg("driver is suspend_status\n");
+		return;
+	}
+#endif
+	s5p_mixer_ctrl_set_priority(MIXER_VIDEO_LAYER, prio);
+}
+
+void s5p_vp_ctrl_stop(void)
+{
+	if (s5p_vp_ctrl_private.running) {
+		s5p_vp_ctrl_internal_stop();
+#ifdef CONFIG_HAS_EARLYSUSPEND
+	if (suspend_status) {
+		tvout_dbg("driver is suspend_status\n");
+	} else
+#endif
+	{
+		s5p_vp_ctrl_clock(0);
+	}
+
+		s5p_vp_ctrl_private.running = false;
+#if defined(CONFIG_BUSFREQ) || defined(CONFIG_BUSFREQ_LOCK_WRAPPER)
+	exynos4_busfreq_lock_free(DVFS_LOCK_ID_TV);
+#endif
+	}
+}
+
+int s5p_vp_ctrl_start(void)
+{
+	struct s5p_vp_ctrl_plane *src_plane = &s5p_vp_ctrl_private.src_plane;
+	enum s5p_tvout_disp_mode disp;
+	enum s5p_tvout_o_mode out;
+
+	struct s5p_vp_ctrl_rect *src_win = &s5p_vp_ctrl_private.src_win;
+	struct s5p_vp_ctrl_rect *dst_win = &s5p_vp_ctrl_private.dst_win;
+
+	bool i_mode, o_mode; /* 0 for interlaced, 1 for progressive */
+
+	s5p_tvif_ctrl_get_std_if(&disp, &out);
+
+	switch (disp) {
+	case TVOUT_480P_60_16_9:
+	case TVOUT_480P_60_4_3:
+	case TVOUT_576P_50_16_9:
+	case TVOUT_576P_50_4_3:
+	case TVOUT_480P_59:
+		s5p_vp_ctrl_private.pp_param.csc_t = VP_CSC_SD_HD;
+		break;
+
+	case TVOUT_1080I_50:
+	case TVOUT_1080I_60:
+	case TVOUT_1080P_50:
+	case TVOUT_1080P_30:
+	case TVOUT_1080P_60:
+	case TVOUT_720P_59:
+	case TVOUT_1080I_59:
+	case TVOUT_1080P_59:
+	case TVOUT_720P_50:
+	case TVOUT_720P_60:
+		s5p_vp_ctrl_private.pp_param.csc_t = VP_CSC_HD_SD;
+		break;
+#ifdef CONFIG_HDMI_14A_3D
+	case TVOUT_720P_60_SBS_HALF:
+	case TVOUT_720P_59_SBS_HALF:
+	case TVOUT_720P_50_TB:
+	case TVOUT_1080P_24_TB:
+	case TVOUT_1080P_23_TB:
+		s5p_vp_ctrl_private.pp_param.csc_t = VP_CSC_HD_SD;
+		break;
+
+#endif
+
+	default:
+		break;
+	}
+
+	i_mode = s5p_vp_ctrl_get_src_scan_mode();
+	o_mode = s5p_vp_ctrl_get_dest_scan_mode(disp, out);
+
+	/* check o_mode */
+	if (i_mode == INTERLACED) {
+		if (o_mode == INTERLACED) {
+			/* i to i : line skip 1, ipc 0, auto toggle 0 */
+			s5p_vp_ctrl_private.op_mode.line_skip		= true;
+			s5p_vp_ctrl_private.op_mode.ipc			= false;
+			s5p_vp_ctrl_private.op_mode.auto_toggling	= false;
+		} else {
+			/* i to p : line skip 1, ipc 1, auto toggle 0 */
+			s5p_vp_ctrl_private.op_mode.line_skip		= true;
+			s5p_vp_ctrl_private.op_mode.ipc			= true;
+			s5p_vp_ctrl_private.op_mode.auto_toggling	= false;
+		}
+	} else {
+		if (o_mode == INTERLACED) {
+			/* p to i : line skip 0, ipc 0, auto toggle 0 */
+			if (dst_win->h > src_win->h &&
+			   ((dst_win->h << 16)/src_win->h < 0x100000))
+				s5p_vp_ctrl_private.op_mode.line_skip	= false;
+			/* p to i : line skip 1, ipc 0, auto toggle 0 */
+			else
+				s5p_vp_ctrl_private.op_mode.line_skip	= true;
+			s5p_vp_ctrl_private.op_mode.ipc			= false;
+			s5p_vp_ctrl_private.op_mode.auto_toggling	= false;
+		} else {
+			/* p to p : line skip 0, ipc 0, auto toggle 0 */
+			s5p_vp_ctrl_private.op_mode.line_skip		= false;
+			s5p_vp_ctrl_private.op_mode.ipc			= false;
+			s5p_vp_ctrl_private.op_mode.auto_toggling	= false;
+		}
+	}
+	src_plane->mem_type
+		= ((src_plane->color_t == VP_SRC_COLOR_NV12) ||
+			(src_plane->color_t == VP_SRC_COLOR_NV12IW) ||
+			(src_plane->color_t == VP_SRC_COLOR_TILE_NV12) ||
+			(src_plane->color_t == VP_SRC_COLOR_TILE_NV12IW)) ?
+			VP_YUV420_NV12 : VP_YUV420_NV21;
+
+	src_plane->mem_mode
+		= ((src_plane->color_t == VP_SRC_COLOR_NV12) ||
+			(src_plane->color_t == VP_SRC_COLOR_NV12IW) ||
+			(src_plane->color_t == VP_SRC_COLOR_NV21) ||
+			(src_plane->color_t == VP_SRC_COLOR_NV21IW)) ?
+			VP_LINEAR_MODE : VP_2D_TILE_MODE;
+
+	if (s5p_vp_ctrl_private.running)
+		s5p_vp_ctrl_internal_stop();
+	else {
+#ifdef CONFIG_HAS_EARLYSUSPEND
+		if (suspend_status) {
+			tvout_dbg("driver is suspend_status\n");
+		} else
+#endif
+		{
+#if defined(CONFIG_BUSFREQ) || defined(CONFIG_BUSFREQ_LOCK_WRAPPER)
+			if ((disp == TVOUT_1080P_60) || (disp == TVOUT_1080P_59)
+					|| (disp == TVOUT_1080P_50)) {
+				if (exynos4_busfreq_lock(DVFS_LOCK_ID_TV, BUS_L0))
+					printk(KERN_ERR "%s: failed lock DVFS\n", __func__);
+			}
+#endif
+			s5p_vp_ctrl_clock(1);
+		}
+		s5p_vp_ctrl_private.running = true;
+	}
+	s5p_vp_ctrl_set_reg();
+
+	return 0;
+}
+
+int s5p_vp_ctrl_constructor(struct platform_device *pdev)
+{
+	int ret = 0;
+
+	ret = s5p_tvout_map_resource_mem(
+		pdev,
+		s5p_vp_ctrl_private.reg_mem.name,
+		&(s5p_vp_ctrl_private.reg_mem.base),
+		&(s5p_vp_ctrl_private.reg_mem.res));
+
+	if (ret)
+		goto err_on_res;
+
+	s5p_vp_ctrl_private.clk.ptr =
+		clk_get(&pdev->dev, s5p_vp_ctrl_private.clk.name);
+
+	if (IS_ERR(s5p_vp_ctrl_private.clk.ptr)) {
+		tvout_err("Failed to find clock %s\n",
+			s5p_vp_ctrl_private.clk.name);
+		ret = -ENOENT;
+		goto err_on_clk;
+	}
+
+	s5p_vp_init(s5p_vp_ctrl_private.reg_mem.base);
+	s5p_vp_ctrl_init_private();
+
+	return 0;
+
+err_on_clk:
+	iounmap(s5p_vp_ctrl_private.reg_mem.base);
+	release_resource(s5p_vp_ctrl_private.reg_mem.res);
+	kfree(s5p_vp_ctrl_private.reg_mem.res);
+
+err_on_res:
+	return ret;
+}
+
+void s5p_vp_ctrl_destructor(void)
+{
+	if (s5p_vp_ctrl_private.reg_mem.base)
+		iounmap(s5p_vp_ctrl_private.reg_mem.base);
+
+	if (s5p_vp_ctrl_private.reg_mem.res) {
+		release_resource(s5p_vp_ctrl_private.reg_mem.res);
+		kfree(s5p_vp_ctrl_private.reg_mem.res);
+	}
+
+	if (s5p_vp_ctrl_private.clk.ptr) {
+		if (s5p_vp_ctrl_private.running)
+			clk_disable(s5p_vp_ctrl_private.clk.ptr);
+		clk_put(s5p_vp_ctrl_private.clk.ptr);
+	}
+}
+
+void s5p_vp_ctrl_suspend(void)
+{
+	tvout_dbg("running(%d)\n", s5p_vp_ctrl_private.running);
+	if (s5p_vp_ctrl_private.running) {
+		s5p_vp_stop();
+		s5p_vp_ctrl_clock(0);
+	}
+}
+
+void s5p_vp_ctrl_resume(void)
+{
+	tvout_dbg("running(%d)\n", s5p_vp_ctrl_private.running);
+	if (s5p_vp_ctrl_private.running) {
+		s5p_vp_ctrl_clock(1);
+		s5p_vp_ctrl_set_reg();
+	}
+}