drivers/media/video/fsl-viu.c

   1 /*
   2  * Copyright 2008-2010 Freescale Semiconductor, Inc. All Rights Reserved.
   3  *
   4  *  Freescale VIU video driver
   5  *
   6  *  Authors: Hongjun Chen <hong-jun.chen@freescale.com>
   7  *           Porting to 2.6.35 by DENX Software Engineering,
   8  *           Anatolij Gustschin <agust@denx.de>
   9  *
  10  * This program is free software; you can redistribute  it and/or modify it
  11  * under  the terms of  the GNU General  Public License as published by the
  12  * Free Software Foundation;  either version 2 of the  License, or (at your
  13  * option) any later version.
  14  *
  15  */
  16
  17 #include <linux/module.h>
  18 #include <linux/clk.h>
  19 #include <linux/kernel.h>
  20 #include <linux/i2c.h>
  21 #include <linux/init.h>
  22 #include <linux/interrupt.h>
  23 #include <linux/io.h>
  24 #include <linux/of_platform.h>
  25 #include <linux/version.h>
  26 #include <media/v4l2-common.h>
  27 #include <media/v4l2-device.h>
  28 #include <media/v4l2-ioctl.h>
  29 #include <media/videobuf-dma-contig.h>
  30
  31 #define DRV_NAME                "fsl_viu"
  32 #define VIU_MAJOR_VERSION       0
  33 #define VIU_MINOR_VERSION       5
  34 #define VIU_RELEASE             0
  35 #define VIU_VERSION             KERNEL_VERSION(VIU_MAJOR_VERSION, \
  36                                                VIU_MINOR_VERSION, \
  37                                                VIU_RELEASE)
  38
  39 #define BUFFER_TIMEOUT          msecs_to_jiffies(500)  /* 0.5 seconds */
  40
  41 #define VIU_VID_MEM_LIMIT       4       /* Video memory limit, in Mb */
  42
  43 /* I2C address of video decoder chip is 0x4A */
  44 #define VIU_VIDEO_DECODER_ADDR  0x25
  45
  46 /* supported controls */
  47 static struct v4l2_queryctrl viu_qctrl[] = {
  48         {
  49                 .id            = V4L2_CID_BRIGHTNESS,
  50                 .type          = V4L2_CTRL_TYPE_INTEGER,
  51                 .name          = "Brightness",
  52                 .minimum       = 0,
  53                 .maximum       = 255,
  54                 .step          = 1,
  55                 .default_value = 127,
  56                 .flags         = 0,
  57         }, {
  58                 .id            = V4L2_CID_CONTRAST,
  59                 .type          = V4L2_CTRL_TYPE_INTEGER,
  60                 .name          = "Contrast",
  61                 .minimum       = 0,
  62                 .maximum       = 255,
  63                 .step          = 0x1,
  64                 .default_value = 0x10,
  65                 .flags         = 0,
  66         }, {
  67                 .id            = V4L2_CID_SATURATION,
  68                 .type          = V4L2_CTRL_TYPE_INTEGER,
  69                 .name          = "Saturation",
  70                 .minimum       = 0,
  71                 .maximum       = 255,
  72                 .step          = 0x1,
  73                 .default_value = 127,
  74                 .flags         = 0,
  75         }, {
  76                 .id            = V4L2_CID_HUE,
  77                 .type          = V4L2_CTRL_TYPE_INTEGER,
  78                 .name          = "Hue",
  79                 .minimum       = -128,
  80                 .maximum       = 127,
  81                 .step          = 0x1,
  82                 .default_value = 0,
  83                 .flags         = 0,
  84         }
  85 };
  86
  87 static int qctl_regs[ARRAY_SIZE(viu_qctrl)];
  88
  89 static int info_level;
  90
  91 #define dprintk(level, fmt, arg...)                                     \
  92         do {                                                            \
  93                 if (level <= info_level)                                \
  94                         printk(KERN_DEBUG "viu: " fmt , ## arg);        \
  95         } while (0)
  96
  97 /*
  98  * Basic structures
  99  */
 100 struct viu_fmt {
 101         char  name[32];
 102         u32   fourcc;           /* v4l2 format id */
 103         u32   pixelformat;
 104         int   depth;
 105 };
 106
 107 static struct viu_fmt formats[] = {
 108         {
 109                 .name           = "RGB-16 (5/B-6/G-5/R)",
 110                 .fourcc         = V4L2_PIX_FMT_RGB565,
 111                 .pixelformat    = V4L2_PIX_FMT_RGB565,
 112                 .depth          = 16,
 113         }, {
 114                 .name           = "RGB-32 (A-R-G-B)",
 115                 .fourcc         = V4L2_PIX_FMT_RGB32,
 116                 .pixelformat    = V4L2_PIX_FMT_RGB32,
 117                 .depth          = 32,
 118         }
 119 };
 120
 121 struct viu_dev;
 122 struct viu_buf;
 123
 124 /* buffer for one video frame */
 125 struct viu_buf {
 126         /* common v4l buffer stuff -- must be first */
 127         struct videobuf_buffer vb;
 128         struct viu_fmt *fmt;
 129 };
 130
 131 struct viu_dmaqueue {
 132         struct viu_dev          *dev;
 133         struct list_head        active;
 134         struct list_head        queued;
 135         struct timer_list       timeout;
 136 };
 137
 138 struct viu_status {
 139         u32 field_irq;
 140         u32 vsync_irq;
 141         u32 hsync_irq;
 142         u32 vstart_irq;
 143         u32 dma_end_irq;
 144         u32 error_irq;
 145 };
 146
 147 struct viu_reg {
 148         u32 status_cfg;
 149         u32 luminance;
 150         u32 chroma_r;
 151         u32 chroma_g;
 152         u32 chroma_b;
 153         u32 field_base_addr;
 154         u32 dma_inc;
 155         u32 picture_count;
 156         u32 req_alarm;
 157         u32 alpha;
 158 } __attribute__ ((packed));
 159
 160 struct viu_dev {
 161         struct v4l2_device      v4l2_dev;
 162         struct mutex            lock;
 163         spinlock_t              slock;
 164         int                     users;
 165
 166         struct device           *dev;
 167         /* various device info */
 168         struct video_device     *vdev;
 169         struct viu_dmaqueue     vidq;
 170         enum v4l2_field         capfield;
 171         int                     field;
 172         int                     first;
 173         int                     dma_done;
 174
 175         /* Hardware register area */
 176         struct viu_reg          *vr;
 177
 178         /* Interrupt vector */
 179         int                     irq;
 180         struct viu_status       irqs;
 181
 182         /* video overlay */
 183         struct v4l2_framebuffer ovbuf;
 184         struct viu_fmt          *ovfmt;
 185         unsigned int            ovenable;
 186         enum v4l2_field         ovfield;
 187
 188         /* crop */
 189         struct v4l2_rect        crop_current;
 190
 191         /* clock pointer */
 192         struct clk              *clk;
 193
 194         /* decoder */
 195         struct v4l2_subdev      *decoder;
 196 };
 197
 198 struct viu_fh {
 199         struct viu_dev          *dev;
 200
 201         /* video capture */
 202         struct videobuf_queue   vb_vidq;
 203         spinlock_t              vbq_lock; /* spinlock for the videobuf queue */
 204
 205         /* video overlay */
 206         struct v4l2_window      win;
 207         struct v4l2_clip        clips[1];
 208
 209         /* video capture */
 210         struct viu_fmt          *fmt;
 211         int                     width, height, sizeimage;
 212         enum v4l2_buf_type      type;
 213 };
 214
 215 static struct viu_reg reg_val;
 216
 217 /*
 218  * Macro definitions of VIU registers
 219  */
 220
 221 /* STATUS_CONFIG register */
 222 enum status_config {
 223         SOFT_RST                = 1 << 0,
 224
 225         ERR_MASK                = 0x0f << 4,    /* Error code mask */
 226         ERR_NO                  = 0x00,         /* No error */
 227         ERR_DMA_V               = 0x01 << 4,    /* DMA in vertical active */
 228         ERR_DMA_VB              = 0x02 << 4,    /* DMA in vertical blanking */
 229         ERR_LINE_TOO_LONG       = 0x04 << 4,    /* Line too long */
 230         ERR_TOO_MANG_LINES      = 0x05 << 4,    /* Too many lines in field */
 231         ERR_LINE_TOO_SHORT      = 0x06 << 4,    /* Line too short */
 232         ERR_NOT_ENOUGH_LINE     = 0x07 << 4,    /* Not enough lines in field */
 233         ERR_FIFO_OVERFLOW       = 0x08 << 4,    /* FIFO overflow */
 234         ERR_FIFO_UNDERFLOW      = 0x09 << 4,    /* FIFO underflow */
 235         ERR_1bit_ECC            = 0x0a << 4,    /* One bit ECC error */
 236         ERR_MORE_ECC            = 0x0b << 4,    /* Two/more bits ECC error */
 237
 238         INT_FIELD_EN            = 0x01 << 8,    /* Enable field interrupt */
 239         INT_VSYNC_EN            = 0x01 << 9,    /* Enable vsync interrupt */
 240         INT_HSYNC_EN            = 0x01 << 10,   /* Enable hsync interrupt */
 241         INT_VSTART_EN           = 0x01 << 11,   /* Enable vstart interrupt */
 242         INT_DMA_END_EN          = 0x01 << 12,   /* Enable DMA end interrupt */
 243         INT_ERROR_EN            = 0x01 << 13,   /* Enable error interrupt */
 244         INT_ECC_EN              = 0x01 << 14,   /* Enable ECC interrupt */
 245
 246         INT_FIELD_STATUS        = 0x01 << 16,   /* field interrupt status */
 247         INT_VSYNC_STATUS        = 0x01 << 17,   /* vsync interrupt status */
 248         INT_HSYNC_STATUS        = 0x01 << 18,   /* hsync interrupt status */
 249         INT_VSTART_STATUS       = 0x01 << 19,   /* vstart interrupt status */
 250         INT_DMA_END_STATUS      = 0x01 << 20,   /* DMA end interrupt status */
 251         INT_ERROR_STATUS        = 0x01 << 21,   /* error interrupt status */
 252
 253         DMA_ACT                 = 0x01 << 27,   /* Enable DMA transfer */
 254         FIELD_NO                = 0x01 << 28,   /* Field number */
 255         DITHER_ON               = 0x01 << 29,   /* Dithering is on */
 256         ROUND_ON                = 0x01 << 30,   /* Round is on */
 257         MODE_32BIT              = 0x01 << 31,   /* Data in RGBa888,
 258                                                  * 0 in RGB565
 259                                                  */
 260 };
 261
 262 #define norm_maxw()     720
 263 #define norm_maxh()     576
 264
 265 #define INT_ALL_STATUS  (INT_FIELD_STATUS | INT_VSYNC_STATUS | \
 266                          INT_HSYNC_STATUS | INT_VSTART_STATUS | \
 267                          INT_DMA_END_STATUS | INT_ERROR_STATUS)
 268
 269 #define NUM_FORMATS     ARRAY_SIZE(formats)
 270
 271 static irqreturn_t viu_intr(int irq, void *dev_id);
 272
 273 struct viu_fmt *format_by_fourcc(int fourcc)
 274 {
 275         int i;
 276
 277         for (i = 0; i < NUM_FORMATS; i++) {
 278                 if (formats[i].pixelformat == fourcc)
 279                         return formats + i;
 280         }
 281
 282         dprintk(0, "unknown pixelformat:'%4.4s'\n", (char *)&fourcc);
 283         return NULL;
 284 }
 285
 286 void viu_start_dma(struct viu_dev *dev)
 287 {
 288         struct viu_reg *vr = dev->vr;
 289
 290         dev->field = 0;
 291
 292         /* Enable DMA operation */
 293         out_be32(&vr->status_cfg, SOFT_RST);
 294         out_be32(&vr->status_cfg, INT_FIELD_EN);
 295 }
 296
 297 void viu_stop_dma(struct viu_dev *dev)
 298 {
 299         struct viu_reg *vr = dev->vr;
 300         int cnt = 100;
 301         u32 status_cfg;
 302
 303         out_be32(&vr->status_cfg, 0);
 304
 305         /* Clear pending interrupts */
 306         status_cfg = in_be32(&vr->status_cfg);
 307         if (status_cfg & 0x3f0000)
 308                 out_be32(&vr->status_cfg, status_cfg & 0x3f0000);
 309
 310         if (status_cfg & DMA_ACT) {
 311                 do {
 312                         status_cfg = in_be32(&vr->status_cfg);
 313                         if (status_cfg & INT_DMA_END_STATUS)
 314                                 break;
 315                 } while (cnt--);
 316
 317                 if (cnt < 0) {
 318                         /* timed out, issue soft reset */
 319                         out_be32(&vr->status_cfg, SOFT_RST);
 320                         out_be32(&vr->status_cfg, 0);
 321                 } else {
 322                         /* clear DMA_END and other pending irqs */
 323                         out_be32(&vr->status_cfg, status_cfg & 0x3f0000);
 324                 }
 325         }
 326
 327         dev->field = 0;
 328 }
 329
 330 static int restart_video_queue(struct viu_dmaqueue *vidq)
 331 {
 332         struct viu_buf *buf, *prev;
 333
 334         dprintk(1, "%s vidq=0x%08lx\n", __func__, (unsigned long)vidq);
 335         if (!list_empty(&vidq->active)) {
 336                 buf = list_entry(vidq->active.next, struct viu_buf, vb.queue);
 337                 dprintk(2, "restart_queue [%p/%d]: restart dma\n",
 338                         buf, buf->vb.i);
 339
 340                 viu_stop_dma(vidq->dev);
 341
 342                 /* cancel all outstanding capture requests */
 343                 list_for_each_entry_safe(buf, prev, &vidq->active, vb.queue) {
 344                         list_del(&buf->vb.queue);
 345                         buf->vb.state = VIDEOBUF_ERROR;
 346                         wake_up(&buf->vb.done);
 347                 }
 348                 mod_timer(&vidq->timeout, jiffies+BUFFER_TIMEOUT);
 349                 return 0;
 350         }
 351
 352         prev = NULL;
 353         for (;;) {
 354                 if (list_empty(&vidq->queued))
 355                         return 0;
 356                 buf = list_entry(vidq->queued.next, struct viu_buf, vb.queue);
 357                 if (prev == NULL) {
 358                         list_del(&buf->vb.queue);
 359                         list_add_tail(&buf->vb.queue, &vidq->active);
 360
 361                         dprintk(1, "Restarting video dma\n");
 362                         viu_stop_dma(vidq->dev);
 363                         viu_start_dma(vidq->dev);
 364
 365                         buf->vb.state = VIDEOBUF_ACTIVE;
 366                         mod_timer(&vidq->timeout, jiffies+BUFFER_TIMEOUT);
 367                         dprintk(2, "[%p/%d] restart_queue - first active\n",
 368                                 buf, buf->vb.i);
 369
 370                 } else if (prev->vb.width  == buf->vb.width  &&
 371                            prev->vb.height == buf->vb.height &&
 372                            prev->fmt       == buf->fmt) {
 373                         list_del(&buf->vb.queue);
 374                         list_add_tail(&buf->vb.queue, &vidq->active);
 375                         buf->vb.state = VIDEOBUF_ACTIVE;
 376                         dprintk(2, "[%p/%d] restart_queue - move to active\n",
 377                                 buf, buf->vb.i);
 378                 } else {
 379                         return 0;
 380                 }
 381                 prev = buf;
 382         }
 383 }
 384
 385 static void viu_vid_timeout(unsigned long data)
 386 {
 387         struct viu_dev *dev = (struct viu_dev *)data;
 388         struct viu_buf *buf;
 389         struct viu_dmaqueue *vidq = &dev->vidq;
 390
 391         while (!list_empty(&vidq->active)) {
 392                 buf = list_entry(vidq->active.next, struct viu_buf, vb.queue);
 393                 list_del(&buf->vb.queue);
 394                 buf->vb.state = VIDEOBUF_ERROR;
 395                 wake_up(&buf->vb.done);
 396                 dprintk(1, "viu/0: [%p/%d] timeout\n", buf, buf->vb.i);
 397         }
 398
 399         restart_video_queue(vidq);
 400 }
 401
 402 /*
 403  * Videobuf operations
 404  */
 405 static int buffer_setup(struct videobuf_queue *vq, unsigned int *count,
 406                         unsigned int *size)
 407 {
 408         struct viu_fh *fh = vq->priv_data;
 409
 410         *size = fh->width * fh->height * fh->fmt->depth >> 3;
 411         if (*count == 0)
 412                 *count = 32;
 413
 414         while (*size * *count > VIU_VID_MEM_LIMIT * 1024 * 1024)
 415                 (*count)--;
 416
 417         dprintk(1, "%s, count=%d, size=%d\n", __func__, *count, *size);
 418         return 0;
 419 }
 420
 421 static void free_buffer(struct videobuf_queue *vq, struct viu_buf *buf)
 422 {
 423         struct videobuf_buffer *vb = &buf->vb;
 424         void *vaddr = NULL;
 425
 426         BUG_ON(in_interrupt());
 427
 428         videobuf_waiton(&buf->vb, 0, 0);
 429
 430         if (vq->int_ops && vq->int_ops->vaddr)
 431                 vaddr = vq->int_ops->vaddr(vb);
 432
 433         if (vaddr)
 434                 videobuf_dma_contig_free(vq, &buf->vb);
 435
 436         buf->vb.state = VIDEOBUF_NEEDS_INIT;
 437 }
 438
 439 inline int buffer_activate(struct viu_dev *dev, struct viu_buf *buf)
 440 {
 441         struct viu_reg *vr = dev->vr;
 442         int bpp;
 443
 444         /* setup the DMA base address */
 445         reg_val.field_base_addr = videobuf_to_dma_contig(&buf->vb);
 446
 447         dprintk(1, "buffer_activate [%p/%d]: dma addr 0x%lx\n",
 448                 buf, buf->vb.i, (unsigned long)reg_val.field_base_addr);
 449
 450         /* interlace is on by default, set horizontal DMA increment */
 451         reg_val.status_cfg = 0;
 452         bpp = buf->fmt->depth >> 3;
 453         switch (bpp) {
 454         case 2:
 455                 reg_val.status_cfg &= ~MODE_32BIT;
 456                 reg_val.dma_inc = buf->vb.width * 2;
 457                 break;
 458         case 4:
 459                 reg_val.status_cfg |= MODE_32BIT;
 460                 reg_val.dma_inc = buf->vb.width * 4;
 461                 break;
 462         default:
 463                 dprintk(0, "doesn't support color depth(%d)\n",
 464                         bpp * 8);
 465                 return -EINVAL;
 466         }
 467
 468         /* setup picture_count register */
 469         reg_val.picture_count = (buf->vb.height / 2) << 16 |
 470                                 buf->vb.width;
 471
 472         reg_val.status_cfg |= DMA_ACT | INT_DMA_END_EN | INT_FIELD_EN;
 473
 474         buf->vb.state = VIDEOBUF_ACTIVE;
 475         dev->capfield = buf->vb.field;
 476
 477         /* reset dma increment if needed */
 478         if (!V4L2_FIELD_HAS_BOTH(buf->vb.field))
 479                 reg_val.dma_inc = 0;
 480
 481         out_be32(&vr->dma_inc, reg_val.dma_inc);
 482         out_be32(&vr->picture_count, reg_val.picture_count);
 483         out_be32(&vr->field_base_addr, reg_val.field_base_addr);
 484         mod_timer(&dev->vidq.timeout, jiffies + BUFFER_TIMEOUT);
 485         return 0;
 486 }
 487
 488 static int buffer_prepare(struct videobuf_queue *vq,
 489                           struct videobuf_buffer *vb,
 490                           enum v4l2_field field)
 491 {
 492         struct viu_fh  *fh  = vq->priv_data;
 493         struct viu_buf *buf = container_of(vb, struct viu_buf, vb);
 494         int rc;
 495
 496         BUG_ON(fh->fmt == NULL);
 497
 498         if (fh->width  < 48 || fh->width  > norm_maxw() ||
 499             fh->height < 32 || fh->height > norm_maxh())
 500                 return -EINVAL;
 501         buf->vb.size = (fh->width * fh->height * fh->fmt->depth) >> 3;
 502         if (buf->vb.baddr != 0 && buf->vb.bsize < buf->vb.size)
 503                 return -EINVAL;
 504
 505         if (buf->fmt       != fh->fmt    ||
 506             buf->vb.width  != fh->width  ||
 507             buf->vb.height != fh->height ||
 508             buf->vb.field  != field) {
 509                 buf->fmt       = fh->fmt;
 510                 buf->vb.width  = fh->width;
 511                 buf->vb.height = fh->height;
 512                 buf->vb.field  = field;
 513         }
 514
 515         if (buf->vb.state == VIDEOBUF_NEEDS_INIT) {
 516                 rc = videobuf_iolock(vq, &buf->vb, NULL);
 517                 if (rc != 0)
 518                         goto fail;
 519
 520                 buf->vb.width  = fh->width;
 521                 buf->vb.height = fh->height;
 522                 buf->vb.field  = field;
 523                 buf->fmt       = fh->fmt;
 524         }
 525
 526         buf->vb.state = VIDEOBUF_PREPARED;
 527         return 0;
 528
 529 fail:
 530         free_buffer(vq, buf);
 531         return rc;
 532 }
 533
 534 static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
 535 {
 536         struct viu_buf       *buf     = container_of(vb, struct viu_buf, vb);
 537         struct viu_fh        *fh      = vq->priv_data;
 538         struct viu_dev       *dev     = fh->dev;
 539         struct viu_dmaqueue  *vidq    = &dev->vidq;
 540         struct viu_buf       *prev;
 541
 542         if (!list_empty(&vidq->queued)) {
 543                 dprintk(1, "adding vb queue=0x%08lx\n",
 544                                 (unsigned long)&buf->vb.queue);
 545                 dprintk(1, "vidq pointer 0x%p, queued 0x%p\n",
 546                                 vidq, &vidq->queued);
 547                 dprintk(1, "dev %p, queued: self %p, next %p, head %p\n",
 548                         dev, &vidq->queued, vidq->queued.next,
 549                         vidq->queued.prev);
 550                 list_add_tail(&buf->vb.queue, &vidq->queued);
 551                 buf->vb.state = VIDEOBUF_QUEUED;
 552                 dprintk(2, "[%p/%d] buffer_queue - append to queued\n",
 553                         buf, buf->vb.i);
 554         } else if (list_empty(&vidq->active)) {
 555                 dprintk(1, "adding vb active=0x%08lx\n",
 556                                 (unsigned long)&buf->vb.queue);
 557                 list_add_tail(&buf->vb.queue, &vidq->active);
 558                 buf->vb.state = VIDEOBUF_ACTIVE;
 559                 mod_timer(&vidq->timeout, jiffies+BUFFER_TIMEOUT);
 560                 dprintk(2, "[%p/%d] buffer_queue - first active\n",
 561                         buf, buf->vb.i);
 562
 563                 buffer_activate(dev, buf);
 564         } else {
 565                 dprintk(1, "adding vb queue2=0x%08lx\n",
 566                                 (unsigned long)&buf->vb.queue);
 567                 prev = list_entry(vidq->active.prev, struct viu_buf, vb.queue);
 568                 if (prev->vb.width  == buf->vb.width  &&
 569                     prev->vb.height == buf->vb.height &&
 570                     prev->fmt       == buf->fmt) {
 571                         list_add_tail(&buf->vb.queue, &vidq->active);
 572                         buf->vb.state = VIDEOBUF_ACTIVE;
 573                         dprintk(2, "[%p/%d] buffer_queue - append to active\n",
 574                                 buf, buf->vb.i);
 575                 } else {
 576                         list_add_tail(&buf->vb.queue, &vidq->queued);
 577                         buf->vb.state = VIDEOBUF_QUEUED;
 578                         dprintk(2, "[%p/%d] buffer_queue - first queued\n",
 579                                 buf, buf->vb.i);
 580                 }
 581         }
 582 }
 583
 584 static void buffer_release(struct videobuf_queue *vq,
 585                                 struct videobuf_buffer *vb)
 586 {
 587         struct viu_buf *buf  = container_of(vb, struct viu_buf, vb);
 588         struct viu_fh  *fh   = vq->priv_data;
 589         struct viu_dev *dev  = (struct viu_dev *)fh->dev;
 590
 591         viu_stop_dma(dev);
 592         free_buffer(vq, buf);
 593 }
 594
 595 static struct videobuf_queue_ops viu_video_qops = {
 596         .buf_setup      = buffer_setup,
 597         .buf_prepare    = buffer_prepare,
 598         .buf_queue      = buffer_queue,
 599         .buf_release    = buffer_release,
 600 };
 601
 602 /*
 603  * IOCTL vidioc handling
 604  */
 605 static int vidioc_querycap(struct file *file, void *priv,
 606                            struct v4l2_capability *cap)
 607 {
 608         strcpy(cap->driver, "viu");
 609         strcpy(cap->card, "viu");
 610         cap->version = VIU_VERSION;
 611         cap->capabilities =     V4L2_CAP_VIDEO_CAPTURE |
 612                                 V4L2_CAP_STREAMING     |
 613                                 V4L2_CAP_VIDEO_OVERLAY |
 614                                 V4L2_CAP_READWRITE;
 615         return 0;
 616 }
 617
 618 static int vidioc_enum_fmt(struct file *file, void  *priv,
 619                                         struct v4l2_fmtdesc *f)
 620 {
 621         int index = f->index;
 622
 623         if (f->index > NUM_FORMATS)
 624                 return -EINVAL;
 625
 626         strlcpy(f->description, formats[index].name, sizeof(f->description));
 627         f->pixelformat = formats[index].fourcc;
 628         return 0;
 629 }
 630
 631 static int vidioc_g_fmt_cap(struct file *file, void *priv,
 632                                         struct v4l2_format *f)
 633 {
 634         struct viu_fh *fh = priv;
 635
 636         f->fmt.pix.width        = fh->width;
 637         f->fmt.pix.height       = fh->height;
 638         f->fmt.pix.field        = fh->vb_vidq.field;
 639         f->fmt.pix.pixelformat  = fh->fmt->pixelformat;
 640         f->fmt.pix.bytesperline =
 641                         (f->fmt.pix.width * fh->fmt->depth) >> 3;
 642         f->fmt.pix.sizeimage    = fh->sizeimage;
 643         return 0;
 644 }
 645
 646 static int vidioc_try_fmt_cap(struct file *file, void *priv,
 647                                         struct v4l2_format *f)
 648 {
 649         struct viu_fmt *fmt;
 650         enum v4l2_field field;
 651         unsigned int maxw, maxh;
 652
 653         fmt = format_by_fourcc(f->fmt.pix.pixelformat);
 654         if (!fmt) {
 655                 dprintk(1, "Fourcc format (0x%08x) invalid.",
 656                         f->fmt.pix.pixelformat);
 657                 return -EINVAL;
 658         }
 659
 660         field = f->fmt.pix.field;
 661
 662         if (field == V4L2_FIELD_ANY) {
 663                 field = V4L2_FIELD_INTERLACED;
 664         } else if (field != V4L2_FIELD_INTERLACED) {
 665                 dprintk(1, "Field type invalid.\n");
 666                 return -EINVAL;
 667         }
 668
 669         maxw  = norm_maxw();
 670         maxh  = norm_maxh();
 671
 672         f->fmt.pix.field = field;
 673         if (f->fmt.pix.height < 32)
 674                 f->fmt.pix.height = 32;
 675         if (f->fmt.pix.height > maxh)
 676                 f->fmt.pix.height = maxh;
 677         if (f->fmt.pix.width < 48)
 678                 f->fmt.pix.width = 48;
 679         if (f->fmt.pix.width > maxw)
 680                 f->fmt.pix.width = maxw;
 681         f->fmt.pix.width &= ~0x03;
 682         f->fmt.pix.bytesperline =
 683                 (f->fmt.pix.width * fmt->depth) >> 3;
 684
 685         return 0;
 686 }
 687
 688 static int vidioc_s_fmt_cap(struct file *file, void *priv,
 689                                         struct v4l2_format *f)
 690 {
 691         struct viu_fh *fh = priv;
 692         int ret;
 693
 694         ret = vidioc_try_fmt_cap(file, fh, f);
 695         if (ret < 0)
 696                 return ret;
 697
 698         fh->fmt           = format_by_fourcc(f->fmt.pix.pixelformat);
 699         fh->width         = f->fmt.pix.width;
 700         fh->height        = f->fmt.pix.height;
 701         fh->sizeimage     = f->fmt.pix.sizeimage;
 702         fh->vb_vidq.field = f->fmt.pix.field;
 703         fh->type          = f->type;
 704         dprintk(1, "set to pixelformat '%4.6s'\n", (char *)&fh->fmt->name);
 705         return 0;
 706 }
 707
 708 static int vidioc_g_fmt_overlay(struct file *file, void *priv,
 709                                         struct v4l2_format *f)
 710 {
 711         struct viu_fh *fh = priv;
 712
 713         f->fmt.win = fh->win;
 714         return 0;
 715 }
 716
 717 static int verify_preview(struct viu_dev *dev, struct v4l2_window *win)
 718 {
 719         enum v4l2_field field;
 720         int maxw, maxh;
 721
 722         if (dev->ovbuf.base == NULL)
 723                 return -EINVAL;
 724         if (dev->ovfmt == NULL)
 725                 return -EINVAL;
 726         if (win->w.width < 48 || win->w.height < 32)
 727                 return -EINVAL;
 728
 729         field = win->field;
 730         maxw  = dev->crop_current.width;
 731         maxh  = dev->crop_current.height;
 732
 733         if (field == V4L2_FIELD_ANY) {
 734                 field = (win->w.height > maxh/2)
 735                         ? V4L2_FIELD_INTERLACED
 736                         : V4L2_FIELD_TOP;
 737         }
 738         switch (field) {
 739         case V4L2_FIELD_TOP:
 740         case V4L2_FIELD_BOTTOM:
 741                 maxh = maxh / 2;
 742                 break;
 743         case V4L2_FIELD_INTERLACED:
 744                 break;
 745         default:
 746                 return -EINVAL;
 747         }
 748
 749         win->field = field;
 750         if (win->w.width > maxw)
 751                 win->w.width = maxw;
 752         if (win->w.height > maxh)
 753                 win->w.height = maxh;
 754         return 0;
 755 }
 756
 757 inline void viu_activate_overlay(struct viu_reg *viu_reg)
 758 {
 759         struct viu_reg *vr = viu_reg;
 760
 761         out_be32(&vr->field_base_addr, reg_val.field_base_addr);
 762         out_be32(&vr->dma_inc, reg_val.dma_inc);
 763         out_be32(&vr->picture_count, reg_val.picture_count);
 764 }
 765
 766 static int viu_start_preview(struct viu_dev *dev, struct viu_fh *fh)
 767 {
 768         int bpp;
 769
 770         dprintk(1, "%s %dx%d %s\n", __func__,
 771                 fh->win.w.width, fh->win.w.height, dev->ovfmt->name);
 772
 773         reg_val.status_cfg = 0;
 774
 775         /* setup window */
 776         reg_val.picture_count = (fh->win.w.height / 2) << 16 |
 777                                 fh->win.w.width;
 778
 779         /* setup color depth and dma increment */
 780         bpp = dev->ovfmt->depth / 8;
 781         switch (bpp) {
 782         case 2:
 783                 reg_val.status_cfg &= ~MODE_32BIT;
 784                 reg_val.dma_inc = fh->win.w.width * 2;
 785                 break;
 786         case 4:
 787                 reg_val.status_cfg |= MODE_32BIT;
 788                 reg_val.dma_inc = fh->win.w.width * 4;
 789                 break;
 790         default:
 791                 dprintk(0, "device doesn't support color depth(%d)\n",
 792                         bpp * 8);
 793                 return -EINVAL;
 794         }
 795
 796         dev->ovfield = fh->win.field;
 797         if (!V4L2_FIELD_HAS_BOTH(dev->ovfield))
 798                 reg_val.dma_inc = 0;
 799
 800         reg_val.status_cfg |= DMA_ACT | INT_DMA_END_EN | INT_FIELD_EN;
 801
 802         /* setup the base address of the overlay buffer */
 803         reg_val.field_base_addr = (u32)dev->ovbuf.base;
 804
 805         dev->ovenable = 1;
 806         viu_activate_overlay(dev->vr);
 807
 808         /* start dma */
 809         viu_start_dma(dev);
 810         return 0;
 811 }
 812
 813 static int vidioc_s_fmt_overlay(struct file *file, void *priv,
 814                                         struct v4l2_format *f)
 815 {
 816         struct viu_fh  *fh  = priv;
 817         struct viu_dev *dev = (struct viu_dev *)fh->dev;
 818         unsigned long  flags;
 819         int err;
 820
 821         err = verify_preview(dev, &f->fmt.win);
 822         if (err)
 823                 return err;
 824
 825         mutex_lock(&dev->lock);
 826         fh->win = f->fmt.win;
 827
 828         spin_lock_irqsave(&dev->slock, flags);
 829         viu_start_preview(dev, fh);
 830         spin_unlock_irqrestore(&dev->slock, flags);
 831         mutex_unlock(&dev->lock);
 832         return 0;
 833 }
 834
 835 static int vidioc_try_fmt_overlay(struct file *file, void *priv,
 836                                         struct v4l2_format *f)
 837 {
 838         return 0;
 839 }
 840
 841 int vidioc_g_fbuf(struct file *file, void *priv, struct v4l2_framebuffer *arg)
 842 {
 843         struct viu_fh  *fh = priv;
 844         struct viu_dev *dev = fh->dev;
 845         struct v4l2_framebuffer *fb = arg;
 846
 847         *fb = dev->ovbuf;
 848         fb->capability = V4L2_FBUF_CAP_LIST_CLIPPING;
 849         return 0;
 850 }
 851
 852 int vidioc_s_fbuf(struct file *file, void *priv, struct v4l2_framebuffer *arg)
 853 {
 854         struct viu_fh  *fh = priv;
 855         struct viu_dev *dev = fh->dev;
 856         struct v4l2_framebuffer *fb = arg;
 857         struct viu_fmt *fmt;
 858
 859         if (!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_RAWIO))
 860                 return -EPERM;
 861
 862         /* check args */
 863         fmt = format_by_fourcc(fb->fmt.pixelformat);
 864         if (fmt == NULL)
 865                 return -EINVAL;
 866
 867         /* ok, accept it */
 868         dev->ovbuf = *fb;
 869         dev->ovfmt = fmt;
 870         if (dev->ovbuf.fmt.bytesperline == 0) {
 871                 dev->ovbuf.fmt.bytesperline =
 872                         dev->ovbuf.fmt.width * fmt->depth / 8;
 873         }
 874         return 0;
 875 }
 876
 877 static int vidioc_reqbufs(struct file *file, void *priv,
 878                                 struct v4l2_requestbuffers *p)
 879 {
 880         struct viu_fh *fh = priv;
 881
 882         return videobuf_reqbufs(&fh->vb_vidq, p);
 883 }
 884
 885 static int vidioc_querybuf(struct file *file, void *priv,
 886                                         struct v4l2_buffer *p)
 887 {
 888         struct viu_fh *fh = priv;
 889
 890         return videobuf_querybuf(&fh->vb_vidq, p);
 891 }
 892
 893 static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)
 894 {
 895         struct viu_fh *fh = priv;
 896
 897         return videobuf_qbuf(&fh->vb_vidq, p);
 898 }
 899
 900 static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
 901 {
 902         struct viu_fh *fh = priv;
 903
 904         return videobuf_dqbuf(&fh->vb_vidq, p,
 905                                 file->f_flags & O_NONBLOCK);
 906 }
 907
 908 static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
 909 {
 910         struct viu_fh *fh = priv;
 911
 912         if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 913                 return -EINVAL;
 914         if (fh->type != i)
 915                 return -EINVAL;
 916
 917         return videobuf_streamon(&fh->vb_vidq);
 918 }
 919
 920 static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
 921 {
 922         struct viu_fh  *fh = priv;
 923
 924         if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 925                 return -EINVAL;
 926         if (fh->type != i)
 927                 return -EINVAL;
 928
 929         return videobuf_streamoff(&fh->vb_vidq);
 930 }
 931
 932 #define decoder_call(viu, o, f, args...) \
 933         v4l2_subdev_call(viu->decoder, o, f, ##args)
 934
 935 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *id)
 936 {
 937         struct viu_fh *fh = priv;
 938
 939         decoder_call(fh->dev, core, s_std, *id);
 940         return 0;
 941 }
 942
 943 /* only one input in this driver */
 944 static int vidioc_enum_input(struct file *file, void *priv,
 945                                         struct v4l2_input *inp)
 946 {
 947         struct viu_fh *fh = priv;
 948
 949         if (inp->index != 0)
 950                 return -EINVAL;
 951
 952         inp->type = V4L2_INPUT_TYPE_CAMERA;
 953         inp->std = fh->dev->vdev->tvnorms;
 954         strcpy(inp->name, "Camera");
 955         return 0;
 956 }
 957
 958 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
 959 {
 960         *i = 0;
 961         return 0;
 962 }
 963
 964 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
 965 {
 966         struct viu_fh *fh = priv;
 967
 968         if (i > 1)
 969                 return -EINVAL;
 970
 971         decoder_call(fh->dev, video, s_routing, i, 0, 0);
 972         return 0;
 973 }
 974
 975 /* Controls */
 976 static int vidioc_queryctrl(struct file *file, void *priv,
 977                                 struct v4l2_queryctrl *qc)
 978 {
 979         int i;
 980
 981         for (i = 0; i < ARRAY_SIZE(viu_qctrl); i++) {
 982                 if (qc->id && qc->id == viu_qctrl[i].id) {
 983                         memcpy(qc, &(viu_qctrl[i]), sizeof(*qc));
 984                         return 0;
 985                 }
 986         }
 987         return -EINVAL;
 988 }
 989
 990 static int vidioc_g_ctrl(struct file *file, void *priv,
 991                                 struct v4l2_control *ctrl)
 992 {
 993         int i;
 994
 995         for (i = 0; i < ARRAY_SIZE(viu_qctrl); i++) {
 996                 if (ctrl->id == viu_qctrl[i].id) {
 997                         ctrl->value = qctl_regs[i];
 998                         return 0;
 999                 }
1000         }
1001         return -EINVAL;
1002 }
1003 static int vidioc_s_ctrl(struct file *file, void *priv,
1004                                 struct v4l2_control *ctrl)
1005 {
1006         int i;
1007
1008         for (i = 0; i < ARRAY_SIZE(viu_qctrl); i++) {
1009                 if (ctrl->id == viu_qctrl[i].id) {
1010                         if (ctrl->value < viu_qctrl[i].minimum
1011                                 || ctrl->value > viu_qctrl[i].maximum)
1012                                         return -ERANGE;
1013                         qctl_regs[i] = ctrl->value;
1014                         return 0;
1015                 }
1016         }
1017         return -EINVAL;
1018 }
1019
1020 inline void viu_activate_next_buf(struct viu_dev *dev,
1021                                 struct viu_dmaqueue *viuq)
1022 {
1023         struct viu_dmaqueue *vidq = viuq;
1024         struct viu_buf *buf;
1025
1026         /* launch another DMA operation for an active/queued buffer */
1027         if (!list_empty(&vidq->active)) {
1028                 buf = list_entry(vidq->active.next, struct viu_buf,
1029                                         vb.queue);
1030                 dprintk(1, "start another queued buffer: 0x%p\n", buf);
1031                 buffer_activate(dev, buf);
1032         } else if (!list_empty(&vidq->queued)) {
1033                 buf = list_entry(vidq->queued.next, struct viu_buf,
1034                                         vb.queue);
1035                 list_del(&buf->vb.queue);
1036
1037                 dprintk(1, "start another queued buffer: 0x%p\n", buf);
1038                 list_add_tail(&buf->vb.queue, &vidq->active);
1039                 buf->vb.state = VIDEOBUF_ACTIVE;
1040                 buffer_activate(dev, buf);
1041         }
1042 }
1043
1044 inline void viu_default_settings(struct viu_reg *viu_reg)
1045 {
1046         struct viu_reg *vr = viu_reg;
1047
1048         out_be32(&vr->luminance, 0x9512A254);
1049         out_be32(&vr->chroma_r, 0x03310000);
1050         out_be32(&vr->chroma_g, 0x06600F38);
1051         out_be32(&vr->chroma_b, 0x00000409);
1052         out_be32(&vr->alpha, 0x000000ff);
1053         out_be32(&vr->req_alarm, 0x00000090);
1054         dprintk(1, "status reg: 0x%08x, field base: 0x%08x\n",
1055                 in_be32(&vr->status_cfg), in_be32(&vr->field_base_addr));
1056 }
1057
1058 static void viu_overlay_intr(struct viu_dev *dev, u32 status)
1059 {
1060         struct viu_reg *vr = dev->vr;
1061
1062         if (status & INT_DMA_END_STATUS)
1063                 dev->dma_done = 1;
1064
1065         if (status & INT_FIELD_STATUS) {
1066                 if (dev->dma_done) {
1067                         u32 addr = reg_val.field_base_addr;
1068
1069                         dev->dma_done = 0;
1070                         if (status & FIELD_NO)
1071                                 addr += reg_val.dma_inc;
1072
1073                         out_be32(&vr->field_base_addr, addr);
1074                         out_be32(&vr->dma_inc, reg_val.dma_inc);
1075                         out_be32(&vr->status_cfg,
1076                                  (status & 0xffc0ffff) |
1077                                  (status & INT_ALL_STATUS) |
1078                                  reg_val.status_cfg);
1079                 } else if (status & INT_VSYNC_STATUS) {
1080                         out_be32(&vr->status_cfg,
1081                                  (status & 0xffc0ffff) |
1082                                  (status & INT_ALL_STATUS) |
1083                                  reg_val.status_cfg);
1084                 }
1085         }
1086 }
1087
1088 static void viu_capture_intr(struct viu_dev *dev, u32 status)
1089 {
1090         struct viu_dmaqueue *vidq = &dev->vidq;
1091         struct viu_reg *vr = dev->vr;
1092         struct viu_buf *buf;
1093         int field_num;
1094         int need_two;
1095         int dma_done = 0;
1096
1097         field_num = status & FIELD_NO;
1098         need_two = V4L2_FIELD_HAS_BOTH(dev->capfield);
1099
1100         if (status & INT_DMA_END_STATUS) {
1101                 dma_done = 1;
1102                 if (((field_num == 0) && (dev->field == 0)) ||
1103                     (field_num && (dev->field == 1)))
1104                         dev->field++;
1105         }
1106
1107         if (status & INT_FIELD_STATUS) {
1108                 dprintk(1, "irq: field %d, done %d\n",
1109                         !!field_num, dma_done);
1110                 if (unlikely(dev->first)) {
1111                         if (field_num == 0) {
1112                                 dev->first = 0;
1113                                 dprintk(1, "activate first buf\n");
1114                                 viu_activate_next_buf(dev, vidq);
1115                         } else
1116                                 dprintk(1, "wait field 0\n");
1117                         return;
1118                 }
1119
1120                 /* setup buffer address for next dma operation */
1121                 if (!list_empty(&vidq->active)) {
1122                         u32 addr = reg_val.field_base_addr;
1123
1124                         if (field_num && need_two) {
1125                                 addr += reg_val.dma_inc;
1126                                 dprintk(1, "field 1, 0x%lx, dev field %d\n",
1127                                         (unsigned long)addr, dev->field);
1128                         }
1129                         out_be32(&vr->field_base_addr, addr);
1130                         out_be32(&vr->dma_inc, reg_val.dma_inc);
1131                         out_be32(&vr->status_cfg,
1132                                  (status & 0xffc0ffff) |
1133                                  (status & INT_ALL_STATUS) |
1134                                  reg_val.status_cfg);
1135                         return;
1136                 }
1137         }
1138
1139         if (dma_done && field_num && (dev->field == 2)) {
1140                 dev->field = 0;
1141                 buf = list_entry(vidq->active.next,
1142                                  struct viu_buf, vb.queue);
1143                 dprintk(1, "viu/0: [%p/%d] 0x%lx/0x%lx: dma complete\n",
1144                         buf, buf->vb.i,
1145                         (unsigned long)videobuf_to_dma_contig(&buf->vb),
1146                         (unsigned long)in_be32(&vr->field_base_addr));
1147
1148                 if (waitqueue_active(&buf->vb.done)) {
1149                         list_del(&buf->vb.queue);
1150                         do_gettimeofday(&buf->vb.ts);
1151                         buf->vb.state = VIDEOBUF_DONE;
1152                         buf->vb.field_count++;
1153                         wake_up(&buf->vb.done);
1154                 }
1155                 /* activate next dma buffer */
1156                 viu_activate_next_buf(dev, vidq);
1157         }
1158 }
1159
1160 static irqreturn_t viu_intr(int irq, void *dev_id)
1161 {
1162         struct viu_dev *dev  = (struct viu_dev *)dev_id;
1163         struct viu_reg *vr = dev->vr;
1164         u32 status;
1165         u32 error;
1166
1167         status = in_be32(&vr->status_cfg);
1168
1169         if (status & INT_ERROR_STATUS) {
1170                 dev->irqs.error_irq++;
1171                 error = status & ERR_MASK;
1172                 if (error)
1173                         dprintk(1, "Err: error(%d), times:%d!\n",
1174                                 error >> 4, dev->irqs.error_irq);
1175                 /* Clear interrupt error bit and error flags */
1176                 out_be32(&vr->status_cfg,
1177                          (status & 0xffc0ffff) | INT_ERROR_STATUS);
1178         }
1179
1180         if (status & INT_DMA_END_STATUS) {
1181                 dev->irqs.dma_end_irq++;
1182                 dev->dma_done = 1;
1183                 dprintk(2, "VIU DMA end interrupt times: %d\n",
1184                                         dev->irqs.dma_end_irq);
1185         }
1186
1187         if (status & INT_HSYNC_STATUS)
1188                 dev->irqs.hsync_irq++;
1189
1190         if (status & INT_FIELD_STATUS) {
1191                 dev->irqs.field_irq++;
1192                 dprintk(2, "VIU field interrupt times: %d\n",
1193                                         dev->irqs.field_irq);
1194         }
1195
1196         if (status & INT_VSTART_STATUS)
1197                 dev->irqs.vstart_irq++;
1198
1199         if (status & INT_VSYNC_STATUS) {
1200                 dev->irqs.vsync_irq++;
1201                 dprintk(2, "VIU vsync interrupt times: %d\n",
1202                         dev->irqs.vsync_irq);
1203         }
1204
1205         /* clear all pending irqs */
1206         status = in_be32(&vr->status_cfg);
1207         out_be32(&vr->status_cfg,
1208                  (status & 0xffc0ffff) | (status & INT_ALL_STATUS));
1209
1210         if (dev->ovenable) {
1211                 viu_overlay_intr(dev, status);
1212                 return IRQ_HANDLED;
1213         }
1214
1215         /* Capture mode */
1216         viu_capture_intr(dev, status);
1217         return IRQ_HANDLED;
1218 }
1219
1220 /*
1221  * File operations for the device
1222  */
1223 static int viu_open(struct file *file)
1224 {
1225         struct video_device *vdev = video_devdata(file);
1226         struct viu_dev *dev = video_get_drvdata(vdev);
1227         struct viu_fh *fh;
1228         struct viu_reg *vr;
1229         int minor = vdev->minor;
1230         u32 status_cfg;
1231         int i;
1232
1233         dprintk(1, "viu: open (minor=%d)\n", minor);
1234
1235         dev->users++;
1236         if (dev->users > 1) {
1237                 dev->users--;
1238                 return -EBUSY;
1239         }
1240
1241         vr = dev->vr;
1242
1243         dprintk(1, "open minor=%d type=%s users=%d\n", minor,
1244                 v4l2_type_names[V4L2_BUF_TYPE_VIDEO_CAPTURE], dev->users);
1245
1246         /* allocate and initialize per filehandle data */
1247         fh = kzalloc(sizeof(*fh), GFP_KERNEL);
1248         if (!fh) {
1249                 dev->users--;
1250                 return -ENOMEM;
1251         }
1252
1253         file->private_data = fh;
1254         fh->dev = dev;
1255
1256         fh->type     = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1257         fh->fmt      = format_by_fourcc(V4L2_PIX_FMT_RGB32);
1258         fh->width    = norm_maxw();
1259         fh->height   = norm_maxh();
1260         dev->crop_current.width  = fh->width;
1261         dev->crop_current.height = fh->height;
1262
1263         /* Put all controls at a sane state */
1264         for (i = 0; i < ARRAY_SIZE(viu_qctrl); i++)
1265                 qctl_regs[i] = viu_qctrl[i].default_value;
1266
1267         dprintk(1, "Open: fh=0x%08lx, dev=0x%08lx, dev->vidq=0x%08lx\n",
1268                 (unsigned long)fh, (unsigned long)dev,
1269                 (unsigned long)&dev->vidq);
1270         dprintk(1, "Open: list_empty queued=%d\n",
1271                 list_empty(&dev->vidq.queued));
1272         dprintk(1, "Open: list_empty active=%d\n",
1273                 list_empty(&dev->vidq.active));
1274
1275         viu_default_settings(vr);
1276
1277         status_cfg = in_be32(&vr->status_cfg);
1278         out_be32(&vr->status_cfg,
1279                  status_cfg & ~(INT_VSYNC_EN | INT_HSYNC_EN |
1280                                 INT_FIELD_EN | INT_VSTART_EN |
1281                                 INT_DMA_END_EN | INT_ERROR_EN | INT_ECC_EN));
1282
1283         status_cfg = in_be32(&vr->status_cfg);
1284         out_be32(&vr->status_cfg, status_cfg | INT_ALL_STATUS);
1285
1286         spin_lock_init(&fh->vbq_lock);
1287         videobuf_queue_dma_contig_init(&fh->vb_vidq, &viu_video_qops,
1288                                        dev->dev, &fh->vbq_lock,
1289                                        fh->type, V4L2_FIELD_INTERLACED,
1290                                        sizeof(struct viu_buf), fh);
1291         return 0;
1292 }
1293
1294 static ssize_t viu_read(struct file *file, char __user *data, size_t count,
1295                         loff_t *ppos)
1296 {
1297         struct viu_fh *fh = file->private_data;
1298         struct viu_dev *dev = fh->dev;
1299         int ret = 0;
1300
1301         dprintk(2, "%s\n", __func__);
1302         if (dev->ovenable)
1303                 dev->ovenable = 0;
1304
1305         if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1306                 viu_start_dma(dev);
1307                 ret = videobuf_read_stream(&fh->vb_vidq, data, count,
1308                                 ppos, 0, file->f_flags & O_NONBLOCK);
1309                 return ret;
1310         }
1311         return 0;
1312 }
1313
1314 static unsigned int viu_poll(struct file *file, struct poll_table_struct *wait)
1315 {
1316         struct viu_fh *fh = file->private_data;
1317         struct videobuf_queue *q = &fh->vb_vidq;
1318
1319         if (V4L2_BUF_TYPE_VIDEO_CAPTURE != fh->type)
1320                 return POLLERR;
1321
1322         return videobuf_poll_stream(file, q, wait);
1323 }
1324
1325 static int viu_release(struct file *file)
1326 {
1327         struct viu_fh *fh = file->private_data;
1328         struct viu_dev *dev = fh->dev;
1329         int minor = video_devdata(file)->minor;
1330
1331         viu_stop_dma(dev);
1332         videobuf_stop(&fh->vb_vidq);
1333
1334         kfree(fh);
1335
1336         dev->users--;
1337         dprintk(1, "close (minor=%d, users=%d)\n",
1338                 minor, dev->users);
1339         return 0;
1340 }
1341
1342 void viu_reset(struct viu_reg *reg)
1343 {
1344         out_be32(&reg->status_cfg, 0);
1345         out_be32(&reg->luminance, 0x9512a254);
1346         out_be32(&reg->chroma_r, 0x03310000);
1347         out_be32(&reg->chroma_g, 0x06600f38);
1348         out_be32(&reg->chroma_b, 0x00000409);
1349         out_be32(&reg->field_base_addr, 0);
1350         out_be32(&reg->dma_inc, 0);
1351         out_be32(&reg->picture_count, 0x01e002d0);
1352         out_be32(&reg->req_alarm, 0x00000090);
1353         out_be32(&reg->alpha, 0x000000ff);
1354 }
1355
1356 static int viu_mmap(struct file *file, struct vm_area_struct *vma)
1357 {
1358         struct viu_fh *fh = file->private_data;
1359         int ret;
1360
1361         dprintk(1, "mmap called, vma=0x%08lx\n", (unsigned long)vma);
1362
1363         ret = videobuf_mmap_mapper(&fh->vb_vidq, vma);
1364
1365         dprintk(1, "vma start=0x%08lx, size=%ld, ret=%d\n",
1366                 (unsigned long)vma->vm_start,
1367                 (unsigned long)vma->vm_end-(unsigned long)vma->vm_start,
1368                 ret);
1369
1370         return ret;
1371 }
1372
1373 static struct v4l2_file_operations viu_fops = {
1374         .owner          = THIS_MODULE,
1375         .open           = viu_open,
1376         .release        = viu_release,
1377         .read           = viu_read,
1378         .poll           = viu_poll,
1379         .ioctl          = video_ioctl2, /* V4L2 ioctl handler */
1380         .mmap           = viu_mmap,
1381 };
1382
1383 static const struct v4l2_ioctl_ops viu_ioctl_ops = {
1384         .vidioc_querycap        = vidioc_querycap,
1385         .vidioc_enum_fmt_vid_cap  = vidioc_enum_fmt,
1386         .vidioc_g_fmt_vid_cap     = vidioc_g_fmt_cap,
1387         .vidioc_try_fmt_vid_cap   = vidioc_try_fmt_cap,
1388         .vidioc_s_fmt_vid_cap     = vidioc_s_fmt_cap,
1389         .vidioc_enum_fmt_vid_overlay = vidioc_enum_fmt,
1390         .vidioc_g_fmt_vid_overlay = vidioc_g_fmt_overlay,
1391         .vidioc_try_fmt_vid_overlay = vidioc_try_fmt_overlay,
1392         .vidioc_s_fmt_vid_overlay = vidioc_s_fmt_overlay,
1393         .vidioc_g_fbuf        = vidioc_g_fbuf,
1394         .vidioc_s_fbuf        = vidioc_s_fbuf,
1395         .vidioc_reqbufs       = vidioc_reqbufs,
1396         .vidioc_querybuf      = vidioc_querybuf,
1397         .vidioc_qbuf          = vidioc_qbuf,
1398         .vidioc_dqbuf         = vidioc_dqbuf,
1399         .vidioc_s_std         = vidioc_s_std,
1400         .vidioc_enum_input    = vidioc_enum_input,
1401         .vidioc_g_input       = vidioc_g_input,
1402         .vidioc_s_input       = vidioc_s_input,
1403         .vidioc_queryctrl     = vidioc_queryctrl,
1404         .vidioc_g_ctrl        = vidioc_g_ctrl,
1405         .vidioc_s_ctrl        = vidioc_s_ctrl,
1406         .vidioc_streamon      = vidioc_streamon,
1407         .vidioc_streamoff     = vidioc_streamoff,
1408 };
1409
1410 static struct video_device viu_template = {
1411         .name           = "FSL viu",
1412         .fops           = &viu_fops,
1413         .minor          = -1,
1414         .ioctl_ops      = &viu_ioctl_ops,
1415         .release        = video_device_release,
1416
1417         .tvnorms        = V4L2_STD_NTSC_M | V4L2_STD_PAL,
1418         .current_norm   = V4L2_STD_NTSC_M,
1419 };
1420
1421 static int __devinit viu_of_probe(struct platform_device *op,
1422                                   const struct of_device_id *match)
1423 {
1424         struct viu_dev *viu_dev;
1425         struct video_device *vdev;
1426         struct resource r;
1427         struct viu_reg __iomem *viu_regs;
1428         struct i2c_adapter *ad;
1429         int ret, viu_irq;
1430
1431         ret = of_address_to_resource(op->dev.of_node, 0, &r);
1432         if (ret) {
1433                 dev_err(&op->dev, "Can't parse device node resource\n");
1434                 return -ENODEV;
1435         }
1436
1437         viu_irq = irq_of_parse_and_map(op->dev.of_node, 0);
1438         if (viu_irq == NO_IRQ) {
1439                 dev_err(&op->dev, "Error while mapping the irq\n");
1440                 return -EINVAL;
1441         }
1442
1443         /* request mem region */
1444         if (!devm_request_mem_region(&op->dev, r.start,
1445                                      sizeof(struct viu_reg), DRV_NAME)) {
1446                 dev_err(&op->dev, "Error while requesting mem region\n");
1447                 ret = -EBUSY;
1448                 goto err;
1449         }
1450
1451         /* remap registers */
1452         viu_regs = devm_ioremap(&op->dev, r.start, sizeof(struct viu_reg));
1453         if (!viu_regs) {
1454                 dev_err(&op->dev, "Can't map register set\n");
1455                 ret = -ENOMEM;
1456                 goto err;
1457         }
1458
1459         /* Prepare our private structure */
1460         viu_dev = devm_kzalloc(&op->dev, sizeof(struct viu_dev), GFP_ATOMIC);
1461         if (!viu_dev) {
1462                 dev_err(&op->dev, "Can't allocate private structure\n");
1463                 ret = -ENOMEM;
1464                 goto err;
1465         }
1466
1467         viu_dev->vr = viu_regs;
1468         viu_dev->irq = viu_irq;
1469         viu_dev->dev = &op->dev;
1470
1471         /* init video dma queues */
1472         INIT_LIST_HEAD(&viu_dev->vidq.active);
1473         INIT_LIST_HEAD(&viu_dev->vidq.queued);
1474
1475         /* initialize locks */
1476         mutex_init(&viu_dev->lock);
1477
1478         snprintf(viu_dev->v4l2_dev.name,
1479                  sizeof(viu_dev->v4l2_dev.name), "%s", "VIU");
1480         ret = v4l2_device_register(viu_dev->dev, &viu_dev->v4l2_dev);
1481         if (ret < 0) {
1482                 dev_err(&op->dev, "v4l2_device_register() failed: %d\n", ret);
1483                 goto err;
1484         }
1485
1486         ad = i2c_get_adapter(0);
1487         viu_dev->decoder = v4l2_i2c_new_subdev(&viu_dev->v4l2_dev, ad,
1488                         "saa7115", "saa7113", VIU_VIDEO_DECODER_ADDR, NULL);
1489
1490         viu_dev->vidq.timeout.function = viu_vid_timeout;
1491         viu_dev->vidq.timeout.data     = (unsigned long)viu_dev;
1492         init_timer(&viu_dev->vidq.timeout);
1493         viu_dev->first = 1;
1494
1495         /* Allocate memory for video device */
1496         vdev = video_device_alloc();
1497         if (vdev == NULL) {
1498                 ret = -ENOMEM;
1499                 goto err_vdev;
1500         }
1501
1502         memcpy(vdev, &viu_template, sizeof(viu_template));
1503
1504         vdev->v4l2_dev = &viu_dev->v4l2_dev;
1505
1506         viu_dev->vdev = vdev;
1507
1508         video_set_drvdata(viu_dev->vdev, viu_dev);
1509
1510         ret = video_register_device(viu_dev->vdev, VFL_TYPE_GRABBER, -1);
1511         if (ret < 0) {
1512                 video_device_release(viu_dev->vdev);
1513                 goto err_vdev;
1514         }
1515
1516         /* enable VIU clock */
1517         viu_dev->clk = clk_get(&op->dev, "viu_clk");
1518         if (IS_ERR(viu_dev->clk)) {
1519                 dev_err(&op->dev, "failed to find the clock module!\n");
1520                 ret = -ENODEV;
1521                 goto err_clk;
1522         } else {
1523                 clk_enable(viu_dev->clk);
1524         }
1525
1526         /* reset VIU module */
1527         viu_reset(viu_dev->vr);
1528
1529         /* install interrupt handler */
1530         if (request_irq(viu_dev->irq, viu_intr, 0, "viu", (void *)viu_dev)) {
1531                 dev_err(&op->dev, "Request VIU IRQ failed.\n");
1532                 ret = -ENODEV;
1533                 goto err_irq;
1534         }
1535
1536         dev_info(&op->dev, "Freescale VIU Video Capture Board\n");
1537         return ret;
1538
1539 err_irq:
1540         clk_disable(viu_dev->clk);
1541         clk_put(viu_dev->clk);
1542 err_clk:
1543         video_unregister_device(viu_dev->vdev);
1544 err_vdev:
1545         i2c_put_adapter(ad);
1546         v4l2_device_unregister(&viu_dev->v4l2_dev);
1547 err:
1548         irq_dispose_mapping(viu_irq);
1549         return ret;
1550 }
1551
1552 static int __devexit viu_of_remove(struct platform_device *op)
1553 {
1554         struct v4l2_device *v4l2_dev = dev_get_drvdata(&op->dev);
1555         struct viu_dev *dev = container_of(v4l2_dev, struct viu_dev, v4l2_dev);
1556         struct v4l2_subdev *sdev = list_entry(v4l2_dev->subdevs.next,
1557                                               struct v4l2_subdev, list);
1558         struct i2c_client *client = v4l2_get_subdevdata(sdev);
1559
1560         free_irq(dev->irq, (void *)dev);
1561         irq_dispose_mapping(dev->irq);
1562
1563         clk_disable(dev->clk);
1564         clk_put(dev->clk);
1565
1566         video_unregister_device(dev->vdev);
1567         i2c_put_adapter(client->adapter);
1568         v4l2_device_unregister(&dev->v4l2_dev);
1569         return 0;
1570 }
1571
1572 #ifdef CONFIG_PM
1573 static int viu_suspend(struct platform_device *op, pm_message_t state)
1574 {
1575         struct v4l2_device *v4l2_dev = dev_get_drvdata(&op->dev);
1576         struct viu_dev *dev = container_of(v4l2_dev, struct viu_dev, v4l2_dev);
1577
1578         clk_disable(dev->clk);
1579         return 0;
1580 }
1581
1582 static int viu_resume(struct platform_device *op)
1583 {
1584         struct v4l2_device *v4l2_dev = dev_get_drvdata(&op->dev);
1585         struct viu_dev *dev = container_of(v4l2_dev, struct viu_dev, v4l2_dev);
1586
1587         clk_enable(dev->clk);
1588         return 0;
1589 }
1590 #endif
1591
1592 /*
1593  * Initialization and module stuff
1594  */
1595 static struct of_device_id mpc512x_viu_of_match[] = {
1596         {
1597                 .compatible = "fsl,mpc5121-viu",
1598         },
1599         {},
1600 };
1601 MODULE_DEVICE_TABLE(of, mpc512x_viu_of_match);
1602
1603 static struct of_platform_driver viu_of_platform_driver = {
1604         .probe = viu_of_probe,
1605         .remove = __devexit_p(viu_of_remove),
1606 #ifdef CONFIG_PM
1607         .suspend = viu_suspend,
1608         .resume = viu_resume,
1609 #endif
1610         .driver = {
1611                 .name = DRV_NAME,
1612                 .owner = THIS_MODULE,
1613                 .of_match_table = mpc512x_viu_of_match,
1614         },
1615 };
1616
1617 static int __init viu_init(void)
1618 {
1619         return of_register_platform_driver(&viu_of_platform_driver);
1620 }
1621
1622 static void __exit viu_exit(void)
1623 {
1624         of_unregister_platform_driver(&viu_of_platform_driver);
1625 }
1626
1627 module_init(viu_init);
1628 module_exit(viu_exit);
1629
1630 MODULE_DESCRIPTION("Freescale Video-In(VIU)");
1631 MODULE_AUTHOR("Hongjun Chen");
1632 MODULE_LICENSE("GPL");