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
= V4L2_MBUS_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
);