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_get_fmt(struct v4l2_subdev *sd,
 164                 struct v4l2_subdev_pad_config *cfg,
 165                 struct v4l2_subdev_format *format)
 166 {
 167         struct v4l2_mbus_framefmt *fmt = &format->format;
 168         struct sdo_device *sdev = sd_to_sdev(sd);
 169
 170         if (!sdev->fmt)
 171                 return -ENXIO;
 172         if (format->pad)
 173                 return -EINVAL;
 174         /* all modes are 720 pixels wide */
 175         fmt->width = 720;
 176         fmt->height = sdev->fmt->height;
 177         fmt->code = MEDIA_BUS_FMT_FIXED;
 178         fmt->field = V4L2_FIELD_INTERLACED;
 179         fmt->colorspace = V4L2_COLORSPACE_JPEG;
 180         return 0;
 181 }
 182
 183 static int sdo_s_power(struct v4l2_subdev *sd, int on)
 184 {
 185         struct sdo_device *sdev = sd_to_sdev(sd);
 186         struct device *dev = sdev->dev;
 187         int ret;
 188
 189         dev_info(dev, "sdo_s_power(%d)\n", on);
 190
 191         if (on)
 192                 ret = pm_runtime_get_sync(dev);
 193         else
 194                 ret = pm_runtime_put_sync(dev);
 195
 196         /* only values < 0 indicate errors */
 197         return ret < 0 ? ret : 0;
 198 }
 199
 200 static int sdo_streamon(struct sdo_device *sdev)
 201 {
 202         int ret;
 203
 204         /* set proper clock for Timing Generator */
 205         sdev->vpll_rate = clk_get_rate(sdev->fout_vpll);
 206         ret = clk_set_rate(sdev->fout_vpll, 54000000);
 207         if (ret < 0) {
 208                 dev_err(sdev->dev, "Failed to set vpll rate\n");
 209                 return ret;
 210         }
 211         dev_info(sdev->dev, "fout_vpll.rate = %lu\n",
 212         clk_get_rate(sdev->fout_vpll));
 213         /* enable clock in SDO */
 214         sdo_write_mask(sdev, SDO_CLKCON, ~0, SDO_TVOUT_CLOCK_ON);
 215         ret = clk_prepare_enable(sdev->dacphy);
 216         if (ret < 0) {
 217                 dev_err(sdev->dev, "clk_prepare_enable(dacphy) failed\n");
 218                 goto fail;
 219         }
 220         /* enable DAC */
 221         sdo_write_mask(sdev, SDO_DAC, ~0, SDO_POWER_ON_DAC);
 222         sdo_reg_debug(sdev);
 223         return 0;
 224
 225 fail:
 226         sdo_write_mask(sdev, SDO_CLKCON, 0, SDO_TVOUT_CLOCK_ON);
 227         clk_set_rate(sdev->fout_vpll, sdev->vpll_rate);
 228         return ret;
 229 }
 230
 231 static int sdo_streamoff(struct sdo_device *sdev)
 232 {
 233         int tries;
 234
 235         sdo_write_mask(sdev, SDO_DAC, 0, SDO_POWER_ON_DAC);
 236         clk_disable_unprepare(sdev->dacphy);
 237         sdo_write_mask(sdev, SDO_CLKCON, 0, SDO_TVOUT_CLOCK_ON);
 238         for (tries = 100; tries; --tries) {
 239                 if (sdo_read(sdev, SDO_CLKCON) & SDO_TVOUT_CLOCK_READY)
 240                         break;
 241                 mdelay(1);
 242         }
 243         if (tries == 0)
 244                 dev_err(sdev->dev, "failed to stop streaming\n");
 245         clk_set_rate(sdev->fout_vpll, sdev->vpll_rate);
 246         return tries ? 0 : -EIO;
 247 }
 248
 249 static int sdo_s_stream(struct v4l2_subdev *sd, int on)
 250 {
 251         struct sdo_device *sdev = sd_to_sdev(sd);
 252         return on ? sdo_streamon(sdev) : sdo_streamoff(sdev);
 253 }
 254
 255 static const struct v4l2_subdev_core_ops sdo_sd_core_ops = {
 256         .s_power = sdo_s_power,
 257 };
 258
 259 static const struct v4l2_subdev_video_ops sdo_sd_video_ops = {
 260         .s_std_output = sdo_s_std_output,
 261         .g_std_output = sdo_g_std_output,
 262         .g_tvnorms_output = sdo_g_tvnorms_output,
 263         .s_stream = sdo_s_stream,
 264 };
 265
 266 static const struct v4l2_subdev_pad_ops sdo_sd_pad_ops = {
 267         .get_fmt = sdo_get_fmt,
 268 };
 269
 270 static const struct v4l2_subdev_ops sdo_sd_ops = {
 271         .core = &sdo_sd_core_ops,
 272         .video = &sdo_sd_video_ops,
 273         .pad = &sdo_sd_pad_ops,
 274 };
 275
 276 static int sdo_runtime_suspend(struct device *dev)
 277 {
 278         struct v4l2_subdev *sd = dev_get_drvdata(dev);
 279         struct sdo_device *sdev = sd_to_sdev(sd);
 280
 281         dev_info(dev, "suspend\n");
 282         regulator_disable(sdev->vdet);
 283         regulator_disable(sdev->vdac);
 284         clk_disable_unprepare(sdev->sclk_dac);
 285         return 0;
 286 }
 287
 288 static int sdo_runtime_resume(struct device *dev)
 289 {
 290         struct v4l2_subdev *sd = dev_get_drvdata(dev);
 291         struct sdo_device *sdev = sd_to_sdev(sd);
 292         int ret;
 293
 294         dev_info(dev, "resume\n");
 295
 296         ret = clk_prepare_enable(sdev->sclk_dac);
 297         if (ret < 0)
 298                 return ret;
 299
 300         ret = regulator_enable(sdev->vdac);
 301         if (ret < 0)
 302                 goto dac_clk_dis;
 303
 304         ret = regulator_enable(sdev->vdet);
 305         if (ret < 0)
 306                 goto vdac_r_dis;
 307
 308         /* software reset */
 309         sdo_write_mask(sdev, SDO_CLKCON, ~0, SDO_TVOUT_SW_RESET);
 310         mdelay(10);
 311         sdo_write_mask(sdev, SDO_CLKCON, 0, SDO_TVOUT_SW_RESET);
 312
 313         /* setting TV mode */
 314         sdo_write_mask(sdev, SDO_CONFIG, sdev->fmt->cookie, SDO_STANDARD_MASK);
 315         /* XXX: forcing interlaced mode using undocumented bit */
 316         sdo_write_mask(sdev, SDO_CONFIG, 0, SDO_PROGRESSIVE);
 317         /* turn all VBI off */
 318         sdo_write_mask(sdev, SDO_VBI, 0, SDO_CVBS_WSS_INS |
 319                 SDO_CVBS_CLOSED_CAPTION_MASK);
 320         /* turn all post processing off */
 321         sdo_write_mask(sdev, SDO_CCCON, ~0, SDO_COMPENSATION_BHS_ADJ_OFF |
 322                 SDO_COMPENSATION_CVBS_COMP_OFF);
 323         sdo_reg_debug(sdev);
 324         return 0;
 325
 326 vdac_r_dis:
 327         regulator_disable(sdev->vdac);
 328 dac_clk_dis:
 329         clk_disable_unprepare(sdev->sclk_dac);
 330         return ret;
 331 }
 332
 333 static const struct dev_pm_ops sdo_pm_ops = {
 334         .runtime_suspend = sdo_runtime_suspend,
 335         .runtime_resume  = sdo_runtime_resume,
 336 };
 337
 338 static int sdo_probe(struct platform_device *pdev)
 339 {
 340         struct device *dev = &pdev->dev;
 341         struct sdo_device *sdev;
 342         struct resource *res;
 343         int ret = 0;
 344         struct clk *sclk_vpll;
 345
 346         dev_info(dev, "probe start\n");
 347         sdev = devm_kzalloc(&pdev->dev, sizeof(*sdev), GFP_KERNEL);
 348         if (!sdev) {
 349                 dev_err(dev, "not enough memory.\n");
 350                 ret = -ENOMEM;
 351                 goto fail;
 352         }
 353         sdev->dev = dev;
 354
 355         /* mapping registers */
 356         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 357         if (res == NULL) {
 358                 dev_err(dev, "get memory resource failed.\n");
 359                 ret = -ENXIO;
 360                 goto fail;
 361         }
 362
 363         sdev->regs = devm_ioremap(&pdev->dev, res->start, resource_size(res));
 364         if (sdev->regs == NULL) {
 365                 dev_err(dev, "register mapping failed.\n");
 366                 ret = -ENXIO;
 367                 goto fail;
 368         }
 369
 370         /* acquiring interrupt */
 371         res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
 372         if (res == NULL) {
 373                 dev_err(dev, "get interrupt resource failed.\n");
 374                 ret = -ENXIO;
 375                 goto fail;
 376         }
 377         ret = devm_request_irq(&pdev->dev, res->start, sdo_irq_handler, 0,
 378                                "s5p-sdo", sdev);
 379         if (ret) {
 380                 dev_err(dev, "request interrupt failed.\n");
 381                 goto fail;
 382         }
 383         sdev->irq = res->start;
 384
 385         /* acquire clocks */
 386         sdev->sclk_dac = clk_get(dev, "sclk_dac");
 387         if (IS_ERR(sdev->sclk_dac)) {
 388                 dev_err(dev, "failed to get clock 'sclk_dac'\n");
 389                 ret = PTR_ERR(sdev->sclk_dac);
 390                 goto fail;
 391         }
 392         sdev->dac = clk_get(dev, "dac");
 393         if (IS_ERR(sdev->dac)) {
 394                 dev_err(dev, "failed to get clock 'dac'\n");
 395                 ret = PTR_ERR(sdev->dac);
 396                 goto fail_sclk_dac;
 397         }
 398         sdev->dacphy = clk_get(dev, "dacphy");
 399         if (IS_ERR(sdev->dacphy)) {
 400                 dev_err(dev, "failed to get clock 'dacphy'\n");
 401                 ret = PTR_ERR(sdev->dacphy);
 402                 goto fail_dac;
 403         }
 404         sclk_vpll = clk_get(dev, "sclk_vpll");
 405         if (IS_ERR(sclk_vpll)) {
 406                 dev_err(dev, "failed to get clock 'sclk_vpll'\n");
 407                 ret = PTR_ERR(sclk_vpll);
 408                 goto fail_dacphy;
 409         }
 410         clk_set_parent(sdev->sclk_dac, sclk_vpll);
 411         clk_put(sclk_vpll);
 412         sdev->fout_vpll = clk_get(dev, "fout_vpll");
 413         if (IS_ERR(sdev->fout_vpll)) {
 414                 dev_err(dev, "failed to get clock 'fout_vpll'\n");
 415                 ret = PTR_ERR(sdev->fout_vpll);
 416                 goto fail_dacphy;
 417         }
 418         dev_info(dev, "fout_vpll.rate = %lu\n", clk_get_rate(sclk_vpll));
 419
 420         /* acquire regulator */
 421         sdev->vdac = devm_regulator_get(dev, "vdd33a_dac");
 422         if (IS_ERR(sdev->vdac)) {
 423                 dev_err(dev, "failed to get regulator 'vdac'\n");
 424                 ret = PTR_ERR(sdev->vdac);
 425                 goto fail_fout_vpll;
 426         }
 427         sdev->vdet = devm_regulator_get(dev, "vdet");
 428         if (IS_ERR(sdev->vdet)) {
 429                 dev_err(dev, "failed to get regulator 'vdet'\n");
 430                 ret = PTR_ERR(sdev->vdet);
 431                 goto fail_fout_vpll;
 432         }
 433
 434         /* enable gate for dac clock, because mixer uses it */
 435         ret = clk_prepare_enable(sdev->dac);
 436         if (ret < 0) {
 437                 dev_err(dev, "clk_prepare_enable(dac) failed\n");
 438                 goto fail_fout_vpll;
 439         }
 440
 441         /* configure power management */
 442         pm_runtime_enable(dev);
 443
 444         /* configuration of interface subdevice */
 445         v4l2_subdev_init(&sdev->sd, &sdo_sd_ops);
 446         sdev->sd.owner = THIS_MODULE;
 447         strlcpy(sdev->sd.name, "s5p-sdo", sizeof(sdev->sd.name));
 448
 449         /* set default format */
 450         sdev->fmt = sdo_find_format(SDO_DEFAULT_STD);
 451         BUG_ON(sdev->fmt == NULL);
 452
 453         /* keeping subdev in device's private for use by other drivers */
 454         dev_set_drvdata(dev, &sdev->sd);
 455
 456         dev_info(dev, "probe succeeded\n");
 457         return 0;
 458
 459 fail_fout_vpll:
 460         clk_put(sdev->fout_vpll);
 461 fail_dacphy:
 462         clk_put(sdev->dacphy);
 463 fail_dac:
 464         clk_put(sdev->dac);
 465 fail_sclk_dac:
 466         clk_put(sdev->sclk_dac);
 467 fail:
 468         dev_info(dev, "probe failed\n");
 469         return ret;
 470 }
 471
 472 static int sdo_remove(struct platform_device *pdev)
 473 {
 474         struct v4l2_subdev *sd = dev_get_drvdata(&pdev->dev);
 475         struct sdo_device *sdev = sd_to_sdev(sd);
 476
 477         pm_runtime_disable(&pdev->dev);
 478         clk_disable_unprepare(sdev->dac);
 479         clk_put(sdev->fout_vpll);
 480         clk_put(sdev->dacphy);
 481         clk_put(sdev->dac);
 482         clk_put(sdev->sclk_dac);
 483
 484         dev_info(&pdev->dev, "remove successful\n");
 485         return 0;
 486 }
 487
 488 static struct platform_driver sdo_driver __refdata = {
 489         .probe = sdo_probe,
 490         .remove = sdo_remove,
 491         .driver = {
 492                 .name = "s5p-sdo",
 493                 .pm = &sdo_pm_ops,
 494         }
 495 };
 496
 497 module_platform_driver(sdo_driver);