[deliverable/linux.git] / drivers / media / video / s5p-tv / sdo_drv.c

/*
 * Samsung Standard Definition Output (SDO) driver
 *
 * Copyright (c) 2010-2011 Samsung Electronics Co., Ltd.
 *
 * Tomasz Stanislawski, <t.stanislaws@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 Foundiation. either version 2 of the License,
 * or (at your option) any later version
 */

#include <linux/clk.h>
#include <linux/delay.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/irq.h>
#include <linux/platform_device.h>
#include <linux/pm_runtime.h>
#include <linux/regulator/consumer.h>
#include <linux/slab.h>

#include <media/v4l2-subdev.h>

#include "regs-sdo.h"

MODULE_AUTHOR("Tomasz Stanislawski, <t.stanislaws@samsung.com>");
MODULE_DESCRIPTION("Samsung Standard Definition Output (SDO)");
MODULE_LICENSE("GPL");

#define SDO_DEFAULT_STD	V4L2_STD_PAL

struct sdo_format {
	v4l2_std_id id;
	/* all modes are 720 pixels wide */
	unsigned int height;
	unsigned int cookie;
};

struct sdo_device {
	/** pointer to device parent */
	struct device *dev;
	/** base address of SDO registers */
	void __iomem *regs;
	/** SDO interrupt */
	unsigned int irq;
	/** DAC source clock */
	struct clk *sclk_dac;
	/** DAC clock */
	struct clk *dac;
	/** DAC physical interface */
	struct clk *dacphy;
	/** clock for control of VPLL */
	struct clk *fout_vpll;
	/** regulator for SDO IP power */
	struct regulator *vdac;
	/** regulator for SDO plug detection */
	struct regulator *vdet;
	/** subdev used as device interface */
	struct v4l2_subdev sd;
	/** current format */
	const struct sdo_format *fmt;
};

static inline struct sdo_device *sd_to_sdev(struct v4l2_subdev *sd)
{
	return container_of(sd, struct sdo_device, sd);
}

static inline
void sdo_write_mask(struct sdo_device *sdev, u32 reg_id, u32 value, u32 mask)
{
	u32 old = readl(sdev->regs + reg_id);
	value = (value & mask) | (old & ~mask);
	writel(value, sdev->regs + reg_id);
}

static inline
void sdo_write(struct sdo_device *sdev, u32 reg_id, u32 value)
{
	writel(value, sdev->regs + reg_id);
}

static inline
u32 sdo_read(struct sdo_device *sdev, u32 reg_id)
{
	return readl(sdev->regs + reg_id);
}

static irqreturn_t sdo_irq_handler(int irq, void *dev_data)
{
	struct sdo_device *sdev = dev_data;

	/* clear interrupt */
	sdo_write_mask(sdev, SDO_IRQ, ~0, SDO_VSYNC_IRQ_PEND);
	return IRQ_HANDLED;
}

static void sdo_reg_debug(struct sdo_device *sdev)
{
#define DBGREG(reg_id) \
	dev_info(sdev->dev, #reg_id " = %08x\n", \
		sdo_read(sdev, reg_id))

	DBGREG(SDO_CLKCON);
	DBGREG(SDO_CONFIG);
	DBGREG(SDO_VBI);
	DBGREG(SDO_DAC);
	DBGREG(SDO_IRQ);
	DBGREG(SDO_IRQMASK);
	DBGREG(SDO_VERSION);
}

static const struct sdo_format sdo_format[] = {
	{ V4L2_STD_PAL_N,	.height = 576, .cookie = SDO_PAL_N },
	{ V4L2_STD_PAL_Nc,	.height = 576, .cookie = SDO_PAL_NC },
	{ V4L2_STD_PAL_M,	.height = 480, .cookie = SDO_PAL_M },
	{ V4L2_STD_PAL_60,	.height = 480, .cookie = SDO_PAL_60 },
	{ V4L2_STD_NTSC_443,	.height = 480, .cookie = SDO_NTSC_443 },
	{ V4L2_STD_PAL,		.height = 576, .cookie = SDO_PAL_BGHID },
	{ V4L2_STD_NTSC_M,	.height = 480, .cookie = SDO_NTSC_M },
};

static const struct sdo_format *sdo_find_format(v4l2_std_id id)
{
	int i;
	for (i = 0; i < ARRAY_SIZE(sdo_format); ++i)
		if (sdo_format[i].id & id)
			return &sdo_format[i];
	return NULL;
}

static int sdo_g_tvnorms_output(struct v4l2_subdev *sd, v4l2_std_id *std)
{
	*std = V4L2_STD_NTSC_M | V4L2_STD_PAL_M | V4L2_STD_PAL |
		V4L2_STD_PAL_N | V4L2_STD_PAL_Nc |
		V4L2_STD_NTSC_443 | V4L2_STD_PAL_60;
	return 0;
}

static int sdo_s_std_output(struct v4l2_subdev *sd, v4l2_std_id std)
{
	struct sdo_device *sdev = sd_to_sdev(sd);
	const struct sdo_format *fmt;
	fmt = sdo_find_format(std);
	if (fmt == NULL)
		return -EINVAL;
	sdev->fmt = fmt;
	return 0;
}

static int sdo_g_std_output(struct v4l2_subdev *sd, v4l2_std_id *std)
{
	*std = sd_to_sdev(sd)->fmt->id;
	return 0;
}

static int sdo_g_mbus_fmt(struct v4l2_subdev *sd,
	struct v4l2_mbus_framefmt *fmt)
{
	struct sdo_device *sdev = sd_to_sdev(sd);

	if (!sdev->fmt)
		return -ENXIO;
	/* all modes are 720 pixels wide */
	fmt->width = 720;
	fmt->height = sdev->fmt->height;
	fmt->code = V4L2_MBUS_FMT_FIXED;
	fmt->field = V4L2_FIELD_INTERLACED;
	return 0;
}

static int sdo_s_power(struct v4l2_subdev *sd, int on)
{
	struct sdo_device *sdev = sd_to_sdev(sd);
	struct device *dev = sdev->dev;
	int ret;

	dev_info(dev, "sdo_s_power(%d)\n", on);

	if (on)
		ret = pm_runtime_get_sync(dev);
	else
		ret = pm_runtime_put_sync(dev);

	/* only values < 0 indicate errors */
	return IS_ERR_VALUE(ret) ? ret : 0;
}

static int sdo_streamon(struct sdo_device *sdev)
{
	/* set proper clock for Timing Generator */
	clk_set_rate(sdev->fout_vpll, 54000000);
	dev_info(sdev->dev, "fout_vpll.rate = %lu\n",
	clk_get_rate(sdev->fout_vpll));
	/* enable clock in SDO */
	sdo_write_mask(sdev, SDO_CLKCON, ~0, SDO_TVOUT_CLOCK_ON);
	clk_enable(sdev->dacphy);
	/* enable DAC */
	sdo_write_mask(sdev, SDO_DAC, ~0, SDO_POWER_ON_DAC);
	sdo_reg_debug(sdev);
	return 0;
}

static int sdo_streamoff(struct sdo_device *sdev)
{
	int tries;

	sdo_write_mask(sdev, SDO_DAC, 0, SDO_POWER_ON_DAC);
	clk_disable(sdev->dacphy);
	sdo_write_mask(sdev, SDO_CLKCON, 0, SDO_TVOUT_CLOCK_ON);
	for (tries = 100; tries; --tries) {
		if (sdo_read(sdev, SDO_CLKCON) & SDO_TVOUT_CLOCK_READY)
			break;
		mdelay(1);
	}
	if (tries == 0)
		dev_err(sdev->dev, "failed to stop streaming\n");
	return tries ? 0 : -EIO;
}

static int sdo_s_stream(struct v4l2_subdev *sd, int on)
{
	struct sdo_device *sdev = sd_to_sdev(sd);
	return on ? sdo_streamon(sdev) : sdo_streamoff(sdev);
}

static const struct v4l2_subdev_core_ops sdo_sd_core_ops = {
	.s_power = sdo_s_power,
};

static const struct v4l2_subdev_video_ops sdo_sd_video_ops = {
	.s_std_output = sdo_s_std_output,
	.g_std_output = sdo_g_std_output,
	.g_tvnorms_output = sdo_g_tvnorms_output,
	.g_mbus_fmt = sdo_g_mbus_fmt,
	.s_stream = sdo_s_stream,
};

static const struct v4l2_subdev_ops sdo_sd_ops = {
	.core = &sdo_sd_core_ops,
	.video = &sdo_sd_video_ops,
};

static int sdo_runtime_suspend(struct device *dev)
{
	struct v4l2_subdev *sd = dev_get_drvdata(dev);
	struct sdo_device *sdev = sd_to_sdev(sd);

	dev_info(dev, "suspend\n");
	regulator_disable(sdev->vdet);
	regulator_disable(sdev->vdac);
	clk_disable(sdev->sclk_dac);
	return 0;
}

static int sdo_runtime_resume(struct device *dev)
{
	struct v4l2_subdev *sd = dev_get_drvdata(dev);
	struct sdo_device *sdev = sd_to_sdev(sd);

	dev_info(dev, "resume\n");
	clk_enable(sdev->sclk_dac);
	regulator_enable(sdev->vdac);
	regulator_enable(sdev->vdet);

	/* software reset */
	sdo_write_mask(sdev, SDO_CLKCON, ~0, SDO_TVOUT_SW_RESET);
	mdelay(10);
	sdo_write_mask(sdev, SDO_CLKCON, 0, SDO_TVOUT_SW_RESET);

	/* setting TV mode */
	sdo_write_mask(sdev, SDO_CONFIG, sdev->fmt->cookie, SDO_STANDARD_MASK);
	/* XXX: forcing interlaced mode using undocumented bit */
	sdo_write_mask(sdev, SDO_CONFIG, 0, SDO_PROGRESSIVE);
	/* turn all VBI off */
	sdo_write_mask(sdev, SDO_VBI, 0, SDO_CVBS_WSS_INS |
		SDO_CVBS_CLOSED_CAPTION_MASK);
	/* turn all post processing off */
	sdo_write_mask(sdev, SDO_CCCON, ~0, SDO_COMPENSATION_BHS_ADJ_OFF |
		SDO_COMPENSATION_CVBS_COMP_OFF);
	sdo_reg_debug(sdev);
	return 0;
}

static const struct dev_pm_ops sdo_pm_ops = {
	.runtime_suspend = sdo_runtime_suspend,
	.runtime_resume	 = sdo_runtime_resume,
};

static int __devinit sdo_probe(struct platform_device *pdev)
{
	struct device *dev = &pdev->dev;
	struct sdo_device *sdev;
	struct resource *res;
	int ret = 0;
	struct clk *sclk_vpll;

	dev_info(dev, "probe start\n");
	sdev = kzalloc(sizeof *sdev, GFP_KERNEL);
	if (!sdev) {
		dev_err(dev, "not enough memory.\n");
		ret = -ENOMEM;
		goto fail;
	}
	sdev->dev = dev;

	/* mapping registers */
	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (res == NULL) {
		dev_err(dev, "get memory resource failed.\n");
		ret = -ENXIO;
		goto fail_sdev;
	}

	sdev->regs = ioremap(res->start, resource_size(res));
	if (sdev->regs == NULL) {
		dev_err(dev, "register mapping failed.\n");
		ret = -ENXIO;
		goto fail_sdev;
	}

	/* acquiring interrupt */
	res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
	if (res == NULL) {
		dev_err(dev, "get interrupt resource failed.\n");
		ret = -ENXIO;
		goto fail_regs;
	}
	ret = request_irq(res->start, sdo_irq_handler, 0, "s5p-sdo", sdev);
	if (ret) {
		dev_err(dev, "request interrupt failed.\n");
		goto fail_regs;
	}
	sdev->irq = res->start;

	/* acquire clocks */
	sdev->sclk_dac = clk_get(dev, "sclk_dac");
	if (IS_ERR_OR_NULL(sdev->sclk_dac)) {
		dev_err(dev, "failed to get clock 'sclk_dac'\n");
		ret = -ENXIO;
		goto fail_irq;
	}
	sdev->dac = clk_get(dev, "dac");
	if (IS_ERR_OR_NULL(sdev->dac)) {
		dev_err(dev, "failed to get clock 'dac'\n");
		ret = -ENXIO;
		goto fail_sclk_dac;
	}
	sdev->dacphy = clk_get(dev, "dacphy");
	if (IS_ERR_OR_NULL(sdev->dacphy)) {
		dev_err(dev, "failed to get clock 'dacphy'\n");
		ret = -ENXIO;
		goto fail_dac;
	}
	sclk_vpll = clk_get(dev, "sclk_vpll");
	if (IS_ERR_OR_NULL(sclk_vpll)) {
		dev_err(dev, "failed to get clock 'sclk_vpll'\n");
		ret = -ENXIO;
		goto fail_dacphy;
	}
	clk_set_parent(sdev->sclk_dac, sclk_vpll);
	clk_put(sclk_vpll);
	sdev->fout_vpll = clk_get(dev, "fout_vpll");
	if (IS_ERR_OR_NULL(sdev->fout_vpll)) {
		dev_err(dev, "failed to get clock 'fout_vpll'\n");
		goto fail_dacphy;
	}
	dev_info(dev, "fout_vpll.rate = %lu\n", clk_get_rate(sclk_vpll));

	/* acquire regulator */
	sdev->vdac = regulator_get(dev, "vdd33a_dac");
	if (IS_ERR_OR_NULL(sdev->vdac)) {
		dev_err(dev, "failed to get regulator 'vdac'\n");
		goto fail_fout_vpll;
	}
	sdev->vdet = regulator_get(dev, "vdet");
	if (IS_ERR_OR_NULL(sdev->vdet)) {
		dev_err(dev, "failed to get regulator 'vdet'\n");
		goto fail_vdac;
	}

	/* enable gate for dac clock, because mixer uses it */
	clk_enable(sdev->dac);

	/* configure power management */
	pm_runtime_enable(dev);

	/* configuration of interface subdevice */
	v4l2_subdev_init(&sdev->sd, &sdo_sd_ops);
	sdev->sd.owner = THIS_MODULE;
	strlcpy(sdev->sd.name, "s5p-sdo", sizeof sdev->sd.name);

	/* set default format */
	sdev->fmt = sdo_find_format(SDO_DEFAULT_STD);
	BUG_ON(sdev->fmt == NULL);

	/* keeping subdev in device's private for use by other drivers */
	dev_set_drvdata(dev, &sdev->sd);

	dev_info(dev, "probe succeeded\n");
	return 0;

fail_vdac:
	regulator_put(sdev->vdac);
fail_fout_vpll:
	clk_put(sdev->fout_vpll);
fail_dacphy:
	clk_put(sdev->dacphy);
fail_dac:
	clk_put(sdev->dac);
fail_sclk_dac:
	clk_put(sdev->sclk_dac);
fail_irq:
	free_irq(sdev->irq, sdev);
fail_regs:
	iounmap(sdev->regs);
fail_sdev:
	kfree(sdev);
fail:
	dev_info(dev, "probe failed\n");
	return ret;
}

static int __devexit sdo_remove(struct platform_device *pdev)
{
	struct v4l2_subdev *sd = dev_get_drvdata(&pdev->dev);
	struct sdo_device *sdev = sd_to_sdev(sd);

	pm_runtime_disable(&pdev->dev);
	clk_disable(sdev->dac);
	regulator_put(sdev->vdet);
	regulator_put(sdev->vdac);
	clk_put(sdev->fout_vpll);
	clk_put(sdev->dacphy);
	clk_put(sdev->dac);
	clk_put(sdev->sclk_dac);
	free_irq(sdev->irq, sdev);
	iounmap(sdev->regs);
	kfree(sdev);

	dev_info(&pdev->dev, "remove successful\n");
	return 0;
}

static struct platform_driver sdo_driver __refdata = {
	.probe = sdo_probe,
	.remove = __devexit_p(sdo_remove),
	.driver = {
		.name = "s5p-sdo",
		.owner = THIS_MODULE,
		.pm = &sdo_pm_ops,
	}
};

static int __init sdo_init(void)
{
	int ret;
	static const char banner[] __initdata = KERN_INFO \
		"Samsung Standard Definition Output (SDO) driver, "
		"(c) 2010-2011 Samsung Electronics Co., Ltd.\n";
	printk(banner);

	ret = platform_driver_register(&sdo_driver);
	if (ret)
		printk(KERN_ERR "SDO platform driver register failed\n");

	return ret;
}
module_init(sdo_init);

static void __exit sdo_exit(void)
{
	platform_driver_unregister(&sdo_driver);
}
module_exit(sdo_exit);
Commit	Line	Data
9a498400 TS	1	/*
	2	* Samsung Standard Definition Output (SDO) driver
	3	*
	4	* Copyright (c) 2010-2011 Samsung Electronics Co., Ltd.
	5	*
	6	* Tomasz Stanislawski, <t.stanislaws@samsung.com>
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published
	10	* by the Free Software Foundiation. either version 2 of the License,
	11	* or (at your option) any later version
	12	*/
	13
	14	#include <linux/clk.h>
	15	#include <linux/delay.h>
	16	#include <linux/kernel.h>
	17	#include <linux/module.h>
	18	#include <linux/interrupt.h>
	19	#include <linux/io.h>
	20	#include <linux/irq.h>
	21	#include <linux/platform_device.h>
	22	#include <linux/pm_runtime.h>
	23	#include <linux/regulator/consumer.h>
	24	#include <linux/slab.h>
	25
	26	#include <media/v4l2-subdev.h>
	27
	28	#include "regs-sdo.h"
	29
	30	MODULE_AUTHOR("Tomasz Stanislawski, <t.stanislaws@samsung.com>");
	31	MODULE_DESCRIPTION("Samsung Standard Definition Output (SDO)");
	32	MODULE_LICENSE("GPL");
	33
	34	#define SDO_DEFAULT_STD V4L2_STD_PAL
	35
	36	struct sdo_format {
	37	v4l2_std_id id;
	38	/* all modes are 720 pixels wide */
	39	unsigned int height;
	40	unsigned int cookie;
	41	};
	42
	43	struct sdo_device {
	44	/** pointer to device parent */
	45	struct device *dev;
	46	/** base address of SDO registers */
	47	void __iomem *regs;
	48	/** SDO interrupt */
	49	unsigned int irq;
	50	/** DAC source clock */
	51	struct clk *sclk_dac;
	52	/** DAC clock */
	53	struct clk *dac;
	54	/** DAC physical interface */
	55	struct clk *dacphy;
	56	/** clock for control of VPLL */
	57	struct clk *fout_vpll;
	58	/** regulator for SDO IP power */
	59	struct regulator *vdac;
	60	/** regulator for SDO plug detection */
	61	struct regulator *vdet;
	62	/** subdev used as device interface */
	63	struct v4l2_subdev sd;
	64	/** current format */
65	const struct sdo_format *fmt;
66	};
67
68	static inline struct sdo_device sd_to_sdev(struct v4l2_subdev sd)
69	{
70	return container_of(sd, struct sdo_device, sd);
71	}
72
73	static inline
74	void sdo_write_mask(struct sdo_device *sdev, u32 reg_id, u32 value, u32 mask)
75	{
76	u32 old = readl(sdev->regs + reg_id);
77	value = (value & mask) \| (old & ~mask);
78	writel(value, sdev->regs + reg_id);
79	}
80
81	static inline
82	void sdo_write(struct sdo_device *sdev, u32 reg_id, u32 value)
83	{
84	writel(value, sdev->regs + reg_id);
85	}
86
87	static inline
88	u32 sdo_read(struct sdo_device *sdev, u32 reg_id)
89	{
90	return readl(sdev->regs + reg_id);
91	}
92
93	static irqreturn_t sdo_irq_handler(int irq, void *dev_data)
94	{
95	struct sdo_device *sdev = dev_data;
96
97	/* clear interrupt */
98	sdo_write_mask(sdev, SDO_IRQ, ~0, SDO_VSYNC_IRQ_PEND);
99	return IRQ_HANDLED;
100	}
101
102	static void sdo_reg_debug(struct sdo_device *sdev)
103	{
104	#define DBGREG(reg_id) \
105	dev_info(sdev->dev, #reg_id " = %08x\n", \
106	sdo_read(sdev, reg_id))
107
108	DBGREG(SDO_CLKCON);
109	DBGREG(SDO_CONFIG);
110	DBGREG(SDO_VBI);
111	DBGREG(SDO_DAC);
112	DBGREG(SDO_IRQ);
113	DBGREG(SDO_IRQMASK);
114	DBGREG(SDO_VERSION);
115	}
116
117	static const struct sdo_format sdo_format[] = {
118	{ V4L2_STD_PAL_N, .height = 576, .cookie = SDO_PAL_N },
119	{ V4L2_STD_PAL_Nc, .height = 576, .cookie = SDO_PAL_NC },
120	{ V4L2_STD_PAL_M, .height = 480, .cookie = SDO_PAL_M },
121	{ V4L2_STD_PAL_60, .height = 480, .cookie = SDO_PAL_60 },
122	{ V4L2_STD_NTSC_443, .height = 480, .cookie = SDO_NTSC_443 },
123	{ V4L2_STD_PAL, .height = 576, .cookie = SDO_PAL_BGHID },
124	{ V4L2_STD_NTSC_M, .height = 480, .cookie = SDO_NTSC_M },
125	};
126
127	static const struct sdo_format *sdo_find_format(v4l2_std_id id)
128	{
129	int i;
130	for (i = 0; i < ARRAY_SIZE(sdo_format); ++i)
131	if (sdo_format[i].id & id)
132	return &sdo_format[i];
133	return NULL;
134	}
135
136	static int sdo_g_tvnorms_output(struct v4l2_subdev sd, v4l2_std_id std)
137	{
138	*std = V4L2_STD_NTSC_M \| V4L2_STD_PAL_M \| V4L2_STD_PAL \|
139	V4L2_STD_PAL_N \| V4L2_STD_PAL_Nc \|
140	V4L2_STD_NTSC_443 \| V4L2_STD_PAL_60;
141	return 0;
142	}
143
144	static int sdo_s_std_output(struct v4l2_subdev *sd, v4l2_std_id std)
145	{
146	struct sdo_device *sdev = sd_to_sdev(sd);
147	const struct sdo_format *fmt;
148	fmt = sdo_find_format(std);
149	if (fmt == NULL)
150	return -EINVAL;
151	sdev->fmt = fmt;
152	return 0;
153	}
154
155	static int sdo_g_std_output(struct v4l2_subdev sd, v4l2_std_id std)
156	{
157	*std = sd_to_sdev(sd)->fmt->id;
158	return 0;
159	}
160
161	static int sdo_g_mbus_fmt(struct v4l2_subdev *sd,
162	struct v4l2_mbus_framefmt *fmt)
163	{
164	struct sdo_device *sdev = sd_to_sdev(sd);
165
166	if (!sdev->fmt)
167	return -ENXIO;
168	/* all modes are 720 pixels wide */
169	fmt->width = 720;
170	fmt->height = sdev->fmt->height;
171	fmt->code = V4L2_MBUS_FMT_FIXED;
172	fmt->field = V4L2_FIELD_INTERLACED;
173	return 0;
174	}
175
176	static int sdo_s_power(struct v4l2_subdev *sd, int on)
177	{
178	struct sdo_device *sdev = sd_to_sdev(sd);
179	struct device *dev = sdev->dev;
180	int ret;
181
182	dev_info(dev, "sdo_s_power(%d)\n", on);
183
184	if (on)
185	ret = pm_runtime_get_sync(dev);
186	else
187	ret = pm_runtime_put_sync(dev);
188
189	/* only values < 0 indicate errors */
190	return IS_ERR_VALUE(ret) ? ret : 0;
191	}
192
193	static int sdo_streamon(struct sdo_device *sdev)
194	{
195	/* set proper clock for Timing Generator */
196	clk_set_rate(sdev->fout_vpll, 54000000);
197	dev_info(sdev->dev, "fout_vpll.rate = %lu\n",
198	clk_get_rate(sdev->fout_vpll));
199	/* enable clock in SDO */
200	sdo_write_mask(sdev, SDO_CLKCON, ~0, SDO_TVOUT_CLOCK_ON);
201	clk_enable(sdev->dacphy);
202	/* enable DAC */
203	sdo_write_mask(sdev, SDO_DAC, ~0, SDO_POWER_ON_DAC);
204	sdo_reg_debug(sdev);
205	return 0;
206	}
207
208	static int sdo_streamoff(struct sdo_device *sdev)
209	{
210	int tries;
211
212	sdo_write_mask(sdev, SDO_DAC, 0, SDO_POWER_ON_DAC);
213	clk_disable(sdev->dacphy);
214	sdo_write_mask(sdev, SDO_CLKCON, 0, SDO_TVOUT_CLOCK_ON);
215	for (tries = 100; tries; --tries) {
216	if (sdo_read(sdev, SDO_CLKCON) & SDO_TVOUT_CLOCK_READY)
217	break;
218	mdelay(1);
219	}
220	if (tries == 0)
221	dev_err(sdev->dev, "failed to stop streaming\n");
222	return tries ? 0 : -EIO;
223	}
224
225	static int sdo_s_stream(struct v4l2_subdev *sd, int on)
226	{
227	struct sdo_device *sdev = sd_to_sdev(sd);
228	return on ? sdo_streamon(sdev) : sdo_streamoff(sdev);
229	}
230
231	static const struct v4l2_subdev_core_ops sdo_sd_core_ops = {
232	.s_power = sdo_s_power,
233	};
234
235	static const struct v4l2_subdev_video_ops sdo_sd_video_ops = {
236	.s_std_output = sdo_s_std_output,
237	.g_std_output = sdo_g_std_output,
238	.g_tvnorms_output = sdo_g_tvnorms_output,
239	.g_mbus_fmt = sdo_g_mbus_fmt,
240	.s_stream = sdo_s_stream,
241	};
242
243	static const struct v4l2_subdev_ops sdo_sd_ops = {
244	.core = &sdo_sd_core_ops,
245	.video = &sdo_sd_video_ops,
246	};
247
248	static int sdo_runtime_suspend(struct device *dev)
249	{
250	struct v4l2_subdev *sd = dev_get_drvdata(dev);
251	struct sdo_device *sdev = sd_to_sdev(sd);
252
253	dev_info(dev, "suspend\n");
254	regulator_disable(sdev->vdet);
255	regulator_disable(sdev->vdac);
256	clk_disable(sdev->sclk_dac);
257	return 0;
258	}
259
260	static int sdo_runtime_resume(struct device *dev)
261	{
262	struct v4l2_subdev *sd = dev_get_drvdata(dev);
263	struct sdo_device *sdev = sd_to_sdev(sd);
264
265	dev_info(dev, "resume\n");
266	clk_enable(sdev->sclk_dac);
267	regulator_enable(sdev->vdac);
268	regulator_enable(sdev->vdet);
269
270	/* software reset */
271	sdo_write_mask(sdev, SDO_CLKCON, ~0, SDO_TVOUT_SW_RESET);
272	mdelay(10);
273	sdo_write_mask(sdev, SDO_CLKCON, 0, SDO_TVOUT_SW_RESET);
274
275	/* setting TV mode */
276	sdo_write_mask(sdev, SDO_CONFIG, sdev->fmt->cookie, SDO_STANDARD_MASK);
277	/* XXX: forcing interlaced mode using undocumented bit */
278	sdo_write_mask(sdev, SDO_CONFIG, 0, SDO_PROGRESSIVE);
279	/* turn all VBI off */
280	sdo_write_mask(sdev, SDO_VBI, 0, SDO_CVBS_WSS_INS \|
281	SDO_CVBS_CLOSED_CAPTION_MASK);
282	/* turn all post processing off */
283	sdo_write_mask(sdev, SDO_CCCON, ~0, SDO_COMPENSATION_BHS_ADJ_OFF \|
284	SDO_COMPENSATION_CVBS_COMP_OFF);
285	sdo_reg_debug(sdev);
286	return 0;
287	}
288
289	static const struct dev_pm_ops sdo_pm_ops = {
290	.runtime_suspend = sdo_runtime_suspend,
291	.runtime_resume = sdo_runtime_resume,
292	};
293
294	static int __devinit sdo_probe(struct platform_device *pdev)
295	{
296	struct device *dev = &pdev->dev;
297	struct sdo_device *sdev;
298	struct resource *res;
299	int ret = 0;
300	struct clk *sclk_vpll;
301
302	dev_info(dev, "probe start\n");
303	sdev = kzalloc(sizeof *sdev, GFP_KERNEL);
304	if (!sdev) {
305	dev_err(dev, "not enough memory.\n");
306	ret = -ENOMEM;
307	goto fail;
308	}
309	sdev->dev = dev;
310
311	/* mapping registers */
312	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
313	if (res == NULL) {
314	dev_err(dev, "get memory resource failed.\n");
315	ret = -ENXIO;
316	goto fail_sdev;
317	}
318
319	sdev->regs = ioremap(res->start, resource_size(res));
320	if (sdev->regs == NULL) {
321	dev_err(dev, "register mapping failed.\n");
322	ret = -ENXIO;
323	goto fail_sdev;
324	}
325
326	/* acquiring interrupt */
327	res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
328	if (res == NULL) {
329	dev_err(dev, "get interrupt resource failed.\n");
330	ret = -ENXIO;
331	goto fail_regs;
332	}
333	ret = request_irq(res->start, sdo_irq_handler, 0, "s5p-sdo", sdev);
334	if (ret) {
335	dev_err(dev, "request interrupt failed.\n");
336	goto fail_regs;
337	}
338	sdev->irq = res->start;
339
340	/* acquire clocks */
341	sdev->sclk_dac = clk_get(dev, "sclk_dac");
342	if (IS_ERR_OR_NULL(sdev->sclk_dac)) {
343	dev_err(dev, "failed to get clock 'sclk_dac'\n");
344	ret = -ENXIO;
345	goto fail_irq;
346	}
347	sdev->dac = clk_get(dev, "dac");
348	if (IS_ERR_OR_NULL(sdev->dac)) {
349	dev_err(dev, "failed to get clock 'dac'\n");
350	ret = -ENXIO;
351	goto fail_sclk_dac;
352	}
353	sdev->dacphy = clk_get(dev, "dacphy");
354	if (IS_ERR_OR_NULL(sdev->dacphy)) {
355	dev_err(dev, "failed to get clock 'dacphy'\n");
356	ret = -ENXIO;
357	goto fail_dac;
358	}
359	sclk_vpll = clk_get(dev, "sclk_vpll");
360	if (IS_ERR_OR_NULL(sclk_vpll)) {
361	dev_err(dev, "failed to get clock 'sclk_vpll'\n");
362	ret = -ENXIO;
363	goto fail_dacphy;
364	}
365	clk_set_parent(sdev->sclk_dac, sclk_vpll);
366	clk_put(sclk_vpll);
367	sdev->fout_vpll = clk_get(dev, "fout_vpll");
368	if (IS_ERR_OR_NULL(sdev->fout_vpll)) {
369	dev_err(dev, "failed to get clock 'fout_vpll'\n");
370	goto fail_dacphy;
371	}
372	dev_info(dev, "fout_vpll.rate = %lu\n", clk_get_rate(sclk_vpll));
373
374	/* acquire regulator */
375	sdev->vdac = regulator_get(dev, "vdd33a_dac");
376	if (IS_ERR_OR_NULL(sdev->vdac)) {
377	dev_err(dev, "failed to get regulator 'vdac'\n");
378	goto fail_fout_vpll;
379	}
380	sdev->vdet = regulator_get(dev, "vdet");
381	if (IS_ERR_OR_NULL(sdev->vdet)) {
382	dev_err(dev, "failed to get regulator 'vdet'\n");
383	goto fail_vdac;
384	}
385
386	/* enable gate for dac clock, because mixer uses it */
387	clk_enable(sdev->dac);
388
389	/* configure power management */
390	pm_runtime_enable(dev);
391
392	/* configuration of interface subdevice */
393	v4l2_subdev_init(&sdev->sd, &sdo_sd_ops);
394	sdev->sd.owner = THIS_MODULE;
395	strlcpy(sdev->sd.name, "s5p-sdo", sizeof sdev->sd.name);
396
397	/* set default format */
398	sdev->fmt = sdo_find_format(SDO_DEFAULT_STD);
399	BUG_ON(sdev->fmt == NULL);
400
401	/* keeping subdev in device's private for use by other drivers */
402	dev_set_drvdata(dev, &sdev->sd);
403
404	dev_info(dev, "probe succeeded\n");
405	return 0;
406
407	fail_vdac:
408	regulator_put(sdev->vdac);
409	fail_fout_vpll:
410	clk_put(sdev->fout_vpll);
411	fail_dacphy:
412	clk_put(sdev->dacphy);
413	fail_dac:
414	clk_put(sdev->dac);
415	fail_sclk_dac:
416	clk_put(sdev->sclk_dac);
417	fail_irq:
418	free_irq(sdev->irq, sdev);
419	fail_regs:
420	iounmap(sdev->regs);
421	fail_sdev:
422	kfree(sdev);
423	fail:
424	dev_info(dev, "probe failed\n");
425	return ret;
426	}
427
428	static int __devexit sdo_remove(struct platform_device *pdev)
429	{
430	struct v4l2_subdev *sd = dev_get_drvdata(&pdev->dev);
431	struct sdo_device *sdev = sd_to_sdev(sd);
432
433	pm_runtime_disable(&pdev->dev);
434	clk_disable(sdev->dac);
435	regulator_put(sdev->vdet);
436	regulator_put(sdev->vdac);
437	clk_put(sdev->fout_vpll);
438	clk_put(sdev->dacphy);
439	clk_put(sdev->dac);
440	clk_put(sdev->sclk_dac);
441	free_irq(sdev->irq, sdev);
442	iounmap(sdev->regs);
443	kfree(sdev);
444
445	dev_info(&pdev->dev, "remove successful\n");
446	return 0;
447	}
448
449	static struct platform_driver sdo_driver __refdata = {
450	.probe = sdo_probe,
451	.remove = __devexit_p(sdo_remove),
452	.driver = {
453	.name = "s5p-sdo",
454	.owner = THIS_MODULE,
455	.pm = &sdo_pm_ops,
456	}
457	};
458
459	static int __init sdo_init(void)
460	{
461	int ret;
462	static const char banner[] __initdata = KERN_INFO \
463	"Samsung Standard Definition Output (SDO) driver, "
464	"(c) 2010-2011 Samsung Electronics Co., Ltd.\n";
465	printk(banner);
466
467	ret = platform_driver_register(&sdo_driver);
468	if (ret)
469	printk(KERN_ERR "SDO platform driver register failed\n");
470
471	return ret;
472	}
473	module_init(sdo_init);
474
475	static void __exit sdo_exit(void)
476	{
477	platform_driver_unregister(&sdo_driver);
478	}
479	module_exit(sdo_exit);