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