2 * Samsung Standard Definition Output (SDO) driver
4 * Copyright (c) 2010-2011 Samsung Electronics Co., Ltd.
6 * Tomasz Stanislawski, <t.stanislaws@samsung.com>
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
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>
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>
26 #include <media/v4l2-subdev.h>
30 MODULE_AUTHOR("Tomasz Stanislawski, <t.stanislaws@samsung.com>");
31 MODULE_DESCRIPTION("Samsung Standard Definition Output (SDO)");
32 MODULE_LICENSE("GPL");
34 #define SDO_DEFAULT_STD V4L2_STD_PAL
38 /* all modes are 720 pixels wide */
44 /** pointer to device parent */
46 /** base address of SDO registers */
50 /** DAC source clock */
54 /** DAC physical interface */
56 /** clock for control of VPLL */
57 struct clk *fout_vpll;
58 /** vpll rate before sdo stream was on */
59 unsigned long vpll_rate;
60 /** regulator for SDO IP power */
61 struct regulator *vdac;
62 /** regulator for SDO plug detection */
63 struct regulator *vdet;
64 /** subdev used as device interface */
65 struct v4l2_subdev sd;
67 const struct sdo_format *fmt;
70 static inline struct sdo_device *sd_to_sdev(struct v4l2_subdev *sd)
72 return container_of(sd, struct sdo_device, sd);
76 void sdo_write_mask(struct sdo_device *sdev, u32 reg_id, u32 value, u32 mask)
78 u32 old = readl(sdev->regs + reg_id);
79 value = (value & mask) | (old & ~mask);
80 writel(value, sdev->regs + reg_id);
84 void sdo_write(struct sdo_device *sdev, u32 reg_id, u32 value)
86 writel(value, sdev->regs + reg_id);
90 u32 sdo_read(struct sdo_device *sdev, u32 reg_id)
92 return readl(sdev->regs + reg_id);
95 static irqreturn_t sdo_irq_handler(int irq, void *dev_data)
97 struct sdo_device *sdev = dev_data;
100 sdo_write_mask(sdev, SDO_IRQ, ~0, SDO_VSYNC_IRQ_PEND);
104 static void sdo_reg_debug(struct sdo_device *sdev)
106 #define DBGREG(reg_id) \
107 dev_info(sdev->dev, #reg_id " = %08x\n", \
108 sdo_read(sdev, reg_id))
119 static const struct sdo_format sdo_format[] = {
120 { V4L2_STD_PAL_N, .height = 576, .cookie = SDO_PAL_N },
121 { V4L2_STD_PAL_Nc, .height = 576, .cookie = SDO_PAL_NC },
122 { V4L2_STD_PAL_M, .height = 480, .cookie = SDO_PAL_M },
123 { V4L2_STD_PAL_60, .height = 480, .cookie = SDO_PAL_60 },
124 { V4L2_STD_NTSC_443, .height = 480, .cookie = SDO_NTSC_443 },
125 { V4L2_STD_PAL, .height = 576, .cookie = SDO_PAL_BGHID },
126 { V4L2_STD_NTSC_M, .height = 480, .cookie = SDO_NTSC_M },
129 static const struct sdo_format *sdo_find_format(v4l2_std_id id)
132 for (i = 0; i < ARRAY_SIZE(sdo_format); ++i)
133 if (sdo_format[i].id & id)
134 return &sdo_format[i];
138 static int sdo_g_tvnorms_output(struct v4l2_subdev *sd, v4l2_std_id *std)
140 *std = V4L2_STD_NTSC_M | V4L2_STD_PAL_M | V4L2_STD_PAL |
141 V4L2_STD_PAL_N | V4L2_STD_PAL_Nc |
142 V4L2_STD_NTSC_443 | V4L2_STD_PAL_60;
146 static int sdo_s_std_output(struct v4l2_subdev *sd, v4l2_std_id std)
148 struct sdo_device *sdev = sd_to_sdev(sd);
149 const struct sdo_format *fmt;
150 fmt = sdo_find_format(std);
157 static int sdo_g_std_output(struct v4l2_subdev *sd, v4l2_std_id *std)
159 *std = sd_to_sdev(sd)->fmt->id;
163 static int sdo_g_mbus_fmt(struct v4l2_subdev *sd,
164 struct v4l2_mbus_framefmt *fmt)
166 struct sdo_device *sdev = sd_to_sdev(sd);
170 /* all modes are 720 pixels wide */
172 fmt->height = sdev->fmt->height;
173 fmt->code = MEDIA_BUS_FMT_FIXED;
174 fmt->field = V4L2_FIELD_INTERLACED;
175 fmt->colorspace = V4L2_COLORSPACE_JPEG;
179 static int sdo_s_power(struct v4l2_subdev *sd, int on)
181 struct sdo_device *sdev = sd_to_sdev(sd);
182 struct device *dev = sdev->dev;
185 dev_info(dev, "sdo_s_power(%d)\n", on);
188 ret = pm_runtime_get_sync(dev);
190 ret = pm_runtime_put_sync(dev);
192 /* only values < 0 indicate errors */
193 return ret < 0 ? ret : 0;
196 static int sdo_streamon(struct sdo_device *sdev)
200 /* set proper clock for Timing Generator */
201 sdev->vpll_rate = clk_get_rate(sdev->fout_vpll);
202 ret = clk_set_rate(sdev->fout_vpll, 54000000);
204 dev_err(sdev->dev, "Failed to set vpll rate\n");
207 dev_info(sdev->dev, "fout_vpll.rate = %lu\n",
208 clk_get_rate(sdev->fout_vpll));
209 /* enable clock in SDO */
210 sdo_write_mask(sdev, SDO_CLKCON, ~0, SDO_TVOUT_CLOCK_ON);
211 ret = clk_prepare_enable(sdev->dacphy);
213 dev_err(sdev->dev, "clk_prepare_enable(dacphy) failed\n");
217 sdo_write_mask(sdev, SDO_DAC, ~0, SDO_POWER_ON_DAC);
222 sdo_write_mask(sdev, SDO_CLKCON, 0, SDO_TVOUT_CLOCK_ON);
223 clk_set_rate(sdev->fout_vpll, sdev->vpll_rate);
227 static int sdo_streamoff(struct sdo_device *sdev)
231 sdo_write_mask(sdev, SDO_DAC, 0, SDO_POWER_ON_DAC);
232 clk_disable_unprepare(sdev->dacphy);
233 sdo_write_mask(sdev, SDO_CLKCON, 0, SDO_TVOUT_CLOCK_ON);
234 for (tries = 100; tries; --tries) {
235 if (sdo_read(sdev, SDO_CLKCON) & SDO_TVOUT_CLOCK_READY)
240 dev_err(sdev->dev, "failed to stop streaming\n");
241 clk_set_rate(sdev->fout_vpll, sdev->vpll_rate);
242 return tries ? 0 : -EIO;
245 static int sdo_s_stream(struct v4l2_subdev *sd, int on)
247 struct sdo_device *sdev = sd_to_sdev(sd);
248 return on ? sdo_streamon(sdev) : sdo_streamoff(sdev);
251 static const struct v4l2_subdev_core_ops sdo_sd_core_ops = {
252 .s_power = sdo_s_power,
255 static const struct v4l2_subdev_video_ops sdo_sd_video_ops = {
256 .s_std_output = sdo_s_std_output,
257 .g_std_output = sdo_g_std_output,
258 .g_tvnorms_output = sdo_g_tvnorms_output,
259 .g_mbus_fmt = sdo_g_mbus_fmt,
260 .s_stream = sdo_s_stream,
263 static const struct v4l2_subdev_ops sdo_sd_ops = {
264 .core = &sdo_sd_core_ops,
265 .video = &sdo_sd_video_ops,
268 static int sdo_runtime_suspend(struct device *dev)
270 struct v4l2_subdev *sd = dev_get_drvdata(dev);
271 struct sdo_device *sdev = sd_to_sdev(sd);
273 dev_info(dev, "suspend\n");
274 regulator_disable(sdev->vdet);
275 regulator_disable(sdev->vdac);
276 clk_disable_unprepare(sdev->sclk_dac);
280 static int sdo_runtime_resume(struct device *dev)
282 struct v4l2_subdev *sd = dev_get_drvdata(dev);
283 struct sdo_device *sdev = sd_to_sdev(sd);
286 dev_info(dev, "resume\n");
288 ret = clk_prepare_enable(sdev->sclk_dac);
292 ret = regulator_enable(sdev->vdac);
296 ret = regulator_enable(sdev->vdet);
301 sdo_write_mask(sdev, SDO_CLKCON, ~0, SDO_TVOUT_SW_RESET);
303 sdo_write_mask(sdev, SDO_CLKCON, 0, SDO_TVOUT_SW_RESET);
305 /* setting TV mode */
306 sdo_write_mask(sdev, SDO_CONFIG, sdev->fmt->cookie, SDO_STANDARD_MASK);
307 /* XXX: forcing interlaced mode using undocumented bit */
308 sdo_write_mask(sdev, SDO_CONFIG, 0, SDO_PROGRESSIVE);
309 /* turn all VBI off */
310 sdo_write_mask(sdev, SDO_VBI, 0, SDO_CVBS_WSS_INS |
311 SDO_CVBS_CLOSED_CAPTION_MASK);
312 /* turn all post processing off */
313 sdo_write_mask(sdev, SDO_CCCON, ~0, SDO_COMPENSATION_BHS_ADJ_OFF |
314 SDO_COMPENSATION_CVBS_COMP_OFF);
319 regulator_disable(sdev->vdac);
321 clk_disable_unprepare(sdev->sclk_dac);
325 static const struct dev_pm_ops sdo_pm_ops = {
326 .runtime_suspend = sdo_runtime_suspend,
327 .runtime_resume = sdo_runtime_resume,
330 static int sdo_probe(struct platform_device *pdev)
332 struct device *dev = &pdev->dev;
333 struct sdo_device *sdev;
334 struct resource *res;
336 struct clk *sclk_vpll;
338 dev_info(dev, "probe start\n");
339 sdev = devm_kzalloc(&pdev->dev, sizeof(*sdev), GFP_KERNEL);
341 dev_err(dev, "not enough memory.\n");
347 /* mapping registers */
348 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
350 dev_err(dev, "get memory resource failed.\n");
355 sdev->regs = devm_ioremap(&pdev->dev, res->start, resource_size(res));
356 if (sdev->regs == NULL) {
357 dev_err(dev, "register mapping failed.\n");
362 /* acquiring interrupt */
363 res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
365 dev_err(dev, "get interrupt resource failed.\n");
369 ret = devm_request_irq(&pdev->dev, res->start, sdo_irq_handler, 0,
372 dev_err(dev, "request interrupt failed.\n");
375 sdev->irq = res->start;
378 sdev->sclk_dac = clk_get(dev, "sclk_dac");
379 if (IS_ERR(sdev->sclk_dac)) {
380 dev_err(dev, "failed to get clock 'sclk_dac'\n");
381 ret = PTR_ERR(sdev->sclk_dac);
384 sdev->dac = clk_get(dev, "dac");
385 if (IS_ERR(sdev->dac)) {
386 dev_err(dev, "failed to get clock 'dac'\n");
387 ret = PTR_ERR(sdev->dac);
390 sdev->dacphy = clk_get(dev, "dacphy");
391 if (IS_ERR(sdev->dacphy)) {
392 dev_err(dev, "failed to get clock 'dacphy'\n");
393 ret = PTR_ERR(sdev->dacphy);
396 sclk_vpll = clk_get(dev, "sclk_vpll");
397 if (IS_ERR(sclk_vpll)) {
398 dev_err(dev, "failed to get clock 'sclk_vpll'\n");
399 ret = PTR_ERR(sclk_vpll);
402 clk_set_parent(sdev->sclk_dac, sclk_vpll);
404 sdev->fout_vpll = clk_get(dev, "fout_vpll");
405 if (IS_ERR(sdev->fout_vpll)) {
406 dev_err(dev, "failed to get clock 'fout_vpll'\n");
407 ret = PTR_ERR(sdev->fout_vpll);
410 dev_info(dev, "fout_vpll.rate = %lu\n", clk_get_rate(sclk_vpll));
412 /* acquire regulator */
413 sdev->vdac = devm_regulator_get(dev, "vdd33a_dac");
414 if (IS_ERR(sdev->vdac)) {
415 dev_err(dev, "failed to get regulator 'vdac'\n");
416 ret = PTR_ERR(sdev->vdac);
419 sdev->vdet = devm_regulator_get(dev, "vdet");
420 if (IS_ERR(sdev->vdet)) {
421 dev_err(dev, "failed to get regulator 'vdet'\n");
422 ret = PTR_ERR(sdev->vdet);
426 /* enable gate for dac clock, because mixer uses it */
427 ret = clk_prepare_enable(sdev->dac);
429 dev_err(dev, "clk_prepare_enable(dac) failed\n");
433 /* configure power management */
434 pm_runtime_enable(dev);
436 /* configuration of interface subdevice */
437 v4l2_subdev_init(&sdev->sd, &sdo_sd_ops);
438 sdev->sd.owner = THIS_MODULE;
439 strlcpy(sdev->sd.name, "s5p-sdo", sizeof(sdev->sd.name));
441 /* set default format */
442 sdev->fmt = sdo_find_format(SDO_DEFAULT_STD);
443 BUG_ON(sdev->fmt == NULL);
445 /* keeping subdev in device's private for use by other drivers */
446 dev_set_drvdata(dev, &sdev->sd);
448 dev_info(dev, "probe succeeded\n");
452 clk_put(sdev->fout_vpll);
454 clk_put(sdev->dacphy);
458 clk_put(sdev->sclk_dac);
460 dev_info(dev, "probe failed\n");
464 static int sdo_remove(struct platform_device *pdev)
466 struct v4l2_subdev *sd = dev_get_drvdata(&pdev->dev);
467 struct sdo_device *sdev = sd_to_sdev(sd);
469 pm_runtime_disable(&pdev->dev);
470 clk_disable_unprepare(sdev->dac);
471 clk_put(sdev->fout_vpll);
472 clk_put(sdev->dacphy);
474 clk_put(sdev->sclk_dac);
476 dev_info(&pdev->dev, "remove successful\n");
480 static struct platform_driver sdo_driver __refdata = {
482 .remove = sdo_remove,
485 .owner = THIS_MODULE,
490 module_platform_driver(sdo_driver);