Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

Linux/drivers/media/platform/s5p-tv/sdo_drv.c

  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         /** 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;
 66         /** current format */
 67         const struct sdo_format *fmt;
 68 };
 69 
 70 static inline struct sdo_device *sd_to_sdev(struct v4l2_subdev *sd)
 71 {
 72         return container_of(sd, struct sdo_device, sd);
 73 }
 74 
 75 static inline
 76 void sdo_write_mask(struct sdo_device *sdev, u32 reg_id, u32 value, u32 mask)
 77 {
 78         u32 old = readl(sdev->regs + reg_id);
 79         value = (value & mask) | (old & ~mask);
 80         writel(value, sdev->regs + reg_id);
 81 }
 82 
 83 static inline
 84 void sdo_write(struct sdo_device *sdev, u32 reg_id, u32 value)
 85 {
 86         writel(value, sdev->regs + reg_id);
 87 }
 88 
 89 static inline
 90 u32 sdo_read(struct sdo_device *sdev, u32 reg_id)
 91 {
 92         return readl(sdev->regs + reg_id);
 93 }
 94 
 95 static irqreturn_t sdo_irq_handler(int irq, void *dev_data)
 96 {
 97         struct sdo_device *sdev = dev_data;
 98 
 99         /* clear interrupt */
100         sdo_write_mask(sdev, SDO_IRQ, ~0, SDO_VSYNC_IRQ_PEND);
101         return IRQ_HANDLED;
102 }
103 
104 static void sdo_reg_debug(struct sdo_device *sdev)
105 {
106 #define DBGREG(reg_id) \
107         dev_info(sdev->dev, #reg_id " = %08x\n", \
108                 sdo_read(sdev, reg_id))
109 
110         DBGREG(SDO_CLKCON);
111         DBGREG(SDO_CONFIG);
112         DBGREG(SDO_VBI);
113         DBGREG(SDO_DAC);
114         DBGREG(SDO_IRQ);
115         DBGREG(SDO_IRQMASK);
116         DBGREG(SDO_VERSION);
117 }
118 
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 },
127 };
128 
129 static const struct sdo_format *sdo_find_format(v4l2_std_id id)
130 {
131         int i;
132         for (i = 0; i < ARRAY_SIZE(sdo_format); ++i)
133                 if (sdo_format[i].id & id)
134                         return &sdo_format[i];
135         return NULL;
136 }
137 
138 static int sdo_g_tvnorms_output(struct v4l2_subdev *sd, v4l2_std_id *std)
139 {
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;
143         return 0;
144 }
145 
146 static int sdo_s_std_output(struct v4l2_subdev *sd, v4l2_std_id std)
147 {
148         struct sdo_device *sdev = sd_to_sdev(sd);
149         const struct sdo_format *fmt;
150         fmt = sdo_find_format(std);
151         if (fmt == NULL)
152                 return -EINVAL;
153         sdev->fmt = fmt;
154         return 0;
155 }
156 
157 static int sdo_g_std_output(struct v4l2_subdev *sd, v4l2_std_id *std)
158 {
159         *std = sd_to_sdev(sd)->fmt->id;
160         return 0;
161 }
162 
163 static int sdo_g_mbus_fmt(struct v4l2_subdev *sd,
164         struct v4l2_mbus_framefmt *fmt)
165 {
166         struct sdo_device *sdev = sd_to_sdev(sd);
167 
168         if (!sdev->fmt)
169                 return -ENXIO;
170         /* all modes are 720 pixels wide */
171         fmt->width = 720;
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;
176         return 0;
177 }
178 
179 static int sdo_s_power(struct v4l2_subdev *sd, int on)
180 {
181         struct sdo_device *sdev = sd_to_sdev(sd);
182         struct device *dev = sdev->dev;
183         int ret;
184 
185         dev_info(dev, "sdo_s_power(%d)\n", on);
186 
187         if (on)
188                 ret = pm_runtime_get_sync(dev);
189         else
190                 ret = pm_runtime_put_sync(dev);
191 
192         /* only values < 0 indicate errors */
193         return IS_ERR_VALUE(ret) ? ret : 0;
194 }
195 
196 static int sdo_streamon(struct sdo_device *sdev)
197 {
198         int ret;
199 
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);
203         if (ret < 0) {
204                 dev_err(sdev->dev, "Failed to set vpll rate\n");
205                 return ret;
206         }
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);
212         if (ret < 0) {
213                 dev_err(sdev->dev, "clk_prepare_enable(dacphy) failed\n");
214                 goto fail;
215         }
216         /* enable DAC */
217         sdo_write_mask(sdev, SDO_DAC, ~0, SDO_POWER_ON_DAC);
218         sdo_reg_debug(sdev);
219         return 0;
220 
221 fail:
222         sdo_write_mask(sdev, SDO_CLKCON, 0, SDO_TVOUT_CLOCK_ON);
223         clk_set_rate(sdev->fout_vpll, sdev->vpll_rate);
224         return ret;
225 }
226 
227 static int sdo_streamoff(struct sdo_device *sdev)
228 {
229         int tries;
230 
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)
236                         break;
237                 mdelay(1);
238         }
239         if (tries == 0)
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;
243 }
244 
245 static int sdo_s_stream(struct v4l2_subdev *sd, int on)
246 {
247         struct sdo_device *sdev = sd_to_sdev(sd);
248         return on ? sdo_streamon(sdev) : sdo_streamoff(sdev);
249 }
250 
251 static const struct v4l2_subdev_core_ops sdo_sd_core_ops = {
252         .s_power = sdo_s_power,
253 };
254 
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,
261 };
262 
263 static const struct v4l2_subdev_ops sdo_sd_ops = {
264         .core = &sdo_sd_core_ops,
265         .video = &sdo_sd_video_ops,
266 };
267 
268 static int sdo_runtime_suspend(struct device *dev)
269 {
270         struct v4l2_subdev *sd = dev_get_drvdata(dev);
271         struct sdo_device *sdev = sd_to_sdev(sd);
272 
273         dev_info(dev, "suspend\n");
274         regulator_disable(sdev->vdet);
275         regulator_disable(sdev->vdac);
276         clk_disable_unprepare(sdev->sclk_dac);
277         return 0;
278 }
279 
280 static int sdo_runtime_resume(struct device *dev)
281 {
282         struct v4l2_subdev *sd = dev_get_drvdata(dev);
283         struct sdo_device *sdev = sd_to_sdev(sd);
284         int ret;
285 
286         dev_info(dev, "resume\n");
287 
288         ret = clk_prepare_enable(sdev->sclk_dac);
289         if (ret < 0)
290                 return ret;
291 
292         ret = regulator_enable(sdev->vdac);
293         if (ret < 0)
294                 goto dac_clk_dis;
295 
296         ret = regulator_enable(sdev->vdet);
297         if (ret < 0)
298                 goto vdac_r_dis;
299 
300         /* software reset */
301         sdo_write_mask(sdev, SDO_CLKCON, ~0, SDO_TVOUT_SW_RESET);
302         mdelay(10);
303         sdo_write_mask(sdev, SDO_CLKCON, 0, SDO_TVOUT_SW_RESET);
304 
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);
315         sdo_reg_debug(sdev);
316         return 0;
317 
318 vdac_r_dis:
319         regulator_disable(sdev->vdac);
320 dac_clk_dis:
321         clk_disable_unprepare(sdev->sclk_dac);
322         return ret;
323 }
324 
325 static const struct dev_pm_ops sdo_pm_ops = {
326         .runtime_suspend = sdo_runtime_suspend,
327         .runtime_resume  = sdo_runtime_resume,
328 };
329 
330 static int sdo_probe(struct platform_device *pdev)
331 {
332         struct device *dev = &pdev->dev;
333         struct sdo_device *sdev;
334         struct resource *res;
335         int ret = 0;
336         struct clk *sclk_vpll;
337 
338         dev_info(dev, "probe start\n");
339         sdev = devm_kzalloc(&pdev->dev, sizeof(*sdev), GFP_KERNEL);
340         if (!sdev) {
341                 dev_err(dev, "not enough memory.\n");
342                 ret = -ENOMEM;
343                 goto fail;
344         }
345         sdev->dev = dev;
346 
347         /* mapping registers */
348         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
349         if (res == NULL) {
350                 dev_err(dev, "get memory resource failed.\n");
351                 ret = -ENXIO;
352                 goto fail;
353         }
354 
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");
358                 ret = -ENXIO;
359                 goto fail;
360         }
361 
362         /* acquiring interrupt */
363         res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
364         if (res == NULL) {
365                 dev_err(dev, "get interrupt resource failed.\n");
366                 ret = -ENXIO;
367                 goto fail;
368         }
369         ret = devm_request_irq(&pdev->dev, res->start, sdo_irq_handler, 0,
370                                "s5p-sdo", sdev);
371         if (ret) {
372                 dev_err(dev, "request interrupt failed.\n");
373                 goto fail;
374         }
375         sdev->irq = res->start;
376 
377         /* acquire clocks */
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);
382                 goto fail;
383         }
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);
388                 goto fail_sclk_dac;
389         }
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);
394                 goto fail_dac;
395         }
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);
400                 goto fail_dacphy;
401         }
402         clk_set_parent(sdev->sclk_dac, sclk_vpll);
403         clk_put(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);
408                 goto fail_dacphy;
409         }
410         dev_info(dev, "fout_vpll.rate = %lu\n", clk_get_rate(sclk_vpll));
411 
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);
417                 goto fail_fout_vpll;
418         }
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);
423                 goto fail_fout_vpll;
424         }
425 
426         /* enable gate for dac clock, because mixer uses it */
427         ret = clk_prepare_enable(sdev->dac);
428         if (ret < 0) {
429                 dev_err(dev, "clk_prepare_enable(dac) failed\n");
430                 goto fail_fout_vpll;
431         }
432 
433         /* configure power management */
434         pm_runtime_enable(dev);
435 
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));
440 
441         /* set default format */
442         sdev->fmt = sdo_find_format(SDO_DEFAULT_STD);
443         BUG_ON(sdev->fmt == NULL);
444 
445         /* keeping subdev in device's private for use by other drivers */
446         dev_set_drvdata(dev, &sdev->sd);
447 
448         dev_info(dev, "probe succeeded\n");
449         return 0;
450 
451 fail_fout_vpll:
452         clk_put(sdev->fout_vpll);
453 fail_dacphy:
454         clk_put(sdev->dacphy);
455 fail_dac:
456         clk_put(sdev->dac);
457 fail_sclk_dac:
458         clk_put(sdev->sclk_dac);
459 fail:
460         dev_info(dev, "probe failed\n");
461         return ret;
462 }
463 
464 static int sdo_remove(struct platform_device *pdev)
465 {
466         struct v4l2_subdev *sd = dev_get_drvdata(&pdev->dev);
467         struct sdo_device *sdev = sd_to_sdev(sd);
468 
469         pm_runtime_disable(&pdev->dev);
470         clk_disable_unprepare(sdev->dac);
471         clk_put(sdev->fout_vpll);
472         clk_put(sdev->dacphy);
473         clk_put(sdev->dac);
474         clk_put(sdev->sclk_dac);
475 
476         dev_info(&pdev->dev, "remove successful\n");
477         return 0;
478 }
479 
480 static struct platform_driver sdo_driver __refdata = {
481         .probe = sdo_probe,
482         .remove = sdo_remove,
483         .driver = {
484                 .name = "s5p-sdo",
485                 .owner = THIS_MODULE,
486                 .pm = &sdo_pm_ops,
487         }
488 };
489 
490 module_platform_driver(sdo_driver);
491 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us